Linearly Implicit Quantized State Methods

• LIQSS methods are numerical integrators for ODEs that combine event-driven quantization with linear implicit treatment to effectively handle stiff and complex dynamics.
• They employ piecewise-polynomial state approximations and local event handling to achieve controlled global error and efficient computation.
• Recent extensions like eLIQSS and CheQSS further optimize error control and step size selection, enhancing performance on high-dimensional, event-rich systems.

Linearly Implicit Quantized State System (LIQSS) methods are a class of numerical integrators for ordinary differential equations (ODEs) that combine the event-driven, asynchronous state quantization of Quantized-State System (QSS) integrators with linearly implicit treatment of stiff terms. These methods enable efficient and robust simulation of stiff, high-dimensional, and event-rich dynamical systems, and recent generalizations identify new algorithmic sub-families with improved stability, error control, and efficiency (Bergonzi et al., 19 Dec 2025).

1. Foundations: QSS and Linearly Implicit QSS

Consider an autonomous ODE system: $$\dot {\mathbf x}(t) = f(\mathbf x(t), t), \quad \mathbf x \in \mathbb R^N.$$ Classical time-stepping methods compute $\mathbf x(t)$ at synchronized time instances with fixed or adaptive time-steps. QSS methods, by contrast, represent the state $\mathbf x(t)$ by a vector of quantized states $\mathbf q(t)$. Each component $q_i(t)$ is a piecewise-polynomial approximation to $x_i(t)$ that only updates (i.e., triggers an event) when $|x_i(t) - q_i(t_k)| = \Delta Q_i$ for some quantum $\Delta Q_i$.

The QSS approximate dynamics is thus: $\dot {\mathbf x}(t) = f(\mathbf q(t), t)$ with a component-wise hysteretic quantization, in which $q_i(t)$ remains unchanged except at event times when the deviation exceeds $\Delta Q_i$. This leads to an event-driven integration scheme where only affected states and their dependencies require local re-evaluation.

LIQSS extends QSS for stiff ODEs by linearizing $f_i$ in $x_i$ at each quantization event: $$a_i = \frac{\partial f_i}{\partial x_i}\big|_{(\mathbf q(t^i_j), t^i_j)}, \quad u_i(t) = f_i(\mathbf q(t), t) - a_i q_i(t)$$

$\dot x_i(t) \approx a_i q_i(t) + u_i(t)$

At events, the next quantized value $q_i^*$ can be chosen by solving the scalar equation $0 = a_i q_i^* + u_i(t)$, maintaining the locality and sparsity of QSS while improving performance on stiff, diagonal dynamics.

2. Unification via Difference Polynomials and New Method Families

The generalization in (Bergonzi et al., 19 Dec 2025) introduces a unified framework using a "difference polynomial": $p_i(t) = x_i(t) - q_i(t)$ The event scheduling and quantized update rules are crafted so that $|p_i(t)| \le \Delta Q_i$ over the interval $[t_k, t_{k+1}]$, providing global error control.

Using this formalism, classic LIQSSn methods correspond to $p_i(t) = b_n (t_m-t)^n$ with parameters selected so the error at the endpoint reaches exactly $\Delta Q_i$. The update requires solution of a scalar algebraic equation of degree $n$.

Two new sub-families arise:

• Extended LIQSS (eLIQSS): Maintains the same difference polynomial form as LIQSS, but restricts each quantization event to exactly where $|x_i(t) - q_i(t)| = \Delta Q_i$, not allowing for possible overshoot. This adjustment reduces the maximum possible global error from $2\Delta Q_i$ to $\Delta Q_i$.
• Chebyshev LIQSS (CheQSS): Chooses $p_i(t)$ as a shifted Chebyshev polynomial $T_n$, with normalization ensuring equioscillation and optimal polynomial error:

$$p_i(t) = \mathrm{sign}(b_n)\, \Delta Q_i\, T_n\left(\frac{2t-\Delta t}{\Delta t}\right)$$

The event interval $\Delta t$ is maximized so that the difference remains within the quantum, using the local $n$th derivative as a “local activity” estimate. This leads to optimal step sizes and minimal number of quantization events for given polynomial degree.

3. Theoretical Properties: Stability, Error Bounds, Event Handling

Stability: Under Lipschitz continuity of $f$ in $\mathbf x$, the QSS and LIQSS approximations are viewed as perturbations of the true system by a bounded disturbance $\Delta(t)$, $|\Delta_i(t)| \le \Delta Q_i$. A Grönwall argument establishes practical stability with error proportional to $\exp(Lt) \max_i \Delta Q_i$. Partial implicitness for stiff diagonal blocks ensures retention of A-stability for those components.

Global Error Bounds:

For linear time-invariant systems,

$$\max_{0 \le t \le T} \|\mathbf x_\text{exact}(t) - \mathbf x(t)\| \le (e^{\|A\|T}-1) \max_i \Delta Q_i$$

implying first-order global accuracy in quantum size for LIQSS, eLIQSS, and CheQSS ($O(\Delta Q)$). Higher-order QSSn achieves $O(\Delta Q^{1/n})$ in appropriate norms.

Event Handling: Each $q_i(t)$ is piecewise-polynomial, facilitating analytic computation of zero-crossings for discontinuity detection. Event processing is local: only variables directly affected by the state change require re-evaluation, yielding $O($#affected$)$ computational overhead, not $O(N)$. This achieves substantial efficiency for sparse or locally coupled systems with event-driven features.

Event-Driven Pseudocode (paraphrased schema):

• At each step, for all $i$ predict the next $t_i$ at which $|x_i - q_i| = \Delta Q_i$ or a zero-crossing occurs.
• Advance all $x_i$ analytically to the minimum predicted event time $\tau$.
• Process all events at $\tau$: update $q_i$, re-evaluate local Jacobians/derivatives as needed.

4. Numerical Performance and Benchmark Results

Implementations of LIQSS, eLIQSS, and CheQSS (orders 1–3) in the Stand-Alone QSS Solver were benchmarked against traditional QSSn, standard LIQSSn, and conventional algorithms (DOPRI, CVODE–BDF) on two stiff, high-dimensional problems:

Advection–Diffusion–Reaction:

• 100-node discretized stiff ADR system with

$$\dot x_i = -A\frac{x_i-x_{i-1}}{\Delta x} + D\frac{x_{i+1}-2x_i+x_{i-1}}{\Delta x^2} + R(x_i^2-x_i^3)$$

$(A=1, D=0.1, R=100)$.

• eLIQSS and CheQSS reduce step count and CPU by up to 50\% relative to standard LIQSS.
• CheQSS2 requires ~$3 \times 10^3$ events vs. $4.3 \times 10^3$ in LIQSS2, for the same MAE $\approx 10^{-4}$.
• eLIQSS3 slightly outperforms CheQSS3 in CPU due to fewer Jacobian re-evaluations; both are 2–3× faster than CVODE–BDF at loose tolerances.

Spiking Neural Network:

• 1000-neuron leaky integrate-and-fire network, Poisson input.
• Mean relative error in spike count $\mathcal{O}(10^{-4})$ at $\Delta Q = 10^{-3}$ with CheQSS2/3 and eLIQSS2/3, needing $2$–$5\times10^5$ events in <1s.
• Classic QSSn uses about twice as many events and $30$–$50\%$ more CPU than CheQSS.
• DOPRI requires $\sim6\times10^4$ steps, each updating 2000 variables, costing orders of magnitude more time ($7$–$8$s).

These results highlight the efficiency of event-local quantization, particularly with Chebyshev-optimized steps, for stiff and heterogeneous systems (Bergonzi et al., 19 Dec 2025).

5. Algorithmic Workflow and Comparative Properties

Family	Quantization Policy	Event Bound	Step-Size/Order
LIQSSn	$p_i(t) = b_n (t_m-t)^n$ with possible overshoot	$2 \Delta Q_i$	Scalar poly root
eLIQSSn	Same as LIQSSn, but event at $|p_i(t)| = \Delta Q$	$\Delta Q_i$	Scalar poly root
CheQSSn	Chebyshev $p_i(t)$, equioscillation, optimal $\Delta t$	$\Delta Q_i$	Scalar poly root, optimal $n$

The explicit control of global error, event locality, and elimination of global matrix operations during stepping differentiate these schemes from classical stepper-based integrators.

6. Limitations and Research Directions

Current limitations are most pronounced in handling stiff, non-diagonal Jacobians, where blockwise extensions may be required. The need for efficient computation of higher local derivatives $u_i^{(k)}$ for high-order QSSn or CheQSS remains a challenge. Open research questions include:

• Designing nonlinear implicit quantization algorithms beyond the linearly implicit case.
• Automatic, per-variable adaptation of quantization degree $n$ and quantum sizes $\Delta Q_i$ for local error control.
• Extension of the CheQSS framework to delay differential equations and partial differential-algebraic systems.

Potential application domains include large-scale stiff circuit simulation, multiscale reaction kinetics, and event-rich hybrid dynamical systems, where asynchrony and efficient event handling are critical (Bergonzi et al., 19 Dec 2025).

7. Connections and Impact

The difference-polynomial framework introduced in (Bergonzi et al., 19 Dec 2025) subsumes and improves prior LIQSSn approaches, clarifies update rule derivations, and provides a systematic path to method optimization (error bounds, step-size selection, event synchronization). This unification aligns quantization-based ODE integration with classic ideas of polynomial approximation and zero distortion over maximal intervals, suggesting broad applicability and grounds for future theoretical development. These algorithms represent a rigorously justified, highly efficient class of event-driven integrators that blend quantization and (partial) implicitness, offering practical advantages in modern simulation settings characterized by stiffness and high event rates.