Jacobi Method¶

Solve a linear system by isolating its diagonal and synchronously recomputing every component from the same previous iterate, with the resulting iteration matrix governing convergence.

Version: v5 · 2026-09-19 · History
Domain-specific #: 2110
Domain group: Formal Sciences
Origin domain: Mathematics
Subdomains: Numerical Linear Algebra, Stationary Iterative Linear Solvers → Mathematics

Core Idea¶

The Jacobi method is a stationary iterative solver for a square linear system \(Ax=b\). It isolates every unknown using the diagonal coefficient in its own row, then recomputes all unknowns from one shared previous approximation. Write

\[ A=D+R, \]

where \(D=\operatorname{diag}(A)\) and \(R=A-D\). Every diagonal entry must be nonzero so that \(D^{-1}\) exists. Starting from \(x^{(0)}\), the canonical point-Jacobi sweep is

\[ x^{(k+1)}=D^{-1}\bigl(b-Rx^{(k)}\bigr), \]

or componentwise.

How would you explain it like I'm…

Everybody Guesses Together

Imagine a group of friends each trying to guess a secret number, and each guess depends on the others' guesses. Every round, they all write down new guesses at the same time, using only what everyone said last round. Then they compare and do another round. Often the guesses get closer and closer to the right answers, but not always.

Last Round's Guesses Only

The Jacobi method solves a set of equations with many unknowns by guessing over and over. Each equation is used to work out one unknown, by moving everything else to the other side and dividing. In every round, all the new values are computed from the previous round's values only, never from values already updated in the same round. Because of that, every unknown can be updated at the same time, and the order does not matter. The guesses do not always settle down; whether they do depends on the equations.

Simultaneous-Update Linear Solver

The Jacobi method is an iterative way to solve a square linear system Ax = b. Split A into its diagonal D and the remainder R, and require every diagonal entry to be nonzero. Each sweep computes x_new = D^{-1}(b − R x_old): every unknown is solved from its own row using only the previous iterate. This 'old-iterate barrier' is what separates it from Gauss–Seidel, which uses new values as soon as they are computed. Because of this, the updates can run in parallel, but you need a separate buffer for the new vector. It converges from every starting guess exactly when a quantity called the spectral radius of the iteration matrix is less than 1. Strict diagonal dominance is enough to guarantee this, but it is not required.

The Jacobi method is a stationary iterative solver for Ax = b. Write A = D + R, where D = diag(A) must be invertible and R is the off-diagonal remainder. The sweep is x^(k+1) = D^(−1)(b − R x^(k)), or componentwise x_i^(k+1) = (b_i − Σ_{j≠i} a_ij x_j^(k)) / a_ii. Its defining feature is the old-iterate barrier: every new component depends only on the previous iterate. This makes the sweep order-independent and fully parallel, and it requires a separate buffer, since overwriting values in place would change the method. For this reason it is also called the method of simultaneous displacements. With the iteration matrix B_J = I − D^(−1)A and c = D^(−1)b, the error obeys e^(k+1) = B_J e^(k). Hence, for nonsingular A, the iteration converges from every start if and only if ρ(B_J) < 1. Strict diagonal dominance is sufficient but neither necessary nor definitional. Stopping tolerances and iteration caps are implementation choices, and a diverging run is still the Jacobi method.

Scope of Application¶

Large sparse linear systems. Each sweep requires diagonal scaling and a sparse matrix-vector product or row traversal. The method avoids factorization storage and exposes regular component-level parallelism.

Discretized elliptic equations. Finite-difference or finite-element Poisson-like systems motivate classical analysis. Jacobi can be slow as a standalone solver because smooth error modes decay weakly as the mesh is refined, but damped Jacobi is useful as a multigrid smoother when it rapidly reduces oscillatory components that a coarse grid cannot represent.

Clarity¶

Jacobi clarifies an iterative solver by separating what is fixed during a sweep from what is updated between sweeps. This distinction is operational, not cosmetic. Two implementations using the same component formula can be different methods if one reads only \(x^{(k)}\) and the other consumes partial \(x^{(k+1)}\).

Manages Complexity¶

A direct factorization couples rows through fill, pivoting, and triangular solves. Jacobi replaces that global dependency pattern with repeated local scalar or block solves. Each row needs its diagonal, right-hand side, neighboring old values, and a place for one new value. Sparse structure remains sparse; no fill graph is created by the sweep itself.

Abstract Reasoning¶

Error prediction. Because \(e^{(k)}=B_J^ke^{(0)}\), an eigencomponent with eigenvalue \(\lambda\) is multiplied asymptotically by \(\lambda\) per sweep. Magnitude sets decay/growth; sign or complex phase sets alternation/rotation.

Convergence prediction. If \(\rho(B_J)<1\), every initial error decays. If \(\rho(B_J)>1\), generic starts diverge, though a specially chosen error can avoid unstable eigendirections. State the “every starting vector” quantifier.

Knowledge Transfer¶

The full mechanism transfers literally among sparse scientific systems: split the diagonal, preserve an old generation, compute independent next values, exchange them, inspect the residual, and continue under a convergence/stopping contract. A heat stencil, circuit network, structural discretization, and graph-Laplacian system can share this exact computation.

Block Jacobi transfers the same grammar to subdomains and variable groups. Each block owns a local solve; cross-block terms read the old global state. This makes the point method's synchronization invariant scale to parallel domain decomposition without pretending that blocks are scalar entries.

Relationships to Other Abstractions¶

Current abstraction Jacobi Method Domain-specific

Parents (2) — outgoing typed relations

Jacobi Method is a kind of Iteration Prime

prime:iteration — proposed strict subsumption parent. Jacobi is a particular state-carrying repeated update whose child differentia are the linear system, diagonal split, synchronization rule, and spectral verdict.
Jacobi Method presupposes Matrix Domain-specific

domain_specific:matrix — proposed strict presupposition. The coefficient matrix, its diagonal and remainder, and the iteration matrix are indispensable; the method is not a subtype of an array.

Hierarchy paths (6) — routes to 6 parentless roots

Jacobi Method → is a kind of Iteration

Show alternative paths (5)

Neighborhood in Abstraction Space¶

Jacobi Method sits in a sparse region of the domain-specific corpus (66^th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Convex Optimization & Iterative Methods (8 abstractions)

Nearest neighbors

Computed from structural-signature embeddings · 2026-10-25