# Is there a standard solution for Gauss elimination in Python?

One function that can be worth checking is `_remove_redundancy`

, if you wish to remove repeated or redundant equations:

```
import numpy as np
import scipy.optimize
a = np.array([[1.,1.,1.,1.],
[0.,0.,0.,1.],
[0.,0.,0.,2.],
[0.,0.,0.,3.]])
print(scipy.optimize._remove_redundancy._remove_redundancy(a, np.zeros_like(a[:, 0]))[0])
```

which gives:

```
[[1. 1. 1. 1.]
[0. 0. 0. 3.]]
```

As a note to @flonk answer, using a LU decomposition might not always give the desired reduced row matrix. Example:

```
import numpy as np
import scipy.linalg
a = np.array([[1.,1.,1.,1.],
[0.,0.,0.,1.],
[0.,0.,0.,2.],
[0.,0.,0.,3.]])
_,_, u = scipy.linalg.lu(a)
print(u)
```

gives the same matrix:

```
[[1. 1. 1. 1.]
[0. 0. 0. 1.]
[0. 0. 0. 2.]
[0. 0. 0. 3.]]
```

even though the last 3 rows are linearly dependent.

I finally found, that it can be done using **LU decomposition**. Here the **U** matrix represents the reduced form of the linear system.

```
from numpy import array
from scipy.linalg import lu
a = array([[2.,4.,4.,4.],[1.,2.,3.,3.],[1.,2.,2.,2.],[1.,4.,3.,4.]])
pl, u = lu(a, permute_l=True)
```

Then `u`

reads

```
array([[ 2., 4., 4., 4.],
[ 0., 2., 1., 2.],
[ 0., 0., 1., 1.],
[ 0., 0., 0., 0.]])
```

Depending on the solvability of the system this matrix has an upper triangular or trapezoidal structure. In the above case a line of zeros arises, as the matrix has only rank `3`

.