Identity matrix determinant

Deep Breakdown

What it tells me (Situation Awareness): The identity matrix $I_n$ (or just $I$ when the size is clear) is the $n \times n$ matrix with ones on the main diagonal and zeros everywhere else. Its determinant is always 1: $\det(I) = 1$. This is the canonical baseline value: $\det(I) = 1$ because $I$ represents the "do nothing" linear transformation, which scales volumes by a factor of exactly 1 (no stretching, shrinking, or flipping). In DA/DS, $\det(I) = 1$ is a reference point for understanding how determinants change under operations: adding $\lambda I$ to a matrix (ridge regularization), multiplying by orthogonal matrices (which have $|\det| = 1$), and building the characteristic polynomial $\det(A - \lambda I) = 0$.

Flowchart

Real-world use

Where it is used

$\det(I) = 1$ appears as: the baseline in the product rule $\det(AB) = \det(A)\det(B)$ (multiplying by $I$ preserves the determinant), the explanation for why orthogonal matrices have $|\det| = 1$ (since $Q^T Q = I$ implies $\det(Q)^T \det(Q) = 1$), and the anchor for the characteristic polynomial $\det(A - \lambda I)$ where $\lambda = 0$ gives $\det(A - 0 \cdot I) = \det(A)$.

Problem it solves

When reasoning about how determinants change under transformations (scaling, rotation, regularization), $\det(I) = 1$ is the reference: any transformation that is "close to the identity" has a determinant close to 1. This helps reason about whether a near-identity covariance structure is well-conditioned.

How it solves the problem

Using either the eigenvalue formula ($I$ has all eigenvalues equal to 1, product $= 1$) or the $2 \times 2$ formula ($1 \cdot 1 - 0 \cdot 0 = 1$), or the Leibniz formula (the only permutation that contributes a non-zero term is the identity permutation, which gives $+1$): all three agree. The result is a hard fact: $\det(I_n) = 1$ for any $n$.

Example in a business

A data scientist checks whether PCA rotation preserves the determinant of the covariance matrix. The eigenvector matrix $Q$ (whose columns are PCA directions) satisfies $Q^T Q = I$, so $\det(Q^T)\det(Q) = \det(I) = 1$, giving $\det(Q)^2 = 1$ and $|\det(Q)| = 1$. This means applying PCA rotation changes the coordinate frame but not the total variance (since the absolute volume scaling is 1). The data scientist uses this to verify that the total variance in the rotated space equals the total variance in the original space: $\text{tr}(\Lambda) = \text{tr}(Q^T \Sigma Q)$.

The formula, piece by piece

• $\det(\cdot)$: the determinant operator; takes a square matrix and returns a scalar
• $I$: the identity matrix; $I_n$ is $n \times n$ with $[I]_{ij} = 1$ if $i = j$ (diagonal) and $0$ if $i \neq j$
• $= 1$: the determinant evaluates to exactly 1, for any dimension $n$
• This holds because: all eigenvalues of $I$ are 1 ($Iv = 1 \cdot v$ for any $v$), and $\det(I) = \prod_i \lambda_i = 1^n = 1$ Full formula: $\det(I_n) = 1$ for all $n \geq 1$

The formula in words

"The identity matrix is the 'do nothing' transformation. It maps every vector to itself, so it scales all volumes by exactly 1. Its determinant is 1." Tiny numeric example ($n = 3$): $I_3 = \begin{bmatrix}1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\end{bmatrix}$. Using the $2 \times 2$ sub-formula approach (cofactor expansion along row 1): $\det(I_3) = 1 \cdot \det\begin{bmatrix}1 & 0 \\ 0 & 1\end{bmatrix} - 0 + 0 = 1 \cdot 1 = 1$.

Critical Concepts

• Orthogonal matrices: $Q$ orthogonal means $Q^T Q = I$. Taking determinants: $\det(Q^T)\det(Q) = 1 \Rightarrow [\det(Q)]^2 = 1 \Rightarrow \det(Q) = \pm 1$. Rotation matrices have $\det = +1$; reflection matrices have $\det = -1$.
• Product rule anchor: $\det(AI) = \det(A)\det(I) = \det(A) \cdot 1 = \det(A)$. Multiplying by $I$ never changes the determinant.
• Characteristic polynomial: $\det(A - \lambda I) = 0$ is the eigenvalue equation. At $\lambda = 0$: $\det(A)$; the fact that $I$ has determinant 1 is why subtracting $\lambda I$ shifts eigenvalues by $\lambda$.
• Regularization scaling: $\det(A + \varepsilon I) = \prod_i(\lambda_i + \varepsilon) \to \varepsilon^n$ as $\lambda_i \to 0$; the identity's "contribution" is $\varepsilon^n$ in the limit.
• Scalar multiples: $\det(kI_n) = k^n$; scaling the identity by $k$ gives a diagonal matrix with all entries $k$, whose determinant is $k^n$.
• The identity is the only matrix (up to sign and reordering) with $\det = 1$ and all eigenvalues equal to 1.

Step-by-step calculation (tiny example)

Step 1: Write the 2x2 identity and apply the determinant formula $I_2 = \begin{bmatrix}1 & 0 \\ 0 & 1\end{bmatrix}$. $\det(I_2) = 1 \cdot 1 - 0 \cdot 0 = 1$.

Step 2: Scale and verify the scaling rule $k = 3$: $kI_2 = \begin{bmatrix}3 & 0 \\ 0 & 3\end{bmatrix}$. $\det(3I_2) = 3 \cdot 3 - 0 = 9 = 3^2$. Consistent with $\det(kI_n) = k^n$.

Step 3: Verify orthogonal matrix property via det(I) = 1 Rotation matrix $Q = \begin{bmatrix}\cos\theta & -\sin\theta \\ \sin\theta & \cos\theta\end{bmatrix}$. $\det(Q) = \cos^2\theta + \sin^2\theta = 1$ (for any $\theta$). $Q^T Q = I$ implies $\det(Q)^2 = \det(I) = 1$, so $\det(Q) = \pm 1$.

Code examples

Beginner example (Python)

import numpy as np

# -- det(I) = 1: verify and explore scaling and orthogonal properties --
for n in [2, 3, 4, 5]:
    I_n = np.eye(n)
    print(f"det(I_{n}) = {np.linalg.det(I_n):.6f} (should be 1.0)")

# Scaling rule: det(k * I_n) = k^n
K = 3.0
N = 4
scaled_I = K * np.eye(N)
print(f"\ndet({K} * I_{N}) = {np.linalg.det(scaled_I):.4f} (should be {K**N:.4f} = {K}^{N})")

# Orthogonal matrix: |det| = 1 since Q^T Q = I
theta = np.pi / 6  # 30 degrees
Q = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
print(f"\nRotation matrix Q (theta = {np.degrees(theta):.0f} deg):")
print(Q.round(4))
print(f"det(Q) = {np.linalg.det(Q):.6f} (should be 1.0: rotation preserves orientation)")
print(f"Q.T @ Q == I: {np.allclose(Q.T @ Q, np.eye(2))}")

Beginner example (R)

# -- det(I) = 1: verify and scaling rule ------------------------------
for (n in 2:5) {
  cat(sprintf("det(I_%d) = %.6f (should be 1.0)\n", n, det(diag(n))))
}

# Scaling rule
K <- 3.0; N <- 4L
cat(sprintf("\ndet(%g * I_%d) = %.4f (should be %.4f = %g^%d)\n", K, N, det(K * diag(N)), K^N, K, N))

# Orthogonal matrix
theta <- pi / 6
Q <- matrix(c(cos(theta), sin(theta), -sin(theta), cos(theta)), nrow = 2)
cat(sprintf("\ndet(Q) = %.6f (rotation, should be 1.0)\n", det(Q)))
cat(sprintf("Q^T Q == I: %s\n", isTRUE(all.equal(t(Q) %*% Q, diag(2)))))

Professional example (Python)

import numpy as np
import pandas as pd
np.random.seed(42)

# -- Business scenario: verify PCA rotation preserves total variance
# Q (eigenvector matrix) is orthogonal, so det(Q) = +-1.
# Total variance = tr(Sigma) must equal tr(Lambda) (in rotated PCA space).
# det(I) = 1 is the anchor: Q^T Q = I means det(Q)^2 = 1.
N_OBS = 200
N_FEATURES = 6
KPI_NAMES = ["spend", "impressions", "clicks", "cvr", "revenue", "roas"]

# Simulate correlated KPI data
L_sim = np.tril(np.random.uniform(0.2, 1.0, size=(N_FEATURES, N_FEATURES)))
X = np.random.normal(0, 1, size=(N_OBS, N_FEATURES)) @ L_sim.T
X_c = X - X.mean(axis=0)
cov_matrix = X_c.T @ X_c / (N_OBS - 1)

# PCA eigendecomposition
eigenvalues, eigenvectors = np.linalg.eigh(cov_matrix)
eigenvalues = eigenvalues[::-1]
eigenvectors = eigenvectors[:, ::-1]  # columns are principal components (= Q)

# Verify Q is orthogonal: Q^T Q = I
Q = eigenvectors
QtQ = Q.T @ Q
I_n = np.eye(N_FEATURES)
orthogonality_error = float(np.max(np.abs(QtQ - I_n)))
det_Q = float(np.linalg.det(Q))

# Variance preservation: tr(Sigma) == tr(Lambda) == tr(Q^T Sigma Q)
Lambda = np.diag(eigenvalues)
total_var = float(np.trace(cov_matrix))
trace_lambda = float(np.trace(Lambda))
trace_rotated = float(np.trace(Q.T @ cov_matrix @ Q))
print(f"Q^T Q - I max error: {orthogonality_error:.2e} (should be ~0)")
print(f"det(Q) = {det_Q:.6f} (should be +/-1 since Q^T Q = I -> det(Q)^2 = det(I) = 1)")
print(f"\nTotal variance tr(Sigma): {total_var:.4f}")
print(f"Sum of eigenvalues tr(Lambda): {trace_lambda:.4f}")
print(f"Trace of rotated cov tr(Q^T S Q): {trace_rotated:.4f}")
print(f"\nVariance preserved by rotation: {np.isclose(total_var, trace_lambda)}")
print(f"\nExplained variance per component:")
pca_df = pd.DataFrame({
    "component": [f"PC{i+1}" for i in range(N_FEATURES)],
    "eigenvalue": eigenvalues.round(3),
    "explained_pct": (eigenvalues / total_var * 100).round(2),
})
print(pca_df.to_string(index=False))
print("\nInterpretation: det(I) = 1 is why |det(Q)| = 1 for the PCA rotation matrix -- rotation is a volume-preserving transformation.")

Professional example (R)

# PCA rotation Q: det(Q) = +/-1, trace preserved
set.seed(42)
N_OBS <- 200
N_FEATURES <- 4
L_sim <- matrix(rnorm(N_FEATURES^2), nrow = N_FEATURES)
X <- scale(matrix(rnorm(N_OBS * N_FEATURES), nrow = N_OBS) %*% t(L_sim), scale = FALSE)
cov_matrix <- (t(X) %*% X) / (N_OBS - 1)
eig <- eigen(cov_matrix, symmetric = TRUE)
Q <- eig$vectors[, order(-eig$values)]
QtQ <- t(Q) %*% Q
orthogonality_error <- max(abs(QtQ - diag(N_FEATURES)))
det_Q <- det(Q)
total_var <- sum(diag(cov_matrix))
trace_lambda <- sum(eig$values)
cat(sprintf("Q^T Q - I max error: %.2e det(Q) = %.6f Variance preserved: %s\n", orthogonality_error, det_Q, isTRUE(all.equal(total_var, trace_lambda))))

Source: 1300 p. 117

#linear-algebra#matrices-and-determinants#determinants-and-inverses