[proofplan] We run Gauss-Jordan elimination on the augmented matrix $(A \mid b)$ using the zero test to choose pivots, inverses of nonzero pivots to normalize pivot rows, and field arithmetic to eliminate entries. Elementary row operations preserve exactly the solution set of the augmented system, so the final reduced row echelon form detects inconsistency precisely. The arithmetic-operation count is polynomial in $m$ and $n$, and the polynomial control assumptions on the field encoding convert this arithmetic bound into a bit-time bound, including the cost of writing the output solution. [/proofplan] [step:Encode the augmented system and specify the elimination algorithm] Let $N_{\mathrm{in}}$ denote the total length of the entrywise encodings of $A$ and $b$. Define the augmented matrix $C \in k^{m \times (n+1)}$ by \begin{align*} C_{ij} = A_{ij} \text{ for } 1 \leq i \leq m,\ 1 \leq j \leq n,\quad C_{i,n+1} = b_i \text{ for } 1 \leq i \leq m. \end{align*} The algorithm maintains a row index $r \in \{1,\dots,m+1\}$, initially $r=1$, and scans columns $j=1,\dots,n$. At column $j$, it searches among rows $r,r+1,\dots,m$ for an entry unequal to $0_k$, using the encoded zero test. If none exists, it proceeds to column $j+1$. If such an entry occurs in row $s$, it swaps rows $r$ and $s$, multiplies row $r$ by $C_{rj}^{-1}$, and for every row $i \neq r$ replaces row $i$ by row $i - C_{ij} \cdot \text{row } r$. It then records column $j$ as a pivot column and increments $r$ by $1$. All operations invoked here are among the permitted encoded field operations: zero testing, inversion of a nonzero element, multiplication, subtraction, and copying encoded entries. [/step] [step:Show that every row operation preserves the solution set] For a matrix $D \in k^{m \times (n+1)}$, define the associated solution set $S(D) \subset k^n$ by \begin{align*} S(D) = \{x \in k^n : \sum_{j=1}^{n} D_{ij}x_j = D_{i,n+1} \text{ for every } i \in \{1,\dots,m\}\}. \end{align*} We verify that each elementary row operation used by the algorithm leaves $S(D)$ unchanged. Swapping two rows only changes the order in which the same equations are listed, hence does not change the set of vectors satisfying all equations. Multiplying row $i$ by a scalar $\lambda \in k^\times$ replaces the equation \begin{align*} \sum_{j=1}^{n} D_{ij}x_j = D_{i,n+1} \end{align*} by \begin{align*} \sum_{j=1}^{n} \lambda D_{ij}x_j = \lambda D_{i,n+1}. \end{align*} Since $\lambda$ has inverse $\lambda^{-1}$ in $k$, these two equations are equivalent. Finally, replacing row $i$ by row $i-\mu$ row $q$ replaces the $i$th equation by the difference between the old $i$th equation and $\mu$ times the old $q$th equation. Any vector satisfying the old system satisfies the new system by subtracting equal quantities. Conversely, if a vector satisfies the new system and the unchanged $q$th equation, then adding $\mu$ times the $q$th equation recovers the old $i$th equation. Therefore the solution set is preserved. [guided] The purpose of this step is to justify that row reduction is not merely a formal manipulation of arrays: it preserves exactly the vectors $x \in k^n$ solving the system. For every augmented matrix $D \in k^{m \times (n+1)}$, we attach the concrete solution set \begin{align*} S(D) = \{x \in k^n : \sum_{j=1}^{n} D_{ij}x_j = D_{i,n+1} \text{ for every } i \in \{1,\dots,m\}\}. \end{align*} Thus proving correctness of row operations means proving equality of these sets before and after each operation. A row swap preserves $S(D)$ because the system is a finite conjunction of equations, and exchanging two conjuncts does not change which vectors satisfy all of them. Next consider multiplying row $i$ by a scalar $\lambda \in k^\times$. The original row equation is \begin{align*} \sum_{j=1}^{n} D_{ij}x_j = D_{i,n+1}. \end{align*} The new row equation is \begin{align*} \sum_{j=1}^{n} \lambda D_{ij}x_j = \lambda D_{i,n+1}. \end{align*} If the original equation holds, multiplying both sides by $\lambda$ gives the new equation. If the new equation holds, multiplying both sides by $\lambda^{-1}$ gives the original equation. The inverse exists because the operation is only used with $\lambda \neq 0_k$. Finally consider replacing row $i$ by row $i-\mu$ row $q$, where $\mu \in k$. If $x$ satisfies the old system, then it satisfies both the old $i$th equation and the old $q$th equation, so subtracting $\mu$ times the $q$th equality from the $i$th equality gives the new $i$th equation. Conversely, suppose $x$ satisfies the new system. The $q$th row was not changed, so $x$ also satisfies the old $q$th equation. Adding $\mu$ times that $q$th equation to the new $i$th equation recovers the old $i$th equation. Hence the old and new systems have the same solution set. [/guided] [/step] [step:Identify inconsistency and construct a solution from reduced row echelon form] Let $R \in k^{m \times (n+1)}$ be the final augmented matrix. By the preceding step, $S(R)=S(C)$, and $S(C)$ is exactly the solution set of $Ax=b$. If some row $i$ satisfies $R_{ij}=0_k$ for every $j \in \{1,\dots,n\}$ and $R_{i,n+1} \neq 0_k$, then the corresponding equation is $0_k=R_{i,n+1}$, which is false in a field. Hence $S(R)=\varnothing$, and the algorithm correctly reports that $Ax=b$ has no solution. Assume no such row exists. Let $P \subset \{1,\dots,n\}$ be the set of pivot columns recorded by the algorithm, and let $F=\{1,\dots,n\}\setminus P$ be the set of free columns. Define $x \in k^n$ as follows. For each free column $j \in F$, set $x_j=0_k$. For each pivot column $p \in P$, let $i(p)$ be the unique row whose leading pivot is in column $p$, and set \begin{align*} x_p = R_{i(p),n+1}. \end{align*} Because the algorithm normalized each pivot to $1_k$ and eliminated all other entries in each pivot column, every nonzero row of $R$ has the form \begin{align*} x_p + \sum_{j \in F} R_{i(p),j}x_j = R_{i(p),n+1}. \end{align*} With $x_j=0_k$ for every $j \in F$ and $x_p=R_{i(p),n+1}$, each such equation is satisfied. The zero rows are also satisfied because we have assumed there is no row with zero coefficient part and nonzero final entry. Thus $x \in S(R)=S(C)$, so $Ax=b$. [/step] [step:Bound the number of field operations by a polynomial] There are at most $\min(m,n)$ pivot columns. For each column scan, the algorithm performs at most $m$ zero tests. Across all $n$ columns, this gives at most $mn$ zero tests. For each pivot, row normalization applies one inversion and then at most $n+1$ multiplications. Eliminating the pivot column from all rows $i \neq r$ uses, for each such row, at most $n+1$ multiplications and at most $n+1$ subtractions. Hence one pivot uses at most \begin{align*} 1 + (n+1) + (m-1)(2n+2) \end{align*} field operations other than zero tests, up to row swaps and copying entries. Since the number of pivots is at most $\min(m,n)$, the total number of arithmetic operations is bounded by \begin{align*} mn + \min(m,n)\bigl(1 + (n+1) + (m-1)(2n+2)\bigr), \end{align*} which is a polynomial in $m$ and $n$. [/step] [step:Convert the arithmetic bound into encoded polynomial time] By hypothesis, the field encoding supplies polynomial-time algorithms for zero testing, addition, subtraction, multiplication, and inversion of nonzero elements. The algorithm performs only polynomially many such operations on entries obtained from the original encodings by a polynomially bounded sequence of field operations. The polynomial growth condition in the definition of a polynomially controlled field encoding therefore gives a polynomial $Q$ such that every intermediate entry encoding and every output entry encoding has length at most $Q(m,n,N_{\mathrm{in}})$. Since each field operation on such encodings takes time polynomial in their lengths, and since the number of operations is polynomial in $m$ and $n$, the total running time of elimination is bounded by a polynomial in $m$, $n$, and $N_{\mathrm{in}}$. The final consistency test performs at most $m(n+1)$ zero tests. If a solution exists, writing the vector $x \in k^n$ outputs $n$ encodings, each of length at most $Q(m,n,N_{\mathrm{in}})$, so the output-writing time is also polynomial. This proves that Gaussian elimination decides solvability and computes one solution in polynomial time under the stated encoding assumptions. [/step]