Invert the transform:
A log-sum-exp of Gaussian-sampled terminal costs.
Numerically evaluated in a log-domain-stable form (log-mean-exp) to avoid overflow/underflow.
arbitrary evaluation states — laid on a grid or scattered — each with its own fresh samples.
The value at a query point is a scalar reduction over samples. Embarrassingly parallel across both states and samples.
The spatial gradient (co-state) has a closed Gaussian-expectation form:
A weighted-mean shift: the gradient points from toward the exponentially-weighted centroid of the samples.
No finite differencing, no stored field — the co-state is a byproduct of the same samples.
This gradient is (up to constants) a score function . Hold that: it is the entire bridge to diffusion in Part 7.
Datum is continuous, strictly positive, bounded above by , decaying at infinity.
⇒ the heat solution is the unique bounded one; the integral converges absolutely; the Gaussian expectation is genuine and unbiased.
Only is required (bounded target); no upper bound on .
The estimator drawing over all of is unbiased for the quantity inside the logarithm — the foundation for the concentration bound of Part 4.
: it grows without bound in flat regions and vanishes and flips sign where optimal dynamics run tangent to the level set (the barrier).
The zero of is a removable singularity of the estimator: as ,
i.e. the log-sum-exp gracefully degenerates to the Gaussian mean of the terminal data — the correct pure-diffusion limit ( reduces the PDE to the heat equation).
log1p-stable form and clip to .The coefficient's pathologies are analytically understood and numerically tamed — clipping is itself a bounded, priced perturbation (next slide).
Run Algorithm 1 with the regularized coefficient
equivalent to running it unregularized for the perturbed Hamiltonian , which satisfies a uniform bound
so the induced value-function perturbation is at most .
Regularization cures the flat-interior blow-up at a quantified, uniform price — no hidden instability.
Steps (2)-(4) are all Gaussian-expectation reductions over samples.
Convergence typically in ≤ 20 iterations (empirically 12-15).
Every line is grid-free. The only state carried between iterations is the coefficient field at the evaluation states.
= i.i.d. Gaussian draws used independently at each evaluation state to form the estimators.
Resampled fresh at every evaluation state and every Picard iteration.
= the evaluation states where is queried — carry no randomness, may be a uniform grid or scattered arbitrarily.
Total randomness per iteration: draws.
The zero level set is recovered by evaluating at the states and isocontouring at level zero (marching cubes) — a deterministic post-process consuming no further samples.
The solve is grid-free; the grids that appear in results are evaluation windows for visualization and error measurement, not sampling constraints.
| Grid level sets | HJ-Gauss | |
|---|---|---|
| Representation | Stored field on grid | Gaussian samples per query, -vectors |
| Memory | ||
| Discretization | Cartesian grid + marching cubes to solve | None (grid-free solve) |
| Query states | Tied to grid | Arbitrary / scattered |
| Parallelism | Grid array ops | Over states and samples |
Memory now scales with sample budget and dimension, not with a grid raised to the dimension. This is the whole contribution in one line.
Making the Gaussian estimator work in high dimensions.
The estimators are a ratio of exponential-weight expectations, e.g. the gradient's numerator/denominator both carry .
In high dimensions (or small ), is large over the kernel support, so the denominator is carried by a rare event.
The weights collapse onto a few samples → the ratio's variance explodes; the effective sample size crashes.
Naive Gaussian sampling is unbiased but can be catastrophically high-variance right where we need it (high , small ). We fix it with importance sampling.
Replace () by a shifted proposal .
Reweight by the density ratio
which leaves every expectation unbiased.
We move the samples to where the integrand has mass, then correct via the ratio. Bias is untouched; variance can collapse by orders of magnitude.
The zero-variance proposal is proportional to the integrand itself.
Its first-order Laplace / Gaussian approximation gives the shift
The previous Picard iterate hands the sampler its drift for free. Reachability and importance sampling become the same computation — the value gradient is the optimal sampling direction.
: weights well-spread → estimate certified.
: weight degeneracy → flag, increase , raise , or re-tilt.
ESS is a free, per-query health check: it tells you when to trust the estimate and why it failed when it does.
Concentration · Contraction · Residual · Total Error · Certificate · Robustness.
The distance from the computed field to the true inviscid viscosity solution decomposes into four independently-controlled sources:
| Source | Controlled by | Scaling |
|---|---|---|
| Iteration (Picard truncation at ) | More iterations | |
| Monte-Carlo (finite ) | More samples | |
| Quasi-linearization residual | Surrogate fidelity (not effort) | Floor |
| Viscosity (finite ) | Smaller |
Three of four shrink with computational effort; the residual is a property of the surrogate and sets the floor. We now bound each.
Fix phase and frozen ; assume on the sampling support. With , , , , , and :
Bounded weights ⇒ Hoeffding.
Rate is the standard , independent of state dimension — the crux of the scalability claim.
Dimension enters the cost per sample, not the number of samples for a target accuracy. That is how we beat .
to guarantee error with probability .
The accuracy gain from shrinking and the sample cost pull in opposite directions. This Hoeffding bound is loose; the next slide tightens it, and experiments sit far below it.
Bernstein: when , a variance-aware tail bound gives strictly tighter concentration than Hoeffding.
Jensen: the loose lower bound can be replaced by , substantially reducing the required .
Importance sampling (Part 3) attacks the same variance directly.
The pessimistic is a worst-case artifact of Hoeffding + crude bound. In practice suffices at .
Fix evaluation states and time ; let be a stable gradient-reconstruction operator, .
Coefficient-update map: .
Frozen-coefficient heat-kernel map:
The whole method is a fixed-point iteration of a composed map on with the sup-norm. Contraction ⇒ convergence.
On a closed admissible set (sup-norm), assume:
Non-degeneracy (item 2) holds on the tube band where the gradient is bounded away from zero — where the barrier lives. Outside, use the regularized coefficient.
is a contraction on ⇒ unique fixed point , and for any :
with the a posteriori estimate
The residual you watch (successive-iterate change) bounds the error you cannot see (distance to ). That is the a posteriori estimate — a runtime stopping certificate.
The theorem is about the frozen-coefficient numerical map, not the original nonlinear PDE.
The fixed point solves the viscous HJ equation with replaced by its quadratic surrogate at .
iff (then , ).
For general , the two differ by the quasi-linearization residual .
We do not claim unconditional global convergence to the true HJ solution. We claim geometric convergence to a surrogate fixed point, plus a bound on the gap — next.
With converged coefficient , coefficient-variation bound , value bound :
— contracts as the surrogate gradient tracks the true one.
— governed by coefficient variation .
Proof idea: solves the heat equation with a source (Lemma); Duhamel + heat-semigroup -contraction bounds ; mean-value theorem for converts back to .
The bound vanishes in the quadratic case (, ) and is largest where turns over sharply — the usable-part boundary.
Vanishes when : recovers the closed-form Cole-Hopf.
Governed by , the variation rate of the converged coefficient — largest near the barrier where the Hamiltonian-to-gradient ratio shocks.
Algebraic part : the residual contracts as the Picard iteration refines the co-state.
Certifies smallness where is slowly varying; offers no reprieve where it is not.
This is why experimental errors concentrate at the zero-level-set boundary — the theory predicts the location of the worst error.
Chaining all four sources by the triangle inequality:
Bias-variance tradeoff in : viscosity bias as , but MC variance .
Balancing the two nontrivial -dependent terms yields the optimal
slower than plain MC but dimension-robust and scalable.
A single decomposition tells you how to spend budget: iterate to kill , sample to kill , choose , and accept the residual floor.
Let be the total error budget. Declare state :
SAFE only if ;
UNSAFE only if ;
UNDETERMINED otherwise ().
With probability : no unsafe state is certified safe and no safe state is certified unsafe; all classification error is confined to a declared band of width about the boundary.
The certificate errs on refusal, never on admission.
This is the accuracy quotation: worst-case sign-correctness with an explicit abstention band, not an average that flatters the interior.
The scheme is stable under small perturbations of the Hamiltonian and terminal cost (robustness theorems, appendix): perturb by in sup-norm ⇒ value perturbed by (Duhamel/comparison).
Consequence: perfectly known dynamics and terminal costs are not required — real-world models with bounded error still yield certified-with-margin sets.
The coefficient-clipping and regularization perturbations are of this priced form.
The method degrades gracefully and quantifiably under model error — a prerequisite for deployment on real robots with imperfect models.
Rockets, Dubins, a 45D game, and birds.
Hardware: single CPU (Intel i7-14700K, 20 cores, 31 GiB RAM, Ubuntu 22.04); JAX on CPU backend
— Consistent with the memory-frugality claim.
Replication: Each experiment re-solved with 30 independent Monte-Carlo seeds;
Figures show one representative seed for clarity; tables report full 30-seed statistics. Multiplicity-controlled reporting throughout.
(a) paired Wilcoxon of 30-seed-averaged MC field vs grid reference;
(b) one-sided -test that per-seed lies below the Crandall-Lions bound ;
(c) cross-condition Mann-Whitney (Rockets vs Dubins; speed regimes).
Figures show one representative seed for clarity; tables report full 30-seed statistics. Multiplicity-controlled reporting throughout.
Rockets launch game1: two identical rockets — pursuer , evader — on the - plane, thrusts , relative orientation . Capture when .
Dubins two-car game (Merz): relative , symmetric turn-rate bound.
Both are 3D relative-state games; the BRT is a 3D tube, visualized as 2D slices at fixed .
Target: -ball of capture radius ; horizon ; ; (rockets) / (Dubins) samples per iteration.
These are the canonical HJ-Isaacs benchmarks — and the Dubins game is the pairwise MAPF conflict of Part 6.
1 Dreyfus 1966

Relative geometry: evader fixed at the origin (accel. , control , gravity ); pursuer at relative orientation on the plane. — HJ-Gauss (Molu et al., 2026).

Air3D relative coordinates with the evader fixed at the origin: relative position and relative heading ; turn-rate-bounded pursuer vs evader. — LevelSetPy (Molu, ACM TOMS 2025 / IEEE CDC 2024).

slices at : LevelSetPy grid (top) · HJ-Gauss MC (middle) · pointwise error (bottom). — HJ-Gauss (Molu et al., 2026).

LevelSetPy grid (top) · HJ-Gauss MC (middle) · error (bottom). — HJ-Gauss (Molu et al., 2026); LevelSetPy (Molu, TOMS 2025 / CDC 2024).
| System | (rad) | MC time (s) | Iters | ||
|---|---|---|---|---|---|
| Rockets | 12 | ||||
| Rockets | 12 | ||||
| Rockets | 12 | ||||
| Dubins | 15 | ||||
| Dubins | 15 | ||||
| Dubins | 15 |
Reference: LevelSetPy grid interpolated to a evaluation grid.
Holm-Bonferroni one-sided -test rejects at in every condition.
Sampling-plus-iteration error is statistically well inside the viscosity budget — not merely numerically.
The Crandall-Lions bounds the inviscid-vs-viscous sup-distance; the table measures MC-vs-grid in — different currencies, compared with care.
Averaging does not equal agreement: a paired Wilcoxon of the 30-seed-averaged MC field vs the grid rejects equality at everywhere — a systematic quasi-linearization residual remains (Theorem, Part 4).
Dubins reaches (smooth interior); and rockets sit ~- (share of grid near the coefficient-turnover boundary).
- driven by the zero-level-set boundary where is maximal — where the residual term predicts.
The report is Corollary (conservative certificate): sign-correctness outside an abstention band; flatters the interior, is dominated by the declared-undetermined band.
Rockets are asymmetric between and : the gravity term gives a drift at but at .
Holm-Bonferroni test over 30 seeds detects this asymmetry for Rockets () but not for the gravity-free Dubins vehicle ().
The method resolves a genuine physical effect, and the statistics correctly find it present where physics says it should be and absent where it should not. Validation, not just fitting.
15 rockets (14 pursuers, 1 evader), state : each agent , control .
Dynamics ; target .
Three regimes: evader faster ( vs ), balanced (/), pursuers faster ( vs ).
A -point grid would need cells; HJ-Gauss operates at ≈ 7.2 MB per iteration.
This is the flagship: a reachability computation grid solvers cannot even represent, done on a single CPU in seconds.
| Case | Iters | Residual | Wall-clock (s) | ||
|---|---|---|---|---|---|
| Evader faster | 2.0 | 1.0 | 15 | ||
| Equal speed | 1.0 | 1.0 | 15 | ||
| Pursuers faster | 1.0 | 2.0 | 15 |
Memory constant at 7.2 MB/iteration; residuals below (indeed ~) → near-zero Picard residual floor.
Min-max Hamiltonian evaluates in closed form (box-constrained control ⇒ sign structure), so each iteration is arithmetic and memory.
Pairwise Holm-Bonferroni Mann-Whitney: no significant residual difference between speed regimes () → floor set by , not game parameters.
At there is no grid reference; the report is measurable quantities — iteration stability, memory, wall-clock — i.e. scalability, not certified accuracy.
3D benchmarks floor at -; the 45D game floors at - — two orders of magnitude lower.
Reason: the residual floor tracks proximity to the coefficient-turnover region (the shock-prone barrier), not dimension per se.
45D evaluation states are drawn uniformly over per coordinate — with small probability of landing near the boundary — so the average residual is small.
A subtle but important message: error concentrates geometrically (at the barrier), not dimensionally. High dimension is not inherently high error.
3D isosurface over points: 129.4 s (rockets, single CPU) vs 1.3 s for the dense -point LevelSetPy grid.
Per-iteration memory: ≈ 0.6 MB (MC, k, ) vs ≈ 1.5 MB (grid value+gradient).
In low dimensions () grids win — smaller constant, no sampling variance.
The Monte-Carlo overhead becomes favorable where grid storage becomes prohibitive ().
The two paradigms are complementary, not competing. Use grids where they fit in memory; use HJ-Gauss where they cannot.
Certify 100,000 European starlings (Sturnus vulgaris) as 4D aerial Dubins vehicles under predator attack.
Structure (explicit): the murmuration is partitioned into flocks; each flock has its own value function; the population safe set is the aggregation of per-flock zero sublevel sets — many coupled low-D games, not one joint high-D PDE.
Because the solve is grid-free, the value-function solve is independent of bird count; the population enters only through parallel per-bird certification — the operational content of at agents.
Two curses dodged at once: dimensionality (grid-free solve) and agent cardinality (per-flock decoupling + parallel evaluation).

2,000 of 100,000 birds (colored by heading) with 7 flock centers (stars) and their capture discs (dashed). Black contour is the certified safe-set boundary at : an annular cordon around a protected core. — HJ-Gauss (Molu et al., 2026).
Backward time runs outward from the capture set: the certified safe set of the attacked flock grows and changes topology.
Green crosses and dashed circles are the seven attacking predators with their capture discs.
Blue interior = certified safe; the black curve is the boundary.
A safety certificate for agents, as one evolving surface.

Same solve, six instants. A hole persists in the safe set (, cordon) through ; by it has closed (, cohesion). — HJ-Gauss (Molu et al., 2026).
The certificates recover the field-documented collective repertoire as topological events of the reachable set, compressed to three integers per time step :
| Behavior | Topological signature | Marker |
|---|---|---|
| Vacuole nucleation (predator penetrates) | Drop in Euler characteristic | Threshold crossing in |
| Defensive cordon (protected core) | Annular safe set, first Betti number | transition |
| Flock fragmentation | Rising connected-component count | Component-count jump |
The triple tells an operator not merely that safety is being lost but how — nucleation vs cordon vs split. Safety posture as a 3-integer summary.
steps while drops at the same : one event, two independent witnesses.
holds at throughout, so this flock never fragments.
Vacuole nucleation is the reverse event: a predator penetration attaches a 1-handle and drops by one.
Three integers per tick say whether safety is being lost, and how.
Real starling responses to predation: cordon, tube, funnel, and split.
Each one appears in our certificates as a topological signature of the safe set, and none of them is a hand-coded rule.
The certificate reproduces a documented repertoire from dynamics and the game alone — which is the reason to trust it on a floor, where the repertoire is congestion, yielding, and deadlock instead.
Fragmentation event, . Field murmuration imagery as reproduced in HJ-Gauss (Molu et al., 2026).
The reason this talk is for the autonomous mobility team.

Storage blocks separated by single-cell travel corridors, task endpoints on the border columns — the RHCR fulfillment-warehouse map family (Li et al., AAAI 2021). CBS/ECBS resolve the two classical conflict types marked above.
Vertex conflict : two agents occupy the same cell at the same timestep.
Edge (swap) conflict : two agents traverse the same edge in opposition — the head-on case in a one-cell corridor.
CBS branches on a conflict, adds a constraint to one agent, and re-plans that agent's shortest path; ECBS bounds suboptimality; RHCR applies this inside a rolling window.
Every one of these predicates is a statement about cells and timesteps.
Nothing in this vocabulary mentions turn radius, actuation lag, or localization error.

CCBS (Andreychuk et al., IJCAI 2019) replaces integer timesteps with continuous time: agents are discs moving along straight edges with arbitrary durations, and conflicts become unsafe time intervals. Turn radius, actuation lag, and disturbance remain outside the model.
Multi-Agent Path Finding (MAPF): move a team of agents to goals without collision. Solvers: CBS/ECBS (conflict-based search), PIBT, LaCAM/LaCAM*, and lifelong RHCR.
All operate on a discrete grid with simplified kinematics (unit moves / rotate-in-place) and no disturbance model.
A "conflict" is a shared vertex/edge (or swept-disc overlap) — dynamics-blind.
Consequence: realized collisions on a real floor (turn-radius limits, localization noise, actuation lag) are out of scope.
The discrete plan is provably conflict-free on the graph — yet the continuous robot can still collide. That is the gap HJ reachability fills.
Rolling-Horizon Collision Resolution: decompose lifelong MAPF into a sequence of Windowed MAPF instances; resolve collisions only within a bounded time window , ignore beyond.
Scales to 1,000 agents on warehouse maps; co-authored by J. Durham (Amazon Robotics).
Current frontier: LaCAM* (10,000+ agents, near-optimal, anytime), PIBT (thousands in ms), learning-based lifelong (imitation, guidance-graph, MAPF-GPT).
All still discrete-grid, deterministic.
HJ-Gauss does not compete with LaCAM's combinatorial search; it certifies the plan under continuous dynamics — a different, complementary axis.
1 Li et al., AAAI 2021
| HJ-Gauss construct | MAPF role |
|---|---|
| Windowed BRT over , set | Continuous, disturbance-robust replacement for the RHCR rolling window (innovation #1) |
| Pairwise Dubins BRT membership | Dynamics-aware conflict predicate replacing the geometric/disc check in CBS/CCBS (innovation #2) |
| Relative-frame tube, computed once | Reused across all pairs & timesteps ⇒ certificate cost in agents |
| Value gradient | A score: certified guidance term for diffusion planners (innovation #3) |
The Dubins pursuit-evasion BRT from Part 5 is the canonical pairwise MAPF conflict, computed rigorously.

Black = certified inevitable-collision boundary; dashed = naive disc. The BRT bulges beyond the disc in a heading-dependent way — what a dynamics-blind check cannot see.
Sweeping the relative heading makes the certified set rotate and deform.
A near head-on geometry grows a long lobe; a near-parallel one stays compact.
The dashed red circle is the dynamics-blind disc, fixed for every heading.
This is the object a swept-disc test approximates with a circle.
Only about 2% of the relative-state box is certified inevitable-collision at s.
So the gate is selective, not blanket-conservative: it fires on geometry that actually traps the pair.
Where the tube exceeds the disc, a geometric planner is blind; where it falls inside, the disc is needlessly cautious.
Naming: HJ = Hamilton-Jacobi (the method); HB-n = hypothesis .
| ID | Hypothesis | Null we try to reject | Metric |
|---|---|---|---|
| HB-1 | HJ-shield is sound | Admits collisions geometric catches | Realized collisions |
| HB-2 | HJ is dynamics-aware | Geometric never misses what HJ catches | Collisions, geom vs HJ (CRN) |
| HB-3 | Memory , flat in resolution | Grows like grid | Peak memory |
| HB-4 | Certified gate costs little throughput | Large makespan inflation | Throughput / flowtime |
| HB-5 | Fast enough (precompute + lookup) | Too slow for the loop | Wall-clock / latency |
| HB-6 (stretch) | -guidance reduces collisions in a diffusion planner | No reduction | Guided vs unguided |
World: an RHCR-style structured warehouse grid — storage blocks, single-cell corridors, border endpoints — with lifelong task reassignment.
Planner: windowed prioritized planning (space-time A*), the RHCR rolling horizon, shared by both policies.
Executor: a continuous unicycle/Dubins rollout with bounded turn rate and bounded disturbance, where realized collisions are detected in continuous space.
The planner is held fixed on purpose. Only the safety layer varies.
Geometric — the classical dynamics-blind vertex/edge conflict test, unshielded.
HJ — the same planner plus the windowed-BRT runtime shield.
Both run under Common Random Numbers: identical spawns, tasks, priorities, and disturbance realizations for a given seed.
BRT precompute: the JAX HJ sampler (Algorithm B) on the Dubins-relative Hamiltonian, cached once; the online loop is numpy-only lookups.
One clean contrast: the only difference between the two arms is whether the certificate is actuated.

RHCR-style structured floor: storage blocks (obstacles), border endpoints (pickup/dropoff), 14 lifelong agents (circles) heading to goals (stars).

Left: geometric conflict check. Right: the HJ-Gauss windowed-BRT shield. Amber ring = shield firing (agent fleeing), red = realized contact, stars = current goals. Seed 1028 of the 30-seed harness: 98 → 66 collisions at identical throughput (0.825). Animated in the HTML deck; the PDF shows the opening frame.

Four instants from the run above: top row geometric, bottom row HJ-shield. Counters under each panel accumulate realized collisions and shield activations. Identical spawn, task, and disturbance streams throughout (CRN).
This is the arc: a negative result diagnosed to a principle, then the correct mechanism. Actuation, not inspection.
Mirrors the WIP-forecast harness; numpy-only:
≥30 seeds (configurable);
MSER-5 warm-up truncation of the per-tick collision series (+ Welch running-mean cross-check);
Bootstrap 95% CIs on every headline metric;
Common Random Numbers (CRN) across policies (spawn/task/disturbance streams keyed to the seed) for a paired comparison;
Paired bootstrap CI for + Holm-Bonferroni step-down FWER control across the HB family.
Single-seed results were noisy and even inverted; the harness is what turns a direction into a defensible claim.
| Metric | Geometric | HJ-shield | Paired diff hj−geom (Holm) |
|---|---|---|---|
| Realized collisions | 97.7 [90.8, 104.9] | 66.1 [61.2, 71.2] | −31.6 [−38.0, −25.4], reject |
| Collision rate (MSER-5) | 2.48 /tick | 1.67 /tick | −0.81 [−0.98, −0.64], reject |
| Throughput | — | — | 0 [0,0], not rejected |
| Flowtime | — | — | 0 [0,0], not rejected |
| Shield interventions | 0 | ~1024 | (activity, by design) |
~32% fewer realized collisions, significant under Holm-Bonferroni, at no throughput/flowtime cost in this model.
Aggregated sweeps: 18-37% reduction across densities and disturbance levels.
HB-1/HB-2 rejected in the safe direction; HB-3/HB-4 show no throughput penalty. The certificate, actuated, works.

30 CRN-paired seeds, bootstrap 95% CI. Geometric 97.7 → HJ-shield 66.1; paired diff −31.6 [−38.0, −25.4], Holm p≈0.

HJ shield (teal) sits below geometric (red) at every steady-state tick; the dashed line is the MSER-5 warm-up cut discarded before averaging.

Collision reduction persists across agent densities (8-20 agents) — the certificate's value does not wash out with congestion.
| ID | Prediction | Result | Verdict |
|---|---|---|---|
| HB-1 | Shield is sound | HJ never certifies a colliding plan safe; collisions ↓ | |
| HB-2 | Dynamics-aware advantage | 31.6 fewer collisions per run, paired, Holm p≈0 | |
| HB-3 | memory | 7.2 MB at ; flat in resolution | |
| HB-4 | Little throughput cost | Throughput/flowtime diff = 0 in this model | |
| HB-5 | Fast enough | BRT precompute ~10 s; online lookup | |
| HB-6 | Diffusion-guidance helps | Deferred to Option C |
HB-4's zero difference is partly a modeling artifact (next: Dirty Laundry). Everything else holds under the harness.
The Cole-Hopf kernel is the diffusion kernel.
The Cole-Hopf step turns the HJ PDE into the heat equation, whose fundamental solution is the Gaussian transition kernel — the identical kernel that score-based generative models (DDPM, score matching) and diffusion policies use in their forward process.
Under , the recovered value gradient is a score function:
Certified reachability and diffusion trajectory generation meet at the same Gaussian kernel. This is not a metaphor; it is the same PDE.
Diffusion trajectory planners (Diffuser, Decision Diffuser, Motion Planning Diffusion) generate paths by denoising but carry no hard safety guarantee.
The BRT gradient can serve as a certified guidance / shield term: add it to the denoiser's score to steer denoised trajectories out of the inevitable-collision set.
The AMFS shield is the discrete-time instance of this idea (flee along ); the continuous diffusion-guidance version is Option C.
A reachability-certified shield for neural planners — the missing safety guarantee in the learning-based MAPF line (imitation, guidance-graph, MAPF-GPT).
is a genuine score of the Cole-Hopf-transformed value density .
But is not the data distribution a diffusion planner learns — the objects coincide structurally (same kernel, same form), not identically.
The rigorous joint-work statement: use the certified reachability score as a guidance/projection term on the learned generative score, inheriting the BRT's worst-case guarantee as a shield while the learned score supplies task performance.
State it carefully and it is bulletproof; overstate it and a diffusion expert will (rightly) push back. Structural identity + guidance role, not "our value function is your data score."
Shared kernel: both sides live on transitions — infrastructure reuse.
Certified shield: wrap any learned proposer (BC, CQL/IQL, diffusion) with the windowed-BRT flee/guidance term; report blocked actions and throughput margin separately.
Score as drift: the importance-sampling tilt is literally a score-guided proposal — a learned score could serve as the sampler's drift and vice versa.
Benchmark: extend League-of-Robot-Runners / RHCR with a disturbance model → a robust-throughput axis.
One decision contract, two evidence environments: certified reachability and learned generation, meeting at the Gaussian kernel.
Limits, caveats, and boundaries.
Quasi-linearization residual floors accuracy for non-quadratic ; the scheme is closed-form only when . The residual is largest where turns over sharply (the usable-part boundary) — the theory predicts where the error lives.
Worst-case sample complexity is exponential in (Hoeffding + crude bound: ), while viscosity error is only — a genuine bias-variance tension. Practical sits far below this; Bernstein/Jensen and importance sampling tighten it; the optimal gives .
Coefficient blows up in flat interiors and flips sign at the barrier; cured by regularization at a quantified, uniform price .
None of these are hidden — each has a theorem, a remark, and a mitigation. The certificate is correct by construction (abstention band).
The Crandall-Lions bound and the reported errors are in different currencies (inviscid-vs-viscous sup-norm vs MC-vs-grid); compared with explicit care.
Averaging ≠ agreement: even the 30-seed-averaged field differs from the grid (paired Wilcoxon, ) — the systematic residual remains.
At there is no grid reference: we report scalability (iteration stability, memory, wall-clock), not certified accuracy.
The accuracy quotation is the conservative certificate: sign-correctness outside a declared abstention band, not an average that flatters the interior.
flatters; is dominated by the band we already declare undetermined. We quote the certificate, not the flattering average.
Adversarial vs cooperative: the BRT is a worst-case set; using it as a cooperative-MAPF predicate is safe but conservative, and only reduces realized collisions when actuated (shield), not merely checked at plan time — this was our diagnosed negative result.
"Free safety" is a modeling artifact: in the AMFS executor the discrete planner is authoritative for task progress, so shield-induced fleeing does not delay arrivals → HB-3/HB-4 diffs are 0. A physical executor should let fleeing delay arrivals, introducing a small, real throughput cost.
Shield compute: the per-micro-step BRT interpolation is the CPU bottleneck (~7 min / 30 seeds); vectorize before scaling.
Scope: Dubins agents, one floor topology, single disturbance level — a PoC, not a fleet study.
The result is real and significant; the magnitude and cost need a more physical executor and larger sweeps (Option C, GPU).
Grid solvers remain preferable for (smaller constant, no sampling variance); HJ-Gauss is the method of choice only in the high-dimensional regime. The paradigms are complementary.
The -bird result is many coupled low-D games, not one joint high-D PDE — we are explicit about this.
All experiments are single-CPU; GPU/Lambda scaling (Part 9) is future work, not claimed here.
The diffusion connection is a structural identity + guidance role, not a claim that our value density equals a learned data distribution.
Complementary, decoupled, single-CPU, structural — four boundaries stated plainly so no claim is overread.
HJ-Gauss turns the nonlinear viscous HJ PDE into a sequence of linear heat equations (Cole-Hopf), solved as Gaussian Feynman-Kac expectations by a frozen-coefficient Picard iteration (Algorithm 1).
Memory drops from grid to — storage- and discretization-free.
Guarantees: concentration (dimension-independent), geometric contraction with a posteriori estimate, a Duhamel residual bound, a total-error decomposition with , and a one-sided conservative safety certificate.
Validated to a 45D game and -agent certification — regimes grids cannot represent.
For autonomous mobility: a dynamics-aware, disturbance-robust conflict predicate/shield for MAPF (windowed BRT = RHCR window), and — via the Gaussian/score identity — a certified guidance term for diffusion planners.
Certified safety is the sign of a value function. HJ-Gauss computes that sign where grids cannot — and hands the same object to your learned planners.
Option C — diffusion-guided planning (HB-6): actuate as continuous guidance on a diffusion/sampling planner; certified shield for neural LMAPF.
Physical MAPF executor: let shield fleeing delay arrivals → measure the real throughput-vs-safety frontier (robust-throughput benchmark).
GPU / Lambda Labs scaling: vectorize the shield's BRT interpolation; run the harness as a Metaflow flow (fan-out over configs × seeds); scale the BRT precompute (bigger grids, higher-D dynamics) on H100s.
Adaptive importance sampling in high dimensions; Bernstein-tight sample budgets.
Tighter integration with safe-RL / policy-certification pipelines.
The scaling path (
imp/ar-metaflow, W&B, S3 checkpointing) is scoped inAMFS/infra/lambda_labs_notes.md.
Reference ledger complete.
Code: github.com/robotsorcerer/levelsetpy (monte_carlo, monte_carlo/AMFS) · Contact: ogunmolu@amazon.com
I. Mitchell, "Reach Sets and the Hamilton-Jacobi Equation," UBC CS542D lecture notes, 2004 (with A. Bayen, M. Oishi, C. Tomlin). cs.ubc.ca/~mitchell/Class/CS542D.2004/Handouts/reachSets1.pdf
L. C. Evans, P. E. Souganidis, "Differential Games and Representation Formulas for Solutions of Hamilton-Jacobi-Isaacs Equations," Indiana Univ. Math. J., 1984.
A. W. Merz, "The Homicidal Chauffeur," AIAA J., 1972; I. Mitchell, numerical validation, 2001.
M. Falcone (static HJ); J.-P. Aubin & P. Saint-Pierre (viability kernels) — alternative Eulerian reachability.
Notation, Hamilton-Jacobi / viscosity theory (A), reachability foundations (B), and the LevelSetPy grid pipeline (C) — reference material for the main talk.
| Symbol | Meaning |
|---|---|
| : State; : Open set; = State dimension | |
| Value function; time derivative; spatial gradient (co-state) | |
| Hamiltonian; = co-state | |
| Terminal/target datum (signed distance ); BUC | |
| Viscosity parameter |
| Symbol | Meaning |
|---|---|
| Cole-Hopf transformed variable | |
| Frozen coefficient | |
| Grid points per dimension (); Monte-Carlo samples per query state () | |
| Target set, backward reachable tube (BRT) |
Two independent counts: evaluation states (arbitrary, grid-free) vs Gaussian samples drawn per state. Total randomness per iteration .
Autonomous mobility / MAPF: a certified, dynamics-aware, disturbance-robust conflict predicate that slots into rolling-horizon planners at fleet scale.
Safe RL / policy verification: computing backward reachable tubes for a closed-loop learned policy is memory-bound on grids; lifts that bound.
Differential games / pursuit-evasion: the adversarial worst-case reachable set is what HJ-Isaacs computes.
The unifying object is a value function whose sign certifies safety. This talk is about computing that sign where grids cannot.
Differential games / pursuit-evasion: the adversarial worst-case reachable set is what HJ-Isaacs computes.
Diffusion / generative planning: the Cole-Hopf kernel is the score-based diffusion kernel; the value gradient is a score.
Air-traffic, collision avoidance, multi-robot control: the classical application domain of HJ reachability.
The unifying object is a value function whose sign certifies safety. This talk is about computing that sign where grids cannot.
Viscosity solutions, vanishing viscosity, and why we need them.
Our chief object is the evolution (Cauchy) HJ equation
with continuous and bounded, uniformly continuous (BUC).
A closely related object is the scalar conservation law / convection equation , whose shock theory motivates the numerics.
The HJ equation is first-order, nonlinear, hyperbolic.
First-order nonlinear hyperbolic PDEs generically fail to have smooth global solutions — the reason the entire viscosity-solution apparatus exists.
The method of characteristics integrates the PDE along curves in .
For nonlinear , characteristics cross: multiple characteristics carry conflicting values to the same point → a shock / gradient discontinuity.
Consequence: no global solution exists in general, even when and are smooth.
Global analysis via classical PDE theory is "virtually impossible" (Crandall-Lions).
The value function of a differential game develops kinks and shocks right at the barrier — the most safety-relevant region. We must define a weak solution that survives there.
Viscosity solutions are the correct weak solution class for HJ PDEs: they exist almost everywhere, and enjoy existence, uniqueness, and stability theorems.
Definition (sketch) via test functions: is a viscosity subsolution if for every smooth touching from above at , ; supersolution with the reverse inequality and touching from below; a solution is both.
This selects the physically-correct kinked solution and discards spurious ones.
Viscosity theory gives us a unique object to compute and to certify — indispensable for a safety guarantee.
1 Crandall & Lions, 1983
Introduce and regularize (parabolic smoothing, as in gas dynamics):
The added Laplacian makes the PDE parabolic, hence classically well-posed: , unique, stable, BUC for all .
Traversing the limit recovers the unique viscosity solution.
is the linchpin of HJ-Gauss: it is both the smoothing that admits a classical solution and the diffusion coefficient of the heat equation we are about to expose.
The viscous solution approximates the inviscid viscosity solution at a known rate:
Bias scales as : smaller → more accurate.
But (preview) smaller → more concentrated exponential weights → higher Monte-Carlo variance.
This is the bias-variance knob we will formalize in Part 4 ().
One scalar trades geometric accuracy against sampling variance. Choosing it well is the practical art of the method.
Whole-space heat theory requires the datum in .
The transformed datum is — not itself. This matters: the signed distance is unbounded above, but for a bounded target and as , so
Only the lower bound is needed; no upper bound on is used. This is what lets us sample over all of .
What a certified safety set is, before we compute one.
Reachability concerns the decidability of a dynamical system's trajectory evolution across a phase space.
A reachable system is decidable when one can compute all states reachable from an initial condition in a finite number of steps.
Dual questions:
Forward: where can the system go from here?
Backward: from which states is a target inevitably reached (or avoidable)?
Safety analysis is naturally backward: characterize the set of states doomed to enter a danger set, then stay out of it.
Certifying a learned controller, neural policy, or planner means proving it satisfies all specified requirements — a verification problem. Reachability is the geometric engine of that verification.
Backward Reachable Set (BRS): states that reach the target at a specific time.
Backward Reachable Tube (BRT): states that reach the target at some time in — the safety-relevant object.
Reach-Avoid Tube (BRAT): states that can reach a goal while avoiding an obstacle set.
Robustly-Controlled BRT (RCBRT): when the controller must counter a worst-case disturbance — the adversarial guarantee.
The strategy structure () encodes the game: disturbance plays a nonanticipative strategy against control .
A continuous backward reachable set is the set of all states from which trajectories can reach a given target set .
Called "backward" to distinguish it from the forward reachable set.
To compute it, run the dynamics backward in time from the target set.
For safety, the target is usually the unsafe set, so the backward reachable set is the set of states doomed to become unsafe.
(Mitchell 2004, Reach Sets and the HJ Equation)
Computing a reachable set poses two coupled problems:
Represent the set of reachable states.
Evolve that set according to the dynamics.
Inset: A sphere as an SDF — LevelSetPy (L. Molu), ACM TOMS 51(2), 2025.
Level-set idea: Represent a set as an isosurface of a scalar function 1:
State-space dimension does not matter conceptually: the same machinery works in any .
Surfaces automatically merge and separate as the set evolves.
Geometric quantities (normals, curvature, distance) are easy to compute from .
Critical talk juncture: the reachable set is the zero sublevel set of a value function .
Inset: Set union of two spheres — LevelSetPy (L. Molu), ACM TOMS 51(2), 2025. · 1 Osher & Sethian
For continuous systems , two families:
Lagrangian (forward sets; restricted dynamics/shapes; overapproximation): HyTech, Checkmate, , ellipsoidal1.
Eulerian (backward sets; general dynamics incl. competitive inputs; implicit set representation).
1 Kurzhanski
Classical collision avoidance:
Collision if the vehicles come within 5 units of each other.
Evader picks turn rate to avoid;
Pursuer picks to cause collision; fixed equal speeds .
(Mitchell 2004, Reach Sets and the HJ Equation)
Classical collision avoidance:
Work in relative coordinates with the evader fixed at the origin
State is relative position and relative heading .
NB: Same relative-coordinate pursuit-evasion (PE) game we solve with HJ-Gauss (Part 5); and the pairwise MAPF conflict of Part 6.
(Mitchell 2004, Reach Sets and the HJ Equation)
The set evolves by a (modified) Hamilton-Jacobi PDE:
A first-order hyperbolic PDE whose solution can form kinks (discontinuous derivatives).
The right weak solution is the viscosity solution1.
(Mitchell 2004, Reach Sets and the HJ Equation); viscosity: Crandall-Evans-Lions; level sets: Osher-Sethian · Dubins BRT: LevelSetPy (L. Molu), ACM TOMS 51(2), 2025 · 1 Crandall, Evans, Lions
The set evolves by a (modified) Hamilton-Jacobi PDE:
Level-set methods produce convergent numerical schemes1:
Non-oscillatory high-accuracy spatial derivatives;
A stable/consistent numerical Hamiltonian; and
Total variation-diminishing (TVD) high-order explicit time integration.
This is the classical grid pipeline of Part C. HJ-Gauss tackles this computational cost.
(Mitchell 2004, Reach Sets and the HJ Equation); viscosity: Crandall-Evans-Lions; level sets: Osher-Sethian · Dubins BRT: LevelSetPy (L. Molu), ACM TOMS 51(2), 2025 · 1 Osher, Sethian
The terminal-cost differential game
Trajectories ;
Value function is the viscosity solution of the HJ equation1.
This modified/augmented Hamiltonian is the freeze term on our HJI-RCBRT slide.
1 Evans & Souganidis, 1984
To stop trajectories from passing through the target (so the set is a tube, not just a set),
Augment the disturbance input;
The augmented HJ equation solves for the reachable set;
The augmented Hamiltonian is the modified Hamiltonian.
This modified/augmented Hamiltonian is the freeze term on our HJI-RCBRT slide.
The method sits among Eulerian formulations:
Static HJ: Minimum time-to-reach1; (dis)continuous implicit representation; yields optimal-input information.
Viability kernels: Set-valued analysis for very general dynamics2; discrete implicit representation; overapproximation guarantee.
Time-dependent HJ (this method): Continuous solution, optimal-input information throughout the state space, high-order accurate.
All three are theoretically equivalent; HJ-Gauss is a new solver for the time-dependent HJ formulation.
(Mitchell 2004, Reach Sets and the HJ Equation); Falcone/Sethian; Aubin/Saint-Pierre · 1 Falcone; Sethian · 2 Aubin; Saint-Pierre
Reachable sets already drive real-world safety systems:
Softwalls for aircraft safety: Filter evader's input so the pursuer never enters the reachable (unsafe) set — a certified safety filter (with E. Lee & A. Cataldo).
Collision alert for ATC: Flag aircraft pairs whose flight plans intersect and whose relative state enters the collision region.
These are the ancestors of the certified conflict predicate / shield we bring to warehouse MAPF in Part 6.
(Mitchell 2004, Reach Sets and the HJ Equation); Softwalls with E. Lee & A. Cataldo
For identical PE dynamics, the reachable set admits an analytic solution1.
Merz placed the pursuer at the origin; the game is not symmetric.
That analytic solution is used to validate the numerical algorithm2 — the same discipline behind our LevelSetPy-vs-Monte-Carlo comparison in Part 5.
Takeaway of the primer: reachability = represent implicitly, evolve in a HJ PDE game, solve for the viscosity solution.
HJ-Gauss keeps this exactly and changes only how the PDE is solved.
(Mitchell 2004, Reach Sets and the HJ Equation); Merz (1972); Mitchell (2001) · 1 Merz, 1972 · 2 Mitchell, 2001
robustly controlled over the distance-to-target cost .
Numerically is a signed-distance function whose zero sublevel set is the target: negative inside, positive outside.
The BRT is recovered as the zero sublevel set of the value function:
The value function of the RCBRT is the viscosity solution of the variational HJ-Isaacs equation
with the game Hamiltonian
The freeze term makes the set only grow (a tube, not a set) — states already captured stay captured.
For reach-avoid, the variational inequality couples the growth term with the obstacle datum .
This Hamiltonian is positively 1-homogeneous in , state-dependent, nonconvex, and sign-changing across the barrier. Those four properties will rule out every convex-duality shortcut.
Backward-reachability convention: is the backward horizon (time-to-go); the datum is posed at and the tube grows over .
Reach (capture) tube: .
Reach-avoid tube (viscous):
These conventions matter for signs during implementation and for which set (reach vs avoid) a negative value certifies. We adopt the backward-reachability viscosity-solution convention throughout.
Worst-case, not average-case: the RCBRT certifies safety against all admissible disturbances — the guarantee a safety case needs.
Geometric and set-valued, not trajectory-valued: it characterizes every unsafe initial condition at once, not one rollout.
Composable: the zero level set can be intersected, unioned, and propagated; it plugs into supervisory control and shielding.
Certificate-grade: a signed value with an error bound yields a decision — SAFE / UNSAFE / UNDETERMINED (Part 4).
The cost of this rigor is computational: solving the HJ(I) PDE. The rest of the talk is about paying that cost at scale.
How Reachable Sets Are Computed Today — and Why It Is .
Molu. ACM TOMS 2025 · IEEE CDC 2024
TOMS: ACM Transactions on Mathematical Software · CDC: Conference on Decision and Control.
Represent the reachable set implicitly as the zero sublevel set of stored on a Cartesian grid.
Evolve the interface by integrating the HJ PDE on the grid:
Discretize space (upwinding),
Stabilize the Hamiltonian (Lax-Friedrichs),
March in time (TVD-RK).
1 Osher-Sethian
| MATLAB ToolboxLS (2004) | LevelSetPy (2024/25) |
|---|---|
| CPU-only, single-threaded | NumPy + CuPy GPU |
| Slow for modern problems | Fast, batched, portable |
| No modern-library plug-in | ROS/PyTorch/SciPy compatible |
LevelSetPy makes grid reachability fast. It does not change the memory scaling — the theme of Part 1.
1 Osher-Sethian
The target set is initialized as a signed-distance function : negative inside, positive outside, .
Stored as an -dimensional array over a Cartesian grid: points per axis → cells.
Geometric primitives (spheres, cylinders, half-spaces) and boolean set operations (union/intersection/complement) are implemented as min/max on the level-set field.
Example: a capture ball of radius is ; a cylinder ignores the periodic axis.
The implicit representation is elegant and closed under set algebra — but it stores the value at every grid node.
The co-state must be approximated from grid values with the correct direction of information flow (upwinding) to remain stable at shocks.
First-order upwinding: one-sided differences chosen by the sign of the characteristic speed.
Left/right approximations feed the numerical Hamiltonian; the choice prevents differencing across a discontinuity.
Naive centered differences ring and go unstable at the barrier; upwinding is the minimal fix, refined next by ENO/WENO.
ENO picks, among candidate stencils, the smoothest one to interpolate the derivative — avoiding stencils that straddle a shock.
Orders implemented: ENO2 (2nd), ENO3 (3rd), via upwind_first_eno2.py, upwind_first_eno3.py.
Higher order → sharper interface, lower numerical diffusion, at more stencil work per node.
ENO chooses one smoothest stencil. WENO improves on this by blending stencils with adaptive weights.
WENO51 forms a convex combination of three candidate substencils rather than choosing one, achieving 5th-order accuracy in smooth regions and non-oscillatory capture at shocks.
Substencils on the grid index :
combined with nonlinear weights that de-emphasize stencils crossing a discontinuity.
upwind_first_weno5.py.WENO5 is the workhorse for accurate reachable-set boundaries — and its per-node cost is one reason grid solves are expensive even before the memory wall.
1 Liu, Osher, Chan 1994
with dissipation coefficient over the relevant range (dimension-wise for global LF).
The artificial dissipation is a numerical cousin of the viscosity — both stabilize the barrier. HJ-Gauss will trade the grid's LF dissipation for the analytic .
Method of lines + Total-Variation-Diminishing Runge-Kutta1, so the interface does not spuriously oscillate:
Forward Euler (1st): , .
TVD-RK2: Euler step to , second Euler step, then convex average .
TVD-RK3: three stages with convex-combination weights .
TVD-RK preserves monotonicity of the spatial scheme in time. Each stage is a full grid sweep.
1 Shu-Osher
Numerical information must not travel more than one grid cell per step.
Finer grids () force smaller → more steps → compounding the cost.
CFL couples spatial and temporal resolution: refining space to sharpen the barrier makes both the memory and the step count worse.
| Module | Role |
|---|---|
grids, initialconditions |
Cartesian grids, signed-distance shapes |
spatialderivative |
Upwind first, ENO2/3, WENO5 |
explicitintegration |
Lax-Friedrichs Hamiltonians, TVD-RK, CFL |
dynamicalsystems |
Vehicle models (Dubins, rockets) |
visualization |
Isosurface / marching cubes rendering |
Worked example: the rockets-launch pursuit-evasion game; 2D slices of the 3D relative-state BRT, evolved backward over .
Multi-agent verification: flocks/murmurations partitioned into per-flock games.
A clean, tested, GPU-portable stack — the state of practice we now try to move beyond.
Memory: — store the value (and gradient) at every node.
Time per step: node updates × stencil width × RK stages, under a CFL-bounded step count.
GPU acceleration cuts the constant and parallelizes node updates, but the exponent is untouched.
This is the wall. Part 1 quantifies it and surveys who has tried to climb it.