An iterative procedure that seeks a fixed point x = G(x) of a mapping G by repeatedly applying G to an initial guess: x_{k+1} = G(x_k). Convergence depends on contractivity or related properties of G.

Principle

The organizing idea is to recast the problem as finding a self-consistent point of a map and then use repeated application of that map; Banach fixed-point theorem gives a simple sufficient condition (contraction) guaranteeing unique fixed point and linear convergence.

Demonstration

Solve x = cos(x) by iterating x_{k+1} = cos(x_k) starting from x_0; because cos is a contraction on [0,1], the iterates converge to the unique fixed point approximately 0.739085, illustrating simple Picard iteration for scalar nonlinear equations.

Misapplication

Applying naive fixed-point iteration to a map with Lipschitz constant ≥1 or without proper preconditioning can fail to converge or converge extremely slowly; choosing a poor reformulation G(x) of f(x)=0 may prevent any progress.

Consequence

When the mapping is contractive or suitably damped, fixed-point iteration provides a simple and robust solver with predictable linear convergence and low per-iteration cost; it underlies many iterative schemes including Picard linearization for PDEs.

Reversal

The contrast is to Newton-type linearization: instead of repeatedly applying the original map, Newton solves linearized corrections producing potentially faster (superlinear or quadratic) local convergence at the cost of solving linear systems.

Boundary

Applicable when one can construct a map G with fixed points equivalent to the original problem and with contractive or averaged properties; excludes mappings that are not continuous or problems where only derivative-based rapid convergence is acceptable.

Semantic Tension

Tension with Newton and quasi-Newton methods: fixed-point iteration is cheaper and simpler but slower; there is also tension with accelerated or multistep fixed-point variants that add memory or mixing to improve convergence.

Synthesis

Fixed-point iteration reframes a problem as x = G(x) and repeatedly applies G, relying on contractivity or damping for convergence; it is conceptually simple, low-cost per iteration, and a foundation for many linearization and splitting algorithms, but its speed depends critically on the map's properties.