The Three Elementary Row Operations

By Lena Fischer●2026-06-01●Updated 2026-07-18

Every technique for solving a linear system by hand reduces to three moves. These moves, called elementary row operations, let you reshape a matrix without changing which solutions it represents. Master them and you have the mechanical foundation for Gaussian elimination, Gauss-Jordan elimination, and matrix inversion.

At a Glance

• There are exactly three elementary row operations: swap, scale, and replace (add a multiple of one row to another).
• Every operation preserves the solution set. The system after the operation has exactly the same solutions as before.
• Scaling is only valid with a nonzero constant; multiplying a row by zero destroys information irreversibly.
• Each operation corresponds to an invertible elementary matrix, so applying operations is equivalent to matrix multiplication on the left.
• Row replacement is the workhorse: it is the operation that actually eliminates variables.
• Two matrices are row-equivalent exactly when a finite sequence of these three operations connects them, and row-equivalent systems always share the same solution set.

What Counts as an Elementary Row Operation

There are exactly three. Each one transforms an augmented matrix into an equivalent one, meaning the two systems share the same solution set. That equivalence is what makes the operations useful: you can reduce a complicated matrix to a simple form and read off the answer, confident nothing was lost along the way. Wikipedia's Gaussian elimination article lists the same three moves: "swapping two rows, multiplying a row by a nonzero number, and adding a multiple of one row to another row."

Operation 1: Row Swap (Interchange)

Swap the positions of two rows. If row 1 is [2, 4, 6] and row 2 is [1, 0, 3], swapping them produces [1, 0, 3] on top and [2, 4, 6] below. The equations are still there; only the order changed.

Notation: R1 ↔ R2

Swapping rows is useful when the leading entry in the current pivot position is zero, which would otherwise block division. Moving a nonzero entry into the pivot spot lets the algorithm continue.

Why it preserves the solution set: A linear system is just a set of equations. Writing them in a different order does not change what satisfies all of them simultaneously.

Operation 2: Row Scaling (Scalar Multiplication)

Multiply every entry in a single row by the same nonzero constant k. The restriction to nonzero is critical: multiplying a row by zero would destroy information and collapse that equation to 0 = 0, which cannot be undone.

Notation: kR1 → R1 (read: replace row 1 with k times row 1)

For example, scaling [3, 6, 9] by 1/3 gives [1, 2, 3]. That simpler row is algebraically identical to the original, just divided through.

Why it preserves the solution set: If the original equation is 3x + 6y = 9, then x + 2y = 3 has exactly the same solutions. Multiplying both sides of an equation by the same nonzero number is one of the most basic legal moves in algebra.

Operation 3: Row Replacement (Row Addition)

Replace one row with the sum of itself and a scalar multiple of another row. This is the operation that actually eliminates variables.

Notation: R2 + kR1 → R2 (replace row 2 with row 2 plus k times row 1)

If R1 = [1, 2, 3] and R2 = [4, 5, 6], then R2 + (−4)R1 → R2 gives [4−4, 5−8, 6−12] = [0, −3, −6]. The leading 4 is gone.

Why it preserves the solution set: The replacement says "take the equation for R2 and add k copies of the equation for R1 to it." Because R1 represents a true equation (one satisfied by every solution of the system), adding it (scaled or not) to another equation produces a new equation that is also satisfied by every solution. The solution set cannot shrink or grow from this.

Notation Conventions

Different textbooks use slightly different symbols, but the ideas are consistent:

• R_i ↔ R_j for a swap
• cR_i → R_i for scaling (sometimes written as (1/c)R_i → R_i when you are dividing)
• R_i + cR_j → R_i for replacement

Keeping track of each step in this notation makes it easier to check your work and to reverse the process if needed, since all three operations are invertible.

A Worked Reduction

Here is a small but complete example. Reduce the following augmented matrix to row echelon form:

[ 0   2   4  |  8 ]
[ 1   3   2  |  7 ]
[ 2   1  -1  |  1 ]

Step 1: The top-left entry is 0, so swap R1 and R2.

R1 ↔ R2:

[ 1   3   2  |  7 ]
[ 0   2   4  |  8 ]
[ 2   1  -1  |  1 ]

Step 2: Eliminate the 2 in position (3,1). Use R3 + (−2)R1 → R3.

[ 1   3   2  |  7 ]
[ 0   2   4  |  8 ]
[ 0  -5  -5  | -13 ]

Step 3: Scale R2 by 1/2 to make the pivot in position (2,2) equal to 1.

(1/2)R2 → R2:

[ 1   3   2  |  7 ]
[ 0   1   2  |  4 ]
[ 0  -5  -5  | -13 ]

Step 4: Eliminate the −5 in position (3,2). Use R3 + 5R2 → R3.

[ 1   3   2  |  7 ]
[ 0   1   2  |  4 ]
[ 0   0   5  |  7 ]

The matrix is now in row echelon form. Continuing with back-substitution, or applying further row operations to reach RREF, gives the unique solution. See the full step-by-step process in how to find RREF by hand.

A quick check confirms the arithmetic: substitute the original R3 = [2, 1, -1, 1] and R1 = [1, 3, 2, 7] into R3 + (−2)R1: [2 - 2(1), 1 - 2(3), -1 - 2(2), 1 - 2(7)] = [0, -5, -5, -13], matching Step 2 exactly. Working the arithmetic back through each operation like this is a fast way to catch a dropped sign before it compounds three steps later.

Elementary Matrices

Each row operation corresponds to an elementary matrix: a special matrix obtained by applying that operation to the identity matrix. Multiplying your matrix A on the left by an elementary matrix E produces the same result as applying that row operation to A directly. Wikipedia's elementary matrix entry confirms this correspondence: "there are three types of elementary matrices, which correspond to three types of row operations."

For example, the operation R2 + (−4)R1 → R2 on a 3×3 matrix corresponds to:

E = [ 1   0  0 ]
    [ -4  1  0 ]
    [ 0   0  1 ]

To see this actually work, take A = [[1,2,3],[4,5,6],[7,8,9]] and compute EA row by row. Row 1 of EA is 1·[1,2,3] + 0·[4,5,6] + 0·[7,8,9] = [1,2,3], unchanged. Row 2 of EA is -4·[1,2,3] + 1·[4,5,6] + 0·[7,8,9] = [-4,-8,-12] + [4,5,6] = [0,-3,-6]. Row 3 stays [7,8,9], untouched. So EA = [[1,2,3],[0,-3,-6],[7,8,9]], exactly what you get by hand-applying R2 + (−4)R1 → R2 to A while leaving rows 1 and 3 alone.

This connection matters for two reasons. First, it proves that row operations can be represented as matrix multiplication, which is essential for understanding matrix factorizations like LU decomposition. Second, since each elementary matrix is invertible (its inverse is the elementary matrix for the reverse operation), it confirms that row-equivalent matrices truly do share the same solution set.

Elementary matrices also appear prominently in finding a matrix inverse with Gauss-Jordan, where you track the product of all the elementary matrices applied to A.

Common Pitfalls

A few mistakes come up repeatedly in practice:

• Scaling by zero. Row scaling is only valid with a nonzero scalar. Multiplying a row by 0 produces a zero row and destroys information.
• Modifying two rows in one step. Each operation changes at most one row (a swap changes two, but only by exchange). Writing "R1 − R2 → R1 and R2 − R1 → R2 simultaneously" is not a valid single step and produces wrong results.
• Sign errors in row replacement. If you want to eliminate a positive entry, you typically add a negative multiple. Keeping the sign explicit in your notation helps avoid this. A broader list of places where errors accumulate appears in common Gauss-Jordan mistakes.
• Forgetting the augmented column. When an operation is performed on a coefficient row, the same operation must be applied to the entry in the augmented column too. Treating the coefficient part and the right-hand-side part as separate updates is a common source of arithmetic slips, especially by hand.

Frequently Asked Questions

Are the three operations the only ones allowed?

Yes. Any valid manipulation of a linear system that preserves its solution set can be decomposed into these three operations. Adding rows, rearranging them, or scaling them cover every legitimate algebraic move. Operations like squaring a row or adding a constant to one entry are not valid and will change the solution set.

Can I apply row operations to a non-augmented matrix?

Yes. When computing a matrix inverse or exploring properties like rank and null space, you apply row operations to a coefficient matrix or an augmented form [A | I] rather than [A | b]. The operations themselves are identical; the interpretation of the result differs.

Does the order of row operations matter?

The final reduced form is unique (RREF is unique for any given matrix), but the sequence of operations you take to get there is not. Different valid sequences can reach the same result in more or fewer steps. Some orderings are more efficient than others, especially for larger matrices where reducing pivot counts early saves work.

What does "row-equivalent" mean?

Two matrices are row-equivalent if one can be obtained from the other by a finite sequence of elementary row operations. Row-equivalent augmented matrices represent systems with identical solution sets. Every matrix is row-equivalent to exactly one matrix in RREF, which is why RREF is a useful canonical form.

Why is row replacement described as "the workhorse" operation?

Because it is the only one of the three that actually combines information from two different rows, which is what lets you cancel a variable out of an equation. Swaps just reorder existing information and scaling only rescales one row in isolation. Elimination, the whole point of Gaussian elimination, happens through repeated row replacement.

Can a single row operation ever introduce a new solution that wasn't there before?

No, and this is worth understanding rather than just trusting. Because every elementary matrix is invertible, each operation is a bijection on the space of possible coefficient vectors: it maps solutions to solutions and non-solutions to non-solutions, with no exceptions. That invertibility, not just intuition, is the formal reason row operations never gain or lose solutions.