Wolfram Language & System Documentation Center

PseudoInverse

finds the pseudoinverse of a rectangular matrix.

Details and Options

PseudoInverse works on both symbolic and numerical matrices.
For a square matrix, PseudoInverse gives the Moore–Penrose inverse.
For numerical matrices, PseudoInverse is based on SingularValueDecomposition.
PseudoInverse[m,Tolerance->t] specifies that singular values smaller than t times the maximum singular value should be dropped.
With the default setting Tolerance->Automatic, singular values are dropped when they are less than 100 times 10^-p, where p is Precision[m].
For nonsingular square matrices M, the pseudoinverse is equivalent to the standard inverse .
PseudoInverse[m] formats as in StandardForm and TraditionalForm. »

Examples

open all close all

Basic Examples (5)

Find the pseudoinverse of an invertible matrix:

Wolfram Language code:

m = (|   |   |
| - | - |
| 1 | 2 |
| 3 | 4 |);
PseudoInverse[m]

The pseudoinverse is merely the inverse:

Wolfram Language code: % == Inverse[m]

Find the pseudoinverse of a singular matrix:

Wolfram Language code:

m = (⁠|   |   |   |
| - | - | - |
| 1 | 2 | 3 |
| 4 | 5 | 6 |
| 7 | 8 | 9 |⁠);
p = PseudoInverse[m]

The determinant of is zero, so it does not have a true inverse:

Wolfram Language code: Det[m]

For a pseudoinverse, both and :

Wolfram Language code: m.p.m == m && p.m.p == p

However, in this particular case neither nor is an identity matrix:

Wolfram Language code: {m.p//MatrixForm, p.m//MatrixForm}

Find the pseudoinverse of a rectangular matrix:

Wolfram Language code:

m = (⁠|   |   |   |
| - | - | - |
| 1 | 2 | 3 |
| 4 | 5 | 6 |⁠);
p = PseudoInverse[m]

In this particular case, is an identity matrix:

Wolfram Language code: m.p

However, is not:

Wolfram Language code: p.m

Find the pseudoinverse of a row matrix:

Wolfram Language code: Simplify[PseudoInverse[{{a, b, c}}], {a, b, c}∈Reals]

Find the pseudoinverse of a zero matrix:

Wolfram Language code:

PseudoInverse[(⁠|   |   |   |
| - | - | - |
| 0 | 0 | 0 |
| 0 | 0 | 0 |⁠)]//MatrixForm

Scope (11)

Basic Uses (7)

Find the pseudoinverse of a machine-precision matrix:

Wolfram Language code: PseudoInverse[{{1.25, 3.2, 3.2}, {7.9, -1.4, 5.1}, {0, 0, 0}}]

Pseudoinverse of a complex matrix:

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

Pseudoinverse of an exact matrix:

Wolfram Language code: PseudoInverse[{{2, 3}, {2, 2}, {3, 1}, {4, 3}}]

Pseudoinverse of an arbitrary-precision matrix:

Wolfram Language code: PseudoInverse[RandomReal[4, {2, 2}, WorkingPrecision -> 20]]

Compute a symbolic pseudoinverse:

Wolfram Language code: Simplify[PseudoInverse[{{a, b}, {c, d}, {1, 0}}], {a, b, c, d}∈Reals]

The inversion of large machine-precision matrices is efficient:

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

Wolfram Language code: AbsoluteTiming[PseudoInverse[mat]; ]

Output formatting:

Wolfram Language code: PseudoInverse[m]

Special Matrices (4)

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

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

Wolfram Language code: PseudoInverse[%]

Format the result:

Wolfram Language code: %//MatrixForm

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

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

Wolfram Language code: PseudoInverse[%]

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: PseudoInverse[%]

IdentityMatrix[n] is its own pseudoinverse:

Wolfram Language code: PseudoInverse[IdentityMatrix[3]]

The pseudoinverse of IdentityMatrix[{m,n}] is a transposition:

Wolfram Language code: IdentityMatrix[{3, 4}]

Wolfram Language code: PseudoInverse[%]

Compute the pseudoinverse for HilbertMatrix:

Wolfram Language code: PseudoInverse[HilbertMatrix[{3, 4}]]

Options (1)

Tolerance (1)

m is a 16×16 Hilbert matrix:

Wolfram Language code: m = HilbertMatrix[16];

Some singular values are below the default tolerance for machine precision:

Wolfram Language code: Length[SingularValueList[N[m]]]

Compute the pseudoinverse with the default tolerance:

Wolfram Language code: minv = PseudoInverse[N[m]];

It is not a true inverse since some singular values were considered to be effectively zero:

Wolfram Language code: Max[Abs[minv.m - IdentityMatrix[16]]]

Compute the pseudoinverse with no tolerance:

Wolfram Language code: minv0 = PseudoInverse[N[m], Tolerance -> 0];

Even though no singular values were considered zero, it is worse due to numerical error:

Wolfram Language code: Max[Abs[minv0.m - IdentityMatrix[16]]]

Applications (8)

Equation Solving (4)

Solve the following system of equations using PseudoInverse:

Wolfram Language code: system = {2x + 3y + 5z == -2, -3x + 4y - z == 7, 4x + y - 6z == 3};

Rewrite the system in matrix form:

Wolfram Language code:

a = {{2, 3, 5}, {-3, 4, -1}, {4, 1, -6}};
b = {-2, 7, 3};
system  == Thread[ a.{x, y, z} == b]

The general solution is given by for an arbitrary vector :

Wolfram Language code: v = PseudoInverse[a].b + (IdentityMatrix[3] - PseudoInverse[a].a).Table[C[i], {i, 3}]

Since the dropped out, the solution is unique, as can be verified using SolveValues:

Wolfram Language code: SolveValues[system, {x, y, z}]

Find all solutions of the following system of equations:

Wolfram Language code: system = {10 x + 12 y + 14 z == 1, 22 x + 27 y + 32 z == 0, 34 x + 42 y + 50 z == -1}

First, write the coefficient matrix , vector variable and constant vector :

Wolfram Language code:

m = {{10, 12, 14}, {22, 27, 32}, {34, 42, 50}};
b = {1, 0, -1};
v = {x, y, z};

Verify the rewrite:

Wolfram Language code: system == Thread[m.v == b]

The general solution is given by for an arbitrary vector :

Wolfram Language code: sol = PseudoInverse[m].b + (IdentityMatrix[3] - PseudoInverse[m].m).Table[C[i], {i, 3}]

Verify the solution:

Wolfram Language code: m.sol == b//Simplify

Although there are three parameters, this solution represents a line:

Wolfram Language code: RegionDimension[ParametricRegion[sol, {C[1], C[2], C[3]}]]

This is because the null space of is one-dimensional:

Wolfram Language code: NullSpace[m]

Hence it is possible to reparameterize to eliminate two of the parameters:

Wolfram Language code: sol /. {C[1] -> 6(x - (91/36)), C[2] -> 0, C[3] -> 0}//Simplify

This parameterization gives the answer in the same form as SolveValues:

Wolfram Language code: SolveValues[m.v == b, {x, y, z}]

Find the minimum Frobenius-norm solution to , with and as follows:

Wolfram Language code:

a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
b = {{84, 84, 84}, {399, 327, 255}, {714, 570, 426}};

The minimum norm solution is :

Wolfram Language code: x = PseudoInverse[a].b

Compute the Frobenius norm of :

Wolfram Language code: Norm[x, "Frobenius"]

As in the vector case, the general solution is given by , with now an arbitrary matrix:

Wolfram Language code: MatrixForm[c = Array[C[Row[{##}]]&, {3, 3}]]

Wolfram Language code: x + (IdentityMatrix[3] - PseudoInverse[a].a).c//MatrixForm

The minimum occurs when all the are zero, confirming that is the minimum-norm solution:

Wolfram Language code: Minimize[Norm[%, "Frobenius"], Flatten[c]]

In this case there is no solution to :

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

Wolfram Language code: LinearSolve[m, b]

An approximate solution that minimizes the norm of is given by :

Wolfram Language code: x = PseudoInverse[m].b

Wolfram Language code: Norm[m.x - b]

Compare to general minimization:

Wolfram Language code: Minimize[Norm[m.{x1, x2, x3} - b], {x1, x2, x3}]

A more general solution is given by :

Wolfram Language code: v = PseudoInverse[m].b + (IdentityMatrix[3] - PseudoInverse[m].m).Table[C[i], {i, 3}]

All these vectors minimize :

Wolfram Language code: Norm[m.v - b]//Simplify

Although there are three parameters in , it represents a line:

Wolfram Language code: RegionDimension[ParametricRegion[v, {C[1], C[2], C[3]}]]

This is because the null space of is one-dimensional:

Wolfram Language code: Length[NullSpace[m]]

Least Squares and Curve Fitting (4)

For the matrix and vector that follow, find a vector that minimizes :

Wolfram Language code:

m = {{10, 0, 5}, {7, 1, 9}, {0, 9, 9}, {4, 1, 10}};
b = {4, 6, 2, 3};

One solution, in this case unique, is given by :

Wolfram Language code: PseudoInverse[m].b

This result could also have been obtained using LeastSquares[m,b]:

Wolfram Language code: LeastSquares[m, b]

Confirm the answer using Minimize:

Wolfram Language code: Minimize[Norm[m.{x, y, z} - b], {x, y, z}]

For the matrices and that follow, find a matrix that minimizes $TemplateBox[{{{m, ., x}, -, b}}, Norm]_F$ :

Wolfram Language code:

m = {{1, 1}, {1, 2}, {1, 3}};
b = {{7, 1}, {7, 2}, {8, 3}};

One solution, in this case unique, is given by :

Wolfram Language code: PseudoInverse[m].b

This result could also have been obtained using LeastSquares[m,b]:

Wolfram Language code: LeastSquares[m, b]

Confirm the answer using Minimize:

Wolfram Language code: Minimize[Norm[m.{{w, x}, {y, z}} - b, "Frobenius"], {w, x, y, z}]

PseudoInverse can be used to find a best-fit curve to data. Consider the following data:

Wolfram Language code:

data = IconizedObject[«Data»];
ListPlot[data]

Extract the and coordinates from the data:

Wolfram Language code: {x, y} = Extract[data, {{All, 1}, {All, 2}}];

Construct a design matrix, whose columns are and , for fitting to a line :

Wolfram Language code: m = Map[x |-> {1, x}, x];

Get the coefficients and for a linear least‐squares fit:

Wolfram Language code: {a, b} = PseudoInverse[m].y

Verify the coefficients using Fit:

Wolfram Language code: Fit[data, {1, s}, s]

Plot the best-fit curve along with the data:

Wolfram Language code: Show[Plot[a + b x, {x, 0, 1}], ListPlot[data]]

Find the best-fit parabola to the following data:

Wolfram Language code:

data = IconizedObject[«Data»];
ListPlot[data]

Extract the and coordinates from the data:

Wolfram Language code: {x, y} = Extract[data, {{All, 1}, {All, 2}}];

Construct a design matrix, whose columns are , and , for fitting to a line :

Wolfram Language code: m = Map[x |-> {1, x, x ^ 2}, x];

Get the coefficients , and for a least‐squares fit:

Wolfram Language code: {a, b, c} = PseudoInverse[m].y

Verify the coefficients using Fit:

Wolfram Language code: Fit[data, {1, s, s ^ 2}, s]

Plot the best-fit curve along with the data:

Wolfram Language code: Show[Plot[a + b x + c x ^ 2, {x, 0, 3}], ListPlot[data]]

Properties & Relations (14)

For a nonsingular matrix, the pseudoinverse is the same as the inverse:

Wolfram Language code: PseudoInverse[{{1, 2, 3}, {1, 4, 9}, {1, 8, 27}}]

Wolfram Language code: Inverse[{{1, 2, 3}, {1, 4, 9}, {1, 8, 27}}]

PseudoInverse is involutive, :

Wolfram Language code: m = RandomInteger[{0, 9}, {3, 4}];

Wolfram Language code: PseudoInverse[PseudoInverse[m]] == m

PseudoInverse commutes with Transpose, i.e $(TemplateBox[{m}, Transpose])^((-1))=TemplateBox[{{(, {m, ^, {(, {(, {-, 1}, )}, )}}, )}}, Transpose]$ :

Wolfram Language code:

m = RandomComplex[1 + I, {3, 4}];
PseudoInverse[Transpose[m]] == Transpose[PseudoInverse[m]]

It also commutes with Conjugate, $(TemplateBox[{m}, Conjugate])^((-1))=TemplateBox[{{(, {m, ^, {(, {(, {-, 1}, )}, )}}, )}}, Conjugate]$ :

Wolfram Language code: PseudoInverse[Conjugate[m]] == Conjugate[PseudoInverse[m]]

Hence it commutes with ConjugateTranspose, $(TemplateBox[{m}, ConjugateTranspose])^((-1))=TemplateBox[{{(, {m, ^, {(, {(, {-, 1}, )}, )}}, )}}, ConjugateTranspose]$ :

Wolfram Language code: PseudoInverse[ConjugateTranspose[m]] == ConjugateTranspose[PseudoInverse[m]]

PseudoInverse satisfies the Moore–Penrose equations [more info]:

Wolfram Language code: a = RandomInteger[1, {2, 3}];

Wolfram Language code: b = PseudoInverse[a];

Wolfram Language code: {a.b.a == a, b.a.b == b, a.b == (a.b), b.a == (b.a)}

If MatrixRank[m] equals the number of columns of , then $m^((-1))=TemplateBox[{{(, {TemplateBox[{m}, ConjugateTranspose, SyntaxForm -> SuperscriptBox], ., m}, )}}, Inverse].TemplateBox[{m}, ConjugateTranspose]$ :

Wolfram Language code:

m = (⁠|   |   |   |   |
| - | - | - | - |
| 2 | 4 | 0 | 2 |
| 3 | 5 | 2 | 1 |
| 7 | 4 | 0 | 7 |
| 7 | 9 | 4 | 6 |
| 7 | 0 | 3 | 1 |⁠);
MatrixRank[m]

Wolfram Language code: PseudoInverse[m] == Inverse[ConjugateTranspose[m].m].ConjugateTranspose[m]

In particular, PseudoInverse[m] is a left-inverse of m:

Wolfram Language code: PseudoInverse[m].m == IdentityMatrix[4]

If MatrixRank[m] equals the number of rows of , then $m^((-1))=TemplateBox[{m}, ConjugateTranspose].TemplateBox[{{(, {m, ., TemplateBox[{m}, ConjugateTranspose]}, )}}, Inverse]$ :

Wolfram Language code:

m = (⁠|   |   |   |   |   |
| - | - | - | - | - |
| 2 | 3 | 7 | 7 | 7 |
| 4 | 5 | 4 | 9 | 0 |
| 0 | 2 | 0 | 4 | 3 |
| 2 | 1 | 7 | 6 | 1 |⁠);
MatrixRank[m]

Wolfram Language code: PseudoInverse[m] == ConjugateTranspose[m].Inverse[m.ConjugateTranspose[m]]

In particular, PseudoInverse[m] is a right-inverse of m:

Wolfram Language code: m.PseudoInverse[m] == IdentityMatrix[4]

For a diagonal matrix d, PseudoInverse[d] is the transpose with nonzero elements inverted:

Wolfram Language code:

PseudoInverse[(⁠|   |   |   |   |   |
| - | - | - | - | - |
| 1 | 0 | 0 | 0 | 0 |
| 0 | 2 | 0 | 0 | 0 |
| 0 | 0 | 3 | 0 | 0 |
| 0 | 0 | 0 | 0 | 0 |⁠)]//MatrixForm

If has the singular value decomposition , then $m^((-1))=v.sigma^((-1)).TemplateBox[{u}, ConjugateTranspose]$ :

Wolfram Language code:

m = (⁠|                    |                     |                     |
| ------------------ | ------------------- | ------------------- |
| 0.9422988726753116 | 0.40886883587634726 | 0.6762912513288197  |
| 0.3047350258462227 | 0.24005155170123138 | 0.24852539119763817 |
| 0.3067838926578499 | 0.8131116863793726  | 0.3567451429742945  |⁠);
{u, σ, v} = SingularValueDecomposition[m];

Wolfram Language code: m == u.σ.ConjugateTranspose[v]

Wolfram Language code: PseudoInverse[m] == v.PseudoInverse[σ].ConjugateTranspose[u]

If a is an matrix and MatrixRank[a]==m, QRDecomposition will give the pseudoinverse:

Wolfram Language code:

a = RandomReal[1, {5, 3}];
{n, m} = Dimensions[a];
MatrixRank[a] == m

In particular $a^((-1))=TemplateBox[{r}, Inverse].q$ :

Wolfram Language code:

{q, r} = QRDecomposition[a];
PseudoInverse[a] - Inverse[r].q//Chop

A normal matrix commutes with its pseudoinverse:

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

Wolfram Language code: NormalMatrixQ[n]

Wolfram Language code: n.PseudoInverse[n] == PseudoInverse[n].n

PseudoInverse[m] can be computed as , where denotes DrazinInverse:

Wolfram Language code: m = {{2, 2, -2}, {5, 1, -3}, {1, 5, -3}};

Wolfram Language code: PseudoInverse[m] == DrazinInverse[ConjugateTranspose[m].m].ConjugateTranspose[m]

LeastSquares and PseudoInverse can both be used to solve the least-squares problem:

Wolfram Language code:

m = {{1, 2}, {3, 4}, {1, 1}};
b = {1, 2, 3};

Wolfram Language code: LeastSquares[m, b] == PseudoInverse[m].b

gives the minimum norm that minimizes the residual :

Wolfram Language code:

m = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
b = {1, 2, 1};

Wolfram Language code: x = PseudoInverse[m].b

Verify that minimizes the residual:

Wolfram Language code: Norm[m.x - b] == MinValue[Norm[m.{α, β, γ} - b], {α, β, γ}]

Adding any vector in the NullSpace of to will leave the residual unchanged:

Wolfram Language code: NullSpace[m]

Wolfram Language code:

y = x + First[%] t;
Norm[m.x - b] == Norm[m.y - b]//Simplify

The minimum norm occurs at , i.e when :

Wolfram Language code: Plot[Norm[y], {t, -1, 1}]

For a vector and a matrix with empty nullspace, equals ArgMin[Norm[m.x-b],x]:

Wolfram Language code:

m = {{1, 2}, {3, 4}, {1, 1}};
x = {x1, x2};
b = {1, 2, 3};

Wolfram Language code: NullSpace[m]

Wolfram Language code: PseudoInverse[m].b == ArgMin[Norm[m.x - b], x]

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

PseudoInverse

Details and Options

Examples

Basic Examples (5)

Scope (11)

Basic Uses (7)

Special Matrices (4)

Options (1)

Tolerance (1)

Applications (8)

Equation Solving (4)

Least Squares and Curve Fitting (4)

Properties & Relations (14)

Text

CMS

APA

BibTeX

BibLaTeX

PseudoInverse

Details and Options

Examples

Basic Examples (5)

Scope (11)

Basic Uses (7)

Special Matrices (4)

Options (1)

Tolerance (1)

Applications (8)

Equation Solving (4)

Least Squares and Curve Fitting (4)

Properties & Relations (14)

See Also

Tech Notes

Related Guides

Related Links

History

Text

CMS

APA

BibTeX

BibLaTeX