Identity, Inverse & Determinant

With ordinary numbers, 1 is special (x × 1 = x) and every non-zero number has a reciprocal (5 × 1/5 = 1). Matrices have the same ideas: the identity matrix plays the role of 1, the inverse plays the role of the reciprocal, and the determinant tells you whether an inverse exists at all. These three are the foundation for solving equations in the next topic.

Definition

The identity matrix I is a square matrix with 1s on the main diagonal and 0s everywhere else. For any matrix A of matching size, A @ I = I @ A = A.

The inverse of a square matrix A, written A⁻¹, is the matrix that "undoes" A: A @ A⁻¹ = A⁻¹ @ A = I.

The determinant of a square matrix, det(A), is a single number computed from its entries. If det(A) = 0 the matrix is singular — it has no inverse. Otherwise it is invertible.

• Square — same number of rows and columns. Only square matrices have an identity partner, an inverse and a determinant.
• Main diagonal — positions [0,0], [1,1], [2,2], ….
• Singular — the matrix squashes space flat (one row is a combination of others), so information is lost and cannot be undone.
• For a 2×2 matrix [[a, b], [c, d]]: det = a·d − b·c and inverse = (1/det) × [[d, −b], [−c, a]].

Syntax

np.eye(N, M=None, k=0, dtype=float)
np.identity(n, dtype=float)
np.linalg.inv(a)
np.linalg.det(a)
np.allclose(a, b)        # compare floats with a tolerance

Example — identity matrix

import numpy as np
I = np.eye(3)
print(I)
print(np.identity(3, dtype=int))
A = np.array([[2, 1, 0], [1, 3, 1], [0, 1, 4]])
print(np.array_equal(A @ np.eye(3, dtype=int), A))
print(np.eye(2, 3, k=1, dtype=int))

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
[[1 0 0]
 [0 1 0]
 [0 0 1]]
True
[[0 1 0]
 [0 0 1]]

How it works: np.eye returns floats by default (1.). Multiplying by I leaves A unchanged. np.eye is more flexible than np.identity — it can be rectangular and shift the diagonal with k.

Example — inverse, and the floating-point surprise

A = np.array([[4, 7],
              [2, 6]])
A_inv = np.linalg.inv(A)
print(A_inv)
print(A @ A_inv)
print(np.allclose(A @ A_inv, np.eye(2)))
print((A @ A_inv).round(10))

[[ 0.6 -0.7]
 [-0.2  0.4]]
[[ 1.00000000e+00  0.00000000e+00]
 [-2.22044605e-16  1.00000000e+00]]
True
[[ 1.  0.]
 [-0.  1.]]

How it works: by the 2×2 formula, det = 4·6 − 7·2 = 10, so A⁻¹ = (1/10) × [[6, −7], [−2, 4]] = [[0.6, −0.7], [−0.2, 0.4]] ✔. A @ A_inv should be exactly I, but computers store decimals in binary, so one cell is -2.22e-16 (= −0.000000000000000222) instead of 0. That is a tiny rounding error, not a bug. Always compare float matrices with np.allclose, never with ==. (-0. after rounding is just "negative zero", which equals 0.)

Example — determinant and a singular matrix

A = np.array([[4, 7],
              [2, 6]])
print(np.linalg.det(A))
print(round(np.linalg.det(A), 6))
S = np.array([[1, 2],
              [2, 4]])
print(np.linalg.det(S))
try:
    np.linalg.inv(S)
except np.linalg.LinAlgError as e:
    print("LinAlgError:", e)

10.000000000000002
10.0
0.0
LinAlgError: Singular matrix

det(A) should be 10 — again a tiny float error, so round it for display. In S, the second row is exactly 2 × the first row, so det(S) = 1·4 − 2·2 = 0: the matrix is singular and inv raises LinAlgError: Singular matrix.

Example — a 3×3 matrix

M = np.array([[2, 1, 0],
              [1, 3, 1],
              [0, 1, 4]])
print(round(float(np.linalg.det(M)), 6))
print(np.linalg.inv(M).round(3))
print(np.allclose(M @ np.linalg.inv(M), np.eye(3)))

18.0
[[ 0.611 -0.222  0.056]
 [-0.222  0.444 -0.111]
 [ 0.056 -0.111  0.278]]
True

What the determinant tells you

Common mistakes

• ❌ A ** -1 or 1 / A for the inverse — these are element-wise reciprocals. ✅ np.linalg.inv(A).
• ❌ Inverting a non-square matrix → LinAlgError: Last 2 dimensions of the array must be square. ✅ Only square matrices have inverses (look up np.linalg.pinv for the pseudo-inverse).
• ❌ (A @ A_inv == np.eye(2)).all() → often False because of rounding. ✅ np.allclose(A @ A_inv, np.eye(2)).
• ❌ Checking det == 0 exactly for float matrices. ✅ Check abs(det) < 1e-10, or better, just try and catch LinAlgError.

Interview tip

Q: When does a matrix not have an inverse? A: When it is not square, or when its determinant is 0 (it is singular) — this happens when one row/column is a linear combination of the others, so the matrix loses information that cannot be recovered.