Row Space of a Matrix

Q: Why is the row space defined using the transpose rather than just as a set of rows?

For uniformity of type. Every other object in the theory — null space, column space, solution set — is a set of column vectors, and defining the row space as $\mathcal{C}(A^{t})$ keeps it in the same family. The practical consequence is that every theorem already proved about column spaces applies immediately to row spaces with no new arguments.

Q: Do row operations change the row space?

No. Each of the three elementary row operations produces a new set of rows whose linear combinations reach exactly the same vectors, and each operation is reversible, so the span is preserved in both directions. This is why row reduction is the natural tool for simplifying a span.

Q: Can I use the same trick to simplify a column space?

Yes, but only after transposing. Since $\mathcal{C}(A) = \mathcal{R}(A^{t})$, you transpose the matrix, reduce, discard zero rows and transpose the survivors back into column vectors. Reducing $A$ itself and taking its columns gives a different and generally wrong answer.

Q: Are the row space and column space of a square matrix the same set?

Usually not, although they always have the same dimension. They coincide for symmetric matrices, and can coincide by accident for others, but in general a square matrix has two distinct $r$-dimensional subspaces of $\mathbb{C}^n$ associated with it. Equality of dimension is a theorem; equality of sets is a coincidence.

Q: How do I test whether a vector lies in a given row space?

Reduce the matrix, note the pivot column indices $d_1, \ldots, d_r$, and read the candidate vector's entries at those positions as the required scalars. Form that linear combination of the basis vectors and compare it with the candidate. If they agree in every coordinate the vector is in the row space; if any non-pivot coordinate differs, it is not.

Q: Does the basis from the reduced form depend on how I reduced the matrix?

No. The reduced row-echelon form of a matrix is unique, so the resulting basis is completely determined by the input. This is what makes the procedure a legitimate test for equality of two spans: identical spans always produce identical reduced descriptions.

Q: What happens if the matrix has more rows than the dimension of the ambient space?

Then the rows must be linearly dependent, and reduction will produce at least $m - n$ zero rows. The row space is still a subspace of $\mathbb{C}^n$ with dimension at most $n$; the surplus rows contribute nothing and are exactly the redundancy the procedure is designed to expose.

Overview

A matrix has two natural families of vectors inside it. The columns are already column vectors and generate the column space; the rows are lists of numbers written horizontally and generate the row space. To keep every object in the library of the same type — column vectors in $\mathbb{C}^n$ — the row space is defined as the column space of the transpose. This is a bookkeeping decision, not a mathematical one, but it pays for itself immediately: every theorem already proved about column spaces transfers to row spaces with no additional work.

The two spaces are not interchangeable. For an $m \times n$ matrix the column space is a subspace of $\mathbb{C}^m$ while the row space is a subspace of $\mathbb{C}^n$ , so unless the matrix is square the two sets do not even contain objects of the same size and cannot be compared. Even for a square matrix they are usually different sets, despite always having the same dimension.

What singles the row space out is its behaviour under row reduction. Each of the three elementary row operations replaces the rows by a new set whose linear combinations reach exactly the same vectors, so row-equivalent matrices have identical row spaces. Column spaces enjoy no such protection — row reduction destroys them — and that asymmetry is the single most commonly misapplied fact in elementary matrix computation.

The payoff is a general-purpose simplification engine. Any span of vectors in $\mathbb{C}^n$ can be written as the row space of the matrix whose rows are those vectors. Reducing that matrix and discarding the zero rows returns a description of the same set using fewer vectors, guaranteed to be linearly independent, and carrying a leading-one pattern that makes membership testing almost arithmetic-free. Next to row reduction itself, this is the highest-leverage routine computation in the subject.

Definition

RSM

Let $A$ be an $m \times n$ matrix. The row space of $A$ , written $\mathcal{R}(A)$ , is the column space of the transpose: $\mathcal{R}(A) = \mathcal{C}(A^{t}) \subseteq \mathbb{C}^n$ . Informally it is the set of all linear combinations of the rows of $A$ , with each row transposed into a column vector so that the result is an object of the usual type.

For an $m \times n$ matrix, $\mathcal{C}(A) \subseteq \mathbb{C}^m$ but $\mathcal{R}(A) \subseteq \mathbb{C}^n$ . The two are not comparable unless $m = n$ , and even then they are usually distinct sets.

Row-Equivalent Matrices have Equal Row Spaces

REMRS

If $A$ and $B$ are row-equivalent matrices, then $\mathcal{R}(A) = \mathcal{R}(B)$ . The three elementary row operations — swapping two rows, scaling a row by a non-zero constant, and adding a multiple of one row to another — each produce a new set of rows whose span is unchanged, so the equality propagates through any finite sequence of operations.

Basis for the Row Space

BRS

Let $A$ be a matrix and let $B$ be a row-equivalent matrix in reduced row-echelon form. Let $S$ be the set of non-zero columns of $B^{t}$ , that is, the non-zero rows of $B$ written as column vectors. Then $\mathcal{R}(A) = \operatorname{span}(S)$ and $S$ is a linearly independent set.

Independence follows from the leading-one pattern: in the coordinate of the $i$ -th pivot column, every vector of $S$ contributes zero except the $i$ -th, which contributes $1$ . A relation of linear dependence therefore forces each scalar to be zero in turn.

Column Space, Row Space, Transpose

CSRST

For any matrix $A$ , $\mathcal{C}(A) = \mathcal{R}(A^{t})$ . This follows immediately from the definition of the row space together with $\left(A^{t}\right)^{t} = A$ , and it is what allows the row-reduction machinery to be turned around and used to produce a clean description of a column space.

Concepts

Why row operations preserve the row space

Transposing turns row operations into operations on the columns of $A^{t}$ , and the row space is the span of those columns. Swapping two columns clearly changes nothing about the set of reachable linear combinations. Scaling a column by $\alpha \ne 0$ changes nothing either, because any combination using $\alpha A_t$ can be rewritten using $A_t$ with the scalar divided by $\alpha$ — and this is precisely where the requirement $\alpha \ne 0$ earns its place. Adding $\alpha A_s$ to $A_t$ is reversed by subtracting it, so each containment can be demonstrated in both directions. Because every operation is reversible, the span is trapped between two inclusions and must be equal.

The row space is preserved; the column space is not

This asymmetry deserves to be stated bluntly, because it is the source of a persistent error. Row reduction leaves $\mathcal{R}(A)$ identical and leaves $\mathcal{N}(A)$ identical, but it moves $\mathcal{C}(A)$ . Take any matrix with no zero rows whose reduced form does have a zero row: every column of the reduced matrix then has a zero in that final coordinate, while the original matrix has columns that do not. The two column spaces cannot be equal. The correct statement for column spaces is that the pivot columns of the original matrix form a basis — the pivot positions are read from the reduced form, but the vectors are taken from the input.

Improving a span

A span presented as $\operatorname{span}(\{\vec{v}_1, \ldots, \vec{v}_k\})$ carries no guarantee of economy: the generating set may be redundant, the entries may be arbitrary, and testing whether a given vector belongs requires solving a linear system. Stack the $\vec{v}_i$ as the rows of a matrix $A$ , so that the span is exactly $\mathcal{R}(A)$ , then reduce. The non-zero rows of the reduced form describe the same set with no redundancy and with a distinguished pattern of zeros and ones. This procedure works on any span in $\mathbb{C}^n$ and is the standard way to compare two spans for equality: reduce both and compare the results.

Membership testing becomes reading

Suppose the reduced form has $r$ non-zero rows with leading ones in columns $d_1 < \cdots < d_r$ . Any vector in the row space is a unique linear combination of those rows, and because each basis vector has a $1$ in coordinate $d_i$ and zeros in the other pivot coordinates, the scalars are simply the entries of the candidate vector at positions $d_1, \ldots, d_r$ . Membership therefore reduces to forming one linear combination with known coefficients and checking the remaining $n - r$ coordinates. No system is solved and no elimination is repeated.

Turning the tool on the column space

Because $\mathcal{C}(A) = \mathcal{R}(A^{t})$ , a column space can be described by transposing the matrix, reducing, discarding zero rows and transposing the surviving rows back into columns. The result is a linearly independent spanning set for $\mathcal{C}(A)$ whose vectors carry the same convenient zero-one pattern in their leading coordinates. This description is often more useful in practice than a basis of original columns, because it makes membership of a right-hand side vector — and hence consistency of $A\vec{x} = \vec{b}$ — a matter of inspection.

Rank is visible from either side

The number of non-zero rows in the reduced form of $A$ is the rank $r$ , and by the basis theorem above it is also $\dim \mathcal{R}(A)$ . The same count is $\dim \mathcal{C}(A)$ , because the pivot columns of $A$ form a basis for the column space. That the row space and column space of the same matrix always share a dimension, despite living in different ambient spaces and generally being unequal as sets, is one of the quiet structural facts that the whole theory of rank is built upon.

Procedure: simplify a span using the row space

Stack the generators as rowsGiven

\operatorname{span}(\{\vec{v}_1, \ldots, \vec{v}_k\}) \subseteq \mathbb{C}^n

, form the

k \times n

matrix

A

whose

i

-th row is

\vec{v}_i^{\,t}

. By construction the span equals

\mathcal{R}(A)

Row-reduce to $B$ Bring

A

to reduced row-echelon form. The row space is untouched by every operation, so

\mathcal{R}(A) = \mathcal{R}(B)

Discard the zero rowsA zero row contributes the zero vector, which is never needed in a span. The remaining

r

rows still span the same set.

Transpose the survivorsWrite the

r

non-zero rows as column vectors. This set is linearly independent, by the leading-one argument, so it is a basis for the span.

Read membership directlyFor a candidate

\vec{w}

, read the coefficients off the pivot coordinates of

\vec{w}

, form the combination, and compare the remaining coordinates.

Equations

Definition of the row space

EQ-RSM-01

R (A) = C (A^{t}) \subseteq ℂ^{n}

For an $m \times n$ matrix $A$ . The transpose converts each row into a column vector so that the row space is a set of the same type as every other subspace in the library.

Row space as a span of the rows

EQ-RSM-02

R (A) = span ({{\vec{r}}_{1}, {\vec{r}}_{2}, \dots, {\vec{r}}_{m}}), [{\vec{r}}_{i}]_{j} = [A]_{i j}

The informal reading: $\mathcal{R}(A)$ collects every linear combination of the rows of $A$ .

Invariance under row equivalence

EQ-RSM-03

A \sim B \Rightarrow R (A) = R (B)

Row operations change the individual rows but never the set of vectors reachable as combinations of them. The converse implication is false: two matrices of different sizes can share a row space.

Basis from the reduced form

EQ-RSM-04

R (A) = span (S), S = {non-zero rows of RREF (A), transposed}

The set $S$ has exactly $r$ elements and is linearly independent, so it is a basis and $\dim \mathcal{R}(A) = r$ .

Column space via the transpose

EQ-RSM-05

C (A) = R (A^{t})

Transpose, reduce, discard zero rows, transpose back. This yields a linearly independent spanning set for the column space with a convenient leading-one pattern.

Row operations do not preserve the column space

EQ-RSM-06

A \sim B not \Rightarrow C (A) = C (B)

The standard counterexample is any matrix whose reduced form acquires a zero row: every vector of $\mathcal{C}(B)$ then has a zero final coordinate, which vectors of $\mathcal{C}(A)$ need not.

Equal dimensions, different ambient spaces

EQ-RSM-07

\dim R (A) = \dim C (A) = r = rank (A)

For an $m \times n$ matrix these are subspaces of $\mathbb{C}^n$ and $\mathbb{C}^m$ respectively, yet their dimensions always agree.

Variable Definitions

Symbols used on this page
Symbol	Name	Meaning	Domain / type
$A$	Matrix	The $m \times n$ matrix whose rows generate the row space	m x n matrix over C
$A^{t}$	Transpose	The $n \times m$ matrix with rows and columns interchanged; its columns are the rows of $A$	n x m matrix over C
$R (A)$	Row space	All linear combinations of the rows of $A$ , held as column vectors	subspace of C^n
$C (A)$	Column space	All linear combinations of the columns of $A$	subspace of C^m
$B$	Reduced form	The matrix in reduced row-echelon form that is row-equivalent to $A$	m x n matrix over C
$r$	Rank	Number of non-zero rows of $B$ , equal to $\dim \mathcal{R}(A)$	0 to min(m,n)
$Row-space basis$	Row-space basis	The transposed non-zero rows of $B$ ; linearly independent and spanning	set of r vectors in C^n
$D$	Pivot column set	Indices $d_1 < \cdots < d_r$ of the columns of $B$ holding leading ones	subset of 1..n
${\vec{r}}_{i}$	Row vector	The $i$ -th row of $A$ , transposed into a column vector	vector in C^n

Worked Numerical Example

Problem statement

Four load cases have been applied to a five-channel strain-gauge rig, giving four rows of channel sensitivities. Determine the space of channel patterns reachable by combining load cases, produce a minimal independent description of it, and decide whether two specific target patterns are reachable.

Assemble the load-case matrix
Each row records the five channel readings produced by one unit load case. The reachable set of channel patterns is exactly $\mathcal{R}(A)$ , the span of the four rows.
$A = [\begin{matrix} 2 & 1 & 3 & 1 & 4 \\ 4 & 2 & 6 & 3 & 9 \\ 1 & 0 & 1 & 1 & 3 \\ 3 & 1 & 4 & 2 & 7 \end{matrix}]$
Reduce the matrix
Row-reduce $A$ to reduced row-echelon form. Every operation leaves the row space unchanged, so the reduced matrix generates precisely the same set of channel patterns.
$B = [\begin{matrix} 1 & 0 & 1 & 0 & 2 \\ 0 & 1 & 1 & 0 & - 1 \\ 0 & 0 & 0 & 1 & 1 \\ 0 & 0 & 0 & 0 & 0 \end{matrix}]$
Identify the redundancy
One zero row has appeared, so $r = 3$ and the four load cases are not independent. Inspecting the original rows confirms the relation: row 1 plus row 3 equals row 4, since $(2,1,3,1,4) + (1,0,1,1,3) = (3,1,4,2,7)$ . Load case 4 is a superposition of load cases 1 and 3 and adds no new information to the rig.
Extract the basis
Discard the zero row and transpose the three survivors. This set spans the same space and is linearly independent, because the leading ones sit in columns $1$ , $2$ and $4$ and no vector in the set has a non-zero entry in another vector's pivot coordinate.
$R (A) = span ({[\begin{matrix} 1 \\ 0 \\ 1 \\ 0 \\ 2 \end{matrix}], [\begin{matrix} 0 \\ 1 \\ 1 \\ 0 \\ - 1 \end{matrix}], [\begin{matrix} 0 \\ 0 \\ 0 \\ 1 \\ 1 \end{matrix}]})$
Test the first target pattern
For $\vec{w} = (2,\, 3,\, 5,\, 1,\, 2)$ the pivot coordinates are positions $1$ , $2$ and $4$ , giving scalars $2$ , $3$ and $1$ without any elimination. Forming that combination reproduces $\vec{w}$ exactly, so the pattern is reachable.
$2 [\begin{matrix} 1 \\ 0 \\ 1 \\ 0 \\ 2 \end{matrix}] + 3 [\begin{matrix} 0 \\ 1 \\ 1 \\ 0 \\ - 1 \end{matrix}] + 1 [\begin{matrix} 0 \\ 0 \\ 0 \\ 1 \\ 1 \end{matrix}] = [\begin{matrix} 2 \\ 3 \\ 5 \\ 1 \\ 2 \end{matrix}]$
Test the second target pattern
For $\vec{u} = (2,\, 3,\, 5,\, 1,\, 0)$ the same three scalars are forced by the same pivot coordinates, and the combination has fifth entry $2$ , not $0$ . The two vectors differ, so $\vec{u} \notin \mathcal{R}(A)$ : no combination of these load cases produces that channel pattern.
Turn the tool around for the column space
Transposing $A$ and reducing gives leading ones in the first three columns, and the surviving rows transpose back into a basis for $\mathcal{C}(A)$ . The zero-one pattern in the first three entries makes consistency of $A\vec{x} = \vec{b}$ a matter of inspection for any $\vec{b}$ .
$C (A) = R (A^{t}) = span ({[\begin{matrix} 1 \\ 0 \\ 0 \\ 1 \end{matrix}], [\begin{matrix} 0 \\ 1 \\ 0 \\ 0 \end{matrix}], [\begin{matrix} 0 \\ 0 \\ 1 \\ 1 \end{matrix}]})$

Result

The rig has three independent load cases, not four: $\dim \mathcal{R}(A) = 3$ , and load case 4 is the sum of load cases 1 and 3. The three-vector basis is a complete and minimal description of every achievable channel pattern, and its leading-one structure converts a membership question that would otherwise require solving a $4 \times 5$ system into reading three numbers and checking two.

Applications & Industry Use

Structural testing

Independence of load cases

A test programme applies a schedule of load cases and records instrumentation response. Stacking the response vectors as rows and reducing reveals how many cases are genuinely independent and which are superpositions of others. Redundant cases can be removed from the schedule without reducing the information content of the test, which is a direct saving in rig time.

Chemical process engineering

Independent reactions in a network

A reaction network is described by a stoichiometric matrix whose rows are individual reactions over a set of species. The row space is the set of net stoichiometries achievable by running reactions in combination, and its dimension is the number of independent reactions. Reducing the matrix produces a canonical set of independent reactions that generates every observable overall transformation.

Coding and communications

Generator matrices and equivalent codes

A linear block code is the row space of its generator matrix, so two generator matrices define the same code precisely when they reduce to the same form. Bringing a generator matrix to reduced row-echelon form yields the systematic representation in which the message symbols appear unaltered in the pivot positions, simplifying both encoding and equivalence checking.

Geospatial and survey engineering

Redundant observation equations

A levelling or triangulation network produces one observation equation per measurement. The row space of the design matrix is the space of estimable linear functions of the unknowns; anything outside it cannot be determined from the observations no matter how many are taken. Reduction identifies the estimable combinations explicitly and exposes datum defects as a rank shortfall.

Computer graphics and geometry

Canonical description of an affine constraint set

A set of linear constraints on control-point coordinates defines a span. Reducing the constraint matrix returns a minimal independent constraint set, which removes duplicated or implied constraints before a solver is invoked and prevents the singular systems that redundant constraints otherwise produce.

Data engineering

Deduplicating feature definitions

Derived features are frequently defined as weighted sums of base fields, and different teams define overlapping combinations. Writing each derived feature as a row and reducing reveals exactly how many independent quantities the feature set actually contains and produces a canonical minimal set, cutting both storage and the collinearity that destabilises downstream models.

Design Considerations

Never row-reduce to obtain a column space

Reducing $A$ and taking the columns of the result is the most common error in this area. Row operations preserve $\mathcal{R}(A)$ and $\mathcal{N}(A)$ but not $\mathcal{C}(A)$ . If a column-space basis is wanted, either take the pivot columns of the original matrix, or transpose first and then reduce. The reduced matrix supplies pivot positions, never column-space vectors.

Choose between original rows and reduced rows deliberately

The reduced rows form the cleanest possible basis but are combinations of the input, so they carry no direct physical meaning. When each row corresponds to a real object — a measurement channel, a reaction, a load case — a basis chosen from the original rows is more interpretable, even though it lacks the zero-one pattern. Decide which of interpretability and computational convenience the deliverable requires.

Comparing two spans requires a common ambient dimension

Two spans in $\mathbb{C}^n$ are equal precisely when the matrices holding their generators as rows have the same reduced row-echelon form after zero rows are removed. This test is exact and cheap, but it is only meaningful when both sets live in the same $\mathbb{C}^n$ ; comparing a row space in $\mathbb{C}^n$ with a column space in $\mathbb{C}^m$ is a category error.

Transposing costs memory bandwidth, not arithmetic

The transpose used in the definition is free in theory and rarely free in practice. For a large dense matrix, an explicit transpose destroys cache locality and can dominate the cost of the subsequent reduction. Production code typically avoids materialising $A^{t}$ and instead runs the elimination with swapped loop order or uses a factorisation of $A$ directly.

Rank determination is a tolerance decision in floating point

Deciding how many non-zero rows the reduced form has is equivalent to deciding which pivot candidates are non-zero. On measured data no entry is exactly zero, so the row-space dimension becomes threshold-dependent. Where the rank itself is the deliverable, a singular value decomposition with a stated tolerance is a far more defensible instrument than counting rows after elimination.

Watch for coefficient growth in exact arithmetic

Reducing an integer matrix over the rationals can produce intermediate entries with very large numerators and denominators even when both the input and the final reduced form are small. For matrices beyond a few hundred rows, a fraction-free elimination or a modular approach with reconstruction is preferable to naive rational arithmetic.

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 notational conventions used here: the transpose superscript, italic letters for matrices, and the bracket delimiters that distinguish a matrix from a determinant.
`IEEE 754-2019`	IEEE Standard for Floating-Point Arithmetic	Defines the rounding behaviour that makes the count of non-zero rows — and therefore the computed dimension of the row space — a tolerance-dependent rather than exact quantity.
`BLAS Level 3`	Basic Linear Algebra Subprograms, Level 3	Provides the blocked kernels that back practical elimination and explicit transposition; the transpose flags on routines such as `xGEMM` exist precisely so that $A^{t}$ need never be materialised.
`ISO/IEC 40314`	Mathematical Markup Language (MathML) Version 3.0	Encodes the matrices and set expressions on this page as semantic markup rather than images, keeping them searchable and machine-readable.
`W3C WCAG 2.1 AA`	Web Content Accessibility Guidelines	Matrix layouts are exposed to assistive technology with structural roles preserved, so a screen reader can navigate rows and columns rather than reading a flat number stream.

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 deliverable is the dimension of a span, a canonical basis, or an equality test between two spans.	Gives an unambiguous count of non-zero rows with no threshold decisions, but intermediate coefficient growth can be severe on larger integer matrices.
Arbitrary-precision integers with fraction-free elimination	Integer or symbolic input where exactness is required but rational blow-up must be contained.	The Bareiss approach keeps entries bounded by minors of the input, at the cost of producing an echelon rather than a fully reduced form.
IEEE 754 binary64	Measured data such as gauge sensitivities or design matrices, where the input already carries uncertainty.	Fast and memory-efficient, but the row-space dimension becomes a tolerance judgement and nearly dependent rows may be misclassified either way.
Orthogonal factorisation (QR or SVD) instead of elimination	A numerically robust basis for the row space of floating-point data is required.	The leading right singular vectors give an orthonormal row-space basis with an explicit conditioning measure, at roughly an order of magnitude more arithmetic than elimination and with no zero-one pattern.
Finite field arithmetic	Coding theory, where the row space of a generator matrix over $GF(2)$ or $GF(q)$ is the code.	Exact, fast and free of growth, with bitwise implementations available over $GF(2)$ ; but pivot patterns over a finite field can differ from those over the rationals.
Sparse row storage with fill-reducing ordering	Very large, sparse design matrices from network or finite-element models.	Storage is proportional to the non-zeros, but elimination introduces fill that can destroy sparsity, so a sparse QR is usually the better route to a row-space basis.

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

Reducing an $m \times n$ matrix to reduced row-echelon form costs on the order of $m n r$ multiply-add operations, where $r$ is the rank. Obtaining a column-space basis by transposing first adds only the cost of the transpose itself, which is a memory-bandwidth operation rather than an arithmetic one, so the two routes to a basis are comparable in flops.

Doing it by hand

Write the generating vectors as rows, not columns — the single most common hand-computation slip in this procedure is building the matrix the wrong way round and then reducing it, which computes something else entirely. Reduce fully, cross out zero rows, and transpose the survivors. Sanity-check the result by confirming that each original row can be written as a combination of the basis using its own pivot coordinates.

Library behaviour

SymPy exposes the reduced form directly through Matrix.rref(), and Matrix.rowspace() returns the non-zero reduced rows. NumPy provides no reduced form by design; the idiomatic floating-point equivalent is numpy.linalg.svd, whose right singular vectors corresponding to non-negligible singular values form an orthonormal row-space basis. MATLAB's rref exists but its documentation explicitly warns against relying on it for numerical rank.

Verification technique

Two independent checks are worth performing. First, confirm that each original row lies in the span of the computed basis, using the pivot-coordinate shortcut. Second, confirm the count: the number of basis vectors must equal the number of pivot columns of the reduced matrix, and must also equal the rank obtained independently from the untransposed matrix.

Numerical stability of the elimination

Elimination without pivoting can produce catastrophically wrong pivot patterns on badly scaled data. Partial pivoting on magnitude is the minimum acceptable strategy; where the row-space dimension itself matters, rank-revealing QR with column pivoting or an SVD provides both a basis and a quantitative gap measure justifying the chosen rank.

Failure Modes & Common Mistakes

Failure modes, root causes and prevention
Failure mode / mistake	Impact	Root cause	Prevention & detection
Row-reducing to get a column space	high	Applying the row-space procedure to columns, i.e. taking the columns of $\operatorname{RREF}(A)$ as a basis for $\mathcal{C}(A)$ .	Row operations preserve row spaces only. Use the pivot columns of the original $A$ , or transpose before reducing.
Building the matrix with generators as columns	high	Assembling a span's generating vectors into columns and then reducing, which computes information about the wrong subspace.	For a row-space computation the generators must be the rows. Check the matrix dimensions against the ambient space before reducing.
Comparing a row space with a column space	medium	Assuming $\mathcal{R}(A)$ and $\mathcal{C}(A)$ are comparable because they have the same dimension.	For an $m \times n$ matrix they are subspaces of $\mathbb{C}^n$ and $\mathbb{C}^m$ . Equal dimension does not imply equal sets, even when $m = n$ .
Retaining zero rows in the basis	low	Transposing every row of the reduced form, including the zero rows, into the spanning set.	The zero vector is never a member of a linearly independent set. Discard zero rows before forming the basis and confirm the count equals the rank.
Assuming the reduced rows are original rows	medium	Interpreting a basis vector from the reduced form as if it were a physical row of the input, such as a real measurement channel or a real reaction.	Reduced rows are combinations of the input rows. Where physical interpretation is needed, select a basis from the original rows using the pivot pattern.
Exact-zero test on floating-point pivots	high	Counting non-zero rows by testing entries against zero on rounded data, so that a structurally zero row of magnitude $10^{-16}$ is retained.	Apply a tolerance scaled to the matrix norm, or determine the dimension from an SVD with a documented threshold.
Scaling a row by zero	medium	Applying the second row operation with $\alpha = 0$ , which is not an elementary row operation and collapses information irreversibly.	The non-zero requirement on the scaling constant is essential to the invariance proof; enforce it explicitly in any implementation.
Assuming equal row spaces implies row equivalence	low	Reading the invariance theorem as an equivalence rather than an implication.	Matrices of different sizes can share a row space. Row equivalence additionally requires the same number of rows and identical reduced forms.

FAQs

Why is the row space defined using the transpose rather than just as a set of rows?

For uniformity of type. Every other object in the theory — null space, column space, solution set — is a set of column vectors, and defining the row space as $\mathcal{C}(A^{t})$ keeps it in the same family. The practical consequence is that every theorem already proved about column spaces applies immediately to row spaces with no new arguments.

Do row operations change the row space?

No. Each of the three elementary row operations produces a new set of rows whose linear combinations reach exactly the same vectors, and each operation is reversible, so the span is preserved in both directions. This is why row reduction is the natural tool for simplifying a span.

Can I use the same trick to simplify a column space?

Yes, but only after transposing. Since $\mathcal{C}(A) = \mathcal{R}(A^{t})$ , you transpose the matrix, reduce, discard zero rows and transpose the survivors back into column vectors. Reducing $A$ itself and taking its columns gives a different and generally wrong answer.

Are the row space and column space of a square matrix the same set?

Usually not, although they always have the same dimension. They coincide for symmetric matrices, and can coincide by accident for others, but in general a square matrix has two distinct $r$ -dimensional subspaces of $\mathbb{C}^n$ associated with it. Equality of dimension is a theorem; equality of sets is a coincidence.

How do I test whether a vector lies in a given row space?

Reduce the matrix, note the pivot column indices $d_1, \ldots, d_r$ , and read the candidate vector's entries at those positions as the required scalars. Form that linear combination of the basis vectors and compare it with the candidate. If they agree in every coordinate the vector is in the row space; if any non-pivot coordinate differs, it is not.

Does the basis from the reduced form depend on how I reduced the matrix?

No. The reduced row-echelon form of a matrix is unique, so the resulting basis is completely determined by the input. This is what makes the procedure a legitimate test for equality of two spans: identical spans always produce identical reduced descriptions.

What happens if the matrix has more rows than the dimension of the ambient space?

Then the rows must be linearly dependent, and reduction will produce at least $m - n$ zero rows. The row space is still a subspace of $\mathbb{C}^n$ with dimension at most $n$ ; the surplus rows contribute nothing and are exactly the redundancy the procedure is designed to expose.

References

Beezer, R. A. A First Course in Linear Algebra, Version 0.70. University of Puget Sound, 2006. Section CRS, Subsection RSM. 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.
MacWilliams, F. J. and Sloane, N. J. A. The Theory of Error-Correcting Codes. North-Holland, 1977.
W3C. Mathematical Markup Language (MathML) Version 3.0, 2nd edition (ISO/IEC 40314).

AI Suggested Questions

Construct two matrices of different sizes that have exactly the same row space, and explain why they are not row-equivalent.
Show me a concrete matrix where the column space changes under row reduction, and identify the coordinate that proves the two column spaces differ.
Compare the row-space basis obtained from reduced row-echelon form with the orthonormal basis obtained from the right singular vectors of an SVD.
For a square matrix, what conditions force the row space and the column space to be equal as sets rather than merely equal in dimension?
Walk through using the row space to decide whether two linear block codes defined by different generator matrices are the same code.
How does coefficient growth behave when reducing a 50x50 integer matrix over the rationals, and what does fraction-free elimination change?

Related Calculators

Row Space Basis Calculator

Reduce a matrix and return a linearly independent basis for its row space, with pivot indices and dimension.

Span Simplifier

Enter any set of vectors and receive a minimal independent description of the same span, plus a membership test for a candidate vector.

Matrix Rank & Nullity Calculator

Compute rank, nullity and pivot columns with a selectable numerical tolerance.

Overview

Definition