⚡ electrical engineering

PyCC.id: A package for hypothesis-driven equation discovery with structural identifiability

This paper introduces PyCC, a Python library that facilitates hypothesis-driven ordinary differential equation discovery by leveraging structurally identifiable skeletons to constrain the search space and integrate various equation discovery paradigms.

Original authors: Federico J. Gonzalez

Published 2026-06-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Federico J. Gonzalez

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 a detective trying to figure out the rules of a mysterious machine just by watching it move. You see the gears turn, the springs bounce, and the pistons pump, but you don’t have the blueprint. Your job is to look at the motion and write down the mathematical equation that explains why it moves that way.

This is what scientists call "equation discovery." But there’s a huge problem: it’s like trying to guess a password by looking at the screen. There are millions of different mathematical formulas that could explain the movement you see. Some might be right, but most are just lucky guesses that fit the data by accident. This makes the problem "ill-conditioned"—meaning it’s messy, ambiguous, and hard to solve reliably.

The paper introduces a new software tool called PyCC.id (or just PyCC) that changes how we play this detective game. Instead of letting the computer guess wildly from scratch, PyCC uses a "hypothesis-driven" approach. Here is how it works, explained with a few analogies:

1. The "Skeleton" Analogy

Imagine you are trying to identify a bird. If you just look at a blurry photo, you might guess it’s a pigeon, a dove, or a sparrow. It’s hard to be sure.

But what if you knew for a fact that the bird had wings, two legs, and a beak? You wouldn’t waste time checking if it was a fish or a lizard. You would start with a "skeleton"—a basic framework of what a bird must look like.

PyCC works the same way. Before the computer starts guessing, the scientist provides a "structural skeleton." This is a pre-defined family of equations based on physical intuition. For example, if you are studying a swinging pendulum, you know it involves position, velocity, and friction. You tell PyCC: "The equation must look like this general shape." This drastically reduces the number of wrong guesses the computer has to make.

2. The "Grey Box" vs. "Black Box"

Most modern AI tools are like "black boxes." You feed them data, and they spit out an answer, but you have no idea how they got there. It’s like a magic trick.

PyCC is a "grey box." It doesn’t try to learn the entire universe at once. Instead, it breaks the problem down into small, understandable pieces. Think of it like repairing a car engine. You don’t replace the whole engine; you identify specific parts—the spark plug, the fuel injector, the piston—and fix them individually.

PyCC isolates specific physical forces, like friction or stiffness, and treats them as separate, unknown functions. It learns the shape of the friction curve and the shape of the stiffness curve independently. This makes the final result much easier for humans to understand and verify.

3. Adding "Clues" (Constraints)

In our detective story, you might know some extra clues. For example, "Friction always opposes motion," or "The spring force is zero when the spring is relaxed."

PyCC allows scientists to feed these clues directly into the training process. You can tell the software: "Make sure this function is odd (symmetrical in a specific way)" or "Make sure this value is zero at this point." This ensures that the final equation isn’t just mathematically correct, but also physically sensible.

4. The Toolkit

PyCC is flexible. It doesn’t force you to use one specific method. It’s like a Swiss Army knife that can use different tools to find the answer:

Neural Networks: Great for finding complex, wiggly shapes in the data.
Symbolic Regression: Good for finding clean, algebraic formulas (like $x^2$ or $\sin(x)$ ).
Polynomials: Useful for simpler, smooth curves.

The software can even switch between these methods. For instance, it might use a neural network to get a rough idea of the shape, and then use symbolic regression to turn that rough shape into a clean, human-readable equation.

Why is this useful?

The main benefit of PyCC is structural identifiability. This is a fancy way of saying: "We can prove that this specific structure is the only one that fits the data."

If the skeleton you chose is wrong, PyCC can help you realize it. If it’s right, it gives you a clear, interpretable equation that matches the laws of physics. It moves the process away from "guessing until it fits" and toward "validating a physical hypothesis."

In Summary

PyCC.id is a Python library that helps scientists discover the governing equations of physical systems from data. It does this by:

Restricting the search to physically plausible "skeletons."
Breaking down complex systems into simple, understandable parts (like friction and stiffness).
Incorporating prior knowledge (constraints) to ensure the results make physical sense.
Providing interpretable results that scientists can actually use and understand, rather than opaque "black box" predictions.

It’s not about replacing human expertise; it’s about giving scientists a powerful tool to test their physical intuitions against real-world data.

Technical Summary: PyCC.id – A Package for Hypothesis-Driven Equation Discovery with Structural Identifiability

Problem Statement
Data-driven equation discovery is fundamentally an ill-conditioned inverse problem. While modern methods can infer governing differential equations from time-series measurements, the finite nature of data often allows multiple mathematical models to fit with similar accuracy. This results in a vast landscape of candidate models that, while valid in terms of data fitting, may vary significantly in structural form and lack physical consistency. Consequently, practitioners are often forced to rely on post-hoc manual filtering based on domain expertise, leaving the final model selection somewhat arbitrary. Existing packages often seek the "best" equation from scratch or rely on rigid libraries of basis functions (e.g., sparse identification), which can fail if the true dynamics involve complex or non-standard terms not present in the library.

Methodology
The paper introduces PyCC.id (PyCC), an open-source Python library that implements a hypothesis-driven methodology based on structural "skeletons" inspired by characteristic curves (CCs). The core workflow requires the practitioner to propose a specific structural skeleton—a template defining a family of admissible ordinary differential equations (ODEs)—based on physical intuition or domain knowledge.

The library decomposes global dynamics into skeletons composed of univariate one-dimensional (1D) functions ( $f_i$ ). This approach ensures that the identified components are structurally identifiable and grounded in underlying physics. PyCC supports three distinct identification strategies based on the level of prior knowledge:

Functional Approach: The 1D functions ( $f_i$ ) are treated as unknowns and approximated using universal approximators such as Neural Networks (NN), Symbolic Regression (SymbR), or polynomial expansions.
Parametric Approach: The functional form is fully hypothesized and parameterized using scalar parameters ( $a_i$ ), which are optimized via nonlinear optimization.
Hybrid Approach: A combination of functional discovery for some terms and parametric optimization for others.

The library allows users to integrate physical priors directly into the training process, such as enforcing symmetries (e.g., odd/even parity) or specific boundary conditions (e.g., $f_2(0)=0$ ). It serves as an integrative framework that interfaces with existing tools (like PySR for symbolic regression and PyTorch for neural networks) within a structured pipeline that prioritizes identifiability and interpretability.

Key Contributions

Structural Identifiability Framework: PyCC formalizes the use of structural skeletons that possess demonstrable structural identifiability properties. This provides a formal framework to determine whether a proposed equation is consistent with the data or should be discarded, addressing the ambiguity of the inverse problem.
Modular Integration: The library acts as a manager that internally utilizes established packages (e.g., PySR, PyTorch) but constrains them within a physically motivated structure. It supports multiple back-ends (NN, Poly, SymbR) and hardware acceleration (CPU, NVIDIA CUDA, Intel XPU).
Hypothesis-Driven Workflow: Unlike black-box methods, PyCC enforces a "grey-box" philosophy where only specific, unknown constitutive relations within a fixed skeleton are learned. This ensures that learned components (e.g., damping, stiffness) retain clear physical interpretations.
Core Functions: The library provides three main methods: pycc.simulate() for forward integration and validation, pycc.train() for identifying system dynamics from data, and pycc.post_processing() for converting numerical CCs into explicit symbolic expressions.

Illustrative Example and Results
The paper demonstrates the library’s capabilities using a classic physical system: a nonlinear oscillator with velocity-dependent friction (Coulomb friction modeled via a smooth $\tanh$ approximation). The governing equation is rewritten as a set of first-order ODEs.

Functional Identification: Using the NN method, PyCC successfully recovers the shapes of the unknown characteristic curves $f_1(\dot{x})$ (damping) and $f_2(x)$ (stiffness) from simulated data. The learned functions closely matched the theoretical ground truth.
Post-Processing: The library’s post-processing tool was used to fit the numerically obtained CCs analytically using Symbolic Regression (PySR), demonstrating robustness to noise and the ability to extract interpretable analytical expressions.
Simulation: The identified models were used to simulate the system forward, showing accurate agreement with theoretical predictions.

Significance
The paper claims that PyCC addresses the ill-conditioned nature of the inverse problem by shifting the focus from purely data-driven discovery to a structural skeleton approach. By providing a clear pathway to validate or eliminate hypothesized structures at the algorithmic level, the library mitigates structural ambiguity. It enables practitioners to seamlessly define skeletons and hypotheses, reducing the search space and facilitating the discovery of interpretable, physically consistent governing equations. The library is positioned not as a replacement for existing packages, but as an interface that leverages their strengths within a framework that ensures physical consistency and structural identifiability.