🤖 AI

Certified Access: Test-Time Compute on Conservative Physics-Structured AI Memory

This paper proposes and verifies a theoretical framework for test-time compute on physics-structured AI memory, where mechanisms like Lorentz squeezing and gated canonical translations provide exact phase-volume and energy certificates to resolve reachability failures while maintaining stability guarantees.

Original authors: Pratik Jawahar, Riccardo Maggioni, Jonas Petersen, Matteo Cozzi, Gian-Alessandro Lombardi, Marek Gajewski, Camilla Mazzoleni, Federico Martelli

Published 2026-10-30

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Pratik Jawahar, Riccardo Maggioni, Jonas Petersen, Matteo Cozzi, Gian-Alessandro Lombardi, Marek Gajewski, Camilla Mazzoleni, Federico Martelli

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the modern world of artificial intelligence, computers are learning to think by processing vast amounts of information, but they often struggle with a specific problem: knowing when to stop. As these systems grow more complex, they need a way to decide if they have thought enough to give an answer or if they need to keep working. This is a bit like a person trying to solve a puzzle; they might need to look at a piece a few more times to be sure, or they might need to step back and look at the whole picture from a different angle. For years, engineers have added extra steps to these computer programs to help them decide, but these steps have usually been treated as mysterious black boxes. The computer tries a few more calculations, and if the answer looks good, it stops. If not, it keeps going. The problem is that no one really understood the rules of the road for these extra steps. They didn't know exactly what the computer was doing to its internal state, how much energy it was using, or whether it was accidentally deleting important information along the way.

A team of researchers from CERN, ETH Zurich, and Forgis AG has set out to map these hidden rules. They focused on a specific type of artificial memory that behaves like a physical system, where information is stored as a kind of motion rather than just static data. In this system, the computer's memory is like a ball rolling on a landscape of hills and valleys. The shape of this landscape is learned by the computer, and the ball rolls according to strict physical laws. The researchers wanted to know what happens when they force the computer to take extra steps to find a specific piece of information. They discovered that by treating these extra steps as physical movements, they could prove exactly how much energy was needed, how much information was preserved, and what would happen if the computer tried to jump to a distant part of its memory.

The researchers built their study around a concept called a "latent dynamics model," which is a way of organizing memory so that it follows the rules of physics. Imagine the computer's memory as a room where every piece of information has a specific location and a specific speed. When the computer wants to find something, it doesn't just search a list; it rolls a ball across the floor of this room. Usually, the ball rolls until it settles in a valley, which represents the answer. But sometimes, the answer is trapped behind a high hill, or it is located in a completely different room that the ball cannot roll to. The researchers identified two main ways the computer could fail to find the answer. The first is a "reach failure," where the target is simply too far away to be reached by rolling. The second is an "escape failure," where the target is nearby but blocked by a barrier that the ball doesn't have enough energy to climb over.

To solve these problems, the team proposed two new methods that act like certified tools for the computer. The first tool is designed to help the ball climb over a hill. They call this a "Lorentz squeeze." Instead of just pushing the ball harder, which might waste energy or destabilize the system, this method gives the ball a precise, calculated boost. The researchers proved that this boost adds a specific, limited amount of energy to the system. If the computer needs to jump a little further, it uses a little more energy; if it needs to jump much further, the energy cost grows, but it does so in a predictable way. This ensures that the computer doesn't accidentally burn through its resources or lose control of the memory.

The second tool is for when the target is in a different room entirely, too far to reach by rolling. The researchers created a "gated channel," which is essentially a teleportation bridge that connects two specific points in the memory. Unlike the rolling motion, this bridge moves the information instantly from one spot to another. The most important discovery here is that this bridge is perfectly safe for the information it carries. The researchers showed that when the computer uses this bridge, it does not lose any of the subtle details stored in the memory. It is like moving a delicate object from one shelf to another without shaking it or dropping a single grain of dust. They also proved that the bridge does not distort the space around it, meaning the computer can use it without messing up the rest of its memory.

However, the researchers were careful to show that these tools are not magic. They tested their ideas on a controlled, simulated environment where they could measure everything exactly. They found that while the tools worked perfectly in theory, they had strict limits. For instance, the teleportation bridge only works if the computer is allowed to freeze the rules of the bridge for the duration of the jump. If the rules change while the jump is happening, the safety guarantees disappear. They also found that simply moving information around is not enough; the computer must also be protected from falling off the edge of its memory world. If the computer tries to jump to a place where the landscape is undefined, the information can escape and be lost forever. To prevent this, the computer needs a safety check that ensures it only jumps to safe, defined areas.

When the team applied these ideas to a real, learned memory system, they saw interesting results. They built a system that could decide for itself when to stop thinking and when to use these extra tools. In cases where the memory was small and the computer was still learning, this self-regulating system saved a significant amount of computing power, reducing the number of steps needed by nearly five times. As the memory grew larger, the savings became smaller, but the system still worked. They also tested how well these tools handled noise, or confusion in the input. They found that while the memory itself remained perfect, the decision-making part of the system became much less reliable when the input was noisy. This suggests that while the physical rules of the memory are solid, the computer's ability to decide when to use them is still fragile.

The study concludes that treating test-time computation as a physical process allows scientists to write down exact rules for how computers use extra thinking time. They proved that you can add energy to cross barriers, and you can build bridges to reach distant memories, but you must do so with strict adherence to physical laws to avoid losing information. The work does not claim to have solved all the problems of artificial intelligence, nor does it promise that these methods will make every computer smarter immediately. Instead, it provides a clear, verified map of what is possible and what is dangerous when a computer decides to think a little longer. The main achievement is not a new record on a leaderboard, but a formal understanding of the costs and guarantees of these extra steps, turning a black box into a transparent, rule-bound process.

Technical Summary: Certified Access on Conservative Physics-Structured AI Memory

Problem Statement
Current test-time compute mechanisms in deep learning (e.g., learned halting, confidence-gated early exits, and mixture-of-experts routing) are typically deployed as black-box additions to feedforward stacks. While these methods adaptively allocate inference compute, they lack structural guarantees regarding how extra computation alters the model's latent state. Specifically, there is no formal account of what the additional compute "buys" (e.g., reachability, stability) or what it costs in terms of the model's stability guarantees. This paper addresses the need for a theoretical and empirical framework that provides structural certificates for test-time compute on Latent Dynamics Models (LDMs) used as memory.

Methodology
The authors propose a framework where the memory is a Conservative Latent State $(q, p)$ , produced by an encoder and evolved via a learned, separable Hamiltonian $H(q, p) = T(p) + V_\theta(q)$ . The dynamics are advanced using a damped symplectic integrator (velocity-Verlet). In this regime, test-time compute is defined as access to a defined phase space, where every access mechanism must carry a physical certificate.

The framework partitions reachability failures into two distinct categories:

Kinematic Reach Failures: The target lies outside the causal box $C_T$ (the maximum distance reachable via standard dynamics).
Energetic Escape Failures: The target is inside $C_T$ but shielded by a potential barrier that the latent energy cannot cross.

To resolve these, the authors introduce and analyze two mechanisms:

Lorentz Squeeze ( $S^{(M)}_\zeta$ ): A mass-weighted hyperbolic rotation applied to resolve escape failures. It injects bounded, re-absorbable energy to cross potential barriers.
Gated Canonical Translation: A one-step channel across the causal box to resolve reach failures. It applies a constant translation $q \to q + \Delta$ with a frozen gate.

The core of the methodology is the derivation of three certificates for these mechanisms:

Volume Certificate: The Jacobian determinant ( $\det J$ ) must be exactly 1 (symplectic) to preserve phase volume.
Energy Certificate: The energy change must be bounded and quantifiable.
Latch-Transport Law: The transformation of stored content in protected continuous-symmetry directions (Goldstone charge).

These certificates are verified on a designed analytic testbed (2D and 4D latent spaces) and then evaluated on learned associative memories (Causal Learning Units, or CLUs).

Key Contributions
The paper makes six specific contributions:

Formalization of Failure Modes: Distinguishing between kinematic reach failures (requiring non-local jumps) and energetic escape failures (requiring energy injection), each requiring distinct mechanisms with different certificates.
Verification of the Certificate Stack: Empirical verification on an analytic testbed showing that:
- The Lorentz squeeze cures escape with bounded injection, though energy grows exponentially with rapidity and quadratically with excess distance.
- The gated channel resolves reach failures with $\det J = 1$ exactly, zero energy cost (on matched channels), and exact latch transport.
Empirical Measurement of Latch Transport: Demonstrating that untrained state-replacing maps have $\det J = 0$ , annihilating phase volume and erasing stored charge. In contrast, the certified gated channel transports charge with preserved spread. The paper notes that volume preservation alone is insufficient; a matched channel is required for transport.
Calibrated Compute Rationing: Implementation of a self-calibrating gate on learned memories that reduces relaxation steps by $4.81 \pm 0.44\times$ at low capacity ($kv16$) under a 400-epoch budget. The value is in rationing, not baseline accuracy improvement.
Scaling Limits of Non-Local Routing: Verification that a direct one-hop non-local edge maintains a flat FLOP count as distance grows, unlike multi-hop diffusion. However, a parameter-matched, physics-free router outperforms the energy-gated version in both FLOPs and accuracy.
Capacity and Epoch-Budget Map: Mapping the rationing gate across capacity and training budgets. Results show that beyond $kv64$, performance is constrained by the epoch budget rather than hard capacity limits. Gate accuracy degrades sharply under evaluation cue noise, while storage fidelity remains high.

Results

Analytic Testbed: The certificates hold to machine precision. The Lorentz squeeze extends reach but requires energy that scales with the square of the excess distance. The gated channel achieves reach with zero energy cost on symmetric potentials and preserves the Goldstone charge.
Learned Memories: The compute rationing gate effectively reduces steps for clean retrieval tasks (MQAR) but does not improve general accuracy over a full-budget baseline.
Routing: While the certified channel provides a flat FLOP cost for long-distance routing, a "physics-free" learned router outperforms the energy-gated mechanism in accuracy and efficiency.
Stability Limits: The paper demonstrates that $\det J = 1$ and zero energy change are not sufficient for Bounded-Input Bounded-Output (BIBO) stability. A "coercive-component screening" is required to prevent trajectories from escaping to infinity, even if the jump itself is symplectic.

Significance and Claims
The paper explicitly states that its main contribution is the formalization and verification of the certificate stack, not benchmark performance or leaderboard dominance.

The work provides a theoretical framework where test-time compute mechanisms are not black boxes but carry physical guarantees (volume conservation, bounded energy, latch transport).
It highlights that these guarantees are conditional: they hold for damping frozen within a step and specific testbed potentials, but do not automatically extend to the full learned system with state-dependent governors.
The authors emphasize that while the mechanisms enable "certified access," they do not claim to solve all stability issues (e.g., BIBO stability requires additional screening) or to outperform standard physics-free routing in all metrics.
The implementation reveals design trade-offs: achieving exact value fidelity, amplitude-independent address hold, and amplitude-independent read latency simultaneously is not achieved in the current implementation, representing a trade-off rather than a proved incompatibility.

In summary, the paper shifts the paradigm of test-time compute from heuristic escalation to a physics-structured approach where every access mechanism is accompanied by a verifiable mathematical certificate regarding its impact on the latent state's geometry and stability.

Technical Summary: Certified Access on Conservative Physics-Structured AI Memory

More like this