Physics-Augmented Diffusion Modeling for planetary geology survey missions in hybrid quantum-classical pipelines

Physics-Augmented Diffusion Modeling for planetary geology survey missions in hybrid quantum-classical pipelines

Introduction: A Crater Field That Taught Me Humility

Three months ago, I was staring at a mosaic of the Jezero Crater delta, trying to reconcile two things that refused to agree: a diffusion model that generated beautiful Martian terrain, and a planetary geologist who kept telling me the terrain was "physically impossible." The generated images had craters with rim heights that violated isostatic equilibrium, sedimentary layers that dipped at angles inconsistent with the local gravity regime, and ejecta blankets that ignored the ballistic trajectory physics that govern Mars' lower gravity. My model had learned the aesthetics of planetary geology without learning its physics.

That moment sent me down a rabbit hole that combined three fields I'd been exploring separately for years: physics-informed generative modeling, quantum circuit simulation, and agentic orchestration for autonomous science. While experimenting with score-based diffusion models on lunar DEM (digital elevation model) data, I realized that the standard denoising objective — minimizing the difference between predicted and true noise — has no mechanism to enforce conservation laws, thermodynamic constraints, or morphological priors that geologists consider non-negotiable. And when I started exploring quantum sampling for the reverse diffusion process, I found that parameterized quantum circuits offered an intriguing way to represent high-dimensional probability distributions with far fewer parameters than classical networks — but only if the physics constraints were baked into the ansatz itself.

This article documents what I learned building a physics-augmented diffusion pipeline for planetary geology survey missions, where classical diffusion models are guided by differentiable physics simulators and where a hybrid quantum-classical sampler accelerates and regularizes the reverse process. I'll share the architecture, the code patterns that worked, the failure modes I hit, and why I now believe that agentic AI systems orchestrating these pipelines are the missing piece for real autonomous planetary survey missions.

Why Planetary Geology Needs Physics-Aware Generative Models

Planetary geology survey missions — whether orbital reconnaissance, rover traverses, or future autonomous landers — face a brutal data problem. Bandwidth from Mars is measured in kilobits per second during most of the sol. A rover can't stream raw hyperspectral imagery or high-resolution DEMs back to Earth for every decision. It must infer geology locally, decide where to drill, and send back compressed, decision-relevant summaries.

Generative models are increasingly used for three tasks in this regime:

1. Data imputation and super-resolution — filling gaps in DEMs and imagery caused by shadows, dust, or downlink constraints.
2. Scene synthesis for planning — generating plausible terrain variations around a rover to test traverse plans before committing.
3. Uncertainty-aware mapping — producing distributions over geological interpretations rather than single point estimates.

While studying recent work on diffusion models for remote sensing, I observed a consistent pattern: models trained purely on data produce samples that are statistically plausible but mechanically wrong. A diffusion model trained on Martian craters will happily generate a 10 km crater with a 50 m rim — geometrically impossible given the impact energy scaling laws. In a survey mission context, that's not just aesthetically wrong; it's a navigation hazard and a science-planning failure.

The core insight from my experimentation: generative models for planetary science must be constrained by the same physics that shaped the terrain they're modeling. The physics isn't decoration — it's the strongest prior available, and it's free.

The Physics-Augmented Diffusion Architecture

Let me walk through the architecture I converged on after several iterations. The pipeline has four components that interact through a shared differentiable physics layer.

1. Score-Based Diffusion with Physics Guidance

Standard diffusion models learn a score function ∇ₓ log p(x) and sample by integrating a reverse SDE. My approach augments the score at each denoising step with the gradient of a physics-based energy function:

import torch
import torch.nn as nn

class PhysicsGuidedScore(nn.Module):
    def __init__(self, base_score_net, physics_simulator, guidance_scale=0.5):
        super().__init__()
        self.base_score = base_score_net
        self.physics = physics_simulator  # differentiable
        self.gamma = guidance_scale

    def forward(self, x_t, t):
        # Learned score from data
        s_data = self.base_score(x_t, t)

        # Physics energy: E_phys(x) encodes constraints
        # e.g., crater rim scaling, slope stability, thermal inertia
        with torch.enable_grad():
            x_t.requires_grad_(True)
            energy = self.physics.energy(x_t)
            s_phys = -torch.autograd.grad(energy.sum(), x_t)[0]

        # Classifier-free style guidance toward physics-consistent manifold
        return s_data + self.gamma * s_phys

The physics energy function is where the domain knowledge lives. For crater morphology, I used a differentiable approximation of the Pi-group scaling laws relating crater diameter to rim height and depth:

class CraterMorphologyPhysics(nn.Module):
    """Differentiable energy penalizing physically implausible crater geometry."""
    def __init__(self, gravity=3.71, target_density=2900.0):
        super().__init__()
        self.g = gravity          # Mars gravity m/s^2
        self.rho = target_density # regolith density kg/m^3

    def energy(self, dem):
        # Extract local crater statistics via differentiable morphology
        # (simplified: assumes dem is [B, 1, H, W] elevation in meters)
        laplacian = torch.nn.functional.conv2d(
            dem, self._laplacian_kernel(dem), padding=1)

        # Rim height should scale ~ D^0.3 for simple craters
        # Slope stability: |grad h| < tan(friction angle) ~ 0.6
        grad_x = dem.diff(dim=-1, prepend=dem[..., :1])
        grad_y = dem.diff(dim=-2, prepend=dem[..., :1, :])
        slope = torch.sqrt(grad_x**2 + grad_y**2)
        slope_penalty = torch.relu(slope - 0.6).pow(2).mean()

        # Curvature regularity (avoid non-physical spikes)
        curv_penalty = laplacian.abs().mean()

        return slope_penalty + 0.1 * curv_penalty

Through studying the interplay between these terms, I learned that the guidance scale γ is critical: too low and the model ignores physics, too high and it collapses to a trivial flat surface (the global minimum of the slope penalty). The sweet spot for Martian DEMs was around γ = 0.3–0.7, and I found it useful to anneal γ over the diffusion timesteps — strong physics guidance early (when the sample is mostly noise) and weaker guidance late (when fine detail should come from data).

2. Hybrid Quantum-Classical Reverse Sampler

This is where things got genuinely interesting. The reverse diffusion process is, at its core, a sequence of sampling steps from a Gaussian distribution whose mean and variance are parameterized by the score network. For a planetary survey mission, the state space is enormous (a 1024×1024 DEM is a million-dimensional vector), and classical sampling is the bottleneck.

While exploring variational quantum circuits for generative modeling, I found that parameterized quantum circuits (PQCs) can represent certain high-dimensional distributions with exponentially fewer parameters than classical networks — the catch being that the distributions they represent are constrained by the circuit's entanglement structure. For diffusion sampling, this constraint turns out to be a feature: the quantum circuit's limited expressivity acts as a natural regularizer, preventing the sampler from wandering into physically absurd regions of the state space.

The hybrid sampler I built uses a small quantum circuit to generate the stochastic component of each reverse step, while the classical network provides the mean:

import pennylane as qml
import numpy as np

n_qubits = 8
dev = qml.device("default.qubit", wires=n_qubits)

@qml.qnode(dev, interface="torch", diff_method="backprop")
def quantum_noise_generator(params, latent_encoding):
    """Generate structured noise for reverse diffusion step."""
    # Encode classical latent state (compressed score features)
    for i in range(n_qubits):
        qml.RY(latent_encoding[i], wires=i)

    # Variational layers with ring entanglement
    for layer in range(3):
        for i in range(n_qubits):
            qml.RY(params[layer, i, 0], wires=i)
            qml.RZ(params[layer, i, 1], wires=i)
        for i in range(n_qubits):
            qml.CNOT(wires=[i, (i + 1) % n_qubits])

    return [qml.expval(qml.PauliZ(i)) for i in range(n_qubits)]

class HybridReverseSampler:
    def __init__(self, score_net, q_params, classical_head):
        self.score = score_net
        self.q_params = q_params
        self.head = classical_head  # projects quantum outputs to full dim

    def step(self, x_t, t, dt):
        mean = x_t + dt * self.score(x_t, t)

        # Compress x_t to 8-dim latent for quantum encoding
        latent = self.head.encode(x_t)  # [B, 8]
        q_noise = torch.stack(
            quantum_noise_generator(self.q_params, latent.T), dim=-1)

        # Expand quantum noise back to full dimensionality
        noise = self.head.decode(q_noise) * np.sqrt(dt)
        return mean + noise

In my experimentation with this hybrid sampler on lunar DEM patches, I observed two things worth sharing. First, the quantum-generated noise has correlated structure across the 8-qubit register that maps through the classical decoder into spatially coherent perturbations — this turned out to produce more geologically realistic texture than uncorrelated Gaussian noise. Second, the quantum circuit's parameter count (3 layers × 8 qubits × 2 rotations = 48 parameters) was roughly 1/1000th of the classical noise head it replaced, which matters enormously for flight software where every parameter must be validated and radiation-hardened.

A critical caveat: I ran this on default.qubit (a statevector simulator). On real quantum hardware, shot noise and decoherence would degrade the sampler's quality, and the current generation of NISQ devices can't handle the circuit depth needed for meaningful diffusion steps without error mitigation. The honest assessment from my research: hybrid quantum-classical samplers are currently a research curiosity for diffusion, but the parameter efficiency argument makes them worth tracking for flight-constrained systems.

3. Agentic Orchestration Layer

The third component — and the one I became most convinced is essential — is an agentic layer that coordinates the pipeline autonomously. A survey mission doesn't just need a generative model; it needs a system that decides when to generate, what physics constraints to apply, and whether to trust the output.

I built a lightweight agent loop using a tool-calling pattern where the LLM-based planner has access to the diffusion pipeline, the physics simulator, and a geological validation module:

class SurveyAgent:
    def __init__(self, planner_llm, diffusion_pipeline, validator):
        self.planner = planner_llm
        self.pipeline = diffusion_pipeline
        self.validator = validator

    def plan_survey_step(self, rover_state, science_goals):
        # Agent decides: impute gap? synthesize scene? map uncertainty?
        decision = self.planner.decide(
            context=rover_state,
            goals=science_goals,
            available_tools=["impute_dem", "synthesize_terrain",
                             "uncertainty_map", "abort_and_retreat"]
        )

        if decision.tool == "synthesize_terrain":
            sample = self.pipeline.generate(
                condition=decision.conditioning,
                physics_scale=decision.physics_weight
            )
            # Validate before acting on the sample
            report = self.validator.check(sample)
            if not report.physically_plausible:
                return self.plan_survey_step(
                    rover_state, science_goals)  # re-plan
            return sample
        # ... other tools

My exploration of agentic systems for science autonomy revealed an important pattern: the agent's value isn't in generating samples — it's in the closed loop of generate → validate → re-plan. The diffusion model produces candidates; the physics validator rejects implausible ones; the agent decides whether to try again with different conditioning, escalate to a human-in-the-loop, or accept the uncertainty and proceed conservatively. This loop is where the physics augmentation pays off, because the validator and the guidance term share the same physics simulator — so when the validator rejects a sample, the agent can feed that rejection signal back into the guidance scale for the next attempt.

What Broke, and What I Learned Fixing It

I want to be candid about the failure modes, because they shaped the final architecture more than the successes did.

Failure 1: Physics guidance collapsed the distribution. My first attempt used a hard constraint (project samples onto the physics-consistent manifold after each step). The result was mode collapse — every sample converged to the same smooth, featureless terrain that trivially satisfied the slope constraint. The fix was the soft energy formulation with annealing, plus a diversity term that penalized low-variance batches.

Failure 2: The quantum sampler was too slow to be useful in simulation. Each quantum circuit evaluation in the inner loop of a 1000-step diffusion process took ~2ms on the simulator, which sounds fast until you multiply by batch size and steps. I learned to pre-generate a bank of quantum noise samples and reuse them with classical interpolation — a compromise that preserved the correlated-noise benefit at a fraction of the cost.

Failure 3: The agent hallucinated geological justifications. Early versions of the planner LLM would confidently explain why a physically implausible sample was actually a "rare maar crater" or "periglacial feature." This is a known failure mode of LLM agents in scientific domains, and the fix was structural: the planner never sees raw samples, only the validator's structured report. It reasons over validated facts, not over images.

Failure 4: Domain gap between training and target terrains. A diffusion model trained on lunar mare basalts generated poor samples for Martian sedimentary terrain. My research into this revealed that physics-guided models are more robust to domain shift than pure data-driven models — the physics prior transfers even when the data distribution doesn't. But it's not a complete fix; I ended up using a small amount of target-domain fine-tuning with the physics guidance frozen.

Real-World Applications and the Road Ahead

The pipeline I've described maps onto real mission needs more directly than I initially expected. NASA's Perseverance and the planned Mars Sample Return campaign both rely on autonomous terrain assessment; ESA's ExoMars Rosalind Franklin rover's autonomous navigation would benefit from physics-constrained terrain synthesis for planning. The hybrid quantum component remains speculative for flight — current radiation-hardened classical processors outperform NISQ devices for this workload — but the parameter efficiency argument is compelling for long-duration missions where model size is constrained by memory and validation budget.

Looking forward, I see three promising directions from my research:

1. Physics-informed quantum circuits with native constraints. Instead of using a generic PQC and adding physics as a classical penalty, design circuit ansätze whose structure encodes conservation laws — for example, circuits whose symmetries correspond to the symmetries of the geological process being modeled. My early experiments with symmetry-preserving circuits showed better sample quality per parameter, but I haven't yet scaled this to realistic DEM sizes.

2. Agentic multi-model ensembles. Rather than one diffusion model, a survey agent could orchestrate an ensemble of specialized models (crater morphology, aeolian features, fluvial channels) with the physics simulator as the arbiter. This mirrors how human geologists reason — multiple hypotheses, tested against physical constraints.

3. Onboard continual learning with physics as the regularizer. A rover that encounters novel terrain could fine-tune its generative model on the fly, using physics consistency as the only supervision signal. This is the most speculative direction, but the physics-guided score formulation naturally supports it: the guidance term doesn't need labels.

Conclusion: Physics Is the Prior We Already Have

The most important thing I learned from this project is almost embarrassingly simple: for scientific generative modeling, the physics is the prior you should reach for first, before architecture search, before more data, before bigger models. A diffusion model that knows about crater scaling laws and slope stability is worth more than a diffusion model that has seen ten times more terrain, because the physics generalizes across planets, epochs, and imaging conditions in ways that data never will.

The hybrid quantum-classical component taught me something subtler: constraints on expressivity are not always limitations. The quantum sampler's restricted state space acted as a regularizer, and its parameter efficiency is a genuine advantage for flight-constrained systems — even if the current hardware isn't ready. And the agentic layer taught me that the real product of a generative model in a science context isn't the sample; it's the decision the sample enables, and that decision requires validation, re-planning, and the humility to say "I don't know, retreat and gather more data."

If you're building generative models for any physically grounded domain — climate, materials, geology, fluid dynamics — I'd encourage you to start with the energy function. Write down what your domain expert considers physically impossible, make it differentiable, and add it to your score. You'll be surprised how much of the "hard" part of generative modeling dissolves once the model knows what it's not allowed to do.

The terrain my model generates now passes muster with the planetary geologist. It's not because the model got bigger or the data got better — it's because it finally learned the one thing every geologist knows instinctively: gravity always wins.