Casting Out Vectors: Reducing a Spanning Set

Q: Why can I keep the original vectors rather than the reduced columns?

Because row operations preserve linear relationships among columns but not the columns themselves. The reduced form tells you which columns are independent and how the others depend on them, and those facts transfer back to the original matrix. The reduced columns span a different subspace entirely and are never the answer.

Q: Does the answer change if I reorder the vectors?

The subspace does not change and the size of the retained set does not change, but which vectors are retained usually does. Reduction retains a column only when it is independent of everything to its left, so earlier vectors are favoured. Order the list deliberately if some vectors are preferable to keep.

Q: How is this different from removing dependent vectors one at a time?

It gives the same kind of result with one reduction instead of many, and it avoids the trap of using a single relation to justify multiple removals. The canonical relation attached to each free column has a zero coefficient on every other free column, so all removals are simultaneously valid.

Q: Is the retained set a basis?

Yes. It is linearly independent and spans the same subspace as the original set, which is exactly the definition of a basis for that subspace. Its size is therefore the dimension of the subspace, which equals the rank of the matrix of columns.

Q: What if the generating set is already independent?

Then every column is a pivot column, $F$ is empty, and the method retains everything. That is the correct answer: an independent generating set has no redundancy to remove, and the reduction confirms it rather than failing.

Q: Can I use this to get a basis for the column space of a matrix?

Yes, and it is the standard way to do so from the original columns. Reduce the matrix, take the columns of the original in the pivot positions, and you have a basis for the column space consisting of actual columns rather than abstract combinations — which matters whenever the columns carry physical meaning.

Q: Why do numerical libraries use pivoted QR instead?

Because the pivot pattern from row reduction is discontinuous in the entries, so rounding can change which vectors are retained. Column-pivoted QR chooses columns by decreasing residual magnitude, which is numerically stable and yields a well-conditioned retained set, at the price of losing the canonical, order-determined answer.

Overview

A generating set for a subspace is rarely economical. Vectors accumulate from measurements, from catalogue entries, from repeated design iterations, and many of them are linear combinations of the others. Removing one such redundant vector at a time is possible but tedious, and each removal invalidates the analysis that justified the next one. Casting out vectors replaces that loop with a single decision made once.

The construction is disarmingly simple. Build the matrix $A$ whose columns are the vectors of the generating set $S$ , in whatever order you choose. Reduce $A$ and note the pivot column indices $D = \{d_1, \dots, d_r\}$ . Then keep exactly the original vectors sitting in those columns and throw away every other one. The retained set $T$ is linearly independent and generates the same subspace as $S$ .

Both halves of that claim carry weight. Independence follows because any relation of linear dependence restricted to the pivot columns corresponds to a solution of the homogeneous system in which every free variable is zero — and the only such solution is the trivial one. The spanning half follows because each discarded vector can be written explicitly in terms of the retained ones, with coefficients read straight out of the reduced form.

The result is one of the workhorses of applied linear algebra. It is the mechanism behind extracting a basis for a column space from the original columns of a matrix, behind pruning redundant load cases or reaction steps, and behind converting an over-complete description of a subspace into a minimal one. Crucially, the retained vectors are members of the original set, not abstract combinations of them, so whatever physical meaning they carried survives the reduction.

Definition

Span of a Set of Vectors

SSCV

For $S = \{\vec{v}_1, \vec{v}_2, \dots, \vec{v}_n\}$ a set of column vectors from $\mathbb{C}^m$ , the span is the set of all linear combinations of its members, $\operatorname{span}(S) = \{\, \alpha_1\vec{v}_1 + \cdots + \alpha_n\vec{v}_n \mid \alpha_i \in \mathbb{C} \,\}$ . Many different sets can share a span; this page selects a distinguished small one.

Pivot Column

A column of a matrix in reduced row-echelon form that contains a leading one. The pivot indices are written $D = \{d_1, d_2, \dots, d_r\}$ with $d_1 < d_2 < \cdots < d_r$ ; the remaining indices form $F = \{f_1, \dots, f_{n-r}\}$ and correspond to the free variables.

Because the reduced row-echelon form is unique, $D$ and $F$ are determined by the matrix alone, which is what makes the selection below canonical.

Basis of a Span

Given $S = \{\vec{v}_1, \dots, \vec{v}_n\}$ with $W = \operatorname{span}(S)$ , let $A$ be the matrix with these vectors as columns and let $D$ be the pivot column indices of its reduced row-echelon form. The basis of the span extracted from $S$ is

$T = \{\, \vec{v}_{d_1},\ \vec{v}_{d_2},\ \dots,\ \vec{v}_{d_r} \,\}$

This set is linearly independent and satisfies

\operatorname{span}(T) = W

The vectors in $T$ are the original vectors, unmodified. The reduced form is only used to decide which indices to keep.

Concepts

One relation per free variable

Each free column supplies exactly one canonical relation of linear dependence. Set that free variable to $1$ , set every other free variable to $0$ , and read the dependent variables off the reduced rows. The resulting coefficient vector is a solution of the homogeneous system, and by the correspondence between homogeneous solutions and relations on the columns, it is a relation of linear dependence on $S$ .

That relation has coefficient $1$ on the free column's own vector and coefficient $0$ on every other free column's vector. It can therefore always be solved for that one vector, and never accidentally involves another discarded vector. This is why all $n-r$ removals can be carried out from a single reduction rather than one at a time.

Discarded vectors, written explicitly

Rearranging the relation associated with free column $f_k$ gives $\vec{v}_{f_k} = [B]_{1,f_k}\vec{v}_{d_1} + [B]_{2,f_k}\vec{v}_{d_2} + \cdots + [B]_{r,f_k}\vec{v}_{d_r}$ . The coefficients are literally the entries of column $f_k$ of the reduced form, read top to bottom and matched against the pivot vectors in order.

This is the practical payoff and the audit trail. Every removal comes with an explicit formula reconstructing the removed vector from the survivors, so the claim "nothing was lost" is not an assertion but a computation that can be checked entrywise.

Why the retained set is independent

Start with a relation $\alpha_1\vec{v}_{d_1} + \cdots + \alpha_r\vec{v}_{d_r} = \vec{0}$ among the retained vectors only. Pad it with zero coefficients on all the discarded vectors; this changes nothing. The padded coefficient vector is now a solution of the homogeneous system $A\vec{x} = \vec{0}$ in which every free variable equals zero.

But in the vector form of the solution set, a solution is determined entirely by its free variables. Setting them all to zero gives the trivial solution and nothing else. Hence every $\alpha_i = 0$ , and the retained set is linearly independent. The argument uses no arithmetic at all — only the structure of the solution set.

Why the span is unchanged

One inclusion is immediate: $T \subseteq S$ , so every combination of $T$ is a combination of $S$ and $\operatorname{span}(T) \subseteq \operatorname{span}(S)$ . For the reverse, take any $\vec{w} \in \operatorname{span}(S)$ and write it with the terms grouped as pivot vectors plus discarded vectors.

Replace each discarded $\vec{v}_{f_k}$ by its expression in the retained vectors and collect coefficients. The result is a linear combination of $T$ alone, so $\vec{w} \in \operatorname{span}(T)$ . Both inclusions hold, and the two sets are equal. Note that all $n - r$ substitutions are performed simultaneously, which is exactly what removing vectors one at a time obscures.

The size of the result is the rank

The retained set has $r$ elements, where $r$ is the number of pivot columns and therefore the rank of $A$ . Because $T$ is an independent spanning set, $r$ is the dimension of the subspace generated by $S$ . This is precisely the statement that the rank of a matrix equals the dimension of its column space.

The count is also a hard lower bound: no set of fewer than $r$ vectors can span the subspace, so the reduction is not merely a shrinkage but an optimal one. Any further removal loses part of the span.

Canonical, but only one of many valid answers

Uniqueness of the reduced row-echelon form means the index set $D$ — and therefore the set $T$ — is determined by $S$ together with the order in which the vectors were placed as columns. Two people following this procedure on the same ordered list get the same answer, which makes the result reproducible and testable.

It is not, however, the only independent subset with the right span. Reordering the columns typically selects a different subset; other algorithms such as column-pivoted QR select yet another, chosen for numerical conditioning rather than for lexicographic priority. All are correct; they differ in which physical vectors survive.

Procedure: cast out the redundant vectors

Order and assembleDecide the order of the vectors — earlier vectors are preferentially retained — and form the matrix

A

with them as columns.

Reduce to $B$ Row-reduce

A

to reduced row-echelon form. Record the number of non-zero rows

r

and the pivot index set

D

Retain the pivot vectorsKeep the original vectors

\vec{v}_{d_1}, \dots, \vec{v}_{d_r}

unmodified. Do not use the reduced columns themselves.

Write out each discarded vectorFor each free index

f_k

, express

\vec{v}_{f_k}

using the entries of column

f_k

B

as coefficients on the retained vectors.

Verify the reconstructionsCheck each expression entrywise against the original vector. This confirms both the reduction and the coefficient bookkeeping.

Report the basisThe retained set is linearly independent, spans the same subspace, and has size

r

, which is the dimension of that subspace.

Equations

Matrix of columns and its reduced form

EQ-COV-01

A = [{\vec{v}}_{1} ∣ {\vec{v}}_{2} ∣ \dots ∣ {\vec{v}}_{n}] \to B = RREF (A), D = {d_{1}, \dots, d_{r}}, F = {f_{1}, \dots, f_{n - r}}

The single computation the whole method rests on. The pivot indices $D$ decide what is kept and the free indices $F$ decide what is cast out.

The retained set

EQ-COV-02

T = {{\vec{v}}_{d_{1}}, {\vec{v}}_{d_{2}}, {\vec{v}}_{d_{3}}, \dots, {\vec{v}}_{d_{r}}}

Original vectors, selected by index. Nothing is scaled, combined or modified.

Canonical relation from free column $f_k$

EQ-COV-03

Canonical relation from free column $f_k$

Obtained by setting free variable $x_{f_k} = 1$ and all other free variables to zero. The coefficient $1$ on $\vec{v}_{f_k}$ guarantees the relation can be solved for that vector.

Each discarded vector in terms of the retained ones

EQ-COV-04

{\vec{v}}_{f_{k}} = [B]_{1, f_{k}} {\vec{v}}_{d_{1}} + [B]_{2, f_{k}} {\vec{v}}_{d_{2}} + \dots + [B]_{r, f_{k}} {\vec{v}}_{d_{r}}

The coefficients are the entries of column $f_k$ of the reduced form, taken in order against the pivot vectors.

Span preservation

EQ-COV-05

span (T) = span (S) = W

The retained set generates exactly the subspace the original set generated, no more and no less.

Size of the retained set

EQ-COV-06

| T | = r = rank (A) = \dim (W)

Because $T$ is both independent and spanning, its size is the dimension of the subspace, and no smaller generating set exists.

Uniqueness of coordinates over the retained set

EQ-COV-07

\vec{w} = \sum_{i}^{=} γ_{i} {\vec{v}}_{d_{i}} with the scalars γ_{i} uniquely determined by \vec{w}

A consequence of independence: over the original dependent set the coefficients were not unique, and over $T$ they are.

Variable Definitions

Symbols used on this page
Symbol	Name	Meaning	Domain / type
$S$	Original generating set	The $n$ vectors whose span is to be described more economically	finite subset of C^m
$T$	Retained set	The subset of $S$ indexed by the pivot columns; independent and with the same span	subset of S of size r
$A$	Matrix of columns	The $m \times n$ matrix built by using the vectors of $S$ as its columns	m x n matrix over C
$B$	Reduced form	The unique reduced row-echelon form of $A$ , source of both $D$ and the substitution coefficients	m x n matrix over C
$D$	Pivot index set	Indices of the columns containing leading ones; these vectors are retained	subset of 1..n of size r
$F$	Free index set	Indices of columns without leading ones; these vectors are cast out	subset of 1..n of size n-r
$r$	Rank	Number of pivot columns, equal to the dimension of the subspace generated	0 to min(m,n)
$W$	Generated subspace	The span of $S$ , equivalently the column space of $A$	subspace of C^m
$[B]_{k, f_{k}}$	Substitution coefficient	Entry of the reduced form giving the weight of $\vec{v}_{d_k}$ in the reconstruction of a discarded vector	complex scalar

Worked Numerical Example

Problem statement

A structural test rig can apply six catalogued load patterns to a four-node frame. The set of achievable loadings is the span of the six patterns. Reduce the catalogue to the smallest subset of the original patterns that achieves the same set, and show how each discarded pattern is reproduced.

List the catalogue
Six load patterns $\vec{v}_1$ through $\vec{v}_6$ in $\mathbb{C}^4$ , one entry per node. Write $W = \operatorname{span}(S)$ for the achievable set.
${\vec{v}}_{1} = [\begin{matrix} 1 \\ 2 \\ 0 \\ 1 \end{matrix}], {\vec{v}}_{2} = [\begin{matrix} 3 \\ 6 \\ 0 \\ 3 \end{matrix}], {\vec{v}}_{3} = [\begin{matrix} 0 \\ 1 \\ 1 \\ 0 \end{matrix}], {\vec{v}}_{4} = [\begin{matrix} 2 \\ 0 \\ 1 \\ 1 \end{matrix}], {\vec{v}}_{5} = [\begin{matrix} - 2 \\ 5 \\ - 1 \\ 0 \end{matrix}], {\vec{v}}_{6} = [\begin{matrix} 1 \\ 0 \\ 3 \\ 0 \end{matrix}]$
Assemble the matrix of columns
Six vectors from $\mathbb{C}^4$ must be dependent, since the associated homogeneous system has more unknowns than equations. The reduction will say precisely how much redundancy there is.
$A = [\begin{matrix} 1 & 3 & 0 & 2 & - 2 & 1 \\ 2 & 6 & 1 & 0 & 5 & 0 \\ 0 & 0 & 1 & 1 & - 1 & 3 \\ 1 & 3 & 0 & 1 & 0 & 0 \end{matrix}]$
Reduce and read the pivot pattern
Three non-zero rows, so $r = 3$ . Leading ones sit in columns 1, 3 and 4, giving $D = \{1, 3, 4\}$ and $F = \{2, 5, 6\}$ .
$B = [\begin{matrix} 1 & 3 & 0 & 0 & 2 & - 1 \\ 0 & 0 & 1 & 0 & 1 & 2 \\ 0 & 0 & 0 & 1 & - 2 & 1 \\ 0 & 0 & 0 & 0 & 0 & 0 \end{matrix}]$
Retain the pivot vectors
Keep the original patterns $\vec{v}_1$ , $\vec{v}_3$ and $\vec{v}_4$ exactly as they were recorded. The reduced columns are used only to select indices and to supply coefficients; they are not the answer.
$T = {[\begin{matrix} 1 \\ 2 \\ 0 \\ 1 \end{matrix}], [\begin{matrix} 0 \\ 1 \\ 1 \\ 0 \end{matrix}], [\begin{matrix} 2 \\ 0 \\ 1 \\ 1 \end{matrix}]}$
Cast out pattern 2
Column 2 of $B$ is $(3, 0, 0)$ , so the coefficients on $\vec{v}_1$ , $\vec{v}_3$ , $\vec{v}_4$ are $3$ , $0$ , $0$ . Checking: $3(1,2,0,1) = (3,6,0,3) = \vec{v}_2$ .
$Cast out pattern 2$
Cast out pattern 5
Column 5 of $B$ is $(2, 1, -2)$ . Checking entrywise: $2(1,2,0,1) + (0,1,1,0) - 2(2,0,1,1) = (2,4,0,2) + (0,1,1,0) - (4,0,2,2) = (-2,5,-1,0) = \vec{v}_5$ .
$Cast out pattern 5$
Cast out pattern 6
Column 6 of $B$ is $(-1, 2, 1)$ . Checking: $-(1,2,0,1) + 2(0,1,1,0) + (2,0,1,1) = (-1,-2,0,-1) + (0,2,2,0) + (2,0,1,1) = (1,0,3,0) = \vec{v}_6$ .
$Cast out pattern 6$
Express an arbitrary loading over the retained set
Take the loading obtained by applying all six patterns at unit weight. Substituting the three reconstructions and collecting coefficients gives weights $1 + 3 + 2 - 1 = 5$ on $\vec{v}_1$ , $1 + 1 + 2 = 4$ on $\vec{v}_3$ , and $1 - 2 + 1 = 0$ on $\vec{v}_4$ . Direct arithmetic confirms $5(1,2,0,1) + 4(0,1,1,0) = (5,14,4,5)$ .
$\vec{w} = {\vec{v}}_{1} + {\vec{v}}_{2} + {\vec{v}}_{3} + {\vec{v}}_{4} + {\vec{v}}_{5} + {\vec{v}}_{6} = [\begin{matrix} 5 \\ 14 \\ 4 \\ 5 \end{matrix}] = 5 {\vec{v}}_{1} + 4 {\vec{v}}_{3}$

Result

Three of the six catalogued patterns suffice. Patterns 1, 3 and 4 are linearly independent and generate every loading the full catalogue could generate, so the achievable set is three-dimensional and patterns 2, 5 and 6 can be retired from the rig without narrowing its capability. Each retirement is documented by an exact recipe reproducing the retired pattern from the three that remain, and because the survivors are independent, the recipe for any target loading is now unique rather than one of infinitely many.

Applications & Industry Use

Structural engineering

Minimal load case sets for certification

Certification programmes specify long lists of load cases, many of which are superpositions of others. Casting out the dependent cases yields the smallest set that still covers the full loading envelope, cutting analysis runs while leaving the covered envelope provably identical.

Chemical & process engineering

Independent reaction sets

A mechanism written with many elementary steps usually contains steps that are stoichiometric combinations of others. Retaining the pivot-column reactions produces a maximal independent reaction set, which is what determines the number of extents needed to describe every possible composition change.

Computing & data

Feature selection under exact collinearity

When design matrix columns are exactly dependent, the fitted model is unidentifiable. Retaining pivot columns removes the redundancy while keeping original, interpretable features rather than replacing them with principal components, so the resulting model still speaks in the language of the measured variables.

Computer graphics & geometry

Reducing a generator set for a subspace of deformations

Blend-shape rigs accumulate targets that overlap in their effect on the mesh. Selecting the pivot targets keeps the achievable deformation space intact while removing shapes that add nothing, which shortens artist workflows and reduces solve time in inverse-kinematic fitting.

Wireless communications

Pruning an over-complete beam codebook

Beamforming codebooks are deliberately redundant for search convenience. When a minimal exactly-equivalent codebook is required — for storage or for enumeration — casting out identifies which beam vectors are combinations of the rest and can be dropped without changing the reachable beam space.

Electrical power systems

Independent measurement channels for state estimation

Retaining pivot columns of the measurement matrix identifies a minimal channel set with the same observability. Each discarded channel comes with an explicit formula reconstructing it from the retained ones, which doubles as a consistency check on live telemetry.

Design Considerations

Column order decides which vectors survive

Reduction favours earlier columns: a column becomes a pivot column only if it is independent of everything to its left. Place vectors you want to keep — because they are cheap to apply, easy to interpret or already validated — at the front of the list. The subspace is unaffected, but the surviving subset is not.

Keep the original vectors, not the reduced columns

The reduced form is a selection device only. The pivot columns of $B$ are columns of an identity matrix and span the wrong space entirely. This is the most common conceptual error in implementing the method, and it produces an answer that is independent but has nothing to do with the original subspace.

This gives a basis, not a well-conditioned one

The retained vectors can be nearly parallel even though they are exactly independent. If the basis will be used for projection, least squares or coordinate extraction, follow the selection with a Gram-Schmidt orthogonalisation, or select columns by pivoted QR instead, which chooses for conditioning rather than for index priority.

Exact dependence versus near dependence

The method acts on exact linear dependence. Measured vectors are almost never exactly dependent, so a naive reduction will retain everything. Decide whether the question is algebraic or numerical; for the numerical case, define a rank tolerance and use a rank-revealing factorisation, then state the tolerance alongside the retained set.

Retain the reconstruction formulas

Column $f_k$ of the reduced form is the complete recipe for rebuilding discarded vector $f_k$ . Store those columns with the reduced catalogue. They allow any historical result expressed in the old generating set to be translated into the new one without redoing the reduction.

Duplicate and zero vectors are handled automatically

A repeated vector or a zero vector always lands in a free column and is cast out without special handling. There is no need to pre-screen for them, though doing so can shrink the matrix before reduction and save arithmetic on large catalogues.

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	Fixes the set, index and matrix notation used for $S$ , $T$ , $D$ and $F$ , and the upright rendering of operator names such as $\operatorname{rank}$ and $\dim$ .
`LAPACK / BLAS reference`	Linear Algebra PACKage reference implementation	Supplies `xGEQP3`, the column-pivoted QR that performs the same selection numerically and returns the retained-column permutation directly.
`BLAS Level 3`	Basic Linear Algebra Subprograms, matrix-matrix operations	Underpins the blocked elimination kernels used to reduce a large matrix of columns, and the `xGEMM` call that verifies every reconstruction in one operation.
`IEEE 754-2019`	IEEE Standard for Floating-Point Arithmetic	Governs the rounding that makes the pivot pattern — and hence which vectors are cast out — a tolerance-dependent decision on measured data.
`ISO/IEC 40314`	Mathematical Markup Language (MathML) Version 3.0	Encodes the matrices, index sets and reconstruction formulas on this page as semantic markup so they remain searchable and machine-readable.

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	The generating set is exact — stoichiometric, combinatorial or symbolic — and the retained subset must be canonical.	Gives the exact pivot pattern with no tolerance, but intermediate fractions can grow substantially on large catalogues.
Arbitrary-precision integers, fraction-free elimination	Integer vector catalogues where entry growth must stay controlled.	Bounded operand growth via Bareiss-style elimination, at the cost of an extra normalisation to recover the substitution coefficients.
IEEE 754 binary64 with a rank tolerance	Measured or simulated vector catalogues where near-dependence is the real question.	Practical and fast, but the retained subset now depends on a threshold that must be reported with the result.
Column-pivoted QR selection	Numerical work where the retained vectors will be used for projection or fitting.	Chooses well-conditioned columns and is backward stable, but the selection is not canonical and generally differs from the row-reduction choice.
Dense column-major storage	Catalogue sizes in the hundreds to low thousands of vectors.	Simple and cache-friendly for the reduction, but memory grows as $m n$ and offers no benefit when the vectors are mostly zero.
Sparse storage with fill-reducing ordering	Very large catalogues derived from incidence or connectivity structures.	Compact input representation, but elimination generates fill-in; a sparse rank-revealing QR is usually the better instrument.

Manufacturing Notes

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

Complexity and what dominates

Reducing an $m \times n$ matrix of columns costs $O(mn\min(m,n))$ operations, and everything else — selecting indices, reading substitution coefficients — is $O(rn)$ bookkeeping. Removing vectors one at a time, re-reducing after each removal, multiplies the dominant cost by $n - r$ for no additional information.

Hand procedure

Rule the reduced matrix into pivot and free columns and label them $d_1, d_2, \dots$ and $f_1, f_2, \dots$ before writing anything else. Copy each free column vertically as the coefficient list for that vector's reconstruction, pairing entry $k$ with $\vec{v}_{d_k}$ . Pairing by row number instead of by pivot index is the dominant hand error and is invisible whenever the pivots happen to start at column 1.

Library behaviour

SymPy's Matrix.columnspace and Matrix.rref implement exactly this selection over the rationals. NumPy and SciPy provide no equivalent; the standard numerical substitute is scipy.linalg.qr(A, pivoting=True), whose permutation array orders columns by decreasing importance, so the first $r$ entries name a well-conditioned retained set. MATLAB's rref returns the pivot indices as a second output for the same purpose.

Verification technique

Three checks close the loop. Confirm $|T| = r$ ; reconstruct every discarded vector from its coefficient column and compare entrywise against the original; and confirm that the matrix formed from $T$ alone reduces to a form with every column a pivot column. Together these certify both conclusions of the theorem for the specific data at hand.

Batch reconstruction as one product

Let $A_D$ be the matrix of retained columns and $B_F$ the submatrix of the reduced form consisting of the free columns restricted to the first $r$ rows. Then the discarded vectors are recovered as the single matrix product $A_D B_F$ . Verifying all reconstructions therefore reduces to one GEMM call and one comparison against the discarded columns.

Failure Modes & Common Mistakes

Failure modes, root causes and prevention
Failure mode / mistake	Impact	Root cause	Prevention & detection
Returning the reduced columns instead of the original vectors	high	Taking the pivot columns of $B$ — which are columns of an identity matrix — as the answer.	Use $B$ only to obtain the index set $D$ and the substitution coefficients. The retained vectors are the untouched columns of $A$ .
Pairing coefficients with the wrong retained vectors	high	Matching entry $k$ of a free column with $\vec{v}_k$ rather than with $\vec{v}_{d_k}$ .	Write $D$ out explicitly and index the reconstruction by $d_k$ . Verify each reconstruction entrywise before trusting it.
Assuming a different column order gives the same subset	medium	Comparing results from two tools or two runs that ordered the vectors differently and concluding one is wrong.	Compare spans, not subsets: check that both retained sets have the same size and that each reconstructs the other's vectors.
Using the retained set as if it were orthonormal	medium	Projecting onto the subspace with plain inner products against the retained vectors.	Independence does not imply orthogonality. Apply the Gram-Schmidt procedure first, or solve a least squares problem rather than projecting term by term.
Exact zero pivot test on floating-point data	high	A rounding artefact of magnitude $10^{-16}$ promoted to a pivot, so a dependent vector is retained and the reported dimension is too large.	Use a scaled tolerance relative to the matrix norm, or a rank-revealing factorisation with an explicit threshold.
Discarding a vector without recording its reconstruction	medium	Retaining only the surviving set and losing the free columns of the reduced form.	Store the free columns alongside the retained set; they are the only record of how earlier results in the old set translate to the new one.
Reducing the transpose by mistake	medium	Placing the vectors as rows, which selects independent rows and describes the row space rather than the span of the given vectors.	The vectors must be columns. If they arrive as rows, transpose before reducing and transpose the interpretation back.
Believing the result is the unique minimal subset	low	Reporting the retained set as the only possible basis drawn from the generating set.	Many subsets of the same size work. State the selection rule; only under a fixed column order is the answer canonical.

FAQs

Why can I keep the original vectors rather than the reduced columns?

Because row operations preserve linear relationships among columns but not the columns themselves. The reduced form tells you which columns are independent and how the others depend on them, and those facts transfer back to the original matrix. The reduced columns span a different subspace entirely and are never the answer.

Does the answer change if I reorder the vectors?

The subspace does not change and the size of the retained set does not change, but which vectors are retained usually does. Reduction retains a column only when it is independent of everything to its left, so earlier vectors are favoured. Order the list deliberately if some vectors are preferable to keep.

How is this different from removing dependent vectors one at a time?

It gives the same kind of result with one reduction instead of many, and it avoids the trap of using a single relation to justify multiple removals. The canonical relation attached to each free column has a zero coefficient on every other free column, so all removals are simultaneously valid.

Is the retained set a basis?

Yes. It is linearly independent and spans the same subspace as the original set, which is exactly the definition of a basis for that subspace. Its size is therefore the dimension of the subspace, which equals the rank of the matrix of columns.

What if the generating set is already independent?

Then every column is a pivot column, $F$ is empty, and the method retains everything. That is the correct answer: an independent generating set has no redundancy to remove, and the reduction confirms it rather than failing.

Can I use this to get a basis for the column space of a matrix?

Yes, and it is the standard way to do so from the original columns. Reduce the matrix, take the columns of the original in the pivot positions, and you have a basis for the column space consisting of actual columns rather than abstract combinations — which matters whenever the columns carry physical meaning.

Why do numerical libraries use pivoted QR instead?

Because the pivot pattern from row reduction is discontinuous in the entries, so rounding can change which vectors are retained. Column-pivoted QR chooses columns by decreasing residual magnitude, which is numerically stable and yields a well-conditioned retained set, at the price of losing the canonical, order-determined answer.

References

Beezer, R. A. A First Course in Linear Algebra, Version 0.70. University of Puget Sound, 2006. Section LDS, Subsection COV. 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.
Anderson, E. et al. LAPACK Users' Guide, 3rd edition. Society for Industrial and Applied Mathematics, 1999.
Trefethen, L. N. and Bau, D. Numerical Linear Algebra. Society for Industrial and Applied Mathematics, 1997.

AI Suggested Questions

Take a set of eight vectors in four dimensions, reduce it, and show which four are cast out along with their reconstruction formulas.
How does reordering the columns before reduction change which vectors survive, and can I force a particular vector to be retained?
Compare the retained subset from row reduction against the one chosen by column-pivoted QR on a badly conditioned example.
Show that the pivot columns of the original matrix form a basis for its column space, and why the pivot columns of the reduced form do not.
Given a catalogue of load cases with measurement noise, how should I set a rank tolerance before casting out cases?
Express a target vector in the span using the retained set, and explain why that representation is unique while the original one was not.

Related Calculators

Spanning Set Reducer

Cast out redundant vectors from a generating set and return the retained basis with each discarded vector's reconstruction formula.

Column Space Basis Calculator

Return a basis for the column space of a matrix drawn from its original columns, with the pivot index set.

Linear Independence Checker

Test a set of vectors for independence and return an explicit relation of linear dependence when one exists.