We supplement these definitions with two new terms. The cokernel of a linear transformation is a vector space that measures the failure of that transformation to be surjective (onto). On the other hand, the coimage describes the reconstructed domain that restores injectivity.
Cokernel & Coimage
if T : X ⇾ Y
is a linear transformation between two vector spaces over a field, the cokernel of T, denoted as coker(T), is the quotient space of the target space Y modulo the image of T:
\[
\mbox{coker}(T) = Y/\mbox{im}(T) .
\]
The coimage of a linear transformation T : X ⇾ Y is the quotient space of the domain X by the kernel of T, written algebraically as X/ker(T).
Coimage of T consists of cosets formed by factoring out the kernel from the domain. It groups together vectors in X
that produce the exact same output in Y. The coimage X/ker(T) is naturally (canonically) isomorphic to the image im(T). While the image lives in the codomain Y
as the set of actual outputs, the coimage lives in the domain X
as the structure of distinct input "slices" that lead to those outputs.
Example 51:
Let us look at a geometric projection T : ℝ³ ⇾ ℝ² defined by projecting a 3D point onto the xy-plane:
\[
T\left( x, y, z \right) = (x, y) .
\]
The kernel consists of all vectors in the domain ℝ³
that map to the zero vector (0, 0)
in the codomain.
Each element (coset) in the coimage is a vertical line parallel to the z-axis, passing through the point (x₀, x₀)
on the xy-plane. The coimage is the collection of all these vertical lines.
The First Isomorphism Theorem states that the coimage is isomorphic to the image
(ℝ³/ker(T) ≌ ℝ².
Every single vector in the image (a point (x₀, x₀)
in ℝ²) corresponds to exactly one element in the coimage (the entire vertical line { (x₀, x₀, z) }).
Any vector chosen along that vertical line will map to the exact same point in the image.
■
End of Example 51
The kernel of a linear transformation is the set of vectors mapped to 0.
A linear map T : X ⇾ Y is injective (one-to-one) if and only if its kernel contains only the zero vector, ker(T) = {0}.
If the kernel is larger than just {0}, it tells you exactly which inputs are collapsing into each other.
The "size" of this failure to be one-to-one is quantified by the nullity, dim ker(T).
Instead of measuring the failure of injectivity, the coimage, X/ker(T), fixes it by bundling all the vectors that cause the failure into single packages (cosets).
When you look at the induced transformation T′ that maps the coimage into the image:
\[
T' \ : \ X/\ker (T) \,\to\,\mbox{im}(T) ,
\]
this new transformation is always perfectly injective (and surjective, making it an isomorphism).
Concept
What it represents geometrically
Its role in injectivity
Kernel
The "blind spot" that collapses to zero.
Measures the failure. If it is larger than a single point, the map is not injective.
Coimage
The set of parallel "slices" of the domain.
Eliminates the failure. It collapses the redundant dimensions so the map becomes injective.
The dimension of the cokernel (dim(coker(T)) is called the corank of the linear map. For finite-dimensional spaces, dim(coker(T)) = dim(Y) − rank(T).
In the linear equation A x = b, which also can be written as linear transformation T(x) = b, the kernel represents the degrees of freedom that can be added to x without changing the outcome. The cokernel represents the constraints, defining the specific relations between components of b that must be imposed to force the equation to have a solution.
The corank tells you exactly how many constraints a vector b must satisfy to ensure the equation T(x) = b
has a solution.
If corank(T) = 0: The transformation is surjective (onto). A solution exists for every b.
If corank(T) > 0: The system is overdetermined. The corank counts the number of independent "failure modes" or missing dimensions in the output space.
By matrix duality, the cokernel is isomorphic to the kernel of dual transformation T′ (the null space of the transpose operator, AT). This yields the crucial relationship:
This means that the corank counts the number of independent linear constraints (or equations) that the target vector b must satisfy (b • y = 0 for all y ∈ ker(TT)) to be in the image of T.
While the classic Rank-Nullity Theorem balances the domain's dimensions (dim(ker(T)) + rank(T) = dim(Domain), the cokernel allows us to balance the codomain's dimensions:
In infinite-dimensional spaces (like functional analysis and differential equations), individual dimensions can be infinite, but their difference might be finite. This defines the Fredholm index:
From the row-reduced matrix, we can extract all structural dimensions:
The kernel consists of all vectors x such that A x = 0. The kernel space is spanned on one vector: ker(T) = span{[1, 1, −1]T}.
With Mathematica, we find the kernel (Null Space) of T/matrix A:
The dimension of the kernel is called the nullity and it is 1.
The image (column space) is the span of the columns of the original matrix A. Looking back at our REF, the pivots are located in Column 1 and Column 2. Therefore, the first two columns of our original matrix form a basis for the image.
Corank (Cokernel dimension): The matrix maps into a 4-dimensional space (ℝ4). The corank represents the dimension of the left null space (the geometric constraints on the codomain):
Index: Using the standard linear algebra operator index formula (dim(kerA) - corank(A)):
\[
\mbox{ind}(\mathbf{A}) = 1 - 2 = -1 .
\]
Note: For any finite-dimensional linear map T : X ⇾ Y, the index is invariant and it always is simplified via rank-nullity to dim(X) − dim(Y) = 3 − 4 = −1.
which in our case reads as 2 + 2 = 4 = dim(ℝ4).
■
End of Example 52
The cokernel of a linear transformation T : X ⇾ Y is the quotient space Y/ image(T), which is not the same space as the complement of the image of T. The former is a subset of Y and the latter is a new space. However, these two spaces are isomorphic.
While a quotient space is conceptually a set of equivalence classes (cosets) rather than a direct subspace, it is abstractly isomorphic to actual subspaces in the following ways depending on the geometric context.
In finite dimensions, any quotient space Y/U
is isomorphic to the complementary subspace of U. Indeed, if we choose a subspace S ⊂ Y
such that Y = im(T) ⊕ S
(an internal direct sum), then every vector in Y
can be uniquely broken down into an image component and a component in S. This gives us a natural vector space isomorphism:
\[
\mbox{coker}(T) \cong S .
\]
Since S
is explicitly a subspace of the codomain Y, the cokernel is isomorphic to a subspace of the codomain.
If your vector space has an inner product (like standard Euclidean space ℝⁿ), you can choose the unique orthogonal complement of the image as your subspace.
This orthogonal complement (imT)⊥
is exactly what matrix algebra calls the left null space (the null space of the conjugate transpose matrix, ker(T✶)).
If X and Y
are infinite-dimensional, a complementary subspace S
still abstractly exists (by the Axiom of Choice), meaning it is still algebraicly isomorphic to a subspace.
However, in functional analysis (working with Banach or Hilbert spaces), the image im(T)
might not be a closed subspace. If the image is not closed, the quotient space behaves poorly topologically, and it may not be possible to decompose the space cleanly into a closed topological subspace helper.
Example 53:
Let's use the matrix A and generated linear transformation T
from our previous calculations. Recall that T = TA
maps ℝ3×1 ⇾ ℝ4×1. Its image, im(T),
is a 2-dimensional plane sitting inside 4-dimensional space of column vectors ℝ4×1, spanned by:
By definition, the abstract cokernel is the quotient space ℝ4×1/imT. Since dim(ℝ4×1) − dim(imT) = 4 − 2 = 2, the cokernel is 2-dimensional.
We will show how this abstract space is isomorphic to a concrete 2-dimensional subspace of the codomain called the left null space, ker(AT).
The left null space consists of all vectors y ∈ ℝ4×1 ≌ ℝ4 such that ATy = 0. These are vectors orthogonal to every column in the image.
The elements of the abstract cokernel are cosets (equivalence classes) written as [y] = y + im(A). Two vectors point to the same coset if their difference lands entirely in the image.
Because we are in an inner product space, every vector y ∈ ℝ4×1
can be uniquely split into a parallel part and an orthogonal part:
Changing the representative doesn't change the output.
Injective (One-to-One): If ϕ([y]) = 0, it means y⊥ = 0, so y = y∥ ∈ im(A). This is exactly the zero coset [0].
Surjective (Onto): For any vector y
sitting inside our physical subspace ker(AT), we can just feed the coset [y]
into the function, and it maps directly to y.
Instead of dealing with abstract, infinite lines of equivalence classes, the isomorphism lets us work purely with the 2D plane spanned by [−1, −1, 1, 0]T
and [−1, 2, 0, 1]T. This plane is a true, geometric subspace of the ℝ4×1 codomain.
Here is a numerical example showing how a specific vector w ∈ ℝ4×1
is split into its image component (w∥) and its cokernel/left null space component (w⊥), along with the Mathematica code to compute it automatically.
Let's pick an arbitrary vector w
in the codomain ℝ4×1:
Every vector can be decomposed uniquely as w = w∥ + w⊥.
The parallel component w∥
is the orthogonal projection of the vector w
onto the column space (image) of A. Geometrically, it is the closest possible vector inside that 2D plane to our original 4D vector w.
The image space is spanned by the columns of A. Because the third column is just a combination of the first two (col₃ = col₁ + col₂), we strip it out to avoid redundancy. We form a trimmed matrix Acol containing only the basis vectors:
Any vector inside the image must look like a linear combination of these two columns: w∥ - Acolx, where x = [c₁, c₂]T
contains the weighting coefficients.
The perpendicular leftover vector is w⊥ = w − Acolx. For this error to be as small as possible, it must hit the plane at a perfect 90-degree angle. This means it must be completely orthogonal to the columns of Acol:
The remaining vector is the component left completely uncovered by the transformation. This is the unique representative that our isomorphism maps to from the abstract coset [w]:
If we check the dot product of w⊥
against the columns of A, it equals zero. This proves w⊥
successfully lands inside the left null space (the subspace isomorphic to the cokernel).
You can copy and paste the following script into Wolfram Mathematica to run the exact calculation above, find the structural bases, and perform the vector splitting automatically:
(* 1. Define the transformation matrix A and target vector w *)
A = {{1, 2, 3},
{1, 0, 1},
{2, 2, 4},
{-1, 2, 1}};
w = {3, 1, 5, 2};
(* 2. Find explicit bases for the structural spaces *)
imageBasis = Orthogonalize[RowReduce[A.Transpose[A]] // Transpose];
leftNullBasis = NullSpace[Transpose[A]];
Print["Basis for the Left Null Space (Cokernel Subspace):"];
Print[MatrixForm[leftNullBasis]];
(* 3. Compute the Orthogonal Projection Matrix onto the Image of A *)
(* Formula: P = A_col . Inverse[A_col^T . A_col] . A_col^T *)
(* We take the first two columns since column 3 is a linear combination *)
Acol = A[[All, 1 ;; 2]];
Pparallel = Acol . Inverse[Transpose[Acol] . Acol] . Transpose[Acol];
(* 4. Split the vector w into parallel and perpendicular components *)
wParallel = Pparallel . w;
wPerp = w - wParallel;
(* 5. Display the numerical results neatly *)
Print["\n--- Decomposition Results ---"];
Print["w_parallel (Image component): ", wParallel // N];
Print["w_perp (Cokernel component): ", wPerp // N];
(* 6. Exact fraction verification *)
Print["\nExact fraction for w_perp: ", wPerp];
Print["Is w_perp truly orthogonal to columns of A? ", Transpose[A] . wPerp == {0, 0, 0}];
■
End of Example 53
There exists a chain of linear mappings, which "partition g",
It is unique, because ker(σ) = ker(T), and it is an isomorphism, because the inverse
mapping also exists and is defined uniquely.
Example 54:
To demonstrate this exact sequence of mappings, let us construct a non-trivial example using spaces of low dimension so that every step is clear and computable.
Let the domain be X = ℝ3×1, the codomain be Y = ℝ3×1, and T : ℝ3×1 ⇾ ℝ3×1
be a linear transformation given by the standard matrix:
so T = TA is defined by matrix multiplication from left. To handle this computationally, we will concretize the abstract quotient spaces (coim and coker) by choosing coordinate systems based on their dimensions. Since rank(A) = 2, the domain X = ℝ3×1
and codomain Y = ℝ3×1
break down into core components of dimensions 1 and 2.
Domain (X) and Codomain (Y): Both are ℝ3×1.
Kernel (ker(T): Solving A x = 0 yields a 1D line spanned by:
Coimage (doim(T) = X/ker(T)): Since ker(T)
is 1-dimensional, the coimage is 2-dimensional (ℝ²). We represent a coset by eliminating the kernel's direction.
Cokernel (coker(T) = Y/im(T)): Since im(T)
is 2-dimensional, the cokernel is 1-dimensional (ℝ). It is spanned by the left null space of A, which happens to be mT = [1, −2, 1].
We can represent every canonical map in the chain sequence as an explicit matrix:
Step 1:\( \displaystyle \quad \mbox{ker}(T) \, \stackrel{i}{\rightarrow} \, X \ \) (inclusion). Maps the 1D kernel into ℝ3×1.
Step 2:\( \displaystyle \quad X \, \stackrel{\sigma}{\rightarrow} \, \mbox{coim}(T) \ \) Canonical Projection). Maps ℝ3×1 ⇾ ℝ2×1
by collapsing the kernel direction k. A valid algebraic projection matrix is:
(Notice that dot product Σ • k = ]0, 0], perfectly squashing the kernel).
Step 3:\( \displaystyle \quad \mbox{coim}(T) \, \stackrel{h}{\rightarrow} \, \mbox{im}(T) \ \) (The Unique Isomorphism).
Maps the 2D coimage coordinates into the 3D landing plane. By solving A = H · Σ, we extract:
(The columns of H
are exactly the basis vectors of im(T)).
Step 4:\( \displaystyle \quad \mbox{im}(T) \, \stackrel{j}{\rightarrow} \, Y \ \) (Inclusion).
Since H
already outputs full 3D vectors in Y, the inclusion map j
is implicitly handled by H mapping into ℝ3×1.
Step 5:\( \displaystyle \quad Y \, \stackrel{f}{\rightarrow} \, \mbox{coker}(T) \ \) (Canonical Projection).
Maps ℝ³ ⇾ ℝ¹
by squashing everything inside im(T)
to zero. This is computed by the left null vector:
You can evaluate, verify, and experiment with this exact pipeline using Wolfram Mathematica:
(* 1. Define the core singular matrix *)
A = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
(* 2. Compute foundational spaces *)
kerBasis = NullSpace[A]; (* Spans Kernel *)
imBasis = Transpose[RowReduce[A]][[1 ;; 2]]; (* Spans Image *)
leftNullBasis = NullSpace[Transpose[A]]; (* Spans Cokernel scaling *)
(* 3. Define the explicit structural matrices from our chain *)
Iin = Transpose[kerBasis]; (* Inclusion i: Ker -> X *)
Sigma = {{1, 0, -1}, {0, 1, 2}}; (* Canonical Projection \[Sigma]: X -> Coim *)
H = {{1, 2}, {4, 5}, {7, 8}}; (* Isomorphism h: Coim -> Im *)
F = leftNullBasis; (* Canonical Projection f: Y -> Coker *)
(* 4. Heavy Calculation Verifications *)
Print["--- COMMUTATIVE DIAGRAM CHECK ---"];
Print["Does A equal H . Sigma? ", A == H . Sigma];
Print["\n--- EXACTNESS CHECKS ---"];
Print["1. Image of i is annihilated by \[Sigma] (Sigma . I == 0): ",
Sigma . Iin == ZeroMatrix[2, 1]];
Print["2. Image of T is annihilated by f (F . A == 0): ",
F . A == ZeroMatrix[1, 3]];
(* 5. Numerical Test Tracking *)
v = {1, 1, 1};
Print["\n--- TEST VECTOR TRACE v = {1,1,1} ---"];
Print["Direct T(v) = ", A . v];
Print["Coimage coordinates \[Sigma](v) = ", Sigma . v];
Print["Factored path h(\[Sigma](v)) = ", H . (Sigma . v)];
Print["Cokernel output f(T(v)) = ", F . (A . v)];
■
End of Example 54
Lemma 1:
Let f : X ⇾ U and g : X ⇾ V be two linear mappings of finite dimensional vectors space over the same field 𝔽 of scalars. For existence of linear transformation h : U ⇾ V that make the following diagram commutative,
\[
\begin{array}{cccc}
&X& \\
f \swarrow &&\searrow g \\
U& & V
\end{array} \qquad \Longrightarrow \qquad \begin{array}{cccc}
&X& \\
f \swarrow &&\searrow g \\
U& \stackrel{h}{\rightarrow} & V
\end{array}
\]
it is necessarily and sufficient that ker(f) ⊂ ker(g).
If this condition holds and imf = U, then h is unique.
Suppose a linear transformation h : U ⇾ V
exists such that g = h ∘ f. If x ∈ ker(f), then f(x) = 0, which implies:
\[
g(\mathbf{x}) = \left( h \circ f \right) (\mathbf{x}) = h(f(\mathbf{x})) = h(0) = 0 .
\]
Thus, x ∈ ker(g), which proves that ker(f) ⊆ ker(g).
Conversely, assume that ker(f) ⊆ ker(g). We first define h on the subspace im(f) ⊆ U. To satisfy the commutativity requirement, we must set:
We must verify that h is well-defined (unique) and linear on im(f).
Well-defined: If y = f(x₁) = f(x₂), then f(x₁ − x₂) = 0, meaning x₁ − x₂ ∈ ker(f). Since ker(f) ⊆ ker(g), it follows that x₁ − x₂ ∈ ker(g), which implies g(x₁) = g(x₂). Thus, the value of h(y) does not depend on the choice of the representative x.
Linearity: This follows directly from the linearity of both f and g. For instance, if y₁ = f(x₁) and y₂ = f(x₂), then:
To complete the proof, it suffices to extend h
from the subspace im(f) to the entire space U. We can do this by choosing a basis for im(f), extending it to a basis of U, and defining h
to be zero on the newly added basis vectors.
Example 55:
For a mapping h : U ⇾ V
to exist such that g = h ⚬ f, the map f
must "wipe out" at least as much information as g does. If f
sends a vector to zero, g
must also send that same vector to zero. Otherwise, h
would have to map zero to a non-zero vector, which violates linearity.
Let's look at an explicit example where the condition holds, demonstrate how to build h, and look at the uniqueness criteria.
Let our domain be X = ℝ3×1 ≌ ℝ³, and let the target spaces be U = ℝ2×1 ≌ ℝ² and V = ℝ2×1 ≌ ℝ².
We define two linear mappings f and g
via their standard matrices:
Map f : ℝ3×1 ⇾ ℝ2×1:
\[
f = \begin{bmatrix} 1&0&0 \\ 0&1&0 \end{bmatrix} .
\]
The condition is satisfied. According to the lemma, a linear transformation h : ℝ2×1 ⇾ ℝ2×1
must exist. In order to determine h, we need to solve the matrix equation h · f = g:
\[
f(\mathbf{v}) = \begin{pmatrix} x \\ y \end{pmatrix} \qquad \Longrightarrow \qquad h \left( f(\mathbf{v})\right) = \begin{pmatrix} 2x + 3y \\ 4x + 5y \end{pmatrix} .
\]
Both paths yield the exact same result. The diagram commutes.
Uniqueness check:
The lemma states: If im(f) = U, then h
is unique.
In our setup,\( \displaystyle \quad f = \begin{bmatrix} 1&0&0 \\ 0&1&0 \end{bmatrix} . \quad \)
The columns span all of ℝ2×1 ≌ ℝ², meaning
f is surjective (onto), so im(f) = U = ℝ2×1.
. Because f
completely covers the target space U, the behavior of h
is entirely locked down for every single element in U. There is exactly one matrix h
that works.
What if h
wasn't unique? (Counter-example for uniqueness)
Imagine if we enlarged U to ℝ3×1 ≌ ℝ³ by adding a dead row to f, making\( \displaystyle \quad f = \begin{bmatrix} 1&0&0 \\ 0&1&0 \\ 0&0&0 \end{bmatrix} . \quad \)
We have spaces: X = ℝ3×1 ≌ ℝ³, U = ℝ³, and V = ℝ2×1 ≌ ℝ². The linear map f : ℝ3×1 ⇾ ℝ3×1 acts as a projection, while g : ℝ3×1 ⇾ ℝ2×1 acts as a standard linear transformation.
For a mapping h : U ⇾ V to exist, the lemma states we must have ker(f) ⊆ ker(g). Let's check the kernels of both mappings:
Kernel of f:
Looking at your matrix f, any vector where the first two components are zero maps to zero:
This shows that [0, 0, 1]T
also lives inside ker(g).
Since ker(f) ⊂ ker(g)
holds perfectly, the linear transformation h
is guaranteed to exist.
The second clause of the lemma states that h
is unique if and only if im(f) = U.
In our example, the image of f
is only a 2D plane spanned by the first two standard basis vectors:
Because im(f)
fails to cover the entire codomain U, there is an entire dimension left unconstrained (Column 3). We can define the behavior of h
arbitrarily on this missing dimension without affecting the commutative diagram equation h ∘ f = g.
Let h : ℝ³ ⇾ ℝ²
be represented by a general 2 × 3 matrix:
Both H₁F = G and H₂F = G
evaluate to the exact same matrix, formally demonstrating the violation of uniqueness.
■
End of Example 55
Matrix Interpretations
In this section, the field of scalars 𝔽 is either the set of real numbers ℝ or complex numbers ℂ.
Every linear transformation T mapping 𝔽n×1 ⇾ 𝔽m×1 is represented by an m-by-n matrix A acting on column vectors from left: T(x) = A x. Then:
The image Im(T) is the column space of A.
The coimage of a matrix A
is directly identified with its row space (the subspace spanned by the row vectors of A).
The kernel (also known in Linear Algebra as the Null Space) is the set of all input vectors that get mapped to the zero vector when multiplied by that matrix. The number of vectors in a basis for the kernel is called the nullity of the matrix.
The cokernel is isomorphic to the left null space of A
(the kernel of the transpose matrix AT):
We want to show why ker(AT)
fails to act as the orthogonal complement to the image, whereas ker(A✶) succeeds.
By looking at the columns, the second column is zero, and the third column is identical to the first. Therefore, the column space (image) is a 1-dimensional subspace in ℂ² spanned by the first column:
Because im(A) = ker(AT), the standard transpose kernel contains the exact same vectors as the image. It completely fails to provide a complementary, orthogonal subspace to im(A)
inside ℂ².
Now we show what happens when we use the conjugate transpose, which changes the sign of ⅉ:
They are perfectly perpendicular! The space decomposes cleanly as ℂ² = im(A) ⊕ ker(A✶), proving that ker(A✶) is the correct geometric representation of the cokernel.
Metric / Property
Standard Transpose \((\mathbf{A}^{\mathrm{T}})\)
Conjugate Transpose \((\mathbf{A}^{\mathrm{H}})\)
Matrix Operation
\(\mathbf{A}^{\mathrm{T}} = \begin{bmatrix} 1 & i \\ 0 & 0 \\ 1 & i \end{bmatrix}\)
The following Mathematica script defines the matrices F and G, builds a general matrix H
with symbolic entries, and solves the system HF = G to show exactly how the free parameters (variables) arise due to the violation of uniqueness.
(* 1. Define the matrices from your unique map violation example *)
F = {{1, 0, 0}, {0, 1, 0}, {0, 0, 0}};
G = {{2, 3, 0}, {4, 5, 0}};
Print["--- Commutative Diagram Setup ---"];
Print["Matrix F (f: X -> U) = ", MatrixForm[F]];
Print["Matrix G (g: X -> V) = ", MatrixForm[G]];
(* 2. Construct a general 2x3 matrix H with symbolic entries *)
H = Array[c, {2, 3}];
Print["\nGeneral Symbolic Matrix H = ", MatrixForm[H]];
(* 3. Compute the composition H . F *)
composition = H . F;
Print["Calculated H . F = ", MatrixForm[composition]];
(* 4. Solve the matrix equation H . F == G *)
(* Thread is used to equate the matrices element-by-element *)
system = Thread[Flatten[composition] == Flatten[G]];
solutions = Solve[system, Flatten[H]];
Print["\n--- Uniqueness Solutions Output ---"];
Print["Matrix H Solutions: ", solutions];
(* 5. Display the parameterized matrix H to show the free variables *)
parameterizedH = H /. solutions[[1]];
Print["Final Parameterized Matrix H = ", MatrixForm[parameterizedH]];
■
End of Example 56
The Inner Product Spaces (The Conjugate Transpose)
If you are using the standard complex inner product (dot product) to find the orthogonal complement, you replace the transpose AT
with the conjugate transpose A✶
(also written as AH or A†).
The cokernel is isomorphic to the left null space using the conjugate transpose:
This works perfectly because, just like in the real case, the fundamental theorem of linear algebra over
states that the orthogonal complement of the column space is the null space of the conjugate transpose:
The notation A✶ represents the conjugate transpose (or Hermitian adjoint) of the matrix A. By definition, the adjoint is the unique operator that satisfies the inner product identity for all vectors x and y:
Because every step is an "if and only if" (⇔) logical deduction, the two sets contain the exact same vectors: im(A)⊥ = ker(A✶).
Example 57:
The statement A✶y = 0 ⇔ y ∈ ker(A✶)
is technically a definitional identity rather than a structural isomorphism. By definition, the kernel (or null space) of any linear operator is exactly the set of all vectors that the operator maps to the zero vector.
Let's construct a non-square, complex matrix A ∈ ℂ3×4
where the columns are linearly dependent. This ensures that the adjoint matrix A✶
has a nontrivial kernel. We will then use Mathematica to find a complex vector y
that satisfies A✶y = 0
and show how it serves as an orthogonal filter for any target vector b.
(* 1. Define a truly dependent complex matrix A (3 x 4) *)
(* Row 3 is explicitly constructed as: (1+I)*Row 1 + (2-I)*Row 2 *)
row1 = {1 + I, 2, -I, 3};
row2 = {2 - I, I, 4, 1};
row3 = (1 + I)*row1 + (2 - I)*row2; (* Evaluates to {3-2*I, 3+4*I, 9-5*I, 5+2*I} *)
A = {row1, row2, row3};
Print["--- Adjoint Kernel & Orthogonality Verification ---"];
(* 2. Compute the Adjoint (Conjugate Transpose A*) *)
AStar = ConjugateTranspose[A];
(* 3. Find the basis for ker(A*) *)
kerAStarBasis = NullSpace[AStar];
Print["Basis vectors for ker(A*): ", kerAStarBasis];
(* Extract the first vector from the non-empty kernel *)
y = kerAStarBasis[[1]];
(* Verify definition: A* . y == {0, 0, 0, 0} *)
Print["Verification that A* . y == 0: ", AStar . y];
Print["-------------------------------------------------"];
(* 4. Test Case 1: A vector b1 that IS in the image of A *)
xTrue = {1, -I, 2, 1 + I};
bSolvable = A . xTrue;
Print["Solvable target b1 = ", bSolvable];
(* Correct mathematical complex inner product: Conjugate(y) . b *)
innerProduct1 = Conjugate[y] . bSolvable;
Print["Inner product : ", Simplify[innerProduct1]];
Print["Does a solution exist? ", Quiet[Check[LinearSolve[A, bSolvable]; True, False]]];
Print["-------------------------------------------------"];
(* 5. Test Case 2: A vector b2 that IS NOT in the image of A *)
(* We break the system by adding the conjugate of y to b *)
bUnsolvable = bSolvable + y;
Print["Unsolvable target b2 = ", bUnsolvable];
innerProduct2 = Conjugate[y] . bUnsolvable;
Print["Inner product : ", Simplify[innerProduct2]];
Print["Does a solution exist? ", Quiet[Check[LinearSolve[A, bUnsolvable]; True, False]]];
The basis of the orthogonal complement of the image of A is exactly the basis of the kernel of the adjoint matrix, ker(A✶).
This is the exact structural identity guaranteed by the geometric formulation of the Fredholm Alternative:
Using the exact, linearly dependent matrix
from the previous prompt, here is the short code snippet to explicitly calculate and extract the basis vectors fo5 (im(A))⊥:
(* 1. Define the linearly dependent matrix A *)
row1 = {1 + I, 2, -I, 3};
row2 = {2 - I, I, 4, 1};
row3 = (1 + I)*row1 + (2 - I)*row2;
A = {row1, row2, row3};
(* 2. Find the basis of the orthogonal complement of im(A) *)
(* Since (im(A))^perp == ker(A*), we compute the NullSpace of the adjoint *)
basisOrthogonalComplement = NullSpace[ConjugateTranspose[A]];
Print["Basis for (im(A))^perp is: ", basisOrthogonalComplement];
■
End of Example 57
By explicitly utilizing A✶
instead of the plain transpose, the conjugate math cancels out perfectly over ℂ, ensuring the geometric relationship remains intact.
The Algebraic Dual
If you are not using an inner product and are only dealing with the vector space structure, the transpose AT
actually represents the dual map (or algebraic adjoint) between two dual spaces: A′ : Y′ ⇾ X′.
Over the field of complex numbers, the dual map is still just the standard matrix transpose AT (without taking the complex conjugate). In this purely algebraic sense:
Note: This isomorphism is non-canonical because it requires choosing a basis for the dual space.
Concept
Real Matrix (ℝ)
Complex Matrix (ℂ)
Purely Algebraic Quotient
ℝm / im(A)
ℂm / im(A)
Dual Map Relation
ker(AT)
ker(AT) (No conjugation)
Orthogonal Complement (Geometric)
ker(AT) = im(A)⊥
ker(A*) = im(A)⊥(With conjugation)
Since physical and geometric problems (like the Dirichlet-to-Neumann map) inherently rely on Hilbert spaces and inner products, you will almost always use the conjugate transpose
to represent the cokernel in those contexts.
Example 58:
Let's look at a complex matrix A
that is failing to be surjective, meaning it has a non-trivial cokernel. Let
First, we find the Image (Column Space) of linear transformation defined by this matrix.
Notice that the second column is just ⅉ
times the first column: \( \displaystyle \quad \mathbf{j} \cdot \begin{pmatrix} 1 \\ \mathbf{j} \end{pmatrix} = \begin{pmatrix} \mathbf{j} \\ -1 \end{pmatrix} . \quad \)
Thus, im(A) = span\( \displaystyle \left\{ \begin{pmatrix} 1 \\ \mathbf{j} \end{pmatrix} \right\} , \quad \)
which is a 1-dimensional subspace of ℂ².
To find the orthogonal complement to this image, take the conjugate transpose A✶:
So ker(A✶) = span\( \displaystyle \left\{ \begin{pmatrix} \mathbf{j} \\ 1 \end{pmatrix} \right\} . \quad \)
We check with Mathematica:
Aast = {{1, -I}, {-I, -1} };
NullSpace[Aast]
{{I, 1}}
Because dim(ker(A✶)) = 1, the cokernel space ℂ²/Im(A) is 1-dimensional. Geometrically, any target vector in ℂ² that has a non-zero inner product with \( \displaystyle \quad \begin{pmatrix} \mathbf{j} \\ 1 \end{pmatrix} \quad \) cannot be reached by A.
Lemma 2:
There is an isomorpism between the left null space and dual to cokernel: ker(AT) ≌ (coker(A))′, moreover, the left null space and cokernel have the same dimensions:
\[
\dim\,\mbox{ker}\left( \mathbf{A}^{\mathrm T} \right) = \dim \mbox{coker} (\mathbf{A}) = m - \mbox{rank}(\mathbf{A}) .
\]
Also
\[
\dim(\mbox{coim}(\mathbf{A})) = \dim \mathbb{F}^n - \dim\mbox{ker}(\mathbf{A}) = \mbox{rank}(\mathbf{A})
\]
because coim(A) = 𝔽ⁿ/ker(A) ≌ image(A) = ColumnSpace(A) ⊆ 𝔽m × 1.
An element of the cokernel is a coset [v] = v + im(A), where v ∈ ℝm×`. A linear functional on coker(A) is a map
\[
\varphi \ : \ \mbox{coker}(\mathbf{A}) \mapsto \mathbb{R}
\]
such that φ(α[v] + β[w]) = αφ([v]) + βφ([w]), where α, β are some scalars.
To define such a φ, it suffices to define a linear functional on ℝm ≌ ℝm×1 that vanishes on im(A), because then it descends to the quotient.
We construct tunctionals vanishing on im(A):
Every linear functional on ℝm can be written as
ℓy(v) = y • v
for a unique y ∈ ℝm×1, using the dot product.
The condition “ℓy vanishes on im(A)” means:
\[
\ell _y (\mathbf{A}\,\mathbf{v}) = \langle {\bf y}, \mathbf{A}\,\mathbf{v}\rangle = {\bf y} \bullet \mathbf{A}\, \mathbf{v} =0\quad \mathrm{for\ all\ }\mathbf{v}\in \mathbb{R}^{n}.
\]
Equivalently,
\[
\langle \mathbf{A}^T \mathbf{y}, \mathbf{v}\rangle = 0\quad \mathrm{for\ all\ }\mathbf{v}\in \mathbb{R}^{n},
\]
so ATy = 0, i.e., y ∈ ker(AT).
Thus:
Linear functionals on coker(A) correspond exactly to vectors y ∈ ker(AT).
Construction of the explicit isomorphism:
Define
\[
\Phi : \ \ker (\mathbf{A}^T)\rightarrow (\operatorname{coker} (\mathbf{A}))'
\]
by
\[
\Phi (\mathbf{y})([\mathbf{v}]) = \langle {\bf y}, {\bf v}\rangle= {\bf y} \bullet {\bf v} .
\]
We must check that Φ:
is well-defined: If [v] = [v'], then v' = v + A w for some w. Then
\begin{align*}
\langle \mathbf{y}, \mathbf{v}'\rangle &=\langle \mathbf{y}, \mathbf{v}+{\bf A}\,{\bf w}\rangle
=\langle \mathbf{y}, \mathbf{v}\rangle +\langle \mathbf{y}, {\bf A}\,{\bf w}\rangle
\\
&=\langle \mathbf{y},\mathbf{v}\rangle +\langle \mathbf{A}^T\mathbf{y}, \mathbf{w}\rangle =\langle \mathbf{y}, \mathbf{v}\rangle +0,
\end{align*}
since y ∈ ker(AT). So Φ(y)([v]) is independent of the representative.
Linearity in y: Clear from linearity of the dot product.
Injective: If Φ(y) = 0, then y • v = 0 for all v; hence, y = 0.
Surjective: Any ψ from coker(A)′ corresponds to a linear functional on ℝm vanishing on image(A); that functional is ℓy for a unique y, and then y ∈ ker(AT). So ψ = Φ(y).
Therefore, Φ is a vector space isomorphism:
\[
\ker (\mathbf{A}^T) \cong \operatorname{coker}(\mathbf{A})'.
\]
left null space = orthogonal functionals that “see” only the quotient by the image.
Example 60:
Let
\[
\mathbf{A} = \left[ \begin{matrix}1&2\\ 3&6 \end{matrix}\right] : \mathbb{R}^{2} \rightarrow \mathbb{R}^{2} .
\]
Construct Image and cokernel:
The second row is 3 times the first, so rank(A) = 1. The image is
\[
\operatorname{im} (\mathbf{A}) = \operatorname{span} \left\{ \left[ \begin{matrix}1\\ 3\end{matrix}\right] \right\} .
\]
Thus,
\[
\operatorname{coker} (\mathbf{A}) = \mathbb{R}^{2}/\operatorname{im} (\mathbf{A})
\]
is 1‑dimensional.
A convenient representative of a nonzero coset is, say,
\[
[\mathbf{v}]=\left[ \left[ \begin{matrix}1\\ 0\end{matrix}\right] \right] .
\]
Construct the left null space, ker(AT):
Compute
\[
\mathbf{A}^T = \left[ \begin{matrix}1&3\\ 2&6\\ \end{matrix}\right] .
\]
We want ATy = 0, i.e.,
\[
\left[ \begin{matrix}1&3\\ 2&6\\ \end{matrix}\right] \left[ \begin{matrix}y_1\\ y_2\end{matrix}\right] =\left[ \begin{matrix}0\\ 0\end{matrix}\right] .
\]
This gives
\[
\left\{ \, \begin{array}{l}\textstyle y_1+3y_2=0,\\ \textstyle 2y_1+6y_2=0,\end{array}\right.
\]
and the second equation is redundant. So
\[
y_1=-3y_2.
\]
A basis vector for ker(AT) is
\[
\mathbf{y} = \left[ \begin{matrix}-3\\ 1\end{matrix}\right] .
\]
So \( \displaystyle \quad \ker (\mathbf{A}^T) = \operatorname{span} \left\{ \left[ \begin{matrix}-3\\ 1\end{matrix}\right] \right\} , \quad \) a 1‑dimensional subspace.
If v' = v + A w, then
\[
\mathbf{y}^T \mathbf{v}' = \mathbf{y}^T \mathbf{v} + \mathbf{y}^T {\bf A}\,{\bf w} = \mathbf{y}^T \mathbf{v} + (\mathbf{A}^T \mathbf{y})^T\mathbf{w} = \mathbf{y}^T\mathbf{v}+0,
\]
since ATy = 0.
So Φ(y) is a linear functional on coker(A).
Evaluate it on our chosen coset:
\[
\Phi (y)\left( \left[ \left[ \begin{matrix}1\\ 0\end{matrix}\right] \right] \right) =y^T\left[ \begin{matrix}1\\ 0\end{matrix}\right] =-3.
\]
This is nonzero, so Φ(y) is a nontrivial functional on the 1‑dimensional space coker(A); hence it spans (coker(A))′.
Thus, in this example:
ker(AT) is the line spanned by \( \displaystyle \quad \left[ \begin{matrix}-3\\ 1\end{matrix}\right] .\)
(coker(A))′ is the line spanned by the functional [v] ↦ y • v.
The map y ↦ ([v] ↦ y • v) is a linear isomorphism between these two 1‑dimensional spaces.
■
End of Example 60
DELETE ???? Lemma 2 because it is a repetition of above
Lemma 2 (Isomorphism and Dimensions of Dual Spaces). There is a canonical isomorphism between the left null space and the algebraic dual of the cokernel: $\ker(\mathbf{A}^T) \cong (\text{coker}(\mathbf{A}))'$. Consequently, the left null space and the cokernel share the same finite dimension:
which follows from the First Isomorphism Theorem, establishing that coim(A) = 𝔽ⁿ / ker(A) ≌ image(A) = 𝒞(A) ⊆ 𝔽ᵐ.
Theorem 3A:
For any m-by-n matrix A, its left null space (ker(AT)) is orthogonal complement of the column space 𝒞(A).
The row space 𝒞(AT) is the orthogonal complement to ker(A) in ℝⁿ.
The statement remains completely true under the standard complex inner product, with the exact same geometric meaning.
Theorem 4A:
For any linear operator or m × n
matrix A
acting between finite-dimensional complex inner product spaces, we have
Since this must hold for all choices of x ∈ ℂn×1, you can choose x = x✶y, yielding
. By the positive-definiteness of the inner product, 〈A✶y ∣ A✶yrang; = ∥A✶y∥ = 0, meaning y ∈ ker(A✶).
Example 17:
■
End of Example 17
Theorem 19:
Every m × n matrix A ∈ 𝔽m×n generates the linear transformation TA : 𝔽n×1 ⇾ 𝔽m×1 by matrix multiplication from left,
TA(x) = A x. Then its kernel and image are related via the following relation:
If x ∈ ker(AT), then ATx = 0. Taking dot product, we get
\[
\mathbf{A}^{\mathrm T}\mathbf{x} \bullet \mathbf{y} = \mathbf{x} \bullet \mathbf{A}\,\mathbf{y} = 0 \qquad \forall \mathbf{y} \in \mathbb{F}^{m\times 1} .
\]
In Theorem 1 of the previous section, it was shown that ATx • y = x • A y.
Hence, x belongs to the orthogonal complement of image of TA. Since these relations are valid backward, the statement follows.
This theorem establishes a duality between matrix A and its transpose AT (more precisely between corresponding linear transformations TA and TA′, but we will refer to matrices):
If the operator AT is surjective, then A is injective.
Recall that the kernel of matrix A is also called the null space in linear algebra. The kernel of transpose matrix, which we denote ker(AT), is known as left null space of matrix A.
Now note that the left null space can be defined as the column space:
where \( \displaystyle \quad \mathbf{a}_k^{\mathrm T} \quad \) is the k-th column vector of transpose matrix, AT.
The left null space is also isomorphic to the row vector space:
Theorem 20:
Let A be a real m × n matrix and let b ∈ ℝm×1. There exists a solution x
to the equation Ax = b if and only if b ∈ ker(AT)⊥.
First suppose b ∈ ker(AT)⊥. Then this says that if ATx = 0, it follows that b • x = 0. In other words, taking transpose,
\[
\mathbf{x}^{\mathrm T} \mathbf{A} = 0 \qquad \Longrightarrow \qquad \mathbf{x}^{\mathrm T} \mathbf{b} = 0 .
\]
Thus, if P is a product of elementary matrices such that PA is in row reduced echelon form,
then if PA has a row of zeros, in the k-th position, obtained from the k-th row of P times A,
then there is also a zero in the k-th position of P b. This is because the kth position in P b is
just the k-th row of P times b. Thus, the row reduced echelon forms of A and augmented matrix [A ∣ b] have the same number of zero rows. Hence, the rank of the augmented matrix equals the rank of matrix A.According to Theorem 1, there exists a solution x to the system A x = b. It remains to prove the converse statement.
Let z ∈ ker(AT) and suppose A x = b. We need to verify b • z = 0. Since for dot product we have v •A u = ATv • u, we have
\[
\mathbf{b} \bullet \mathbf{z} = \mathbf{A}\,\mathbf{x} \bullet \mathbf{z} = \mathbf{x} \bullet \mathbf{A}^{\mathrm T} \mathbf{z} = \mathbf{x} \bullet \mathbf{0} = 0 .
\]
Find index of the following matrices and determine which of them defines an injective (one-to-one) or surjective (onto) linear mapping.
Suppose A is an m × n matrix and that m ≤ n. Suppose also that the rank A equals m. Show that TA maps 𝔽n×1 onto 𝔽m×1. Hint: vectors e₁, e₂, … , em occur as columns in the row reduced echelon form for A
Suppose A is an m × n matrix and that m ≥ n. Suppose also that the rank A equals n. Show that TA is one-to-one. Hint: If not, there exists a vector x ≠ 0 such that A x = 0, and this implies at least one column of A is a linear combination of the others. Show that this would require the column rank to be less than n.
Suppose A is an m × n matrix and that m < n. Show that A is not one to one.