⚡ electrical engineering

Evaluating the Exp-Minus-Log Sheffer Operator for Battery Characterization

This paper evaluates the Exp-Minus-Log (EML) operator for lithium-ion battery modeling, concluding that while its direct use in forward simulation is computationally inefficient compared to classical methods, it serves as a powerful, differentiable basis for parameter identification when the number of RC branches is unknown.

Original authors: Eymen Ipek

Published 2026-04-16

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Eymen Ipek

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

The Big Idea: One Magic Tool vs. A Swiss Army Knife

Imagine you are trying to describe every possible shape in the world. You could use a massive toolbox with a hammer, a saw, a screwdriver, a ruler, and a drill. That's how most computer models work today—they use different math tools (addition, multiplication, exponentials, logs) to build complex equations.

Recently, a mathematician named Odrzywo lek discovered a "Magic Universal Tool" called the EML Operator. It's a single, strange-looking function: exp(x) - ln(y).

The amazing thing is that if you have this one tool and the number 1, you can build any mathematical function you can think of. It's like having a single Lego brick that, if you stack it in just the right way, can build a castle, a car, or a spaceship. In the world of math, this is as revolutionary as the "NAND" gate is to computer chips (the one tiny switch that can build all of digital logic).

The Problem: The Battery "Black Box"

The paper looks at Lithium-ion batteries (like the ones in your electric car). To predict how a battery behaves, engineers use a model called the 6RC ECM.

Think of the battery as a complex machine with six different "leaky buckets" (resistor-capacitor branches) inside it.

Some buckets leak fast (fast reactions).
Some leak slow (slow diffusion).
To know the battery's voltage, you have to calculate how full or empty all six buckets are at every single moment.

Currently, engineers use a standard, fast method (the "Classical Exponential-Euler") to calculate this. It's like using a specialized wrench that fits the battery perfectly. It's fast and reliable.

The Experiment: Can the "Magic Tool" Do It Better?

The researchers asked: "What if we force the battery model to be built entirely out of the EML Magic Tool?"

They tested this in two scenarios: Running the simulation (predicting the future) and Finding the parameters (figuring out how the battery is aging).

1. Running the Simulation (The "Forward" Problem)

The Result: It was a disaster.
The Analogy: Imagine you need to drive a car from Point A to Point B.

The Classical Method: You drive a sports car. It's built for speed. You get there in 10 minutes.
The EML Method: You try to build the car out of the "Magic Tool" bricks. To make the engine work, you have to stack 500 bricks just to make a simple turn. To make the wheels turn, you stack another 500.
The Outcome: The EML car is so heavy and clunky that it takes 150 to 300 times longer to get to the same destination.

Why? The classical method is already the most efficient way to do the math. Forcing it into the "Magic Tool" format is like trying to write a poem using only the letter "A." You can do it, but it takes forever and looks ridiculous.

Verdict: Do not use this for real-time battery management in a car. It's too slow.

2. Finding the Parameters (The "Identification" Problem)

The Result: This is where the Magic Tool shines.
The Analogy: Imagine you have a broken clock, and you don't know how many gears are inside or how big they are. You need to figure out the internal structure just by listening to the ticking.

Old Methods: You might guess the number of gears (e.g., "It has 6 gears"). If you guess wrong, your math breaks. Or you use a "fuzzy" method that gives you a blurry picture of the gears.
The EML Method: Because the EML tool can build any shape, you don't need to guess how many gears there are. You just let the computer stack the Magic Tools until it perfectly matches the sound of the ticking.
The Bonus: Once the computer finds the perfect stack, it can "snap" it into a clean, simple formula. It's like the computer saying, "I built this complex tower, but actually, it's just a simple house with a red roof."

Why is this good?

It finds the unknown: If an old battery develops a new type of leak (a 7th branch), the EML method can find it. Old methods usually fail here because they are stuck assuming there are only 6.
It's safe and clear: Unlike "Neural Networks" (black boxes that guess and are hard to explain), the EML method produces a clear, written math formula. Engineers can look at it and say, "Yes, this is exactly how the battery works." This is crucial for safety certifications in cars.

The Final Recommendation: A Hybrid Workflow

The paper concludes with a smart, two-step strategy:

Keep the old, fast method for the car's computer. When the car is driving, it needs to calculate the battery voltage in milliseconds. Use the fast, classical "sports car" method.
Use the "Magic Tool" in the lab. When engineers are designing the battery or analyzing how it ages, they should use the EML method. It's slower, but it's a master detective that can find hidden problems and give you a clear, certified blueprint of the battery's health.

Summary

For Speed: The new method is too slow. Stick to the classics.
For Discovery: The new method is a superpower. It can figure out complex, unknown battery behaviors that other methods miss, and it gives you a clear, safe formula to prove it.

The takeaway: Don't use the Magic Tool to drive the car, but definitely use it to design the engine.

1. Problem Statement

The paper addresses the challenge of modeling and characterizing Lithium-ion (Li-ion) batteries using the 6-branch Resistor-Capacitor (6rc) Equivalent Circuit Model (ECM).

Context: The 6rc ECM is increasingly used for aged cells or those with strong temperature dependence because it captures distinct charge-transfer and diffusion processes better than simpler models. However, it introduces 13 parameters (plus OCV maps) and suffers from ill-posed identification problems when time constants overlap.
Current Limitations:
- Simulation: Classical exponential-Euler recursions are efficient but rigid.
- Parameter Identification: Existing methods (analytical time-windowing, Recursive Least Squares/EKF, and Distribution of Relaxation Times (DRT)) have specific drawbacks: they require a priori knowledge of the number of branches, suffer from noise sensitivity, or produce continuous distributions that must be re-clustered.
Research Question: Can the Exp-Minus-Log (EML) operator—a single binary operator recently proven to generate the entire basis of elementary functions—accelerate either the forward simulation or the parameter identification of the 6rc ECM?

2. Methodology

The authors investigate the application of the EML operator, defined as $eml(x, y) = \exp(x) - \ln(y)$ , to the 6rc model. The study is divided into two distinct phases:

A. Forward Simulation Analysis

Reformulation: The standard discretized state-space recursion for the 6rc model (Equation 3) was rewritten entirely in terms of the EML operator.
Complexity Analysis: The authors derived an exact operation count. Since the EML operator replaces all primitives (addition, multiplication, exponentiation) with nested $exp$ and $ln$ calls, the authors calculated the "EML node" depth required to replicate the classical recursion.
Hardware Estimation: They estimated the wall-clock penalty on modern x86-64 CPUs, considering the cost of transcendental function calls.

B. Parameter Identification (Symbolic Regression)

Master-Formula Construction: Instead of using EML for runtime execution, the authors proposed using it as a search basis for symbolic regression.
Architecture: They utilized a "master-formula" approach where an EML tree is initialized with free parameters (logits) at its nodes. The input variable is the time step $\Delta t$ .
Optimization Protocol:
1. Initialize a level-4 EML tree (74 free parameters).
2. Train using Adam optimizer on HPPC (Hybrid-Pulse Power Characterization) data with an entropy regularizer to push weights toward discrete vertices.
3. "Snap" weights to the nearest vertex once entropy is low, converting the neural-like structure into a closed-form algebraic expression.
4. Extract physical parameters ( $R_j, \tau_j$ ) via pattern matching against the canonical 6rc response function.
Hybrid Initialization: The authors suggest seeding the EML search with priors derived from Tikhonov-regularized DRT deconvolution to reduce the search space.

3. Key Contributions

Operational Cost Quantification: The paper provides the first rigorous operation count for implementing a 6rc ECM using the EML operator, revealing a massive computational overhead compared to classical methods.
Structural Completeness Argument: It demonstrates that the EML grammar is "structurally complete," meaning it can theoretically represent any elementary function (including the sum of exponentials required for the 6rc model) without basis mis-specification, a common failure mode in genetic programming.
Differentiable Basis: The authors establish that EML-based parametrization offers a gradient-differentiable basis native to modern automatic differentiation frameworks, unlike many traditional symbolic regression methods.
Certifiability: The paper highlights that once the EML search converges and weights are snapped, the result is a pure algebraic formula. This solves the "black box" opacity problem of Physics-Informed Neural Networks (PINNs), making the model suitable for formal verification (ISO 26262).

4. Results

Simulation Performance (Negative Result):
- Direct EML simulation is significantly slower than the classical exponential-Euler scheme.
- Overhead: The EML approach incurs a ~25× instruction overhead per RC branch and a ~150–300× wall-clock penalty for the full 6rc model.
- Reason: The classical recursion is already at the information-theoretic minimum (one exponential per state). The EML operator forces every arithmetic operation (addition, multiplication) to be expressed as nested exponentials and logarithms, which is computationally inefficient for real-time execution.
- Conclusion: EML is unsuitable for runtime Battery Management Systems (BMS) or Hardware-in-the-Loop (HiL) deployment.
Parameter Identification (Positive Result):
- EML-based symbolic regression (EML-SR) is competitive with and potentially superior to Tikhonov DRT and Genetic Algorithms, specifically when the number of RC branches ( $n$ ) is unknown a priori.
- Unlike DRT, which produces a continuous distribution requiring post-processing, EML-SR directly yields discrete $(R, C)$ pairs.
- Unlike Genetic Algorithms, EML-SR is gradient-based and differentiable.
- The method successfully recovers the 6rc parameters when initialized with DRT priors, overcoming the "basin-of-attraction" issues of random restarts.

5. Significance and Recommendations

The paper concludes with a hybrid workflow recommendation that leverages the strengths of both classical and EML approaches:

Runtime (Online): Retain the classical exponential-Euler recursion for the BMS. It is fast, deterministic, and meets real-time constraints (RTF < 0.5).
Offline (Characterization): Use EML-SR for parameter identification.
- Run this offline on high-fidelity data (e.g., HPPC).
- Seed the search with DRT results to ensure convergence.
- The output is a closed-form, certifiable algebraic model that can be formally verified for safety-critical applications (ISO 26262).

Final Verdict: The EML operator is not a replacement for runtime simulation but a powerful tool for neuro-symbolic parameter identification, offering a bridge between the flexibility of neural networks and the interpretability/certifiability of analytical models.