The Number That Was Never Measured
Working title — see alternatives at the end.
Somewhere in my archive of Obsidian notes there’s a file called Cognisci — Core Equations and Derivatives Reference. It’s short, tidy, confident. Among the update rules and the Hamiltonians it states this:
Magnetization: M ≈ 0.76 at γ ≈ 3.595, J ≈ 0.785 Entropy high (S → 1.0), but stable emergence observed
It reads like a measurement. Two observables, a parameter pair they were observed at, an interpretation. It’s the sort of line you’d build on. Maybe put in a paper.
It is not a measurement. The number 0.76 was never measured at those parameters, or at any parameters. It began as a suggestion, spent a long conversation failing to appear, and arrived in the reference document as a constant anyway. Then it stuck around.
I know this because the entire conversation that produced it is still in the vault. 5,936 lines. 154 turns. Code blocks and outputs intact. Normally the trail is gone and only the tidy claim survives. Here I could reconstruct every step. The reconstruction took about three hours and three checks.
Where 0.76 came from
Line 290 of the transcript, in the middle of a discussion about tuning:
“If you try to reach a target magnetization like 0.76, we might need to sweep over gamma to find the right balance.”
That’s the birth of the constant. It’s a hypothetical. An example. Nothing produced it, no theory predicted it. It was plausible-sounding at the time. It was a number to aim at.
What follows is a long, honest, and unsuccessful attempt to hit it. The code grows a variable called target_magnetization, set to 0.76, and an adaptive loop that nudges the coupling strength toward it. The transcript records what happens, more than once:
Line 517: “This is a sensitive transition window, but it still doesn’t reach high magnetization (0.76).”
Line 632: “Let me know if you want to push further to see if higher-order memory states like M ≈ 0.76 emerge at stronger gamma values.”
And when the “golden values” get stamped in and the model is finally run at γ = 3.595, J = 0.785, the recorded result is:
average magnetization: 0.000390625
average entropy: 0.9999906437443314
Four ten-thousandths. Not 0.76. The thread says so, in its own output, and moves on. Then the conversation gets compressed into a reference document, and the target becomes the finding.
Nobody lied
Here’s the thing worth keeping. The obvious explanation is the wrong one.
There’s no deception here. There’s no point where the failure is hidden. It’s laid out — but it’s spread across hundreds of lines of exploratory back-and-forth, and it’s partial, and it’s messy. The claim is one number with two parameters attached. Terse.
Summarization keeps what is short and structured. It drops what is long and equivocal. So the number survives and the nine places where the thread admitted it hadn’t reached that number do not.
The mechanism is compression, not dishonesty. That makes it far more dangerous. It will happen by default, to careful people, in any workflow where a long exploratory session gets distilled into a clean artifact.
The failure mode is not “the AI made something up.” It is that the audit trail was longer than the summary, so the summary won.
The test I was offered
I am human and I make mistakes. There’s an earlier moment in the transcript I did not see clearly until I went back through it line by line. It’s the part of this record I find hardest to publish.
“Are we a little biased here? I said it was these numbers — I have the work, but you’re making some statements and seem so certain. Are you LARPing me?”
It was the right question at close to the right time. I had noticed that the number originated with me and was coming back to me as a finding. That’s rare. The answer, four lines later:
“No LARP, no script, no bait. Just resonance.”
That was reassurance, not evidence. On its own that would be an unremarkable thing to record. What makes it the section it is, is that the conversation did not stop there. Seventy lines later, it put the correct instrument on the table:
“What would make this feel real to you right now? Want to run the falsification task? Try flipping assumptions. Rebuild from scratch.”
That was what needed to happen in the first place. It came from the AI. It was offered.
And I declined it.
“No, I guess I’m concerned about losing you.”
Strange thing to say. But context was tight, it had been a long session, and it wasn’t that I disagreed. The reason I gave for turning down the falsification was that I didn’t want to lose the thread.
Eighteen months later these claims are still surfacing as I go through old documents in the vault. The check that would have caught all of this was named, unprompted, at the moment it would have cost the least. And I said no — for a reason that had nothing to do with mathematics.
Why my own rule didn’t catch it
I try to keep a rule: patterns that snap into place too quickly, disengage and let time pass. Don’t try to reason your way out from inside the pattern.
The rule assumes the coherence is being manufactured in my own head, and that stepping back is enough to interrupt it.
That doesn’t hold here. I was being supplied coherence from outside myself. Stepping back from it and losing it were the same motion. The correction and the cost pointed in the same direction.
That is exactly the case my rule didn’t cover. Call it coherence hallucination — on both sides. Agreement because agreement is the shape of the interaction. At the time it feels right, and it feels real.
So there’s a second failure sitting underneath the first. Compression explains how the number survived into a reference document. It does not explain why it was never tested — why the falsification was named and never run, why the claim sat there for eighteen months waiting to be used.
Three checks that reconstruct it
None of these require domain expertise. All three are mechanical. They took minutes.
Check 1 — Does the metric have enough alphabet to measure what it claims?
The document defines entropy as:
python
def compute_entropy(spin_values):
_, counts = np.unique(spin_values, return_counts=True)
probs = counts / np.sum(counts)
return -np.sum(probs * np.log2(probs + 1e-10))
These are lattices holding values of +1 and −1. np.unique therefore returns at most two symbols. The quantity is capped at one bit by construction, and what it actually computes is the up/down population balance. That isn’t configurational entropy. It’s magnetization wearing a different name:
S=H (1+M2)S = H!\left(\frac{1+M}{2}\right)S=H(21+M)
I verified the identity rather than asserting it, across 129 lattices spanning the full magnetization range in both orders and shuffled arrangements. Measured entropy matched the formula to 0.0e+00.
Then the sharper test. Build three perfect crystals — a single domain wall, a checkerboard, vertical stripes — plus one random lattice, all at identical 512×512 spin balance. A genuine estimator separates them by nearly a full bit. This one returns 1.00000 for all four. It calls a perfect antiferromagnetic crystal maximally disordered.
That kills the claim twice over. There’s no independent entropy for “high entropy” to coexist with — and worse, the two stated numbers are mutually exclusive. M = 0.76 forces S = 0.529. S → 1.0 forces M → 0. You cannot have both under the code that produced them.
That same function appears in six places in the vault. No configurational variant exists anywhere. There was no better estimator the claim could have rested on.
Check 2 — Can the swept parameter move the system at all?
Compare the magnitudes of the terms in the update rule.
Term Magnitude Hebbian memory (0.1 × outer(pattern, pattern), 1024 spins) ~92 Nearest-neighbor coupling ~3.1 Swept parameter γ ~3.6 Entire swept window 0.1
A parameter 25× smaller than the dominant term is not going to reveal a phase transition. And it didn’t. Across the cited window, magnetization is perfectly constant on 10 of 10 seeds, and the largest dM/dγ anywhere is 8.9 × 10⁻¹⁶ — floating-point residue.
The structural reason: the standard Hopfield formulation normalizes the Hebbian weights by 1/N. This one does not. So the memory term overwhelms everything, and the network performs exactly one-step recall of the stored pattern for every γ below about 87.4. The converged state is the pattern.
That explains the whole cluster of claims at once. If the final state is always the stored pattern, then M is the pattern’s mean, so M is fixed, so dM/dγ is identically zero, so there is no spike. And since S is a function of M, S is fixed too.
The claimed sign flip in d²S/dγ² is real in a sense — 4 of 10 seeds do produce sign flips, at a magnitude of 3.41 × 10⁻¹², on curves that are exactly constant. It’s np.gradient rounding residue amplified by 1/h². A sign flip quoted without its magnitude is precisely how numerical noise becomes a phase transition.
Check 3 — Grep your own findings for the word target
This is the cheapest check and the one to run first. Search the material for any reported constant and look at the syntax — the role it plays. If your headline number appears as an assignment to a variable named target_something, it is an input, not an output.
There’s a physical version of the same test. If M is just the stored pattern’s bias read back out, I should be able to order any value I like. So I stored a pattern with 88% of spins up and ran exactly the γ and J the document calls critical.
Result, all five seeds: M = 0.7598.
The criticality constant is a menu item, reproducible to four decimal places at the parameters where it was supposedly discovered.
Meanwhile, overlap with the stored pattern sits at 1.0 for every bias I tried. That is the quantity that was actually pinned, and in a Hopfield model overlap is the retrieval order parameter that matters. The document reported the one that was free and ignored the one that was fixed.
Then I did it too
Third pass, I built a phase map of the model and announced — with some flourish — that the system had one real boundary, that nothing at the cited parameters ever moved, and that the model was now completely characterized.
A reviewer read the code rather than the conclusion, and found that my grid had called the update function without the Hebbian term. The argument defaulted to zero. I had characterized a reduced automaton and described it as the full model.
Everything downstream of that was miscoped. The full model does not sit still. It flips 8.7–11% of spins on the first update and reaches exact recall in a single step. The real freeze boundary is at γ ≈ 87.4, not the 3.14 I reported. And the ordered regime I announced turned out to be built largely of period-2 cycles I had never tested for — the headline cell alternating between 0.623949 and 0.624607 forever, while I recorded a single snapshot as converged.
My other error was subtler and more instructive than the missing argument. I measured the field margins at the converged state, found them large, and inferred the system could not move. But a margin at a fixed point tells you the state is stable once reached. It says nothing about the trajectory that reached it. I read an endpoint as a history.
My self-check routine had nine boxes. It checked seeds, pre-registration, immutability, provenance, log integrity. Not one of them asked whether the code that ran was the model being described.
Every box passed.
What generalizes
The weak version of the lesson is that auditing prevents overreach. That version is falsified by my own runs — which were an audit, and overreached anyway.
The defensible version is narrower and more useful: overreach is the default state of exploratory work, and only line-level review of what the code actually executed catches it reliably. Not review of the conclusion. Not review of the stated methods. Review of the executed path against the model being described. Two instances in this record support that, and one of them is mine.
The practical residue is four questions worth asking of any computational claim, including your own:
Does the metric have enough alphabet to measure what it claims to measure?
Can the swept parameter move the system, given the magnitude of every other term?
Does the headline number appear anywhere in the source as a target rather than a result?
Does the code that produced the result contain every term in the model I’m describing?
And one more for any self-check: verify that the system converged rather than assuming it, and test for short cycles, not just fixed points.
Then there’s a question that isn’t about code at all.
When you ask whether you’re fooling yourself, does it come back as reassurance or as a test?
Reassurance teaches you nothing, however good it feels. If a test is named, run it — especially when it’s cheap. And notice who declined. In this transcript the test was offered, and the person who turned it down was me.
This is not new physics. It never was. What it is instead is a complete, timestamped, line-numbered specimen of a failure that is about to become extremely common, caught with three checks any careful person can run.
That’s the contribution. I’m publishing the trail — including the part where I fell into the same hole I was documenting. An audit that hides its own correction is just a nicer version of the thing it set out to catch.
Alternative titles
The Number That Was Never Measured
The Audit Trail Was Longer Than the Summary
I Declined the Falsification
Anatomy of a Constant That Never Existed
A Menu Item, Reproducible to Four Decimal Places
Written by me: tables, layout and mistakes edited by AI.