💻 computer science

Decoupled Entropic-Geometric Planning (DEGP): Verified Conditioning and a Measured Contact-Prediction Boundary in Latent World Models

This paper introduces Decoupled Entropic-Geometric Planning (DEGP), a framework that addresses the trade-off between robust perception and stable trajectory optimization in latent space planning by combining architectural separation with analytical spectral bounds and runtime telemetry to define the operational limits of contact-conditional prediction.

Original authors: Mohsen Mostafa

Published 2026-10-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Mohsen Mostafa

Original paper licensed under CC BY 4.0 (https://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

Robots that can manipulate objects in the real world face a fundamental contradiction. To see and understand a changing environment, a robot needs a flexible, high-level understanding of the world, one that can handle unexpected shifts in lighting or texture. This kind of perception thrives on rich, complex data that captures every possible detail. However, to actually move and plan a path through that world, a robot needs a rigid, predictable mathematical structure. The equations that guide a robot's arm must be stable and well-behhaved, or the robot will lose its balance and fail. For years, researchers have tried to build a single system that does both: a neural network that learns to see the world and simultaneously learns the physics of how that world moves. The hope was that one model could handle the messy reality of perception and the strict demands of control at the same time.

A researcher set out to test whether this single-model approach could work, and to see if they could prove mathematically that their system would remain stable. They developed a new framework called Decoupled Entropic-Geometric Planning. Instead of forcing one network to do everything, they split the job into two distinct parts. The first part, the "perception" engine, was trained only to organize visual information into a clean, structured format, ignoring how the world moves. The second part, the "control" engine, was trained separately to predict how that organized information changes over time, with strict rules to ensure its mathematical predictions remained stable. They also built a safety system, a kind of digital watchdog, that constantly checks the math to ensure the robot's internal map doesn't become too distorted to use.

The researcher began by proving that their split approach worked exactly as the math predicted. In controlled simulations, they showed that by keeping the perception and control parts separate, they could prevent the mathematical instability that usually plagues these systems. They measured a specific property of the robot's internal map, known as its condition number, which acts like a measure of how easily the robot can calculate a path. In their system, this number stayed low and steady, regardless of how complex the map became or how far into the future the robot tried to plan. This confirmed that their architectural separation successfully isolated the messy work of seeing from the precise work of moving. They also verified that their safety checks could detect when the system was about to drift out of bounds, proving that the theoretical guarantees held up in practice.

However, when the researcher moved from simulations to a real-world task involving a robot arm manipulating a T-shaped block, the results were starkly different. Despite having a mathematically perfect and stable internal map, the robot failed to complete the task in every single attempt. They ran fifty trials under various conditions, and in none of them did the robot successfully move the block to its goal. The robot's internal map was stable, but it was useless for the job. The researcher then spent a significant amount of time investigating why this happened, treating the failure not as a bug, but as a discovery of a hidden boundary. They systematically swapped out different parts of the system, trying different planning algorithms, different ways of feeding data to the robot, and even different versions of the control engine.

The investigation revealed a specific gap between what the robot could see and what it could use. The robot's perception engine was successfully capturing information about the block's position and its contact with the table; this information was present in the robot's internal map. However, the part of the system responsible for predicting the future was completely blind to this information. It failed to learn that when the block touched the table, its movement would change. The robot's internal model predicted that the block would slide smoothly forever, even when it was physically blocked. Furthermore, the researcher found that the way they translated the robot's internal map back into a physical goal was also flawed. Even when they replaced the learned model with a perfect, known physics engine, the robot still failed if it used the same flawed translation method. This proved that the failure was not just about the robot's ability to predict the future, but also about how it interpreted its own internal state. Specifically, the study identified a two-part explanation for the failure: a gap in predicting contact-conditional dynamics, combined with a limitation in the "probe-decoded cost" used to guide the robot's actions.

The study concludes that simply separating the perception and control systems is not enough to solve the problem of robotic manipulation. While the researcher successfully built a system that was mathematically stable and verifiable, they uncovered a deeper issue: the information required to solve the task was present in the robot's perception, but the learning process failed to teach the control system how to use it. The robot knew where the block was, but it did not know how to move it when it hit an obstacle. The researcher did not find a solution to this specific failure in this study; instead, they mapped the exact limits of where the current technology breaks down. They demonstrated that a robot can have a perfect, stable internal map and still fail to act because the map does not contain the specific, usable rules of physics needed for the task. The work serves as a rigorous diagnostic, showing that the path to successful robotic manipulation requires not just stable math, but a way to ensure that the robot's understanding of the world actually includes the physical constraints it must obey.

Technical Summary: Decoupled Entropic-Geometric Planning (DEGP)

Problem Statement

Robotic perception and control impose conflicting requirements on learned representations. Vision backbones deployed in industrial environments require high-entropy, overcomplete features to survive domain shifts (often achieved via self-supervised objectives). Conversely, gradient-based planners require strictly conditioned geometries to backpropagate through learned dynamics models without exploding condition numbers over long horizons. Training both demands within a single network creates a fundamental tension: geometric penalties distort the representation, while representational freedom destabilizes planner conditioning. This often manifests empirically as either representational collapse or planning failure.

Methodology: Decoupled Entropic-Geometric Planning (DEGP)

DEGP addresses this tension through strict architectural decoupling rather than compromise. The framework separates the system into three distinct components:

The Entropic Encoder ( $f_\theta$ ): Trained with a "blind perception" objective using only a variance-covariance loss (Eq. 1). It enforces spherical covariance to prevent collapse but contains no reconstruction, prediction, or invariance terms. Consequently, it preserves information but does not organize it for dynamics-relevant structures (e.g., contact).
The Geometric Predictor ( $g_\phi$ ): Trained on detached latents (stop-gradient from the encoder) with a "sharp control" objective. It utilizes a residual parameterization ( $g(z, a) = z + f(z, a)$ ) initialized near-identity, combined with a Jacobian penalty ( $\lambda_2$ ) to enforce $\|J_g - I\|_F \approx 0$ . This ensures the predictor remains locally linear and well-conditioned.
The Asymmetric Planner: Optimizes a leashed quasi-metric cost. The cost function includes a ReLU-difference projection to create asymmetry and a $\mu$ -leash term ( $\mu \|z_T - z_{goal}\|^2$ ) to guarantee stability and prevent the planner from entering "blind cones" where the cost gradient vanishes.

Runtime Contract: The system employs a telemetry-based runtime contract involving pre-deployment gates (checking condition number $\kappa$ , spectral bounds $\epsilon$ , and latent scale), continuous monitoring of conditioning budgets, and a watchdog/fallback mechanism.

Key Contributions

1. Architecture and Theory

Decoupled Stack: A formal separation of encoder (variance-preserving) and predictor (geometry-enforcing) with stop-gradient isolation.
Conditioning Theorems:
- Theorem 1: Proves that under the condition $\|J_g - I\|_F \le \epsilon < 1$ , the condition number of the unrolled state Jacobian is bounded by $(\frac{1+\epsilon}{1-\epsilon})^{2T}$ , independent of latent dimension $K$ .
- Corollary 2: Establishes an $\epsilon \cdot T$ budget, showing that planning stability is maintained only if the product of the spectral bound and horizon remains below a threshold (e.g., $\epsilon \cdot T \lesssim 0.5$ ).
- Theorem 2: Proves that the $\mu$ -leash ensures a unique global minimizer and geometric contraction of the error, preventing stationary points outside a defined leash ball.

2. Measured Conditioning and Verification

Statistical Flatness: Empirical results confirm that the condition number $\kappa$ remains statistically flat across latent dimensions $K \in \{64, 128, 256\}$ (verified via TOST equivalence testing with 30 paired seeds), whereas non-decoupled baselines exhibit exponential growth.
Executable Verification Suite: A twelve-check command-line suite maps every theoretical result to a pass/fail test, verifying gradient isolation, leash geometry, and Jacobian bounds with documented inputs and tolerances.

3. Attributed Deployment Boundary (Negative Results)

The paper reports a pre-registered deployment study on the Push-T environment where all success hypotheses were falsified (0/50 successes across all conditions).

Attribution Battery: An 18-condition diagnostic battery isolated the failure causes.
Findings: The failure is attributed to a two-component gap:
1. Contact-Conditional Prediction Gap: The self-supervised latents (Eq. 1) retain contact information (decodable via a probe with $R^2 \approx 0.65-0.70$ ), but the learned predictors fail to exploit this information selectively (selectivity ratio $\approx 1.0$ , indicating contact-blindness).
2. Probe-Decoded Cost Limitation: Even with oracle dynamics, the use of a linear probe-decoded cost suppressed movement, suggesting the cost formulation itself is a limiting factor.
Non-Binding Factors: The study found that planner family/order, perception input, and the conditioning leash were not the binding failure factors in this regime.

Results Summary

Stage 1 (Synthetic/Certification): The certified predictor exhibits dimension-invariant conditioning and satisfies the $\epsilon \cdot T$ budget. Gradient-based planning converges in 2 iterations on synthetic dynamics, while sampling planners (CEM) fail at high dimensions (the "dimensionality wall").
Stage 2 (Real Images/Transfer): When applied to real images (MimicGen), the "frozen encoder + DEGP predictor" configuration occupies the "deployable corner" of modularity and conditioning, though it slightly exceeds the $\epsilon \cdot T$ budget guideline ($0.54$ vs $0.5$).
Stage 3 (Deployment/Attribution):
- Success Rate: 0/50 episodes succeeded in the Push-T environment for all tested conditions (CEM, PGD, various cost variants, and model versions).
- Movement: T-block movement was negligible (0.0–1.1 px).
- Model Journey: Iterating the predictor (v1 to v4) improved contact capture ratios (from under-prediction to over-amplification) but failed to achieve selectivity (contact-blindness persisted).
- Controls: Removing the leash (B1b) violated the conditioning budget but did not change the deployment outcome (0/10 success), confirming that conditioning certification alone does not guarantee task competence in this regime.

Significance and Claims

The paper positions its contribution as methodological and diagnostic rather than a demonstration of task success.

Verified Conditioning: DEGP provides a framework where conditioning claims can be explicitly stated, verified via executable checks, and monitored at runtime.
Measured Boundary: The primary contribution is the experimentally mapped deployment boundary. The study demonstrates that structural decoupling and geometric conditioning are insufficient to bridge the gap between "information present" in a representation and "information used" by a learned dynamics predictor.
Negative Results as Data: The paper treats the 0/50 failure rate not as an omission but as a measured datum, using a pre-registered diagnostic battery to localize the failure to the interaction between contact-conditional prediction errors and the cost signal.
Open Questions: The necessity of the asymmetric metric and the deployment necessity of conditioning certification remain open. The paper identifies the next technical problem as developing objectives that make decodable contact information learnable by predictors over high-entropy latents.

The study concludes that while DEGP successfully isolates gradient interference and guarantees geometric properties, it does not automatically solve the problem of learning dynamics that exploit those properties for contact-rich manipulation.