Timed Automata-based TGPM

• Timed Automata-based TGPM is a formal framework that extends timed automata into timed games, enabling rigorous analysis of temporal and adversarial system behaviors.
• It integrates advanced features such as parametric constraints, probabilistic transitions, and stack-based memory to support tasks like WCET analysis, controller synthesis, and pattern matching.
• The model leverages symbolic methods including zone/region abstractions and fixpoint computations to efficiently compute optimal reachability and extract actionable strategies in complex environments.

A Timed Automata-based Timed-Game Programming Model (TGPM) is a formalism for representing and analyzing temporal, adversarial, and potentially parametric behaviors in complex systems—ranging from real-time hardware pipelines to controllers with environmental uncertainty. These models build on Timed Automata (TA), extend them to timed games, and integrate features such as parametricity, probabilistic branching, stack-based memory, and temporal logic for pattern matching. TGPMs underpin a diverse research landscape encompassing exact and approximate computation of worst-case metrics, synthesis of winning strategies, quantitative verification, and temporal graph analytics.

1. Formal Foundations: Timed Automata, Timed Games, and TGPM

At the core, a Timed Automaton (TA) consists of a finite control graph with real-valued clocks governing transitions and enforcing time constraints. Timed Games generalize this with two (or more) players partitioning the set of actions/transitions, modeling adversarial decision-making. A canonical TGPM comprises:

• A network of components, each modeled as a TA or an extension thereof (e.g., program automata, pipeline stages, caches).
• A set of real-valued clocks $X$, possibly parameters $P$, and invariants/guards, all phrased as conjunctions of linear constraints over these variables.
• Synchronous product composition, imposing a global semantic of time elapse and discrete transitions, with partitioned controllable (Player 1) and uncontrollable (Player 2) moves.

For instance, (Cassez, 2010) defines a TGPM for WCET analysis, composing:

• A program automaton (with Player 1 controlling instruction fetch and Player 2 controlling unknown branch decisions).
• Timed automata models of pipeline stages (each as a small process TA).
• Cache and memory automata with clock-controlled transitions to emulate hit/miss and latency effects.

Timed-Pushdown Automata (TPDA) (Abdulla et al., 2012) and Clock-Dependent Probabilistic Timed Automata (CDPTA) (Sproston, 2017) generalize the model to handle stack-based control flow and clock-dependent probabilistic transitions, respectively. Parametric Timed Games (PTG) (Dahlsen-Jensen et al., 18 Jun 2025) admit real-valued parameters in guards/invariants, enabling parameter synthesis and controller synthesis contingent on unknown timing constants.

2. TGPM-Based Methodologies: Construction and Solution Procedures

The TGPM methodology for worst-case execution time (WCET) analysis, controller synthesis, and pattern matching involves several core steps:

1. Model Construction: Define each component as a TA or appropriate extension (TPDA, CDPTA, etc.), with their local clocks, data/state variables, and transitions. Abstraction may be employed (e.g., replacing non-critical program instructions by abstract variants that preserve the observable WCET (Cassez, 2010)).
2. Game Composition: Compose the component automata synchronously. Partition transitions into controllable (system/controller, e.g., Player 1), uncontrollable (environment/adversary, e.g., Player 2), or parameter-dependent moves (Dahlsen-Jensen et al., 18 Jun 2025). Tag branch outcomes or environment interfaces as Σ₂-moves.
3. Objective Formulation: Define the reachability objective (e.g., reach a designated “DONE”/winning state as fast as possible for Player 1, or guarantee reachability within a set of parameter valuations).
4. Symbolic Analysis/Solution:
   • Value Iteration (Backward): For timed games, propagate optimal reachability values from winning states backward, taking the minimum over Player 1 strategies and maximum over Player 2 moves (Cassez, 2010).
   • Fixpoint Equations: For PTG, compute the greatest fixpoint of the winning region in symbolic state space (location × polyhedral zone), incorporating both controllable-predecessor ($◇_c$) and uncontrollable-predecessor ($□_u$) operators (Dahlsen-Jensen et al., 18 Jun 2025).
   • Model Checking / Optimization: Employ tools (e.g., UPPAAL-TiGA, PRISM) to solve the induced reachability or optimal-reachability game.
5. Controller/Strategy Extraction: For controller synthesis, represent the (finite) compiled strategy as an explicit automaton to be run in parallel with the plant automaton (as in (Dahlsen-Jensen et al., 18 Jun 2025)).

3. Key Mathematical Formalisms and Solution Algorithms

Principal mathematical concepts underpinning these models include:

• Symbolic State-Space: States are tuples $(ℓ, v_X, v_P)$ with $ℓ$ a location, $v_X$ a clock valuation, and $v_P$ a parameter valuation; zones are convex polyhedra defined by linear clock/parameter constraints.
• Optimal Reachability: In timed games, WCET is characterized as

$$WCET = \sup_{σ_2} \inf_{σ_1} \{ t \mid (s_0,0) \overset{*}{\rightarrow}_{σ_1,σ_2} (s_w, t) \}$$

where $σ_1$/$P$0 denote Player 1/2 strategies (Cassez, 2010).

• Fixpoint Characterization (PTG):

$P$1

where $P$2 is the set of winning symbolic states, $P$3 covers controllable-predecessors, and $P$4 covers uncontrollable-predecessors (Dahlsen-Jensen et al., 18 Jun 2025).

• Region Construction (TPDA, CDPTA): Partition clock valuations into equivalence classes ("regions") that respect all clock constraints, yielding a finite-state abstraction amenable to untimed reachability analysis or (in the probabilistic case) region-MDPs (Abdulla et al., 2012, Sproston, 2017).
• Algorithmic Implementation: On-the-fly symbolic graph exploration with zone-based representation, followed by value iteration (or LP-solving for probabilistic models), is standard for TGPM analyses (Cassez, 2010, Sproston, 2017).

4. Advanced Extensions: Parametric Games, Timed Pushdown, and Probabilistic Models

Parametric Timed Games (PTGs): PTGs allow guards and invariants containing both clocks and real-valued parameters ($P$5). Synthesis algorithms compute parameter sets and explicit strategies ensuring the winning objective for all compatible runs. The approach in (Dahlsen-Jensen et al., 18 Jun 2025) integrates polyhedral zone representations, on-the-fly fixpoint computations, and explicit strategy extraction as a PTA, guaranteeing the controller does not block uncontrollable/environment moves.

Timed Pushdown Automata (TPDA): TPDA (Abdulla et al., 2012) combine a finite-state control, unbounded stack memory, and continuous clocks. Reachability is reduced to that of a finite region-annotated Pushdown Automaton (PDA), preserving EXPTIME-completeness and enabling the application of established untimed techniques.

Clock-Dependent Probabilistic TA (CDPTA): In CDPTA, the probability of each transition is a piecewise-linear function of clock values. This enables modeling probabilistic delays, failures, or choices with rates dependent on elapsed time, e.g., "the longer the system waits, the higher the failure probability." Reachability probabilities are generally undecidable, but conservative (upper/lower) bounds can be obtained using k-region abstractions and region-based MDP value iteration (Sproston, 2017).

5. Temporal Graph Pattern Matching via Timed Automata

A recent and impactful TGPM application is temporal graph pattern matching (TGPM) (Aghasadeghi et al., 2022). Here, both the pattern (a basic graph pattern, BGP) and the temporal constraints (regular or complex timing between events) are encoded as a timed automaton. The system matches the pattern across time-stamped graphs, using the TA to accept or reject candidate (partial or total) matchings. Algorithms range from baseline (all-match, two-pass), to on-demand incremental (applying TA on arrival of graph updates), to fully incremental partial-match (maintaining maximal partial matches with TA state/prefix). Empirical results indicate distinct trade-offs: cyclic patterns on sparse graphs favor on-demand; acyclic/dense cases favor partial-match algorithms. Timed automata support highly expressive temporal constraints beyond existential or journey-based temporal logic.

6. Tooling, Verification, and Case Studies

• WCET via UPPAAL-TiGA: For in-depth pipeline and cache-aware WCET, TGPMs composed as two-player TA games are verified using UPPAAL-TiGA (Cassez, 2010). The tool employs zone-based backward value iteration, exploring the state space on-the-fly and computing the minimal time Player 1 can guarantee.
• Controller Extraction and Verification (Imitator, PTA): For PTGs, synthesized finite strategies are compiled into explicit PTAs, which can be composed and model-checked using tools such as Imitator (Dahlsen-Jensen et al., 18 Jun 2025).
• Probabilistic and Quantitative Models (PRISM/Storm): Region-based abstractions for CDPTA allow the reduction to finite MDPs, which can be solved symbolically using probabilistic model checkers, refined iteratively by region granularity (Sproston, 2017).
• Temporal Graph Analytics: TGPMs for temporal graph motifs operate efficiently on large datasets, often outperforming SQL-based approaches for complex time constraints (Aghasadeghi et al., 2022).

7. Complexity, Decidability, and Practical Considerations

• Control-state reachability in TPDA is EXPTIME-complete (Abdulla et al., 2012).
• Optimum reachability (WCET) in timed games is computed exactly in finite time for bounded models (via region/zones abstraction).
• PTG controller synthesis returns parameter constraints and explicit strategies; the algorithm is symbolic but terminates for practical instances (Dahlsen-Jensen et al., 18 Jun 2025).
• In CDPTA, reachability is undecidable for ≥3 clocks due to the reduction to two-counter machines; region-MDPs yield sound upper/lower bounds for practical purposes (Sproston, 2017).
• Scalability depends on region (or zone) set size; best-practice includes clock bound invariants, minimal use of parameters, and symbolic state-space pruning.

All Timed Automata-based TGPMs hinge on the compositional abstraction of complex system dynamics as timed games, the symbolic (zone/region/polyhedral) analysis of their reachable/controllable set, and the robust extraction and verification of strategies—addressing both correctness and quantitative optimality in temporal domains.

References:

(Cassez, 2010): "Timed Games for Computing Worst-Case Execution-Times" (Dahlsen-Jensen et al., 18 Jun 2025): "Controller Synthesis for Parametric Timed Games" (Abdulla et al., 2012): "Adding Time to Pushdown Automata" (Sproston, 2017): "Probabilistic Timed Automata with Clock-Dependent Probabilities" (Aghasadeghi et al., 2022): "Temporal graph patterns by timed automata"