# Leveraging Pseudo-Inverse for Solving Complex Linear Equations

The world we live in is full of complex systems and mathematical equations that help us understand the world around us. Linear algebra is an essential tool in the field of mathematics, helping us solve complex problems that would otherwise be impossible.

One such tool in linear algebra is the Pseudo-Inverse. In this article, we will explore the concept of Pseudo-Inverse and its significance in the field of linear algebra.

We will start by discussing the definition of Pseudo-Inverse, followed by the purpose of using Pseudo-Inverse. After that, we will delve into the syntax and components of the linalg.pinv() function.

## 1) Pseudo-Inverse

Pseudo-Inverse, also known as the Moore-Penrose Inverse, is a mathematical concept used in linear algebra. Pseudo-Inverse is a generalization of the concept of matrix inversion.

In matrix inversion, we find the inverse of a square matrix, which, when multiplied by the original matrix, gives us an identity matrix. However, this concept of matrix inversion is not applicable to non-square matrices.

This is where Pseudo-Inverse comes into play. Pseudo-Inverse is a way to solve equations by inverting the matrices that do not have an inverse.

## 2) The Purpose of Using Pseudo-Inverse

In linear algebra, Pseudo-Inverse is used for a variety of purposes. One of the primary purposes is to solve linear equations.

In many real-world problems, we encounter large matrices that are either singular or not square. In such scenarios, the traditional method of matrix inversion cannot be applied, and Pseudo-Inverse is used instead.

Another application of Pseudo-Inverse is to solve least-squares problems. In the field of statistics, we often encounter non-square matrices when we try to solve problems related to prediction.

Pseudo-Inverse is an efficient method of solving such problems and is widely used in machine learning algorithms.

### 2.1) Syntax of linalg.pinv() function

The linalg.pinv() function is a built-in function in Python used to compute the Pseudo-Inverse of a given matrix.

This function takes in three parameters:

``linalg.pinv(a, rcond=1e-15, hermitian=False)``
• a: This parameter is mandatory and represents the matrix for which we want to compute the Pseudo-Inverse.
• rcond: This parameter is optional and represents the cutoff condition for small singular values in the matrix. The default value for this parameter is 1e-15.
• hermitian: This parameter is optional and specifies whether the input matrix is Hermitian or not. The default value for this parameter is False.

### 2.2) The Components of linalg.pinv() function

The linalg.pinv() function works by first calculating the Singular Value Decomposition (SVD) of the input matrix.

SVD is a method of factorizing the matrix into three matrices called U, S, and V. Here, U and V are unitary matrices, while S is a diagonal matrix consisting of the singular values of the input matrix.

Using this SVD, the Pseudo-Inverse is calculated as:

``a_inv = V.T @ inv(S) @ U.T``

Where “@” is the matrix multiplication operator and “inv()” calculates the inverse of the matrix S. The Pseudo-Inverse is then returned by the linalg.pinv() function.

### 2.3) Default Values in linalg.pinv() function

The linalg.pinv() function has two optional parameters, rcond and hermitian, that have default values. The rcond parameter specifies the cutoff condition for small singular values in the input matrix.

If the singular value of the matrix is smaller than this cutoff value, it is set to zero. The default value for rcond is 1e-15, which ensures that singular values smaller than one trillionth are considered zero.

This value can be changed based on the requirements of the problem. The hermitian parameter specifies whether the input matrix is Hermitian or not.

If this parameter is set to True, the input matrix is assumed to be Hermitian, and the function uses a different method of calculating the Pseudo-Inverse.

## 3) Use Cases for linalg.pinv() Function

When working with linear algebra and matrix operations, matrix inversion is an essential tool for solving various problems.

However, certain limitations arise when working with non-square matrices that do not have inverses. Fortunately, Pseudo-Inverse, together with the linalg.pinv() function, can overcome these limitations and provide near-approximate solutions to problems that require matrix inversion.

### 3.1) Pre-requisites for Matrix Inversion

Matrix inversion is only possible for square matrices that are also non-singular (i.e., have a nonzero determinant). If a matrix is not non-singular or not square, the matrix inverse operation cannot be performed.

Instead, we can use Pseudo-Inverse and the linalg.pinv() function in these cases to solve problems that require matrix inversion.

### 3.2) Limitations of Matrix Inversion in Linear Equation Solving

Matrix inversion has a crucial role in solving linear systems of equations. Typically, a system of linear equations with n variables can be expressed as:

``Ax = b``

Here, A represents the coefficient matrix, x is the vector of the variables we need to solve, and b is the vector of constant terms.

When solving for x, we need to compute A, the inverse of the coefficient matrix A. However, if A does not have an inverse, we cannot use matrix inversion to solve for x.

### 3.3) Consider the following example of a system of linear equations:

``````2x + y = 5
4x + 2y = 10
8x + 4y = 20``````

If we attempt to solve for x by dividing the third equation by 4, we find that 2x + y = 5, which is the first equation. Hence, the system of equations is dependent, and the coefficient matrix is singular.

### 3.4) Demonstration of linalg.pinv() Function

To illustrate the working of the linalg.pinv() function, let us consider a scenario where we have a non-square matrix A and a vector b and need to solve the equation Ax = b. Suppose we have a 3×2 matrix A:

``````A = [[1, 2],
[3, 4],
[5, 6]]``````

### and a vector b:

``b = [1,2,3]``

If we try to solve the equation Ax = b, an error will be generated because A does not have an inverse.

We can solve this problem using the linalg.pinv() function as follows:

``````import numpy as np
A = np.array([[1, 2],[3, 4], [5, 6]])
b = np.array([1, 2, 3])
A_inv = np.linalg.pinv(A)
x = A_inv.dot(b)

print(x)``````

### The output of this code will be:

``[0.57377049 0.18032787]``

Here, the output represents an approximation of the vector x that satisfies Ax = b. The linalg.pinv() function has used the Singular Value Decomposition (SVD) of A to calculate a near-approximation of A.

This near-approximation is then multiplied with b to produce an estimate of x. It is important to note that the linalg.pinv() function can fail if the calculation of the SVD of A encounters a problem.

For example, if A contains NaN or infinity values, the function will raise a LinAlgError. To avoid this error, it is essential to check the input data for invalid values before using the linalg.pinv() function.

## 4) Conclusion

In conclusion, the linalg.pinv() function is an essential tool in solving problems that require matrix inversion. In many real-world scenarios, we encounter non-square or singular matrices that do not have an inverse.

In such cases, Pseudo-Inverse can overcome this limitation and provide a near-approximate solution using SVD and the linalg.pinv() function in Python. Linear algebra remains an essential tool for solving problems in various fields, such as engineering, physics, and data science.

With the help of the linalg.pinv() function, we can extend the applicability of linear algebra and solve problems that would otherwise be impossible. Overall, this article has explored the Pseudo-Inverse and its significance in linear algebra.

Matrix inversion is an essential tool in solving problems related to linear equations, but certain limitations arise when working with non-square or singular matrices. The linalg.pinv() function provides a way to overcome these limitations and calculate a near-approximation of the inverse through SVD.

The article has discussed the use cases, pre-requisites, and limitations of matrix inversion while demonstrating the linalg.pinv() function. Linear algebra remains an essential tool for solving complex problems in various fields, and understanding the Pseudo-Inverse and linalg.pinv() function provides us with a powerful toolset to tackle these challenges.