Question bank — Solving linear systems — Gaussian elimination with partial pivoting

False. It also avoids dividing by tiny pivots, which spawn huge multipliers that amplify round-off; stability, not just legality, is the point.

True. We put the largest-magnitude column entry on the diagonal, so $|a_{ik}|\le |a_{kk}|$ and $|m_{ik}|=|a_{ik}/a_{kk}|\le 1$.

False. Swapping two equations just reorders them; the solution set is untouched — swapping is a legal elementary row operation.

False. A nonzero-but-tiny pivot is legal yet numerically disastrous in floating point; partial pivoting still helps enormously.

False. Some non-singular matrices give a zero pivot mid-way (needing a swap), and the process can also lose accuracy badly without ever hitting an exact zero.

False. Complete pivoting searches the whole remaining submatrix, so it may pick a different pivot and give a (usually more) accurate result at higher cost.

False. Only the last equation has a single unknown; each $x_i$ needs the already-known $x_j$ for $j>i$, so you must go bottom-up.

False. Such matrices are stable without pivoting (Cholesky needs none); pivoting there can even destroy symmetry. See Condition Number and Numerical Stability.

True. No swap can supply a usable pivot, so column $k$ (rows $k\dots n$) is all zero — the rows are dependent and $\det A=0$.

False. It only adds $O(n^2)$ comparisons on top of the $\frac{2}{3}{n}^3$ elimination cost — cheap insurance, not a doubling.

Wrong axis. Partial pivoting compares entries down the current column (rows $k\dots n$), not along a row; a row search would mix up different variables.

The swap must include the right-hand side. Work on the augmented $[A|\mathbf{b}]$; a half-swap pairs wrong RHS values with wrong equations and corrupts the answer.

The ratio is upside-down. We need $a_{ik}-m_{ik}{a}_{kk}=0$, giving $m_{ik}=a_{ik}/a_{kk}$ — pivot in the denominator.

The row operation ${\text{Row}}_i\leftarrow {\text{Row}}_i-m_{ik}{\text{Row}}_k$ acts on every column including the RHS: $b_i\leftarrow b_i-m_{ik}{b}_k$. Skipping $\mathbf{b}$ solves the wrong system.

You must divide by the pivot: $x_i=\frac{1}{u_{ii}}(c_i-{\sum }_{j>i}{u}_{ij}{x}_j)$. Omitting $u_{ii}$ mis-scales every unknown except when $u_{ii}=1$.

Scaling a zero stays zero; scaling a nonzero pivot changes nothing essential. The correct move is a row swap with a row that has a nonzero column entry.

Pivoting uses absolute value: $\arg {\max }_{i\ge k}|a_{ik}|$. A large-magnitude negative entry (e.g. $-9$ over $+2$) is the better, more stable pivot.

The update $a_{ij}\leftarrow a_{ij}-m_{ik}{a}_{kj}$ scales the pivot row by $m_{ik}$; a large $m_{ik}$ can swamp $a_{ij}$ so significant digits of the small term are lost to round-off. See Round-off Error in Floating Point.

Rows above $k$ are already finalized (their pivots are set), and other columns belong to variables we haven't reached; only the current column's sub-entries can legally supply this step's pivot.

Elimination touches an $O(n)\times O(n)$ block for each of $n$ columns ($\sim \frac{2}{3}{n}^3$), while back-substitution does one $O(n)$-length sum per unknown for $n$ unknowns ($\sim n^2$).

$\det A$ equals the product of the pivots times $(-1{)}^s$ for $s$ row swaps; elimination already produces those pivots, far cheaper than the $n!$ cofactor route. See Determinants and Cramer's Rule.

Bounded multipliers keep the entries of $U$ from growing wildly, which bounds the amplification of round-off — this is exactly what "numerical stability" buys us.

The pivoted elimination is an $LU$ factorization $PA=LU$; storing $L$, $U$, $P$ lets us solve $A\mathbf{x}=\mathbf{b}$ for many different $\mathbf{b}$ without re-eliminating. See LU Decomposition and Back-substitution and Forward-substitution.

For huge sparse systems, $\frac{2}{3}{n}^3$ direct work and fill-in become prohibitive, whereas each iteration is $O(\text{nonzeros})$. See Iterative Methods (Jacobi, Gauss-Seidel).

No swap yields a nonzero pivot, so $A$ is singular; the system has either no solution or infinitely many, never a unique one.

It swaps the row with itself — a no-op. Pivoting never hurts; in the best case it simply confirms the current pivot.

Either is valid; a common tie-break is the lowest-index row. The choice affects intermediate numbers but not the exact solution.

All below-diagonal entries are zero, so every multiplier is zero and no swaps improve things; you can jump straight to back-substitution.

Yes — swap that lower row up to supply a nonzero pivot. This is precisely the case partial pivoting was designed to rescue.

Pivoting still runs and gives an answer, but a large condition number means small data errors can cause large solution errors; report with caution. See Condition Number and Numerical Stability.

There is nothing to eliminate; back-substitution gives $x=b/a$, and pivoting only checks that $a\ne 0$ (else singular).