Column Space Spanned by Original Columns

Overview

The definition of the column space presents it as the span of all $n$ columns, which is a correct but wasteful description: whenever the rank is less than $n$ , some columns are redundant and contribute nothing. What is wanted instead is a minimal spanning set — a basis — and ideally one whose members are themselves columns of the matrix rather than manufactured combinations of them.

The procedure that achieves this is short. Reduce the matrix to reduced row-echelon form, note the index set $D$ of columns containing leading ones, discard the reduced matrix, and return to the original to collect the columns indexed by $D$ . Those $r$ columns are linearly independent and span the whole column space. Everything about the selection came from the reduced form; everything in the answer came from the original.

That asymmetry is the point of the result and the source of the most common error associated with it. Row operations preserve the relationships between columns — which combinations of columns give zero — but they do not preserve the columns themselves. So the pivot columns of the reduced matrix identify which original columns are independent, while the reduced columns span an entirely different subspace. Substituting one for the other produces a set of the right size that is a basis for the wrong space.

The requirement that a basis consist of genuine columns is not aesthetic. When the columns are physical objects — feedstocks, actuators, reactions, measured predictors — a basis built from combinations of them is uninterpretable and often unrealisable, while a basis of actual columns names a subset of the real objects that is sufficient. The same demand drives interpolative and CUR decompositions in numerical linear algebra, where the value of selecting actual columns is retained sparsity, retained non-negativity and retained meaning.

Definition

Basis of the Column Space

BCS

Let $A$ be an $m \times n$ matrix with columns $\vec{A}_1, \ldots, \vec{A}_n$ , and let $B$ be a row-equivalent matrix in reduced row-echelon form with $r$ non-zero rows. Let $D = \{d_1, d_2, \ldots, d_r\}$ be the indices of the columns of $B$ containing leading ones, and set $T = \{\vec{A}_{d_1}, \vec{A}_{d_2}, \ldots, \vec{A}_{d_r}\}$ . Then

$T$ is a linearly independent set;
$\mathcal{C}(A) = \operatorname{span}(T)$ .

Read the subscripts carefully: the indices come from $B$ , the vectors come from $A$ . This is the entire content of the theorem and the single point at which it is misapplied.

Pivot and Non-Pivot Columns

A pivot column of a matrix in reduced row-echelon form is one containing a leading one; every other column is non-pivot. There are exactly $r$ pivot columns, where $r$ is the rank, and each is a column of the identity matrix. In the original matrix, the columns at pivot positions are the independent ones and those at non-pivot positions are combinations of the pivot columns to their left.

Dependency Relation from the Reduced Form

DRRF

If column $j$ of the reduced form $B$ is non-pivot, its entries are the coefficients that express the corresponding original column in terms of the earlier original pivot columns: $\vec{A}_j = \sum_{k=1}^{r} [B]_{kj}\, \vec{A}_{d_k}$ . The reduced form therefore delivers not only the selection but every redundancy relation, at no extra cost.

Concepts

Why the construction works

Row operations do not change the solution set of $A\vec{x} = \vec{0}$ , so $\mathcal{N}(A) = \mathcal{N}(B)$ . A vector in that null space is exactly a list of coefficients producing a vanishing combination of columns. Hence $A$ and $B$ have identical patterns of linear dependence among their columns: a subset of columns of $A$ is independent precisely when the correspondingly indexed subset of columns of $B$ is. Since the pivot columns of $B$ are distinct standard unit vectors and therefore independent, the corresponding columns of $A$ are independent too.

Each non-pivot column of $B$ is a combination of the pivot columns of $B$ , with coefficients read directly from that column. Transferring the same coefficients back to $A$ — legitimate because the dependency pattern is preserved — expresses every non-pivot column of $A$ as a combination of the selected columns. Any element of $\mathcal{C}(A)$ is a combination of all $n$ columns; substituting for the non-pivot ones rewrites it using only the $r$ selected columns. So the selected columns span the whole column space, and being independent as well, they form a basis.

The columns of the reduced form span a different space

It is essential that the answer uses columns of $A$ . Row reduction generally changes the column space completely: a matrix whose reduced form has three pivot columns $\vec{e}_1, \vec{e}_2, \vec{e}_3$ has $\mathcal{C}(B)$ equal to the set of vectors whose remaining entries are zero, which almost never coincides with $\mathcal{C}(A)$ . The two spaces have the same dimension, because rank is preserved, and that coincidence is what makes the error so easy to miss — the wrong answer has the right shape.

Contrast with the row space

Row operations preserve the row space exactly, since each new row is a combination of old rows and the process is reversible. So for the row space the reduced matrix may be used directly, and its non-zero rows form a basis. The column space enjoys no such convenience. This asymmetry — reduce and read off for rows, reduce and go back for columns — is worth committing to memory, because it is the practical difference between the two constructions.

The basis is not unique

Row reduction makes a specific, greedy choice: scanning left to right, it keeps each column that is not already in the span of those retained. Other subsets of columns can serve equally well. In the general case, any $r$ columns that happen to be independent form a basis of the column space. The reduction supplies one valid answer deterministically; where a particular subset is preferred for engineering reasons, the columns can be reordered before reducing, which changes which subset is selected.

Rank, dimension and what the count means

The number of selected columns is $r = \operatorname{rank}(A)$ , which is therefore both the number of non-zero rows of the reduced form and the dimension of the column space. Interpreted in an application, $r$ is the number of genuinely independent objects among the $n$ on offer — independent reactions, independent load cases, non-redundant predictors — and $n - r$ is the count of redundancies, each of which the reduced form makes explicit.

The numerical counterpart

Exact row reduction makes a discontinuous choice: an arbitrarily small perturbation can move a pivot and change the selected subset entirely. The numerically respectable version of this procedure is a column-pivoted QR factorisation, which selects columns greedily by largest remaining norm and produces a permutation identifying a well-conditioned subset. Interpolative decompositions extend the idea, approximating the whole matrix using a small number of its actual columns with a bounded coefficient matrix.

Procedure: extracting a basis of original columns

Keep the original matrixWork on a copy. The original columns are the answer, so overwriting

A

during reduction destroys the result before it is read.

Reduce to reduced row-echelon formApply Gauss-Jordan elimination to

A

alone. No augmented column is involved — this construction is about the matrix, not about any particular system.

Record the pivot indices $D$ Scan the reduced matrix for leading ones and note the column index of each. There are exactly

r

of them, and

r

is the rank.

Return to the original and selectTake columns

d_1, \ldots, d_r

A

. Discard the reduced matrix at this point; its columns are not part of the answer.

Read the dependency relationsEach non-pivot column of the reduced form lists the coefficients expressing the corresponding original column in terms of the selected ones. Verify one of them by direct substitution.

Equations

Pivot index set

EQ-CSSOC-01

D = {d_{1}, d_{2}, \dots, d_{r}}, 1 \leq d_{1} < d_{2} < \dots < d_{r} \leq n

The ordered indices of the columns of the reduced form containing leading ones. The count $r$ is the rank of the matrix.

The selected basis

EQ-CSSOC-02

T = {{\vec{A}}_{d_{1}}, {\vec{A}}_{d_{2}}, \dots, {\vec{A}}_{d_{r}}}, C (A) = span (T)

Indices from the reduced matrix, vectors from the original. The set is linearly independent and spans the whole column space.

Dimension of the column space

EQ-CSSOC-03

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

A basis fixes the dimension. This identifies rank, the number of non-zero rows of the reduced form and the size of the minimal spanning set as one quantity.

Dependency relation for a non-pivot column

EQ-CSSOC-04

Dependency relation for a non-pivot column

The entries of a non-pivot column of the reduced form are exactly the coefficients that rebuild the corresponding original column from the selected ones.

Preserved null space, preserved dependencies

EQ-CSSOC-05

N (A) = N (B) \Rightarrow same dependence pattern among columns

The mechanism behind the theorem. Row operations preserve which combinations of columns vanish, which is why a selection made on $B$ is valid for $A$ .

The column spaces are generally different

EQ-CSSOC-06

C (A) \neq C (B) in general, but \dim C (A) = \dim C (B)

Equal dimensions, different subspaces. This is precisely why the answer must be assembled from the original columns.

Matrix form of the selection

EQ-CSSOC-07

A P = [A_{D} ∣ A_{F}], A_{F} = A_{D} W

Permuting the selected columns to the front exhibits the remaining columns as $A_D W$ for a coefficient matrix $W$ read from the reduced form. This is the exact form of an interpolative decomposition.

Variable Definitions

Symbols used on this page
Symbol	Name	Meaning	Domain / type
$A$	Original matrix	The matrix whose column space is being described	m x n matrix
$B$	Reduced form	The reduced row-echelon form of $A$ , used only to locate pivots and coefficients	m x n matrix
${\vec{A}}_{j}$	Column of A	The $j$ -th original column, a candidate basis member	element of C^m
$D$	Pivot index set	Indices of the columns of $B$ holding leading ones	subset of 1..n
$r$	Rank	Number of pivot columns; dimension of the column space	0 to min(m,n)
$T$	Basis	The selected original columns, independent and spanning	subset of C^m
$C (A)$	Column space	Span of all columns of $A$ ; the set being given a basis	subspace of C^m
$N (A)$	Null space	Preserved by row operations; the reason the dependency pattern survives reduction	subspace of C^n
$W$	Coefficient matrix	Expresses the non-selected columns in terms of the selected ones	r x (n-r) matrix

Worked Numerical Example

Problem statement

A structure is instrumented at four locations. Five candidate excitation patterns are available in the laboratory, and the measured response to each is recorded as a column of a $4 \times 5$ matrix. Determine the smallest set of actual excitation patterns whose responses span every response the rig can produce, and express the discarded patterns in terms of the retained ones.

Assemble the response matrix
Each column holds the four measured responses to one excitation pattern. All five patterns are physically realisable, so any basis chosen must consist of real columns — a fictitious combination of patterns cannot be applied to the rig.
$A = [\begin{matrix} 1 & 0 & 2 & 1 & 2 \\ 0 & 1 & - 1 & 1 & 1 \\ 2 & 1 & 3 & 0 & 2 \\ 1 & 2 & 0 & 0 & 1 \end{matrix}]$
Reduce to reduced row-echelon form
Row-reduce $A$ alone; no right-hand side is involved. Three non-zero rows appear, so $\operatorname{rank}(A) = 3$ : only three of the five patterns are independent, and the response space is a three-dimensional subspace of $\mathbb{C}^4$ .
$Reduce to reduced row-echelon form$
Record the pivot columns
Leading ones sit in columns $1$ , $2$ and $4$ , so $D = \{1, 2, 4\}$ . Columns $3$ and $5$ are non-pivot, which marks excitation patterns $3$ and $5$ as redundant. Note that this is the only information taken from $B$ .
$D = {1, 2, 4}, r = | D | = 3$
Return to the original matrix
Collect columns $1$ , $2$ and $4$ of $A$ — not of $B$ . These three genuine excitation patterns form a basis of the response space.
$T = {[\begin{matrix} 1 \\ 0 \\ 2 \\ 1 \end{matrix}], [\begin{matrix} 0 \\ 1 \\ 1 \\ 2 \end{matrix}], [\begin{matrix} 1 \\ 1 \\ 0 \\ 0 \end{matrix}]}$
Read and verify the redundancy relations
Column $3$ of $B$ is $\begin{bmatrix} 2 & -1 & 0 \end{bmatrix}^{t}$ against the pivot rows, so $\vec{A}_3 = 2\vec{A}_1 - \vec{A}_2$ . Column $5$ is $\begin{bmatrix} 1 & 0 & 1 \end{bmatrix}^{t}$ , so $\vec{A}_5 = \vec{A}_1 + \vec{A}_4$ . Both check by direct substitution.
$2 [\begin{matrix} 1 \\ 0 \\ 2 \\ 1 \end{matrix}] - [\begin{matrix} 0 \\ 1 \\ 1 \\ 2 \end{matrix}] = [\begin{matrix} 2 \\ - 1 \\ 3 \\ 0 \end{matrix}] = {\vec{A}}_{3}, [\begin{matrix} 1 \\ 0 \\ 2 \\ 1 \end{matrix}] + [\begin{matrix} 1 \\ 1 \\ 0 \\ 0 \end{matrix}] = [\begin{matrix} 2 \\ 1 \\ 2 \\ 1 \end{matrix}] = {\vec{A}}_{5}$
Demonstrate why the reduced columns would be wrong
The pivot columns of $B$ are $\vec{e}_1$ , $\vec{e}_2$ and $\vec{e}_3$ , which span the set of vectors whose fourth entry is zero. But $\vec{A}_1$ has fourth entry $1$ , so $\vec{A}_1 \in \mathcal{C}(A)$ while $\vec{A}_1 \notin \mathcal{C}(B)$ . The two spaces both have dimension $3$ and are nevertheless different, which is exactly the trap the theorem is designed to avoid.
Note that other valid choices exist
The set $\{\vec{A}_1, \vec{A}_3, \vec{A}_4\}$ is also a basis, since $\vec{A}_2 = 2\vec{A}_1 - \vec{A}_3$ recovers the discarded column. Row reduction returns the leftmost valid choice; if pattern $3$ were cheaper to apply than pattern $2$ , reordering the columns before reducing would select it instead.
State the test programme
Applying only excitation patterns $1$ , $2$ and $4$ characterises the rig completely. The response to pattern $3$ is predicted as $2$ times the response to pattern $1$ minus the response to pattern $2$ , and the response to pattern $5$ as the sum of the responses to patterns $1$ and $4$ . Both predictions are available before any further test is run and can be used as a validation check if the tests are performed anyway.

Result

Three of the five excitation patterns suffice: the response space has dimension $3$ , and patterns $1$ , $2$ and $4$ span it. Because the basis consists of actual columns, the answer is a test programme rather than an abstraction — there is no need to synthesise a combination of excitations that the rig cannot physically apply. The reduction also supplies exact predictions for the two discarded patterns, converting $40\%$ of the planned tests into validation checks.

Applications & Industry Use

Test and validation engineering

Minimal test programmes

When each candidate test contributes a column of measured response, the pivot columns identify a minimal subset of real tests that characterises the system completely. The remaining tests are predicted exactly by the dependency relations, so they can be dropped from the schedule or retained as independent validation.

Chemical and process engineering

Independent reaction sets

The stoichiometric matrix has one column per candidate reaction. Selecting the pivot columns yields a set of genuine reactions that spans all achievable composition changes, which is what a kinetic model requires — a linear combination of reactions is not itself a reaction with a rate law.

Statistics and data science

Removing collinear predictors

Exactly collinear columns of a design matrix make the model unidentifiable. Selecting the pivot columns retains a maximal set of real predictors, keeping coefficients interpretable in the original variables — unlike principal components, which span the same space with combinations nobody can name.

Structural engineering

Choosing redundants in a primary structure

In the force method, an indeterminate structure is analysed by removing redundant members until a determinate primary structure remains. Selecting independent columns of the equilibrium matrix identifies which actual members may be released, and how many, without changing the space of resolvable load patterns.

Numerical linear algebra

Interpolative and CUR decompositions

Approximating a large matrix by a small number of its own columns preserves sparsity, non-negativity and physical meaning, none of which survive a singular value decomposition. The selection is made by column-pivoted QR or randomised sampling, but the structure is exactly that of this theorem: retained columns plus a coefficient matrix.

Power systems and instrumentation

Sensor and measurement placement

With one column per candidate sensor location, the pivot columns give a minimal set of physical placements whose measurements span the observable space. Since sensors are installed at real locations, a basis of actual columns is the only kind that can be procured and mounted.

Design Considerations

Reduce a copy, never the original

The answer lives in the original matrix, so an in-place reduction destroys it. In code this means taking an explicit copy before elimination; in hand computation it means writing the reduced form beside the original rather than over it. This trivial discipline prevents the most common practical failure of the whole procedure.

Order the columns to control which are selected

Row reduction selects greedily from the left, so column order determines the outcome among equally valid choices. Where some columns are cheaper, more reliable or more interpretable, move them to the front before reducing. This is a legitimate and often decisive design lever, and it costs nothing.

Prefer pivoted QR for floating-point data

The pivot pattern of a reduced row-echelon form is discontinuous in the entries, so on measured data the selection can flip under noise far smaller than the measurement uncertainty. Column-pivoted QR chooses by largest remaining norm, produces a well-conditioned subset, and carries an explicit tolerance for the rank decision.

Distinguish exact redundancy from near redundancy

This theorem addresses exact linear dependence. Two columns that are merely highly correlated are both pivot columns, and both survive the selection while leaving the problem badly conditioned. Detecting near-dependence needs singular values or a condition estimate, and the remedy is regularisation or deliberate column removal rather than the pivot pattern.

Use the dependency relations, do not discard them

The non-pivot columns of the reduced form are not waste; they are the exact recipe for reconstructing every discarded column. In an engineering setting they are predictions that can be checked against reality, and a disagreement is direct evidence that the linear model is incomplete.

Remember that this basis need not be orthogonal

The selected columns are independent but generally far from orthogonal, so coordinates relative to them still require a linear solve. Where repeated projection onto the column space is needed, follow the selection with Gram-Schmidt or a QR factorisation — at the cost of losing the property that the basis vectors are actual columns.

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
`LAPACK / BLAS reference`	Linear Algebra PACKage reference implementation	`xGEQP3` performs QR with column pivoting and returns the permutation identifying a well-conditioned subset of original columns — the numerically robust counterpart of the pivot selection described here.
`ISO 80000-2`	Quantities and units — Part 2: Mathematics	Standardises index sets, subscript conventions and the notation for a span, all of which are needed to state precisely that indices come from one matrix and vectors from another.
`IEEE 754-2019`	IEEE Standard for Floating-Point Arithmetic	Rounding makes exact linear dependence practically undetectable, so the pivot pattern computed in floating point is a tolerance-dependent judgement rather than a property of the data.
`ISO 5725`	Accuracy (trueness and precision) of measurement methods and results	Measured columns carry uncertainty, and any claim that one column is exactly a combination of others must be assessed against that uncertainty rather than against exact arithmetic.
`ISO/IEC 40314`	Mathematical Markup Language (MathML) Version 3.0	Encodes the subscripted index notation $\vec{A}_{d_k}$ semantically, so the distinction between the selection index and the column it selects survives into machine-readable form.

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 matrices where exact dependence is meaningful, such as stoichiometry and combinatorial models.	The pivot pattern and the dependency coefficients are exact and reproducible; but coefficient growth limits practical size, and the answer is brittle if the entries were themselves rounded measurements.
IEEE 754 binary64 with column-pivoted QR	Measured or estimated data of moderate size.	Selects a well-conditioned subset with a documented rank tolerance, at roughly twice the cost of an unpivoted factorisation; the selected subset may differ from the leftmost-greedy one.
Singular value decomposition for the rank, QR for the selection	Rank is uncertain and the subset must be defensible.	The most reliable rank determination available, followed by a selection of actual columns; costs roughly ten times an LU factorisation but removes the main source of disputed results.
Randomised interpolative decomposition	Very large matrices where only an approximate basis of columns is needed.	Cost grows nearly linearly in the number of entries and the selected columns come with a bounded coefficient matrix; the result is probabilistic and the failure probability must be stated.
Sparse storage with sparse QR	Large structured matrices from networks, finite elements or circuits.	Selecting original columns preserves sparsity exactly, which is a decisive advantage over any method producing dense combinations; fill-in during factorisation still requires a good ordering.
Finite field arithmetic	Coding theory and combinatorial designs, where columns are drawn from a finite field.	Dependence is exact and cheap to test with no tolerance at all, but the pivot pattern over a finite field may differ from the pattern over the rationals for the same integer matrix.

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 procedure

The dominant cost is the reduction itself, about $\tfrac{2}{3}mn^{2}$ operations for a dense $m \times n$ matrix, after which the selection is free: it is a scan of the reduced matrix for leading ones. Extracting the chosen columns is a copy of $m r$ entries. There is no cheaper way to obtain both the pivot pattern and the dependency coefficients in one pass.

Hand procedure

Write the original matrix at the top of the page and reduce underneath it, so the two remain visible together. Circle the leading ones and write their column indices as a list before doing anything else. Then draw the answer by copying columns from the top matrix. Physically separating the two matrices on the page is the most effective guard against selecting from the wrong one.

Library behaviour

SymPy's Matrix.columnspace returns original columns exactly as this theorem prescribes, and rref returns the pivot tuple alongside the reduced matrix. NumPy offers no reduced row-echelon form at all; the idiomatic route is scipy.linalg.qr(A, pivoting=True), taking the first $r$ entries of the permutation vector as the selected column indices. MATLAB's rref returns pivot indices as a second output for the same purpose.

Verification technique

Two checks confirm the result. For independence, reduce the $m \times r$ matrix of selected columns and confirm that every one of its columns is a pivot column. For spanning, verify that each discarded column satisfies its predicted dependency relation by direct substitution into the original matrix — not the reduced one, since an arithmetic slip during reduction leaves a self-consistent but wrong result.

Why the pivot pattern is fragile

Consider a matrix with a column that is exactly a multiple of another. Perturbing one entry by $10^{-16}$ makes the pair independent, raises the rank by one, and changes the selected subset. Exact reduction therefore reports a different answer for data that is physically identical. This is the whole argument for rank-revealing factorisations with explicit tolerances in any pipeline that consumes measurements.

Failure Modes & Common Mistakes

Failure modes, root causes and prevention
Failure mode / mistake	Impact	Root cause	Prevention & detection
Taking the columns of the reduced matrix	high	Reading the basis off $B$ instead of returning to $A$ , producing a set of the correct size that spans the wrong subspace.	Use $B$ only to obtain the index set $D$ ; write those indices down and then copy columns from the original matrix.
Reducing the matrix in place	high	Overwriting $A$ during elimination, so the original columns no longer exist when the selection is made.	Reduce a copy. In code this means an explicit clone; on paper it means writing the reduced form below the original.
Assuming the pivots are the first $r$ columns	medium	Generalising from examples where the leading columns happen to be independent.	Record $D$ explicitly from the reduced matrix rather than inferring positions; non-pivot columns can appear anywhere, including in the first position when a column is zero.
Confusing the row-space and column-space constructions	medium	Applying the row-space rule — take the non-zero rows of the reduced form — to columns, or vice versa.	Remember the asymmetry: row operations preserve the row space so $B$ may be used directly, but destroy the column space so $A$ must be revisited.
Treating the selected subset as the only valid basis	low	Assuming the reduction produces a canonical answer, when it merely produces the leftmost greedy one.	State that any $r$ independent columns form a basis; reorder the columns before reducing when a particular subset is preferred.
Applying the exact procedure to noisy data	high	Row-reducing measured columns in floating point and treating the resulting pivot pattern as a physical fact.	Use column-pivoted QR or a singular value decomposition with an explicit tolerance, and report the tolerance with the selection.
Ignoring near-dependence	medium	Concluding that all pivot columns are healthy when two of them are nearly parallel, leaving the basis badly conditioned.	Check the condition number or the smallest singular value of the selected submatrix, not merely its rank.
Discarding the dependency coefficients	low	Recording only which columns were removed, losing the exact relations that reconstruct them.	Save the non-pivot columns of the reduced form as the coefficient matrix $W$ ; they are the reconstruction recipe and cost nothing extra to retain.

FAQs

Why must the basis be built from columns of the original matrix?

Because row operations change the column space. They preserve which combinations of columns vanish, which is how the reduced form correctly identifies which columns are independent, but the reduced columns themselves span a different subspace of the same dimension. Using them gives a set of the right size that is a basis for the wrong space.

How do I know the selected columns really span the whole column space?

Because every non-pivot column of the reduced form is a combination of its pivot columns, and the coefficients transfer unchanged to the original matrix. So each discarded column of $A$ is a combination of the selected ones, and any element of $\mathcal{C}(A)$ can be rewritten using only the selection.

Is the basis produced by this method unique?

No. Row reduction makes a greedy left-to-right choice, but in general many subsets of $r$ columns are independent and any of them is a valid basis. If a particular subset is preferred — because those columns are cheaper, more accurate or more meaningful — permute the columns before reducing and the selection will change accordingly.

Why can I use the reduced matrix directly for the row space but not for the column space?

Because row operations replace each row by a combination of rows, and the process is reversible, so the span of the rows is unchanged. Nothing analogous is done to the columns: they are altered entry by entry, and their span moves. The row space survives reduction; the column space does not.

What does this construction give me beyond a basis?

Every dependency relation. Each non-pivot column of the reduced form lists the coefficients that rebuild the corresponding original column from the selected ones. In an application those are quantitative predictions about the discarded objects, available at no extra cost and checkable against measurement.

Can I use this procedure on floating-point measurement data?

Only with care. The pivot pattern is discontinuous in the entries, so a rounding error can promote a dependent column to independent and change the answer. The numerically defensible alternative is a column-pivoted QR factorisation or a singular value decomposition with a stated tolerance, both of which still return actual columns.

How does this relate to reducing a general spanning set?

It is the same construction applied to a specific spanning set. Given any finite set of vectors, make them the columns of a matrix, reduce, and keep the vectors at pivot positions; the result is an independent subset with the same span. The column space case is simply the version where the matrix already exists.

References

Beezer, R. A. A First Course in Linear Algebra, Version 0.70. University of Puget Sound, 2006. Section CRS, subsection CSSOC. 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.
Martinsson, P.-G. and Tropp, J. A. Randomized Numerical Linear Algebra: Foundations and Algorithms. Acta Numerica, 2020.
Mahoney, M. W. and Drineas, P. CUR Matrix Decompositions for Improved Data Analysis. Proceedings of the National Academy of Sciences, 2009.
Anderson, E. et al. LAPACK Users' Guide, 3rd edition. Society for Industrial and Applied Mathematics, 1999.

AI Suggested Questions

Give me a matrix where the column space of the reduced row-echelon form is disjoint from the column space of the original except at the zero vector.
Show how permuting the columns before row reduction changes which subset is selected, on a matrix of rank 2 with four columns.
Compare the subset chosen by row reduction with the subset chosen by column-pivoted QR on a matrix with two nearly parallel columns.
Derive the coefficient matrix of an interpolative decomposition from the reduced row-echelon form and explain the bound on its entries.
Why does preserving the null space under row operations guarantee that the same columns are independent before and after reduction?
How would I choose a minimal set of physical sensors from a candidate list so that the selected submatrix is also well conditioned?

Related Calculators

Column Space Basis Calculator

Row-reduce a matrix, report the pivot index set, and return the corresponding original columns together with every dependency relation.

Column Subset Selector

Choose a well-conditioned subset of original columns by pivoted QR, with a selectable rank tolerance and a condition number for the selection.

Matrix Rank & Nullity Calculator

Compute rank, nullity and the pivot column set, with a comparison between exact and tolerance-based rank determination.