Kernel of a Linear Transformation

Overview

For a linear transformation $T \colon U \to V$ , the kernel is the collection of every input that the transformation flattens to zero. It is a subset of the domain, not of the codomain, and it answers a question that recurs in every application of linear models: what can be changed about the input without changing the output at all? The set of such changes is exactly the kernel, and its dimension is the number of independent directions along which the transformation is blind.

Two facts make the kernel more than a curiosity. First, it is always a subspace of the domain — it contains the zero vector, and it is closed under addition and scalar multiplication. That means it can be described by a basis, has a well-defined dimension, and inherits every result about subspaces. Second, it controls the entire preimage structure of the transformation. If any single input produces a given output, then the complete set of inputs producing that output is obtained by adding the whole kernel to that one input. Preimages are therefore either empty or translates of one fixed subspace, all of the same dimension.

The kernel is also the operational test for injectivity. A transformation is one-to-one exactly when its kernel contains nothing but the zero vector. This replaces a statement quantified over all pairs of inputs with a single computation, and for a matrix transformation $T(\vec{x}) = A\vec{x}$ the kernel coincides with the null space of $A$ , so the entire apparatus of row reduction applies unchanged.

In engineering terms the kernel names the redundancy in a system. For a redundant manipulator it is the space of self-motions that reconfigure the arm without moving the tool. For a measurement chain it is the space of state changes the instrument cannot detect. For a structural model it is the space of self-equilibrated internal force states. In each case, computing a basis for the kernel converts a vague sense that the model has slack into an explicit, parameterised description of that slack.

Definition

Kernel of a Linear Transformation

KLT

Let $T \colon U \to V$ be a linear transformation. The kernel of $T$ , written $\mathcal{K}(T)$ , is the set of all vectors in the domain that $T$ sends to the zero vector of the codomain:

$\mathcal{K}(T) = \{\, \vec{u} \in U \mid T(\vec{u}) = \vec{0} \,\}$

Equivalently,

\mathcal{K}(T)

is the preimage of the zero vector,

T^{-1}(\vec{0})

Older texts sometimes call this the null space of the transformation. The notation $\mathcal{K}$ keeps it distinct from the null space $\mathcal{N}(A)$ of a matrix, although the two objects coincide when the transformation is defined by that matrix.

Preimage of a Vector

For $T \colon U \to V$ and $\vec{v} \in V$ , the preimage $T^{-1}(\vec{v})$ is the set of all inputs producing that output: $T^{-1}(\vec{v}) = \{\, \vec{u} \in U \mid T(\vec{u}) = \vec{v} \,\}$ . It may be empty. The notation does not presuppose that $T$ has an inverse function.

The kernel is the special case $\vec{v} = \vec{0}$ , and it is the only preimage that is ever a subspace.

Nullity of a Linear Transformation

The dimension of the kernel, $\dim(\mathcal{K}(T))$ . It counts the independent directions in the domain along which $T$ carries no information, and it is the number of free parameters in every non-empty preimage.

Concepts

The kernel is always a subspace

Apply the three-part subspace test to $\mathcal{K}(T)$ as a subset of $U$ . It is non-empty because every linear transformation satisfies $T(\vec{0}_U) = \vec{0}_V$ , so the zero vector of the domain belongs to the kernel. If $\vec{x}, \vec{y} \in \mathcal{K}(T)$ then $T(\vec{x} + \vec{y}) = T(\vec{x}) + T(\vec{y}) = \vec{0} + \vec{0} = \vec{0}$ , giving closure under addition. If $\alpha$ is a scalar and $\vec{x} \in \mathcal{K}(T)$ then $T(\alpha\vec{x}) = \alpha T(\vec{x}) = \alpha \vec{0} = \vec{0}$ , giving closure under scalar multiplication. Hence $\mathcal{K}(T)$ is a subspace of the domain. The practical payoff is immediate: the kernel can always be reported as the span of a finite basis rather than as an unstructured set.

Kernel and null space are the same object

When $U = \mathbb{C}^n$ , $V = \mathbb{C}^m$ and $T(\vec{x}) = A\vec{x}$ for a fixed $m \times n$ matrix $A$ , the condition $T(\vec{u}) = \vec{0}$ is literally the homogeneous system $A\vec{u} = \vec{0}$ . So $\mathcal{K}(T) = \mathcal{N}(A)$ , and everything known about null spaces transfers: reduce $A$ , identify the free columns, and read off one basis vector per free variable. The dimension of the kernel is $n - \operatorname{rank}(A)$ . Nothing about the abstract definition is lost in this translation; the abstract version simply extends the same idea to domains of polynomials, matrices or functions.

Preimages are translates of the kernel

Suppose $T^{-1}(\vec{v})$ is non-empty and $\vec{u}$ is one of its elements. Then $T^{-1}(\vec{v}) = \vec{u} + \mathcal{K}(T) = \{\, \vec{u} + \vec{z} \mid \vec{z} \in \mathcal{K}(T) \,\}$ . The proof runs in two inclusions. Any $\vec{u} + \vec{z}$ with $\vec{z}$ in the kernel satisfies $T(\vec{u} + \vec{z}) = \vec{v} + \vec{0} = \vec{v}$ , so it lies in the preimage. Conversely if $T(\vec{x}) = \vec{v}$ then $T(\vec{x} - \vec{u}) = \vec{v} - \vec{v} = \vec{0}$ , so $\vec{x} - \vec{u}$ lies in the kernel and $\vec{x}$ has the required form. Every non-empty preimage is therefore a copy of the kernel, shifted; all of them have the same dimension, and only the one over $\vec{0}$ passes through the origin and is a subspace.

Injective if and only if the kernel is trivial

This is the theorem that makes the kernel the standard instrument for testing injectivity. If $T$ is injective and $\vec{x} \in \mathcal{K}(T)$ , then $T(\vec{x}) = \vec{0} = T(\vec{0})$ , and injectivity forces $\vec{x} = \vec{0}$ ; so the kernel is trivial. Conversely, if the kernel is trivial and $T(\vec{x}) = T(\vec{y})$ , then linearity gives $T(\vec{x} - \vec{y}) = \vec{0}$ , so $\vec{x} - \vec{y}$ lies in the kernel, hence equals $\vec{0}$ , hence $\vec{x} = \vec{y}$ . The equivalence converts a statement about every pair of inputs into a single homogeneous computation.

A non-trivial kernel generates collisions everywhere

Take $\vec{z} \ne \vec{0}$ in the kernel. For any input $\vec{x}$ whatsoever, $T(\vec{x} + \vec{z}) = T(\vec{x}) + T(\vec{z}) = T(\vec{x})$ . A single non-zero kernel vector therefore produces a distinct pair of inputs with identical outputs at every point of the domain. This is why the kernel is the natural object to compute when a model is suspected of being unidentifiable: it does not merely certify that ambiguity exists, it parameterises the ambiguity completely.

The engineering meaning of kernel dimension

The nullity is the number of independent input adjustments that leave the output untouched. In robotics it counts the degrees of self-motion of a redundant manipulator: the joint rates lying in the kernel of the Jacobian reconfigure the arm while holding the tool still, and are exploited for obstacle avoidance and joint-limit management. In structural analysis the kernel of an equilibrium matrix contains the self-stress states, and its dimension is the degree of static indeterminacy. In model fitting the kernel of the design matrix contains the parameter changes invisible to the data, and its dimension is the number of unidentifiable directions. A zero-dimensional kernel means no slack; every extra dimension is one more thing the system can do for free, or one more thing you cannot measure.

Computing and using a kernel

Write $T(\vec{u}) = \vec{0}$ Set the general output expression equal to the zero vector of the codomain.

Equate components or coefficientsConvert the single vector equation into a homogeneous linear system in the coordinates of

\vec{u}

Row-reduce the coefficient matrixNo augmented column is needed; the right-hand side is zero and stays zero.

Read one basis vector per free variableSet one free variable to

1

and the rest to

0

; the pivot rows supply the remaining coordinates.

Report the kernel as a span

\mathcal{K}(T)

is the span of those vectors, and its dimension is the number of free variables.

Draw the conclusionsTrivial kernel means injective; otherwise every non-empty preimage is that kernel translated by one particular solution.

Equations

Definition of the kernel

EQ-KLT-01

K (T) = {\vec{u} \in U ∣ T (\vec{u}) = \vec{0}}

The kernel is a subset of the domain. The zero vector on the right belongs to the codomain $V$ .

Kernel as the preimage of zero

EQ-KLT-02

K (T) = T^{- 1} (\vec{0})

The kernel is one particular preimage, and the only one that contains the origin and is therefore a subspace.

Kernel of a matrix transformation

EQ-KLT-03

T (\vec{x}) = A \vec{x} Longrightarrow K (T) = N (A) = {\vec{x} \in ℂ^{n} ∣ A \vec{x} = \vec{0}}

For transformations defined by a matrix the kernel is exactly the null space, so a single row reduction produces a basis.

Structure of a non-empty preimage

EQ-KLT-04

Structure of a non-empty preimage

One particular solution plus the entire kernel gives the complete solution set. This is the transformation-level form of the particular-plus-homogeneous decomposition.

Injectivity criterion

EQ-KLT-05

T injective \Leftrightarrow K (T) = {\vec{0}}

A transformation is one-to-one exactly when nothing but the zero vector is annihilated.

Nullity from the pivot count

EQ-KLT-06

\dim (K (T)) = n - rank (A), n = \dim (U)

For a matrix transformation, the number of free columns is the dimension of the kernel and the number of parameters in every non-empty preimage.

Collision generated by a kernel vector

EQ-KLT-07

\vec{z} \in K (T) Longrightarrow T (\vec{x} + \vec{z}) = T (\vec{x}) \forall \vec{x} \in U

Variable Definitions

Symbols used on this page
Symbol	Name	Meaning	Domain / type
$T$	Linear transformation	The map $T \colon U \to V$ whose kernel is under study	function from U to V
$K (T)$	Kernel	The set of domain vectors sent to the zero vector	subspace of U
$U$	Domain	The vector space of inputs; the kernel is a subspace of this space	vector space over C
$V$	Codomain	The vector space of outputs, containing the target zero vector	vector space over C
$\vec{u}$	Input vector	A candidate element of the kernel or of a preimage	element of U
$\vec{z}$	Kernel vector	An element of $\mathcal{K}(T)$ , used to translate one solution into all solutions	element of K(T)
$A$	Matrix of the transformation	Coefficient matrix when $T(\vec{x}) = A\vec{x}$	m x n matrix
$T^{- 1} (\vec{v})$	Preimage of a vector	All inputs mapping to $\vec{v}$ ; empty, or a translate of the kernel	subset of U
$n$	Domain dimension	Number of input coordinates; bounds the kernel dimension from above	positive integer

Worked Numerical Example

Problem statement

A four-joint planar manipulator carries a tool whose velocity is described by three quantities: two translation rates and one rotation rate. In a particular pose the Jacobian relating joint rates to tool velocity is the matrix $B$ below. Compute the kernel of the associated transformation, interpret it as the space of self-motions, and describe every joint-rate command that produces one specified tool velocity.

Set up the transformation
The map from joint rates to tool velocity is $T \colon \mathbb{C}^4 \to \mathbb{C}^3$ with $T(\vec{u}) = B\vec{u}$ :
$B = [\begin{matrix} 1 & 2 & 0 & - 1 \\ 2 & 4 & 1 & 1 \\ - 1 & - 2 & 1 & 4 \end{matrix}]$
Write the kernel condition
A joint-rate vector $\vec{u}$ lies in $\mathcal{K}(T)$ when it produces no tool motion at all, that is when $B\vec{u} = \vec{0}$ . Component by component this is a homogeneous system of three equations in the four unknowns $u_1, u_2, u_3, u_4$ .
$u_{1} + 2 u_{2} - u_{4} = 0, 2 u_{1} + 4 u_{2} + u_{3} + u_{4} = 0, - u_{1} - 2 u_{2} + u_{3} + 4 u_{4} = 0$
Row-reduce the coefficient matrix
Apply $R_2 \to R_2 - 2R_1$ and $R_3 \to R_3 + R_1$ , which produce identical rows $(0, 0, 1, 3)$ ; subtracting one from the other clears the third row entirely.
$[\begin{matrix} 1 & 2 & 0 & - 1 \\ 0 & 0 & 1 & 3 \\ 0 & 0 & 0 & 0 \end{matrix}]$
Identify pivot and free columns
Leading ones sit in columns 1 and 3, so $\operatorname{rank}(B) = 2$ and the free variables are $u_2$ and $u_4$ . The kernel therefore has dimension $4 - 2 = 2$ . Note that the rank is only $2$ , not $3$ : in this pose the manipulator is also singular, and the tool cannot be driven in every direction.
Extract a basis
Set $u_2 = 1, u_4 = 0$ for the first basis vector, then $u_2 = 0, u_4 = 1$ for the second, reading $u_1$ and $u_3$ from the two pivot rows:
$K (T) = span ({[\begin{matrix} - 2 \\ 1 \\ 0 \\ 0 \end{matrix}], [\begin{matrix} 1 \\ 0 \\ - 3 \\ 1 \end{matrix}]})$
Verify against the original matrix
Substitute both candidates into $B$ , not into the reduced form. First vector: $(-2 + 2,\ -4 + 4,\ 2 - 2) = (0,0,0)$ . Second vector: $(1 - 1,\ 2 - 3 + 1,\ -1 - 3 + 4) = (0,0,0)$ . Both check, so the basis is correct and $T$ is not injective.
Describe a full preimage
Take the joint-rate command $\vec{u}_0 = (1, 1, 1, 1)$ . Then $B\vec{u}_0 = (2, 8, 2)$ , so this command produces the tool velocity $\vec{v} = (2, 8, 2)$ . Every command producing that same tool velocity is $\vec{u}_0$ plus an arbitrary kernel vector:
$T^{- 1} (\vec{v}) = [\begin{matrix} 1 \\ 1 \\ 1 \\ 1 \end{matrix}] + α [\begin{matrix} - 2 \\ 1 \\ 0 \\ 0 \end{matrix}] + β [\begin{matrix} 1 \\ 0 \\ - 3 \\ 1 \end{matrix}], α, β \in ℂ$
Spot-check a second member of the preimage
Taking $\alpha = 1$ and $\beta = 0$ gives $(-1, 2, 1, 1)$ . Evaluating: $-1 + 4 + 0 - 1 = 2$ ; $-2 + 8 + 1 + 1 = 8$ ; $1 - 4 + 1 + 4 = 2$ . The tool velocity is unchanged, confirming the coset description.

Result

The kernel is two-dimensional, so the manipulator has two independent self-motions in this pose: whole families of joint-rate commands hold the tool perfectly still. Any commanded tool velocity that is achievable at all is achievable by a two-parameter family of joint-rate vectors, and those two parameters are exactly the freedom a redundancy-resolution scheme has to spend on secondary objectives such as avoiding joint limits. The rank deficiency also signals that this pose is singular, so not every tool velocity is achievable in the first place.

Applications & Industry Use

Robotics

Self-motion of redundant manipulators

The kernel of the manipulator Jacobian is the space of joint velocities that generate no end-effector motion. Redundancy-resolution schemes project a secondary objective — obstacle clearance, joint-limit avoidance, torque minimisation — onto that kernel so the tool trajectory is unaffected. The dimension of the kernel is the number of free directions available.

Structural engineering

Self-stress states in indeterminate structures

For a pin-jointed structure, the kernel of the equilibrium matrix consists of member-force distributions in equilibrium with zero external load. Its dimension is the degree of static indeterminacy, and its basis vectors are the prestress patterns available to a designer of cable nets and tensegrity structures.

Signal processing

Blind directions of a filter bank

A linear analysis stage maps a signal block to a coefficient vector. Signals in the kernel are annihilated entirely and cannot be reconstructed downstream. Characterising the kernel identifies exactly which signal content the front end discards, which is essential when designing an anti-aliasing or decimation stage.

Control systems

Unobservable subspace

The kernel of the observability matrix is the set of initial states producing an identically zero output. States differing by an element of that kernel are indistinguishable to any observer, no matter how long the record. Its dimension quantifies how much of the state must be handled by other means.

Chemical engineering

Independent reaction directions

The kernel of the atomic composition matrix contains the stoichiometric vectors that conserve every element. A basis for that kernel is a maximal set of independent balanced reactions, and its dimension tells the process engineer how many reaction extents are needed to describe the chemistry completely.

Statistics & machine learning

Unidentifiable parameter directions

In a linear model, the kernel of the design matrix consists of parameter shifts that leave every fitted value unchanged. Coefficients are determined only modulo that kernel, which is precisely why dummy-variable traps and collinear predictors make individual coefficient estimates meaningless while leaving predictions intact.

Design Considerations

Report a basis, not a description

Because the kernel is a subspace it always admits a finite basis, and the basis is far more useful than a verbal statement that a redundancy exists. Downstream code needs vectors to project onto; a sentence cannot be projected onto. Always deliver the kernel as an explicit list of spanning vectors together with its dimension.

Choose the basis for the job

The basis obtained from row reduction has ones and zeros in the free positions, which makes each vector easy to interpret as the effect of one free variable. An orthonormal basis from a singular value decomposition is better conditioned and better suited to projection. Neither is canonical — only the subspace they span is — so state which convention a reported basis follows.

Kernel dimension is discontinuous

Perturbing the entries of a matrix by an arbitrarily small amount can shrink the kernel to nothing. A physically redundant system will often present a numerically empty kernel because measured coefficients are not exact. The reliable numerical statement is not the dimension but the list of small singular values, together with the threshold used to declare them negligible.

Do not confuse the kernel with the range

The kernel is a subspace of the domain; the range is a subspace of the codomain. They generally live in different spaces of different dimensions, and no inclusion between them is meaningful unless domain and codomain coincide. Mixing them is the most common structural error in this part of the subject.

Use the coset structure to organise solutions

Once a kernel basis is available, solving $T(\vec{u}) = \vec{v}$ for many different right-hand sides requires only one particular solution each; the free part is reusable. Structuring a solver this way avoids recomputing the homogeneous part and makes the parameterisation of the answer explicit rather than implicit.

A trivial kernel is a design goal, not an accident

If a model is required to be identifiable, the kernel must be forced to be trivial by construction — through sensor placement, excitation design or regularisation — rather than hoped for. Checking the kernel early in a design is cheap; discovering an unidentifiable direction after commissioning is not.

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	Prescribes the set-builder and mapping notation used for $\mathcal{K}(T) = \{\, \vec{u} \in U \mid T(\vec{u}) = \vec{0} \,\}$ , and the typographic distinction between the transformation and its argument.
`LAPACK / BLAS reference`	Linear Algebra PACKage reference implementation	The singular value decomposition driver `xGESVD` supplies an orthonormal basis for the numerical kernel through the trailing right singular vectors, which is the production route to a kernel basis.
`IEEE 754-2019`	IEEE Standard for Floating-Point Arithmetic	Defines the rounding behaviour that makes exact kernel dimension undecidable from floating-point data, forcing every numerical kernel computation to declare a tolerance.
`ISO 9283`	Manipulating industrial robots — Performance criteria and related test methods	Pose accuracy and repeatability requirements for manipulators are what redundancy resolution in the Jacobian kernel is ultimately designed to protect, by keeping self-motions away from joint limits and singularities.
`W3C WCAG 2.1 AA`	Web Content Accessibility Guidelines	Set-builder expressions and matrices on this page are published as semantic MathML with alternative text, so their content is available to screen readers rather than locked in images.

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	Symbolic or integer models where the kernel dimension is a structural fact to be certified, such as a degree of static indeterminacy.	Gives an exact dimension and an exact basis with no tolerance, but intermediate fractions grow rapidly and the method does not scale.
IEEE 754 binary64 with SVD-based kernel	Measured or estimated matrices, including robot Jacobians evaluated at a numerical pose.	Produces a well-conditioned orthonormal basis and a graded measure of near-degeneracy, at cubic cost and with a tolerance that must be justified.
IEEE 754 binary64 with pivoted QR	Larger matrices where a full SVD is uneconomical and an approximate kernel basis suffices.	Substantially cheaper and reveals dependent columns, but the resulting basis is less orthogonal and the rank decision is less robust.
Row-reduced basis with unit free variables	Hand computation, teaching, and any setting where each basis vector must be readable as the effect of one specific input.	Maximum interpretability and exactness, but the basis can be badly conditioned and is unsuitable for repeated numerical projection.
Sparse storage with a fill-reducing ordering	Very large network, finite-element or circuit models whose matrices are mostly zero.	Keeps memory tractable, but elimination causes fill-in, so a sparse QR or an iterative null-space method is usually preferable to direct reduction.
Finite field arithmetic	Coding theory and combinatorial models where the kernel of a parity-check matrix is the code itself.	Exact and fast with bounded operand size; the kernel dimension over a finite field may differ from the dimension over the rationals.

Manufacturing Notes

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

Cost of computing a kernel basis

Row reduction of an $m \times n$ matrix costs on the order of $mn \min(m,n)$ operations and delivers a basis directly from the free columns. A singular value decomposition costs several times more but returns an orthonormal basis plus the singular values that quantify how nearly degenerate the matrix is. For a one-off structural question the reduction is enough; for repeated numerical projection the decomposition is worth its price.

Hand procedure

Reduce the coefficient matrix alone. For each free column in turn, set that free variable to $1$ , set all other free variables to $0$ , and read the pivot variables straight off the pivot rows — no back-substitution is required once the form is fully reduced. The number of vectors produced is the nullity, and they are automatically linearly independent because of the pattern of ones and zeros in the free positions.

Library behaviour

scipy.linalg.null_space(A, rcond=...) returns an orthonormal kernel basis from the SVD and exposes the tolerance explicitly. numpy.linalg.matrix_rank gives the complementary number. Symbolic systems expose Matrix.nullspace(), which returns the exact row-reduced basis with unit free variables. The three answers span the same subspace only when the numerical tolerance is chosen consistently with the exact structure.

Verification discipline

Check every candidate kernel vector against the original matrix, never against its reduced form. Two independent checks are worth the effort: confirm that each basis vector is annihilated, and confirm that the count of basis vectors equals $n$ minus the rank. A slip in elimination usually breaks one of the two.

Projecting onto the kernel

Applications that exploit redundancy need the projector onto $\mathcal{K}(T)$ , not merely a basis. With an orthonormal basis $Z$ from the SVD, the projector is $Z Z^{*}$ ; equivalently, for a matrix transformation it is $I - A^{+}A$ where $A^{+}$ is the pseudoinverse. Building the projector from a badly conditioned row-reduced basis instead of an orthonormal one is a common source of drift in iterative redundancy-resolution loops.

Failure Modes & Common Mistakes

Failure modes, root causes and prevention
Failure mode / mistake	Impact	Root cause	Prevention & detection
Placing the kernel in the codomain	high	Confusing the kernel with the range, or with the set of zero outputs viewed as living in $V$ .	The kernel is defined by a condition on inputs, so it is a subspace of the domain. Check the dimensions of the two spaces if in doubt.
Reporting the empty set as the kernel	medium	Writing $\mathcal{K}(T) = \emptyset$ when only the zero vector is annihilated.	The kernel always contains $\vec{0}$ , so it is never empty. The trivial case is $\mathcal{K}(T) = \{\vec{0}\}$ , a subspace of dimension zero.
Confusing nullity with the number of zero rows	medium	Counting zero rows of the reduced matrix instead of free columns.	Nullity is $n - \operatorname{rank}$ , computed from the column count of the domain. Zero rows count deficient equations, which is a different quantity unless the matrix is square.
Assuming every preimage is a subspace	medium	Generalising the subspace property of the kernel to preimages of non-zero vectors.	Only $T^{-1}(\vec{0})$ contains the origin. Other non-empty preimages are translates and are closed under neither addition nor scalar multiplication.
Declaring a numerical kernel from an exact-zero test	high	Comparing computed pivots or singular values against zero on floating-point data.	Use a tolerance scaled by the largest singular value and the machine epsilon, and report the tolerance with the result.
Treating a row-reduced basis as orthonormal	medium	Building a projector as $Z Z^{*}$ from a basis that is merely independent.	Orthonormalise first, or take the basis from the SVD, before forming any projector or performing repeated projections.
Recomputing the kernel for every right-hand side	low	Solving $T(\vec{u}) = \vec{v}$ from scratch for each new $\vec{v}$ .	The kernel does not depend on $\vec{v}$ . Compute it once, then only a particular solution is needed for each new target.
Applying the subspace argument to a non-linear map	low	Assuming the zero set of any function is a subspace.	The closure proofs use additivity and scalar-multiple preservation. Without linearity the zero set can be any shape at all.

FAQs

Is the kernel the same thing as the null space?

For a transformation defined by a matrix, $T(\vec{x}) = A\vec{x}$ , yes: $\mathcal{K}(T) = \mathcal{N}(A)$ exactly. The kernel is the more general notion because it is defined for transformations between any vector spaces, including spaces of polynomials, matrices or functions where no coefficient matrix is given in advance.

Why is the kernel always a subspace but a general preimage is not?

The subspace proof relies on the target being the zero vector: sums and scalar multiples of vectors sent to zero are still sent to zero. For a non-zero target $\vec{v}$ , the sum of two inputs maps to $2\vec{v}$ , not $\vec{v}$ , so closure fails. Non-empty preimages are translates of the kernel, which are not subspaces unless the translation is trivial.

How does the kernel let me test injectivity?

A transformation is injective if and only if its kernel is trivial. This is a strict equivalence, so it can be used in either direction: a computed non-zero kernel vector immediately produces witness pairs disproving injectivity, and a verified trivial kernel is a complete proof of injectivity.

Can the kernel be the whole domain?

Yes, when $T$ is the zero transformation that sends every input to $\vec{0}$ . Then $\mathcal{K}(T) = U$ and the nullity equals $\dim(U)$ . This is the extreme case in which the transformation carries no information whatsoever, and the rank is zero.

What does the kernel tell me about solving

T(\vec{u}) = \vec{v}

It tells you the shape of the answer. If the equation has any solution at all, the full solution set is one particular solution plus the entire kernel, so it has as many free parameters as the kernel has dimensions. A trivial kernel means the solution, if it exists, is unique.

Why does my numerical kernel come out empty for a system I know is redundant?

Because rounding in the stored coefficients perturbs an exactly dependent matrix into a nearby independent one. The honest numerical statement is that some singular values are far smaller than the largest, and the kernel dimension is whatever count of singular values falls below your declared tolerance.

How is the kernel related to the rank of a transformation?

They partition the domain dimension: the nullity plus the rank equals $\dim(U)$ . Every dimension of the domain is either carried through to the range or collapsed into the kernel, and no dimension is counted twice. This accounting is the rank-nullity relationship.

References

Beezer, R. A. A First Course in Linear Algebra, Version 0.70. University of Puget Sound, 2006. Section ILT, subsection KLT. Licensed under the GNU Free Documentation License v1.2.
ISO 80000-2:2019, Quantities and units — Part 2: Mathematics. International Organization for Standardization.
Golub, G. H. and Van Loan, C. F. Matrix Computations, 4th edition. Johns Hopkins University Press, 2013.
Siciliano, B., Sciavicco, L., Villani, L. and Oriolo, G. Robotics: Modelling, Planning and Control. Springer, 2009.
Anderson, E. et al. LAPACK Users' Guide, 3rd edition. Society for Industrial and Applied Mathematics, 1999.

AI Suggested Questions

Show me a transformation from 2x2 matrices to quadratic polynomials whose kernel has dimension two, and compute a basis for it.
How do I build the orthogonal projector onto the kernel of a Jacobian, and why should it come from the SVD rather than from row reduction?
Explain why the preimage of a non-zero vector fails the subspace test, with an explicit counterexample.
For a structural equilibrium matrix, how does the kernel dimension relate to the degree of static indeterminacy?
Compare the kernel bases returned by SymPy's nullspace and SciPy's null_space for the same integer matrix and explain the differences.
If a measured matrix has singular values 10, 4, 0.001, how should I decide whether the kernel is one-dimensional or empty?

Related Calculators

Kernel Basis Calculator

Compute a basis and dimension for the kernel of a linear transformation given by a matrix, in exact or floating-point arithmetic.

Preimage Solver

Find one particular solution of $T(\vec{u}) = \vec{v}$ and return the complete preimage as that solution plus the kernel.

Matrix Rank & Nullity Calculator

Report rank, nullity and the pivot column set with a selectable numerical tolerance.

Overview

Definition

Kernel of a Linear Transformation

Preimage of a Vector

Nullity of a Linear Transformation

Concepts

The kernel is always a subspace

Kernel and null space are the same object

Preimages are translates of the kernel

Injective if and only if the kernel is trivial

A non-trivial kernel generates collisions everywhere

The engineering meaning of kernel dimension

Computing and using a kernel

Equations

Variable Definitions

Worked Numerical Example

Problem statement

Set up the transformation

Write the kernel condition

Row-reduce the coefficient matrix

Identify pivot and free columns

Extract a basis

Verify against the original matrix

Describe a full preimage

Spot-check a second member of the preimage

Applications &amp; Industry Use

Self-motion of redundant manipulators

Self-stress states in indeterminate structures

Blind directions of a filter bank

Unobservable subspace

Independent reaction directions

Unidentifiable parameter directions

Design Considerations

Report a basis, not a description

Choose the basis for the job

Kernel dimension is discontinuous

Do not confuse the kernel with the range

Use the coset structure to organise solutions

A trivial kernel is a design goal, not an accident

Standards &amp; Codes

Material Selection

Manufacturing Notes

Cost of computing a kernel basis

Hand procedure

Library behaviour

Verification discipline

Projecting onto the kernel

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