Computing the Inverse of a Matrix

Q: What happens if the matrix is singular?

The left block cannot reduce to $I_n$; a zero row appears instead. The procedure has then proved that at least one system $A\vec{x} = \vec{e}_j$ is inconsistent, so no matrix can satisfy $AB = I_n$. This is a correct diagnosis of non-invertibility, not a breakdown of the method.

Overview

Knowing that an inverse exists is a different problem from producing one. The naive route — write $n^2$ unknown entries, impose $AB = I_n$ , and solve the resulting $n^2$ equations — is workable for $2 \times 2$ matrices and yields a memorable closed formula, but it collapses under its own notation almost immediately afterwards. A $3 \times 3$ attempt already requires eighteen symbols.

The productive reformulation is to think in columns. Matrix multiplication acts column by column, so the single matrix equation $AB = I_n$ splits into $n$ independent vector equations $A\vec{B}_j = \vec{e}_j$ , one for each column of the unknown $B$ and each standard unit vector on the right. Every one of these is an ordinary linear system, and crucially they all share the coefficient matrix $A$ . Column $j$ of the inverse is simply the solution of the $j$ -th system.

Solving those $n$ systems separately would repeat the identical sequence of row operations $n$ times. Gauss-Jordan reduction of the single augmented array $[\, A \mid I_n \,]$ performs the work once and carries all $n$ right-hand sides along simultaneously. When the left block reduces to $I_n$ , each of the $n$ systems has been solved and the answers are stacked side by side in the right block. When the left block does not reduce to $I_n$ — a zero row appears — the matrix is singular and the procedure correctly reports that no inverse exists.

The same augmented array is also a record of the elimination itself. Row reduction is left multiplication by a product of elementary matrices, so reducing $[\, A \mid I_n \,]$ produces $[\, JA \mid J \,]$ where $J$ accumulates that product. If $JA = I_n$ then $J$ is the inverse, which is why the identity block is the right thing to append: it starts as a blank ledger and finishes holding the entire transformation.

Definition

Standard Unit Vectors

SUV

For each $j$ with $1 \le j \le m$ , the vector $\vec{e}_j \in \mathbb{C}^m$ is column $j$ of the identity matrix $I_m$ : it has a $1$ in position $j$ and $0$ everywhere else. The collection $\{\vec{e}_1, \vec{e}_2, \ldots, \vec{e}_m\}$ is the set of standard unit vectors in $\mathbb{C}^m$ .

Entrywise, $[\vec{e}_j]_i = 1$ when $i = j$ and $0$ otherwise. These vectors are the natural right-hand sides for the inversion problem because they are exactly the columns of $I_n$ .

Two-by-Two Matrix Inverse

TTMI

For $A = \begin{bmatrix} a & b \\ c & d \end{bmatrix}$ , the matrix $A$ is invertible if and only if $ad - bc \ne 0$ , and in that case $A^{-1} = \dfrac{1}{ad - bc}\begin{bmatrix} d & -b \\ -c & a \end{bmatrix}$ .

The quantity $ad - bc$ is the determinant of $A$ . The forward implication is a direct verification; the converse is proved by contradiction, multiplying rather than dividing so that no entry has to be assumed non-zero.

Computing the Inverse of a Nonsingular Matrix

CINSM

Let $A$ be a nonsingular square matrix of size $n$ . Form the $n \times 2n$ array $M = [\, A \mid I_n \,]$ , let $N$ be the matrix row-equivalent to $M$ that is in reduced row-echelon form, and let $J$ consist of the final $n$ columns of $N$ . Then $AJ = I_n$ .

The statement delivers a right inverse. Because $A$ is square, the reverse product $JA = I_n$ follows as well, so $J = A^{-1}$ ; that step requires a separate theorem and should not be assumed silently.

Concepts

Inversion is $n$ linear systems in disguise

Write the unknown inverse as $B = [\,\vec{B}_1 \mid \vec{B}_2 \mid \cdots \mid \vec{B}_n\,]$ . Because $AB = [\,A\vec{B}_1 \mid A\vec{B}_2 \mid \cdots \mid A\vec{B}_n\,]$ , the condition $AB = I_n$ is equivalent to the $n$ separate systems $A\vec{B}_j = \vec{e}_j$ . This is the conceptual pivot of the whole subject: a matrix problem becomes $n$ vector problems, all sharing one coefficient matrix, and sharing a coefficient matrix is precisely the situation elimination is designed to exploit.

Why the identity block is the right thing to append

Each elementary row operation is realised by left multiplication with an elementary matrix. Reducing $[\, A \mid I_n \,]$ therefore produces $[\, E_k \cdots E_2 E_1 A \mid E_k \cdots E_2 E_1 \,]$ . Setting $J = E_k \cdots E_1$ , the array is $[\, JA \mid J \,]$ . The reduction stops when $J A$ is in reduced row-echelon form; if that form is $I_n$ , then $J$ is a left inverse of $A$ and the right block has recorded it. The identity block functions as an audit trail of the elimination.

The two-by-two formula and why it does not generalise

For a $2 \times 2$ matrix the four unknown entries can be eliminated by hand, giving $A^{-1} = (ad-bc)^{-1}\begin{bmatrix} d & -b \\ -c & a \end{bmatrix}$ : swap the diagonal, negate the off-diagonal, divide by the determinant. A general closed formula does exist for size $n$ — the adjugate divided by the determinant — but it involves $n^2$ determinants of size $n-1$ and its cost grows factorially. Row reduction is polynomial. The closed formula is a theoretical instrument; elimination is the working method.

What the procedure does when the matrix is singular

If $A$ is singular, its reduced row-echelon form has a zero row and cannot be $I_n$ . Row reduction of $[\, A \mid I_n \,]$ still terminates, but the left block ends in a form with fewer than $n$ leading ones and the right block is not an inverse of anything. This is a genuine diagnosis rather than a breakdown: the procedure has demonstrated that at least one of the systems $A\vec{x} = \vec{e}_j$ is inconsistent, so no matrix $B$ can satisfy $AB = I_n$ .

One-sided output and the missing half

The reduction argument establishes $AJ = I_n$ directly, because column $n+i$ of the reduced array solves the $i$ -th system. It does not by itself establish $JA = I_n$ , which the definition of the inverse also demands. For square matrices the second identity is automatic, but that is a theorem in its own right. Until it is invoked, the honest statement is that the procedure yields a right inverse of a nonsingular matrix.

Pivoting choices affect the arithmetic, not the answer

Reduced row-echelon form is unique, so the computed inverse does not depend on the order in which pivots were chosen. That freedom is exploited differently in exact and inexact arithmetic: by hand, a row with a leading $1$ is promoted first to keep fractions out of the early stages, whereas in floating point the row with the largest pivot magnitude is chosen to limit growth of rounding error. Both routes terminate at the same $A^{-1}$ .

Procedure: inverting a square matrix by row reduction

Append the identityForm the

n \times 2n

array

M = [\, A \mid I_n \,]

, keeping the two blocks aligned.

Reduce the whole arrayApply Gauss-Jordan elimination to

M

, operating on all

2n

entries of every row. Never treat the blocks separately.

Inspect the left blockIf the left block is

I_n

, continue. If a zero row appears,

A

is singular; stop and report that no inverse exists.

Read off the candidateExtract the final

n

columns as

J

. The construction guarantees

AJ = I_n

VerifyConfirm

JA = I_n

as well, or invoke the one-sided inverse theorem. Record

A^{-1} = J

Equations

Entries of a standard unit vector

EQ-CIM-01

[{\vec{e}}_{j}]_{i} = {\begin{cases} 1 & i = j \\ 0 & i \neq j \end{cases}

The vector $\vec{e}_j$ is column $j$ of $I_m$ , and the collection of all of them is the set of standard unit vectors.

Column-by-column form of the inversion problem

EQ-CIM-02

A [{\vec{B}}_{1} ∣ {\vec{B}}_{2} ∣ \dots ∣ {\vec{B}}_{n}] = [{\vec{e}}_{1} ∣ {\vec{e}}_{2} ∣ \dots ∣ {\vec{e}}_{n}] \Leftrightarrow A {\vec{B}}_{j} = {\vec{e}}_{j}, 1 \leq j \leq n

Matrix multiplication acts column by column, so one matrix equation is exactly $n$ vector equations with a shared coefficient matrix.

Closed formula for a two-by-two inverse

EQ-CIM-03

Closed formula for a two-by-two inverse

Swap the diagonal entries, negate the off-diagonal entries, divide by the determinant. The matrix is invertible precisely when $ad - bc \ne 0$ .

The augmented inversion array

EQ-CIM-04

[A ∣ I_{n}] \sim [I_{n} ∣ A^{- 1}]

Row-equivalence of the two arrays, valid exactly when $A$ is nonsingular. The symbol $\sim$ denotes row equivalence.

Row reduction as left multiplication

EQ-CIM-05

J = E_{k} \dots E_{2} E_{1}, [A ∣ I_{n}] \sim [J A ∣ J]

Each $E_i$ is the elementary matrix of one row operation. The appended identity block accumulates the product, so the transformation is recorded as it is applied.

Conclusion of the reduction procedure

EQ-CIM-06

J A = I_{n} \Rightarrow A J = I_{n} \Rightarrow A^{- 1} = J

The first implication is the one-sided inverse theorem for square matrices; without it the procedure delivers only a one-sided inverse.

Worked blending matrix and its inverse

EQ-CIM-07

A = [\begin{matrix} 3 & 1 & 2 \\ 1 & 2 & 1 \\ 2 & 1 & 3 \end{matrix}], A^{- 1} = \frac{1}{8} [\begin{matrix} 5 & - 1 & - 3 \\ - 1 & 5 & - 1 \\ - 3 & - 1 & 5 \end{matrix}]

The example carried through below. Note that the inverse of a symmetric matrix is symmetric, a useful check on the arithmetic.

Variable Definitions

Symbols used on this page
Symbol	Name	Meaning	Domain / type
$A$	Matrix to be inverted	Square matrix of size $n$ , assumed nonsingular for the procedure to succeed	n x n complex matrix
$M$	Augmented array	The $n \times 2n$ array $[\, A \mid I_n \,]$ presented to the reduction	n x 2n matrix
$N$	Reduced array	The reduced row-echelon form of $M$	n x 2n matrix
$Right-hand block$	Right-hand block	Final $n$ columns of $N$ ; equals $A^{-1}$ when the left block is $I_n$	n x n matrix
${\vec{e}}_{j}$	Standard unit vector	Column $j$ of $I_n$ ; the right-hand side of the $j$ -th system	C^n
${\vec{B}}_{j}$	Column $j$ of the unknown inverse	The unique solution of $A\vec{x} = \vec{e}_j$	C^n
$E_{i}$	Elementary matrix	The matrix implementing one elementary row operation by left multiplication	n x n matrix
$Two-by-two determinant$	Two-by-two determinant	Scalar whose vanishing characterises singularity of a $2 \times 2$ matrix	complex scalar
$n$	Size	Common row and column count of $A$	positive integer

Worked Numerical Example

Problem statement

Three ore concentrates are blended to hit a specified metal assay. Column $j$ of the assay matrix $A$ gives the content of the three target metals in concentrate $j$ , in consistent units. Invert $A$ once so that any future assay target can be converted directly into a blend recipe.

Form the augmented array
Place the $3 \times 3$ identity to the right of the assay matrix. Every subsequent row operation acts on all six entries of a row.
$M = [\begin{matrix} 3 & 1 & 2 & 1 & 0 & 0 \\ 1 & 2 & 1 & 0 & 1 & 0 \\ 2 & 1 & 3 & 0 & 0 & 1 \end{matrix}]$
Promote a convenient pivot
Row $2$ already has a leading $1$ in column $1$ . Exchanging rows $1$ and $2$ avoids introducing thirds at the very first step. Exact arithmetic permits this choice freely, because the reduced form is unique.
$[\begin{matrix} 1 & 2 & 1 & 0 & 1 & 0 \\ 3 & 1 & 2 & 1 & 0 & 0 \\ 2 & 1 & 3 & 0 & 0 & 1 \end{matrix}]$
Clear the first column
Apply $R_2 \to R_2 - 3R_1$ and $R_3 \to R_3 - 2R_1$ . The right block is no longer the identity; it is accumulating the transformation.
$[\begin{matrix} 1 & 2 & 1 & 0 & 1 & 0 \\ 0 & - 5 & - 1 & 1 & - 3 & 0 \\ 0 & - 3 & 1 & 0 & - 2 & 1 \end{matrix}]$
Normalise and clear the second column
Scale with $R_2 \to -\tfrac{1}{5}R_2$ to obtain a leading $1$ , then clear above and below using $R_1 \to R_1 - 2R_2$ and $R_3 \to R_3 + 3R_2$ .
$[\begin{matrix} 1 & 0 & \frac{3}{5} & \frac{2}{5} & - \frac{1}{5} & 0 \\ 0 & 1 & \frac{1}{5} & - \frac{1}{5} & \frac{3}{5} & 0 \\ 0 & 0 & \frac{8}{5} & - \frac{3}{5} & - \frac{1}{5} & 1 \end{matrix}]$
Normalise and clear the third column
Scale with $R_3 \to \tfrac{5}{8}R_3$ , then apply $R_1 \to R_1 - \tfrac{3}{5}R_3$ and $R_2 \to R_2 - \tfrac{1}{5}R_3$ . The left block is now $I_3$ , which confirms that $A$ is nonsingular.
$[\begin{matrix} 1 & 0 & 0 & \frac{5}{8} & - \frac{1}{8} & - \frac{3}{8} \\ 0 & 1 & 0 & - \frac{1}{8} & \frac{5}{8} & - \frac{1}{8} \\ 0 & 0 & 1 & - \frac{3}{8} & - \frac{1}{8} & \frac{5}{8} \end{matrix}]$
Extract and verify the inverse
The right block is the candidate inverse. Its symmetry mirrors the symmetry of $A$ , which is one free check. A second check multiplies row $1$ of $A$ into column $1$ of the candidate: $\tfrac{1}{8}\left(3 \cdot 5 + 1 \cdot (-1) + 2 \cdot (-3)\right) = \tfrac{1}{8}(15 - 1 - 6) = 1$ , as required.
$A^{- 1} = \frac{1}{8} [\begin{matrix} 5 & - 1 & - 3 \\ - 1 & 5 & - 1 \\ - 3 & - 1 & 5 \end{matrix}]$
Convert an assay target into a recipe
A target assay of $\vec{b} = (7, 6, 7)$ gives blend proportions $\vec{x} = A^{-1}\vec{b}$ . The first entry is $\tfrac{1}{8}(35 - 6 - 21) = 1$ , the second is $\tfrac{1}{8}(-7 + 30 - 7) = 2$ , the third is $\tfrac{1}{8}(-21 - 6 + 35) = 1$ .
$\vec{x} = A^{- 1} [\begin{matrix} 7 \\ 6 \\ 7 \end{matrix}] = [\begin{matrix} 1 \\ 2 \\ 1 \end{matrix}]$
Contrast with a singular assay matrix
Had the third concentrate been a fixed dilution of the second — say column $3$ equal to $-2$ times column $2$ — the left block would have finished with a zero row. That is not an arithmetic failure but a physical statement: the three concentrates would span only a two-dimensional set of achievable assays, and most targets would be unreachable by any blend.

Result

One reduction produces $A^{-1}$ in exact rational form, after which every future assay target costs a single matrix-vector product rather than a fresh elimination. The verified target $(7, 6, 7)$ corresponds to blending the concentrates in the ratio $1 : 2 : 1$ . Because $A$ is nonsingular, each achievable assay corresponds to exactly one recipe, and negative entries in a computed recipe would signal a target outside the physically attainable region.

Applications & Industry Use

Mineral processing

Blend recipes from assay targets

With feedstock compositions as columns of $A$ , the inverse converts any required product assay into the blend proportions that achieve it. Inverting once and reusing the result suits a plant that re-specifies its target grade several times a shift while the feed sources remain unchanged.

Instrumentation and metrology

Sensor cross-talk decoupling

A multi-axis load cell or magnetometer produces raw channel readings related to true axis values by a calibration matrix determined during commissioning. Inverting that matrix once yields the decoupling matrix stored in firmware, so each measurement is corrected by a single matrix-vector product at sample rate.

Colour science and printing

Device colour transforms

Converting between an RGB primary set and CIE XYZ tristimulus coordinates uses a $3 \times 3$ matrix built from the primaries and white point. The reverse transform is its inverse, computed once at profile creation and embedded in the colour management pipeline.

Chemical engineering

Reactor recycle and species balances

Steady-state species balances around a recycle loop give a square linear system in the unknown stream compositions. When the same flowsheet is evaluated across many feed conditions, an explicit inverse of the balance matrix turns each case into a multiplication rather than a re-solve.

Cryptography

Key inversion over a finite field

Classical matrix ciphers encrypt blocks by multiplication with a key matrix over the integers modulo $m$ . Decryption requires the inverse over that modulus, obtained by the same augmented reduction with modular arithmetic, and the key is admissible only when its determinant is a unit modulo $m$ .

Geotechnical engineering

Back-analysis of soil parameters

A linearised model relating measured settlements to unknown stiffness parameters yields a square coefficient matrix. Inverting it exposes how strongly each measurement constrains each parameter, and near-singularity is the quantitative warning that the instrumentation layout cannot separate two parameters.

Design Considerations

Reduce the array as a unit

Every row operation must be applied across all $2n$ entries of the row. Operating on the left block alone silently destroys the correspondence between the accumulated transformation and the matrix it transforms, and the resulting right block is not an inverse of anything. This is the single most common procedural error in hand computation.

Pick pivots for the arithmetic you are doing

In exact arithmetic, promote a row whose leading entry is $1$ or a small integer to keep fractions manageable; the destination is unaffected because the reduced form is unique. In floating point, choose the largest available pivot magnitude in the column, because partial pivoting bounds the growth of the multipliers and hence of rounding error.

Prefer a factorisation unless the inverse itself is required

If the goal is to solve $A\vec{x} = \vec{b}$ for a handful of right-hand sides, an LU factorisation with triangular solves is cheaper and more accurate. Compute the explicit inverse when its entries are the deliverable — a decoupling matrix, a covariance, a set of influence coefficients — or when the number of right-hand sides is comparable to $n$ .

Exploit structure before calling a general routine

Diagonal, triangular, orthogonal, unitary and permutation matrices all invert far more cheaply than the general procedure. A permutation matrix inverts by transposition alone. Checking for structure costs $O(n^2)$ and can save an $O(n^3)$ reduction outright.

Treat near-singularity as a modelling result

A left block that reduces to something very close to $I_n$ but with a tiny pivot indicates a matrix that is technically invertible and practically useless. Report the condition number rather than the bare inverse; in a calibration or back-analysis context, a huge condition number means the experiment cannot distinguish two effects and the instrumentation, not the arithmetic, needs attention.

Keep an independent check on the result

The symmetry of the inverse of a symmetric matrix, agreement with the closed formula in the $2 \times 2$ case, and a spot check of one row-column product all cost far less than the reduction itself. Build one of them into any hand computation as a matter of routine.

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	Standardises the augmented-array notation, the symbol $I_n$ for the identity matrix and the placement of the inverse exponent used throughout this procedure.
`LAPACK / BLAS reference`	Linear Algebra PACKage reference implementation	Implements inversion as `xGETRF` followed by `xGETRI`, that is LU factorisation followed by explicit inversion, rather than as a single Gauss-Jordan sweep, because the factored form is reusable.
`IEEE 754-2019`	IEEE Standard for Floating-Point Arithmetic	Governs the rounding of every division and multiplication in the reduction, and defines the exceptional values that a division by a numerically zero pivot would produce.
`BLAS Level 3`	Basic Linear Algebra Subprograms, matrix-matrix level	Blocked inversion is expressed as matrix-matrix products so that the inner loops run at Level 3 efficiency, which is where nearly all achieved performance in dense inversion comes from.
`ISO/IEC 40314`	Mathematical Markup Language (MathML) Version 3.0	Encodes the partitioned arrays on this page with explicit column alignment, so the vertical rule separating the two blocks is semantic rather than decorative.

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	Hand computation, teaching examples and small calibration matrices where an exact inverse must be recorded.	Every entry is exactly right and singularity is detected with certainty, but intermediate fractions grow quickly and the method does not scale past a few dozen rows.
Fraction-free integer elimination	Integer matrices where exactness matters but rational blow-up must be contained; the inverse is then reported as an integer matrix over a common determinant denominator.	Keeps all intermediates integral and bounded by the Bareiss identity, at the cost of a less familiar algorithm and a deferred final division.
IEEE 754 binary64 (double precision)	The default for engineering matrices of moderate size assembled from measured data.	Fast and well supported, but a pivot that should be exactly zero appears as a small non-zero value, so singularity becomes a tolerance decision.
IEEE 754 binary32 (single precision)	Embedded decoupling matrices and graphics transforms where the matrix is small, fixed and well conditioned.	Halves storage and suits GPU pipelines, but about seven significant digits leaves little margin once the condition number exceeds roughly $10^{3}$ .
Fixed-point arithmetic	Inverse calibration matrices burned into microcontroller firmware without a floating-point unit.	Deterministic timing and small code size, but scaling must be designed by hand for every entry and overflow behaviour must be proved rather than assumed.
Modular arithmetic over $\mathbb{Z}_m$	Block ciphers, coding theory and multi-prime reconstruction of an exact rational inverse.	Exact with bounded operand size, but invertibility depends on the modulus: the determinant must be a unit, so an otherwise fine matrix can fail for a particular $m$ .

Manufacturing Notes

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

Operation count

Gauss-Jordan reduction of the $n \times 2n$ array costs about $2n^3$ floating-point operations. The LU route used by production libraries costs about $\tfrac{2}{3}n^3$ for the factorisation plus a further $\tfrac{4}{3}n^3$ for the inversion of the factors, so the totals are comparable; the LU route wins because the factors can be retained and reused for solves.

Doing it by hand

Work one pivot column at a time, left to right, and never move on until the column is clear both above and below. Write the fractions rather than converting to decimals, so that an exact final answer can be checked. Recording each operation in the margin makes an error traceable instead of forcing a restart.

Library behaviour

NumPy's numpy.linalg.inv and SciPy's scipy.linalg.inv both route through LAPACK's LU-based inversion; SymPy's Matrix.inv() offers Gauss-Jordan, LU and adjugate methods over exact fields. MATLAB's inv issues a warning when the reciprocal condition estimate is below tolerance rather than refusing to return a result.

Detecting singularity in floating point

An exact zero pivot almost never appears in floating-point elimination. Production code therefore compares the reciprocal condition estimate against a tolerance, or examines the smallest singular value, instead of testing a pivot for equality with zero. A singular value decomposition remains the most defensible instrument when the answer matters.

Verification strategy

Compute the residual $R = AJ - I_n$ and check that its norm is small relative to $n \, \varepsilon \, \| A \| \, \| J \|$ . For a symmetric input, verify that the computed inverse is symmetric to within the same tolerance. Both tests are $O(n^3)$ and $O(n^2)$ respectively and are cheap insurance on any new implementation.

Failure Modes & Common Mistakes

Failure modes, root causes and prevention
Failure mode / mistake	Impact	Root cause	Prevention & detection
Operating on one block only	high	Applying a row operation to the left block while forgetting the appended identity, or vice versa.	Treat each row of the $n \times 2n$ array as an indivisible unit; write the vertical rule as a visual reminder rather than a boundary.
Appending the identity on the wrong side	medium	Reducing $[\, I_n \mid A \,]$ instead of $[\, A \mid I_n \,]$ , on the assumption that the layout is arbitrary.	The matrix being reduced must occupy the leading columns, because it is the one that must become $I_n$ . Check the layout before the first operation.
Stopping at echelon form	high	Clearing only below each pivot, so the left block is triangular rather than the identity, and the right block is a partial transformation.	Continue until every pivot is the sole non-zero entry in its column. The left block must be exactly $I_n$ , verified entry by entry.
Declaring an inverse for a singular matrix	high	Reading off the right block without confirming that the left block reduced to $I_n$ .	Make the identity check an explicit gate in the procedure. A zero row in the left block means no inverse exists, full stop.
Misapplying the $2 \times 2$ formula	medium	Negating the diagonal and swapping the off-diagonal instead of the reverse, or omitting the division by $ad - bc$ .	State the formula as swap the diagonal, negate the off-diagonal, divide by the determinant, then verify by multiplying out one product.
Dividing by a numerically zero pivot	high	Testing a floating-point pivot for exact equality with zero, so a value of order $10^{-17}$ is accepted and amplified.	Use partial pivoting with a scaled tolerance, or decide invertibility from a condition estimate or singular values rather than from pivot inspection.
Inverting when a solve was wanted	medium	Writing `inv(A) @ b` in production code out of habit.	Use the library solve routine. Reserve explicit inversion for cases where the entries of the inverse are themselves required output.
Losing the sign in a scaling step	low	Scaling a row by a negative reciprocal such as $-\tfrac{1}{5}$ and applying the sign to only part of the row.	Write the scaled row out in full before using it to clear other rows, and confirm the pivot entry is exactly $1$ .

FAQs

Why does appending the identity matrix work?

Because row reduction is left multiplication by a product of elementary matrices. Reducing $[\, A \mid I_n \,]$ produces $[\, JA \mid J \,]$ where $J$ is that accumulated product, so when the left block becomes $I_n$ the right block is exactly the matrix that achieved the reduction — a left inverse of $A$ .

What happens if the matrix is singular?

The left block cannot reduce to $I_n$ ; a zero row appears instead. The procedure has then proved that at least one system $A\vec{x} = \vec{e}_j$ is inconsistent, so no matrix can satisfy $AB = I_n$ . This is a correct diagnosis of non-invertibility, not a breakdown of the method.

Does the answer depend on the order in which I choose pivots?

No. Reduced row-echelon form is unique, so any legal sequence of row operations reaches the same reduced array and hence the same inverse. Pivot order affects only the intermediate arithmetic, which is why it can be chosen for convenience in exact arithmetic and for stability in floating point.

Is there a closed formula for the inverse of an

n \times n

matrix?

Yes: the adjugate matrix divided by the determinant. It is invaluable in proofs and for symbolic $2 \times 2$ and $3 \times 3$ work, but computing it directly requires $n^2$ determinants of size $n-1$ , so its cost is astronomically worse than the polynomial cost of elimination.

Why do libraries use LU factorisation rather than Gauss-Jordan for inversion?

The operation counts are similar, but the LU factors are a reusable asset: they solve any number of later systems at $O(n^2)$ each, support determinant and condition estimation, and expose blocked formulations that map onto Level 3 BLAS. Gauss-Jordan produces the inverse and nothing else.

How many arithmetic operations does inverting a matrix cost?

Roughly $2n^3$ floating-point operations for a dense $n \times n$ matrix, against about $\tfrac{2}{3}n^3$ for a factorisation alone. Doubling the size therefore multiplies the work by about eight, which is why explicit inversion becomes untenable well before memory does.

Can I invert a matrix whose entries are unknown symbols?

For small sizes, yes — the $2 \times 2$ formula is exactly that. A computer algebra system will carry symbolic elimination further, but expression swell is severe and the result must be qualified by the assumption that every pivot encountered is non-zero, which is a case analysis in disguise.

References

Beezer, R. A. A First Course in Linear Algebra, Version 0.70. University of Puget Sound, 2006. Section MISLE, Subsection CIM. 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.
Higham, N. J. Accuracy and Stability of Numerical Algorithms, 2nd edition. Society for Industrial and Applied Mathematics, 2002.
IEEE 754-2019, IEEE Standard for Floating-Point Arithmetic. Institute of Electrical and Electronics Engineers.

AI Suggested Questions

Show the elementary matrices whose product equals $A^{-1}$ for a specific $3 \times 3$ reduction, and confirm the product numerically.
Compare the operation counts and measured runtimes of Gauss-Jordan inversion against LU-based inversion for a $1000 \times 1000$ matrix.
Derive the adjugate formula for a $3 \times 3$ inverse and explain why its cost grows factorially with size.
How should partial pivoting be organised when the augmented array $[\, A \mid I_n \,]$ is reduced in floating point?
Work through the inversion of a $3 \times 3$ matrix modulo $26$ and explain when the determinant fails to be a unit.
Given a symmetric positive definite matrix, how does a Cholesky-based inversion differ in cost and accuracy from the general method?

Related Calculators

Matrix Inverse Calculator

Invert a square matrix by augmented row reduction, with every intermediate array shown in exact rational form.

Gauss-Jordan Step Tool

Apply elementary row operations to an $n \times 2n$ array one at a time and watch the accumulated transformation build.

Two-by-Two Inverse Calculator

Apply the $ad - bc$ formula, report the determinant and flag singular inputs immediately.