# Check if a Matrix is Invertible

In linear algebra, an n-by-n square matrix A is called Invertible, if there exists an n-by-n square matrix B such that where ‘In‘ denotes the n-by-n identity matrix. The matrix B is called the inverse matrix of A.
A square matrix is Invertible if and only if its determinant is non-zero. Examples:

```Input : {{1, 2, 3}
{4, 5, 6}
{7, 8, 9}}
Output : No
The given matrix is NOT Invertible
The value of Determinant is: 0
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

We find determinant of the matrix. Then we check if the determinant value is 0 or not. If the value is 0, then we output, not invertible.

## C++

 `// C++ program to find Deteminant of a matrix ` `#include ` `using` `namespace` `std; ` ` `  `// Dimension of input square matrix ` `#define N 4 ` ` `  `// Function to get cofactor of mat[p][q] in temp[][]. n is current ` `// dimension of mat[][] ` `void` `getCofactor(``int` `mat[N][N], ``int` `temp[N][N], ``int` `p, ``int` `q, ``int` `n) ` `{ ` `    ``int` `i = 0, j = 0; ` ` `  `    ``// Looping for each element of the matrix ` `    ``for` `(``int` `row = 0; row < n; row++) { ` `        ``for` `(``int` `col = 0; col < n; col++) { ` `            ``// Copying into temporary matrix only those element ` `            ``// which are not in given row and column ` `            ``if` `(row != p && col != q) { ` `                ``temp[i][j++] = mat[row][col]; ` ` `  `                ``// Row is filled, so increase row index and ` `                ``// reset col index ` `                ``if` `(j == n - 1) { ` `                    ``j = 0; ` `                    ``i++; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `/* Recursive function for finding determinant of matrix. ` `n is current dimension of mat[][]. */` `int` `determinantOfMatrix(``int` `mat[N][N], ``int` `n) ` `{ ` `    ``int` `D = 0; ``// Initialize result ` ` `  `    ``// Base case : if matrix contains single element ` `    ``if` `(n == 1) ` `        ``return` `mat; ` ` `  `    ``int` `temp[N][N]; ``// To store cofactors ` ` `  `    ``int` `sign = 1; ``// To store sign multiplier ` ` `  `    ``// Iterate for each element of first row ` `    ``for` `(``int` `f = 0; f < n; f++) { ` `        ``// Getting Cofactor of mat[f] ` `        ``getCofactor(mat, temp, 0, f, n); ` `        ``D += sign * mat[f] * determinantOfMatrix(temp, n - 1); ` ` `  `        ``// terms are to be added with alternate sign ` `        ``sign = -sign; ` `    ``} ` ` `  `    ``return` `D; ` `} ` ` `  `bool` `isInvertible(``int` `mat[N][N], ``int` `n) ` `{ ` `    ``if` `(determinantOfMatrix(mat, N) != 0) ` `        ``return` `true``; ` `    ``else` `        ``return` `false``; ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` `    ``/* int mat[N][N] = {{6, 1, 1}, ` `                    ``{4, -2, 5}, ` `                    ``{2, 8, 7}}; */` ` `  `    ``int` `mat[N][N] = { { 1, 0, 2, -1 }, ` `                      ``{ 3, 0, 0, 5 }, ` `                      ``{ 2, 1, 4, -3 }, ` `                      ``{ 1, 0, 5, 0 } }; ` `    ``if` `(isInvertible(mat, N)) ` `        ``cout << ``"Yes"``; ` `    ``else` `        ``cout << ``"No"``; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find ` `// Determinant of a matrix ` `class` `GFG  ` `{ ` ` `  `    ``// Dimension of input square matrix ` `    ``static` `int` `N = ``4``; ` `     `  `    ``// Function to get cofactor  ` `    ``// of mat[p][q] in temp[][].  ` `    ``// n is current dimension ` `    ``// of mat[][] ` `    ``static` `void` `getCofactor(``int` `[][]mat, ``int` `[][]temp,  ` `                            ``int` `p, ``int` `q, ``int` `n) ` `    ``{ ` `    ``int` `i = ``0``, j = ``0``; ` ` `  `    ``// Looping for each  ` `    ``// element of the matrix ` `    ``for` `(``int` `row = ``0``; row < n; row++)  ` `    ``{ ` `        ``for` `(``int` `col = ``0``; col < n; col++)  ` `        ``{ ` `            ``// Copying into temporary matrix  ` `            ``// only those element which are ` `            ``// not in given row and column ` `            ``if` `(row != p && col != q) ` `            ``{ ` `                ``temp[i][j++] = mat[row][col]; ` ` `  `                ``// Row is filled, so increase  ` `                ``// row index and reset col index ` `                ``if` `(j == n - ``1``)  ` `                ``{ ` `                    ``j = ``0``; ` `                    ``i++; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` `    ``} ` ` `  `    ``/* Recursive function for finding  ` `    ``determinant of matrix. n is current  ` `    ``dimension of mat[][]. */` `    ``static` `int` `determinantOfMatrix(``int` `[][]mat,  ` `                                   ``int` `n) ` `    ``{ ` `    ``int` `D = ``0``; ``// Initialize result ` ` `  `    ``// Base case : if matrix ` `    ``// contains single element ` `    ``if` `(n == ``1``) ` `        ``return` `mat[``0``][``0``]; ` `         `  `    ``// To store cofactors ` `    ``int` `[][]temp = ``new` `int``[N][N];  ` `     `  `    ``// To store sign multiplier ` `    ``int` `sign = ``1``;  ` ` `  `    ``// Iterate for each  ` `    ``// element of first row ` `    ``for` `(``int` `f = ``0``; f < n; f++)  ` `    ``{ ` `        ``// Getting Cofactor of mat[f] ` `        ``getCofactor(mat, temp, ``0``, f, n); ` `        ``D += sign * mat[``0``][f] *  ` `             ``determinantOfMatrix(temp, n - ``1``); ` ` `  `        ``// terms are to be added ` `        ``// with alternate sign ` `        ``sign = -sign; ` `    ``} ` ` `  `    ``return` `D; ` `    ``} ` ` `  `    ``static` `boolean` `isInvertible(``int` `[][]mat, ``int` `n) ` `    ``{ ` `        ``if` `(determinantOfMatrix(mat, N) != ``0``) ` `            ``return` `true``; ` `        ``else` `            ``return` `false``; ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String []args) ` `    ``{ ` `        ``int` `[][]mat = {{``1``, ``0``, ``2``, -``1` `}, ` `                       ``{``3``, ``0``, ``0``, ``5` `}, ` `                       ``{``2``, ``1``, ``4``, -``3` `}, ` `                       ``{``1``, ``0``, ``5``, ``0` `}}; ` `        ``if` `(isInvertible(mat, N)) ` `            ``System.out.println(``"Yes"``); ` `        ``else` `            ``System.out.println(``"No"``); ` `    ``} ` `} ` ` `  `// This code is contributed  ` `// by ChitraNayal `

## Python 3

 `# Function to get cofactor of  ` `# mat[p][q] in temp[][]. n is  ` `# current dimension of mat[][] ` `def` `getCofactor(mat, temp, p, q, n): ` `    ``i ``=` `0` `    ``j ``=` `0` ` `  `    ``# Looping for each element ` `    ``# of the matrix ` `    ``for` `row ``in` `range``(n):  ` `         `  `        ``for` `col ``in` `range``(n): ` `             `  `            ``# Copying into temporary matrix ` `            ``# only those element which are  ` `            ``# not in given row and column ` `            ``if` `(row !``=` `p ``and` `col !``=` `q) : ` `                 `  `                ``temp[i][j] ``=` `mat[row][col] ` `                ``j ``+``=` `1` ` `  `                ``# Row is filled, so increase  ` `                ``# row index and reset col index ` `                ``if` `(j ``=``=` `n ``-` `1``): ` `                    ``j ``=` `0` `                    ``i ``+``=` `1` ` `  `# Recursive function for  ` `# finding determinant of matrix. ` `# n is current dimension of mat[][].  ` `def` `determinantOfMatrix(mat, n): ` `    ``D ``=` `0` `# Initialize result ` ` `  `    ``# Base case : if matrix  ` `    ``# contains single element ` `    ``if` `(n ``=``=` `1``): ` `        ``return` `mat[``0``][``0``] ` `         `  `    ``# To store cofactors ` `    ``temp ``=` `[[``0` `for` `x ``in` `range``(N)]  ` `               ``for` `y ``in` `range``(N)]  ` ` `  `    ``sign ``=` `1` `# To store sign multiplier ` ` `  `    ``# Iterate for each  ` `    ``# element of first row ` `    ``for` `f ``in` `range``(n): ` `         `  `        ``# Getting Cofactor of mat[f] ` `        ``getCofactor(mat, temp, ``0``, f, n) ` `        ``D ``+``=` `(sign ``*` `mat[``0``][f] ``*` `              ``determinantOfMatrix(temp, n ``-` `1``)) ` ` `  `        ``# terms are to be added  ` `        ``# with alternate sign ` `        ``sign ``=` `-``sign ` `    ``return` `D ` ` `  `def` `isInvertible(mat, n): ` `    ``if` `(determinantOfMatrix(mat, N) !``=` `0``): ` `        ``return` `True` `    ``else``: ` `        ``return` `False` `     `  `# Driver Code ` `mat ``=` `[[ ``1``, ``0``, ``2``, ``-``1` `], ` `       ``[ ``3``, ``0``, ``0``, ``5` `], ` `       ``[ ``2``, ``1``, ``4``, ``-``3` `], ` `       ``[ ``1``, ``0``, ``5``, ``0` `]]; ` `     `  `N ``=` `4` `if` `(isInvertible(mat, N)): ` `    ``print``(``"Yes"``) ` `else``: ` `    ``print``(``"No"``) ` ` `  `# This code is contributed ` `# by ChitraNayal `

## C#

 `// C# program to find ` `// Determinant of a matrix ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// Dimension of input ` `// square matrix ` `static` `int` `N = 4; ` ` `  `// Function to get cofactor of  ` `// mat[p,q] in temp[,]. n is  ` `// current dimension of mat[,] ` `static` `void` `getCofactor(``int``[,] mat, ``int``[,] temp, ` `                        ``int` `p, ``int` `q, ``int` `n) ` `{ ` `int` `i = 0, j = 0; ` ` `  `// Looping for each element  ` `// of the matrix ` `for` `(``int` `row = 0; row < n; row++)  ` `{ ` `    ``for` `(``int` `col = 0; col < n; col++)  ` `    ``{ ` `        ``// Copying into temporary matrix  ` `        ``// only those element which are ` `        ``// not in given row and column ` `        ``if` `(row != p && col != q)  ` `        ``{ ` `            ``temp[i, j++] = mat[row, col]; ` ` `  `            ``// Row is filled, so  ` `            ``// increase row index and ` `            ``// reset col index ` `            ``if` `(j == n - 1)  ` `            ``{ ` `                ``j = 0; ` `                ``i++; ` `            ``} ` `        ``} ` `    ``} ` `} ` `} ` ` `  `/* Recursive function for finding  ` `determinant of matrix. n is current ` `dimension of mat[,]. */` `static` `int` `determinantOfMatrix(``int``[,]  ` `                               ``mat, ``int` `n) ` `{ ` `int` `D = 0; ``// Initialize result ` ` `  `// Base case : if matrix  ` `// contains single element ` `if` `(n == 1) ` `    ``return` `mat[0, 0]; ` `     `  `// To store cofactors ` `int``[,] temp = ``new` `int``[N, N];  ` ` `  `int` `sign = 1; ``// To store sign multiplier ` ` `  `// Iterate for each  ` `// element of first row ` `for` `(``int` `f = 0; f < n; f++)  ` `{ ` `    ``// Getting Cofactor of mat[0,f] ` `    ``getCofactor(mat, temp, 0, f, n); ` `    ``D += sign * mat[0, f] *      ` `         ``determinantOfMatrix(temp, n - 1); ` ` `  `    ``// terms are to be added ` `    ``// with alternate sign ` `    ``sign = -sign; ` `} ` `return` `D; ` `} ` ` `  `static` `bool` `isInvertible(``int``[,] mat, ``int` `n) ` `{ ` `    ``if` `(determinantOfMatrix(mat, N) != 0) ` `        ``return` `true``; ` `    ``else` `        ``return` `false``; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main()  ` `{ ` `    ``int``[,] mat = {{ 1, 0, 2, -1 }, ` `                  ``{ 3, 0, 0, 5 }, ` `                  ``{ 2, 1, 4, -3 }, ` `                  ``{ 1, 0, 5, 0 }}; ` `    ``if` `(isInvertible(mat, N)) ` `        ``Console.Write(``"Yes"``); ` `    ``else` `        ``Console.Write(``"No"``); ` `} ` `} ` ` `  `// This code is contributed ` `// by ChitraNayal `

## PHP

 ` `

Output:

```Yes
```

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : chitranayal

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.