Quantized State Systems Method¶

A family of event-driven numerical integrators that quantize state trajectories instead of time, scheduling each component's next update when its continuous state departs from its quantized surrogate by a prescribed quantum.

Version: v2 · 2026-09-07 · History
Domain-specific #: 2590
Origin domain: numerical simulation
Subdomain: quantization-based integration
Aliases: Quantized State System methods, QSS methods, Quantization-based integration

Core Idea¶

The Quantized State Systems (QSS) method is a family of numerical integration methods for ordinary differential-equation and hybrid-system simulation^[1]. Conventional solvers usually choose successive times and compute approximate states at those times. QSS reverses the organizing choice: time remains continuous, while each state component is represented to the derivative function by a quantized surrogate. An event is scheduled when the continuously evolving state is predicted to differ from that surrogate by a prescribed quantum. The component then updates its surrogate and schedules its next threshold crossing.

For an initial-value problem

\[ \dot{\mathbf{x}}(t)=\mathbf{f}(\mathbf{x}(t),\mathbf{u}(t),t), \qquad \mathbf{x}(t_0)=\mathbf{x}_0, \]

first-order QSS replaces the derivative input \(\mathbf{x}\) with a quantized vector \(\mathbf{q}\):

\[ \dot{\mathbf{x}}(t)=\mathbf{f}(\mathbf{q}(t),\mathbf{u}(t),t). \]

For component \(i\), a hysteretic quantizer keeps \(q_i\) fixed until \(|x_i-q_i|\) reaches a quantum \(\Delta Q_i\), then updates \(q_i\) to the current state. Each component can change at a different event time. Higher-order QSS methods use richer piecewise-polynomial state and quantized trajectories; stiff-system variants alter how future or implicit state information enters the quantized update.

The defining identity is therefore not “rounding a state.” It is state-quantized, threshold-scheduled integration with asynchronous discrete events.

Structural Signature¶

The method family has nine load-bearing roles:

the continuous-time model — an ODE or compatible hybrid model that defines state derivatives and discrete changes;
the continuous state trajectory — \(x_i(t)\), internally advanced between events;
the quantized surrogate — \(q_i(t)\), supplied to dependency equations in place of the exact continuously varying state;
the quantum — \(\Delta Q_i\), possibly absolute, relative, or adaptively chosen, setting allowed surrogate deviation;
the hysteretic update rule — memory that retains the prior surrogate until a boundary is reached and then resets it;
the next-crossing prediction — a calculation of when \(x_i(t)\) will next reach a quantization boundary;
the asynchronous event scheduler — selects the earliest component event rather than advancing every variable on one global step;
the dependency propagation rule — recomputes only derivative or output relations affected by the changed quantized component;
the reconstructed approximation — the event-defined numerical trajectory used to estimate the modeled system.

The invariant is: a state's deviation from its quantized surrogate, not the expiration of a preselected global time step, determines the component's next update. A method may adapt time steps or detect events without qualifying. It must organize integration around quantized-state crossings and their discrete-event propagation.

What It Is Not¶

QSS is not quantization in quantum physics, signal digitization, fixed-point arithmetic, or state-space discretization for model checking. Those may replace continuous values by discrete representatives, but they do not necessarily generate a numerical ODE trajectory by scheduling quantum-crossing events.

It is not an ordinary fixed-step method. In Euler or Runge–Kutta integration, a clock step triggers a simultaneous numerical update. In QSS, components generally update asynchronously when their state error reaches a threshold. It is also not merely an adaptive time-step method: an adaptive solver still chooses a sequence of time steps and advances a coupled state vector at accepted times.

QSS is not synonymous with the Discrete Event System Specification (DEVS). QSS trajectories can be represented and implemented as discrete-event models, and the original literature emphasizes that connection^[2]. DEVS is a broader modeling formalism; most DEVS models are not QSS integrators.

The base QSS1, QSS2, and QSS3 methods should not be equated with BQSS, CQSS, LIQSS, or modified LIQSS variants^[3]. These share the state-quantization architecture but differ in order, stability strategy, future-state treatment, and applicability to stiff systems.

Scope of Application¶

QSS applies to numerical simulation of continuous and hybrid dynamical systems described primarily by ODEs, sometimes within broader differential-algebraic or discrete-event model structures. It is especially relevant when state changes are sparse or localized, components evolve on different activity schedules, discontinuities and threshold events are important, or a discrete-event simulation engine is the natural execution substrate.

Applications in the literature include electrical and power-electronic systems, control models, large sparse systems, and hybrid models with switching^[4]. Suitability is conditional. Explicit QSS methods can perform poorly on stiff systems because quantized variables may generate high-frequency event activity. BQSS and linearly implicit QSS families were designed for stiffness, but published analyses impose structural conditions and do not justify a claim that every stiff system is efficiently solved^[4].

The abstraction covers the family architecture rather than one order or implementation. A record should specify QSS1, QSS2, QSS3, LIQSS, or another variant when accuracy order and stability behavior matter. “QSS” alone establishes the state-quantized event mechanism, not a complete performance guarantee.

Clarity¶

A solver qualifies as QSS when five diagnostic questions all have affirmative answers:

Does it maintain a continuous or polynomial approximation \(x_i(t)\) together with a distinct quantized surrogate \(q_i(t)\)?
Is a quantum or hysteretic band defined for each quantized state component?
Is the next local update time predicted from a crossing of that band?
Can state components update asynchronously rather than only on a common clock grid?
Does a changed quantized state propagate through a discrete-event dependency structure to update affected dynamics?

The fourth condition distinguishes QSS from merely rounding a conventional solver's state. The fifth distinguishes it from a collection of unrelated scalar threshold detectors. A complete implementation also needs initialization, simultaneous-event handling, discontinuity rules, error/quantum policy, and termination semantics.

For QSS1, the quantized trajectory is piecewise constant. Higher-order methods alter that trajectory's local representation, so “piecewise constant output” is not a family-wide invariant. The family invariant is the use of quantized state approximations to schedule state events.

Manages Complexity¶

QSS converts continuous integration into a locally scheduled event problem. That reframing can exploit sparsity: if one quantized component changes, only equations that depend on it need be reconsidered. In a time-stepping solver, even inactive components may be revisited at every global step. QSS therefore makes computational activity follow model activity rather than clock ticks.

The method also integrates threshold location into ordinary operation. A QSS component is continually solving for its next quantization crossing, so state-event detection is not an auxiliary search bolted onto a stepper. This can be valuable for hybrid models with frequent discontinuities, although handling simultaneous events and discontinuous right-hand sides still requires explicit semantics.

Finally, the abstraction separates accuracy control from time-step control. The quantum sets an allowed local state-surrogate deviation; the event schedule emerges from the dynamics. This gives modelers a different tradeoff surface: smaller quanta ordinarily increase event count and improve approximation, while larger quanta reduce activity but coarsen the trajectory.

Abstract Reasoning¶

Suppose one autonomous scalar QSS1 component has fixed \(q\) between events. Then \(\dot{x}=f(q)\) is constant over that interval and \(x\) evolves linearly. If the derivative is positive, the next event solves \(x(t)=q+\Delta Q\); if negative, it solves \(x(t)=q-\Delta Q\). Thus the solver predicts a time from a state boundary rather than predicting a state from a chosen time.

The inverse relationship between quantum and event count follows qualitatively: for a monotone excursion of fixed magnitude, halving the quantum roughly doubles the number of quantized transitions, absent changes in trajectory or higher-order effects. This is a design tendency, not a universal complexity theorem.

For stable linear time-invariant systems, Kofman's QSS/QSS2 analysis derives error bounds proportional to the quantization vector and independent of simulation duration under stated assumptions^[5]. That result is important but scoped. It does not prove uniform bounded error for every nonlinear, unstable, stiff, or discontinuous model.

Because updates are asynchronous, a model's dependency graph predicts computational locality. A component with no dependency path from the changed surrogate need not immediately recompute. Conversely, dense coupling or rapid alternating crossings can erase the advantage by producing widespread event cascades.

Knowledge Transfer¶

Within numerical simulation, the QSS structure transfers across physical domains because it attaches to the mathematical model rather than to a particular plant: circuits, mechanical systems, control laws, and transport models can all be expressed through state derivatives and dependency relations. The same quantized-event mechanism can then be implemented in different simulation engines.

QSS also supplies a conceptual bridge between continuous-system integration and discrete-event simulation. Continuous trajectories generate future threshold events; event processing updates the surrogates that determine future derivatives. This bridge supports modular and potentially parallel execution, but only when causal ordering, simultaneous events, and dependencies are handled correctly.

Outside simulation, threshold-triggered updates appear in level-crossing sampling, event-triggered control, and delta modulation^[6]. Those are informative analogies and sometimes technical relatives, not automatic QSS instances. A sensor that reports only when a value changes by a threshold does not become an ODE integrator unless it also plays the surrogate, scheduling, and derivative-propagation roles.

Examples¶

Scalar decay. For \(\dot{x}=-ax\), QSS1 evaluates the derivative using a piecewise-constant \(q\). The continuous approximation moves until it differs from \(q\) by \(\Delta Q\), then the surrogate drops by one quantum and a new event time is predicted. No global time grid is chosen.

Sparse network. In a large model, one component's quantized state crosses its boundary. Only derivatives whose equations depend on that component are updated, and each affected component revises its own next event. The local propagation is the computational benefit; merely using a small time step everywhere would be a non-example.

Switched system. A modeled threshold changes a circuit configuration. QSS's event-oriented execution can process the discontinuity and then reschedule affected quantized trajectories. The discrete switch event and the numerical quantization events remain distinct even though the same scheduler may handle both.

Stiff power model. A LIQSS variant uses linearly implicit ideas within the quantized-state architecture to suppress event-intensive oscillation that defeats explicit QSS. It remains within the family because state quantization and asynchronous crossing events still organize integration.

Non-example—adaptive Runge–Kutta. A solver estimates local truncation error, shortens its next time step, and updates all states at that accepted time. Adaptivity alone does not make it QSS.

Structural Tensions¶

Accuracy versus event activity. Smaller quanta usually tighten state approximation while increasing event traffic. Relative and absolute quantum policies help scale variables, but choosing them remains a modeling decision analogous—not identical—to choosing tolerances in time-stepping solvers.

Locality versus coupling. Asynchronous updates can exploit sparse dependencies and inactive regions. Dense models or strongly interacting states cause each event to invalidate many predictions, reducing locality.

Explicit event timing versus numerical burden. Low-order polynomial trajectories often permit direct prediction of the next crossing. Higher-order representations can improve accuracy per event but make crossing computation more difficult and may require iterative roots.

Discontinuity handling versus event cascades. Discrete-event organization makes state discontinuities natural to represent. Closely spaced or simultaneous changes can create ordering, confluent-event, and rescheduling problems that an implementation must resolve.

General explicit method versus stiffness. Basic QSS is conceptually simple, but stiffness can provoke excessive events. Implicit and linearly implicit variants extend the family at the cost of additional structure and restricted efficiency conditions.

Structural–Framed Character¶

The QSS method is strongly structural–framed. It specifies typed mathematical objects, a memory-bearing quantizer, an event-generation rule, an asynchronous scheduler, a dependency propagation mechanism, and a reconstructed numerical trajectory. These roles yield exact recognition tests, performance hypotheses, and failure modes.

The abstraction is not merely the proposition that continuous values can be discretized. It coordinates a reusable solver architecture. Implementers can vary polynomial order, quantum policy, stiffness treatment, data structures, and execution engine while preserving the state-quantized event invariant.

Its frame is numerical integration. State error, derivative evaluation, trajectory approximation, stability, convergence, stiffness, discontinuity handling, and event scheduling are constitutive. Removing that frame leaves generic quantization or threshold-triggered activation, both already represented at the prime level.

Structural Core vs. Domain Accent¶

The structural core is threshold-triggered local update: maintain an approximation, observe continuous deviation, activate a rule at a boundary, and propagate the changed representation to dependents. A second portable core is the choice between discretizing an independent coordinate and discretizing the evolving state.

The domain accent fixes ODE integration, continuous state trajectories, derivative functions, quantized surrogates, error quanta, next-event prediction, solver order, stability, and reconstructed trajectories. Those elements make QSS more than an instance of generic event-driven processing.

Transfer should preserve this division. An event-triggered sensor may instantiate the threshold core without being QSS. A QSS2 or LIQSS implementation preserves both the core and the numerical domain accent despite changing the surrogate order or stability treatment.

QSS most directly presupposes Threshold-Triggered Rule Activation: each component's deviation reaches a quantization boundary and activates a surrogate update plus dependency propagation. This is the smallest useful DAG parent because the threshold crossing organizes the solver's temporal behavior.

The method also instantiates Discrete vs. Continuous (Quantization) by retaining continuous time while discretizing the communicated state representation. That prime explains the duality with time discretization, but its one-line scope does not supply event scheduling, numerical integration, or dependency propagation.

Event-driven processing, feedback, approximation, and error budgeting are additional structural relations. They remain prose relations to avoid an inflated parent set. A future live Numerical Integration or Discrete-Event Integration node may warrant a locality review.

Relationships to Other Abstractions¶

Current abstraction Quantized State Systems Method Domain-specific

Parents (1) — more general patterns this builds on

Quantized State Systems Method presupposes Threshold-Triggered Rule Activation Prime

QSS most directly presupposes Threshold-Triggered Rule Activation: each component's deviation reaches a quantization boundary and activates a surrogate update plus dependency propagation.

Hierarchy path (1) — routes to 1 parentless root

Quantized State Systems Method → Threshold-Triggered Rule Activation → Threshold

Neighborhood in Abstraction Space¶

Quantized State Systems Method sits in a sparse region of the domain-specific corpus (88^th percentile for distinctiveness): few abstractions share its structure, so a faithful description tends to retrieve it precisely.

Family — Quantum States & Thermal Dynamics (12 abstractions)

Nearest neighbors

Computed from structural-signature embeddings · 2026-09-08

Not to Be Confused With¶

Fixed-step integration: advances a coupled state on a chosen time grid.
Adaptive time stepping: changes the time grid using error estimates but remains time-discretized.
Event detection in a conventional solver: locates selected roots without reorganizing all integration around state quantization.
DEVS: a general discrete-event modeling formalism capable of hosting QSS but not synonymous with it.
Level-crossing sampling: emits signal samples at amplitude changes without necessarily integrating a dynamical model.
Event-triggered control: schedules sensing or control action by a state condition; it may use QSS ideas but has a control rather than integration identity.
State abstraction for verification: creates a finite transition system rather than an approximate continuous numerical trajectory.
Quantum computing or stochastic quantization: unrelated uses of quantized.
LIQSS/BQSS/CQSS: specialized members or relatives within the broader quantization-based integration family, not unrestricted names for QSS1.

References¶

[1] Cellier and Kofman. Continuous System Simulation. Springer Science & Business Media, 2006. The textbook chapter 'Quantization-based Integration' (pp. 555-629), which gives quantization-based ODE integration its standard textbook treatment alongside the classical single-step, multi-step and DAE method families. registry ↩

[2] Kofman, Ernesto and Junco, Sergio. “Quantized-State Systems: A DEVS Approach for Continuous System Simulation”. Transactions of the Society for Computer Simulation International, 2001. The founding QSS paper, which introduces quantized state systems precisely as a DEVS discrete-event formulation of continuous-system simulation. registry ↩

[3] Migoni, Kofman, and Cellier. “Quantization-based new integration methods for stiff ordinary differential equations”. SIMULATION, 2011. The paper that introduces the two first-order stiff-oriented siblings by name – backward QSS (BQSS) and centered QSS (CQSS) – as new solver classes distinct from the base quantized-state methods. registry ↩

[4] Migoni, et al. “Linearly implicit quantization-based integration methods for stiff ordinary differential equations”. Simulation Modelling Practice and Theory, 2013. The LIQSS paper, whose demonstrated application is the simulation of electronic circuits; the control-model, large-sparse-system and switching-hybrid items in this list rest on other work. The LIQSS paper, which designs the linearly implicit quantized-state family for stiff ODEs and validates its efficiency on two benchmark problems rather than in general; the structural restriction is stated explicitly in the same group's 2019 follow-up. registry ↩a ↩b

[5] Kofman. “A Second-Order Approximation for DEVS Simulation of Continuous Systems”. SIMULATION, 2002. Kofman's QSS2 paper, which deduces a closed formula relating the quantization to an error bound holding over the whole simulation for linear time-invariant systems, a result stated for both QSS and QSS2. registry ↩

[6] Heemels, Johansson, and Tabuada. “An introduction to event-triggered and self-triggered control”. 2012 IEEE 51^st IEEE Conference on Decision and Control (CDC), 2012. The standard tutorial on event-triggered and self-triggered control, covering the middle item in this list – control updates issued on threshold violation rather than on a clock. registry ↩