# Root Finding by Similarity and Analogy: A Bracketing Method with a Data-Selected Decision Layer V. Sitnikov ## Abstract We replace bisection's midpoint rule by a similarity rule — the step grows with the dissimilarity of $f(x)$ to 0 under a similarity $S$ — and derive its contraction factor in closed form. It fixes, before any benchmark, a base rule: with the tent similarity and a three-point divided-difference scale it is a Newton step of Muller's order 1.839, clipped to the bracket and projected onto a budget of twice bisection whose multiplier is its one numerical constant. On the 154 problems of Alefeld, Potra and Shi it is level with TOMS 748 and 1.5% behind Chandrupatla's method; on wide brackets it is clearly behind. The gap is a decision, when to give the model up, and we take it by analogy: at a flat root the dimensionless configuration of the last three points recurs under zoom, at a simple root it tends to a line, and the analogous pair gives the order that says whether and where to split. This decision layer — about ten discrete rules selected on two development sets — gives A′. On 240 problems fixed before its code was frozen it needs 3656 evaluations against 5717 for Chandrupatla, 5535 for ModAB and 4488 with Lagouanelle's multiplicity estimate in place of the analogy; the lead lies in multiple and fractional roots, present in two of six families. With the multiplicity known, the transformation $\operatorname{sign}(f)|f|^{1/m}$ is 2.4 to 6.8 times cheaper on multiple roots; A′ adds an estimate of the order, within a guarantee of twice bisection. --- ## 1. Introduction A bracketing root finder must decide, at every step, where inside the bracket to evaluate next. Bisection answers "in the middle", which is the correct answer when nothing is known. Every improvement since has answered "where a local model of $f$ says the root is": a secant in false position, an inverse quadratic in Brent [2], a cubic in TOMS 748 [1], an interpolate–truncate–project cycle in ITP [4], an Anderson–Björck step behind a linearity check in ModAB [10, 20]. Each of those answers carries constants: Illinois [7] halves the stale ordinate, Brent accepts an interpolation subject to three empirical inequalities, ITP is governed by $\kappa_1,\kappa_2,n_0$. This paper asks a different question. Suppose the only thing available is a *similarity function* — a map $S$ from an outcome to $[0,1]$, where 1 means "identical to what was wanted" and 0 means "not similar at all", in the sense used for parameter-free control in [6]. Can a root finder be built out of $S$ alone, and how does it compare with methods built out of polynomial models and tuned constants? The paper makes four claims, each measured. 1. A contraction law for the similarity step (§2) fixes a *base rule* — tent similarity, three-point scale, a projection safeguard — before any benchmark is consulted (§3); its order is Muller's. 2. Projecting the step onto the bisection budget, instead of replacing it, keeps the order and a worst case of twice bisection plus one step; the budget's multiplier is the base rule's one numerical constant, and a constant-free variant costs a measured price (§3.1, §5). 3. The base rule's gap on wide brackets is a decision — when to give the model up — and a similarity of the run to its own past takes it (§6). The resulting method, A′, is tested once on a corpus fixed before its code was frozen, against simpler detectors put in its place, and against the classical transformation with the multiplicity known in advance (§7). 4. Every table uses one criterion, a sign change within $10^{-6}$ of the answer, because the benchmarks' published roots score six problems unsolved for every method (§4, §A.5). The search that produced these results — readings of the similarity that did not pay, the decomposition of the wide-bracket gap, wall-clock time, and the rejected rules — is reported in Appendices A–C. The code, the corpora and the documents that recorded each test before its run are released (Appendix D and the availability statement). --- ## 2. The similarity step rule **Definition 1 (Similarity step).** Let $[a,b]$ bracket a root, $x$ be the current iterate and $x_\mathrm{far}$ the opposite end. Let $S:\mathbb{R}\to[0,1]$ with $S(0)=1$ be a similarity function and $\sigma>0$ a scale. The next iterate is $$x' \;=\; x \;+\; \bigl(1 - S(f(x)/\sigma)\bigr)\,(x_\mathrm{far} - x). \tag{1}$$ The rule is exactly the informal statement "step further when the outcome is dissimilar to the expectation, and less far when it is similar". Bisection is the degenerate member $S\equiv\tfrac12$: a similarity function that carries no information about $f$. ### 2.1 The two-point normalisation is false position The most obvious way to make (1) scale-free is to normalise the similarity by the two ends of the bracket, $S(a)=|f(b)|/(|f(a)|+|f(b)|)$ and $S(b)=1-S(a)$, and to place the next iterate at the similarity-weighted average of the ends. **Proposition 1.** For the ratio similarity $S(z)=1/(1+|z|)$ with $\sigma=|f(x_\mathrm{far})|$, equivalently for the endpoint weights above, $$S(a)\,a + S(b)\,b \;=\; \frac{a f(b) - b f(a)}{f(b)-f(a)}.$$ That is the false-position formula, and it is specific to that similarity: on $f=x^2-2$ over $[1,4]$, where false position gives 1.200000, $e^{-|z|}$ gives 1.206812, $1/(1+z^2)$ 1.015228, $1/\sqrt{1+z^2}$ 1.007624 and the truncated linear form 1.214286. Bracket-scaled similarity configurations take third, fourth and sixth place on Chandrupatla's set (Table 3), where false position solves 6 of 45. **Proposition 1'.** It is, however, specific to the *bracket ends* rather than to the ratio form. Take the truncated linear similarity $S(z)=\max(0,1-|z|)$ and the divided difference over the two ends, $\sigma=|f[a,b]|\cdot|b-a|=|f(b)-f(a)|=|f(a)|+|f(b)|$. Then $1-S=|f(a)|/(|f(a)|+|f(b)|)$, which is false position again, and the agreement is exact to the last bit. Together the two say that the boundary of novelty runs through the words *most recent* in the definition of $\hat f'$ in §3: a divided difference over the bracket ends is false position, the same difference over the most recent iterates is the secant. In our measurements plain false position solves 127 of the 154 Alefeld–Potra–Shi problems, against 154 for bisection. ### 2.2 The contraction law Write $e_n = x_n - r$ for the error, $D = x_\mathrm{far} - r$, and let $c$ be the slope of $1-S$ at the origin, $1-S(z) = c\,z + O(z^2)$. **Proposition 2 (Contraction law).** For a simple root and $e_n$ small, rule (1) satisfies $$e_{n+1} \;=\; e_n\left(1 - \frac{c\,|f'(r)|\,D}{\sigma}\right) + O(e_n^2), \qquad \text{rate} = \left|1 - \frac{c\,|f'(r)|\,D}{\sigma}\right|. \tag{2}$$ *Derivation.* $|f(x_n)| = |f'(r)|\,|e_n| + O(e_n^2)$, hence $1-S(f(x_n)/\sigma) = c\,|f'(r)|\,|e_n|/\sigma + O(e_n^2)$, and $x_\mathrm{far}-x_n = D - e_n$. Substituting into (1) and discarding second-order terms gives (2). $\square$ Table 1 checks (2) against measurement on $f(x)=x^2-2$ over $[0,2]$ with $\sigma=|f(0)|$, for which $|f'(r)|=2\sqrt2$, $D=2-\sqrt2$ and $\sigma=2$. **Table 1.** The contraction law against measurement, all rows at the *chosen* scale $\sigma=|f(x_0)|$. $c$ is the slope of $1-S$ at the origin and $c_2$ the coefficient of $z^2$ when $c=0$. | $S(z)$ | $c$ | predicted | measured | |---|---|---|---| | $1/(1+\lvert z\rvert)$ | 1 | rate 0.1716 | 0.1716 | | $e^{-\lvert z\rvert}$ | 1 | rate 0.1716 | 0.1716 | | $1/(1+z^2)$ | 0, $c_2=1$ | $n\,e_n\to0.8536$ | 0.8503 | | $e^{-z^2}$ | 0, $c_2=1$ | $n\,e_n\to0.8536$ | 0.8498 | | $1/\sqrt{1+z^2}$ | 0, $c_2=\tfrac12$ | $n\,e_n\to1.7071$ | 1.6988 | | $\max(0,1-\lvert z\rvert)$ | 1 | rate 0.1716 | fails: stays at $x_\mathrm{far}$ | A similarity with $c=0$ does not converge at a rate at all. Expanding $1-S=c_2z^2+O(z^4)$ in the same way as (2) gives $e_{n+1}=e_n-c_2|f'(r)|^2|D|e_n^2/\sigma^2+O(e_n^3)$, hence $$e_n \;\simeq\; \frac{\sigma^2}{c_2\,|f'(r)|^2\,|D|}\cdot\frac1n, \tag{2a}$$ sublinear rather than stagnant. Reporting a "measured rate" for these rows would report the value of $e_{n+1}/e_n$ at whatever $n$ the window happened to end — it creeps to 1 monotonically (0.925 at $n=10$, 0.991 at $n=100$, 0.9998 at $n=4000$) — so the prediction tested is the coefficient in (2a) instead. The last row fails at once, and it matters because that similarity is the one this paper proposes: at $x_0=0$, $z=-1$, so $S=0$, the step is the whole bracket and the iterate stays at $x_\mathrm{far}$ (error 0.5858 after one step and after two hundred). The failure belongs to the chosen scale, not to the similarity: under the derived scale of §3 the clip never engages on this problem, and the same function is the best of the nine (Table 4). **Corollary 1 (A chosen similarity is not enough).** For fixed $S$ and fixed $\sigma$ the rate in (2) depends on $|f'(r)|$, $D$ and $\sigma$, none of which is under the method's control. Convergence is at best linear and occurs only when the product lands in $(0,2)$. Empirically, with $\sigma$ taken as $|f|$ at the starting point, five to eight of the eight standard problems fail outright for the six similarity functions tested. Those eight, used throughout as a quick set and never as evidence on their own, are: $x^2-2$ on $[0,2]$; $\cos x-x$ on $[0,1]$; $e^x-2$ on $[0,2]$; $x^3-x-2$ on $[1,2]$; $\sin x-\tfrac12$ on $[0,1.5]$; $x^{10}-1$ on $[0,1.3]$, which stalls false position; $e^{-x}(x-1)$ on $[-1,40]$, whose right end is flat to $10^{-16}$; and $\arctan x$ on $[-1,3]$. **Corollary 2 (Missing the calibration in either direction costs).** The rate degrades as the product $c\,|f'(r)|\,|D|/\sigma$ departs from 1, upwards or downwards. We claim no symmetry between the two directions, and the measurements do not support one: similarities with unbounded slope — $1-\sqrt{|z|}$ has $c\approx3.2\cdot10^{3}$ at the resolution used, $1-|z|^{1/3}$ has $c\approx4.6\cdot10^{4}$ — fail on five and six of the eight problems with a chosen scale, yet over the full benchmark (best over scales, Table 4) they finish at 9411 and 10874, ahead of all three $c=0$ similarities at 13187, 13990 and 15272. Overshooting is the milder failure. **Corollary 3 (The scale must come from the data).** The rate is zero exactly when $c\,|f'(r)|\,D/\sigma = 1$, i.e. $\sigma = c\,|f'(r)|\,D$. Substituting this $\sigma$ back into (1) with $c=1$ gives $x' - x = |f(x)|/|f'|$, the Newton step. The similarity rule is therefore superlinear precisely when its scale is the *local scale of the value axis*, and that scale is not available a priori: it must be read off the evaluations. --- ## 3. The method Corollaries 1–3 fix every choice before any benchmark is consulted; Section 5.2 tests the prediction against the full grid. One number in the safeguard is not fixed by them, and §3.1 declares it. **Similarity: any with $c\neq0$.** The law makes the shape of $S$ almost irrelevant and its slope at the origin decisive. We take the plainest member, the **truncated linear** or tent form $S(z)=\max(0,1-|z|)$. It is not the ratio form $1/(1+|z|)$ of Proposition 1. **Scale: the finest data-derived one.** We set $\sigma = |\hat f'|\cdot|x_\mathrm{far}-x|$ with $\hat f'$ a divided difference of the **most recent evaluations** — not of the bracket ends, which by Proposition 1' would give false position. A divided difference is a computation, not a fitted coefficient: nothing is chosen, regressed or tuned. The two-point difference has slope error $O(h)$ and gives the secant order $\varphi\approx1.618$; the three-point difference — the derivative at $x_n$ of the parabola through the last three evaluations, $\hat f' = f[x_{n-1},x_n] + f[x_{n-2},x_{n-1},x_n](x_n-x_{n-1})$ — has error $\tfrac16 f'''(\eta)\,(x_n-x_{n-1})(x_n-x_{n-2})$, that is $O(e_{n-1}e_{n-2})$. The Newton step with that derivative satisfies $e_{n+1}=\tfrac{f''}{2f'}e_n^2+\tfrac{f'''}{6f'}\,e_n e_{n-1}e_{n-2}+\dots$; the second term dominates, and the order is the root of $p^3=p^2+p+1$, $p\approx1.839$ — **Muller's order**, as it should be, since the step uses the same parabola as Muller's method, through its derivative rather than its root. Only where the parabola is exact ($f'''=0$) does the order rise to Newton's 2. Carried to $10^{-2900}$ in 3000-digit arithmetic (`order_high_precision.py`), the computational order per step settles at 1.840 on $\cos x-x$, $e^x-2$, $x^3-x-2$ and $\sin x-\tfrac12$ and at 2.000 on $x^2-2$; the two-point scale settles at 1.618. In double precision a run takes three or four superlinear steps before it reaches the tolerance, too few to tell 1.84 from 2, and we report no order measured there. **What the rule reduces to.** With $S(z)=\max(0,1-|z|)$ one has $1-S=\min(1,|z|)$, and (1) becomes $$x' \;=\; x + \operatorname{sign}(x_\mathrm{far}-x)\cdot\min\!\Bigl(\frac{|f(x)|}{|\hat f'|},\;|x_\mathrm{far}-x|\Bigr), \tag{4}$$ a Newton step with a three-point divided-difference derivative, clipped to the bracket and then projected as in §3.1. That the tent turns the similarity step into Newton's is a property of the chosen similarity, and which $S$ stands in the step is measured rather than assumed: in the proposed method, replacing the tent by any other function costs 19% to 425% (Table 7). The base rule is therefore not a new family of methods; what is ours is a derivation that fixes every choice before any benchmark is consulted, and a safeguard of ITP's projection type with ITP's truncation stage — and all three of its constants — removed. The proposed method builds on it in Section 6. **Algorithm.** Given $[a,b]$ with $f(a)f(b)<0$ and tolerance $\varepsilon_x$: ``` evaluate fa = f(a), fb = f(b) A, B <- a, b the proven bracket x <- the endpoint with the smaller |f|; xp <- the other; xp2 <- none n_max <- 2 * ceil(log2(|b-a| / xtol)); allow <- 2^n_max * xtol/2 while |B - A| > xtol: far <- the end of [A,B] further from x f' <- derivative at x of the parabola through (x,xp,xp2) (two-point difference while xp2 does not yet exist) sigma <- |f'| * |far - x| if sigma is 0 or not finite: xn <- midpoint(A,B) else: xn <- x + min(1, |f(x)|/sigma) * (far - x) # the step, eq (4) lo, hi <- min(A,B), max(A,B) xn <- clamp(xn, hi - allow, lo + allow) # projection, eq (3) if xn outside (A,B) or already evaluated: xn <- midpoint(A,B) (if the midpoint too was evaluated: return it) evaluate fn = f(xn); allow <- allow / 2 xp2, xp, x <- xp, x, xn update the bracket: whichever of A,B keeps the sign change return midpoint(A,B) ``` Every quantity in it is either an evaluation of $f$, a divided difference of evaluations, or the halving that defines bisection — with one exception, the factor 2 in `n_max`, which §3.1 declares as the base rule's one numerical constant. The constant-free variant of §3.1 replaces the two `allow` lines by the earned credit of (3'). ### 3.1 The safeguard: project, do not replace An interpolation-only rule has no worst-case bound. The obvious safeguards *replace* the computed step with a midpoint whenever some progress test fails, and all of them are ruinous here, for a reason specific to a fast method: a step that collapses the *error* need not halve the *bracket*, so a bracket-based test fires on exactly the steps that were best. With the three-point scale, replacing on that test makes the convergence linear and takes the Alefeld–Potra–Shi total from 2634 to 7068 — nearly the cost of bisection (7338). The remedy is to keep as much of the computed step as the budget allows. Let $n_{\max}=2\lceil\log_2(w_0/\varepsilon_x)\rceil$ be twice the bisection step count for the initial width $w_0$ and $x$-tolerance $\varepsilon_x$, and let $\epsilon=\varepsilon_x/2$. At step $j$, with the bracket $[\ell,h]$, define the allowance and the projection $$\alpha_j = 2^{\,n_{\max}-j}\epsilon, \qquad x \;=\; \operatorname{clamp}\bigl(x_\mathrm{sim},\; h-\alpha_j,\; \ell+\alpha_j\bigr). \tag{3}$$ The next bracket is at most $\max(x-\ell,\,h-x)$, so (3) gives $w_{j+1}\le\alpha_j$ directly, and induction bounds the run by $n_{\max}$ steps in exact arithmetic. In floating point the bracket can land exactly on the boundary, and the termination test then asks for one more; the guarantee stated and verified is therefore $2\lceil\log_2(w_0/\varepsilon_x)\rceil+3$ evaluations. **The multiplier is the base rule's one numerical constant**, and it is not neutral (`measure_budget_factor.py`, Linux): **Table 1a.** The scheduled projection at budget multiplier $c$, i.e. $n_{\max}=\lceil c\cdot\log_2(w_0/\varepsilon_x)\rceil$. Total evaluations, failures charged. | $c$ | APS-154 | CHA-45 | both | |---|---|---|---| | 1 | 4625 | 2039 | 6664 | | 1.25 | 2626 | 1822 | 4448 | | 1.5 | 2636 | 1991 | 4627 | | 2 | 2634 | 2357 | 4991 | | 3 | 2634 | 2936 | 5570 | | 4 | 2634 | 3229 | 5863 | On the canonical set the projection binds on one problem only once $c\ge1.25$ — `aps.13.00`, whose $f$ underflows to zero around the root (20, 30 and 28 evaluations at $c=1.25$, 1.5 and 2). On the wide-bracket set the cost rises monotonically with $c$ from 1.25 on, and 2 is not the best value; zero slack ($c=1$) is not degenerate either (4625 and 2039, against bisection's 7338 and 2136). No member of the family is singled out by the bound: the multiplier is a free constant. **The budget earned rather than scheduled: a constant-free variant.** The constant can be removed. Let $s_j=\log_2(w_j/w_{j+1})$ be the shrink a step delivers in bits — bisection delivers exactly 1 — and keep a credit $$C \leftarrow \max(0,\;C+s_j-1),\qquad \alpha_j = w_j\,2^{\,C-1},\qquad x=\operatorname{clamp}\bigl(x_\mathrm{sim},\,h-\alpha_j,\,\ell+\alpha_j\bigr), \tag{3'}$$ leaving the step alone while $C\ge1$. A step may under-deliver only by what earlier steps banked, and since $C$ never goes negative the shrinks over $j$ steps sum to at least $j-C_0$: the run costs at most bisection plus $\lceil C_0\rceil$ steps. The endowment $C_0$ is therefore the promise, not a setting. $C_0=0$ makes the allowance exactly half the bracket on the first step, which forces the midpoint and makes the method bisection; every $C_0\in(0,1]$ promises the same single extra step; and among those, 1 is the most permissive and — measured — the cheapest: **Table 1b.** The earned projection at endowment $C_0$. Total evaluations, failures charged. | $C_0$ | promise | APS-154 | CHA-45 | both | |---|---|---|---|---| | 0.1 | bisection + 1 step | 5150 | 2097 | 7247 | | 0.5 | bisection + 1 step | 4462 | 2037 | 6499 | | **1** | **bisection + 1 step** | **3377** | **2073** | **5450** | | 2 | bisection + 2 steps | 3502 | 1757 | 5259 | | 5 | bisection + 5 steps | 2819 | 1666 | 4485 | Within one promise the cheapest endowment is determined, so the constant-free variant is the earned projection with $C_0=1$; its guarantee, $\lceil\log_2(w_0/\varepsilon_x)\rceil+4$ evaluations, is verified on all 199 problems. We nonetheless propose the scheduled projection with $c=2$, fixed before any benchmark was consulted: it is 743 evaluations cheaper on the canonical set (2634 against 3377), the earned variant is cheaper on the wide-bracket set (2073 against 2357) — one declared numerical constant and the better canonical result, or none, a tighter bound and the better wide-bracket result. Three remarks apply to both forms. - **Guaranteed bounds of this kind are classical.** Bus and Dekker [21] gave bracketing methods whose worst case is four to five times bisection; the scheduled projection guarantees twice bisection plus one step, the earned one bisection plus one step. - **This is ITP's projection stage without ITP's truncation stage.** All three of ITP's constants live in the truncation, whose purpose is to repair regula falsi; the similarity step needs no repair, so the truncation and every constant with it are dropped. - **Writing the clamp in the form (3) rather than as a radius $\alpha_j-w_j/2$ about the midpoint is not cosmetic.** That radius is a difference of two nearly equal numbers; the cancellation made the computed radius too large by a relative $8.9\cdot10^{-5}$, which broke the invariant on eleven Chandrupatla problems. --- ## 4. Experimental protocol **Problem sets.** The 154 problems of Alefeld, Potra and Shi [1] and the 45 of Chandrupatla [3], taken programmatically from SciPy's `scipy.optimize._tstutils` so that no bracket or root is transcribed by hand. **Cost model.** Evaluations of $f$. A run counts as solved when it reports convergence and $f$ changes sign within $10^{-6}$ of the returned point, or vanishes there — the bracketing notion of a root, the same criterion on every corpus of this paper; $x$-tolerance $10^{-12}$; budget 200 evaluations. Every method, ours included, stops when its bracket is no wider than $\varepsilon_x$ or when it evaluates an exact zero of the function it works on; none stops on a small $|f|$. Scoring against the published root instead, as the benchmarks' harness does, charges every method the full budget on six problems where $f$ vanishes identically around the root in floating point (§A.5). Head-to-head counts (wins/ties/losses) are taken over every problem of a set with the same charging as the totals. *Failures are charged the full budget*, so no method can buy a low total by giving up early, and totals are reported over all problems rather than over the subset a method happened to solve. Rankings are by failures first, then by total. **Competitors.** Where SciPy ships the method, the competitor is the library — Chandrupatla is `scipy.optimize.elementwise.find_root`, Brent `brentq`, TOMS 748 `toms748` — run with the stopping rule of every method (a bracket no wider than $\varepsilon_x$, the relative term at machine precision, no stopping on $|f|$) and counted by the same wrapper around $f$. ITP, which has no library implementation, is ours, run with $\epsilon=\varepsilon_x/2$ because it terminates on $b-a\le2\epsilon$, checked against its own theorem ($n_{1/2}+n_0$ iterations at most, on all 154 problems for $n_0\in\{0,1,2,5\}$), and reported both at the authors' constants and as a *per-problem oracle* over a $(\kappa_1,n_0)$ grid — not an achievable method, included so that it cannot be said to have been handicapped. Bisection and the false-position family are ours. **Reproducibility.** All numbers come from a single Linux run. The test functions call `libm`, whose last digit differs between platforms; the same SciPy version scores 2635 for TOMS 748 on Windows and 2636 on Linux for the same set. Every number stated in this paper is checked against the run data by a script that is part of the test suite. --- ## 5. Results The grid is nine similarity functions × four scales × seven safeguards = 252 configurations, plus twelve baselines: 264 in all. The base rule of Section 3 — tent similarity, three-point scale, projection safeguard with its multiplier declared — is one entry of that grid, fixed by the theory rather than chosen from the ranking; the constant-free earned variant of §3.1 is shown beside it. Chandrupatla's own method and Dekker's are among the baselines. **Table 2.** Alefeld–Potra–Shi, 154 problems, out of 264 configurations. Places by failures first, then total. | # | configuration | tuned | solved | total evals | $>2\times$ | |---|---|---|---|---|---| | 1 | Chandrupatla | no | 154/154 | 2595 | 0 | | 2 | the same rule with no safeguard at all | no | 154/154 | 2634 | 0 | | **3** | **base rule: tent, 3-point, projection ($c=2$)** | **no** | 154/154 | **2634** | 0 | | 4 | TOMS 748 | yes | 154/154 | 2636 | 0 | | 5 | Brent | yes | 154/154 | 2707 | 0 | | 11 | ITP, per-problem oracle | yes | 154/154 | 3068 | 0 | | 15 | Ridders [5] | no | 154/154 | 3124 | 0 | | 25 | constant-free variant: earned projection | no | 154/154 | 3377 | 0 | | 29 | ITP, recommended constants | yes | 154/154 | 3767 | 0 | | 73 | bisection | no | 154/154 | 7338 | 0 | | 232 | Dekker | no | 153/154 | 3158 | 0 | | 237 | Illinois [7] | yes | 153/154 | 7045 | 0 | | 244 | false position | no | 127/154 | 10560 | — | The base rule and the same rule without any safeguard tie at 2634: the projection never binds on this set. By total, Chandrupatla's method is first with 2595, 1.5% fewer; the base rule and TOMS 748 are level (2634 against 2636). Problem by problem the base rule wins against Chandrupatla 87/24/43 (wins/ties/losses; exact two-sided sign test $p=1.4\cdot10^{-4}$), against TOMS 748 86/16/52, Brent 102/11/41, ITP at its recommended constants 132/3/19, the per-problem ITP oracle 121/4/29, and bisection 152/1/1. It trails Chandrupatla in total because its losses are the larger ones; by function family, the unit in which these problems are independent (§7), the comparison is 6/1/8 of 15 families, a tie. The constant-free variant goes 79/3/72 against Chandrupatla ($p=0.63$), 78/9/67 against TOMS 748 and 79/5/70 against Brent. Dekker, Illinois and false position fail `aps.13.00` under either criterion and so keep their totals: they spend the whole budget without converging, Dekker and Illinois stalled on one side of the zero where $|f|<10^{-62}$ but $f$ does not change sign within $10^{-6}$. **Table 3.** Chandrupatla, 45 problems, brackets up to $10^{12}$ wide, out of 264 configurations. | # | configuration | tuned | solved | total evals | $>2\times$ | |---|---|---|---|---|---| | 1 | Chandrupatla | no | 45/45 | 1505 | 0 | | 2 | ITP, per-problem oracle | yes | 45/45 | 1675 | 0 | | 3 | similarity, $e^{-\lvert z\rvert}$, bracket scale, both guards | no | 45/45 | 1778 | 0 | | 4 | similarity, $e^{-\lvert z\rvert}$, bracket scale, bracket guard | no | 45/45 | 1848 | 0 | | 5 | ITP, recommended constants | yes | 45/45 | 1946 | 0 | | 6 | similarity, $e^{-\lvert z\rvert}$, bracket scale, earned projection | no | 45/45 | 1952 | 0 | | 9 | constant-free variant: earned projection | no | 45/45 | 2073 | 0 | | 15 | bisection | no | 45/45 | 2136 | 0 | | **49** | **base rule: tent, 3-point, projection ($c=2$)** | **no** | 45/45 | **2357** | 0 | | 158 | TOMS 748 | yes | 45/45 | 3088 | 15 | | 227 | Brent | yes | 43/45 | 3238 | 18 | | 229 | the same rule with no safeguard at all | no | 39/45 | 3391 | 10 | Here Chandrupatla's method is genuinely the stronger: it beats the base rule 29 problems to 11 ($p=0.006$) and by 1505 against 2357 in total. The base rule beats Brent 34/4/7 and TOMS 748 33/1/11 — which exceed $2\times$ bisection, a bound they do not promise, on 18 and 15 problems — and loses to ITP 18/1/26 and to the ITP oracle 16/1/28. The wide-bracket set is where the multiplier matters (Table 1a) and where the constant-free variant is the cheaper form, 2073 against 2357. Over both sets the base rule needs 4991 and the constant-free variant 5450, against 4100 for Chandrupatla, 4743 for the ITP oracle, 5724 for TOMS 748 and 5945 for Brent. ### 5.1 What the guarantee costs Against the same rule with no safeguard (Tables 2 and 3), the projection costs nothing on the canonical set and on the wide-bracket set solves six more problems for 30% fewer evaluations (2357 against 3391; unguarded, 10 runs break the bound). The earned projection, promising bisection plus one step, pays 743 evaluations (28%) on the canonical set and is the cheapest of the three on the wide-bracket set. That is the point of projecting rather than replacing: the two safeguards that replace cost 7068 and 7046 on Alefeld–Potra–Shi, against 2634. ### 5.2 The law across the whole grid Corollaries 1–3 predict that the similarities with $c=1$ come before those with $c=0$ under a data-derived scale; they say nothing about the order within a group, nor about the functions with unbounded slope. For every data-derived scale the three similarities with $c=1$ occupy the top three places of Table 4 and the three with $c=0$ the bottom three (that $c=0$ is slow is the unsurprising half: a step proportional to $z^2$ is damped quadratically). With the chosen scale the two groups are indistinguishable (14983 against 14228), as they should be. **Table 4.** Mean total evaluations over both sets, step guard, grouped by the slope $c$ of $1-S$ at the origin. | scale | $c=1$ (linear approach) | $c=0$ (quadratic approach) | |---|---|---| | 3-point derived | **5764** | 21200 | | 2-point derived | 5854 | 21089 | | bracket | 9149 | 18015 | | start (chosen) | 14983 | 14228 | Ranked individually and best over scales, the similarities come out $1-|z|$ (5422), $e^{-|z|}$ (5772), $1/(1+|z|)$ (5993), $(1+|z|)^{-2}$ (8455), $1-\sqrt{|z|}$ (9411), $1-|z|^{1/3}$ (10874), $e^{-z^2}$ (13187), $1/(1+z^2)$ (13990), $1/\sqrt{1+z^2}$ (15272); the scales come out 3-point (5422), 2-point (5564), bracket (7972), start (13423). The group order and the order of the scales were predicted before the grid was run; the order inside each group is measured. --- ## 6. The flat regime, recognised by analogy The base rule's gap on wide brackets is a decision, *when to give the model up* (§A.6): on the pure powers `fun3`–`fun6` the right move is to halve, Chandrupatla's method halves on up to all of its steps, and no reading of a single state measured takes that decision correctly. This section takes it by a similarity of the run to *its own past* — an analogy in Pólya's sense [8], two situations agreeing in more than one relation. Every rule below was recorded, with its criteria and stop rule, before its code and run (Appendix D); the rejected ones are in Appendix C. ### 6.1 The flag: a promise that was not kept A tangent step on an approach of local order $m$ lands at $e(1-1/m)$ and leaves the residual $r=|f_\text{new}/f_\text{old}|=(1-1/m)^m$ on the same side of the root. It beats a halving exactly when $|1-1/m|<\tfrac12$, that is for $\tfrac23\tfrac12$. Three choices are declared rather than derived: the multiplier $c$ of the projection (§3.1), the Euclidean geometry of the $(\xi,\varphi)$ plane, and the pattern test of the step lengthening (lags from 2 to half the history, threshold $\tfrac12$). The projection carries the guarantee, $2\lceil\log_2(w_0/\varepsilon_x)\rceil+3$ evaluations; it is verified with no violation on every corpus of this paper and under every safeguard of the grid. Counting numerical constants does not measure the method's freedom, however. Beyond these numbers A′ is a decision layer of about ten discrete rules — the flag, the analogy and its memory, the entry, the exit, the overshoot branch, the split, the step pattern, the half, the contradiction, the tolerance step — chosen on the two development sets among the many candidates of Appendix C. That selection is why the method was tested once on a corpus fixed before its code was frozen, and against simpler rules put in its place (§7). Algorithm 2 is the complete method; `simroot/pure.py` and the compiled `simbracket` implement exactly this and agree bit for bit. The nearest-configuration search runs over the run's memory: $O(n)$ per step, $O(n^2)$ per run of $n$ evaluations ($n\le200$ here), arithmetic that matters only when $f$ is cheap (Appendix B). **Algorithm 2 (A′).** Notation of Algorithm 1; $S(z)=\max(0,1-|z|)$. ``` state: bracket [A,B], FA, FB; points x, xp, xp2; values fx, fp, fp2 memory: configs (configurations), moves (displacements) flags: last_model, in_regime, analogy_seen (with order m_a), shallow_seen (with order m_s) initialise as Algorithm 1; allow <- 2^n_max * xtol/2 while |B - A| > xtol: far <- end of [A,B] further from x; mid <- (A+B)/2; model <- false f' <- derivative at x of the parabola through (x, xp, xp2) sigma <- |f'| * |far - x| if sigma is 0 or not finite: xn <- mid else: z <- |fx| / sigma # the flat regime (6.1-6.3) c <- (xi, phi, |x-xp|, |fx-fp|), last three points, if defined # unkept promise, and unkept promise with a crossing flag <- not in_regime and last_model and fx/fp >= 1/4 flag_over <- not in_regime and last_model and fx/fp <= -1/4 # order (6) of the analogous pair. q <- the configuration in # configs nearest to c (Euclidean in (xi, phi)); no m if c or # configs is empty or q is not nearer than the line phi = xi. # L_x <- |x-xp| / q.dx, L_f <- |fx-fp| / q.df # m <- inf if L_f < 1 <= L_x (translation), else ln L_f / ln L_x m <- order of the analogous pair if m >= 2: analogy_seen <- true; m_a <- m if 0 < m <= 2/3: shallow_seen <- true; m_s <- m if flag and analogy_seen: in_regime <- true elif flag_over and shallow_seen: in_regime <- true; m_a <- m_s append c to configs if in_regime: xn <- split point (7) with m = m_a elif x != xp and sign((fx-fp)/(x-xp)) != sign((FB-FA)/(B-A)): xn <- mid elif S(z) >= 1/2 and |f(far)| < |fx|: xn <- mid else: step <- (1 - S(z)) * (far - x) # eq. (4) append x - xp to moves # step pattern: q_j <- |d_j|/|d_(j-1)| over the # successive nonzero moves d (k ratios); # rho(u,v) <- min(u,v)/max(u,v); repeats iff # max_{p=2..floor(k/2)} mean_j rho(q_j, q_(j-p)) > 1/2 if repeats and step, x - xp point the same way: s <- min(|step|,|x-xp|) / max(|step|,|x-xp|) step <- step / (1 - s), at most |far - x| long if |step| < xtol/2 and last_model and |fx/fp| < 1/4: step <- sign(far - x) * xtol/2 # tolerance step xn <- x + step; model <- true lo, hi <- min(A,B), max(A,B) xn <- clamp(xn, hi - allow, lo + allow) # projection (3) if xn outside (A,B) or xn in {x, xp}: xn <- mid; if mid in {x, xp}: return mid last_model <- model and xn is the model's own point fn <- f(xn) if in_regime: # exit t <- (xn - A)/(B - A) if |fn - (FA(1-t) + FB t)| < |fn|: in_regime <- false; analogy_seen <- false allow <- allow/2; (xp2, xp, x) <- (xp, x, xn) keep the sign change in [A,B] return midpoint(A,B) ``` **Table 5.** A′ on the two sets of §4 (failures charged 200). A′'s wins/ties/losses against each rival over all problems of the set, exact two-sided sign test. | | APS-154 | CHA-45 | both | A′ per problem, APS | A′ per problem, CHA | |---|---|---|---|---|---| | **A′ (proposed)** | **2259** | **1074** | **3333** | — | — | | A′, earned budget (no free constant) | 3417 | 1852 | 5269 | — | — | | base rule (§3) | 2634 | 2357 | 4991 | — | — | | Chandrupatla | 2595 | 1505 | 4100 | 103/20/31, $p=3\cdot10^{-10}$ | 31/4/10, $p=0.001$ | | TOMS 748 | 2636 | 3088 | 5724 | 127/6/21 | 42/2/1 | | Brent | 2707 | 3238 | 5945 | 118/17/19 | 39/3/3 | | ITP, per-problem oracle | 3068 | 1675 | 4743 | 126/7/21 | 35/1/9 | | ModAB [10, 20] | 2726 | 1681 | 4407 | 118/10/26 | 34/4/7 | A′ is 12.9% below Chandrupatla on the canonical set and 28.6% below on the wide-bracket set, and wins more problems than it loses against every rival on both. By function family, the unit in which these problems are independent (§7), it is ahead of Chandrupatla on 8 of the 15 canonical families (6 behind, one level) and on 7 of the 9 wide-bracket families — too few families for either count to be significant ($p=0.79$, $0.18$). The two it is behind on are `fun7`, 69 against 64, and `fun9`, 65 against 55. **Table 6.** Leave-one-out ablation of A′ on all six corpora of §7 (uniform criterion, a sign change within $10^{-6}$). Δ = total without the component − total with it; positive means the component earns its place. | component removed | APS | CHA | new-1 | Roots.jl | applied | fourth | sum | |---|---|---|---|---|---|---|---| | the whole regime | −7 | +1013 | +1660 | +324 | +77 | +2269 | **+5336** | | the split (7) (midpoint instead) | −5 | +479 | +667 | +272 | +30 | +1672 | **+3115** | | overshoot branch | −6 | 0 | −7 | +16 | +63 | +893 | +959 | | tolerance step (borrowed) | +130 | +35 | +97 | +78 | +135 | −2 | +473 | | the half the step promises | +249 | +65 | +82 | −16 | −5 | +1 | +376 | | translation limit | +31 | +143 | +100 | −21 | −2 | +87 | +338 | | repeated step pattern | −22 | −6 | +123 | −30 | −10 | +34 | +89 | | sign contradiction | +11 | −12 | +29 | 0 | +1 | −1 | +28 | Every component is positive in sum; the regime and the split carry the method. The step pattern (earns on two corpora of six) and the sign contradiction (+28 over 855 problems) are marginal — together under one per cent, 117 of 13032 evaluations — and are kept because the rule recorded in advance removes only a component that earns nowhere. **Table 7.** The similarity in the step of A′: the same method with each of the nine similarity functions of §5.2 in place of the tent, everything else unchanged. Totals on the two sets of §4 and over the six corpora of §7; the guarantee holds with every function. | $S$ in the step | APS + CHA | six corpora (855) | |---|---|---| | **tent $1-|z|$ (A′)** | **3333** | **13032** | | $e^{-|z|}$ | 3965 | 14142 | | $1/(1+|z|)$ | 4424 | 14843 | | $(1+|z|)^{-2}$ | 7249 | 28500 | | $1-\sqrt{|z|}$ | 11613 | 45552 | | $1-|z|^{1/3}$ | 16094 | 63031 | | $e^{-z^2}$ | 17429 | 67701 | | $1/(1+z^2)$ | 17452 | 67394 | | $1/\sqrt{1+z^2}$ | 17487 | 67854 | The nearest other function costs 19% more on the two sets and 9% more over the six corpora, and the functions that approach 1 quadratically cost five times more; the three functions with a linear approach come first and the three with a quadratic approach last, as the contraction law of §2.2 predicts. What this measures should be said plainly: with the tent the step is the undamped Newton step clipped to the bracket, and the other functions damp it, so the table shows that the undamped step is the better one — expected, and evidence for the choice of $S$ within the rule rather than for the similarity framing as such. ### 6.6 What is known, and what is new Several mechanisms of A′ coincide with classical ones, reached from similarity and analogy and recognised afterwards: | in A′ | classical counterpart | |---|---| | the three-point order estimate of §A.3 | Lagouanelle's multiplicity estimate $m=f'^2/(f'^2-ff'')$ [13] | | the contraction $e(1-1/m)$ behind the flag of §6.1 | multiplicity estimates from successive Newton iterates [14, 15] | | the order (6) of an analogous pair | the log–log slope of a power law; the (approximate) computational order of convergence [18, 19] | | the split (7) | false position on $\operatorname{sign}(f)|f|^{1/m}$ [16, 17]; inside a bracket, with the multiplicity given, the SFRFm method of [22] | | the dimensionless configuration $(\xi,\varphi)$ of §6.2 | the ratios of Chandrupatla's acceptance band [3]; every scaled regula falsi written in two dimensionless parameters [22] | | the half the step promises | a relative of Brent's acceptance condition [2] | | the tolerance step | Dekker [9], Brent [2] — borrowed and named as such | | the exit judgment of §6.2 (the value at a split against the line) | ModAB's linearity check at the midpoint [10, 20], $|y_m-y_3|\min(\xi,1-\xi)$ ("defect"); and refuse when the configuration's similarity to linear falls below the iterate's similarity to the root, $S(|\varphi-\xi|)1$ on 27.9% of steps with excursions to $m=34.8$, against 35.8% on the flat families. 27.9 against 35.8 is no separation. A cruder variant, correcting by the fraction of its own promise the previous step kept, fails everything: the convergence becomes sublinear and the standard problems double to 161. 6. **The harness scores one canonical problem unsolved for every method**, `aps.13.00`, $f(x)=x e^{-1/x^2}$, all of whose derivatives vanish at the root and which underflows to exactly zero throughout $|x|<0.086$. Every method returns a point where $f(x)=0$ exactly — a genuine root — which the harness scores as a failure because it lies more than $10^{-6}$ from the declared root. With the five `fun7` problems of §A.5 it is why this paper scores by a sign change. 7. **The symmetric ratio similarity degenerates.** For $S(x,y)=\min(|x|,|y|)/\max(|x|,|y|)$ with $y$ the target 0, $S\equiv0$; the only usable reading is $1-|f|/\sigma$, which saturates and stagnates (Table 1, last row). 8. **Placement beats form, and the wrong placement is expensive.** The same "refuse before the step" idea as reading (1) of §A.2, with refusal decided by *promised bracket progress* instead of by the shape of the model, costs 4258 on the canonical set against 2337 — a difference of 1921 evaluations for one choice of criterion. A secant step routinely collapses the error while barely moving the proven bracket, so bracket progress rejects steps that were excellent; this is the same mechanism that makes the bracket guard of §3.1 cost 7068. 9. **Making the scale independent of the bracket does not help either.** The natural objection to the derived scale is that it defeats the very principle of a similarity step: with $\sigma=|\hat f'|D$ the normalised residual is $|f|/(|\hat f'|D)$, which on the $2\times10^4$-wide bracket of $x^3-2x-5$ at $x=10^4$ equals 0.167, so $S=0.833$ — "similar" — and the step is small although the root is some five thousand step-lengths away. The similarity is reading what fraction of the *bracket* the Newton step is, not how far the iterate is from the root. Selecting the scale between the two quantities already computed, $\sigma=\min(|\hat f'|D,\max(|f(A)|,|f(B)|))$ — no new constant, a minimum over what is in hand — does give a full-bracket step far away and Newton's step near the root, and on eight hand-picked wide problems it improves 403 evaluations to 390. Over the whole grid it is worse on both sets: its best cell is 3101 on the canonical set against 2539 for the best uncapped cell of the same grid, and 1766 on the wide-bracket set against 1752. 10. **Reading the similarity at the measured order does not cure false position.** Since false position's stall is a similarity read at order one (§A.3), the obvious hope is that reading it at the measured order is the parameter-free version of the classical fix. It is not. Unguarded, the correction takes the far-end reading from 127/154 and 10676 to 129/154 and 9855 — two problems and eight per cent — where Illinois [7], at the price of one constant (halve the stale ordinate), reaches 153/154 and 7045. A sixth of the gap is not the gap. The correction is real and it is in the right place; it is simply much smaller than a constant that was chosen for exactly this failure. *Our* 10676 and the 10560 of Table 2 are not the same algorithm — our iterate starts at the midpoint of the bracket, plain false position at an end — and the two must not be differenced. 11. **A logarithmic change of variable does not buy the wide brackets.** Working in $u=\operatorname{sign}(x-c)\log(1+|x-c|/\varepsilon_x)$ makes the step multiplicative, which looked like the right diagnosis of the flat families — for the same similarity, scale and safeguard ($(1+|z|)^{-2}$, two-point, *safe*) the wide-bracket set improves from 2759 to 2598 — but the canonical set gets worse, 5635 to 6749, against the 2634 of the base rule. A march needs a *ratio* of distances while an identity on narrow brackets needs an *absolute* unit, and no parameter-free unit provides both. §A.6 shows the diagnosis itself was wrong: on the flat families the right move is to halve, not to march. 12. **Reading the unkept promise one step at a time does not pay.** The flag of §6.1 sees the flat regime, but a halving in place of each flagged step takes the canonical set from 2634 to 2839 and the wide-bracket set only from 2357 to 2243: a simple root far from convergence breaks its promises too. Requiring the promise to fail twice in a row keeps the canonical set (2613) but fires one step late, before the crossing, and replaces the most useful step of the cycle (wide brackets 2388); requiring a creep in one direction as well gives 2688 and 2399. 13. **A halving that sticks once begun wins the flat families and loses everything else.** Without an exit the flat families fall to 1057 — pure bisection's level — and the canonical set rises to 6707, because a false entry now lasts to the end of the run. Splitting at the order read from the failed promise, $(1-1/m)^m=r$, changes nothing: that order is $m=\infty$ in 163 of 174 entries (6591). 14. **The model's own point cannot tell a flat root from a simple one.** Judging the evaluated point against the line through the bracket ends and against 0 — the exit judgment of §6.2 — also at *entry* gives 2820 and 1532 against 2935 and 1546 for the exit alone: the model aims at the root, so $f$ is small there by construction and looks flat at a simple root as readily as at a power. The same judgment works at a split, which the model did not choose. 15. **The decision reading "defect" does not transfer.** Combined with the regime it was the best configuration on the two development sets (§A.4's defect reading with the flat families of §6), and it passed every criterion recorded for it there. On new corpus 1 it did not: per problem 95/33/78 against Chandrupatla ($p=0.22$), losing the class of exponential flanks 9 to 26. It is therefore not part of A′. 16. **A component rejected alone can pay in combination.** Remembering the analogy for the run was rejected by its own advance record, under the harness scoring of the time (canonical set 2814 against 2806 without the regime; under the sign-change criterion the two are level, 2633 against 2634), and with the split of §6.3 it is the better form (with the step pattern, wide brackets 1250 against 1388 for the analogy read in one state). Composition was measured, not assumed, throughout — which is also why §A.2's readings (2) and (3), each an improvement, are not combined. --- ## Appendix D. Advance records and the frozen code Every rule of §6 and every test of §7 was written down, with its criteria and stop rule, before its code and its run. Table D1 gives, for each document, the commit that first added it and the commit that first added the results its run wrote, both read from git by `check_prereg_order.py`: 25 of the 30 were committed before their results; four were committed together with them, so git cannot order them; one was decided on its smoke run and has no results file. We call these documents advance records, not pre-registrations: they live in the author's repository, and their order relative to the runs is attested only by the author's git history, whose timestamps the author sets; no external registry was used. A deposit with an external timestamp (Zenodo, OSF) before a run would remove that limitation for future tests. Before publication the history was rewritten once, to remove infrastructure details (a server address); the commits cited here are those of the published history, in which `check_prereg_order.py` recomputes Table D1. The code of A′ was committed (`8027d7f`) after corpus 4 was defined (`657df10`) and before its results (`6d2531e`); `simroot/pure.py` did not change in between. **Table D1.** Advance records, in the order they were written. | advance record | commit | results file | commit | order | |------------------------------|---------|--------------------------------------|---------|-------------| | `logarithmic_2026-09-20` | `f9b062e` | `sweep_log.json` | `84ff1c7` | before | | `prestep_gate_2026-09-21` | `0617243` | `sweep_gate.json` | `a6116cd` | before | | `slope_gate_2026-09-21` | `e4769be` | `sweep_slope.json` | `e4769be` | same commit | | `points_and_direction_2026-09-21` | `04ee5c8` | `sweep_points.json` | `22f19c5` | before | | `similarity_per_slot_2026-09-21` | `15b9424` | `sweep_order.json` | `15b9424` | same commit | | `scale_selection_2026-09-21` | `cc2c499` | `sweep_cap.json` | `cc2c499` | same commit | | `decision_place_2026-09-21` | `2357379` | `sweep_decision.json` | `2357379` | same commit | | `step_extrapolation_2026-09-21` | `781bd15` | `results_diag_step_extrapolation.txt` | `3cce10b` | before | | `extrapolate_in_method_2026-09-21` | `a25cffa` | `sweep_extrap.json` | `99be33a` | before | | `extrapolation_gates_2026-09-21` | `29ab495` | `sweep_extrap2.json` | `68df1d2` | before | | `empty_step_2026-09-21` | `8279fb6` | `results_diag_empty_step.txt` | `d754689` | before | | `outcome_memory_2026-09-21` | `2b0ee22` | `results_diag_outcome_memory.txt` | `2498c66` | before | | `flat_regime_2026-09-21` | `9df1aa5` | `sweep_flat.json` | `e7e74d7` | before | | `flat_twice_2026-09-21` | `6a8bb23` | `sweep_flat2.json` | `9884b21` | before | | `flat_creep_2026-09-21` | `35eb941` | `sweep_flatcreep.json` | `5a1edff` | before | | `flat_stick_2026-09-21` | `1192c68` | `sweep_flatstick.json` | `f8c17c4` | before | | `flat_exit_2026-09-21` | `f8dd8d9` | `sweep_flatexit.json` | `1842eb0` | before | | `flat_judge_2026-09-21` | `1dbda21` | `sweep_flatjudge.json` | `8bf595d` | before | | `flat_analogy_2026-09-21` | `42bfab4` | `sweep_flatanalog.json` | `1842eb0` | before | | `flat_analogy_mem_2026-09-21` | `4bf8634` | `—` | `—` | decided on the smoke run, no results file | | `defect_contra_flat_2026-09-21` | `3c92d61` | `sweep_defcontra.json` | `63cf9fb` | before | | `flat_order_point_2026-09-21` | `d1be3bb` | `sweep_orderpt.json` | `08863c1` | before | | `flat_exp_limit_2026-09-21` | `e887691` | `sweep_explimit.json` | `baa9396` | before | | `half_contra_2026-09-21` | `3d74b45` | `sweep_half.json` | `bbb16ec` | before | | `out_of_sample_2026-09-21` | `47361da` | `sweep_oos.json` | `a86a9ed` | before | | `roots_jl_2026-09-21` | `97af3ae` | `sweep_rootsjl.json` | `554ec0c` | before | | `applied_2026-09-21` | `8ea89dd` | `sweep_applied.json` | `c2b0eea` | before | | `close_sub_2026-09-21` | `657df10` | `sweep_fourth_fourth.json` | `6d2531e` | before | | `modab_2026-09-21` | `bfa23b2` | `sweep_modab.json` | `37c81b0` | before | | `controls_2026-09-22` | `77312be` | `sweep_controls.json` | `92c07d8` | before | --- ## References 1. G. E. Alefeld, F. A. Potra and Y. Shi, "Algorithm 748: Enclosing zeros of continuous functions," *ACM Trans. Math. Softw.*, vol. 21, no. 3, pp. 327–344, 1995. 2. R. P. Brent, *Algorithms for Minimization without Derivatives*. Englewood Cliffs, NJ: Prentice-Hall, 1973. 3. T. R. Chandrupatla, "A new hybrid quadratic/bisection algorithm for finding the zero of a nonlinear function without using derivatives," *Adv. Eng. Software*, vol. 28, no. 3, pp. 145–149, 1997. 4. I. F. D. Oliveira and R. H. C. Takahashi, "An enhancement of the bisection method average performance preserving minmax optimality," *ACM Trans. Math. Softw.*, vol. 47, no. 1, pp. 1–24, 2021. 5. C. Ridders, "A new algorithm for computing a single root of a real continuous function," *IEEE Trans. Circuits Syst.*, vol. 26, no. 11, pp. 979–980, 1979. 6. V. Sitnikov, "Parameter-free similarity control," preprint, 2026. 7. M. Dowell and P. Jarratt, "A modified regula falsi method for computing the root of an equation," *BIT*, vol. 11, pp. 168–174, 1971. 8. G. Pólya, *How to Solve It*. Princeton, NJ: Princeton University Press, 1945. 9. T. J. Dekker, "Finding a zero by means of successive linear interpolation," in B. Dejon and P. Henrici (eds.), *Constructive Aspects of the Fundamental Theorem of Algebra*. London: Wiley-Interscience, 1969, pp. 37–51. 10. N. Ganchovski and A. Traykov, "Modified Anderson-Björck's method for solving non-linear equations in structural mechanics," *IOP Conf. Ser.: Mater. Sci. Eng.*, vol. 1276, 012010, 2023. 11. M. Galassi et al., *GNU Scientific Library Reference Manual*, 3rd ed. Network Theory, 2009; root-finding test suite `roots/test.c`. 12. J. Verzani et al., *Roots.jl*, Julia package; bracketing benchmark `test/benchmark-bracketing-methods.jl`, commit cf1d256, 2026. 13. J. L. Lagouanelle, "Sur une méthode de calcul de l'ordre de multiplicité des zéros d'un polynôme," *C. R. Acad. Sci. Paris Sér. A*, vol. 262, pp. 626–627, 1966. 14. L. B. Rall, "Convergence of the Newton process to multiple solutions," *Numer. Math.*, vol. 9, pp. 23–37, 1966. 15. E. Hansen and M. Patrick, "Estimating the multiplicity of a root," *Numer. Math.*, vol. 27, pp. 121–131, 1976. 16. E. Schröder, "Ueber unendlich viele Algorithmen zur Auflösung der Gleichungen," *Math. Ann.*, vol. 2, pp. 317–365, 1870. 17. J. F. Traub, *Iterative Methods for the Solution of Equations*. Englewood Cliffs, NJ: Prentice-Hall, 1964. 18. S. Weerakoon and T. G. I. Fernando, "A variant of Newton's method with accelerated third-order convergence," *Appl. Math. Lett.*, vol. 13, pp. 87–93, 2000. 19. A. Cordero and J. R. Torregrosa, "Variants of Newton's method using fifth-order quadrature formulas," *Appl. Math. Comput.*, vol. 190, pp. 686–698, 2007. 20. N. Ganchovski, O. Smith, C. Rackauckas, L. Tomov and A. Traykov, "Improvements to the Modified Anderson–Björck (modAB) root-finding algorithm," *Algorithms*, vol. 19, 332, 2026; package `pymodab` 1.0.9. 21. J. C. P. Bus and T. J. Dekker, "Two efficient algorithms with guaranteed convergence for finding a zero of a function," *ACM Trans. Math. Softw.*, vol. 1, no. 4, pp. 330–345, 1975. 22. J. M. Fernández-Díaz and C. O. Menéndez-Pérez, "A common framework for modified Regula Falsi methods and new methods of this kind," *Math. Comput. Simul.*, vol. 205, pp. 678–696, 2023. 23. A. Cordero, B. Neta and J. R. Torregrosa, "Memorizing Schröder's method as an efficient strategy for estimating roots of unknown multiplicity," *Mathematics*, vol. 9, 2570, 2021.