🤖 machine learning

Latent Lie-Poisson Neural Networks (LLPNNs): Discovering the motion of Lie-Poisson systems through observable data and latent dynamics

This paper introduces Latent Lie-Poisson Neural Networks (LLPNNs), a structure-preserving framework that learns Lie-Poisson dynamics directly from observable data by leveraging geometric ingredients like Hamiltonian decoders, Noether invariants, and Lie-group updates to achieve accurate long-term predictions even for degenerate systems where latent variables are unobservable.

Original authors: Vakhtang Putkaradze

Published 2026-08-03

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Vakhtang Putkaradze

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a computer to predict how a spinning top, a swimming robot, or a fleet of drones will move in the future. You have a video of them moving, showing their positions and speeds, but you don't have a direct window into the "invisible gears" inside them—the hidden forces and momenta that actually drive the motion. This is the challenge of physics-informed machine learning: teaching AI to understand the laws of nature just by watching things happen.

Usually, when we try to predict motion, we look at the visible stuff (where it is and how fast it's going) and guess the next step. But for many complex systems, like a rigid body spinning in space or a vehicle navigating a fluid, the visible speed isn't enough to tell the whole story. The real "engine" of the system lives in a hidden, mathematical space called momentum. Think of momentum like the invisible tension in a rubber band; you can't see the tension itself, only the movement it causes. If you try to predict the future just by looking at the movement, you might miss the hidden tension, and your prediction will eventually drift off into nonsense.

Furthermore, some of these systems are "degenerate," meaning the rules are a bit broken or incomplete. In these cases, the visible speed doesn't even have its own set of rules to follow; it's entirely dependent on that hidden tension. Trying to predict the future without knowing the hidden tension is like trying to guess the next move in a game of chess when you can only see the pieces on the board but not the rules of how they move. This paper tackles exactly that problem: how to teach a computer to learn the hidden rules and the invisible forces just by watching the visible dance.

The Secret Decoder Ring for Hidden Motion

The author of this paper, Vakhtang Putkaradze, have invented a new kind of AI called Latent Lie-Poisson Neural Networks (LLPNNs). Think of this as a "secret decoder ring" that allows a computer to figure out the invisible, hidden forces driving a system, even when it can only see the visible results.

Most AI models trying to predict motion act like a student who only memorizes the answer key. They look at where an object is now and where it was a second ago, then guess where it will be next. This works okay for simple things, but for complex systems like spinning satellites or underwater vehicles, these models eventually get confused. They forget the "conservation laws"—the fundamental rules that nature never breaks, like the fact that a spinning top must keep its total spin unless something pushes it. Because they forget these rules, their predictions slowly drift away from reality, like a map that gets a little bit wrong every day until you end up in the ocean instead of the city.

The problem gets even trickier when the system is "degenerate." In these cases, the visible speed (like how fast a car is driving forward) is constant or fixed, but the hidden momentum (the invisible force making it turn) is changing wildly. It's like watching a car drive at a perfectly steady 60 mph on a straight road. To a normal observer, the car seems boring and unchanging. But if that car is actually on a giant, invisible merry-go-round, the hidden momentum is spinning wildly even though the speed looks the same. Standard AI models get stuck here because they can't see the merry-go-round; they only see the steady speed. They try to invent a rule for the speed, but no such rule exists because the speed is just a shadow of the hidden spin.

How the New AI Solves the Puzzle

The LLPNNs solve this by realizing that even though we can't see the hidden momentum, we can deduce it using a "magic trick" from physics called Noether's Theorem. This theorem says that if a system has a certain symmetry (like being the same no matter how you rotate it), there is a hidden quantity that never changes.

The author's method works like this:

The Hidden Constant: The AI assumes there is a hidden, unchanging "spatial momentum" vector (let's call it $p_0$ ) that stays the same forever, even as the object spins and moves.
The Reconstruction: Using the visible path of the object (its position and orientation), the AI uses a mathematical bridge called the coadjoint action to reconstruct what the hidden momentum must be at every moment to keep that constant $p_0$ true. It's like seeing a shadow move across a wall and realizing, "Ah, the object casting the shadow must be spinning this way to keep the light source steady."
Learning the Rules: Once the AI has reconstructed the hidden momentum, it learns the actual rules (the Hamiltonian) that govern how that momentum changes. It does this using two different "approaches":
- The Decoder Approach: It learns a function that translates hidden momentum into visible speed.
- The Encoder Approach: It learns a function that translates visible speed back into hidden momentum (but only for the parts of the system that are allowed to change).

What They Found

The author tested this new AI on three very different, challenging scenarios:

A Spinning Rigid Body: A generalized version of a spinning top on a 3D sphere (SO(3)).
An Underwater Vehicle: A complex robot moving through water, dealing with both rotation and translation (SE(3)).
A Swarm of Drones: Multiple autonomous vehicles on a 2D plane, where some of the motion rules are "degenerate" (the forward speed is fixed, but the turning is controlled by hidden forces).

In all three cases, the LLPNNs were able to learn the hidden dynamics and predict the future with excellent long-term accuracy.

The "Magic" of Conservation: The most impressive result is that the AI preserved the "Casimir invariants" (the hidden conserved quantities) to machine precision. This means the AI didn't just guess the right numbers; it mathematically guaranteed that the hidden rules of the universe were never broken.
Beating the Competition: When compared to other popular AI methods like Neural ODEs and DeepONets (which just look at visible data), the LLPNNs stayed on track for a long time. The other methods worked okay for simple systems but failed miserably when the system was "degenerate" (like the drone swarm). In those cases, the other AI models diverged rapidly, predicting impossible paths because they couldn't see the hidden forces.
Robustness: The method worked well even when the data was noisy (simulating real-world sensor errors).

The Limits and the Future

The paper is careful to note that this method isn't a magic wand for everything. It relies on knowing the symmetry group of the system beforehand. You have to tell the AI, "This is a spinning top," or "This is a drone on a flat plane." If the system breaks its own symmetry (like a drone trying to find a target that breaks the rotational rules), the method might struggle. Also, the method is designed specifically for systems that follow Lie-Poisson dynamics; it can't be directly applied to just any random physical system without that specific geometric structure.

However, for the systems it does cover, the results are a significant step forward. The author shows that by embedding the deep geometric structure of physics directly into the neural network, we can build AI that doesn't just memorize data, but actually understands the invisible gears of the universe. They demonstrated this with simulations of rigid bodies, underwater vehicles, and drone swarms, proving that even when the visible data is incomplete or the rules are degenerate, the hidden truth can be recovered and predicted with high precision.

In short, this paper gives us a new way to teach computers to see the invisible, ensuring that their predictions of the future respect the unbreakable laws of physics.

Technical Summary: Latent Lie-Poisson Neural Networks (LLPNNs)

1. Problem Statement

The paper addresses a fundamental challenge in data-driven modeling of Hamiltonian systems: learning the dynamics of Lie-Poisson systems when only observable data (configurations $g(t)$ and velocities $\xi(t)$ ) are available, while the governing dynamics evolve in latent momentum variables ( $\mu$ ) that are unobservable.

This problem is particularly acute in two contexts:

Symmetry Reduction: Many mechanical systems (rigid bodies, fluids, underwater vehicles) admit symmetry reduction to Lie-Poisson systems where the state space is the dual of a Lie algebra ( $\mathfrak{g}^*$ ), but data is collected in the configuration/velocity space ( $G$ and $\mathfrak{g}$ ).
Degenerate Hamiltonians in Optimal Control: In optimal control problems (e.g., interacting vehicles), the reduced Hamiltonian is often degenerate (linear in certain momentum components). This degeneracy prevents the existence of a corresponding Lagrangian formulation in observable variables. Consequently, the observable variables do not form a closed autonomous dynamical system; the evolution of observable velocities cannot be expressed as $\dot{\xi} = f(\xi)$ because different latent momentum states can yield identical observable velocities but different time derivatives.

Existing structure-preserving methods (e.g., Hamiltonian Neural Networks, Symplectic RNNs) typically assume access to the full phase space or a non-degenerate Legendre transform, rendering them inapplicable or inaccurate for these specific cases.

2. Methodology: Latent Lie-Poisson Neural Networks (LLPNNs)

The author proposes LLPNNs, a framework that learns Lie-Poisson dynamics directly from observable data while reconstructing the hidden momentum trajectories. The method relies on three geometric ingredients:

A. Geometric Foundations

Noether's Theorem & Coadjoint Reconstruction: For systems with Lie group symmetry $G$ , spatial momentum $p_0 \in \mathfrak{g}^*$ is conserved. The latent body momentum $\mu(t)$ is related to the constant spatial momentum via the coadjoint action: $\mu(t) = \text{Ad}^*_{g(t)} p_0$ . This provides an exact bridge between the observable configuration $g(t)$ and the latent momentum $\mu(t)$ .
Handling Degeneracy: The framework explicitly distinguishes between active variables (where the Hamiltonian is non-linear and invertible) and passive variables (where velocities are constant or zero). It does not require a global Legendre transform, allowing it to function even when a Lagrangian formulation does not exist.

B. Two Learning Approaches

The paper presents two distinct architectures for learning the system:

Hamiltonian Approach (Decoder):
- Goal: Learn the Hamiltonian function $h(\mu)$ directly.
- Mechanism: The network parameterizes $h(\mu)$ as a sum of linear terms for passive variables and a neural network residual for active variables.
- Training: For each trajectory, a constant spatial momentum vector $p_0$ is optimized alongside the network weights. The loss minimizes the difference between observed velocities and the gradient of the learned Hamiltonian projected onto active components: $\xi_{pred} = \nabla_\mu h(\text{Ad}^*_g p_0)$ .
- Reconstruction: Uses a Magnus expansion combined with the learned $h(\mu)$ and the conserved $p_0$ to update group elements and momenta step-by-step.
Lagrangian Approach (Encoder / Pseudo-Lagrangian):
- Goal: Learn a "pseudo-Lagrangian" $\ell(\xi_{act})$ that maps active velocities to active momenta.
- Mechanism: Assumes the map between active velocities and active momenta is locally invertible. The network learns $\ell(\xi_{act})$ such that $\mu_{act} = \nabla_{\xi_{act}} \ell(\xi_{act})$ .
- Training: The spatial momentum $p_0$ appears linearly in the loss function (outside the network evaluation), allowing it to be solved via linear least squares for a given network state. The loss minimizes the discrepancy between the predicted active momenta and the coadjoint projection of $p_0$ .
- Reconstruction: Solves an implicit equation (via root-finding) to find the next velocity step that satisfies the momentum update rule derived from the pseudo-Lagrangian.

C. Training Strategy

Warm Start: To avoid local minima, the author initializes the networks with a quadratic approximation (quadratic Hamiltonian/Lagrangian) and solves for the metric matrices and $p_0$ using a constrained linear system (KKT conditions) before unfreezing the neural network weights for full training.
Structure Preservation: The reconstruction algorithm uses Lie-group updates (Magnus expansion) and coadjoint actions, ensuring that Casimir invariants are preserved to machine precision regardless of the learning quality.

3. Key Contributions

Learning from Observables Only: The first framework capable of learning Lie-Poisson dynamics directly from observable configuration and velocity data without requiring latent momentum measurements.
Handling Degenerate Hamiltonians: The method works for both regular and degenerate Hamiltonian systems. It successfully addresses optimal control problems where the observable variables do not admit a closed autonomous evolution equation, a scenario where standard Neural ODEs and DeepONets fail.
Machine-Precision Conservation: The architecture guarantees the exact conservation of Casimir invariants (to machine precision) by construction, independent of the training data or optimization quality.
Dual Formulations: Provides both Hamiltonian (decoder) and Lagrangian (encoder) approaches, offering flexibility depending on whether the active velocity-momentum map is invertible.

4. Experimental Results

The method was validated on three benchmark systems using non-quadratic Hamiltonians:

Generalized Rigid Body (SO(3)):
- Demonstrated near-perfect long-term trajectory tracking for both observable velocities and latent momenta.
- Preserved Casimir invariants ( $\|\mu\|^2$ ) and energy with machine precision.
- Outperformed non-structure-preserving baselines (Neural ODE, DeepONet) which diverged rapidly.
Kirchhoff's Underwater Vehicle (SE(3)):
- Tested on a system with coupled rotational and translational modes.
- Both Hamiltonian and Lagrangian LLPNNs maintained phase accuracy and conserved the two Casimir invariants ( $\|P\|^2$ and $J \cdot P$ ).
- Showed superior robustness to noise compared to baselines.
Multi-Vehicle Optimal Control (SE(2) $^N$ ):
- Crucial Test: A system with a degenerate Hamiltonian (linear in translational momenta, non-linear only in angular momentum).
- Result: Standard Neural ODEs and DeepONets failed immediately because no autonomous vector field exists for the observable velocities. The LLPNNs successfully reconstructed the latent dynamics and predicted long-term trajectories.
- The Lagrangian approach showed slightly better phase alignment for angular velocities in this specific degenerate case, while the Hamiltonian approach achieved the lowest overall error growth.
- Casimir invariants for individual vehicles were preserved to machine precision.

5. Significance and Claims

The paper claims that LLPNNs represent a significant advancement in geometric deep learning by bridging the gap between observable data and latent geometric structures.

Significance: The framework resolves the "hidden state" problem in symmetry-reduced systems. It proves that even when observable variables do not form a closed system (due to degeneracy), the underlying Lie-Poisson structure allows for exact reconstruction of the full dynamics using only observable data and the known symmetry group.
Robustness: The method is robust to noise and requires only modest datasets and lightweight neural network architectures.
Limitations: The author notes that the method assumes the symmetry group $G$ is known a priori. It does not currently handle symmetry-breaking cost functions (where the reduction is incomplete) or general Poisson manifolds lacking the specific coadjoint reconstruction formula.

In summary, the paper establishes that by embedding the geometric constraints of Lie-Poisson systems (specifically Noether invariants and coadjoint actions) directly into the learning architecture, one can achieve accurate, long-term prediction of complex dynamical systems that are otherwise intractable for standard data-driven methods.