Adjugate Matrix Calculator: How to Find adj(A) From the Cofactor Matrix
About the Author
Marko Šinko
Co-Founder & Lead Developer, AI Math Calculator
An adjugate matrix calculator computes the most renamed object in linear algebra. The matrix it produces — adj(A), the transpose of the cofactor matrix — answers to at least four names depending on when your textbook was printed: adjugate, adjoint, classical adjoint, occasionally adjunct. The recipe never changes, though. Replace every entry of A with its cofactor, transpose the result, done.
The calculator above runs that recipe on any 2×2 or 3×3 matrix and keeps the whole pipeline visible: the matrix of minors, the checkerboard of signs, the transpose, det(A), the inverse whenever it exists, and the product A·adj(A) as a built-in correctness check. This article covers the parts a tool can’t do for you on an exam — untangling the naming mess, the full 3×3 computation with all nine cofactors, the one identity that justifies the whole construction, and the surprisingly useful case where det(A) = 0.
Adjugate, Adjoint, Classical Adjoint: Untangling the Names
Here’s the collision. Older linear algebra books call the transposed cofactor matrix “the adjoint.” Modern mathematics uses adjoint for something completely different: the conjugate transpose A*, the workhorse of functional analysis and quantum mechanics. For a real matrix the conjugate transpose is just the ordinary transpose — and that is not the adjugate. Take A = [[1, 2], [3, 4]]. Its transpose is [[1, 3], [2, 4]]. Its adjugate is [[4, −2], [−3, 1]]. Different matrices, one overloaded word.
| Name | What it means | Where you’ll meet it |
|---|---|---|
| Adjugate, adj(A) | Transpose of the cofactor matrix | Modern linear algebra texts — the unambiguous term |
| Classical adjoint | Same matrix as adj(A) | Textbooks from roughly the 1990s and earlier |
| Adjoint, A* | Conjugate transpose — a different matrix entirely | Functional analysis, physics, numerical computing |
| Adjunct matrix | Same matrix as adj(A), rare spelling | Older translations and a handful of engineering texts |
So when a homework problem says “find the adjoint,” check the chapter. If cofactors were just introduced, it means adj(A) — exactly what this adjoint matrix calculator produces. If the course is about inner products and operators, it means the conjugate transpose, and no cofactors are involved at all.
Minors, Signs, Transpose: The Three Moves Inside an Adjugate Matrix Calculator
Every adjugate computation is the same three moves, whatever the size of the matrix. First, the minor Mij: delete row i and column j from A, then take the determinant of what remains. For a 3×3 matrix each minor is a small 2×2 determinant; for a 2×2 matrix each minor is a single leftover number. Second, the cofactor Cij = (−1)i+j·Mij — the famous checkerboard, which for a 3×3 looks like this:
+ − +
− + −
+ − +
Third, the move everyone forgets: transpose the cofactor matrix. In index form, adj(A)ij = Cji — note the flipped subscripts. The cofactor sitting at row 2, column 3 ends up at row 3, column 2 of the adjugate. Skipping this flip is the single most common way to lose marks on the whole topic, and it’s why the calculator displays the cofactor matrix and adj(A) side by side instead of jumping straight to the answer.
The 2×2 Adjugate Is a Two-Second Swap
Run the three moves on a general 2×2 matrix and they collapse into something you can do in your head. The minors are single entries, the checkerboard negates two of them, and the transpose shuffles the off-diagonal pair. The net effect: swap the main diagonal, negate the other two entries.
adj [[a, b], [c, d]] = [[d, −b], [−c, a]]
With numbers: A = [[4, 7], [2, 6]] gives adj(A) = [[6, −7], [−2, 4]] and det(A) = (4)(6) − (7)(2) = 10, so A⁻¹ = [[6/10, −7/10], [−2/10, 4/10]] = [[3/5, −7/10], [−1/5, 2/5]]. The classic misremembering is negating the diagonal instead of the off-diagonal — [[−d, b], [c, −a]] — and it’s worth knowing the ten-second self-check that catches it: multiply A by your candidate adjugate. The correct one returns [[10, 0], [0, 10]], the determinant down the diagonal. The wrong one returns a matrix with nonzero off-diagonal junk, and you’ll spot it immediately.
A Full 3×3 Adjugate, All Nine Cofactors Shown
Take A = [[1, 2, 3], [0, 1, 4], [5, 6, 0]] — the calculator’s default, and a favourite of textbook authors for a reason that’ll be obvious in a moment. Nine cofactors, nine small determinants:
| Cofactor | Sign | Minor computation | Value |
|---|---|---|---|
| C₁₁ | + | (1)(0) − (4)(6) = −24 | −24 |
| C₁₂ | − | (0)(0) − (4)(5) = −20 | 20 |
| C₁₃ | + | (0)(6) − (1)(5) = −5 | −5 |
| C₂₁ | − | (2)(0) − (3)(6) = −18 | 18 |
| C₂₂ | + | (1)(0) − (3)(5) = −15 | −15 |
| C₂₃ | − | (1)(6) − (2)(5) = −4 | 4 |
| C₃₁ | + | (2)(4) − (3)(1) = 5 | 5 |
| C₃₂ | − | (1)(4) − (3)(0) = 4 | −4 |
| C₃₃ | + | (1)(1) − (2)(0) = 1 | 1 |
Assemble the cofactor matrix, then transpose it:
C = [[−24, 20, −5], [18, −15, 4], [5, −4, 1]]
adj(A) = Cᵀ = [[−24, 18, 5], [20, −15, −4], [−5, 4, 1]]
Now the reason textbook authors love this matrix. Expanding along row 1 — which reuses three cofactors already sitting in the table — gives det(A) = (1)(−24) + (2)(20) + (3)(−5) = 1. When the determinant is exactly 1, dividing adj(A) by it changes nothing: the adjugate is the inverse, every entry a clean integer. Any integer matrix with det(A) = ±1 has this property, which is why they’re all over problem sets.
A·adj(A) = det(A)·I — the Identity That Earns the Adjugate Its Keep
Why build this matrix at all? One identity: A·adj(A) = adj(A)·A = det(A)·I, for every square matrix. The diagonal entries of the product are cofactor expansions of det(A) — each one a legitimate way to compute the determinant. The off-diagonal entries are cofactor expansions of a matrix with a duplicated row, and a determinant with two equal rows is always 0. That’s the entire proof, and Wikipedia’s adjugate matrix entry spells out each expansion if you want it line by line.
Divide both sides by det(A), whenever it isn’t 0, and out falls the classical adjoint formula for the matrix inverse: A⁻¹ = adj(A)/det(A). Read the same identity one column at a time and you get Cramer’s rule — each unknown as a ratio of two determinants. One identity, three exam topics.
A word of honesty about computation, though. The adjugate route to an inverse is beautiful for 2×2 and 3×3 matrices and a disaster beyond them: cofactor expansion grows factorially, so a 10×10 inverse by adjugate needs on the order of 10! ≈ 3.6 million multiplications, while Gauss-Jordan elimination needs roughly a thousand. That’s why software inverts by elimination and reserves the adjugate for theory, small matrices, and symbolic work where exact fractions matter.
A Singular Matrix Still Has an Adjugate
Here’s the case most courses skip. The inverse dies when det(A) = 0; the adjugate doesn’t. Take the singular classic A = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]. Grinding through the nine cofactors gives:
adj(A) = [[−3, 6, −3], [6, −12, 6], [−3, 6, −3]]
A · adj(A) = 0 (the 3×3 zero matrix — det(A)·I with det(A) = 0)
Look at the columns of that adjugate: every one is a multiple of (1, −2, 1). That’s no accident. Since A·adj(A) = 0, every column of adj(A) sits in the null space of A — the adjugate of a rank-deficient matrix hands you its null-space vector for free, a trick that’s genuinely used for computing eigenvectors of 3×3 matrices by hand. The pattern is governed by rank: if rank(A) = n, then adj(A) has full rank too; if rank(A) = n − 1, then rank(adj A) = 1, like here; and if rank(A) ≤ n − 2, the adjugate is the zero matrix outright — every minor dies.
Identities That Turn adj(A) Into a Shortcut
A handful of adjugate identities show up constantly in proofs and multiple-choice questions, and they’re quick to verify with the 2×2 example from earlier (A = [[4, 7], [2, 6]], det(A) = 10, n = matrix size):
| Identity | Numeric check |
|---|---|
| det(adj A) = det(A)ⁿ⁻¹ | det([[6, −7], [−2, 4]]) = 24 − 14 = 10 = 10¹ ✓ |
| adj(adj A) = det(A)ⁿ⁻² · A | adj([[6, −7], [−2, 4]]) = [[4, 7], [2, 6]] = A, since 10⁰ = 1 ✓ |
| adj(Aᵀ) = adj(A)ᵀ | Transposing first or last gives the same matrix |
| adj(AB) = adj(B) · adj(A) | Order reverses — same behaviour as inverses and transposes |
| adj(kA) = kⁿ⁻¹ · adj(A) | Doubling a 3×3 matrix multiplies its adjugate by 2² = 4 |
| adj(I) = I | Every cofactor of the identity is its own entry |
The second row deserves a second look: for every 2×2 matrix, taking the adjugate twice returns the original matrix exactly. That makes adj(adj A) = A a free sanity test — if a classical adjoint calculator (or your own working) fails it on a 2×2, something upstream is wrong. The scaling rule is the one that catches people on multiple-choice questions: adj(2A) is not 2·adj(A) for anything bigger than a 2×2, because every cofactor of a 3×3 is itself a 2×2 determinant and picks up the factor twice.
The Three Ways an Adjugate Goes Wrong
Grading patterns on this topic are remarkably consistent. Three specific errors account for nearly every wrong adjugate, and each one leaves a recognizable fingerprint:
- Stopping at the cofactor matrix. C and adj(A) agree on the diagonal, so the mistake hides there — but in a typical 3×3 all six off-diagonal entries end up in the wrong positions. In the worked example above, C has 20 where adj(A) has 18. If your answer matches the cofactor matrix, you skipped move three.
- Misplacing the checkerboard. Starting the sign pattern with − instead of +, or applying (−1)i+j twice, negates entries it shouldn’t. The fingerprint: A·adj(A) comes out as −det(A)·I or with sign-flipped off-diagonal garbage instead of zeros.
- Minor bookkeeping slips. Crossing out the wrong row, or reading the 2×2 submatrix in the wrong order, corrupts one or two entries while the rest stay right — the hardest error to spot by eye. The fix is mechanical: write each submatrix out fully before taking its determinant, exactly the way the calculator’s step-by-step view does.
All three share one antidote, and it’s the same check the tool runs automatically: multiply A by your adjugate. The product must be det(A)·I — determinant down the diagonal, zeros everywhere else. It costs thirty seconds by hand and catches every error above before it costs you the question.
