Question bank — NumPy linear algebra — np.linalg.solve, eig, svd, norm, det

False — solve runs LU factorization + back-substitution and never forms the inverse; skipping the inverse both saves work and avoids the extra error the inverse introduces.

False — determinant scales with the entries, so a matrix like $10^{-4}\cdot I$ has tiny det yet is perfectly well-behaved; use the condition number (np.linalg.cond) to judge trust, not det.

False — it has no unique solution; depending on $b$ it can have infinitely many (if $b$ lies in the collapsed image) or none, but never exactly one.

False — a $90^{\circ }$ rotation matrix has no real eigenvectors (nothing stays pointing the same way), so its eigenvalues are complex; np.linalg.eig will return complex numbers.

False — singular values are always $\ge 0$ by definition; any flip/reflection is absorbed into the orthogonal factors $U$ or $V^{\top }$, not into $\Sigma$.

False — the default ord=2 is the Euclidean length $\sqrt{\sum v_i^2}$; the sum of absolute values is the ${\ell }_1$ norm (ord=1).

False — eig needs a square matrix and reports scaling along possibly-complex, non-orthogonal directions; SVD works for any shape and always gives real, ordered, non-negative stretches along orthogonal directions.

False — there is no such symmetry in general; eigenvalues are just the roots of $\det (A-\lambda I)=0$ and can be any set of numbers (e.g. $A=\text{diag}(2,3)$ has $2,3$, not $-2,-3$).

False in general — they coincide only for symmetric matrices; for a general $A$, ${\sigma }_i$ are square roots of eigenvalues of $A^{\top }A$, which need not match $|{\lambda }_i|$.

False — it confirms the residual is tiny, which is the right practical check, but for an ill-conditioned $A$ a tiny residual can still hide a large error in $x$ itself.

The error is philosophical, not syntactic: it needlessly forms the inverse, which is slower and less accurate; write x = np.linalg.solve(A, b) and keep inv only when you truly need the inverse matrix as an object.

Wrong axis — NumPy stores eigenvectors as columns, so the $i$-th one is V[:, i]; V[0, :] is the first row, a mix of coordinates from all eigenvectors.

s is a 1-D array of singular values, not a matrix — you must expand it into a diagonal $\Sigma$ of $A$'s shape (np.zeros_like(A) + np.fill_diagonal) before multiplying.

Floating point almost never lands on an exact $0$; test conditioning with np.linalg.cond(A) (large ⇒ effectively singular) instead of comparing a float to zero.

eig requires a square matrix and will raise LinAlgError; for a rectangular matrix use np.linalg.svd(A), which is defined for every shape.

For a 2-D array the default is the Frobenius norm ($\sqrt{\sum {\text{entries}}^2}$), not the max entry; pass ord=np.inf (max abs row sum) or np.max(np.abs(M)) if you want an extreme.

Mixing the "full" and "economy" shapes breaks the product; either keep full $U,\Sigma ,V^{\top }$, or pass full_matrices=False so all three factors use the reduced, compatible shapes.

It does not error — solve accepts a right-hand side with multiple columns and returns a 3×5 array whose $k$-th column solves $Ax=B[:,k]$; this is a feature, not a bug.

Forming $A^{-1}$ costs extra operations and injects rounding error into every entry; direct elimination reaches $x$ with fewer, more stable steps because it never manufactures the full inverse.

We need a nonzero $v$ with $(A-\lambda I)v=0$; if $A-\lambda I$ were invertible the only solution would be $v=0$, so it must be singular, which is exactly $\det (A-\lambda I)=0$.

SVD builds its directions from $A^{\top }A$ and $A{A}^{\top }$, which are symmetric positive-semidefinite for any $A$ (any shape), guaranteeing real orthogonal factors and non-negative ${\sigma }_i$; eigendecomposition needs square, diagonalizable structure that many matrices lack.

Each encodes a different notion of size — straight-line distance (${\ell }_2$), total step-by-step distance (${\ell }_1$), worst single coordinate (${\ell }_{\infty }$) — and the right one depends on what "big" should mean in your problem.

The condition number measures how much a solve can amplify errors regardless of overall scale, whereas det conflates scale with degeneracy, so cond directly answers "can I trust this solve?".

The orthogonal $U$ cancels ($U^{\top }U=I$), leaving only the stretches squared; this shows the columns of $V$ are eigenvectors of $A^{\top }A$ and ${\sigma }_i^2$ its eigenvalues, linking SVD back to eigen-analysis.

A diagonal matrix scales each coordinate independently, so a vector lying on an axis is only stretched, never tilted — that "no tilt" property is exactly the eigenvector condition $Av=\lambda v$.

All singular values are $0$ (the map crushes everything to a point); $U$ and $V^{\top }$ are still valid orthogonal matrices, just arbitrary since no direction is stretched more than another.

Undefined — determinant needs a square matrix; NumPy raises LinAlgError. Volume-scaling only makes sense when input and output live in the same-dimensional space.

Almost nothing on the factorization side — an upper-triangular matrix is its own $U$ with $L=I$, so solve goes straight to back-substitution, which is why triangular systems are cheap.

For $2I$ every nonzero vector is an eigenvector, so there is a full 2-D eigenspace; but defective matrices like $\left(\begin{array}{cc}2& 1\\ 0& 2\end{array}\right)$ share $\lambda =2$ yet have only one direction, which is why eig can be fragile there.

np.linalg.norm([]) is $0$ (empty sum), and np.linalg.norm([-5]) is $5$ under every ${\ell }_p$ — with one entry all the norms coincide since there is nothing to combine.

No — within the tied subspace the orthogonal directions can be rotated freely, so $U$ and $V$ are not unique even though the set of ${\sigma }_i$ (and thus $A$) is fixed.

It raises LinAlgError: Singular matrix; when $A$ is merely near-singular it silently returns an answer whose error may be huge — which is why the residual check and cond matter.