LU decomposition in SciPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of LU decomposition matrices

Given the matrix A = [[4, 3], [6, 3]], what is the output of the LU decomposition using scipy.linalg.lu?

SciPy

import numpy as np
from scipy.linalg import lu
A = np.array([[4, 3], [6, 3]])
P, L, U = lu(A)
print(np.round(L, 2))
print(np.round(U, 2))

A

[[1.   0.  ]
 [0.67 1.  ]]
[[4.  3.]
 [0.  -1.5]]

B

[[1.   0.  ]
 [1.5  1.  ]]
[[4.  3.]
 [0.  -1.5]]

C

[[1.   0.  ]
 [0.5  1.  ]]
[[4.  3.]
 [0.  -1.5]]

D

[[1.   0.  ]
 [0.67 1.  ]]
[[6.   3.  ]
 [0.   -1.  ]]

💡 Hint

Remember that LU decomposition with pivoting returns P, L, U matrices where P is a permutation matrix.

The LU decomposition with pivoting rearranges rows to maximize numerical stability. The matrix P permutes rows, L is lower triangular with 1s on the diagonal, and U is upper triangular. For the given matrix, the correct L and U matrices correspond to option D.

🧠 Conceptual

intermediate

Purpose of permutation matrix in LU decomposition

What is the main purpose of the permutation matrix P in the LU decomposition P * A = L * U?

A To reorder rows of <code>A</code> to improve numerical stability

B To reorder columns of <code>A</code> to reduce computation

C To convert <code>A</code> into a diagonal matrix

D To scale the matrix <code>A</code> before decomposition

💡 Hint

Think about why row swaps might be needed in matrix factorization.

The permutation matrix P reorders the rows of A to place the largest pivot elements on the diagonal, which improves numerical stability during decomposition.

🔧 Debug

advanced

Identify the error in LU decomposition code

What error will this code raise?

import numpy as np
from scipy.linalg import lu
A = np.array([[1, 2], [3, 4], [5, 6]])
P, L, U = lu(A)

A ValueError: Last 2 dimensions of the array must be square

B TypeError: lu() missing 1 required positional argument

C No error, code runs successfully

D IndexError: index out of bounds

💡 Hint

Check the shape requirements for LU decomposition.

LU decomposition requires a square matrix. The input matrix has shape (3, 2), which is not square, so scipy.linalg.lu raises a ValueError.

❓ data_output

advanced

Number of non-zero elements in L and U matrices

After performing LU decomposition on the matrix A = [[2, 1, 1], [4, -6, 0], [-2, 7, 2]], how many non-zero elements are there in the L and U matrices combined?

SciPy

import numpy as np
from scipy.linalg import lu
A = np.array([[2, 1, 1], [4, -6, 0], [-2, 7, 2]])
P, L, U = lu(A)
nonzero_count = np.count_nonzero(L) + np.count_nonzero(U)
print(nonzero_count)

A 10

B 11

C 9

D 12

💡 Hint

Count all non-zero elements in both L and U matrices after decomposition.

The L matrix is lower triangular with ones on the diagonal, and U is upper triangular. Counting their non-zero elements for this 3x3 matrix results in 11.

🚀 Application

expert

Using LU decomposition to solve a linear system

Given the system Ax = b where A = [[3, 1], [1, 2]] and b = [9, 8], which code snippet correctly uses LU decomposition from scipy.linalg to find x?

A

import numpy as np
from scipy.linalg import lu
A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
P, L, U = lu(A)
x = np.linalg.solve(U, np.linalg.solve(L, np.dot(P.T, b)))
print(x)

B

import numpy as np
from scipy.linalg import lu
A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
P, L, U = lu(A)
x = np.linalg.solve(U, np.linalg.solve(L, np.dot(P, b)))
print(x)

C

import numpy as np
from scipy.linalg import lu_solve, lu_factor
A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
lu, piv = lu_factor(A)
x = lu_solve((lu, piv), b)
print(x)

D

import numpy as np
from scipy.linalg import lu_factor, lu_solve
A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
lu, piv = lu_factor(A)
x = np.dot(np.linalg.inv(L), b)
print(x)

💡 Hint

Use lu_factor and lu_solve functions for efficient solving.

The recommended way to solve linear systems using LU decomposition in scipy is to use lu_factor to get LU and pivot arrays, then lu_solve to solve for x. Option C correctly implements this.