A controller that acts on delayed measurements has to guess where the system will be by the time its command lands. The standard tool is a predictor, meaning a model of the plant that is integrated forward over the delay. This works well when motion is smooth. It fails when a bounce, a foot strike, or a collision happens inside the delay window, because the velocity jumps there, and a smooth forward model either misses the jump or blurs it out. We propose to learn, from trajectory data, a small symbolic hybrid model with three parts: a sparse equation for the smooth motion between events, a sparse symbolic "guard" function whose zero crossing marks where in state space an impact occurs, and a sparse "reset" map that sends pre-impact velocity to post-impact velocity. A delay predictor can then find the impact time exactly inside the window, apply the jump, and keep integrating.
The central bet is that, for delayed prediction, what matters most is when the jump happens, not how well a model fits the vector field. A model that predicts switches as a function of state can locate the impact within the delay window. A model that treats switches as random events in time, or that smooths them away, cannot. Sparse symbolic regression, which picks a few terms from a candidate dictionary to write down a governing equation, is well suited to guards and resets because these objects are often very simple (a height above a plane, a restitution coefficient). It is badly suited to impacts written as a single smooth equation, because a velocity jump is not a term of any finite smooth library.
Core Claim
Consider a delayed prediction from time $t$ to $t+\tau$ for a trajectory that contains one impact at true time $t^*$ inside the window. Let $\hat t^*$ be the predicted impact time and $\Delta v = v^+ - v^-$ the velocity jump. To first order, the position error at $t+\tau$ is dominated by
$$ e_{\text{event}} \approx \|\Delta v\| \, |\hat t^* - t^*| , $$
because between the true and predicted impact times the predictor moves with the wrong velocity. If the impact is located by a learned guard $\hat g$ crossing zero, the timing error is set by the guard error divided by how fast the state approaches the surface:
$$ |\hat t^* - t^*| \approx \frac{|\hat g(x) - g(x)|}{|\nabla g(x)^\top \dot x|}. $$
This follows from linearizing $g$ along the trajectory near the crossing. These two relations make a testable prediction. Smooth predictors should show error that grows with $\|\Delta v\|$ and stays bad no matter how much flow data they get. Guard-based predictors should show error that shrinks as the guard is estimated better, and that degrades mainly for grazing impacts, where the approach speed $\nabla g^\top \dot x$ is small. We claim that a sparse symbolic guard-and-reset model, identified jointly with the flow, achieves the second behavior with tens of trajectories. We also claim this is the regime where predictor feedback in the style of Event-Triggered Stabilization of Nonlinear Systems with Time-Varying Sensing and Actuation Delay stops failing. That work proves stability of predictor feedback with re-anchoring at each delayed measurement, but only for Lipschitz vector fields with a known plant model. It motivates our work and also constrains it, since we inherit its re-anchoring structure but have to replace both of its assumptions.
Relation to Prior Work
The closest work is Amortized Equation Discovery in Hybrid Dynamical Systems. AMORE jointly segments trajectories into modes and regresses a sparse equation per mode. It reaches 99.1% segmentation on a mass-spring hopper, against 70.5% for two-stage Hybrid-SINDy. Its switching model, however, is a latent mode variable with a geometric dwell-time prior. That prior says how long modes tend to last, not which states trigger a switch. It also works offline and models mode changes in the vector field, not velocity resets. We differ on exactly the axis a delay predictor needs: our switches are state-dependent symbolic guards with explicit reset maps, and the model is built to be rolled forward online from delayed measurements. AMORE supplies a baseline and a joint-estimation lesson: we refine events and equations together rather than in a fixed two-stage pipeline.
ContactNets learns signed distance functions and contact Jacobians with a mechanics-based loss. With 32 cube tosses it beats an end-to-end network trained on 256, and it keeps floor penetration under 2% of the cube's width, where the end-to-end model sinks 20%. We borrow its insight that contact should be learned as geometry plus complementarity, not as direct state-to-state regression. We differ in three ways. Our geometry is a sparse closed-form expression rather than a dense network. We drop its assumption of fully known free-body dynamics by regressing the flow. And we use the model as a delay predictor, which ContactNets never does.
On the symbolic side, Bayesian Generalized Nonlinear Models Offer Basis Free SINDy With Model Uncertainty removes the fixed dictionary but assumes one smooth global equation. SINDy-RL and the EKF-SINDy-MPC digital twin use sparse models as fast predictive surrogates, but only on smooth systems without delay. Together they show that sparse models are good forward simulators when the library is right. Work on library failure motivates our insistence that impacts be represented as resets rather than as flow terms. Discovery of Nonlinear Multiscale Systems: Sampling Strategies and Embeddings shows that no sampling strategy rescues a missing basis term, and A relaxed model selection method for Duffing oscillator identification shows sparse regression failing on non-standard friction. Randomized smoothing, as in Bundled Gradients through Contact via Randomized Smoothing, deliberately blurs contact for planning. For identification, that blur is exactly the artifact that would force a dense polynomial fit, so we keep smoothing out of the model and out of the data.
Research Program
The model has three sparse pieces. The flow is $\dot x = \Theta(x)\xi$ with a standard polynomial and trigonometric library, built with PySINDy. The guard $g(x)$ is drawn from a small library of contact primitives: heights of body-fixed points above an unknown plane, and distances between body points. For rotating bodies the guard is the minimum of several such terms. The reset is a sparse linear map from pre-impact velocity, expressed in the contact frame defined by $\nabla g$, to post-impact velocity. Its coefficients play the role of restitution and tangential friction factors.
Identification alternates three steps. First, fit the flow on segments believed to be impact-free. Second, flag candidate events where the flow model's one-step residual spikes, which is sharper than raw velocity thresholding at 148 Hz under noise. Third, fit the guard by implicit sparse regression, requiring $\hat g$ to vanish on interpolated pre-impact states and stay positive elsewhere, and fit the reset by sparse regression on the matched pre/post pairs. Event times are then re-estimated as the guard's zero crossings and the loop repeats. This avoids AMORE's "two-stage trap" without needing its full latent-variable machinery. That machinery is less necessary here because impacts produce large, localized residuals rather than subtle mode changes.
The predictor follows Nozari et al.'s structure. At each delayed measurement it re-anchors the state, integrates the flow, checks for a guard sign change with root-finding, applies the reset, and continues to $t+\tau$. Because the guard is closed-form, the per-step cost is a few function evaluations, which matters when the prediction itself eats into the latency budget.
We will also analyze what happens when the guard library is wrong, for example a rounded edge that is not a point primitive. In that case the predictor should register a residual spike at the unmodeled event. We test whether triggering a measurement-driven re-anchor at that moment degrades gracefully, rather than letting the error compound.
Baselines
The naive reference points are zero-order hold, which uses the delayed measurement unchanged, and constant-velocity extrapolation over $\tau$. Any learned predictor must beat both on windows containing impacts. Constant-velocity extrapolation is surprisingly hard to beat for short delays, and if it wins below some $\tau$ we will report that crossover.
The smooth sparse baseline is SINDy with polynomial terms augmented by sign and saturation functions, with coefficients stabilized by Ensemble-SINDy. It represents the "just enlarge the library" position at its strongest. A black-box baseline is an end-to-end network with a state-history input trained on the same tosses, matching ContactNets' end-to-end comparison.
The strongest competitor on the cube is ContactNets used as a forward predictor over the delay window, since it already handles impacts with little data. Its reported numbers are better accuracy at 32 tosses than end-to-end at 256, and penetration under 2% versus 20% of width (ContactNets). The strongest competitor on the hopper is AMORE rolled forward from delayed states, against its reported 99.1% segmentation (AMORE). For error at delay horizons on either benchmark, we found no reported result on Lacuna, so all delayed-prediction numbers will be produced here under one protocol. That protocol fixes the training splits (32, 64, 256 tosses), the delay grid, a shared hyperparameter search budget per method, and the same compute for rollout.
Two ablations isolate the key ingredient. The first keeps our flow and reset but replaces the state-dependent guard with an AMORE-style time-based dwell prior for when the reset fires. The second keeps the guard but replaces the reset with continued smooth flow. Beating the baselines means lower position and rotation error specifically on impact-containing windows, with no loss on free-flight windows, at 32 tosses, and a smaller event-timing error $|\hat t^* - t^*|$.
Why not just…?
Why not just use ContactNets as the predictor? This is the real threat. ContactNets may match our accuracy on the cube, because its learned signed distance function locates impacts just as a guard does. Its timing, however, comes from solving a contact problem every step through dense networks, and it assumes known free-body dynamics. Our experiments settle the question directly. If ContactNets matches us at equal data, the accuracy claim falls back to "symbolic is as good and is readable and cheap". We would then report per-prediction compute and whether the recovered guard and restitution coefficients match the cube's known geometry. If it loses on grazing impacts or on data where the free-body terms are unknown (the hopper), the claim stands.
Why not just add sign and Heaviside terms to the SINDy library? For Coulomb friction this may work, and it is a baseline here, not a straw man. For impacts it cannot work in principle. A velocity jump has a derivative that is an impulse, not a finite combination of library columns. Champion et al. show that missing structure cannot be recovered by better sampling. The error-versus-$\|\Delta v\|$ curve will show whether the augmented library's error stays proportional to jump size as data grows, which the core claim predicts.
Why not just roll AMORE forward? AMORE already recovers exact per-mode equations on the hopper. Its dwell-time prior, though, predicts switches stochastically in time, so inside a delay window it can only guess when stance begins. The first ablation, a time-based switch with everything else held fixed, tests exactly this difference. If AMORE's timing is as good on the hopper, where dwell times are regular, but worse on the cube, where impact timing depends strongly on state, that supports the state-dependent guard. If it is as good on both, the guard contributes little.
Why not just train a history-conditioned neural predictor or reinforcement learning policy end to end? The evidence on data cost is consistent. PPO reaches about 0.80 IoU after 10,000 episodes on PlasticineLab's RollingPin, where gradient optimization reaches 0.93 in tens of iterations (PlasticineLab). SINDy-RL needs 100x fewer interactions than PPO on cartpole. On contact specifically, end-to-end models penetrate the floor badly. We include the history-conditioned network on the identical splits, so this is measured, not assumed.
Proposed Experiments
The first testbed is the real cube toss dataset: 570 tosses at 148 Hz, tracked with AprilTags. We inject artificial sensing delays of 1 to 20 frames, roughly 7 to 135 ms. Predictions are scored at $t+\tau$, with position and rotation error stratified by whether the window contains an impact, by jump magnitude, and by approach speed. The decisive check is the shape of the error. The core relations predict that smooth predictors' impact-window error scales with $\|\Delta v\|$ and does not shrink with more tosses. Ours should scale with guard error and blow up only at small approach speeds. If our error also tracks $\|\Delta v\|$ independently of data size, the guard is not doing its job and the claim fails.
The second testbed is the mass-spring hopper from AMORE. Here the free-body terms are unknown and must be regressed, which tests the setting ContactNets excludes. We add a closed-loop experiment: a hop-height controller acting on delayed measurements through each predictor, scored by height-tracking error and failure rate as delay grows. This tests whether accurate event timing turns into stability where the smooth-plant guarantees of Nozari et al. no longer apply.
A third, smaller experiment deliberately removes the true guard primitive from the library, using rounded-edge geometry in simulation. It measures whether residual-triggered re-anchoring keeps error bounded, and how much accuracy is lost relative to the correct library. This quantifies the new library dependency we introduce, rather than hiding it.
References
- Event-Triggered Stabilization of Nonlinear Systems with Time-Varying Sensing and Actuation Delay
- Amortized Equation Discovery in Hybrid Dynamical Systems
- ContactNets: Learning Discontinuous Contact Dynamics with Smooth, Implicit Representations
- Bayesian Generalized Nonlinear Models Offer Basis Free SINDy With Model Uncertainty
- SINDy-RL for interpretable and efficient model-based reinforcement learning
- Adaptive Digital Twin Modeling with Control: Integration of Extended Kalman Filter-Based Recursive Sparse Nonlinear Identification with Model Predictive Control
- Discovery of Nonlinear Multiscale Systems: Sampling Strategies and Embeddings
- A relaxed model selection method for Duffing oscillator identification
- Bundled Gradients Through Contact Via Randomized Smoothing
- PySINDy: A comprehensive Python package for robust sparse system identification
- Ensemble-SINDy: Robust sparse model discovery in the low-data, high-noise limit, with active learning and control
- PlasticineLab: A Soft-Body Manipulation Benchmark with Differentiable Physics