event ordering

This work addresses the challenges of modeling causality and temporal ordering in recursive agent execution traces by proposing a formal framework called the Causal-Temporal Event Graph (CTEG). CTEG represents strict causal-temporal relationships through a rooted tree annotated with timestamps and event types, and constructs recursive execution levels via the least fixed point of a monotonic operator. By integrating causal semantics, recursive structure, and temporal sequencing for the first time, CTEG enables decentralized, compositional trace construction, preserves well-formedness under partial failures, and supports tamper-evident verification through compatibility with Merkle trees. Theoretical analysis shows that, under reasonable conditions, the execution hierarchy converges at the first level, yielding a compositional, verifiable, and fault-tolerant model for agent trajectories.

This work addresses the challenge of root-cause diagnosis for Metric Interval Temporal Logic (MITL) specification violations in real-time systems. We propose the first counterfactual causal analysis framework tailored to networked timed automata. Methodologically, we adapt the Halpern–Pearl causal model to the semantics of timed automata, formally define counterfactual causality for MITL violations, and integrate MITL model checking, symbolic trace analysis, and causal graph construction to jointly attribute discrete actions and real-time delays. Our contributions are threefold: (1) a formal, verifiable definition of counterfactual causality for timed systems; (2) an efficient algorithm for generating minimal counterfactual interventions that restore MITL satisfaction; and (3) empirical evaluation on standard benchmarks demonstrating substantial reduction in manual debugging effort and delivering highly interpretable, causally grounded diagnostic reports.

This study addresses the problem of reliably observing causal order in shared-memory concurrent systems (COP), formalizing its observability limits and proving that strong consistency—defined as both completeness and reliability—is generally unattainable. The key insight is that the placement of monitoring instrumentation, rather than the choice of timestamp mechanism, fundamentally determines observability guarantees. To this end, the work proposes three non-blocking monitor implementations: FAInc (a centralized atomic counter), Striped (a decentralized counter), and Collect (an iterative register snapshot). Theoretically, all three provide equivalent COP guarantees. Experimental evaluation on a 64-core NUMA architecture demonstrates that Striped achieves throughput comparable to Collect while maintaining linearizability and substantially alleviating the cache contention bottleneck inherent in FAInc.

This work addresses the limitations of traditional network protocols that rely on the Fixed-In-Time Ordering (FITO) assumption, which fails to ensure semantic consistency and causal reversibility at the link layer. The authors propose the Open Atomic Ethernet (OAE) semantic model, which dispenses with a priori causal ordering and instead dynamically establishes causality through transactional structures. OAE incorporates a reflection acknowledgment mechanism and Indefinite Logical Timestamps (ILT), operating via a six-state finite state machine (e.g., TENTATIVE → REFLECTING → COMMITTED) that permits arbitrary aborts before commitment and finalizes transactions only after bidirectional semantic validation. Leveraging the link-level Slowdown theorem and the principle of knowledge balance, OAE theoretically achieves unbounded consensus capability, whereas protocols such as RDMA, NVLink, and UALink—constrained by FITO semantics—are limited to bounded consensus.

Concurrent programs exhibit nondeterministic, probabilistic, and quantum behaviors, yet existing semantic frameworks lack a unified formal model capable of capturing all three effects simultaneously. Method: This paper introduces an event-structure–based trace semantics framework for imperative concurrent programs. It is the first to directly employ Winskel’s event structures—and their probabilistic and quantum extensions—as the semantic model for program executions, constructing a concise operational semantics that naturally integrates these three computational effects. Contribution/Results: The work establishes a rigorous correspondence between event-structure semantics and program execution traces, proving both soundness and adequacy of the semantics. By unifying nondeterminism, probability, and quantum superposition within a single trace-based model, it overcomes fundamental limitations of classical trace semantics in probabilistic and quantum settings. This provides a novel foundational basis for formal verification of concurrent, probabilistic, and quantum programs, enabling compositional reasoning and mechanizable verification techniques.

This work addresses the challenge of runtime monitoring in distributed large language model (LLM) agent workflows, where asynchronous execution limits visibility into event causality, rendering traditional sequential logs inadequate. To overcome this, the paper integrates Causal Past Logic (CPL) into the ZipperGen framework by embedding it within the control flow of the coordination language, serving as source-level guards for conditional and loop constructs to enable real-time verification based on causal visibility. A vector-clock-based monitor, combined with a latest-value view, evaluates CPL formulas online while ensuring consistency between local computations and denotational semantics. This approach supports cross-lifeline queries over causally visible events and variables, significantly enhancing the accuracy and efficiency of runtime verification in distributed LLM agent workflows and guaranteeing that decisions rely solely on causally reachable historical information.

This work addresses the challenge of verifying data-aware temporal properties in complex, heterogeneous AI-driven dynamic systems whose internal specifications are often opaque and thus resistant to traditional model-checking techniques. To this end, the paper proposes a proactive runtime monitoring framework capable of verifying Linear Temporal Logic over finite traces with Mixed Theories (LTLfMT), which integrates arbitrary SMT theories. The approach combines automata-theoretic methods for handling temporal structure with SMT-based reasoning for first-order data constraints. Its principal contribution lies in establishing, for the first time, a decidable fragment of LTLfMT that includes linear arithmetic and uninterpreted functions, and in developing a foundational architecture that balances theoretical rigor with practical applicability. Preliminary evaluations on data-aware business processes and read-only database-driven systems demonstrate the feasibility and potential of the proposed method.

This work addresses the visibility of security-relevant facts in layered network security pipelines, where discrepancies in processing order—such as those exploited by order-sensitive attacks like HTTP request smuggling—can undermine correctness. For the first time, layer ordering is formally integrated into a semantic security framework through a composable automaton model. This model endows transformation sequences with finite-state semantics via layer-order automata, deterministic order-preserving transducers, evidence-tagging mechanisms, and decision automata, and precisely characterizes the regular prefix-closed conditions necessary for faithful online execution. The approach enables formal identification of boundary-inconsistency scenarios including CL.TE, TE.CL, TE.TE, and HTTP/2 downgrade attacks, establishes a component-permutation classification based on equivalent decision languages, and proves the equivalence of the proposed framework to finite-output deterministic edit transducers.

This work addresses the challenge of verifying temporal safety contracts for synchronous programs, which involve global properties spanning multiple clock cycles and are not amenable to direct handling by conventional deductive verification tools. The authors present Kairos, a novel toolchain that, for the first time, automates the generation of tick-indexed Why3 proof obligations from synchronous programs paired with assume-guarantee contracts expressed in Linear Temporal Logic (LTL). Their approach leverages automata theory by compiling LTL specifications into bad-state automata and constructing their product with the program. The correctness of this framework is formally mechanized in Rocq. Experimental evaluation successfully verifies a medical infusion controller, demonstrating that under given environment assumptions, every input trace induces a unique execution satisfying the temporal guarantees—highlighting the method’s effectiveness in supporting temporal contracts for reactive systems.

Protocol model checking often suffers from state-space explosion, particularly when channel capacity or window size increases. This work proposes a compositional verification approach based on bidirectional simulation relations, constructing a hierarchy of protocol abstractions—SCP → ABP → SWP—with progressively refined semantics. By reducing the verification of complex protocols to that of the most abstract protocol, SCP, the method circumvents direct model checking of large state machines. Correctness of ABP and SWP is then derived from the invariance properties verified solely on SCP. This abstraction-based reduction significantly lowers computational complexity and enables efficient formal verification of protocols under high parameter settings.