---
title: "Inverse"
language: "en"
type: "Symbol"
summary: "Inverse[m] gives the inverse of a square matrix m."
keywords: 
- Cholesky
- cofactor expansion
- division-free row reduction
- inverse of a matrix
- inversion of matrices
- invert
- Krylov
- LINPACK
- multifrontal
- one-step row reduction
- minverse
- INVERT
- MatrixInverse
- inv
canonical_url: "https://reference.wolfram.com/language/ref/Inverse.html"
source: "Wolfram Language Documentation"
related_guides: 
  - 
    title: "Matrix Operations"
    link: "https://reference.wolfram.com/language/guide/MatrixOperations.en.md"
  - 
    title: "Linear Systems"
    link: "https://reference.wolfram.com/language/guide/LinearSystems.en.md"
  - 
    title: "Matrices and Linear Algebra"
    link: "https://reference.wolfram.com/language/guide/MatricesAndLinearAlgebra.en.md"
  - 
    title: "Finite Mathematics"
    link: "https://reference.wolfram.com/language/guide/FiniteMathematics.en.md"
  - 
    title: "Finite Fields"
    link: "https://reference.wolfram.com/language/guide/FiniteFields.en.md"
  - 
    title: "GPU Computing"
    link: "https://reference.wolfram.com/language/guide/GPUComputing.en.md"
  - 
    title: "Symbolic Vectors, Matrices and Arrays"
    link: "https://reference.wolfram.com/language/guide/SymbolicArrays.en.md"
  - 
    title: "Structured Arrays"
    link: "https://reference.wolfram.com/language/guide/StructuredArrays.en.md"
  - 
    title: "GPU Computing with NVIDIA"
    link: "https://reference.wolfram.com/language/guide/GPUComputing-NVIDIA.en.md"
related_functions: 
  - 
    title: "PseudoInverse"
    link: "https://reference.wolfram.com/language/ref/PseudoInverse.en.md"
  - 
    title: "LinearSolve"
    link: "https://reference.wolfram.com/language/ref/LinearSolve.en.md"
  - 
    title: "RowReduce"
    link: "https://reference.wolfram.com/language/ref/RowReduce.en.md"
  - 
    title: "NullSpace"
    link: "https://reference.wolfram.com/language/ref/NullSpace.en.md"
  - 
    title: "LinearSolveFunction"
    link: "https://reference.wolfram.com/language/ref/LinearSolveFunction.en.md"
  - 
    title: "DrazinInverse"
    link: "https://reference.wolfram.com/language/ref/DrazinInverse.en.md"
  - 
    title: "Adjugate"
    link: "https://reference.wolfram.com/language/ref/Adjugate.en.md"
  - 
    title: "MatrixRank"
    link: "https://reference.wolfram.com/language/ref/MatrixRank.en.md"
related_tutorials: 
  - 
    title: "Vectors and Matrices"
    link: "https://reference.wolfram.com/language/tutorial/Lists.en.md#2534"
  - 
    title: "Matrix Inversion"
    link: "https://reference.wolfram.com/language/tutorial/LinearAlgebra.en.md#7971"
  - 
    title: "Implementation notes: Numerical and Related Functions"
    link: "https://reference.wolfram.com/language/tutorial/SomeNotesOnInternalImplementation.en.md#5783"
---
# 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 ``Inverse[m]`` in ``StandardForm`` and ``TraditionalForm``. »

---

## Examples (51)

### Basic Examples (3)

Inverse of a 2×2 matrix:

```wl
In[1]:= Inverse[{{1.4, 2}, {3, -6.7}}]

Out[1]= {{0.435631, 0.130039}, {0.195059, -0.0910273}}
```

---

Enter the matrix in a grid:

```wl
In[1]:=
Inverse[(|   |   |   |
| - | - | - |
| 1 | 2 | 3 |
| 4 | 2 | 2 |
| 5 | 1 | 7 |)]

Out[1]= {{-(2/7), (11/42), (1/21)}, {(3/7), (4/21), -(5/21)}, {(1/7), -(3/14), (1/7)}}
```

---

Inverse of a symbolic matrix:

```wl
In[1]:= Inverse[{{u, v}, {v, u}}]

Out[1]= {{(u/u^2 - v^2), -(v/u^2 - v^2)}, {-(v/u^2 - v^2), (u/u^2 - v^2)}}
```

### Scope (14)

#### Basic Uses (9)

Find the inverse of a machine-precision matrix:

```wl
In[1]:= Inverse[{{1.2, 2.5, -3.2}, {0.7, -9.4, 5.8}, {-0.2, 0.3, 6.4}}]

Out[1]= {{0.74546, 0.204249, 0.187629}, {0.0679223, -0.0847825, 0.110795}, {0.0201118, 0.010357, 0.15692}}
```

---

Invert a complex matrix:

```wl
In[1]:= Inverse[{{1. + I, 2, 3 - 2I}, {0, 4π, 5I}, {E, 0, 6}}]

Out[1]= {{-0.068193 - 0.430381 I, 0.0108533  + 0.0684973 I, 0.234638  + 0.183415 I}, {0.0775812  - 0.0122926 I, 0.06723  + 0.00195643 I, -0.0330627 - 0.0240183 I}, {0.0308946  + 0.194983 I, -0.00491703 - 0.0310325 I, 0.0603647  - 0.0830957 I}}
```

---

Inverse of an exact matrix:

```wl
In[1]:= Inverse[{{2, 3, 2}, {4, 9, 2}, {7, 2, 4}}]

Out[1]= {{-(8/13), (2/13), (3/13)}, {(1/26), (3/26), -(1/13)}, {(55/52), -(17/52), -(3/26)}}
```

---

Inverse of an arbitrary-precision matrix:

```wl
In[1]:= Inverse[RandomReal[1, {2, 2}, WorkingPrecision -> 20]]

Out[1]= {{-0.41246390063006539542, 1.3376508059945982496}, {1.7136983587758040561, -1.3533336473923900597}}
```

---

Inverse of a symbolic matrix:

```wl
In[1]:= Inverse[{{a, b}, {c, d}}]

Out[1]= {{(d/-b c + a d), -(b/-b c + a d)}, {-(c/-b c + a d), (a/-b c + a d)}}
```

Verifying a symbolic inverse may require simplification:

```wl
In[2]:= %.{{a, b}, {c, d}}

Out[2]= {{-(b c/-b c + a d) + (a d/-b c + a d), 0}, {0, -(b c/-b c + a d) + (a d/-b c + a d)}}

In[3]:= Simplify[%]

Out[3]= {{1, 0}, {0, 1}}
```

---

The inversion of large machine-precision matrices is efficient:

```wl
In[1]:= a = RandomReal[{0, 10}, {800, 800}];

In[2]:= Inverse[a];//Timing

Out[2]= {0.365246, Null}
```

---

Inverse of a matrix over a finite field:

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

Out[1]//MatrixForm= [image]
```

---

Inverse of a ``CenteredInterval`` matrix:

```wl
In[1]:= (m = Map[CenteredInterval, RandomReal[{-10, 10}, {3, 3}, WorkingPrecision -> 10], {2}])//MatrixForm

Out[1]//MatrixForm=
(⁠|                                                            |                                                             |                                                            |
| ---------------------------------------------------------- ... enteredInterval[{{9681637715, -31, 1039557934, -61}, 44}] |
| CenteredInterval[{{3052562915, -32, 655532895, -63}, 44}]  | CenteredInterval[{{-5773888925, -32, 619966603, -62}, 44}]  | CenteredInterval[{{-4028974885, -30, 865215769, -61}, 44}] |⁠)

In[2]:= (minv = Inverse[m])//MatrixForm

Out[2]//MatrixForm=
(⁠|                                                                |                                                                 |                                                                |
| ---------------------------------------------- ... {{-8494586696887, -45, 679451292, -61}, 44}]  |
| CenteredInterval[{{-16479187694495, -50, 726415778, -64}, 44}] | CenteredInterval[{{5727721698577, -47, 930490760, -64}, 44}]    | CenteredInterval[{{-15200309067483, -46, 575831808, -63}, 44}] |⁠)
```

Find a random representative ``mrep`` of ``m`` :

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

Out[3]//MatrixForm=
(⁠|                                               |                                                  |                                                   |
| --------------------------------------------- | ------------------------------------------- ... 2205144626787/57646075230342348800)    | (5197789669818438115839/1152921504606846976000)   |
| (327766447230420984161/461168601842738790400) | -(1549916506611497486057/1152921504606846976000) | -(8652157683249603138977/2305843009213693952000)  |⁠)
```

Verify that ``minv`` contains the inverse of ``mrep`` :

```wl
In[4]:= MapThread[IntervalMemberQ, {minv, Inverse[mrep]}, 2]//MatrixForm

Out[4]//MatrixForm=
(⁠|      |      |      |
| ---- | ---- | ---- |
| True | True | True |
| True | True | True |
| True | True | True |⁠)
```

---

Output formatting:

```wl
In[1]:= Inverse[m]

Out[1]= Inverse[m]
```

#### Special Matrices (5)

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

```wl
In[1]:= SparseArray[{{1, 3} -> 1, {2, 2} -> 2, {3, 1} -> 3}, {3, 3}]

Out[1]= SparseArray[Automatic, {3, 3}, 0, {1, {{0, 1, 2, 3}, {{3}, {2}, {1}}}, {1, 2, 3}}]

In[2]:= Inverse[%]

Out[2]= {{0, 0, (1/3)}, {0, (1/2), 0}, {1, 0, 0}}
```

Format the result:

```wl
In[3]:= %//MatrixForm

Out[3]//MatrixForm=
(⁠|   |       |       |
| - | ----- | ----- |
| 0 | 0     | (1/3) |
| 0 | (1/2) | 0     |
| 1 | 0     | 0     |⁠)
```

---

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

```wl
In[1]:= QuantityArray[{{1, 2}, {3, 4}}, {"Meters", "Seconds"}]

Out[1]=
QuantityArray[StructuredArray`StructuredData[{2, 2}, {{{1, 2}, {3, 4}}, {"Meters", "Seconds"}, 
   {{1}, {2}}}]]

In[2]:= Inverse[%]

Out[2]=
QuantityArray[StructuredArray`StructuredData[{2, 2}, {{{-2, Rational[3, 2]}, {1, Rational[-1, 2]}}, 
   {"Meters"^(-1), "Seconds"^(-1)}, {{2}, {1}}}]]
```

This is not always possible:

```wl
In[3]:= SymmetrizedArray[{{1, 1} -> 3, {2, 2} -> 1, {3, 1} -> -5}, {3, 3}, Symmetric[All]]

Out[3]=
SymmetrizedArray[StructuredArray`StructuredData[{3, 3}, {{{1, 1} -> 3, {1, 3} -> -5, {2, 2} -> 1}, 
   Symmetric[{1, 2}]}]]

In[4]:= Inverse[%]

Out[4]= {{0, 0, -(1/5)}, {0, 1, 0}, {-(1/5), 0, -(3/25)}}
```

---

``IdentityMatrix`` is its own inverse:

```wl
In[1]:= Inverse[IdentityMatrix[3]]

Out[1]= {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}
```

---

Inverse of ``HilbertMatrix`` :

```wl
In[1]:= Inverse[HilbertMatrix[3]]//MatrixForm

Out[1]//MatrixForm=
(⁠|     |      |      |
| --- | ---- | ---- |
| 9   | -36  | 30   |
| -36 | 192  | -180 |
| 30  | -180 | 180  |⁠)
```

Visualize the inverses for several matrix sizes:

```wl
In[2]:= Table[ArrayPlot[Inverse[HilbertMatrix[n]], Mesh -> True, ColorFunction -> "Rainbow"], {n, {3, 7, 15, 25}}]

Out[2]= {[image], [image], [image], [image]}
```

---

Compute the inverse of a $10\times 10$ matrix of univariate polynomials of degree $100$ :

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

In[2]:= Inverse[m]//Short[#, 4]&//AbsoluteTiming

Out[2]= {2.4998, {{(«1335» + 822285305206069049790162945 x^900) / (3034638622673506403581743718005 + «1485» + 998816316987602849360464925610 x^1000), («1»/«1»), («1»/«1»), («1»/«1»), («1»/«1»), («1»/«1»), («1»/«1»), («1»/«1»), («1»/3034638622673506403581743718005 + «1485» + «1»), («1»/«1»)}, «9»}}
```

### Options (7)

#### Method (4)

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

```wl
In[1]:= h = N[HilbertMatrix[5], 10];

In[2]:= Inverse[h, Method -> Automatic]//MatrixForm

Out[2]//MatrixForm=
(⁠|              |              |              |              |              |
| ------------ | ------------ | ------------ | ------------ | ------------ |
| 25.00000000  | -300.0000000 | 1050.000000  | -1400.000000 | 630.0000000  |
| -300.0000000  ... -12600.00000 |
| 1050.000000  | -18900.00000 | 79380.00000  | -117600.0000 | 56700.00000  |
| -1400.000000 | 26880.00000  | -117600.0000 | 179200.0000  | -88200.00000 |
| 630.0000000  | -12600.00000 | 56700.00000  | -88200.00000 | 44100.00000  |⁠)
```

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

```wl
In[3]:= Inverse[h, Method -> "CofactorExpansion"]
```

Inverse::sing: Matrix {{1.000000000,0.5000000000,0.3333333333,0.2500000000,0.2000000000},<<3>>,{0.2000000000,0.1666666667,0.1428571429,0.1250000000,0.1111111111}} is singular.

```wl
Out[3]= Inverse[{{1.000000000, 0.5000000000, 0.3333333333, 0.2500000000, 0.2000000000}, {0.5000000000, 0.3333333333, 0.2500000000, 0.2000000000, 0.1666666667}, {0.3333333333, 0.2500000000, 0.2000000000, 0.1666666667, 0.1428571429}, {0.2500000000, 0.2000000000, 0.1666666667, 0.1428571429, 0.1250000000}, {0.2000000000, 0.1666666667, 0.1428571429, 0.1250000000, 0.1111111111}}, Method -> "CofactorExpansion"]
```

---

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

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

Out[1]= {{1., 5.562659362959752`*^-11, 8.076816868335859`*^-11, 5.2798284115799055`*^-11}, {5.558767623869201`*^-11, 1., 9.075966782672407`*^-11, 3.643901151484488`*^-11}, {7.22450567447879`*^-11, 4.201865534344489`*^-11, 1., 1.300203320896276`*^-11}, {2.6639760381147483`*^-11, 8.798874749233894`*^-11, 1.853749394363635`*^-11, 1.}}

In[2]:= 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:

```wl
In[3]:= MatrixForm[inverses[[1]] - #]& /@ Rest[inverses]

Out[3]=
{(⁠|                           |                          |    |                          |
| ------------------------- | ------------------------ | -- | ------------------------ |
| 0.                        | 0.                       | 0. | 0.    ...    |    |    |    |
| ------------------------- | -- | -- | -- |
| 0.                        | 0. | 0. | 0. |
| 0.                        | 0. | 0. | 0. |
| -1.2924697071141057`*^-26 | 0. | 0. | 0. |
| 3.2311742677852644`*^-27  | 0. | 0. | 0. |⁠)}
```

---

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

```wl
In[1]:= matrix = HilbertMatrix[11];

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

In[3]:= inverses[[All, 1]]

Out[3]= {0.000584414, 0.0843365, 0.000431499, 0.000307124}
```

---

Create a matrix with several symbolic elements:

```wl
In[1]:=
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]

Out[1]//MatrixForm=
(⁠|       |       |       |        |        |        |        |
| ----- | ----- | ----- | ------ | ------ | ------ | ------ |
| a     | a     | (1/3) | (1/4)  | (1/5)  | (1/6)  | (1/7)  |
| (1/2) | (1/3) | b     | c      | (1/6)  | (1/7)  | (1/8)   ... (1/4) | b     | (1/6) | d      | (1/8)  | (1/9)  | (1/10) |
| (1/5) | (1/6) | (1/7) | (1/8)  | (1/9)  | (1/10) | (1/11) |
| (1/6) | (1/7) | (1/8) | (1/9)  | (1/10) | (1/11) | (1/12) |
| (1/7) | (1/8) | (1/9) | (1/10) | (1/11) | (1/12) | (1/13) |⁠)
```

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

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

Out[2]= {{0.014489, 9740}, {0.461269, 22386}, {0.15414, 6671}}
```

#### Modulus (1)

Invert a matrix using arithmetic modulo five:

```wl
In[1]:= m = {{1, 2, 4}, {2, 0, 3}, {2, 1, 2}};

In[2]:= Inverse[m, Modulus -> 5]

Out[2]= {{3, 0, 4}, {3, 1, 0}, {3, 2, 4}}
```

The inverse using normal arithmetic:

```wl
In[3]:= Inverse[m]

Out[3]= {{-(1/3), 0, (2/3)}, {(2/9), -(2/3), (5/9)}, {(2/9), (1/3), -(4/9)}}
```

Visualize the two results:

```wl
In[4]:= {MatrixPlot[%], MatrixPlot[%%]}

Out[4]= {[image], [image]}
```

#### ZeroTest (1)

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

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

Out[1]=
{{1, 0}, {1, π - Root[8394424425973111046102466470564958295830951628283298149701386477242875447818673389226090192984\
029732939781061026077658550311303875032545498684307238995818676138470695390760454711538845664627035\
44359274219914069595286724433 ... 7494583708363193025825642551076544298993049143\
615185128783410198233550035568901018893959814690410410216282149769634197560732600787754846222883582\
50360748898046876231601365242979664076168746640932325062440279570663043850648012*#1^20 & , 4, 0]}}

In[2]:= Inverse[m]
```

Inverse::sing: Matrix {{1,0},{1,\[Pi]-Root[<<1>>&,4,0]}} is singular.

```wl
Out[2]=
Inverse[{{1, 0}, {1, π - Root[8394424425973111046102466470564958295830951628283298149701386477242875447818673389226090192984\
029732939781061026077658550311303875032545498684307238995818676138470695390760454711538845664627035\
443592742199140695952 ... 494583708363193025825642551076544298993049143\
615185128783410198233550035568901018893959814690410410216282149769634197560732600787754846222883582\
50360748898046876231601365242979664076168746640932325062440279570663043850648012*#1^20 & , 4, 0]}}]
```

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

```wl
In[3]:=
N[π - Root[8394424425973111046102466470564958295830951628283298149701386477242875447818673389226090192984\
029732939781061026077658550311303875032545498684307238995818676138470695390760454711538845664627035\
4435927421991406959528672443375423719871723709 ... 387494583708363193025825642551076544298993049143\
615185128783410198233550035568901018893959814690410410216282149769634197560732600787754846222883582\
50360748898046876231601365242979664076168746640932325062440279570663043850648012*#1^20 & , 4, 0]]

Out[3]= 0.
```

The entry is very small but nonzero:

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

Out[4]= 5.836637342329589842368578323586993777`10.*^-10001
```

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

```wl
In[5]:= Inverse[m, ZeroTest -> (N[#, $MachinePrecision] == 0&)]

Out[5]= [image]

In[6]:= %.m//Simplify

Out[6]= {{1, 0}, {0, 1}}
```

#### Modulus (1)

Invert a matrix of integers modulo 5:

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

Out[1]= {{1, 4}, {3, 4}}
```

Check it:

```wl
In[2]:= Mod[m.minv, 5]

Out[2]= {{1, 0}, {0, 1}}
```

### Applications (10)

#### Solving Equations (4)

Solve the system of equations $6 x+9 y=11$, $3 z-7 x=-12$, $5 y+9 z=-9$. First, form the coefficient matrix $a$ and constant vector $b$ :

```wl
In[1]:=
a = {{6, 9, 0}, {-7, 0, 3}, {0, 5, 9}};
b = {11, -12, -9};
{a//MatrixForm, b//MatrixForm}

Out[1]=
{(⁠|    |   |   |
| -- | - | - |
| 6  | 9 | 0 |
| -7 | 0 | 3 |
| 0  | 5 | 9 |⁠), (⁠|     |
| --- |
| 11  |
| -12 |
| -9  |⁠)}
```

The solution $\{x,y,z\}$ is given by $a^{-1}.b$ :

```wl
In[2]:= Inverse[a].b

Out[2]= {(188/159), (23/53), -(592/477)}
```

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

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

Out[3]= True
```

---

Solve the matrix equation $m.x=b$ :

```wl
In[1]:= m = {{1, 2}, {3, 4}};b = {5, 6};
```

Multiplying both sides of the equation on the left by $m^{-1}$ shows $x=m^{-1}.b$ :

```wl
In[2]:= Inverse[m].b

Out[2]= {-4, (9/2)}
```

Confirm the result using ``LinearSolve`` :

```wl
In[3]:= LinearSolve[m, b]

Out[3]= {-4, (9/2)}
```

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

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

In[5]:= AbsoluteTiming[LinearSolve[s, v];]

Out[5]= {0.002592, Null}

In[6]:= AbsoluteTiming[Inverse[s].v;]

Out[6]= {1.04262, Null}
```

---

Solve the matrix equation $m.x=y$ :

```wl
In[1]:= 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 $m^{-1}$ shows $x=m^{-1}.y$ :

```wl
In[2]:= Inverse[m].y

Out[2]= {{(158/29), -(305/58), -(234/29)}, {4, -(15/4), -7}, {-(1/29), (9/116), -(11/29)}}
```

Substitute the solution into the equation for verification:

```wl
In[3]:= m.x == y /. x -> %

Out[3]= True
```

---

Solve the system of ODEs $x'=y$, $y'=z$, $z'=-2 x+y+z$. First, construct the coefficient matrix $a$ for the right-hand side:

```wl
In[1]:= a = {{0, 1, 0}, {0, 0, 1}, {-2, 1, 2}};
```

Find the eigenvalues and eigenvectors:

```wl
In[2]:= {λ, v} = Eigensystem[a]

Out[2]= {{2, -1, 1}, {{1, 2, 4}, {1, -1, 1}, {1, 1, 1}}}
```

Construct a diagonal matrix whose entries are the exponential of $t \lambda$ :

```wl
In[3]:= d = DiagonalMatrix[Exp[t λ]]

Out[3]= {{E^2 t, 0, 0}, {0, E^-t, 0}, {0, 0, E^t}}
```

Construct the matrix whose columns are the corresponding eigenvectors:

```wl
In[4]:= p = Transpose[v]

Out[4]= {{1, 1, 1}, {2, -1, 1}, {4, 1, 1}}
```

The general solution is $p.d.p^{-1}.\left\{c_1,c_2,c_3\right\}$, for three arbitrary starting values:

```wl
In[5]:= p.d.Inverse[p].{C[1], C[2], C[3]}

Out[5]= {((E^-t/3) + E^t - (E^2 t/3)) C[1] + (-(E^-t/2) + (E^t/2)) C[2] + ((E^-t/6) - (E^t/2) + (E^2 t/3)) C[3], (-(E^-t/3) + E^t - (2 E^2 t/3)) C[1] + ((E^-t/2) + (E^t/2)) C[2] + (-(E^-t/6) - (E^t/2) + (2 E^2 t/3)) C[3], ((E^-t/3) + E^t - (4 E^2 t/3)) C[1] + (-(E^-t/2) + (E^t/2)) C[2] + ((E^-t/6) - (E^t/2) + (4 E^2 t/3)) C[3]}
```

Verify the solution using ``DSolveValue`` :

```wl
In[6]:= 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]]

Out[6]= True
```

#### Change of Basis/Coordinates (6)

Express a general vector in $\mathbb{R}^3$ as a linear combination of the vectors $\{1,0,1\}$, $\{2,2,3\}$ and $\{-1,-1,1\}$. First, verify the vectors are linearly independent by checking that their null space is empty:

```wl
In[1]:=
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]}]

Out[1]= {}
```

Form the matrix $p$ whose columns are the basis vectors:

```wl
In[2]:= p = Transpose[{Subscript[b, 1], Subscript[b, 2], Subscript[b, 3]}];
```

The coefficients of a general vector $v$ are given by $p^{-1}.v$ :

```wl
In[3]:= {Subscript[c, 1], Subscript[c, 2], Subscript[c, 3]} = Inverse[p].{x, y, z}

Out[3]= {x - y, -(x/5) + (2 y/5) + (z/5), -(2 x/5) - (y/5) + (2 z/5)}
```

Verify that $v$ does indeed equal the linear combination $\sum _{i=1}^3 c_ib_i$ :

```wl
In[4]:= Simplify[Underoverscript[∑, i = 1, 3]Subscript[c, i]Subscript[b, i]]

Out[4]= {x, y, z}
```

---

Find the change-of-basis matrix that transforms coordinates with respect to the basis $\left\{b_i\right\}$ to coordinates with respect to the basis $\left\{d_i\right\}$ :

```wl
In[1]:= {Subscript[b, 1], Subscript[b, 2], Subscript[b, 3]} = {{2, 5, -4}, {1, 0, 3}, {-3, 3, -2}};

In[2]:= {Subscript[d, 1], Subscript[d, 2], Subscript[d, 3]} = {{-2, 4, 1}, {3, -4, -1}, {3, 3, -4}};
```

The matrix $p$ whose columns are the $\left\{b_i\right\}$ transforms from $b$-coordinates to standard coordinates:

```wl
In[3]:= (p = Transpose[{Subscript[b, 1], Subscript[b, 2], Subscript[b, 3]}])//MatrixForm

Out[3]//MatrixForm=
(⁠|    |   |    |
| -- | - | -- |
| 2  | 1 | -3 |
| 5  | 0 | 3  |
| -4 | 3 | -2 |⁠)
```

The matrix $q$ whose columns are the $\left\{d_i\right\}$ transforms from $d$-coordinates to standard coordinates:

```wl
In[4]:= (q = Transpose[{Subscript[d, 1], Subscript[d, 2], Subscript[d, 3]}])//MatrixForm

Out[4]//MatrixForm=
(⁠|    |    |    |
| -- | -- | -- |
| -2 | 3  | 3  |
| 4  | -4 | 3  |
| 1  | -1 | -4 |⁠)
```

Its inverse converts from standard coordinates back to $d$-coordinates:

```wl
In[5]:= Inverse[q]

Out[5]= {{1, (9/19), (21/19)}, {1, (5/19), (18/19)}, {0, (1/19), -(4/19)}}
```

Therefore, $q^{-1}.p$ converts from $b$-coordinates to $d$-coordinates:

```wl
In[6]:= Inverse[q].p

Out[6]= {{-(1/19), (82/19), -(72/19)}, {-(9/19), (73/19), -(78/19)}, {(21/19), -(12/19), (11/19)}}
```

---

Express the linear operator $\mathcal{L}$ whose representation in the standard is given by $m$ in the basis $b_1=\{1,0,1\}$, $b_2=\{2,2,3\}$, $b_3=\{-1,-1,2\}$

```wl
In[1]:= (m = {{1, 2, -3}, {2, 0, 1}, {-3, 1, 5}})//MatrixForm

Out[1]//MatrixForm=
(⁠|    |   |    |
| -- | - | -- |
| 1  | 2 | -3 |
| 2  | 0 | 1  |
| -3 | 1 | 5  |⁠)

In[2]:= Subscript[b, 1] = {1, 0, 1};Subscript[b, 2] = {2, 2, 3};Subscript[b, 3] = {-1, -1, 2};
```

The matrix $p$ whose columns are the $b_i$ transforms from $b$-coordinates to standard coordinates:

```wl
In[3]:= (p = Transpose[{Subscript[b, 1], Subscript[b, 2], Subscript[b, 3]}])//MatrixForm

Out[3]//MatrixForm=
(⁠|   |   |    |
| - | - | -- |
| 1 | 2 | -1 |
| 0 | 2 | -1 |
| 1 | 3 | 2  |⁠)
```

Its inverse converts from standard coordinates to $b$-coordinates:

```wl
In[4]:= Inverse[p]

Out[4]= {{1, -1, 0}, {-(1/7), (3/7), (1/7)}, {-(2/7), -(1/7), (2/7)}}
```

Therefore the representation of $\mathcal{L}$ in $b$-coordinates is:

```wl
In[5]:= p.m.Inverse[p]

Out[5]= {{(67/7), -(47/7), -(11/7)}, {8, -7, -1}, {-(17/7), -(5/7), (24/7)}}
```

---

``Inverse`` can be used to diagonalize a matrix as $m=p.d.p^{-1}$. Compute $m$'s eigenvalues and eigenvectors:

```wl
In[1]:= m = {{9, -7, 3}, {12, -10, 3}, {16, -16, 1}};

In[2]:= Eigensystem[m]

Out[2]= {{-3, 2, 1}, {{-1, 0, 4}, {1, 1, 0}, {-3, -3, 1}}}
```

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

```wl
In[3]:= {d = DiagonalMatrix[First[%]], p = Transpose[Last[%]]}

Out[3]= {{{-3, 0, 0}, {0, 2, 0}, {0, 0, 1}}, {{-1, 1, -3}, {0, 1, -3}, {4, 0, 1}}}
```

Confirm the identity $m=p.d.p^{-1}$ :

```wl
In[4]:= m == p.d.Inverse[p]

Out[4]= True
```

Any function of the matrix can now be computed as $f(m)=p.f(d).p^{-1}$. For example, ``MatrixPower`` :

```wl
In[5]:= MatrixPower[m, k] == p.MatrixPower[d, k].Inverse[p]

Out[5]= True
```

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

```wl
In[6]:= MatrixExp[m] == p.MatrixExp[d].Inverse[p]

Out[6]= True

In[7]:= MatrixExp[d]

Out[7]= {{(1/E^3), 0, 0}, {0, E^2, 0}, {0, 0, E}}
```

---

``Inverse`` of a transformation matrix gives the matrix for the reverse operation. For example, consider a translation by $\{\text{$\Delta $x},\text{$\Delta $t},\text{$\Delta $z}\}$ :

```wl
In[1]:= trans = TranslationTransform[{Δx, Δy, Δz}]

Out[1]=
TransformationFunction[(|   |   |   |    |
| - | - | - | -- |
| 1 | 0 | 0 | Δx |
| 0 | 1 | 0 | Δy |
| 0 | 0 | 1 | Δz |
| 0 | 0 | 0 | 1  |)]
```

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

```wl
In[2]:= Inverse[TransformationMatrix[trans]]//MatrixForm

Out[2]//MatrixForm=
(⁠|   |   |   |     |
| - | - | - | --- |
| 1 | 0 | 0 | -Δx |
| 0 | 1 | 0 | -Δy |
| 0 | 0 | 1 | -Δz |
| 0 | 0 | 0 | 1   |⁠)

In[3]:= TransformationFunction[%] == TranslationTransform[-{Δx, Δy, Δz}]

Out[3]= True
```

Consider a general affine transformation:

```wl
In[4]:= aff = LinearFractionalTransform[{Array[Subscript[a, #1, #2]&, {2, 2}], Array[Subscript[b, #]&, {2}]}]

Out[4]=
TransformationFunction[(|       |       |    |
| ----- | ----- | -- |
| a1, 1 | a1, 2 | b1 |
| a2, 1 | a2, 2 | b2 |
| 0     | 0     | 1  |)]
```

Construct the inverse transformation:

```wl
In[5]:= affInv = TransformationFunction[Inverse[TransformationMatrix[aff]]]

Out[5]=
TransformationFunction[(|                                    |                                    |                                                   |
| ---------------------------------- | ---------------------------------- | -------------------- ... 1, 2 a2, 1 - a1, 1 a2, 2)  | (a1, 1/-a1, 2 a2, 1 + a1, 1 a2, 2) | (-b2 a1, 1 + b1 a2, 1/-a1, 2 a2, 1 + a1, 1 a2, 2) |
| 0                                  | 0                                  | 1                                                 |)]
```

Verify that the two transformations really do undo each other:

```wl
In[6]:= affInv[aff[{x, y}]]//Simplify

Out[6]= {x, y}

In[7]:= aff[affInv[{x, y}]]//Simplify

Out[7]= {x, y}
```

---

For a mapping $f:x\in \mathbb{R}^n\to y\in \mathbb{R}^n$, the Jacobian of the inverse mapping $\nabla _yf^{(-1)}$ is given by $\left(\nabla _xf\right){}^{-1}$. Consider the mapping from Cartesian to spherical coordinates:

```wl
In[1]:= 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 $\{1,1,0\}$ :

```wl
In[2]:= fJac = Grad[f[x, y, z], {x, y, z}] /. {x -> 1, y -> 1, z -> 0}

Out[2]= {{(1/Sqrt[2]), (1/Sqrt[2]), 0}, {0, 0, -(1/Sqrt[2])}, {-(1/2), (1/2), 0}}
```

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

```wl
In[3]:= fInv[r_, θ_, φ_] := {r Cos[φ]Sin[θ], r Sin[θ]Sin[φ], r Cos[θ]}
```

Verify the inverse function:

```wl
In[4]:= fInv@@f[x, y, z]

Out[4]= {x, y, z}
```

Compute the Jacobian of the inverse mapping at the $\{r,\theta ,\varphi \}$ coordinates corresponding to $\{1,1,0\}$ :

```wl
In[5]:= fInvJac = Grad[fInv[r, θ, φ], {r, θ, φ}] /. Thread[{r, θ, φ} -> f[1, 1, 0]]

Out[5]= {{(1/Sqrt[2]), 0, -1}, {(1/Sqrt[2]), 0, 1}, {0, -Sqrt[2], 0}}
```

Confirm the identity $\nabla _yf^{(-1)}=\left(\nabla _xf\right){}^{-1}$ :

```wl
In[6]:= fInvJac == Inverse[fJac]

Out[6]= True
```

### Properties & Relations (13)

``Inverse`` satisfies the relation $a.a^{-1}=a^{-1}.a=\text{IdentityMatrix}[n]$ for an $n\times n$ matrix $a$ :

```wl
In[1]:= a = {{1, 2}, {3, 4}}

Out[1]= {{1, 2}, {3, 4}}

In[2]:= a.Inverse[a] == Inverse[a].a == IdentityMatrix[2]

Out[2]= True
```

---

``Inverse`` satisfies the relation $(a.b)^{-1}=b^{-1}.a^{-1}$ :

```wl
In[1]:= a = {{1, 1, 1}, {6, 9, 7}, {8, 1, 9}};

In[2]:= b = {{0, 3, 9}, {7, 9, 7}, {4, 4, 1}};

In[3]:= Inverse[a.b] == Inverse[b].Inverse[a]

Out[3]= True
```

---

``Inverse`` satisfies the relation $\left(a^T\right)^{-1}=\left(a^{-1}\right)^T$ :

```wl
In[1]:= a = {{-(1/25), (12/25), -(7/25)}, {-(7/25), (9/25), (1/25)}, {(13/75), -(31/75), (16/75)}};

In[2]:= Inverse[Transpose[a]] == Transpose[Inverse[a]]

Out[2]= True
```

---

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

```wl
In[1]:=
m = (|   |   |   |
| - | - | - |
| 1 | 2 | 3 |
| 4 | 5 | 6 |
| 7 | 8 | 9 |);

In[2]:= Det[m]

Out[2]= 0

In[3]:= Inverse[m]
```

Inverse::sing: Matrix {{1,2,3},{4,5,6},{7,8,9}} is singular.

```wl
Out[3]= Inverse[{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}]
```

Moreover, determinant of the inverse $\left| a^{-1}\right|$ equals $\frac{1}{| a| }$ :

```wl
In[4]:= a = RandomReal[1, {5, 5}];

In[5]:= Det[Inverse[a]] == (1/Det[a])

Out[5]= True
```

---

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

```wl
In[1]:= m = {{9, 4, 1, 8}, {4, 8, 3, 4}, {7, 6, 8, 4}, {6, 9, 0, 9}};

In[2]:= MatrixPower[m, -1] == Inverse[m]

Out[2]= True
```

---

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

```wl
In[1]:= a = {{1, 3, 5}, {7, 1, -1}, {8, 4, 1}};

In[2]:= Inverse[a] == Adjugate[a] / Det[a]

Out[2]= True
```

---

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

```wl
In[1]:= m = RandomReal[1, {5, 5}];

In[2]:= Inverse[m] == LinearSolve[m, IdentityMatrix[5]]

Out[2]= True
```

---

The inverse of an orthogonal matrix is given by ``Transpose`` :

```wl
In[1]:= r  = {{-(6/7), (2/7), (3/7)}, {(2/7), -(3/7), (6/7)}, {(3/7), (6/7), (2/7)}};

In[2]:= OrthogonalMatrixQ[r]

Out[2]= True

In[3]:= Inverse[r] == Transpose[r]

Out[3]= True
```

---

The inverse of a unitary matrix is given by ``ConjugateTranspose`` :

```wl
In[1]:= 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)}};

In[2]:= UnitaryMatrixQ[u]

Out[2]= True

In[3]:= Inverse[u] == ConjugateTranspose[u]

Out[3]= True
```

---

A matrix and its inverse have the same symmetry:

```wl
In[1]:= s = {{3, 0, -5}, {0, 1, 0}, {-5, 0, 0}};

In[2]:= {TensorSymmetry[s], TensorSymmetry[Inverse[s]]}

Out[2]= {Symmetric[{1, 2}], Symmetric[{1, 2}]}

In[3]:= a = {{0, -(3/2), (5/2), -6}, {(3/2), 0, 4, 3}, {-(5/2), -4, 0, -5}, {6, -3, 5, 0}};

In[4]:= {TensorSymmetry[a], TensorSymmetry[Inverse[a]]}

Out[4]= {Antisymmetric[{1, 2}], Antisymmetric[{1, 2}]}
```

---

A ``QuantityArray`` and its inverse have reciprocal units:

```wl
In[1]:= QuantityArray[{{1, 2}, {3, 4}}, {("Meters"/"Seconds"), ("Meters"/"Seconds")}]

Out[1]=
QuantityArray[StructuredArray`StructuredData[{2, 2}, {{{1, 2}, {3, 4}}, "Meters"/"Seconds", 
   {{1}, {2}}}]]

In[2]:= Inverse[%]

Out[2]=
QuantityArray[StructuredArray`StructuredData[{2, 2}, {{{-2, 1}, {Rational[3, 2], Rational[-1, 2]}}, 
   "Seconds"/"Meters", {{1}, {2}}}]]
```

---

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

```wl
In[1]:=
a = (⁠|   |   |   |
| - | - | - |
| 4 | 3 | 8 |
| 9 | 5 | 2 |
| 9 | 6 | 7 |⁠);

In[2]:= Inverse[a] === PseudoInverse[a]

Out[2]= True
```

``PseudoInverse`` extends to singular as well as rectangular matrices:

```wl
In[3]:=
PseudoInverse[(|   |   |
| - | - |
| 1 | 2 |
| 1 | 2 |)]//MatrixForm

Out[3]//MatrixForm=
(⁠|        |        |
| ------ | ------ |
| (1/10) | (1/10) |
| (1/5)  | (1/5)  |⁠)

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

Out[4]//MatrixForm=
(⁠|         |        |         |
| ------- | ------ | ------- |
| -(4/3)  | -(1/3) | (2/3)   |
| (13/12) | (1/3)  | -(5/12) |⁠)
```

---

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

```wl
In[1]:=
a = (⁠|   |   |   |
| - | - | - |
| 4 | 3 | 8 |
| 9 | 5 | 2 |
| 9 | 6 | 7 |⁠);

In[2]:= Inverse[a] === DrazinInverse[a]

Out[2]= True
```

``DrazinInverse`` extends to singular square matrices:

```wl
In[3]:=
DrazinInverse[(|   |   |
| - | - |
| 1 | 2 |
| 1 | 2 |)]//MatrixForm

Out[3]//MatrixForm=
(⁠|       |       |
| ----- | ----- |
| (1/9) | (2/9) |
| (1/9) | (2/9) |⁠)
```

### Possible Issues (4)

The inverse may not exist:

```wl
In[1]:=
Inverse[(|   |   |
| - | - |
| 1 | 2 |
| 1 | 2 |)]
```

Inverse::sing: Matrix {{1,2},{1,2}} is singular.

```wl
Out[1]= Inverse[{{1, 2}, {1, 2}}]
```

Typically a pseudo inverse does:

```wl
In[2]:=
PseudoInverse[(|   |   |
| - | - |
| 1 | 2 |
| 1 | 2 |)]

Out[2]= {{(1/10), (1/10)}, {(1/5), (1/5)}}
```

---

Full inverses do not exist for rectangular matrices:

```wl
In[1]:=
Inverse[(|   |   |   |
| - | - | - |
| 1 | 2 | 2 |
| 3 | 1 | 4 |)]
```

Inverse::matsq: Argument {{1,2,2},{3,1,4}} at position 1 is not a nonempty square matrix.

```wl
Out[1]= Inverse[{{1, 2, 2}, {3, 1, 4}}]
```

Use ``PseudoInverse`` instead:

```wl
In[2]:=
PseudoInverse[(|   |   |   |
| - | - | - |
| 1 | 2 | 2 |
| 3 | 1 | 4 |)]

Out[2]= {{-(1/5), (14/65)}, {(3/5), -(17/65)}, {0, (2/13)}}
```

---

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

```wl
In[1]:= Inverse[N@HilbertMatrix[15]][[1, 1]]
```

Inverse::luc: Result for Inverse of badly conditioned matrix {{1.,0.5,0.333333,0.25,0.2,<<20>>,0.142857,0.125,0.111111,0.1,<<5>>},<<9>>,<<5>>} may contain significant numerical errors.

```wl
Out[1]= 160.681
```

Exact result:

```wl
In[2]:= Inverse[HilbertMatrix[15]][[1, 1]]

Out[2]= 225
```

Arbitrary-precision result:

```wl
In[3]:= Inverse[N[HilbertMatrix[15], 30]][[1, 1]]

Out[3]= 225.000000000000000000000000000
```

---

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

```wl
In[1]:= Inverse[{{1, 2}, {3, 2}}, Modulus -> 6]
```

Inverse::nmod: -(1/2) cannot be inverted in non-prime modulus 6.

```wl
Out[1]= Inverse[{{1, 2}, {3, 2}}, Modulus -> 6]
```

## See Also

* [`PseudoInverse`](https://reference.wolfram.com/language/ref/PseudoInverse.en.md)
* [`LinearSolve`](https://reference.wolfram.com/language/ref/LinearSolve.en.md)
* [`RowReduce`](https://reference.wolfram.com/language/ref/RowReduce.en.md)
* [`NullSpace`](https://reference.wolfram.com/language/ref/NullSpace.en.md)
* [`LinearSolveFunction`](https://reference.wolfram.com/language/ref/LinearSolveFunction.en.md)
* [`DrazinInverse`](https://reference.wolfram.com/language/ref/DrazinInverse.en.md)
* [`Adjugate`](https://reference.wolfram.com/language/ref/Adjugate.en.md)
* [`MatrixRank`](https://reference.wolfram.com/language/ref/MatrixRank.en.md)

## Tech Notes

* [Vectors and Matrices](https://reference.wolfram.com/language/tutorial/Lists.en.md#2534)
* [Matrix Inversion](https://reference.wolfram.com/language/tutorial/LinearAlgebra.en.md#7971)
* [Implementation notes: Numerical and Related Functions](https://reference.wolfram.com/language/tutorial/SomeNotesOnInternalImplementation.en.md#5783)

## Related Guides

* [Matrix Operations](https://reference.wolfram.com/language/guide/MatrixOperations.en.md)
* [Linear Systems](https://reference.wolfram.com/language/guide/LinearSystems.en.md)
* [Matrices and Linear Algebra](https://reference.wolfram.com/language/guide/MatricesAndLinearAlgebra.en.md)
* [Finite Mathematics](https://reference.wolfram.com/language/guide/FiniteMathematics.en.md)
* [Finite Fields](https://reference.wolfram.com/language/guide/FiniteFields.en.md)
* [GPU Computing](https://reference.wolfram.com/language/guide/GPUComputing.en.md)
* [Symbolic Vectors, Matrices and Arrays](https://reference.wolfram.com/language/guide/SymbolicArrays.en.md)
* [Structured Arrays](https://reference.wolfram.com/language/guide/StructuredArrays.en.md)
* [GPU Computing with NVIDIA](https://reference.wolfram.com/language/guide/GPUComputing-NVIDIA.en.md)

## History

* Introduced in 1988 (1.0) \| Updated in 1996 (3.0) ▪ [2022 (13.2)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn132.en.md) ▪ [2024 (14.0)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn140.en.md) ▪ [2025 (14.3)](https://reference.wolfram.com/language/guide/SummaryOfNewFeaturesIn143.en.md)