From Data to Laws: Neural Discovery of Conservation Laws Without False Positives

The paper introduces NGCG, a neural-symbolic pipeline that reliably discovers conservation laws from diverse dynamical systems with perfect accuracy and zero false positives by decoupling dynamics learning from symbolic extraction and employing strict validation filters.

The Gist

Imagine you are a detective trying to solve a mystery: What rules are governing a chaotic dance?

In physics, these "rules" are called Conservation Laws. They are quantities that never change, no matter how the system moves. Think of them as the "secret score" of a game that stays the same even as the players run around wildly. For example, in a swinging pendulum, the total energy (a mix of speed and height) stays constant.

For centuries, scientists had to use complex math and deep theory to find these rules. But today, we have data. We can record the dance and ask a computer: "Can you figure out the secret score just by watching?"

The problem? Computers are bad at this. They often get confused, find fake rules (false alarms), or get stuck in dead ends.

Enter NGCG (Neural-Guided Conservation-law Generator). Think of NGCG not as a single detective, but as a specialized detective agency with a four-step process designed to catch the real rules and ignore the fakes.

Here is how it works, explained through simple analogies:

1. The "Practice Run" (Stage 1)

Before trying to find the secret score, the agency first learns how the dancers move. They build a simple AI model that predicts the next step of the dance.

• The Analogy: Imagine a dance instructor watching a routine and learning the steps. Once they know the steps, they stop watching and freeze that knowledge. They don't use this instructor to find the score; they just use it to understand the dance so they don't get lost later.

2. The "10-Attempt" Strategy (Stage 2)

Now, the agency tries to find a number that stays the same while the dance happens. They train a small AI to output a number. If the number changes a lot, it's not the secret score.

• The Problem: AI is like a hiker looking for the lowest point in a foggy mountain range. Sometimes, the hiker gets stuck in a small valley (a "local minimum") and thinks it's the bottom, when the real bottom is far away.
• The NGCG Fix: Instead of sending one hiker, they send 10 different hikers starting from different spots. They pick the one who found the deepest, flattest valley. This ensures they don't miss the real rule just because the computer got stuck in a bad spot.

3. The "Specialized Toolbox" (Stage 3)

Once they have a good "flat valley" (a number that barely changes), they need to write it down as a math formula. But different dances need different tools.

• The Analogy: Imagine you have a toolbox.
  • If the dance is a simple spring, you use a Screwdriver (Polynomial Lasso) to find a simple formula.
  • If the dance is a predator-prey game (like wolves and rabbits), the rule involves Logarithms (weird math functions). You swap the screwdriver for a Specialized Wrench (Log-Basis Lasso) designed just for that shape.
  • If the dance is a complex wave (like water), you use a Magic Search Engine (PySR) that tries thousands of combinations until it finds a match.
• Why it matters: Most other methods use only one tool (like a screwdriver) for everything. If the rule needs a wrench, they fail. NGCG switches tools based on the specific dance.

4. The "Lie Detector" (Stage 4)

This is the most important part. The agency has found a few candidate rules. But are they real, or just lucky guesses?

• The "Constancy Gate": They check: "Does this number stay truly constant?" If it wiggles even a tiny bit, it's rejected.
• The "Diversity Filter" (The Lie Detector): This is the genius move. Imagine a rule that says "The number is always 5." That is constant, but it's boring and useless. It doesn't tell you anything about the dance because it's the same for every dancer, no matter who they are.
  • A real conservation law should be constant for one dancer, but different for another dancer with different starting conditions.
  • NGCG checks: "Does this rule change value when we change the starting conditions?" If the answer is "No, it's always the same," the system says, "Fake! Reject!"
  • This stops the computer from claiming that "Chaos" has a rule when it doesn't.

The Results: Why is this a Big Deal?

The paper tested NGCG on 9 different "dances," including:

1. Simple Swings: It found the rules perfectly.
2. Predator-Prey (Lotka-Volterra): This is the "boss level." The rule involves logarithms, which confuses almost every other AI. NGCG was the only one to solve it.
3. Chaotic Systems (Lorenz, Double Pendulum): These are dances with no secret score. Other AIs often get confused and say, "I found a rule!" (a false alarm). NGCG correctly said, "No rule here," every single time.

The Bottom Line

Think of NGCG as a smart, patient, and skeptical detective.

• It doesn't rely on just one guess (it tries 10 times).
• It knows when to use a screwdriver and when to use a wrench (system-specific tools).
• It has a lie detector to catch fake rules (the diversity filter).

The result? It finds the true laws of physics with high accuracy, never lies about finding rules where none exist, and does it fast enough to be useful in the real world. It turns messy data into clear, understandable laws without the "false positives" that have plagued scientists for years.

Technical Summary

1. Problem Statement

The discovery of conservation laws (quantities that remain constant along system trajectories) is fundamental to understanding dynamical systems. However, existing data-driven methods face four critical challenges:

1. Parameter Variation: Most methods assume fixed system parameters and fail when parameters vary across trajectories (a common real-world scenario).
2. Non-Polynomial Invariants: Standard sparse regression and symbolic libraries often lack the basis functions required to discover non-polynomial invariants (e.g., logarithmic terms in the Lotka–Volterra model).
3. Local Minima and False Positives: Variance-minimizing neural networks often converge to poor local minima. On chaotic systems without true invariants, they frequently produce "spurious near-constants" that are falsely identified as laws.
4. Limited Benchmarks: Previous evaluations often lack diversity, failing to test robustness across ODEs, PDEs, chaotic systems, and systems with parameter shifts simultaneously.

2. Methodology: The NGCG Pipeline

The authors propose NGCG (Neural-Guided Conservation-law Generator), a decoupled neural-symbolic pipeline designed to address the above challenges. The architecture consists of four distinct stages:

Stage 1: Neural Dynamics Model (Baseline)

A Multi-Layer Perceptron (MLP) is trained to predict the next state ($x_{t+1}$) from the current state ($x_t$). This model is trained once and frozen. Crucially, it is not used for the discovery of laws itself but serves as a baseline for prediction error and a reference for the system's dynamics.

Stage 2: Multi-Restart Variance Minimizer

A separate, small neural network $\phi$ is trained to output a scalar value that is nearly constant along trajectories.

• Loss Function: A normalized variance loss is used to minimize intra-trajectory variance while preventing the trivial solution where $\phi(x)$ is constant across all trajectories.
• Multi-Restart Strategy: To avoid local minima, the network is trained with 10 independent random restarts. The run yielding the lowest validation constancy is selected. This is critical for complex systems like Lotka–Volterra where single restarts often fail.

Stage 3: System-Specific Symbolic Extraction

Once the optimal $\phi$ network is selected, closed-form symbolic expressions are extracted using a suite of specialized methods rather than a single universal approach:

• Polynomial Lasso: For systems with polynomial invariants (e.g., Harmonic Oscillator, Hénon–Heiles), a library of monomials is constructed. The method computes the covariance matrix of the mean trajectory features and extracts the eigenvector corresponding to the smallest eigenvalue, yielding the linear combination of monomials with minimal variance.
• Log-Basis Lasso: Specifically for the Lotka–Volterra system, the basis is extended to include logarithmic terms ($\ln(x), \ln(y)$) to capture the known logarithmic invariant.
• Explicit PDE Candidates: For PDEs (Burgers, Kuramoto–Sivashinsky), known integral quantities (like spatial mean) are added as explicit candidates.
• PySR Fallback: A genetic programming engine (PySR) is used as a fallback for all systems to search for complex symbolic expressions based on the output of the best $\phi$ network.

Stage 4: Strict Verification Gate and Diversity Filter

To eliminate false positives, two filters are applied to candidate expressions:

1. Strict Constancy Gate: A candidate is accepted only if its test-set constancy (relative standard deviation) is below a strict threshold ($\tau = 0.01$).
2. Diversity Filter: A genuine law must vary between different trajectories (different initial conditions or parameters). The method calculates a ratio $\rho$ of inter-trajectory variation to intra-trajectory fluctuation. Candidates with $\rho < 10$ are rejected as trivial constants or spurious artifacts. This is the key mechanism for preventing false positives on chaotic systems.

3. Key Contributions

• Decoupled Architecture: Separates dynamics learning from invariant discovery to avoid interference and catastrophic forgetting.
• Robustness to Local Minima: The multi-restart strategy ensures the discovery of near-constant representations even in non-convex landscapes.
• Specialized Extraction: The use of system-specific Lasso variants (polynomial and log-basis) allows the discovery of both polynomial and non-polynomial (logarithmic) invariants.
• Zero False Positives: The combination of the strict constancy gate and the diversity filter successfully eliminates spurious laws on chaotic systems, a common failure point for prior methods.
• Comprehensive Benchmark: Evaluation on nine diverse systems (ODEs, PDEs, Hamiltonian, dissipative, chaotic) with parameter variation.

4. Experimental Results

The method was evaluated on a benchmark of nine systems against four baselines: Hamiltonian Neural Networks (HNN), MLP+PySR, SINDy, and IRAS.

• Systems with True Conservation Laws (4 systems):

  • Performance: NGCG achieved a Discovery Rate (DR) of 1.0, False Discovery Rate (FDR) of 0.0, and F1 score of 1.0 on all four systems (Mass-Spring, Lotka–Volterra, Coupled Springs, Hénon–Heiles).
  • Accuracy: The constancy of discovered laws was 2–3 orders of magnitude lower than the best baseline.
  • Lotka–Volterra: NGCG was the only method to successfully discover the logarithmic invariant; all baselines failed (FDR=1.0 or DR=0).
  • Hénon–Heiles: The polynomial Lasso directly recovered the exact Hamiltonian expression.

• Systems without Conservation Laws (5 systems):

  • Performance: On chaotic systems (Double Pendulum, Lorenz, Three-Body) and PDEs (Burgers, KS), NGCG correctly output "no law" with 0.0 FDR.
  • Comparison: Baselines like HNN frequently produced false positives (e.g., claiming a conserved quantity for the Double Pendulum with FDR=0.8). The diversity filter was proven essential for rejecting these spurious candidates.

• Robustness and Efficiency:

  • Noise: Maintained perfect performance under Gaussian noise up to $\sigma = 0.1$.
  • Sample Efficiency: Successfully discovered laws with as few as 50–100 trajectories.
  • Runtime: Approximately 45–50 seconds per system on a single GPU (slightly slower than baselines due to multi-restarts, but justified by accuracy).
  • Pareto Analysis: The pipeline generates a range of candidate expressions, allowing users to trade off complexity for constancy.

5. Significance

This paper establishes a new state-of-the-art for data-driven conservation law discovery. By rigorously addressing the issues of parameter variation, non-polynomial forms, and false positives, NGCG provides a reliable, interpretable, and robust framework. Its ability to correctly identify the absence of laws in chaotic systems is a critical advancement over previous "always-find-a-law" approaches. The open-source nature of the code and datasets further facilitates reproducibility and future research in scientific machine learning.