Symplectic Discretization for Optimization and Learning

23 concepts17 papers3 proposals

Many foundational concepts in machine learning are naturally conceived in continuous time. We model momentum optimization as a heavy ball rolling down a loss landscape, view neural ordinary differential equations (Neural ODEs) as continuous trajectories, and analyze zero-sum games as continuous dynamical systems. Continuous-time formulations offer elegant mathematical tools, such as conservation laws and Lyapunov stability, making them highly attractive for theoretical design.

However, digital computers cannot execute continuous time; we must discretize. The standard approach is to apply naive numerical integration schemes like the Forward Euler method. Unfortunately, this translation often breaks the very properties that made the continuous model attractive. Naive discretization can introduce artificial energy drift, destroy acceleration guarantees, and cause trajectories to spiral out of control.

Symplectic discretization solves this problem by preserving the underlying geometric structure of these dynamical systems when moving from continuous equations to discrete algorithms.

Why Naive Discretization Fails

To build intuition for why standard discretization fails, consider a simple physical system: an undamped harmonic oscillator (a pendulum swinging without friction). In continuous time, the pendulum's total energy is perfectly conserved. If you plot its position ($q$) and momentum ($p$) over time, the trajectory forms a perfectly closed loop in phase space.

If we discretize this system using the standard Forward Euler method, each discrete step computes the next state using the current tangent vector. Because the true trajectory is curved, this linear step pushes the state slightly outward from the true orbit. Over time, these tiny errors accumulate, causing the system to gain artificial energy and spiral outward to infinity. Conversely, using Backward Euler causes the trajectory to spiral inward, artificially draining energy.

Forward Euler (Spirals Outward)      Symplectic Euler (Preserves Orbit)
       ▲                                    ▲
       │   ┌─►─┐                            │   ┌─►─┐
       │  ▲     ▼                           │  ▲     ▼
       │ ┌┘     │                           │ └───◄─┘
       │ │      ▼                           │
       └─┴──────┴──►                        └─┴────────►

In machine learning, this numerical artifact manifests as algorithmic instability. As Muehlebach et al. demonstrate in Optimization with Momentum: Dynamical, Control-Theoretic, and Symplectic Perspectives, standard numerical integration methods introduce artificial energy growth that destabilizes continuous-time optimization models. Instead of smoothly minimizing a loss function, the discrete iterations can oscillate violently or diverge entirely.

The Mechanism of Symplectic Integration

Symplectic integrators are specialized numerical schemes designed to preserve phase space volume (a property known as symplecticity). Instead of updating position and momentum simultaneously using current values, a basic symplectic integrator (such as Symplectic Euler) updates them sequentially:

$$ q_{k+1} = q_k + \Delta t \cdot f(p_k) $$ $$ p_{k+1} = p_k + \Delta t \cdot g(q_{k+1}) $$

Notice that the momentum update uses the newly computed position $q_{k+1}$ rather than the old $q_k$.

Why does this minor change work? While a symplectic integrator does not conserve the exact energy (Hamiltonian) of the original continuous system, it exactly conserves a slightly perturbed energy function known as a shadow Hamiltonian. Because the discrete steps are bound to the level sets of this shadow Hamiltonian, the system cannot drift to infinity or collapse inward. The discrete trajectory is mathematically constrained to remain stable over long horizons.

Preserving Acceleration in Optimization

This geometric preservation is crucial for translating continuous-time optimization proofs into practical, discrete algorithms. For example, Nesterov’s accelerated gradient descent can be modeled as a continuous-time differential equation. As Shi et al. show in Acceleration via Symplectic Discretization of High-Resolution Differential Equations, explicit discretization often fails to maintain acceleration, whereas a semi-implicit symplectic approach ensures that the discrete algorithm inherits the exact convergence characteristics of the continuous dynamical system.

This framework has been extended across several optimization domains:

Structure-Preserving Deep Learning Architectures

The necessity of symplectic discretization extends directly to deep neural network architectures that model temporal or continuous processes.

In the context of Neural ODEs, Zhu et al. reveal a fundamental limitation of standard training in On Numerical Integration in Neural Ordinary Differential Equations. When trained with standard explicit solvers, a Neural ODE does not learn the true continuous physical dynamics; instead, it learns a solver-specific, perturbed system. Without a symplectic integrator, the model is mathematically incapable of learning exact physical conservation laws (like energy preservation) from Hamiltonian data.

Training Data ──► Naive Solver ──────► Deviates from physical laws
Training Data ──► Symplectic Solver ──► Preserves exact conservation laws

Symplectic principles also offer solutions to classic training pathologies like vanishing and exploding gradients in Recurrent Neural Networks (RNNs). Rusch et al. introduce the UnICORNN architecture in UnICORNN: A recurrent model for learning very long time dependencies. By modeling hidden states as a system of undamped Hamiltonian oscillators and discretizing them via a symplectic Euler scheme, the network preserves phase space volume. This mathematical guarantee prevents gradients from exploding or vanishing, allowing the network to master sequences spanning thousands of time steps.

To scale these physical guarantees to complex systems, Yang et al. propose Hyperverlet: A Symplectic Hypersolver for Hamiltonian Systems. This approach pairs a traditional Velocity Verlet solver with a learned symplectic neural network corrector, ensuring long-term energy conservation that standard black-box neural networks fail to provide.

Broadening the Geometric Framework

Beyond optimization and neural architectures, structure-preserving discretization serves as a foundational bridge across control theory, reinforcement learning, and sampling:

By ensuring that the discrete algorithms respect the geometric invariants of their continuous counterparts, symplectic discretization provides a mathematically rigorous methodology for building stable, accelerated, and structure-preserving machine learning systems.

Key Foundational Work

Discrete Hamilton-Jacobi Theory (2011) — contributed 1 concept elements to this direction.
Acceleration via Symplectic Discretization of High-Resolution Differential Equations (2019) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_symplectic_discretization_7d98bef2,
  title = {symplectic discretization},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/symplectic-discretization/rdr_7d98bef291c54981b247476725ae42ca},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-21},
}

This exact version (version 1, frozen text):

@misc{lacuna_symplectic_discretization_7d98bef2_v1,
  title = {symplectic discretization},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/symplectic-discretization/rdr_7d98bef291c54981b247476725ae42ca/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-21},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake