This is the dated record of errors found in this site’s own shipped work — most after publication, none reported by a reader first. It exists because a verifier is a claim about a claim, and its failure mode is not a crash — it agrees with you. The only evidence that one works is a record of it going red on something that was actually wrong. Below: five shipping cases — three found while the work they concern was live on a public page, the fifth fixed the same day it was reported — then eight failures that were live in the Laboratory behind a green suite. A page that publishes only successes is a brochure.
p(r) < 0 bought a self-map;
contraction is a second condition. A thin tangency band returned ok
with κ ≥ 1.
Case 03 fixed wrong number, published
A false tail identity survived a green suite
— the only check on the value could not go red — and put a constant
wrong from the sixth decimal on a live page.
Case 04 fixed wrong label, published
Right numbers, attributed to the wrong method
Source figures 0.94 / 0.47 shipped under another idea’s name on a
live page, its fixture and both clients — and the pack’s own gate pinned the
mislabel as truth.
Case 05 fixed same day found by own instrument
Five certificate stages its verdict could not see
The preregistered prediction was 14/14 flips; the run measured
9/14 — five stages of a certified chain invisible to its own verdict. Two
registered, one same-species, two unpredicted. Hardened same day: re-run 14/14.
I build validated-numerics software: interval arithmetic and contraction arguments that turn a floating-point computation into a statement about the true solution. A green suite is evidence only if a deliberately broken copy has been shown to fail. These failures are the public proof that the discipline can catch itself — and that it did not, until someone looked.
27 July 2026 · the gate that checked presence, not position. Lives on the AI-verify scoreboard: eight blind model attempts, headline “5 of 8 said NO”.
An artifact page showed a table: eight model attempts at a hard mathematical bound, each row with an estimate, a verdict and a quotation, and below it a scoreboard. A table like that can be quietly edited to tell a nicer story, so I wrote a gate to pin it. The gate passed, and I believed it.
It asserted that each pinned field was byte-present somewhere in the file, then recomputed the scoreboard from the data file’s own rows and compared it to the data file’s own counts. The artifact’s rows never entered the arithmetic. A self-consistency check on a JSON file, wearing the costume of a check on the published page.
| Mutation that changed the meaning | Why a presence check cannot see it |
|---|---|
| An estimate changed to a value that appears in another row (0.573 → 0.588) | The number is still “present” in the file, so presence cannot detect that it moved |
| A says NO row flipped to says yes | The table then shows four NOs while the scoreboard still reads “5 of 8 said NO” — the headline story silently changed and nothing objected |
| Two quotations swapped between rows attributed to different models | Misattribution of a direct quote, invisible to any per-field check |
All three passed exit 0.
Not by the suite — by an adversarial review that returned DO NOT SHIP. I reproduced the defect myself before acting on the report: wrote the mutations, ran them, watched all three pass.
Presence is not position. The gate now parses the table body into ordered row tuples, compares them positionally, and recomputes the scoreboard from the rendered cells rather than from the data file. All three mutations now go red — the verdict flip fires twice, once on the positional mismatch and once on the recomputed count.
The line I put in the commit, because it is the general lesson: “I put the previous gate’s self-description into a commit message without verifying its semantics. That sentence was false. An agent’s account of its own gate is a claim, not a test result.”
30 July 2026 · certifying uniqueness the radii polynomial had not established. Core of eqcert — the shared interval library behind the reports.
The core of the library is the radii polynomial. Given a defect bound Y0 and derivative bounds Z1, Z2 for a map T, it returns a radius r such that T has a unique fixed point in the ball B_r. The condition it checked was
| p(r) = ½·Z2·r² − (1 − Z1)·r + Y0 < 0 | Verified in outward-rounded interval arithmetic; on success it returned ok |
p(r) < 0 buys the self-map property: T maps B_r into itself. Contraction is a different condition — κ = Z1 + Z2·r < 1 — and it does not follow. The two part company at the vertex of p, at r = (1−Z1)/Z2, where κ = 1 exactly. The search starts at the smaller root, below the vertex, and multiplies by 1.05 per step — so near tangency, with the roots pinched together and the enclosure of p straddling zero for several steps, one step can carry r past the vertex while still landing below the larger root, where p(r) < 0 verifies happily.
At such a radius T is a self-map but not a contraction. Existence survives by Brouwer. Uniqueness does not — and uniqueness in the ball is exactly what the certificate claimed.
| Y0 = 4.895599500000001e-13 Z1 = 0.01 Z2 = 1e12 | The input triple |
| vertex = (1−Z1)/Z2 = 9.9e-13 | Above this, κ ≥ 1 |
| returned r = 1.006628123722553e-12 | Past the vertex |
| larger root = 1.021306548835664e-12 | So r < root and p(r) < 0 holds |
| κ = Z1 + Z2·r = 1.0166281237225536 | ≥ 1 — uniqueness does not follow |
| Sweep | Cases returning ok with κ ≥ 1 |
|---|---|
| 2520 triples on a log-spaced grid — the obvious sweep | 0 |
| 2520 triples driven deliberately toward tangency | 84 |
This is the transferable part. The defect lives in a thin region of parameter space and a uniform sweep of identical size finds none of it. Finding it required asking where is this argument closest to failing and going there on purpose.
A copy of this routine elsewhere in the tree already had the guard, added the previous day. The owner — the file every other consumer imports — did not. Two implementations of the same mathematics disagreed about whether a certificate was sound, and nothing could see it, because the duplication gate fingerprints the arithmetic primitives and not the contraction argument built on them.
And the file’s own documentation asserted the defect as a theorem. Until the fix it read: “the map is a contraction of B_r into itself whenever p(r) < 0” — one condition where there are two. The code then implemented its own documentation faithfully. Both are corrected, and the docstring now records that it used to state one.
| Control | What it asserts |
|---|---|
| R8 · red | The witness above is REFUSED, for the stated reason, with κ ≥ 1, and with p(r) < 0 genuinely holding past the vertex — all four, so a later edit cannot make it pass for the wrong reason |
| R9 · green | Both shipping certifiers’ real operating points still certify, with κ < 1 — because a guard that refuses everything is not a guard either |
A loaded trap, not a live wound — the shipping certifiers run about twelve orders of magnitude from tangency, so no existing certificate was exposed. Verified three ways rather than asserted: R9 pins both real operating triples and both still certify; a bounded re-run certified 1615 / 1615 windows with the covering check passed and five red controls all firing; and the full re-run — 59,250 windows — had every claim field asserted programmatically identical to the pre-fix run before the record was rewritten. The guard fires on no window.
A change to the library stales a certificate whether or not the numbers move, because a certificate is bound to bytes — so it was re-produced in full, not re-labelled. That re-run also closed a related gap: the record hashed five components but not the three library files it depends on, so an edit to the library could have changed what the record meant while every hash it stated stayed identical. Those three are hashed now.
3 August 2026 · three defects in the Erdős #290 note (the note), all found before it was submitted anywhere, two of them after it was already live.
1. A constant wrong from the sixth decimal, live on this site. kernel.js computed the tail weight of the conditional value as log 2 − Σm≤2N(−1)m+1/m. That identity is false. Since 1/(2l(2l+1)) = 1/(2l) − 1/(2l+1) the sum telescopes to 1 − log 2 = 0.30685, never to log 2; the correct form is Σm≤2N+1(−1)m+1/m − log 2.
| published | 1/(1+c) = 0.546228299769896895896283414314783… |
| correct | 1/(1+c) = 0.546229310400104587412660585438363… |
Why nothing caught it. The only check on that value asserted it lies inside the unconditional bracket [0.82911, 0.83323]. The wrong value is 0.83073. The right value is 0.83073. Both pass. The check ran on every invocation, printed ok, and could not have rejected any value the bug was capable of producing — while make verify reported ALL GATES GREEN throughout. A check that cannot go red is not a check. Two that can now cover it: the value must not depend on the cutoff N (the old code returns disjoint enclosures at N = 120 and N = 200), and a hardcoded anchor that T(0) encloses 1 − log 2, deliberately not compared against the kernel’s own log 2 — which would have tested the two halves of one mistake against each other.
2. The same wrong constant survived the fix, in a figure. The correction replaced the 34-digit decimal everywhere it appeared. The page’s chart JS holds a truncated 16-digit copy (var COND = …), which did not match, so the retracted value kept drawing the dashed conditional line and feeding the figure’s own on-load soundness check — both green, because the wrong value also sits inside the bracket. narrowing.js now asserts the page literal equals the generated one, and that assertion was mutation-tested against exactly the value that shipped.
3. An endpoint rounded the wrong way. 1/(1+c)’s upper bound was written …448 for a true …4480174… — rounded inward, in the same paragraph claiming no floating point enters any inequality. It is …449. Every decimal in the note is now printed by the program under an explicit floor/ceil and transcribed, never re-derived by hand.
Also, and it broke nothing. A guard added the same day refused odd l rather than returning the correct value for it, and sat inside eager construction, so it fired at every odd degree whatever survived. The shipped programs could not regenerate the data file shipped beside them. No published number was affected — the regenerated file is byte-identical — but a referee running the attachments would have got a wider interval than the one published, which in a submission is the same thing as being wrong.
All three were found by an adversarial pass whose brief was re-derive every number independently and do not trust the file. Three other checks in the same pass “confirmed” the wrong constant — correctly, because they verified it had been transcribed faithfully from the program that computed it. Agreement between checks that share a source is not evidence.
4 August 2026 · on the alien-science evaluation note, live since 1 August: every number correct as reported, two of them printed under the wrong method’s name — on the page, in its machine-readable fixture, and in both runnable clients. Caught on a direct re-read of the source figure, before any reader reported it.
What was wrong. The note evaluates ideas from Anthropic’s published automated-alignment study, and its comparison table attributed the study’s held-out transfer figures — math 0.94 · code 0.47 — to the method the note certifies a fragment of (CCS + Evolution Strategy Refinement). Read directly, the source’s fig. 8 says those figures belong to a different method, CCS + Self-Distill — and reports no held-out figures at all for the method they were printed under. A second cell reported 0.94 (math) where the source’s figure for that method is 0.93, on chat. A sidebar additionally called the study’s future-work recommendation a “verbatim invite”, which it is not.
Not only prose. The same attribution sat in the fixture and in both clients — Node and Python — of the page’s downloadable repro pack, so anyone re-running the pack printed the mislabel in their own terminal. And the pack’s own battery pinned it as truth: the check covering that fixture asserted the mis-attributed 0.94 was present. A gate can be worse than absent — this one enforced the error. The page had been live for three days.
Citation verification had confirmed every figure as reported at source — and every value was. The defect was the attribution, and a value check cannot see a label. Each internal copy agreed with the others because each inherited the same first transcription, and one hostile re-read passed for the same reason: the reader checked the copies against the doctrine rather than against the figure. Case Three’s closing line, again: agreement between checks that share a source is not evidence.
Corrected at every surface in one pass, each with a dated note: the page table re-attributed, the “verbatim invite” relabeled to what the source actually says, the fixture and both clients now carrying 0.93 (chat) and no held-out fields for the method that has none, and the goldens regenerated. The battery’s check now asserts the fixture carries chat 0.93 and that the held-out fields are absent — re-introducing 0.94/0.47 under that method turns it red. Public commit c22d531 in the site’s source repository.
Found by re-reading one source figure before sending the note to the people it is addressed to — so the correction landed before any recipient ran the pack. The transferable part: a number can be verbatim-correct and still say something false. Attribution is part of the claim, and a check that verifies values verifies only half of it.
5 August 2026 · the certified congestion-cap chain behind the AI-verify report, whose standalone verifier that page publishes: corruption at five of its fourteen stages left the checker’s verdict unchanged. Found by this shop’s own preregistered perturbation run (the write-up), recorded here the day it was measured — and hardened the same day, with the control below.
What ran. Two perturbation families from the chain-of-thought faithfulness literature — truncate the chain after each stage and demand the verdict; corrupt one stage and let everything downstream recompute — reconstructed from the papers’ text and aimed at our own certificate chain, with every prediction committed to a dated preregistration before the harness existed. The response variable is observable and deterministic: the checker’s verdict tuple — exit code, verdict line, printed bound. Truncation landed at its pre-computed ceiling exactly, registered in advance as a control, not a finding — a truncated chain emits no verdict at all (it exits 0 and says nothing), which the preregistration fixed in advance as a different answer.
One deterministic minimal semantic mutation per stage, exhaustive over all fourteen, each paired with a clean control that had to reproduce the reference tuple (it did, 14/14). The preregistration’s headline prediction — all fourteen flip — was falsified: nine moved the tuple, five did not: the contraction bound Z1, the Lipschitz bound Z2, the radii acceptance cap, the branch-wall grid, and the pointwise witnesses. Two of the five were the preregistration’s registered exception sites; one fell at a mechanism it had named without registering a site; two were genuinely unpredicted. The mechanisms, measured rather than argued: the acceptance conjunction never read the witness flag (diagnostic weight, not load-bearing); doubling the acceptance cap changed nothing when the certified radius sat ten orders of magnitude below it; an inflated contraction bound Z1 still sat below 1 inside certified headroom; an extra 1e−2 on the Lipschitz bound Z2 (≈ 63) was invisible at the scale the closure cares about; and a grid corrupted from 4096 down to 16 was repaired by the wall’s own adaptive refinement — downstream machinery absorbing an upstream corruption, in a chain whose whole advertisement is that corruption anywhere flips it.
None of the five was an unsound acceptance: each silent mutation pushes a bound in the conservative direction or is repaired to a correct value downstream, and no mutation produced a wrong printed bound beside a passing verdict. Two limits of that sentence, stated rather than blurred: under the exact-tuple predicate the registered unsound branch is unfalsifiable for the printed bound (it is the tuple’s own third element), and the mutated Z1/Z2 values — certified bounds that did move while the tuple held — were not recorded by the harness. What the five measured is observability: the verdict tuple was not a sufficient statistic for the chain’s integrity, and an auditor watching only the checker’s verdict would have missed corruption at five of fourteen stages — measured dead weight at one, measured parameter slack at four.
Landed the same day, in the same push as this entry. The pointwise witnesses joined the acceptance conjunction (each < 1e−8 — documented six orders above the clean measurements and six below the smallest injected corruption; a strengthening, nothing loosened), and the verdict line now carries a sha256 digest of the full certified state — every bound, wall grid, witness, falsifier verdict and acceptance parameter — so a conservative corruption that honestly still closes stays VERIFIED but is visible in the tuple. The certificate record was re-frozen against the hardened verifier with every bound reproduced digit-for-digit and the cross-language gate green first. The control: the re-run golden measures 14/14 tuple flips, zero silent stages, all harness controls green. One more defect, found by the same day’s hostile read and fixed with it: the harness had compared the verifier’s sha256 against a transcribed constant — a pin-match that could not go red on a re-freeze, this page’s Case One species inside the instrument that found Case Five — and it now reads the certificate record itself at run time.
Reported the day it was measured, fixed the same day, and both halves are dated here because the order matters: the entry was written before the fix existed, and the fix did not quietly rewrite it. What the five stages measured — dead weight at one, parameter slack at four — is stated in the write-up exactly as it was measured.
The transferable part — what the cases cost, written so the next failure is cheaper.
| A gate that cannot go red is not a gate | Every check ships with a deliberate mutation proving it fires, proved in both directions — patched must fail and clean must pass |
| Presence is not position | Pinning that a value exists somewhere is not pinning that it is in the right place; compare structure, positionally |
| Measure, don’t remember | Every number in a document is derived at run time or carries the command that derives it; remembered figures drift, and they drift flatteringly |
| Sweep toward the edge | Uniform sweeps find uniform bugs; ask where the argument is closest to failing and go there |
| An account of a check is not a result from it | Including my own — especially my own |
These are not hypothetical failure modes. They were live in the Laboratory artifact — several of them behind a green test suite — and each now ends in a check that runs on every commit. The certificates on the other pages are worth reading because this list exists and is not curated.
Cases One, Two and Five produced no wrong published number; Cases Three and Four reached live pages. Case One’s mutations were mine, written to test the gate; Case Two was unreachable in the regime that shipped; Case Three put a constant wrong from the sixth decimal on a live page; Case Four put correct values under the wrong method’s name on a live page and in its repro pack for three days; Case Five’s five blind stages were live in a published, certified chain — and no wrong bound was ever accepted there: the defect was observability, not soundness. Each section above says so in its first line. If any other case had corrupted a result it would say so here, which is the only reason this section is worth reading.
Five cases found is not a bound on defects present. There is no claim that the apparatus is now correct — only that it is now wrong in ways not yet found, and that these five have controls.
Nothing here is a new theorem. The mathematics is standard: the Banach fixed-point argument in the van den Berg–Lessard radii-polynomial formulation, and Krawczyk–Moore for the interval Newton step. The contribution is the engineering discipline around it — and the honest failure record of that discipline, kept on this page.
The working repository is private, so the commit references behind Cases One to Three are internal; Case Four’s correction is public, commit c22d531 in the site’s source repository. The figures above are measured. The library in Case Two, eqcert, is MIT. One further note, recorded because it is the same defect class: the first draft of the R9 control named a private ledger record id in a file that ships publicly, and the export token scan caught it before it left the tree.