These are the human proofs of Jenkins-Traub algorithm, at full length.
Correctness of the Jenkins-Traub algorithm full
This proof shows: correctness, termination, convergence-rate.
This page proves, in exact arithmetic, the key identity behind the method, the linear convergence of stage 2, and the order 1+φ of stage 3 near a root. It also proves termination of the reference code. The global statement that the full three-stage scheme converges is due to Jenkins and Traub (1970), and it is cited rather than reproved.
Setting
Let p be monic of degree n≥2 with p(0)=0 (zero roots are stripped at L1). Let its distinct roots be α1,…,αr, with multiplicities m1,…,mr. Put Pi(z)=p(z)/(z−αi). Each Pi is monic of degree n−1, and Pi(αj)=0 for j=i while Pi(αi)=0 when mi=1. For any polynomial H of degree at most n−1 and any s with p(s)=0, define
TsH(z)=z−s1(H(z)−p(s)H(s)p(z)).
The bracket vanishes at z=s, so TsH is a polynomial of degree at most n−1.
Lemma 1 (the weights)
TsPi=Pi/(αi−s). Hence, if H=∑iciPi, then TsH=∑iciPi/(αi−s).
Proof.Pi(z)−p(s)Pi(s)p(z)=p(z)(z−αi1−s−αi1)=p(z)(z−αi)(s−αi)s−z. Dividing by z−s gives Pi(z)/(αi−s). Linearity gives the second claim. □
Also p′(z)=∑imiPi(z), by logarithmic differentiation. So H(0)=p′/n has weights mi/n>0. After M steps with s=0 the weights are proportional to miαi−M, all nonzero, and normalising H (dividing by its leading coefficient ∑ici) only rescales them. In floating point, the normalisation keeps the numbers in range.
The estimate
For H=∑ciPi with C=∑ici=0, let Hˉ=H/C and t=s−p(s)/Hˉ(s). Since Pi(s)=p(s)/(s−αi),
t−s=−∑ici/(s−αi)C.(1)
If only c1=0, then t−s=α1−s, so t=α1 exactly. This is why the quotient P1 is the target of the iteration.
Theorem 1 (stage 2 converges linearly)
Fix s, and suppose that α1 is the unique root closest to s: ∣α1−s∣<∣αi−s∣ for i≥2. Let tλ be the estimate after λ fixed-shift steps. Then tλ→α1, and
∣tλ−α1∣=O(θλ),θ=i≥2max∣αi−s∣∣α1−s∣<1.
Proof. By Lemma 1, after λ steps ci=ci(0)(αi−s)−λ with ci(0)=0. The ratios ρi=ci/c1 satisfy ∣ρi∣=O(θλ). Put d=s−α1. Dividing the numerator and denominator of (1) by c1,
The numerator is O(θλ), and the denominator tends to 1. □
The test checks that the ratio of successive errors approaches θ on an example.
Theorem 2 (stage 3 has order 1+φ)
In stage 3, H(λ+1)=TsλH(λ) and sλ+1=sλ−p(sλ)/Hˉ(λ+1)(sλ). Let eλ=sλ−α1, and let ρλ=maxi≥2∣ci/c1∣ for the weights of H(λ). Let δ=mini≥2∣αi−α1∣. If ∣eλ∣≤δ/2 and ρλ is small enough, then
ρλ+1≤δ2ρλ∣eλ∣,∣eλ+1∣≤K∣eλ∣ρλ+1,
with a constant K depending on the roots and on r. Consequently, (eλ,ρλ)→0, and the order of eλ is (3+5)/2=1+φ.
Proof. By Lemma 1, ci(λ+1)/c1(λ+1)=(ci/c1)(α1−sλ)/(αi−sλ). Here ∣α1−sλ∣=∣eλ∣ and ∣αi−sλ∣≥δ−∣eλ∣≥δ/2, which gives the first bound. The second follows from the formula in the proof of Theorem 1, with d=eλ and the weights of H(λ+1). Its numerator is at most ∑i≥2∣ρi∣(∣d∣/(δ/2)+1)≤2rρλ+1, and its denominator is at least 1/2 once ρ is small. Taking logarithms, Eλ=−log∣eλ∣ and Rλ=−logρλ satisfy, up to additive constants,
Rλ+1≥Rλ+Eλ,Eλ+1≥Eλ+Rλ+1≥2Eλ+Rλ.
The matrix (2111) has dominant eigenvalue (3+5)/2≈2.618, so Eλ grows like (1+φ)λ. Once both quantities are small, the constants are absorbed and the iteration converges. □
Multiple roots fit the same framework. The expansion uses distinct roots only, the weights start at mi, and nothing in Theorems 1 and 2 requires m1=1. In floating point, however, p(s) near a root of multiplicity m is dominated by rounding error once ∣e∣≈u1/m, and the stopping rule accepts s at about that distance.
What is cited
Theorems 1 and 2 are local. The global theorem of Jenkins and Traub states that, if the root closest to the stage 2 shift is unique and stage 2 runs for enough steps, stage 3 converges to that root. The reference code takes stage 2 only until the weak test at L8 passes, so it relies on the fallback: a failed stage 3 returns to stage 2, and after L⋅attempt steps a new shift is tried. The bound β comes from the Cauchy bound applied to znp(1/z). Every root satisfies ∣α∣≥β, because for ∣z∣<β the term ∣an∣ exceeds ∑k<n∣ak∣∣z∣n−k.
Termination
Every step of stages 1, 2 and 3 increases the step counter. Stage 2 checks it against K before each step, and stage 3 receives the remaining budget and never exceeds 10 steps. A run of stage 3 that fails returns to stage 2. The loop over attempts is finite (≤ max_shifts attempts of at most L⋅attempt steps each). Each successful root reduces the degree by one, and the outer loop ends at degree at most 1. So the algorithm stops after at most K steps plus the bounded work of one stage 3 and one deflation, returning status done, failed or max-iter.