Discrete-Event Scheduling Semantics

• Discrete-event scheduling semantics are a rigorous framework defining atomic event execution, exact timing, and formal state transitions in discrete-event systems.
• They extend to timed and stochastic models through methods like synchronous product construction and thinning techniques, ensuring accurate simulation in hybrid and distributed architectures.
• The framework supports distributed coordination and run-to-completion models with proven correctness, complexity bounds, and performance guarantees across cyber-physical and manufacturing systems.

Discrete-event scheduling semantics define the precise behavior, execution order, and timing of event occurrences in discrete-event systems (DES). Such systems underpin a range of modeling paradigms, including distributed cyber-physical systems, hybrid automata, manufacturing scheduling, and stochastic or timed networks. Discrete-event scheduling semantics rigorously specify how the system state evolves via atomic, instantaneous events that are scheduled and processed according to formal rules. These semantics support deterministic execution, conformance between models and real systems, and robust analysis or synthesis for correctness and performance guarantees. This article systematically presents foundational models, stochastic extensions, hybrid and timed systems, and distributed/distributed-consistent variants, providing formal definitions, complexity analyses, and results from the latest research.

1. Formal Discrete-Event Scheduling Semantics

Discrete-event scheduling semantics characterize system evolution in terms of instantaneous events that induce state transitions at discrete points in an underlying time domain.

• System State and Event Queue: At simulated time $t$, the global state $S(t)$ includes the simulation clock $t$, a history (filtration) $\mathcal{F}_{t^-}$ of past events, and a priority queue $Q$ of scheduled potential events $\{(T_i, j_i)\}$, where $T_i$ is a future event time and $j_i$ denotes an event type, such as “neuron $j$ spikes at time $T$” (Phi et al., 2019).
• Event Execution: Events are processed in nondecreasing tag order; in distributed systems, tags are pairs $(t, m)$ for time $t$ and microstep $m$, totally ordered to support both physical and logical concurrency (Jun et al., 9 Oct 2024, Donovan et al., 20 May 2024).
• Scheduling Rules: When an event is accepted, the clock advances to its time and local state (and intensities, in point-process models) is updated. Rejected (thinned) events leave no state changes but still result in a clock advance (Phi et al., 2019). “Idle intervals” are not explicitly represented.

In Table 1, several foundational semantic ingredients for discrete-event scheduling systems are summarized:

Ingredient	Description
State S(t)	Includes clock t, filtration of past events, and event queue Q
Event	Atomic, labeled state transition; e.g., “neuron spikes”, “job starts”, “mode switches”
Scheduling mechanism	Priority queue or race policy (earliest event, stochastic competition, or controller arbitration)
Time model	Real-valued, integer, or superdense tags $(t, m)$
Execution model	Centralized, distributed, run-to-completion, fixed-point, stochastic thinning, etc.

This formulation generalizes seamlessly across domains: finite and infinite networks, timed systems, hybrid automata, and distributed architectures (Phi et al., 2019, Jun et al., 9 Oct 2024, Donovan et al., 20 May 2024, Alrahman et al., 2020, Willemsen et al., 2023).

2. Timed and Stochastic Event Scheduling

Timed discrete-event systems (TDES) refine DES by associating lower and upper firing intervals for each event.

• Synchronous Product Construction: TDES can be built as the synchronous product of one untimed “activity automaton” (logical control) and per-event “timer automata” that enforce time-window constraints. Timer automata synchronize on enable/disable/fire events and a global tick, encoding earliest/latest firing semantics (Lin, 2018).
• State-Space and Correctness: The combined automaton enforces all timing constraints via synchronous execution, with bisimulation-equivalence between operational interval-semantics and the product automaton’s run-tree (Lin, 2018).

Stochastic discrete-event semantics arise in multiple frameworks:

• Ogata’s Thinning / Stochastic Races: Candidate event times are proposed via a dominating Poisson rate, and each event is accepted or thinned according to its instantaneous conditional intensity. This underpins perfect simulation methods for neural and point-process networks (Phi et al., 2019).
• Hybrid Automata Extensions: Stochastic hybrid automata admit two canonical semantics:
  • Decomposed Scheduling: Each event (“jump”) is associated with an independent random clock; the event whose clock expires first fires—a stochastic race (Willemsen et al., 2023).
  • Composed Scheduling: The time to the next event is sampled first according to a density $g_\sigma(t)$, then the specific event is chosen probabilistically, conditioned on the time; this captures global scheduling policies or dependencies (Willemsen et al., 2023).

For compositional expressivity, every decomposed automaton admits an equivalent composed scheduling, but not vice versa; composed semantics strictly subsume decomposed in terms of trace probability (Willemsen et al., 2023).

3. Advanced Models: Switched, Infinite, and Run-To-Completion Semantics

Discrete-event scheduling supports complex extensions for modularity and real-world constraints.

• Switched Max-Plus Linear-Dual Inequalities (SLDIs): SLDIs extend max-plus/min-plus linear inequality systems for event timing (as in P-time event graphs) to admit explicit schedules (modes), each imposing distinct timing constraints. The switching pattern is an explicit sequence (regular or periodic), and the system’s cycle times can be efficiently computed using spectral theory and automata-lumping techniques (Zorzenon et al., 2022).
• Infinite-Network Simulation via Kalikow Decomposition: For infinite-network stochastic point processes, the Kalikow decomposition enables correct simulation of a target’s history by recursively “sampling” random neighborhoods. The associated backward-forward scheduling merges thinning/race steps with perfect reconstruction of dependency cones, guaranteeing correctness under a subcriticality (sparsity) condition (Phi et al., 2019).
• Run-To-Completion Scheduling: The run-to-completion (RTC) model, developed for controller synthesis, explicitly encodes alternation of controller- and environment-owned “control turns”. In each turn, either party may execute a finite (but unbounded) spurt of events without interruption, but non-Zeno constraints ensure mutual progress. RTC legality and non-starvation are formalized in the controller synthesis problem and can be reduced to classical DES supervisory control with modest complexity overhead (Alrahman et al., 2020).

4. Distributed and Strongly Consistent Discrete-Event Scheduling

Distributed DE (DDE) systems require coordination for causality and determinism preservation in the presence of network communication and cycles.

• Superdense Tag-Based Semantics: Events are labeled with superdense tags $(t, m)$, which provides a well-founded order across distributed reactions and explicit handling of simultaneous or micro-stepped behaviors (Jun et al., 9 Oct 2024, Donovan et al., 20 May 2024).
• Coordination Protocols: High Level Architecture (HLA)-style protocols enforce causality by requesting each federate to announce its next event tag (NET), confirm completion up to a logical time (LTC), and allow the central runtime (RTI) to issue advance-grants (TAG). Federates may process events at a tag $g$ only when guaranteed no future messages with tag $\leq g$ can arrive (Jun et al., 9 Oct 2024).
• Optimizations: Recent DNET (“deferred NET”) protocols minimize unnecessary NET messages by communicating to federates precisely which next-event announcements are needed for safe downstream progress, demonstrated to provide exponential message reduction without altering correctness (Jun et al., 9 Oct 2024).
• Fixed-Point and Strong Consistency: The “reactor” model with fixed-point semantics generalizes DE to support zero-delay cycles, provided the composed reaction graph is constructive (no causality cycle). Schedulers are required to converge to the unique least fixed point for each tag. The distributed scheduling algorithm ensures strong consistency: all federates agree on the multiset of delivered events at each tag, avoid deadlock, and guarantee eventual progress as long as the program is constructive (Donovan et al., 20 May 2024).

5. Expressivity, Reductions, and Model Transformations

A notable feature in the development of discrete-event scheduling semantics is the precise analysis of expressive power and algorithmic reduction between semantic frameworks.

• Equivalence and Containment: Composed-scheduling semantics for stochastic hybrid automata are strictly more expressive than decomposed-race semantics; there exist systems with composed-sampling that no independent-clock race semantics can reproduce (Willemsen et al., 2023).
• Supervisory Control Reductions: Run-to-completion synthesis, expressive of interleaved controller-environment spurts, reduces via yield automata and plant instrumentation to standard one-event-per-step DES control. The complexity remains polynomial with a constant blowup (Alrahman et al., 2020).
• Synchronous Product Structures in TDES: By transforming activity automata and timer automata into a product form, TDES with constant firing intervals can be analyzed using standard untimed DES toolchains, enabling modularity and leveraging existing infrastructure (Lin, 2018).

Expressivity results and algorithmic reductions clarify the relationships between models and guide selection or implementation for system modeling tasks.

6. Complexity, Correctness, and Practical Implications

Discrete-event scheduling semantics underpin a range of algorithmic and practical guarantees.

• Complexity Bounds: SLDI cycle-time analysis for periodic schedules admits the first linear-in-period, strongly polynomial method, based on automata-lumping, with complexity $O(p n^3 + n^4)$ for $p$ period and $n$ event types (Zorzenon et al., 2022). The infinite-network Kalikow backward-forward algorithm achieves expected $O(1)$ cost per produced spike under sparsity (Phi et al., 2019).
• Correctness and Deadlock Freedom: Event-scheduling algorithms guarantee precise realization of point process intensities; distributed protocols provably ensure causality, determinism, progress, and deadlock-freedom, provided the program is constructive and/or contains sufficient logical delays (Jun et al., 9 Oct 2024, Donovan et al., 20 May 2024).
• Memory and State: Modular or compositional scheduling (e.g., synchronous product TDES, Kalikow decomposition) enable memory-efficient simulation and analysis by bounding state explosion to exponential in the number of events or polynomial in timing bounds (Lin, 2018, Phi et al., 2019).

These guarantees are foundational for robust simulation, controller synthesis, distributed execution, and performance analysis in cyber-physical, manufacturing, and computational neuroscience domains.

---

In summary, discrete-event scheduling semantics provide a mathematically rigorous foundation unifying deterministic, stochastic, timed, infinite, distributed, and control-theoretic models for systems driven by atomic events. They enable formal model transformations, efficient analysis, compositionality, and correct distributed execution, as established by the referenced research (Phi et al., 2019, Jun et al., 9 Oct 2024, Lin, 2018, Zorzenon et al., 2022, Alrahman et al., 2020, Willemsen et al., 2023, Donovan et al., 20 May 2024).