Properties of Matrix Representations

Q: Which coordinatisation applies to the range, and why is this easy to get wrong?

The codomain map $\rho_C$. The confusion arises because the kernel calculation uses $\rho_B$ and the two computations are otherwise symmetric. Keeping in mind that the range is a subspace of the codomain, and must therefore be described in codomain coordinates, resolves it every time.

Q: How do I decide injectivity and surjectivity from one calculation?

Row-reduce the representation once and record the rank $r$, the column count $n$ and the row count $m$. The transformation is injective exactly when $r = n$, and surjective exactly when $r = m$. If it is both, the representation is square and non-singular and the transformation is invertible.

Overview

A linear transformation between abstract vector spaces has two subspaces attached to it. The kernel collects the inputs sent to the zero vector, and the range collects the outputs that are actually attained. Both are defined without reference to any basis, and computing them directly means solving equations in the domain and codomain spaces themselves — among polynomials, matrices, or fields of some other kind. That is possible but laborious, and it produces no reusable machinery.

Matrix representation offers a better route. Once bases are fixed, the transformation becomes a matrix, and a matrix has its own kernel-like and range-like subspaces: the null space and the column space, both computable by row reduction. The two theorems on this page state that these are not merely analogous objects but isomorphic ones, and that the isomorphisms are the vector representations already in hand. The kernel corresponds to the null space through $\rho_B$ , the coordinatisation of the domain; the range corresponds to the column space through $\rho_C$ , the coordinatisation of the codomain.

The consequences are immediate and quantitative. Dimensions are preserved by an isomorphism, so the nullity of $T$ equals the nullity of any representation and the rank of $T$ equals the rank of any representation. Injectivity of $T$ becomes the condition that the representation has only the zero vector in its null space; surjectivity becomes the condition that the columns span all of $\mathbb{C}^m$ . The rank-nullity theorem for transformations follows from the rank-nullity relationship for matrices rather than needing an independent proof.

Just as valuable is the practical procedure the proofs supply. A basis for the null space of the representation, obtained by row reduction, is carried by $\rho_B^{-1}$ into a basis for the kernel; a basis for the column space is carried by $\rho_C^{-1}$ into a basis for the range. An abstract subspace of polynomials or matrices is therefore produced by a routine numerical calculation followed by one decoding step, and the answers arrive as bases rather than as descriptions.

Definition

Kernel of a Linear Transformation

KLT

For $T\colon U \to V$ , the kernel is the set of domain vectors annihilated by $T$ , written $\mathcal{K}(T) = \{\, \vec{u} \in U \mid T(\vec{u}) = \vec{0} \,\}$ . It is a subspace of $U$ , and its dimension is the nullity of $T$ . The transformation is injective precisely when the kernel contains only the zero vector.

Range of a Linear Transformation

RLT

For $T\colon U \to V$ , the range is the set of vectors actually produced, $\mathcal{R}(T) = \{\, T(\vec{u}) \mid \vec{u} \in U \,\}$ . It is a subspace of $V$ , and its dimension is the rank of $T$ . The transformation is surjective precisely when the range is the whole codomain.

Isomorphic Vector Spaces

IVS

Two vector spaces are isomorphic, written $X \cong Y$ , when there exists an invertible linear transformation from one to the other. Isomorphic spaces have equal dimension and identical linear-algebraic structure; any statement about spans, independence or subspaces transfers across the isomorphism unchanged.

Isomorphic is not the same as equal. The kernel of a transformation on $M_{22}$ consists of matrices, not of column vectors; the isomorphism converts between them but does not identify them.

Concepts

Kernel and null space isomorphism

The first theorem states $\mathcal{K}(T) \cong \mathcal{N}(M^{T}_{B,C})$ , and the proof exhibits the isomorphism explicitly: it is $\rho_B$ , restricted to the kernel. Three checks are needed. The restricted map lands where it should, because if $T(\vec{u}) = \vec{0}$ then the fundamental theorem gives $M^{T}_{B,C}\rho_B(\vec{u}) = \rho_C(\vec{0}) = \vec{0}$ . It remains injective, since restricting the domain of an injective map cannot damage injectivity. And it is surjective onto the null space, because for any $\vec{x}$ with $M^{T}_{B,C}\vec{x} = \vec{0}$ the vector $\rho_B^{-1}(\vec{x})$ lies in the kernel and maps to $\vec{x}$ .

Range and column space isomorphism

The companion theorem states $\mathcal{R}(T) \cong \mathcal{C}(M^{T}_{B,C})$ , with the isomorphism given by $\rho_C$ restricted to the range. Note carefully which coordinatisation appears: the range is a subspace of the codomain, so it must be described in codomain coordinates. Using $\rho_B$ here is the single most common error in the subject. The proof mirrors the kernel case, using the fundamental theorem to show that the coordinates of any attained output are a linear combination of the columns of the representation, and conversely.

Dimensions transfer, vectors do not

Because isomorphisms preserve dimension, the nullity of $T$ equals the nullity of its representation and the rank of $T$ equals the rank of its representation. What does not transfer is the identity of the objects: a basis vector of $\mathcal{N}(M^{T}_{B,C})$ is a column of scalars, whereas the corresponding kernel element may be a polynomial or a matrix. The decoding step $\rho_B^{-1}$ is not optional bookkeeping; it is what converts a numerical answer into an answer about the original problem.

Injectivity and surjectivity become matrix conditions

Since the kernel is trivial exactly when its isomorphic image is trivial, $T$ is injective if and only if $\mathcal{N}(M^{T}_{B,C}) = \{\vec{0}\}$ — equivalently, the columns of the representation are linearly independent and its rank is $n$ . Similarly $T$ is surjective if and only if the column space is all of $\mathbb{C}^m$ , that is, the rank equals $m$ . Both tests are settled by one row reduction, and both are independent of the bases chosen, since rank is.

Rank-nullity inherited from the matrix

For any $m \times n$ matrix the rank and nullity sum to $n$ , the number of columns. Transporting both quantities through the isomorphisms gives $\dim(\mathcal{K}(T)) + \dim(\mathcal{R}(T)) = n = \dim(U)$ , which is the rank-nullity theorem for linear transformations. The chain of reasoning is worth noticing: a structural theorem about abstract spaces is obtained from a counting fact about pivot columns.

Basis independence of the conclusions

The representation depends on the bases, so different choices give different null spaces and column spaces — different sets of columns of scalars. The kernel and range they decode to are always the same subspaces of $U$ and $V$ . This is the practical form of the claim that rank, nullity, injectivity and surjectivity are intrinsic properties of the transformation. It also licenses a deliberate tactic: choose whichever bases make the representation easiest to reduce, since the decoded answer cannot depend on that choice.

Computing a kernel or a range through a representation

Choose convenient basesPick ordered bases

B

U

and

C

V

that make coordinatisation cheap. Convenience costs nothing, because the decoded answer is basis independent.

Build $M^{T}_{B,C}$ One column per domain basis vector, holding the codomain coordinates of its image.

Row-reduceCompute the reduced row-echelon form once. It delivers the pivot columns, the rank, and the free variables in a single pass.

For the kernel: read the null spaceWrite a basis for

\mathcal{N}(M^{T}_{B,C})

from the free variables, then apply

\rho_B^{-1}

to each basis vector to obtain kernel elements of

U

For the range: read the column spaceTake the columns of the original matrix indexed by the pivot columns, then apply

\rho_C^{-1}

to each to obtain range elements of

V

Report the invariantsNullity is the number of non-pivot columns, rank the number of pivot columns. Injective when nullity is zero; surjective when rank equals

\dim(V)

Equations

Kernel and null space isomorphism

EQ-PMR-01

K (T) ≅ N (M_{B}^{,})

The isomorphism is $\rho_B$ restricted to the kernel; it is the domain coordinatisation that applies here.

Range and column space isomorphism

EQ-PMR-02

R (T) ≅ C (M_{B}^{,})

The isomorphism is $\rho_C$ restricted to the range; the range lives in the codomain, so codomain coordinates are required.

Transfer of rank and nullity

EQ-PMR-03

rank (T) = rank (M_{B}^{,}), nullity (T) = nullity (M_{B}^{,})

Isomorphisms preserve dimension, so both invariants can be read from any representation.

Rank-nullity for a transformation

EQ-PMR-04

Rank-nullity for a transformation

Inherited from the pivot count of an $m \times n$ representation, where every column is either a pivot column or a free column.

Injectivity test

EQ-PMR-05

T injective \Leftrightarrow N (M_{B}^{,}) = {\vec{0}} \Leftrightarrow rank (M_{B}^{,}) = n

Equivalently, the columns of the representation form a linearly independent set.

Surjectivity test

EQ-PMR-06

T surjective \Leftrightarrow C (M_{B}^{,}) = ℂ^{m} \Leftrightarrow rank (M_{B}^{,}) = m

Equivalently, the columns of the representation span the whole coordinate space of the codomain.

Decoding a computed basis

EQ-PMR-07

K (T) = span ({ρ_{B}^{-} ({\vec{z}}_{1}), \dots, ρ_{B}^{-} ({\vec{z}}_{k})})

Where $\{\vec{z}_1, \ldots, \vec{z}_k\}$ is any basis of the null space of the representation. The analogous statement with $\rho_C^{-1}$ and a column space basis gives the range.

Variable Definitions

Symbols used on this page
Symbol	Name	Meaning	Domain / type
$T$	Linear transformation	The map from $U$ to $V$ whose kernel and range are wanted	element of L(U,V)
$K (T)$	Kernel	Subspace of $U$ mapped to the zero vector of $V$	subspace of U
$R (T)$	Range	Subspace of $V$ consisting of all attained images	subspace of V
$M_{B}^{,}$	Matrix representation	The $m \times n$ array encoding $T$ relative to bases $B$ and $C$	m x n matrix
$N (A)$	Null space	All coordinate vectors annihilated by the representation	subspace of C^n
$C (A)$	Column space	Span of the columns of the representation	subspace of C^m
$ρ_{B}$	Domain coordinatisation	Isomorphism carrying the kernel onto the null space	invertible map U to C^n
$ρ_{C}$	Codomain coordinatisation	Isomorphism carrying the range onto the column space	invertible map V to C^m
$r$	Rank	Common dimension of the range and the column space	0 to min(m,n)

Worked Numerical Example

Problem statement

A signal conditioning block takes a $2 \times 2$ gain matrix supplied by a calibration routine and produces a quadratic correction polynomial. Determine which gain settings produce no correction at all (the kernel) and which correction polynomials are reachable (the range), by working entirely through a matrix representation.

State the transformation and choose bases
Define $T\colon M_{22} \to P_2$ by $T\left(\begin{bmatrix} a & b \\ c & d \end{bmatrix}\right) = (a + 2b - c + d) + (2a + 4b + c - d)x + (a + 2b + 2c - 2d)x^2$ . Use the single-entry basis $B = \{E_{11},\, E_{12},\, E_{21},\, E_{22}\}$ for $M_{22}$ and the monomial basis $C = \{1,\, x,\, x^2\}$ for $P_2$ . The representation will be $3 \times 4$ .
Build the representation
Each basis matrix activates one variable, so the columns can be read straight from the coefficients: $T(E_{11}) = 1 + 2x + x^2$ , $T(E_{12}) = 2 + 4x + 2x^2$ , $T(E_{21}) = -1 + x + 2x^2$ and $T(E_{22}) = 1 - x - 2x^2$ .
$M_{B}^{,} = [\begin{matrix} 1 & 2 & - 1 & 1 \\ 2 & 4 & 1 & - 1 \\ 1 & 2 & 2 & - 2 \end{matrix}]$
Row-reduce once
Subtracting twice row one from row two and row one from row three, then scaling and clearing, gives the reduced row-echelon form. Pivot columns are $1$ and $3$ , so the rank is $2$ and the nullity is $4 - 2 = 2$ .
$Row-reduce once$
Read a basis for the null space
The free columns are $2$ and $4$ . Setting the second free variable to zero and the first to one gives $\left[-2\ 1\ 0\ 0\right]^{t}$ ; reversing the roles gives $\left[0\ 0\ 1\ 1\right]^{t}$ . These two vectors are a basis for $\mathcal{N}(M^{T}_{B,C})$ .
${[\begin{matrix} - 2 \\ 1 \\ 0 \\ 0 \end{matrix}], [\begin{matrix} 0 \\ 0 \\ 1 \\ 1 \end{matrix}]}$
Decode to a basis of the kernel
Apply $\rho_B^{-1}$ , which simply reassembles the four coordinates into a $2 \times 2$ array in the order $a, b, c, d$ . Substituting either matrix into $T$ returns the zero polynomial, confirming the calculation.
$K (T) = span ({[\begin{matrix} - 2 & 1 \\ 0 & 0 \end{matrix}], [\begin{matrix} 0 & 0 \\ 1 & 1 \end{matrix}]})$
Read a basis for the column space
The pivot columns are $1$ and $3$ , so columns $1$ and $3$ of the original matrix — not of its reduced form — are a basis for the column space: $\left[1\ 2\ 1\right]^{t}$ and $\left[-1\ 1\ 2\right]^{t}$ .
Decode to a basis of the range
Applying $\rho_C^{-1}$ converts each coordinate vector back into a polynomial. The range is therefore a two-dimensional subspace of the three-dimensional space $P_2$ .
$R (T) = span ({1 + 2 x + x^{2}, - 1 + x + 2 x^{2}})$
Report the invariants
Rank $2$ , nullity $2$ , and $2 + 2 = 4 = \dim(M_{22})$ as rank-nullity requires. Since the nullity is non-zero, $T$ is not injective: distinct gain settings can produce identical corrections. Since the rank is $2$ rather than $3$ , $T$ is not surjective: one dimension of correction polynomials is unreachable.

Result

The calibration block has a two-dimensional family of gain settings that produce no correction whatsoever, spanned by the two matrices above, and it can only generate corrections lying in a two-dimensional plane of quadratics. Both facts were obtained from a single row reduction of a $3 \times 4$ array, with no equation solving in the spaces of matrices or polynomials.

Applications & Industry Use

Structural engineering

Mechanisms and states of self-stress

The equilibrium operator of a pin-jointed assembly maps member forces to nodal loads. Its kernel is the set of self-stress states that produce no external load, and the kernel of the corresponding operator on displacements is the set of infinitesimal mechanisms. Computing both from the representation identifies redundancy and under-bracing in one row reduction.

Control systems

Unobservable and uncontrollable subspaces

The unobservable subspace is the kernel of the observability operator and the controllable subspace is the range of the reachability operator. Representing each operator relative to a state basis converts these abstract subspaces into a null space and a column space, and the decoded bases name which physical modes are hidden from the sensors or unreachable by the actuators.

Chemical & process engineering

Conserved quantities and feasible compositions

The map from reaction extents to composition changes has a kernel of reaction combinations that leave the mixture unchanged and a range of achievable composition changes. Conservation laws appear as constraints orthogonal to that range, so the same computation both identifies redundant reactions and bounds what a reactor can produce.

Geodesy & surveying

Datum defect in network adjustment

An observation operator that measures only relative quantities has a non-trivial kernel corresponding to translations, rotations and scale of the whole network. Detecting that kernel through the representation quantifies the datum defect exactly and dictates how many external constraints must be imposed before a least-squares adjustment is well posed.

Computer vision

Degenerate camera configurations

Reconstruction algorithms build a linear system whose operator should be injective on the parameter space. When the configuration is degenerate — a planar scene, a pure rotation — the representation acquires a non-trivial null space whose decoded basis names the family of scene reconstructions consistent with the data.

Machine learning

Parameter identifiability

For a linear model the map from parameters to predictions has a kernel of parameter directions that leave every prediction unchanged. Those directions are exactly the unidentifiable combinations, and reporting them as a decoded basis is far more informative to a modeller than a warning that a matrix was rank deficient.

Design Considerations

Use the domain map for kernels and the codomain map for ranges

The two theorems use different isomorphisms, and swapping them is not a harmless slip: the results are elements of the wrong space and typically of the wrong dimension. Anchor the choice by remembering that the kernel is a set of inputs and the range is a set of outputs, so each must be described in the coordinates of the space it inhabits.

Choose bases for computational convenience only

Because kernel and range are basis independent, there is no mathematical reason to prefer one admissible pair of bases over another. Choose the pair that makes coordinatisation trivial — monomials, single-entry matrices, standard unit vectors — and reserve structured bases for problems where the representation itself, not its subspaces, is the deliverable.

Take column space bases from the original matrix

Row reduction preserves the null space but not the column space, so the columns of the reduced form generally span a different subspace. The correct procedure is to locate the pivot columns in the reduced form and then select the corresponding columns of the original representation. Skipping that step produces a subspace of the right dimension and the wrong content.

Decide rank with an appropriate tolerance

In exact arithmetic rank is unambiguous. In floating point, a representation assembled from measured data has no exactly zero pivots, and the rank becomes a threshold decision. For engineering data prefer a singular value decomposition with a documented tolerance over row reduction, and report the gap between consecutive singular values as evidence for the chosen cut.

Report bases, not just dimensions

A statement that a transformation has nullity two is much less actionable than an explicit basis for the kernel. The decoding step costs almost nothing once the null space basis is available, and it converts an abstract diagnosis into a concrete list of the configurations, parameter directions or load states responsible.

Check the answer in the original space

The most reliable verification is to substitute each decoded kernel element into the definition of $T$ and confirm the result is the zero vector of $V$ . This tests the representation, the row reduction and the decoding in a single step, and it catches basis-ordering errors that leave dimensions correct but vectors wrong.

Standards & Codes

Notation, interchange and numerical standards that govern how this material is written down, stored and computed in production systems.

Applicable standards, conventions and reference implementations
Reference	Title	Relevance to this topic
`ISO 80000-2`	Quantities and units — Part 2: Mathematics	Standardises the script notation used here for kernel, range, null space and column space, and the upright operator names $\operatorname{rank}$ and $\dim$ .
`LAPACK / BLAS reference`	Linear Algebra PACKage reference implementation	Supplies the production tools that replace hand row reduction: `xGESVD` for a tolerance-based rank, `xGEQP3` for a rank-revealing factorisation, and the orthonormal bases for null space and range that follow from them.
`IEEE 754-2019`	IEEE Standard for Floating-Point Arithmetic	Explains why a structurally zero pivot appears as a small non-zero number in a representation assembled from measured entries, and hence why rank determination requires an explicit tolerance.
`ISO/IEC 40314`	Mathematical Markup Language (MathML) Version 3.0	Carries the set-builder and script notation of this page as structured markup so that subspace statements remain searchable and machine-readable.
`W3C WCAG 2.1 AA`	Web Content Accessibility Guidelines	Requires the matrices and basis sets here to be exposed as semantic markup with alternative text rather than images, so a screen reader can convey the pivot structure of a representation.

Material Selection

For a mathematical topic, "material" is the numeric representation: the scalar field, storage format and precision the computation is built from.

Representation and precision selection
Representation	Select when	Trade-off
Exact rational arithmetic	Representations assembled from symbolic or integer data where the kernel is a structural result, such as identifying redundant reactions or mechanisms.	The pivot pattern, and hence rank and nullity, are certain; intermediate fractions can grow but the answers need no tolerance argument.
IEEE 754 binary64 with SVD-based rank	Representations built from measurement, discretisation or simulation output, which is most engineering practice.	Robust and fast, and the singular values quantify how close the transformation is to a lower rank, but the reported rank is only as defensible as the stated tolerance.
Finite field arithmetic modulo a prime	Certifying the rank of a large integer representation cheaply, or working in coding theory where the scalars really are a finite field.	Exact and fast with bounded operand size, but an unlucky prime can lower the apparent rank, so certification should use more than one.
Sparse storage with fill-reducing ordering	Representations from locally supported bases in discretised field problems, where the array is large and mostly zero.	Makes otherwise infeasible problems tractable, but elimination causes fill-in, so a sparse QR or SVD is usually preferable to sparse row reduction.
Complex scalars	Representations of operators arising in frequency-domain, modal or quantum settings.	Kernel and range are computed identically, but real-only software will report a trivial kernel for a transformation whose kernel exists only over the complex field.
Orthonormal bases for the decoded subspaces	The kernel or range basis will be used for projection, least squares or further numerical work.	An orthonormal basis from an SVD is numerically far better conditioned than the pivot-column basis, at the cost of losing the interpretability that individual original columns often carry.

Manufacturing Notes

Implementation notes — how the result is actually produced by hand, by algorithm and by library, including cost and numerical behaviour.

Cost of the whole procedure

Assembling the representation costs $n$ evaluations and $n$ coordinatisations. The dominant numerical step is a single reduction of an $m \times n$ array, about $O(mn\min(m,n))$ operations. Decoding is $O(1)$ per basis vector. Compared with solving directly in an abstract space, essentially all of the intellectual work is replaced by one standard factorisation.

Producing the kernel basis by hand

From the reduced row-echelon form, set one free variable to one and the rest to zero, then read the pivot variables from their rows. Repeating for each free variable gives a basis whose size equals the nullity automatically. The resulting vectors are independent by construction, because each has a one in a position where the others have a zero.

Two routes to a range basis

Either take the original columns indexed by the pivots of the reduced form, or row-reduce the transpose of the representation and take the non-zero rows. The first preserves the physical meaning of individual columns; the second produces a tidier, echelon-shaped basis. Both span the same subspace, and disagreement between them is a reliable indicator of an arithmetic error.

Library behaviour

SciPy exposes scipy.linalg.null_space and scipy.linalg.orth, both built on the singular value decomposition with a tolerance argument, returning orthonormal bases rather than pivot-derived ones. SymPy's nullspace and columnspace work exactly and return the pivot-style bases described here. Choose according to whether the downstream use is numerical projection or structural interpretation.

Verification strategy

Three independent checks are cheap. Confirm that rank plus nullity equals the column count; substitute each decoded kernel element into $T$ and require the zero vector; and confirm each decoded range element is genuinely an image by solving for a preimage. Passing all three makes a transcription error very unlikely.

Failure Modes & Common Mistakes

Failure modes, root causes and prevention
Failure mode / mistake	Impact	Root cause	Prevention & detection
Decoding a null space vector with the wrong map	high	Applying $\rho_C^{-1}$ to a null space basis vector, or $\rho_B^{-1}$ to a column space basis vector.	Tie the map to the space: kernel elements are inputs and use $\rho_B^{-1}$ ; range elements are outputs and use $\rho_C^{-1}$ . A dimension mismatch will often, but not always, expose the error.
Using reduced columns for the column space	high	Taking the pivot columns of the reduced row-echelon form instead of the corresponding columns of the original representation.	Row operations preserve the null space but change the column space; always index back into the original matrix once the pivot positions are known.
Confusing isomorphic with equal	medium	Reporting the kernel as a set of column vectors when the domain is a space of polynomials or matrices.	Finish every computation with the decoding step and state the answer in the objects of the original space.
Exact zero test on measured data	high	Treating a pivot of magnitude $10^{-14}$ as non-zero, inflating the rank and reporting a trivial kernel for a genuinely singular transformation.	Use a singular value decomposition with a scaled tolerance and report the singular value gap alongside the rank.
Testing surjectivity against the wrong dimension	medium	Comparing the rank with the number of columns rather than the number of rows, so a transformation is declared surjective when it is merely injective.	Rank equal to $n$ gives injectivity; rank equal to $m$ gives surjectivity. Write both numbers down before drawing either conclusion.
Reordering a basis between assembly and decoding	medium	Building the representation with one ordering of $B$ and decoding coordinates with another, producing kernel elements with permuted entries.	Keep the ordered basis in a single immutable object used by both the assembly and the decoding routine.
Assuming a non-trivial kernel means the representation is square	low	Reaching for a determinant to test for a kernel when the representation is rectangular.	Determinants apply only to square arrays; rank from row reduction or SVD applies to any shape and is the correct instrument.
Reporting dimensions without bases	low	Stopping at rank and nullity because they are basis independent, and omitting the decoded bases that identify the responsible configurations.	Treat the decoded bases as the deliverable; the dimensions are a summary of them, not a substitute.

FAQs

Why is the kernel isomorphic to the null space rather than equal to it?

The kernel consists of vectors in the domain, which may be polynomials, matrices or anything else, while the null space consists of columns of scalars. The vector representation $\rho_B$ converts between them bijectively and linearly, so the two spaces have identical structure and dimension, but their elements are different kinds of object.

Do the kernel and range depend on which bases I choose?

No. The null space and column space of the representation do change with the bases, but the subspaces they decode to are always the same subspaces of $U$ and $V$ . This is why the bases can be chosen purely for convenience when the deliverable is a kernel or a range.

Which coordinatisation applies to the range, and why is this easy to get wrong?

The codomain map $\rho_C$ . The confusion arises because the kernel calculation uses $\rho_B$ and the two computations are otherwise symmetric. Keeping in mind that the range is a subspace of the codomain, and must therefore be described in codomain coordinates, resolves it every time.

How do I decide injectivity and surjectivity from one calculation?

Row-reduce the representation once and record the rank $r$ , the column count $n$ and the row count $m$ . The transformation is injective exactly when $r = n$ , and surjective exactly when $r = m$ . If it is both, the representation is square and non-singular and the transformation is invertible.

Does this replace the direct definition of kernel and range?

Not conceptually — the definitions remain basis free and are what give the objects meaning. It replaces the direct computation, which for abstract spaces means solving equations among polynomials or matrices. The representation route is mechanical, reuses standard software and produces bases rather than descriptions.

What if the representation is not square?

Nothing changes. Both theorems are stated for arbitrary rectangular representations, and rank, nullity, null space and column space are all defined for any shape. Only the questions of invertibility, determinant and eigenvalues require a square representation.

Can I use these results to prove rank-nullity for transformations?

Yes, and that is one of the cleanest routes to it. Every column of an $m \times n$ representation is either a pivot column or a free column, giving rank plus nullity equal to $n$ for the matrix. Transporting both dimensions through the isomorphisms yields the same identity for the transformation, with $n = \dim(U)$ .

References

Beezer, R. A. A First Course in Linear Algebra, Version 0.70. University of Puget Sound, 2006. Section MR, Subsection PMR. Licensed under the GNU Free Documentation License v1.2.
Strang, G. Linear Algebra and Its Applications, 4th edition. Cengage Learning, 2006.
Anderson, E. et al. LAPACK Users' Guide, 3rd edition. Society for Industrial and Applied Mathematics, 1999.
ISO 80000-2:2019, Quantities and units — Part 2: Mathematics. International Organization for Standardization.
Trefethen, L. N. and Bau, D. Numerical Linear Algebra. Society for Industrial and Applied Mathematics, 1997.

AI Suggested Questions

Take a transformation on the space of symmetric matrices and compute its kernel through a representation, showing the decoding step explicitly.
Why does row reduction preserve the null space but not the column space, and what goes wrong if I ignore that?
Compare the pivot-column basis for a range with the orthonormal basis returned by an SVD, for the same representation.
Show how the rank-nullity theorem for linear transformations follows from the pivot count of a rectangular matrix.
Given a representation from measured data with singular values 12, 4, 0.003 and 0.0007, argue for a defensible rank and the resulting kernel.
Construct a transformation between abstract spaces that is injective but not surjective, and identify the shape of its representation.

Related Calculators

Kernel & Range Calculator

Build a representation from a transformation and two bases, then return decoded bases for the kernel and the range in the original spaces.

Matrix Rank & Nullity Calculator

Compute rank, nullity and the pivot column set of a representation with a selectable numerical tolerance.

Null Space Basis Calculator

Row-reduce a matrix and return a basis for its null space, with the free-variable assignments shown step by step.

Overview

Definition

Kernel of a Linear Transformation

Range of a Linear Transformation

Isomorphic Vector Spaces

Concepts

Kernel and null space isomorphism

Range and column space isomorphism

Dimensions transfer, vectors do not

Injectivity and surjectivity become matrix conditions

Rank-nullity inherited from the matrix

Basis independence of the conclusions

Computing a kernel or a range through a representation

Equations

Variable Definitions

Worked Numerical Example

Problem statement

State the transformation and choose bases

Build the representation

Row-reduce once

Read a basis for the null space

Decode to a basis of the kernel

Read a basis for the column space

Decode to a basis of the range

Report the invariants

Applications &amp; Industry Use

Mechanisms and states of self-stress

Unobservable and uncontrollable subspaces

Conserved quantities and feasible compositions

Datum defect in network adjustment

Degenerate camera configurations

Parameter identifiability

Design Considerations

Use the domain map for kernels and the codomain map for ranges

Choose bases for computational convenience only

Take column space bases from the original matrix

Decide rank with an appropriate tolerance

Report bases, not just dimensions

Check the answer in the original space

Standards &amp; Codes

Material Selection

Manufacturing Notes

Cost of the whole procedure

Producing the kernel basis by hand

Two routes to a range basis

Library behaviour

Verification strategy

Failure Modes &amp; Common Mistakes

FAQs

Related Engineering Topics

References

AI Suggested Questions

Related Calculators

Continue learning

Applications & Industry Use

Standards & Codes

Failure Modes & Common Mistakes