Wolfram Language & System Documentation Center

Inverse

Inverse[m]

gives the inverse of a square matrix m.

Details and Options

Inverse works on both symbolic and numerical matrices.
For matrices with approximate real or complex numbers, the inverse is generated to the maximum possible precision given the input. A warning is given for ill‐conditioned matrices.
The following options can be given
Method Automatic method to use

Modulus 0 integer modulus to use

ZeroTest Automatic test for whether an element is zero
Inverse[m,Modulus->p] evaluates the inverse of rational matrices modulo the integer n. If n is zero, ordinary arithmetic is used. If n is not prime, the computation may fail. »
Inverse[m,ZeroTest->test] evaluates test[m[[i,j]]] to determine whether matrix elements are zero.
Settings of Method applicable to exact and symbolic matrices include "CofactorExpansion", "DivisionFreeRowReduction", and "OneStepRowReduction". The default setting of Automatic switches among these methods depending on the matrix given.
Inverse[m] formats as in StandardForm and TraditionalForm. »

Examples

open all close all

Basic Examples (3)

Inverse of a 2×2 matrix:

Wolfram Language code: Inverse[{{1.4, 2}, {3, -6.7}}]

Enter the matrix in a grid:

Wolfram Language code:

Inverse[(|   |   |   |
| - | - | - |
| 1 | 2 | 3 |
| 4 | 2 | 2 |
| 5 | 1 | 7 |)]

Inverse of a symbolic matrix:

Wolfram Language code: Inverse[{{u, v}, {v, u}}]

Scope (14)

Basic Uses (9)

Find the inverse of a machine-precision matrix:

Wolfram Language code: Inverse[{{1.2, 2.5, -3.2}, {0.7, -9.4, 5.8}, {-0.2, 0.3, 6.4}}]

Invert a complex matrix:

Wolfram Language code: Inverse[{{1. + I, 2, 3 - 2I}, {0, 4π, 5I}, {E, 0, 6}}]

Inverse of an exact matrix:

Wolfram Language code: Inverse[{{2, 3, 2}, {4, 9, 2}, {7, 2, 4}}]

Inverse of an arbitrary-precision matrix:

Wolfram Language code: Inverse[RandomReal[1, {2, 2}, WorkingPrecision -> 20]]

Inverse of a symbolic matrix:

Wolfram Language code: Inverse[{{a, b}, {c, d}}]

Verifying a symbolic inverse may require simplification:

Wolfram Language code: %.{{a, b}, {c, d}}

Wolfram Language code: Simplify[%]

The inversion of large machine-precision matrices is efficient:

Wolfram Language code: a = RandomReal[{0, 10}, {800, 800}];

Wolfram Language code: Inverse[a];//Timing

Inverse of a matrix over a finite field:

Wolfram Language code:

ℱ = FiniteField[23, 4];
Inverse[{{ℱ[12], ℱ[23], ℱ[34]}, {ℱ[45], ℱ[56], ℱ[67]}, {ℱ[78], ℱ[89], ℱ[90]}}]//MatrixForm

Inverse of a CenteredInterval matrix:

Wolfram Language code: (m = Map[CenteredInterval, RandomReal[{-10, 10}, {3, 3}, WorkingPrecision -> 10], {2}])//MatrixForm

Wolfram Language code: (minv = Inverse[m])//MatrixForm

Find a random representative mrep of m:

Wolfram Language code:

ranrep[e_CenteredInterval] := e["Center"] + RandomInteger[{-1000, 1000}] / 1000e["Radius"]
(mrep = Map[ranrep, m, {2}])//MatrixForm

Verify that minv contains the inverse of mrep:

Wolfram Language code: MapThread[IntervalMemberQ, {minv, Inverse[mrep]}, 2]//MatrixForm

Output formatting:

Wolfram Language code: Inverse[m]

Special Matrices (5)

The inverse of a sparse matrix is returned as a normal matrix:

Wolfram Language code: SparseArray[{{1, 3} -> 1, {2, 2} -> 2, {3, 1} -> 3}, {3, 3}]

Wolfram Language code: Inverse[%]

Format the result:

Wolfram Language code: %//MatrixForm

When possible, the inverse of a structured matrix is returned as another structured matrix:

Wolfram Language code: QuantityArray[{{1, 2}, {3, 4}}, {"Meters", "Seconds"}]

Wolfram Language code: Inverse[%]

This is not always possible:

Wolfram Language code: SymmetrizedArray[{{1, 1} -> 3, {2, 2} -> 1, {3, 1} -> -5}, {3, 3}, Symmetric[All]]

Wolfram Language code: Inverse[%]

IdentityMatrix is its own inverse:

Wolfram Language code: Inverse[IdentityMatrix[3]]

Inverse of HilbertMatrix:

Wolfram Language code: Inverse[HilbertMatrix[3]]//MatrixForm

Visualize the inverses for several matrix sizes:

Wolfram Language code: Table[ArrayPlot[Inverse[HilbertMatrix[n]], Mesh -> True, ColorFunction -> "Rainbow"], {n, {3, 7, 15, 25}}]

Compute the inverse of a matrix of univariate polynomials of degree :

Wolfram Language code:

rpoly[n_] := RandomInteger[{-2 ^ 10, 2 ^ 10}, {n + 1}].x ^ Range[0, n]
SeedRandom[1234];
m = Table[rpoly[100], {10}, {10}];

Wolfram Language code: Inverse[m]//Short[#, 4]&//AbsoluteTiming

Options (7)

Method (4)

The Automatic method attempts to use a method appropriate for a given matrix:

Wolfram Language code: h = N[HilbertMatrix[5], 10];

Wolfram Language code: Inverse[h, Method -> Automatic]//MatrixForm

Here, the Automatic method has avoided numerical instability possible for some methods when applied to an ill-conditioned matrix:

Wolfram Language code: Inverse[h, Method -> "CofactorExpansion"]

Generate a random numeric matrix with small off-diagonal elements and compute its inverse using various methods:

Wolfram Language code:

SeedRandom[1111];
matrix = RandomReal[{0, 10 ^ -10}, {4, 4}] + DiagonalMatrix[{1, 1, 1, 1}]

Wolfram Language code:

inverses = Table[Inverse[matrix, Method -> meth], {meth, {Automatic, "CofactorExpansion", "DivisionFreeRowReduction", "OneStepRowReduction"}}];

The results are very close but can differ slightly in the least significant digits due to numerical precision handling:

Wolfram Language code: MatrixForm[inverses[[1]] - #]& /@ Rest[inverses]

Compare timings using different methods on a matrix with exact numeric entries:

Wolfram Language code: matrix = HilbertMatrix[11];

Wolfram Language code:

inverses = Table[RepeatedTiming@Inverse[matrix, Method -> meth], {meth, {Automatic, "CofactorExpansion", "DivisionFreeRowReduction", "OneStepRowReduction"}}];

Wolfram Language code: inverses[[All, 1]]

Create a matrix with several symbolic elements:

Wolfram Language code:

matrix = HilbertMatrix[7];
matrix[[1, {1, 2}]] = a;
matrix[[2, {3, 4}]] = {b, c};
matrix[[{3, 4}, 2]] = {c, b};
matrix[[4, 4]] = d;
MatrixForm[matrix]

Compare timings and result sizes using the different methods on this matrix:

Wolfram Language code:

inverses = Table[Timing[Inverse[matrix, Method -> meth]], {meth, {"CofactorExpansion", "DivisionFreeRowReduction", "OneStepRowReduction"}}];
Map[{#[[1]], LeafCount[#[[2]]]}&, inverses]

Modulus (1)

Invert a matrix using arithmetic modulo five:

Wolfram Language code: m = {{1, 2, 4}, {2, 0, 3}, {2, 1, 2}};

Wolfram Language code: Inverse[m, Modulus -> 5]

The inverse using normal arithmetic:

Wolfram Language code: Inverse[m]

Visualize the two results:

Wolfram Language code: {MatrixPlot[%], MatrixPlot[%%]}

ZeroTest (1)

The automatic zero test cannot detect that the following matrix is nonsingular:

Wolfram Language code:

m = {{1, 0}, {1, π - Root[8394424425973111046102466470564958295830951628283298149701386477242875447818673389226090192984\
029732939781061026077658550311303875032545498684307238995818676138470695390760454711538845664627035\
4435927421991406959528672443375423719871723709 ... 387494583708363193025825642551076544298993049143\
615185128783410198233550035568901018893959814690410410216282149769634197560732600787754846222883582\
50360748898046876231601365242979664076168746640932325062440279570663043850648012*#1^20 & , 4, 0]}}

Wolfram Language code: Inverse[m]

The problem is that machine-precision underflows for the bottom right entry:

Wolfram Language code:

N[π - Root[8394424425973111046102466470564958295830951628283298149701386477242875447818673389226090192984\
029732939781061026077658550311303875032545498684307238995818676138470695390760454711538845664627035\
4435927421991406959528672443375423719871723709 ... 387494583708363193025825642551076544298993049143\
615185128783410198233550035568901018893959814690410410216282149769634197560732600787754846222883582\
50360748898046876231601365242979664076168746640932325062440279570663043850648012*#1^20 & , 4, 0]]

The entry is very small but nonzero:

Wolfram Language code:

N[π - Root[8394424425973111046102466470564958295830951628283298149701386477242875447818673389226090192984\
029732939781061026077658550311303875032545498684307238995818676138470695390760454711538845664627035\
4435927421991406959528672443375423719871723709 ... 387494583708363193025825642551076544298993049143\
615185128783410198233550035568901018893959814690410410216282149769634197560732600787754846222883582\
50360748898046876231601365242979664076168746640932325062440279570663043850648012*#1^20 & , 4, 0], 10]

Use a zero test employing arbitrary-precision arithmetic to invert the matrix:

Wolfram Language code: Inverse[m, ZeroTest -> (N[#, $MachinePrecision] == 0&)]

Wolfram Language code: %.m//Simplify

Modulus (1)

Invert a matrix of integers modulo 5:

Wolfram Language code:

m = {{12, -2}, {1, 3}};
minv = Inverse[m, Modulus -> 5]

Check it:

Wolfram Language code: Mod[m.minv, 5]

Applications (10)

Solving Equations (4)

Solve the system of equations , , . First, form the coefficient matrix and constant vector :

Wolfram Language code:

a = {{6, 9, 0}, {-7, 0, 3}, {0, 5, 9}};
b = {11, -12, -9};
{a//MatrixForm, b//MatrixForm}

The solution is given by :

Wolfram Language code: Inverse[a].b

Substitute the solution into the original system of equations to verify the solution:

Wolfram Language code: 6x + 9y == 11 && 3z - 7x == -12 && 5y + 9z == -9 /. Thread[{x, y, z} -> %]

Solve the matrix equation :

Wolfram Language code: m = {{1, 2}, {3, 4}};b = {5, 6};

Multiplying both sides of the equation on the left by shows :

Wolfram Language code: Inverse[m].b

Confirm the result using LinearSolve:

Wolfram Language code: LinearSolve[m, b]

For numerical and especially sparse systems, LinearSolve can be considerably faster:

Wolfram Language code:

n = 3500;
s = SparseArray[{{i_, i_} -> -2., {i_, j_} /; Abs[i - j] == 1 -> 1.}, {n, n}];
v = RandomReal[1, n];

Wolfram Language code: AbsoluteTiming[LinearSolve[s, v];]

Wolfram Language code: AbsoluteTiming[Inverse[s].v;]

Solve the matrix equation :

Wolfram Language code: m = {{-6, 7, 9}, {-2, 1, 3}, {7, -10, 4}};y = {{-5, 6, -4}, {-7, 7, 8}, {-2, 1, 12}};

Multiplying both sides of the equation on the left by shows :

Wolfram Language code: Inverse[m].y

Substitute the solution into the equation for verification:

Wolfram Language code: m.x == y /. x -> %

Solve the system of ODEs , , . First, construct the coefficient matrix for the right-hand side:

Wolfram Language code: a = {{0, 1, 0}, {0, 0, 1}, {-2, 1, 2}};

Find the eigenvalues and eigenvectors:

Wolfram Language code: {λ, v} = Eigensystem[a]

Construct a diagonal matrix whose entries are the exponential of :

Wolfram Language code: d = DiagonalMatrix[Exp[t λ]]

Construct the matrix whose columns are the corresponding eigenvectors:

Wolfram Language code: p = Transpose[v]

The general solution is , for three arbitrary starting values:

Wolfram Language code: p.d.Inverse[p].{C[1], C[2], C[3]}

Verify the solution using DSolveValue:

Wolfram Language code: Simplify[% == DSolveValue[{x'[t] == y[t], y'[t] == z[t], z'[t] == -2x[t] + y[t] + 2z[t]}, {x[t], y[t], z[t]}, t]]

Change of Basis/Coordinates (6)

Express a general vector in $TemplateBox[{}, Reals]^3$ as a linear combination of the vectors , and . First, verify the vectors are linearly independent by checking that their null space is empty:

Wolfram Language code:

Subscript[b, 1] = {1, 0, 1};Subscript[b, 2] = {2, 2, 3};Subscript[b, 3] = {-1, -1, 1};
NullSpace[{Subscript[b, 1], Subscript[b, 2], Subscript[b, 3]}]

Form the matrix whose columns are the basis vectors:

Wolfram Language code: p = Transpose[{Subscript[b, 1], Subscript[b, 2], Subscript[b, 3]}];

The coefficients of a general vector are given by :

Wolfram Language code: {Subscript[c, 1], Subscript[c, 2], Subscript[c, 3]} = Inverse[p].{x, y, z}

Verify that does indeed equal the linear combination :

Wolfram Language code: Simplify[Underoverscript[∑, i = 1, 3]Subscript[c, i]Subscript[b, i]]

Find the change-of-basis matrix that transforms coordinates with respect to the basis to coordinates with respect to the basis :

Wolfram Language code: {Subscript[b, 1], Subscript[b, 2], Subscript[b, 3]} = {{2, 5, -4}, {1, 0, 3}, {-3, 3, -2}};

Wolfram Language code: {Subscript[d, 1], Subscript[d, 2], Subscript[d, 3]} = {{-2, 4, 1}, {3, -4, -1}, {3, 3, -4}};

The matrix whose columns are the transforms from -coordinates to standard coordinates:

Wolfram Language code: (p = Transpose[{Subscript[b, 1], Subscript[b, 2], Subscript[b, 3]}])//MatrixForm

The matrix whose columns are the transforms from -coordinates to standard coordinates:

Wolfram Language code: (q = Transpose[{Subscript[d, 1], Subscript[d, 2], Subscript[d, 3]}])//MatrixForm

Its inverse converts from standard coordinates back to -coordinates:

Wolfram Language code: Inverse[q]

Therefore, converts from -coordinates to -coordinates:

Wolfram Language code: Inverse[q].p

Express the linear operator whose representation in the standard is given by in the basis , ,

Wolfram Language code: (m = {{1, 2, -3}, {2, 0, 1}, {-3, 1, 5}})//MatrixForm

Wolfram Language code: Subscript[b, 1] = {1, 0, 1};Subscript[b, 2] = {2, 2, 3};Subscript[b, 3] = {-1, -1, 2};

The matrix whose columns are the transforms from -coordinates to standard coordinates:

Wolfram Language code: (p = Transpose[{Subscript[b, 1], Subscript[b, 2], Subscript[b, 3]}])//MatrixForm

Its inverse converts from standard coordinates to -coordinates:

Wolfram Language code: Inverse[p]

Therefore the representation of in -coordinates is:

Wolfram Language code: p.m.Inverse[p]

Inverse can be used to diagonalize a matrix as . Compute 's eigenvalues and eigenvectors:

Wolfram Language code: m = {{9, -7, 3}, {12, -10, 3}, {16, -16, 1}};

Wolfram Language code: Eigensystem[m]

Construct a diagonal matrix from the eigenvalues and a matrix whose columns are the eigenvectors:

Wolfram Language code: {d = DiagonalMatrix[First[%]], p = Transpose[Last[%]]}

Confirm the identity :

Wolfram Language code: m == p.d.Inverse[p]

Any function of the matrix can now be computed as . For example, MatrixPower:

Wolfram Language code: MatrixPower[m, k] == p.MatrixPower[d, k].Inverse[p]

Similarly, MatrixExp becomes trivial, requiring only exponentiating the diagonal elements of :

Wolfram Language code: MatrixExp[m] == p.MatrixExp[d].Inverse[p]

Wolfram Language code: MatrixExp[d]

Inverse of a transformation matrix gives the matrix for the reverse operation. For example, consider a translation by :

Wolfram Language code: trans = TranslationTransform[{Δx, Δy, Δz}]

The inverse of its transformation matrix gives a translation by the opposite motion:

Wolfram Language code: Inverse[TransformationMatrix[trans]]//MatrixForm

Wolfram Language code: TransformationFunction[%] == TranslationTransform[-{Δx, Δy, Δz}]

Consider a general affine transformation:

Wolfram Language code: aff = LinearFractionalTransform[{Array[Subscript[a, #1, #2]&, {2, 2}], Array[Subscript[b, #]&, {2}]}]

Construct the inverse transformation:

Wolfram Language code: affInv = TransformationFunction[Inverse[TransformationMatrix[aff]]]

Verify that the two transformations really do undo each other:

Wolfram Language code: affInv[aff[{x, y}]]//Simplify

Wolfram Language code: aff[affInv[{x, y}]]//Simplify

For a mapping $f:x in TemplateBox[{}, Reals]^n->y in TemplateBox[{}, Reals]^n$ , the Jacobian of the inverse mapping $TemplateBox[{{f, ^, {(, {(, {-, 1}, )}, )}}, y}, Grad]$ is given by . Consider the mapping from Cartesian to spherical coordinates:

Wolfram Language code: f[x_, y_, z_] := {Sqrt[x^2 + y^2 + z^2], ArcTan[z, Sqrt[x^2 + y^2]], ArcTan[x, y]}

Compute the Jacobian at the point :

Wolfram Language code: fJac = Grad[f[x, y, z], {x, y, z}] /. {x -> 1, y -> 1, z -> 0}

The inverse mapping is the transformation from spherical back to Cartesian coordinates:

Wolfram Language code: fInv[r_, θ_, φ_] := {r Cos[φ]Sin[θ], r Sin[θ]Sin[φ], r Cos[θ]}

Verify the inverse function:

Wolfram Language code: fInv@@f[x, y, z]

Compute the Jacobian of the inverse mapping at the coordinates corresponding to :

Wolfram Language code: fInvJac = Grad[fInv[r, θ, φ], {r, θ, φ}] /. Thread[{r, θ, φ} -> f[1, 1, 0]]

Confirm the identity $TemplateBox[{{f, ^, {(, {(, {-, 1}, )}, )}}, y}, Grad]=TemplateBox[{{(, TemplateBox[{f, x}, Grad, SyntaxForm -> Del], )}}, Inverse]$ :

Wolfram Language code: fInvJac == Inverse[fJac]

Properties & Relations (13)

Inverse satisfies the relation for an matrix :

Wolfram Language code: a = {{1, 2}, {3, 4}}

Wolfram Language code: a.Inverse[a] == Inverse[a].a == IdentityMatrix[2]

Inverse satisfies the relation :

Wolfram Language code: a = {{1, 1, 1}, {6, 9, 7}, {8, 1, 9}};

Wolfram Language code: b = {{0, 3, 9}, {7, 9, 7}, {4, 4, 1}};

Wolfram Language code: Inverse[a.b] == Inverse[b].Inverse[a]

Inverse satisfies the relation :

Wolfram Language code: a = {{-(1/25), (12/25), -(7/25)}, {-(7/25), (9/25), (1/25)}, {(13/75), -(31/75), (16/75)}};

Wolfram Language code: Inverse[Transpose[a]] == Transpose[Inverse[a]]

A square matrix has an inverse if and only if its determinant is nonzero:

Wolfram Language code:

m = (|   |   |   |
| - | - | - |
| 1 | 2 | 3 |
| 4 | 5 | 6 |
| 7 | 8 | 9 |);

Wolfram Language code: Det[m]

Wolfram Language code: Inverse[m]

Moreover, determinant of the inverse equals :

Wolfram Language code: a = RandomReal[1, {5, 5}];

Wolfram Language code: Det[Inverse[a]] == (1/Det[a])

MatrixPower[m,-1] equals Inverse[m]:

Wolfram Language code: m = {{9, 4, 1, 8}, {4, 8, 3, 4}, {7, 6, 8, 4}, {6, 9, 0, 9}};

Wolfram Language code: MatrixPower[m, -1] == Inverse[m]

For an invertible matrix , Inverse[a] equals Adjugate[a]/Det[a]:

Wolfram Language code: a = {{1, 3, 5}, {7, 1, -1}, {8, 4, 1}};

Wolfram Language code: Inverse[a] == Adjugate[a] / Det[a]

Inverse[m] equals LinearSolve[m,IdentityMatrix[n]] for an invertible n×n matrix:

Wolfram Language code: m = RandomReal[1, {5, 5}];

Wolfram Language code: Inverse[m] == LinearSolve[m, IdentityMatrix[5]]

The inverse of an orthogonal matrix is given by Transpose:

Wolfram Language code: r = {{-(6/7), (2/7), (3/7)}, {(2/7), -(3/7), (6/7)}, {(3/7), (6/7), (2/7)}};

Wolfram Language code: OrthogonalMatrixQ[r]

Wolfram Language code: Inverse[r] == Transpose[r]

The inverse of a unitary matrix is given by ConjugateTranspose:

Wolfram Language code: u = {{-(8/9), -(2I/9), (2/9) - (I/3)}, {(2I/9), -(5/9), (2/3) + (4I/9)}, {(2/9) + (I/3), (2/3) - (4I/9), (4/9)}};

Wolfram Language code: UnitaryMatrixQ[u]

Wolfram Language code: Inverse[u] == ConjugateTranspose[u]

A matrix and its inverse have the same symmetry:

Wolfram Language code: s = {{3, 0, -5}, {0, 1, 0}, {-5, 0, 0}};

Wolfram Language code: {TensorSymmetry[s], TensorSymmetry[Inverse[s]]}

Wolfram Language code: a = {{0, -(3/2), (5/2), -6}, {(3/2), 0, 4, 3}, {-(5/2), -4, 0, -5}, {6, -3, 5, 0}};

Wolfram Language code: {TensorSymmetry[a], TensorSymmetry[Inverse[a]]}

A QuantityArray and its inverse have reciprocal units:

Wolfram Language code: QuantityArray[{{1, 2}, {3, 4}}, {("Meters"/"Seconds"), ("Meters"/"Seconds")}]

Wolfram Language code: Inverse[%]

For an invertible matrix , Inverse[a] and PseudoInverse[a] coincide:

Wolfram Language code:

a = (⁠|   |   |   |
| - | - | - |
| 4 | 3 | 8 |
| 9 | 5 | 2 |
| 9 | 6 | 7 |⁠);

Wolfram Language code: Inverse[a] === PseudoInverse[a]

PseudoInverse extends to singular as well as rectangular matrices:

Wolfram Language code:

PseudoInverse[(|   |   |
| - | - |
| 1 | 2 |
| 1 | 2 |)]//MatrixForm

Wolfram Language code:

PseudoInverse[(|   |   |
| - | - |
| 1 | 2 |
| 3 | 4 |
| 5 | 6 |)]//MatrixForm

For an invertible matrix , Inverse[a] and DrazinInverse[a] coincide:

Wolfram Language code:

a = (⁠|   |   |   |
| - | - | - |
| 4 | 3 | 8 |
| 9 | 5 | 2 |
| 9 | 6 | 7 |⁠);

Wolfram Language code: Inverse[a] === DrazinInverse[a]

DrazinInverse extends to singular square matrices:

Wolfram Language code:

DrazinInverse[(|   |   |
| - | - |
| 1 | 2 |
| 1 | 2 |)]//MatrixForm

Possible Issues (4)

The inverse may not exist:

Wolfram Language code:

Inverse[(|   |   |
| - | - |
| 1 | 2 |
| 1 | 2 |)]

Typically a pseudo inverse does:

Wolfram Language code:

PseudoInverse[(|   |   |
| - | - |
| 1 | 2 |
| 1 | 2 |)]

Full inverses do not exist for rectangular matrices:

Wolfram Language code:

Inverse[(|   |   |   |
| - | - | - |
| 1 | 2 | 2 |
| 3 | 1 | 4 |)]

Use PseudoInverse instead:

Wolfram Language code:

PseudoInverse[(|   |   |   |
| - | - | - |
| 1 | 2 | 2 |
| 3 | 1 | 4 |)]

Accurate inverses cannot be found for ill-conditioned machine-precision numerical matrices:

Wolfram Language code: Inverse[N@HilbertMatrix[15]][[1, 1]]

Exact result:

Wolfram Language code: Inverse[HilbertMatrix[15]][[1, 1]]

Arbitrary-precision result:

Wolfram Language code: Inverse[N[HilbertMatrix[15], 30]][[1, 1]]

The computation may fail if a non-prime modulus is provided:

Wolfram Language code: Inverse[{{1, 2}, {3, 2}}, Modulus -> 6]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

Inverse

Details and Options

Examples

Basic Examples (3)

Scope (14)

Basic Uses (9)

Special Matrices (5)

Options (7)

Method (4)

Modulus (1)

ZeroTest (1)

Modulus (1)

Applications (10)

Solving Equations (4)

Change of Basis/Coordinates (6)

Properties & Relations (13)

Possible Issues (4)

Text

CMS

APA

BibTeX

BibLaTeX

Inverse

Details and Options

Examples

Basic Examples (3)

Scope (14)

Basic Uses (9)

Special Matrices (5)

Options (7)

Method (4)

Modulus (1)

ZeroTest (1)

Modulus (1)

Applications (10)

Solving Equations (4)

Change of Basis/Coordinates (6)

Properties & Relations (13)

Possible Issues (4)

See Also

Tech Notes

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX