np.linalg.solve() for linear systems in NumPy - Step-by-Step Execution

Concept Flow - np.linalg.solve() for linear systems

Start with matrix A and vector b

↓

Check if A is square and dimensions match b

Yes↓

Use np.linalg.solve(A, b) to find x

↓

Return solution vector x

↓

End

The function takes a square matrix A and vector b, checks dimensions, then solves Ax = b for x.

Execution Sample

NumPy

import numpy as np
A = np.array([[3,1],[1,2]])
b = np.array([9,8])
x = np.linalg.solve(A, b)
print(x)

Solves the system 3x + y = 9 and x + 2y = 8 for x and y.

Execution Table

Step	Action	Input	Intermediate Result	Output
1	Define matrix A	[[3,1],[1,2]]	Matrix A created
2	Define vector b	[9,8]	Vector b created
3	Check dimensions	A shape (2,2), b shape (2,)	Dimensions valid
4	Call np.linalg.solve(A,b)	A, b	Computes solution x
5	Return solution x		[2. 3.]	x = [2. 3.]
6	Print x			[2. 3.]

💡 Solution found because A is square and dimensions match b

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 4	Final
A	undefined	[[3 1] [1 2]]	[[3 1] [1 2]]	[[3 1] [1 2]]	[[3 1] [1 2]]
b	undefined	undefined	[9 8]	[9 8]	[9 8]
x	undefined	undefined	undefined	[2. 3.]	[2. 3.]

Key Moments - 3 Insights

Why must matrix A be square to use np.linalg.solve()?

np.linalg.solve() requires a square matrix because only square matrices have unique solutions for Ax = b. See execution_table step 3 where dimension check ensures A is square.

What happens if the dimensions of b do not match A?

The function will raise an error because b must have the same number of rows as A. This is checked in execution_table step 3.

Why does np.linalg.solve() return a vector x?

Because it solves the equation Ax = b for x, which is the vector of unknowns. This is shown in execution_table step 5 where the solution vector is returned.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of x after step 4?

A [3. 1.]

B [2. 3.]

C [9. 8.]

D undefined

💡 Hint

Check the 'Intermediate Result' column at step 4 in execution_table.

At which step does the code check if A is square and matches b's dimensions?

A Step 2

B Step 4

C Step 3

D Step 5

💡 Hint

Look for the 'Check dimensions' action in execution_table.

If b had shape (3,) instead of (2,), what would happen?

A The function would raise a dimension mismatch error

B np.linalg.solve() would return a solution vector of length 3

C The function would ignore extra elements in b

D The function would solve with the first two elements only

💡 Hint

Refer to key_moments about dimension matching and execution_table step 3.

Concept Snapshot

np.linalg.solve(A, b)
- Solves Ax = b for x
- A must be square matrix
- b must match A's row count
- Returns solution vector x
- Fast and accurate for linear systems

Full Transcript

This visual trace shows how np.linalg.solve() works step-by-step. First, we define matrix A and vector b. Then, the function checks if A is square and if b's dimensions match. If valid, it computes the solution vector x that satisfies Ax = b. The solution is returned and printed. Key points include the requirement for A to be square and dimension matching with b. The execution table tracks each step and variable changes, helping beginners understand the process clearly.

Practice

1. What does np.linalg.solve(A, b) do in NumPy?

easy

A. Solves the system of linear equations Ax = b for x

B. Calculates the determinant of matrix A

C. Finds the inverse of matrix A

D. Multiplies matrix A by vector b

Solution

1. Step 1: Understand the function purpose

   np.linalg.solve() is designed to find the vector x that satisfies the equation Ax = b, where A is a square matrix and b is a vector.

2. Step 2: Differentiate from other matrix operations

   Calculating determinant, inverse, or multiplication are different operations and use other functions like np.linalg.det(), np.linalg.inv(), or @ operator respectively.

3. Final Answer:

   Solves the system of linear equations Ax = b for x -> Option A

4. Quick Check:

   np.linalg.solve() = solve Ax=b [OK]

Hint: It finds x in Ax = b, not determinant or inverse [OK]

Common Mistakes:

• Confusing solve() with matrix inverse
• Using solve() for non-square matrices
• Thinking it multiplies matrices

2. Which of the following is the correct syntax to solve the system Ax = b using NumPy?

easy

A. np.linalg.solve(b, A)

B. np.solve.linalg(A, b)

C. np.linalg.solve(A, b)

D. np.solve(A, b)

Solution

1. Step 1: Recall correct function call

   The correct function is np.linalg.solve() with the first argument as matrix A and second as vector b.

2. Step 2: Check argument order and module

   Arguments must be (A, b), not reversed. The function is inside np.linalg, not np.solve.

3. Final Answer:

   np.linalg.solve(A, b) -> Option C

4. Quick Check:

   Correct syntax = np.linalg.solve(A, b) [OK]

Hint: Remember: np.linalg.solve(matrix, vector) [OK]

Common Mistakes:

• Swapping A and b arguments
• Using wrong module or function name
• Missing np.linalg prefix

3. What is the output of this code?

import numpy as np
A = np.array([[2, 1], [1, 3]])
b = np.array([10, 15])
x = np.linalg.solve(A, b)
print(x)

medium

A. [2. 5.]

B. [4. 3.]

C. [5. 2.]

D. [3. 4.]

Solution

1. Step 1: Set up equations from matrix and vector

   Matrix A and vector b represent:
   2x + 1y = 10
   1x + 3y = 15

2. Step 2: Solve equations manually or trust np.linalg.solve

   Solving:
   From first: y = (10 - 2x)
   Substitute in second: x + 3(10 - 2x) = 15
   x + 30 - 6x = 15
   -5x = -15
   x = 3
   y = 10 - 2*3 = 4
   np.linalg.solve gives x = [3. 4.]

3. Final Answer:

   [3. 4.] -> Option D

4. Quick Check:

   np.linalg.solve(A,b) = [3. 4.] [OK]

Hint: Use np.linalg.solve to get exact solution vector [OK]

Common Mistakes:

• Mixing up order of variables in solution
• Incorrect manual calculation
• Confusing rows and columns in matrix

4. What error will this code produce?

import numpy as np
A = np.array([[1, 2], [3, 4], [5, 6]])
b = np.array([7, 8])
x = np.linalg.solve(A, b)

medium

A. ValueError: shapes (3,2) and (2,) not aligned

B. LinAlgError: Last 2 dimensions of the array must be square

C. TypeError: unsupported operand type(s)

D. No error, returns solution vector

Solution

1. Step 1: Check matrix shape requirements

   Matrix A must be square (same number of rows and columns) to use np.linalg.solve(). Here, A is 3x2, not square.

2. Step 2: Identify error raised by NumPy

   NumPy raises LinAlgError with message about last 2 dimensions needing to be square.

3. Final Answer:

   LinAlgError: Last 2 dimensions of the array must be square -> Option B

4. Quick Check:

   Non-square A causes LinAlgError [OK]

Hint: Matrix A must be square for np.linalg.solve() [OK]

Common Mistakes:

• Using non-square matrix A
• Expecting multiplication instead of solve
• Ignoring error message details

5. You have the system:

3x + 2y - z = 1
2x - 2y + 4z = -2
-x + 0.5y - z = 0

Which code correctly solves for x, y, z using np.linalg.solve()?

hard

A. A = np.array([[3, 2, -1], [2, -2, 4], [-1, 0.5, -1]])
b = np.array([1, -2, 0])
x = np.linalg.solve(A, b)

B. A = np.array([[3, 2, 1], [2, -2, 4], [-1, 0.5, -1]])
b = np.array([1, -2, 0])
x = np.linalg.solve(A, b)

C. A = np.array([[3, 2, -1], [2, -2, 4], [-1, 0.5, -1]])
b = np.array([1, 2, 0])
x = np.linalg.solve(A, b)

D. A = np.array([[3, 2, -1], [2, -2, 4], [-1, 0.5, -1]])
b = np.array([1, -2, 0])
x = np.linalg.inv(A) @ b

Solution

1. Step 1: Translate system to matrix and vector

   Coefficients matrix A must match the system exactly:
   Row 1: 3, 2, -1
   Row 2: 2, -2, 4
   Row 3: -1, 0.5, -1
   Constants vector b is [1, -2, 0].

2. Step 2: Check each option for correctness

   A = np.array([[3, 2, -1], [2, -2, 4], [-1, 0.5, -1]]) b = np.array([1, -2, 0]) x = np.linalg.solve(A, b) matches coefficients and constants exactly.
   A = np.array([[3, 2, 1], [2, -2, 4], [-1, 0.5, -1]]) b = np.array([1, -2, 0]) x = np.linalg.solve(A, b) has wrong sign in third element of first row.
   A = np.array([[3, 2, -1], [2, -2, 4], [-1, 0.5, -1]]) b = np.array([1, 2, 0]) x = np.linalg.solve(A, b) has wrong second element in b.
   A = np.array([[3, 2, -1], [2, -2, 4], [-1, 0.5, -1]]) b = np.array([1, -2, 0]) x = np.linalg.inv(A) @ b uses inverse multiplication which is less efficient and not recommended.

3. Final Answer:

   Option A code correctly solves the system -> Option A

4. Quick Check:

   Correct matrix and vector with np.linalg.solve() [OK]

Hint: Match coefficients and constants exactly; use np.linalg.solve() [OK]

Common Mistakes:

• Wrong signs in matrix or vector
• Using inverse instead of solve()
• Mixing up constants vector values