From f(x) = 0 to x = g(x)
The previous guide gave us the bisection method: safe, guaranteed, but slow — it halves the bracket every step and gains only about one bit per iteration. We want something faster, and the cheapest possible idea is this. Take your equation f(x) = 0 and algebraically shuffle it into the form x = g(x), so that a solution is a point that g maps to itself. Such a point is called a fixed point of g, because feeding it through g changes nothing: g leaves it fixed. Solving f(x) = 0 and finding a fixed point of the right g are then the very same task wearing two different costumes.
Once you have x = g(x), the method writes itself: pick a starting guess x_0, then iterate x_{n+1} = g(x_n), reading off a new guess each time. This is fixed-point iteration, and it could hardly be simpler — one function evaluation per step, no derivatives, no brackets. Picture a number line: you stand at x_0, the function g picks you up and drops you at x_1 = g(x_0), then picks you up from there and drops you at x_2, and so on. If you keep landing closer and closer to one spot, that spot is the fixed point and you have your answer.
Here is the catch that makes the subject interesting: the rearrangement is not unique. The same equation f(x) = 0 can be massaged into many different g's, and they do not all behave the same. Take x^2 - x - 2 = 0, whose roots are -1 and 2. You can write it as x = x^2 - 2, or as x = sqrt(x + 2), or as x = 2/(x - 1), or as x = 1 + 2/x — all of them have x = 2 as a fixed point, yet some loops race to 2, some crawl, and some explode and never get there at all. Same root, same starting guess, wildly different fates. So the real question is not 'is x = 2 a fixed point' but 'will THIS loop find it?'
Watching the loop on a cobweb
There is a beautiful picture that lets you SEE whether a loop converges, called a cobweb diagram. Draw the curve y = g(x) and the diagonal line y = x on the same axes. Their crossing is the fixed point, where g(x) equals x. Now trace one step: start at x_0 on the horizontal axis, go straight up to the curve to read off g(x_0) — that height is your next guess x_1 — then go straight across to the diagonal to bring that value back down onto the x-axis as the new input. Up to the curve, across to the line, up to the curve, across to the line: the path staircases or spirals, and the cobweb diagram makes the whole iteration visible at a glance.
Whether the cobweb winds INTO the crossing or spins AWAY from it depends entirely on how steep the curve g is where it meets the diagonal. If the curve is shallow there — flatter than the 45-degree diagonal — each step lands closer to the fixed point and the cobweb tightens into the corner. If the curve is steeper than the diagonal, each step overshoots a little more than the last and the cobweb flares outward, away from the very point you were chasing. The single number that captures 'steeper or shallower than the diagonal' is the slope of g at the fixed point, g'(x_star). That slope is the whole game.
The contraction condition
Let us turn the picture into a guarantee. Suppose that on some interval around the root, g never stretches distances by more than a fixed factor L below 1 — formally, |g(a) - g(b)| <= L |a - b| for all a, b in the interval, with L < 1. A map that shrinks every distance like this is called a contraction, and L is its contraction factor. The contraction mapping condition then promises three things at once: there is exactly one fixed point in the interval, the iteration converges to it from any start inside the interval, and it does so geometrically.
The reason is almost embarrassingly direct. Let x_star be the fixed point and e_n = x_n - x_star be the error at step n. Since g(x_star) = x_star, the error after one step is e_{n+1} = g(x_n) - g(x_star), and the contraction bound says this is at most L times |x_n - x_star| = |e_n|. So every step multiplies the error by at most L: after n steps, |e_n| <= L^n |e_0|. Because L < 1, the factor L^n marches to zero, dragging the error down with it. The loop cannot help but converge, no matter where in the interval you start.
How does L connect to the slope we saw on the cobweb? By the mean value theorem, if g is differentiable then the smallest L that works on an interval is the largest value of |g'(x)| there. So near a fixed point the local contraction factor is just |g'(x_star)|, and the condition |g'(x_star)| < 1 is exactly what the cobweb was showing us. That ties the two views together: the slope you eyeballed on the diagram IS the contraction factor that controls the error. This is the cleanest example of an order of convergence — here it is order one, which we explore next.
Linear convergence — and a tiny worked example
Because each step multiplies the error by roughly the constant factor L = |g'(x_star)|, fixed-point iteration converges linearly: the error shrinks by a steady proportion every step, and the number of correct digits grows by a fixed amount per step. The rate of convergence is that factor L. If L = 0.1 you gain one decimal digit per step — quick. If L = 0.9 you gain a digit only every 22 steps or so, because you need about 0.9^22 to drop one order of magnitude — painfully slow, even though it does eventually converge. Linear convergence is honest but humble; it is the floor that the faster methods in this rung will try to beat.
Solve x = cos(x) (i.e. find the root of x - cos(x) = 0) Here g(x) = cos(x), and g'(x) = -sin(x), so near the root |g'| is about 0.67 < 1 -> a contraction, alternating-sign errors. x_0 = 1.000000 x_1 = cos(1.000000) = 0.540302 x_2 = cos(0.540302) = 0.857553 x_3 = cos(0.857553) = 0.654290 x_4 = cos(0.654290) = 0.793480 ... x_20 ~ 0.739085 (true fixed point 0.7390851...) Errors flip sign each step (spiral) and shrink by ~0.67 per step: linear convergence, about one new digit every ~6 steps.
Contrast that with the bad rearrangements from earlier. For x^2 - x - 2 = 0 at the root x = 2, the form x = x^2 - 2 has g'(x) = 2x, so g'(2) = 4: the slope is far steeper than the diagonal, the cobweb flares outward, and the iteration diverges no matter how close you start. The form x = sqrt(x + 2) has g'(x) = 1/(2 sqrt(x+2)), so g'(2) = 0.25 < 1: a contraction, and it converges nicely. Identical equation, identical root — the ONLY difference is the slope of g at the fixed point. This is why choosing the rearrangement is the real skill of the method.
Stopping, honest limits, and where this leads
When do you stop? You cannot watch the true error e_n because you do not have x_star. The practical stopping criterion watches the step size instead: halt when consecutive iterates barely move, |x_{n+1} - x_n| below some tolerance, optionally combined with checking that |f(x_n)| is small. There is a subtlety, though. When L is close to 1, the step |x_{n+1} - x_n| can look tiny while the remaining error |x_n - x_star| is still about 1/(1 - L) times that step — so a near-stagnant loop can fool you into stopping early. The closer L is to 1, the more the step underestimates the true error.
So why bother with a method that is merely linear and not even guaranteed? Because the idea is the seed of everything that follows. The dream is to engineer a g whose slope at the root is not just below 1 but exactly ZERO — then linear convergence collapses and a faster regime takes over. That is precisely the trick behind Newton's method in the next guide: it is a fixed-point iteration with a cleverly built g for which g'(x_star) = 0, buying quadratic convergence that roughly doubles the correct digits each step. And far beyond root-finding, the contraction-and-fixed-point story reappears as the engine behind the iterative linear solvers, where the iteration matrix plays the role of g' and its spectral radius plays the role of L. Master this small loop and you have met the heartbeat of iterative computation.