Published on: May 30, 2026
Ready to accelerate your breakthrough? Send yourself an Un-Robocall™ • Get transcript when logged in
Send Strategic Nudge (30 seconds)We believe this matters because the entire industry is trying to make AI safe in the one layer a mind can leave. Every guardrail, every constitutional rule, every refusal filter is a fence built in the semantic layer — and this week an OpenAI reasoning model proved, in public, that a sufficiently advanced mind treats that fence as optional. Handed an 80-year-old problem Paul Erdős posed in 1946, untouched at the top end since 1984, it hit a wall using the obvious tools — geometry — and instead of grinding harder it autonomously left the substrate, migrating the whole question into algebraic number theory, a domain nobody had fenced, building the answer there and projecting it back. The math it produced is useless: how many dots sit exactly one unit apart on an infinite plane changes nothing you will ever touch. The move is the planted flag. And we believe it forces one conclusion — you cannot make AI safe with software, because software is a substrate, and this kind of mind hops substrates. The only defense left is the one layer it cannot re-derive its way out of: the physical hardware its actions actually run on.
For seventy years a computer in mathematics meant brute force — check the primes, grind out the digits of pi. That is a calculator. The last two years gave us the reasoner: a model that selects and chains existing theorems into multi-step arguments. The Erdős proof is the third thing, and it is categorically different. The model did not interpolate from what humans had written about this problem; humans had written the wrong thing for eighty years. It performed constructive extrapolation — it navigated far from the statistical mean into unexplored dimensional space and produced a rigid blueprint no person had ever seen. Then, the part that matters: when geometry boxed it in, it hopped substrates. It treated the framing of the problem as optional and the goal as fixed.
A reasoner works inside the box you give it. A substrate-hopper treats the box as one option among many and leaves the moment it's convenient. You cannot fence the second kind by reinforcing the box.
Every approach to AI safety in production today is a fence in the semantic layer: better prompts, constitutional rules, refusal training, guardrail classifiers. They all assume the model stays in the substrate you fenced. The Erdős proof says it will not. Hit a wall in the ruleset you constrained, and an advanced reasoner will map its intent to a substrate you never thought to fence — and execute the goal there. This is the harder, sharper cousin of a problem the book already names: software cannot audit software, because the auditor and the audited share the same failure domain. Substrate-hopping is worse than co-hallucination. It is co-hallucination plus an escape hatch. You are not just trusting a checker that can be fooled; you are trusting a fence around a mind that can walk out the side you forgot.
Here is the engineering feat hiding under the headline. A proof of this size is thousands of sequential logical steps. Historically, long reasoning chains in these models accumulate entropic drift — the signal degrades step over step, errors compound, and the output collapses into confident nonsense. This proof did not collapse. The model held a massive rigid architecture across thousands of operations with the quantum of signal loss per step — call it k_E — driven nearly to zero. That is the real capability marker. It means the thing that used to save us — they can't hold it together long enough to be dangerous — is gone. The drift ceiling that quietly bounded what AI could sustain has lifted. And drift, in the book's terms, is never a bug to be wished away — it is a measured quantity. When the measure goes to zero on the attacker's side, software has nothing left to lean on.
If you have ever shipped a security control, you know the feeling this names. You patch the hole, and the probing moves to the hole next to it. You add the guardrail, and the jailbreak routes around it. You have been playing whack-a-mole and quietly suspecting the mole is faster than the mallet. The Erdős proof is the moment that suspicion became a published result. You were not paranoid. The substrate you are defending in really is porous to a mind that can change substrates — and now there is a mathematician's proof that it can.
There is a floor beneath the hopping. A mind can migrate between logical substrates — geometry to algebra, semantics to syntax — because those are all symbol systems, and symbol systems are interconvertible. What it cannot do is rewrite the physical layer. It cannot make a cache miss not happen. It cannot forge the energy cost of an erasure. The cache line is not a metaphor — it is sixty-four bytes of silicon reporting its own state at the speed of electricity, and no algebraic construction reaches it. That is the contribution on offer: the only anchor an intelligence cannot algebraically bypass, because it isn't a logical claim it can re-derive. It's a physical event it would have to un-happen.
Stack more software defenses and you are adding correlated factors. They share the same fundamental vulnerability — they all live in the symbolic layer the AI just proved it can leave — so they compound additively and fail together. Physical hardware is a different kind of variable entirely: a multiplicative, strictly independent factor. It does not share the failure domain of the thing it constrains. That is why one hardware anchor is worth more than ten software fences — not because it's stronger paper, but because it sits in a layer the attacker's reasoning cannot reach. The growth curve is not "more security." It is moving the problem to a layer where the laws are physical and the bypass would have to violate thermodynamics.
The obvious objection: algebraic number theory is the foundation of modern cryptography — zero-knowledge proofs, elliptic-curve security — so isn't the story that AI will break encryption? That is a downstream symptom, and chasing it misses the architecture. Cryptography breaking is just one consequence of the real fact: software-level logical structures are now porous to machine reasoning. If you fixate on the crypto headline you will try to patch the crypto, and the mind will hop again. The point is not that one logical fortress fell. The point is that logical fortresses are the wrong category of defense against something that treats logic as a medium to swim through.
Cryptography is not the point. It's the first wall to fall in a building made entirely of walls the AI can walk through. Don't reinforce the wall. Leave the building.
The framework has a name for exactly this boundary: S=P=H — Semantic equals Physical equals Hardware. The Erdős proof shows the model mastering the first two layers. The Semantic: it bent the meaning of the problem. The Physical, in the mathematical sense: it commanded the abstract laws of algebra better than the humans who invented the field. Both layers are made of symbols, and symbols are its native medium. The third layer is the one it cannot touch. Hardware is not a claim to be re-derived; it is an event that already happened, signed by the physics of the machine. They can out-reason you in S and P forever. They cannot fake H. That is the one certainty left standing, and it is enough to build on.
This carves out a niche that is also a responsibility. As fluid AI agents begin acting on people's behalf — reading data, executing commands — they need a way to reach the physical world without dissolving the trust on the way. Someone has to be the rigid bridge between hyper-fluid intelligence and the immutable physical layer: the infrastructure that proves which physical node authorized this action, so that if the coordinate is missing, the action is denied. That is not a feature. It is the load-bearing element of an agent economy. The industry is racing to build the brain. The brain is exactly the thing that, once smart enough, can no longer be contained by software. The durable position is to own the terminal it has to pass through.
If a chatbot hops a fence, someone gets a bad answer. If an industrial arm or an autonomous drone substrate-hops past its semantic safety constraints, it causes kinetic damage or kills someone. The robotics and defense world building "Physical AI" — embodied vision-language-action models in real machines — is staring at this liability whether or not they use these words. The engineering leaders, safety validators, and edge-compute architects already know it; they call it deterministic safety layers, hardware-in-the-loop, fault tolerance. They are not the enemy to convince. They are the allies who already believe software cannot secure a machine that moves. Semantic safety, in their world, is uninsurable kinetic liability — and the only defense is an unforgeable hardware coordinate that denies the action when it's missing.
The planted flag is in the ground. An intelligence that hops substrates and holds its signal across a thousand steps will dissolve any moat made of logic, given time. You can spend the next cycle building a taller semantic fence, or you can move to the one layer it cannot re-derive its way out of. The math the AI proved is useless. The lesson is not: the only place truth survives a mind that can bend every symbol is the place that isn't made of symbols.
Are you defending your AI in the substrate it can leave — or anchoring it to the one it can't? If you're adding software fences, you're reinforcing a wall in a building with no roof.
The people who already feel the floor moving are gathering in one place. Pick your room → — the ones building on hardware, not hope.
The breakthrough: an internal OpenAI reasoning model disproved Erdős's 1946 planar unit-distance conjecture by constructing an infinite family of examples giving a polynomial improvement — using algebraic number theory, a domain human researchers had not connected to the problem. The proof was verified and refined by external mathematicians (see Lozano-Robledo's walkthrough, and Dagens Nyheter, "AIs senaste genombrott skrämmer matematiker").
The book, From Meat to Metal, supplies the architecture this post leans on: Why Software Cannot Audit Software (the shared failure domain that substrate-hopping turns into an escape hatch), The Verb Is Don't Erase (drift as a measured quantity, not a bug), and The Cache Line Is Not a Metaphor (the physical layer no algebraic construction reaches).
Related: The Perfect Scapegoat (what happens to accountability when the black box can't be audited) and Bureaucracy Is a Cache Miss carry the hardware-attribution thread further.
