Bundle review table

Does floating-point error have a phase transition?

Supplied working report; original verdicts not validated.

Review status: Blogger published. This is an archival source note, not a passed proof.

README.md

# Does floating-point error have a phase transition?

**Test of hypothesis 23, Volume II — "Floating-Point Error Has a Phase Transition"**
Published proposal: <https://incoprea.com/research-library/original-theories-vol2-20261030/>
Test run: 30 October 2026 · Working result, not peer reviewed · AI-assisted

## The result in one paragraph

The threshold is real, predictable, and exactly where the arithmetic says it
should be — but it is not a catastrophe. Summing a decaying sequence in 200
random orders, every ordering returns the *identical* value up to a depth of 54
terms in 64-bit arithmetic and 25 terms in 32-bit. Beyond that depth the answers
disagree, and the disagreement is one unit in the last place. The switch from
"every run agrees" to "runs disagree" is a step, not a gradient, and it moves
exactly 29 terms for every factor of 2^29 in precision — 29 terms between
binary64 and binary32, 58 between the repetitions that halve the decay rate,
and so on (Table 1). What does *not* follow from depth is magnitude.
Catastrophic error appears at a condition number near 1.6/ε, and at fixed
condition number depth has no effect at all: a 101-term and a 10,001-term sum
carry the same 2% relative error. Reproducibility is a threshold property, as
the proposal claims. Catastrophe is a conditioning property, which the proposal
conflates with it.

## What was tested

The proposal makes three predictions. They were fixed before the first run
(`hypothesis.md`):

- **P1** error shows a sharp increase beyond a critical depth rather than smooth growth;
- **P2** reordering is harmless below the threshold and changes the result above it;
- **P3** lowering precision moves the threshold to shallower depth, predictably.

The test sequence is v<sub>i</sub> = 2<sup>−⌊i/k⌋</sup> for k ∈ {1, 2, 4, 8, 16},
so the total is ≈ 2k and every partial sum below the threshold is exactly
representable. That matters: if the data carry their own rounding from the
first term, "the threshold" is not separable from ordinary rounding noise. With
exactly representable data the only thing that can break determinism is
absorption — a term smaller than the running sum's last place.

For each depth, 200 random orderings were summed naively (left to right) and
the number of distinct results was counted, in binary64 and in binary32. The
exact sum was computed as a rational, so "error" is error against the true
value, not against a rounded reference.

## Table 1 — the threshold moves exactly where it is predicted to

| Repetition k | Predicted first-lost index (f64) | Observed first disagreement (f64) | Predicted (f32) | Observed (f32) | Observed shift | Predicted shift |
|---|---|---|---|---|---|---|
| 1 | 51 | 54 | 22 | 25 | −29 | −29 |
| 2 | 100 | 105 | 42 | 47 | −58 | −58 |
| 4 | 196 | 205 | 80 | 89 | −116 | −116 |
| 8 | 384 | 401 | 152 | 169 | −232 | −232 |
| 16 | 752 | 785 | 288 | 321 | −464 | −464 |

Observed depth = predicted + 2k in every row, with no free parameter. The
prediction comes from one line of arithmetic: a term is absorbed when
2<sup>−j</sup> < ε·(2k), so the first lost level is j\* = 52 − log₂(2k) and the
first lost term index is k·j\*. The offset 2k is round-to-nearest-even: a term
of exactly half an ulp is absorbed without changing the sum, so disagreement
needs the accumulated tail to exceed half an ulp, which takes two further
levels.

## P1: sharp, yes — catastrophic, no

The step in *determinism* is sharp: at 53 terms every one of 200 orderings
returns the same number; at 55 terms they return two. The step in *magnitude* is
one ulp. Mean relative error at the threshold is 4.1 × 10⁻¹⁷ in binary64, about
0.19 of a unit in the last place — ten times the median step elsewhere in the
curve, but still one ulp. It does not grow into a catastrophe as depth
increases; it saturates at the size of the lost tail.

Catastrophe needs cancellation, and cancellation is measured by the condition
number κ = Σ|x|/|Σx|, not by depth. In a 1,001-term sum built from cancelling
pairs plus a residual c, mean relative error rises from 2 × 10⁻¹¹ at κ = 1.5 ×
10⁶ to 0.19 at κ = 1.5 × 10¹⁶, crossing 10% at **κ ≈ 7.3 × 10¹⁵**, which is
1.63/ε. Holding κ at 1.5 × 10¹⁵ while changing depth from 101 to 10,001 moves
mean relative error from 0.021 to 0.016 — no depth effect (Table 2).

## Table 2 — depth at fixed conditioning does nothing

| Terms in the reduction | Condition number | Mean relative error |
|---|---|---|
| 101 | 1.5 × 10¹⁵ | 2.1 × 10⁻² |
| 1,001 | 1.5 × 10¹⁵ | 2.1 × 10⁻² |
| 10,001 | 1.5 × 10¹⁵ | 1.6 × 10⁻² |

## P2: supported, with a qualification that matters for practice

Below the threshold, 200 orderings give one answer. Above it they give two,
differing by half an ulp (1.9999999999999998 vs 2.0 at 200 terms). That is
reproducibility failing in the sense that matters for bitwise comparison, and
it fails abruptly. It does not mean the simulation has gone wrong: both answers
are correct to the last bit, and the spread never approaches the magnitude of
the answer. Practitioners who see two different checksums above a known depth
are seeing this, not divergence.

## P3: strongly supported

The threshold is a closed-form function of precision and decay, and it tracks
exactly: −29 terms per halving of the decay rate's exponent, and −29·k terms
between binary64 and binary32. The proposal's "mixed precision shifts the
threshold in a calculable way" is the best-supported part of it, and the
calculation is a one-liner to hand to a numerical library.

## Limits

- The data are synthetic and exactly representable. Real reductions carry
  rounding from the first term and heavier-tailed magnitudes; the *form* of the
  threshold should survive, the exact constants will not.
- One reduction order (left-to-right) and one accumulation width were tested.
  Pairwise or Kahan summation change the constants, not the mechanism.
- The test cannot distinguish the proposal's percolation-of-large-partials
  mechanism from plain absorption. Simple absorption predicts every number
  here, so the stronger mechanism is not needed — and not supported.
- "200 orderings" bounds how *early* disagreement can be detected: a rare
  ordering could disagree slightly below the reported depth.

## What would change the answer

A data set with realistic magnitudes and cancellation showing a *magnitude*
threshold at fixed condition number would restore the catastrophe claim. We
looked for it in the natural place — depth at fixed conditioning — and it is
not there.

## Files

`run.py` (reproduces everything) · `results.json` · `data/` · `figures/` ·
`hypothesis.md` (pre-specified criteria) · `SOURCE.md` (environment, hashes)

hypothesis.md

# The hypothesis, as published

Source: <https://incoprea.com/research-library/original-theories-vol2-20261030/>
Volume II, hypothesis 23 — "Floating-Point Error Has a Phase Transition".

## Claim (verbatim)

> Error in large reductions switches from benign to catastrophic at a critical
> reduction depth rather than growing smoothly, so reproducibility is a threshold
> property and the threshold shifts predictably with precision and ordering.

## Predictions (verbatim)

- P1 — Error should show a sharp increase beyond a critical reduction depth rather than smooth growth.
- P2 — Reordering below the threshold should be harmless, and above it should change results reproducibly.
- P3 — Lowering precision should move the threshold to shallower depth in a predictable way.

## Refutation criterion (verbatim)

> Error that grows smoothly across depths, with no threshold, would return the
> problem to the random-walk account.

## Pre-specified criteria for this test — fixed 30 October 2026, before the first run

A depth threshold exists if, for a sequence whose partial sums are exactly
representable, the number of distinct sums returned by 200 random orderings
changes from 1 to more than 1 at some depth. It is *predictable* if the observed
first-disagreement depth equals the absorption depth derived from ε and the
decay ratio, to within a small constant offset that must be the same across
decay ratios.

- P1 supported if the determinism step is present *and* the error step at that
  depth exceeds the median step in the error curve by at least 5×. P1 fails if
  either part fails. Reported separately: the size of the step in ulps.
- P2 supported if distinct-count is 1 below the threshold and > 1 above it,
  over 200 orderings, with no intermediate regime.
- P3 supported if the observed shift between binary64 and binary32 is within
  ±2 terms of log₂(ε₃₂/ε₆₄)/log₂(1/r).

Additional pre-specified contrast, needed because the claim is about
*catastrophe*: with the condition number held fixed and depth varied by two
orders of magnitude, the relative error should not change materially. If error
tracks depth rather than conditioning, the catastrophe claim survives; if it
tracks conditioning only, it does not.

Analysis choices, fixed in advance: 200 random orderings per depth; seed 1;
exact rational reference (fractions.Fraction); naive left-to-right accumulation;
binary32 accumulation emulated with numpy.float32 per step; depths 5–130 for
the step test and 3–(predicted + 4k + 10) for the scaling test.

Included code and results