---
title: Linearly Implicit Quantized State Methods
url: https://www.emergentmind.com/topics/linearly-implicit-quantized-state-systems-liqss-methods
type: topic
---

# Linearly Implicit Quantized State Methods

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 [2512.17855].

## 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 [2512.17855] 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 [2512.17855].

## 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 [2512.17855].

## 7. Connections and Impact

The difference-polynomial framework introduced in [2512.17855] 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.

Source: https://www.emergentmind.com/topics/linearly-implicit-quantized-state-systems-liqss-methods