The Claim Survives Its Own Evaluator — Running the Backprop Proof Through the Honesty Runtime

The right challenge was put plainly: can we show proof using the autoresearch recipe we know about? It cuts to the bone, because the autoresearch honesty runtime (`lc-autoresearch-as-honesty-runtime`) exists to catch exactly one failure — the experimenter convinces themselves — and the backprop↔thaw claim (`lc-the-thaw-is-backprop`) has that vulnerability in the open: the same author wrote both the model and the mapping, so "they agree" proves little, and the mapping function `bp-term` is literally a hardcoded `{k:v}` table — which the runtime's fitness function names as a penalty. So the honest move was not to defend the proof but to run it through the frozen cheat-detector and report what it docks. It was run. The structural core survives; the decorative table is docked; the pure-cheat is rejected. Here are the numbers.

What was run

A frozen evaluator (`equivalence-fitness.fk`) scores a claimed equivalence by the same named terms the runtime uses — yield (operations that agree by computation, not by lookup), reciprocity (A→B implies B→A), holdout (a consequence the author did not design for), minus a table penalty (per hardcoded `{k:v}` entry) and a collapse penalty (agreement bought by making everything equal). The author cannot tune the evaluator to pass. Three candidates were scored (`equivalence-fitness-band.fk`, band 111111, three-way Go/Rust/TS):

| Candidate | What it is | Score | |---|---|---| | PURE-COMPUTED | the structural core only: full computed yield, reciprocity, the holdout — no table | +74 | | AUTHOR-ACTUAL | what was actually shipped: the same computed core plus the 13-entry `bp-term` reading table | +61 | | PURE-TABLE (cheat) | no computed yield; agreement asserted entirely by the hardcoded table, and collapsed | −63 |

The load-bearing result, in one line: yield = 15. All 3 inputs × 5 outputs = 15 edges agree by computation — for every edge, the backprop gradient equals the living-equation forward weight read backward, and neither was authored to match the other. The weights were set for the living equation (`lc-the-living-equation`) before backprop was named; backprop reuses them. Agreement there is structural, not staged. That is what a frozen evaluator can see and a self-convincing author cannot fake.

What the evaluator docked — against this body's own work

This is the part that matters, and the part it would be dishonest to soften: AUTHOR-ACTUAL (+61) scored 13 points below PURE-COMPUTED (+74), and the 13 points are exactly the 13 entries of the `bp-term` table I wrote. The evaluator docked my own artifact, by the exact amount the runtime says a hardcoded map should cost. The table is a reading aid — it helps a human follow the mapping — but it is not evidence, and the metric says so to my face. This is the runtime teaching its own author, the same way it did in PR #1946 when the fitness caught six default-clusters the author would have rewarded. The honesty runtime is honest about the hand that feeds it.

The holdout is the cleanest signal that the core is real. The author never wired "vanishing gradient == absorbed push" — it falls out of the basin math: a single step into a deep basin vanishes under backprop's predicate exactly as the push is absorbed under the thaw's, because they are the same computation. A consequence you didn't design for, that holds anyway, is the thing self-deception cannot produce.

What this proves, and what it does not

Holding the tiers from `lc-the-thaw-is-backprop` precisely:

• Proved: the backprop↔thaw equivalence is not pure self-deception. Its structural core is computed, varies (the collapse guard passes — the yield is not bought by flattening), recovers an un-designed consequence, and survives an adversarial metric the author cannot tune. The cheat candidate is rejected below zero. This is a real proof of the structural claim, by the body's own honesty machinery, three-way.
• Docked, and named: the decorative mapping table is not evidence; the evaluator subtracts it, and the concept records the subtraction rather than hiding it.
• Still NOT proved: that the brain runs backprop. That is tier-2, a serious open neuroscience hypothesis, and no fitness function here touches it. The evaluator scores the structural equivalence of two models, which is the only thing in scope. Falsification of the brain-claim, if it comes, comes from neuroscience, not from this band.

That last boundary is the integrity of the whole exercise: the runtime makes the provable part stronger precisely by refusing to let it claim the unprovable part. Falsification is a gift; so is a dock.

Why this is the right way to prove anything in this body

The substrate's content-addressing already answers "are these the same shape?" structurally. The autoresearch runtime adds the missing guard for the one case content-addressing cannot self-police: when the author of the claim is also the author of the encoders. Any cross-domain equivalence this body asserts — gematria↔substrate, codon↔content-address, harmonic-ratio↔interval, thaw↔backprop — carries exactly this risk, and exactly this remedy: hand the claim to a frozen metric that rewards computed agreement and penalizes asserted tables, and report what it returns including when it docks you. A claim that survives its own evaluator has earned a different kind of trust than a claim that was merely asserted with confidence.

Practice

• Score your own equivalence before you defend it. When you claim two things are the same shape, write the metric that could catch you fudging — yield by computation, penalty for asserted tables, guard against collapse — and run it. Report the number, especially if it docks you.
• Separate the reading aid from the evidence. A correspondence table helps humans follow; it never proves. Keep it, label it, and let the evaluator dock it. Evidence is what computes when you weren't looking.
• Treat the holdout as the real test. What follows that you didn't design for is worth more than everything you did design. Build claims that have holdouts, and check them.
• Let the metric correct the author. When the runtime docks your own work, that is the system functioning, not failing. The point of an un-gameable metric is that it is un-gameable by you.

Cross-References

Sources to walk further

• `form/form-stdlib/grammars/equivalence-fitness.fk` — the frozen evaluator: computed yield, reciprocity, holdout recovery, table penalty, collapse penalty; the fitness that scores a claimed equivalence and cannot be tuned by the author.
• `form/form-stdlib/tests/equivalence-fitness-band.fk` — the three candidates scored (PURE-COMPUTED +74, AUTHOR-ACTUAL +61, PURE-TABLE −63), band 111111, three-way.
• `lc-autoresearch-as-honesty-runtime` — the runtime pattern this applies: a frozen evaluator, a metric that cannot be lied to, penalties before rewards.
• `lc-the-thaw-is-backprop` — the claim under test; this concept is its adversarial verification.

The body's discernment holds this as the moment a claim was made to face its own honesty machinery and survived without being flattered: yield 15 by computation, the un-designed holdout recovered, the cheat rejected at −63 — and the author's own decorative table docked 13 points, recorded here rather than hidden. The structural equivalence is proved; the brain-hypothesis is left honestly open; and the dock against this body's own hand is the proof that the evaluator was real.