# History-Determinism vs Fair Simulation

Udi Boker, Thomas A Henzinger, Karoliina Lehtinen, Aditya Prakash

► To cite this version:

Udi Boker, Thomas A Henzinger, Karoliina Lehtinen, Aditya Prakash. History-Determinism vs Fair Simulation. CONCUR, Sep 2024, Calgary, Canada. 311, 2024, 10.4230/LIPIcs.CONCUR.2024.12 .
hal-04788739

HAL Id: hal-04788739

https://hal.science/hal-04788739v1

Submitted on 4 Jul 2025

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>
# History-Determinism vs Fair Simulation

Udi Boker ✠✉

<figure><img src="image_2.png" /></figure>

<figure><img src="image_3.png" /></figure>

Reichman University, Herzliya, Israel

Thomas A. Henzinger ✠✉

<figure><img src="image_4.png" /></figure>

<figure><img src="image_5.png" /></figure>

Institute of Science and Technology Austria (ISTA), Klosterneuburg, Austria

Karoliina Lehtinen ✠✉

<figure><img src="image_6.png" /></figure>

<figure><img src="image_7.png" /></figure>

CNRS, LIS, Aix-Marseille Univ.

Aditya Prakash ✠✉

<figure><img src="image_8.png" /></figure>

<figure><img src="image_9.png" /></figure>

University of Warwick, Coventry, UK

## Abstract

An automaton $\mathcal{A}$ is history-deterministic if its nondeterminism can be resolved on the fly, only using the prefix of the word read so far. This mild form of nondeterminism has attracted particular attention for its applications in synthesis problems. An automaton $\mathcal{A}$ is guidable with respect to a class $C$ of automata if it can fairly simulate every automaton $\mathcal{B}$ in $C$, whose language is contained in that of $\mathcal{A}$. In other words, guidable automata are those for which inclusion and simulation coincide, making them particularly interesting for model-checking.

We study the connection between these two notions, and specifically the question of when they coincide. For classes of automata on which they do, deciding guidability, an otherwise challenging decision problem, reduces to deciding history-determinism, a problem that is starting to be well-understood for many classes.

We provide a selection of sufficient criteria for a class $C$ of automata to guarantee the coincidence of the notions, and use them to show that the notions coincide for the most common automata classes, among which are $\omega$-regular automata and many infinite-state automata with safety and reachability acceptance conditions, including vector addition systems with states, one-counter nets, pushdown-, Parikh-, and timed-automata.

We also demonstrate that history-determinism and guidability do not always coincide, for example, for the classes of timed automata with a fixed number of clocks.

2012 ACM Subject Classification Theory of computation → Automata over infinite objects

Keywords and phrases History-Determinism

Digital Object Identifier 10.4230/LIPIcs.CVIT.2016.23

Funding Udi Boker: Israel Science Foundation grant 2410/22

Karoliina Lehtinen: ANR QUASY 23-CE48-0008-01

Aditya Prakash: Chancellors' International Scholarship from the University of Warwick and Centre for Discrete Mathematics and Its Applications (DIMAP)

## 1 Introduction

Language inclusion between automata is a key problem in verification: given an automaton representing a program and another representing a specification, language inclusion of the former in the latter captures precisely whether all executions of the program satisfy the specification. Unfortunately, in the presence of nondeterminism, inclusion is algorithmically hard. For instance, for regular automata it is PSPACE-hard on both finite and infinite words.

Fair simulation is a more syntactic approximation of inclusion, defined by the simulation game [13]. In this game, one player, in the role of the spoiler, builds, transition by transition, a run in one of the automata, say $\mathcal{A}$, while the other, in the role of the duplicator, chooses at each turn a matching transition in the other automaton, say $\mathcal{B}$. The second player's task

<figure><img src="image_10.png" /></figure>

<figure><img src="image_11.png" /></figure>
is to build a run that is accepting if the first player's run is accepting. If the duplicator
has a winning strategy, then $\mathcal{B}$ is said to simulate $\mathcal{A}$, which, in particular, implies that $\mathcal{A}$'s
language is included in $\mathcal{B}$'s language. Simulation, due to its local and syntactic nature, is
generally easier to check than inclusion: for instance it is in PTIME for nondeterministic
Büchi automata. As a result, automata for which language inclusion and simulation coincide
are particularly well-suited for model-checking. We call such automata *guidable*, after a
similar notion used previously as an alternative to determinism for tree automata [9]. Despite
their clear usefulness for model checking, guidable automata have so far been mostly used as
a tool, but not studied much in their own right, with the notable exception of [19].

Guidability is not easy to decide: it is contingent on an automaton simulating a potentially
infinite number of language-included automata. We would like to have, whenever possible, a
characterisation that is more amenable to algorithmic detection.

Deterministic automata are of course always guidable, and so are *history-deterministic*
automata. These are mildly nondeterministic automata, in which nondeterministic choices
are permitted, but can only depend on the word read so far, rather than the future of the
word. These automata have received a fair bit of attention recently due, in particular, to
their applications in synthesis problems [6]. In general, they offer an interesting compromise
between the power of nondeterministic automata and the better algorithmic properties of
deterministic ones. In particular, they can simulate all equivalent, or language-contained,
automata as they only need the history to resolve nondeterministic choice in the best possible
way—in other words, they are guidable. In fact, at first it might appear that history-
determinism and guidability should coincide; indeed, this is the case if we consider guidability
with respect to all labelled transition systems [14, Theorem 4]. However, there are also
classes of automata for which this is not the case.

Guidability and history-determinism coinciding on a class *C* of automata is equivalent to
the description *“for every automaton *A* ∈ *C* that is not history-deterministic, there is some
*A'* ∈ *C* that is language-included in *A* but that *A* does not simulate”* (D). Then it is easy
enough to hand-pick automata to build classes where guidability and history-determinism
do not coincide (for example, a class of inclusion-incomparable automata that are not
all history-deterministic). However, as we will see, there are also more natural classes of
automata, such as timed automata with a bounded number of clocks, for which guidability
and history-determinism differ.

The characterisation (D) is too abstract to be much use for analysing the usual automata
classes we are interested in. We therefore prove that several more concrete criteria (The-
orem 1) imply that guidability and history-determinism coincide, and use each of these in a
comprehensive analysis of standard automata classes. Roughly, each of the criteria describes
some sufficient closure properties which guarantee the existence of *A'* from description (D).
If some automaton can simulate another automaton that is sufficiently difficult to simulate
(for example a deterministic one, since they simulate all equivalent automaton), then it must
be history-deterministic; as a result, a class of automata having sufficient closure properties
(such as closure under determinisation), implies that guidability and history-determinism
coincide. The challenge is to identify, for a variety of different classes of automata *C*, an
automaton that is sufficiently difficult to simulate, while remaining in *C*.

In order to discuss our sufficient criteria in more detail, we need to start with a couple of
key notions, the first of which is the *1-token game* and the second is the *1-token ghost*.

History-determinism of an automaton is tricky and expensive to decide directly [12]; As
an alternative, Bagnoal and Kuperberg used *k*-token games as potential characterisations for
history-determinism [2]. Roughly, they resemble a (fair) simulation-like game, played on a
single automaton, where one player, Eve (in the role of Duplicator), must build transition-by-transition a run on a word dictated letter-by-letter by Adam, who, after each of Eve's choices, also builds $k$ runs transition-by-transition. Eve then wins if her run is accepting whenever Adam's run is accepting. Bagnol and Kuperberg showed that for Büchi automata, the 2-token game indeed characterises history-determinism, which means that deciding history-determinism for Büchi automata is in PTIME [2]. Since then, the 1- or 2-token games have been shown to characterise history-determinism for various automata classes, including coBüchi [4], DSum, LimInf, and LimSup automata [5]. These games contrast with the letter game, a game which always characterises history-determinism, but which is often challenging to solve directly [12].

In this work, we make heavy use of token-games, this time to understand the connection between history-determinism and guidability. In particular, we extend token games to be played over two automata (Definition 3), separating between Eve's and Adam's automata, and define, given an automaton $\mathcal{A}$, that an automaton $\mathcal{A}'$ is a 1-token ghost of $\mathcal{A}$ if $\mathcal{A}'$ is language-equivalent to $\mathcal{A}$ and Eve wins the 1-token game between $\mathcal{A}'$ and $\mathcal{A}$. For some classes of automata such a ghost is easy to construct, while for other classes it might not exist due to lacking closure properties.

With these notions, we can now state our criteria.

**► Theorem 1.** The notions of history-determinism and guidability coincide for a class C of labelled transitions systems (LTSs) if at least one of the following holds:

1. Determinisation. C is closed under history-determinism, i.e., for each nondeterministic LTS in C, there is a language-equivalent history-deterministic (or deterministic) LTS in C as well. (Lemma 4)

2. 1-token ghost. 1-token games characterise history-determinism in C, and C is closed under 1-token ghost. (Lemma 8)

3. Strategy ghost. For every $\mathcal{A} \in C$ that is not history-deterministic, there is a deterministic LTS $\mathcal{B}$ over the alphabet of transitions of $\mathcal{A}$, such that $\mathcal{B}$ recognises the plays of a winning strategy of Adam in the letter game on $\mathcal{A}$, and $\mathcal{B}$, projected onto the alphabet of $\mathcal{A}$, has a 1-token ghost in C. (Lemma 9)

We prove the criteria of Theorem 1 in Section 4, and use them in Section 5 to show that the notions of history-determinism and guidability coincide for numerous classes of automata, listed in Table 1. We also provide counter-examples of classes for which history-determinism and guidability do not coincide, as listed in Table 1, and elaborated on in Section 6. We restrict our analysis to automata over infinite words, which are better behaved in this context, and discuss how to adapt our techniques for finite words in Section 7.

A practical corollary of our result is that guidability is decidable, with the complexity of deciding history-determinism, for $\omega$-regular automata (EXPTIME for parity automata, PTIME for Büchi and coBüchi), safety and reachability timed automata (EXPTIME) and visibly pushdown automata (EXPTIME). For details on the complexity of these procedures, we refer the reader to a recent survey [6].

## 2 Preliminaries

We use $\mathbb{N}$ and $\mathbb{N}^+$ to denote the set of non-negative and positive integers respectively. We use $[i..j]$ to denote the set $\{i, ..., j\}$ of integers, and $[i]$ for the set $[1..i]$. An alphabet $\Sigma$ is a non-empty set of letters. A finite or infinite word is a finite or infinite sequence of letters from $\Sigma$ respectively. We let $\varepsilon$ be the empty word, and $\Sigma_\varepsilon$ the set $\Sigma \cup \{\varepsilon\}$. The set of all finite (resp. infinite) words is denoted by $\Sigma^*$ (resp. $\Sigma^\omega$). A language is a set of words.
23:4 History-Determinism vs Fair Simulation

<table><caption>**Table 1 History-determinism vs guidability**</caption><thead><tr><th>Automata Class</th><th>HD = Guidability by</th></tr></thead><tbody><tr><td>ω-regular</td><td>Determinisation or Strategy ghost</td></tr><tr><td>Fixed-index parity (e.g., Büchi), Weak</td><td>Strategy ghost Corollary 10</td></tr><tr><td>Linear</td><td>Strategy ghost Theorem 19. (Not ghost-closed Theorem 18)</td></tr><tr><td>Safety & Reachability pushdown automata, VASS, timed, one-counter automata, one-counter net, Parikh</td><td>1-token ghost Theorem 17 and Corollary 15</td></tr><tr><td>VPA with any ω-regular acceptance condition</td><td>Strategy ghost Theorem 16</td></tr><tr><td colspan="2">Classes for which HD ≠ guidability:<br/>- Büchi automata with a bounded number of states. Theorem 20<br/>- Timed automata with a bounded number of clocks. Theorem 21</td></tr><tr><td colspan="2">Notable classes for which we leave the question HD ≠ guidability open:<br/>- PDA/OCA/OCN/Timed automata with general ω-regular acceptance</td></tr></tbody></table>

## 2.1 Labelled transition systems

A labelled transition system (LTS) $\mathcal{A} = (\Sigma, Q, \iota, \Delta, \alpha)$ consists of a potentially infinite alphabet $\Sigma$, a potentially infinite state-space $Q$, an initial state $\iota \in Q$, a labelled transition relation $\Delta \subseteq Q \times \Sigma_{\varepsilon} \times Q$, and a set of accepting runs $\alpha$, where a run $\rho$ is a (finite or infinite) sequence of transitions starting in $\iota$ and following $\Delta$. We may write $q \xrightarrow{\sigma} q'$ instead of $(q, \sigma, q') \in \Delta$ for $\sigma \in \Sigma_{\varepsilon}$. Given a finite run $\rho = q_0 \xrightarrow{\sigma_1} q_1 \xrightarrow{\sigma_2} \dots \xrightarrow{\sigma_k} q_k$ on the word $v = \sigma_0 \cdot \sigma_1 \cdot \sigma_2 \cdot \dots \cdot \sigma_k \in \Sigma_{\varepsilon}^{k+1}$, we write $q_0 \xrightarrow{v, \rho} q_k$ to denote that $\rho$ is a transition sequence on the word $v$ that starts at $q_0$ and ends at $q_k$. An LTS is *deterministic* if for every state $q$ and letter $\sigma \in \Sigma$, there is at most one transition $q \xrightarrow{\sigma} q'$ from $q$ on the $\sigma$, and there are no transitions on $\varepsilon$.

A word $w \in \Sigma^{\omega}$ is accepted by an LTS $\mathcal{A}$ if there is an accepting run of $\mathcal{A}$ on $w$. The language $L(\mathcal{A})$ of $\mathcal{A}$ is the set of words that it accepts. An LTS $\mathcal{A}$ is contained in an LTS $\mathcal{B}$, denoted by $\mathcal{A} \leq \mathcal{B}$, if $L(\mathcal{A}) \subseteq L(\mathcal{B})$, while $\mathcal{A}$ and $\mathcal{B}$ are equivalent, denoted by $\mathcal{A} \equiv \mathcal{B}$ if $L(\mathcal{A}) = L(\mathcal{B})$.

A transducer is like an LTS without acceptance condition and $\varepsilon$-transitions but with an output labelling: it is given by a tuple $(\Sigma_I, \Sigma_O, Q, \iota, \Delta, \gamma)$, where $\Sigma_I$ and $\Sigma_O$ are the input and output alphabets, respectively, $\Delta \subseteq Q \times \Sigma_I \times Q$ is the transition relation, and $\gamma: \Delta \to \Sigma_O$ is the output function. A strategy in general is a deterministic transducer. It is finite memory if the transducer has a finite state space.

## 2.2 Automata

We briefly recall the automata types considered here, which we assume to operate on infinite words unless stated otherwise, and leave the formal definitions to the appendix.

LTSs are represented concisely by various automata. An automaton $\mathcal{A}$ induces an LTS $\mathcal{B}$, whose states are the configurations of $\mathcal{A}$, and whose runs are the same as $\mathcal{A}$'s runs. If $\mathcal{A}$'s states and configurations are the same, as is the case with $\omega$-regular automata which we
define below, then $\mathcal{B}$ is identical to $\mathcal{A}$, but with the acceptance condition given by a set of
runs (as opposed to an $\omega$-regular conditions). If the configurations of $\mathcal{A}$ contain additional
data, as is the case for example with pushdown automata, then $\mathcal{B}$ and $\mathcal{A}$ have different states.
Notice that $\mathcal{A}$ is deterministic iff $\mathcal{B}$ is. The acceptance condition of $\mathcal{A}$ induces the acceptance
condition on $\mathcal{B}$.

In a parity condition, $\alpha$ assigns priorities in $\mathbb{N}$ to either states or transitions, and a run is accepting if the highest priority that occurs infinitely often along it is even. An $[i, j]$-parity automaton, for $i < j$ two natural numbers is a parity automaton whose priorities are in $[i, j]$. A parity automaton is said to be a weak automaton if there is no cycle in the automaton containing both an even and odd priority. In a reachability condition, some states are labelled final; a run accepts if it reaches a final state. In a safety automaton, some states are labelled safe; a run accepts if it remains within the safe region.

In a nondeterministic $\omega$-regular automaton ($\Sigma, Q, \iota, \delta, \alpha$), $\Sigma$ and $Q$ are finite, and the acceptance condition $\alpha$ is based on the set of states (or transitions) visited infinitely often along a run. A timed automaton (TWA) ($\Sigma, Q, \iota, C, \delta, \alpha$) has a set of clocks $C$ and its transitions are guarded by inequalities between the clock values and can reset clocks. It reads timed words, which consist of letters of a finite alphabet $\Sigma$ paired with delays from $\mathbb{R}$. A timed automaton recognises a timed language, for example "at some point an event occurs twice exactly one time-unit apart."

We also handle pushdown automata, one-counter automata, vector addition systems with states, one-counter nets and Parikh automata with reachability and safety acceptance. We define these classes of infinite state systems uniformly in Section 5.2 as classes of finite state automata with transitions that modify an infinite *content space*. A visibly pushdown automaton (VPA) is a pushdown automaton without $\varepsilon$-transitions, in which the input alphabet is partitioned into *pop*, *push* and *noop* letters that induce only transitions that *pop*, *push* and have no effect on the stack respectively.

# 3 History-determinism, simulation and related games

Different simulation-like games that capture either a relationship between automata or properties of a single automaton are at the heart of our technical developments. In this section we go over the various games—both known and newly defined—that will be played throughout this article, and which allow us to connect guidability and history-determinism. These games are all based on Adam (the spoiler) building a word letter by letter, and potentially a run in an automaton over that word, while his opponent Eve (the duplicator) tries to build a single accepting run transition by transition. The differences between these games are based on whether they are played on one or two automata, whether Adam picks transitions, and if so, whether he does it before Eve. The winning condition is similar in all cases: Eve's run must be accepting whenever Adam's run is accepting, or if Adam does not have a run, then whenever the word built by Adam's moves is in the language of a specified automaton. This results in three styles of games: (i) simulation games, played on two automata, in which Adam plays before Eve, and each builds a run in their respective automaton; (ii) token-games, which can be played on one or two automata, in which Adam first declares the letter, and then Eve plays her transition before Adam plays his; and (iii) the letter game, played on a single automaton, in which Adam only chooses letters and does not build a run at all.

Fair simulation between two LTSs (or automata) is captured by the simulation game
defined below:
**► Definition 2 (Simulation game).** Consider LTSs $\mathcal{A} = (\Sigma, Q_A, \iota_A, \Delta_A, \alpha_A)$ and $\mathcal{B} = (\Sigma, Q, \iota_B, \Delta_B, \alpha_B)$. The simulation game $\text{Sim}(\mathcal{B}, \mathcal{A})$ between $\mathcal{B}$ and $\mathcal{A}$ is a two player-game played between Adam and Eve with positions in $Q_A \times Q_B$ which starts at the position $(p_0, q_0) = (\iota_A, \iota_B)$. At round $i$ of the play, for $i \ge 0$, when the position is $(p_i, q_i)$:

- Adam picks $\sigma_i \in \Sigma$ and a transition (or transition sequence, in the presence of $\varepsilon$-transitions) $p_i \xrightarrow{\sigma_i, \rho_i} p_{i+1}$ in $\mathcal{A}$;

- Eve picks a transition (or transition sequence, in the presence of $\varepsilon$-transitions) $q_i \xrightarrow{\sigma_i, \rho_i'} q_{i+1}$ in $\mathcal{B}$; they proceed from $(p_{i+1}, q_{i+1})$.

An infinite play produces a run $\rho_A$ in $\mathcal{A}$ consisting of transitions chosen by Adam and a run $\rho_E$ in $\mathcal{B}$ of transitions chosen by Eve, both on $\sigma_0\sigma_1\sigma_2\dots$. We say that Eve wins the play if $\rho_E$ is accepting or $\rho_A$ is rejecting.

If Eve has a winning strategy in this game, we say that $\mathcal{B}$ simulates $\mathcal{A}$, denoted by $\text{Sim}(\mathcal{B}, \mathcal{A})$. It is easy to observe that if $\mathcal{B}$ simulates $\mathcal{A}$, then $L(\mathcal{A}) \subseteq L(\mathcal{B})$. An LTS $\mathcal{A}$ is *guidable* with respect to a class $C$ of LTSs if $\mathcal{A}$ simulates every LTS $\mathcal{A}'$ in $C$ that satisfies $L(\mathcal{A}') \subseteq L(\mathcal{A})$.

The following *letter game* based definition of history-determinism, was introduced by Henzinger and Piterman [12], and coincides with Colcombet's notion of translation strategies [8].

Given an LTS $\mathcal{A}$, the *letter game* on $\mathcal{A}$, denoted by $\text{HD}(\mathcal{A})$ is similar to the simulation game except that instead of playing transitions in an automaton, Adam just chooses letters and builds a word $w$, letter by letter, which should be in the language of $\mathcal{A}$, while Eve tries to build a run of $\mathcal{A}$ over $w$. More precisely, the letter game starts with Eve's token at the initial state $\iota$, and proceeds in rounds. At round $i$, where Eve's token is at $q_i$:

- Adam chooses a letter $\sigma_i$ in the alphabet $\Sigma$ of $\mathcal{A}$;

- Eve chooses a transition $q_i \xrightarrow{\sigma_i} q_{i+1}$ (or a transition sequence $q_i \xrightarrow{\sigma_i, \rho_i} q_{i+1}$ in the presence of $\varepsilon$-transitions) of $\mathcal{A}$ over $\sigma_i$; Eve's token moves to $q_{i+1}$.

In the limit, a play consists of the word $w = \sigma_0\sigma_1\dots$ and the run $\rho = \rho_0 \cdot \rho_1 \cdot \rho_2 \dots$. Eve wins the play if $w \notin L(\mathcal{A})$ or $\rho$ is accepting. We say that $\mathcal{A}$ is history-deterministic (HD) if Eve has a winning strategy in the letter game over $\mathcal{A}$.

Token games are known to characterise history-determinism on various classes of automata [2, 5, 6]. We generalise token games to be played on two LTSs below, which makes them more akin to a variation of simulation. This will help us relate simulation and history-determinism in Section 4. We only use the 1-token version here.

**► Definition 3 (1-token games over two LTSs (or automata))**. Consider LTSs $\mathcal{A}'$ and $\mathcal{A}$ with initial states $p_0$ and $q_0$ respectively. In the 1-token game on $\mathcal{A}'$ and $\mathcal{A}$ denoted by $G_1(\mathcal{A}', \mathcal{A})$, Eve has a token with which she constructs a run in $\mathcal{A}'$, and Adam has a token with which he constructs a run in $\mathcal{A}$. The game proceeds in rounds, and at round $i$ of the play with token positions $(p_i, q_i)$, for each $i \ge 0$:

- Adam chooses a letter $\sigma_i$ in $\Sigma$;

- Eve chooses a transition (or a transition sequence, in the presence of $\varepsilon$-transitions) $p_i \xrightarrow{\sigma_i, \rho_i'} p_{i+1}$ in $\mathcal{A}$;

- Adam chooses a transition (or transition sequence, in the presence of $\varepsilon$-transitions) $q_i \xrightarrow{\sigma_i, \rho_i} q_{i+1}$; the game proceeds from $(p_{i+1}, q_{i+1})$.

An infinite play produces a word $w = \sigma_0\dots$, a sequence of transitions $\rho_E$ of $\mathcal{A}'$ chosen by Eve, and a sequence of transitions $\rho_A$ in $\mathcal{A}$ chosen by Adam. Eve wins if $\rho_E$ is accepting or if $\rho_A$ is rejecting.
A strategy for Eve here is a function $s : (Δ^+)^* \times Σ \to (Δ')^*$, where $Σ$ is the alphabet of $\mathcal{A}$ and $\mathcal{A}'$, and $Δ$ and $Δ'$ are the sets of transitions of $\mathcal{A}$ and $\mathcal{A}'$, respectively. When clear from context, $G_1(\mathcal{A}', \mathcal{A})$ also denotes the claim that Eve has a winning strategy in the game $G_1(\mathcal{A}', \mathcal{A})$. As an automaton and its induced LTS have the same runs, $G_1(\mathcal{A}', \mathcal{A})$ holds for automata $\mathcal{A}$ and $\mathcal{A}'$ iff it holds for their induced LTSs. We also write $G_1(\mathcal{A})$ for $G_1(\mathcal{A}, \mathcal{A})$.

Note that the 1-token game and the simulation game differ in one key aspect: in the simulation game, Adam plays first, and Eve can use the information of the transition to inform her choice, while in the 1-token game, Eve must choose her transition based only on the letter chosen by Adam, who plays his transition after Eve.

# 4 Criteria for when History-Determinism = Guidability

We now provide criteria which guarantee that history-determinism and guidability coincide for a class of LTSs. In Section 5, we use these to show the coincidence of the two notions for many standard automata classes.

## 4.1 Closure under (history-)determinism

A first observation is that if every LTS $\mathcal{A}$ can be determinised within the class $C$, or even if there exists an equivalent HD LTS $\mathcal{A}'$ within $C$ then $\mathcal{A}$ is HD if and only if it is guidable.

**► Lemma 4.** *History-determinism and guidability coincide for any class $C$ of LTSs in which the languages expressed by history-deterministic (or deterministic) LTSs are the same as languages expressed by nondeterministic LTSs.*

The proof is simple: one direction is trivial (HD always implies guidability) and conversely, if an automaton $\mathcal{A}$ is not HD, then it cannot simulate any equivalent HD automaton, implying that $\mathcal{A}$ is not guidable.

Various examples of such classes are provided in Section 5.1, as summarised in Table 1. In particular, the general class of all labelled-transition systems [14], safety/reachability visibly pushdown automata [1], as well as finite-state automata on finite words (NFAs), and co-Büchi, Parity, Rabin, Streett, and Muller automata on infinite words. Yet, this is not the case for Büchi automata or parity automata with a fixed parity index. History-determinism is also strictly less expressive than nondeterminism for pushdown automata, Parikh automata, timed automata and one-counter nets.

## 4.2 Via token games

For classes that are not closed under determinisation, we have to find some other type of automaton that is difficult to simulate. To do so, we revisit token games, previously used to help decide history-determinism, to relate history-determinism and guidability. Recall that we extended the definition of 1-token games, so that they are played on two automata, rather than one. In the next definition, we use this extended notion of 1-token game to identify, for each automaton $\mathcal{A}$, an automaton $\mathcal{A}'$ such that Eve wins the the 1-token game on $\mathcal{A}$ if and only if $\mathcal{A}$ simulates $\mathcal{A}'$.

**► Definition 5 (1-token ghost).** An LTS (or an automaton) $\mathcal{A}'$ is a 1-token ghost of an LTS $\mathcal{A}$, denoted by $1\text{-TokenGhost}(\mathcal{A}', \mathcal{A})$, if $\mathcal{A}' \equiv \mathcal{A}$ and $G_1(\mathcal{A}', \mathcal{A})$.

To show that the ghost automaton has the property that $Sim(\mathcal{A}, \mathcal{A}')$ if and only if Eve wins $G_1(\mathcal{A}, \mathcal{A})$, we compose the strategies in $Sim(\mathcal{A}, \mathcal{A}')$ and $G_1(\mathcal{A}', \mathcal{A})$.
**Lemma 6.** Consider LTSs $\mathcal{A}$ and $\mathcal{A}'$, such that $\mathcal{A}$ simulates $\mathcal{A}'$ and 1-TokenGhost($\mathcal{A}'$, $\mathcal{A}$).
Then Eve wins $G_1(\mathcal{A})$.

**Proof.** Let $s_{sim}$ be a winning strategy of Eve in the simulation game between $\mathcal{A}$ and $\mathcal{A}'$, and $s'$ her winning strategy in $G_1(\mathcal{A}', \mathcal{A})$. Eve then has a winning strategy $s$ in $G_1(\mathcal{A})$: she plays the strategy $s_{sim}$ in $Sim(\mathcal{A}, \mathcal{A}')$ against her imaginary friend Berta, who plays the strategy $s'$ in $G_1(\mathcal{A}', \mathcal{A})$ against Adam. In more detail: In each round $i$ of the game $G_1(\mathcal{A})$, Adam chooses a transition sequence $\rho_{i-1}$ in $\mathcal{A}$ on $\sigma_{i-1}$ (except for the first round) on his token and a letter $\sigma_i$, then Berta chooses the transition sequence $\rho_i^B = s'(\rho_0, \dots, \rho_{i-1}, \sigma_i)$ over the letter $\sigma_i$ in $\mathcal{A}'$ on her token in $G_1(\mathcal{A}', \mathcal{A})$, and then Eve chooses the transition sequence $\rho_i = s_{sim}(\rho_0^B, \dots, \rho_{i-1}^B)$ in $\mathcal{A}$.

The run built by Eve with the strategy $s$ is accepting if the run built by Berta is, which is in turn accepting if Adam's run is. Hence, $s$ is a winning strategy for Eve in $G_1(\mathcal{A})$. ◀

Then, for classes in which token games characterise history-determinism and which are closed under the ghost relation, guidability and history-determinism coincide.

**Definition 7.** A class $C$ of LTSs is closed under 1-token ghost if for every $\mathcal{A} \in C$ there exists $\mathcal{A}' \in C$ such that 1-TokenGhost($\mathcal{A}'$, $\mathcal{A}$).

**Lemma 8.** Given a class $C$ of LTSs closed under 1-token ghost for which $G_1$ characterises history-determinism, history-determinism and guidability coincide for $C$.

**Proof.** Being HD always implies guidability, so one direction is easy. For the other direction, if $\mathcal{A}$ simulates every LTS $\mathcal{A}' \in C$, such that $\mathcal{A}' \le \mathcal{A}$, then in particular it simulates an LTS $\mathcal{A}' \in C$, such that 1-TokenGhost($\mathcal{A}'$, $\mathcal{A}$), as $C$ is closed under the 1-token ghost. By Lemma 6, Eve wins $G_1(\mathcal{A})$, implying that $\mathcal{A}$ is HD, as $G_1$ characterises history-determinism in $C$. ◀

A 1-token ghost is often easy to build, by delaying nondeterministic choices by one letter (Definition 12), as shown in Section 5.2 for pushdown automata, one-counter automata, vector addition system with states, one-counter nets and Parikh automata.

For some automata classes, however, showing closure under 1-token ghosts is trickier: for VPA the stack action must occur as the letter is read, and for timed automata configuration updates are sensitive to the current timestamp. We handle these complications in Section 5.3. We can also only use Lemma 8 with respect to automata classes for which 1-token games characterise history-determinism, which is not the case for parity automata or $\omega$-VPA [2].

## 4.3 Via Adam's strategy in the letter game

As we will see in detail in Section 5.4, some classes, such as linear automata, are neither closed under 1-token ghost nor determinisation, so there is no hope for the above criteria to apply. Our final criterion is an alternative which, instead of requiring all automata to admit a 1-ghost, builds a difficult-to-simulate automaton from Adam's winning strategy in the letter game. The intuition is that Adam's winning strategy in the letter game on an automaton $\mathcal{A}$ captures behaviour that is difficult for $\mathcal{A}$ to simulate, so if we can turn Adam's strategy into an automaton (which will be language-contained in $\mathcal{A}$ since Adam must play a word in the language of $\mathcal{A}$), then this automaton will not be simulated by $\mathcal{A}$. To build this automaton, we first project an automaton $\mathcal{B}$ recognising Adam's winning plays from his strategy onto the alphabet of $\mathcal{A}$, to obtain an automaton $\mathcal{B}_{\Sigma}$ that recognises the words played by Adam's strategy. Then, by taking the 1-token ghost of $\mathcal{B}_{\Sigma}$, we obtain an automaton $\mathcal{B}'$ against which the simulation game is essentially the letter game against Adam's strategy. If the resulting automaton is always still in the class $C$, guidability and history-determinism coincide.
**► Lemma 9.** *History-determinism and guidability coincide for classes C of LTSs in which, for each $\mathcal{A} \in C$ that is not history-deterministic, there is a deterministic LTS $\mathcal{B}$ over the alphabet of transitions of $\mathcal{A}$ that recognises the plays of a winning strategy of Adam in the letter game on $\mathcal{A}$, and $\mathcal{B}$, projected onto the alphabet of $\mathcal{A}$, has a 1-token ghost in C.*

**Proof.** Consider a winning strategy $\tau$ of Adam in the letter game on $\mathcal{A}$, and let $\mathcal{B}$ be a deterministic LTS that recognises the plays of $\tau$, seen as runs of $\mathcal{A}$. Let $\mathcal{B}_{\Sigma}$ be the projection of $\mathcal{B}$ onto $\Sigma$: it is otherwise like $\mathcal{B}$, except that its alphabet is $\Sigma$ instead of the transitions $\Delta_{\mathcal{A}}$ of $\mathcal{A}$ and as a result it has additional nondeterminism. Crucially, every transition in $\mathcal{B}$ is still a transition in $\mathcal{B}_{\Sigma}$. Given a sequence of transitions $t_0 t_1 \dots t_i \in \Delta_{\mathcal{A}}^*$, we call $t_0'' t_1'' \dots t_i''$ its run in $\mathcal{B}$, which is uniquely defined since $\mathcal{B}$ is deterministic. Note that this sequence of transitions is also a run over the word of $t_0 t_1 \dots t_i$ in $\mathcal{B}_{\Sigma}$. This also extends to infinite sequences. Since every run accepted by $\mathcal{B}$ is a play winning for Adam in the letter game over $\mathcal{A}$, their projection onto $\Sigma$ must be in $L(\mathcal{A})$, so $L(\mathcal{B}_{\Sigma}) \subseteq L(\mathcal{A})$.

Now, let $\mathcal{B}'$ be the 1-token ghost of $\mathcal{B}_{\Sigma}$, witnessed by a strategy $s_1$ of Eve in the game $G_1(\mathcal{B}', \mathcal{B}_{\Sigma})$. Assume, towards contradiction, that $\text{Sim}(\mathcal{A}, \mathcal{B}')$ via some strategy $s_{\text{sim}}$. We construct a strategy $s$ of Eve in the letter game on $\mathcal{A}$ that is winning against $\tau$, in which Eve plays $s_{\text{sim}}$ against her imaginary friend Berta in $\text{Sim}(\mathcal{A}, \mathcal{B}')$, who in turn is playing $s_1$ against Adam in $G_1(\mathcal{B}', \mathcal{B}_{\Sigma})$.

In more detail, Adam begins by playing $\sigma_0$ according to $\tau$ in the letter game on $\mathcal{A}$; Berta responds with a transition (or sequence of transitions in the presence of $\varepsilon$-transitions) $\rho_0' = s_1(\sigma_0)$; and then Eve responds with $s(\sigma_0) = \rho_0 = s_{\text{sim}}(\rho_0')$. On the $i^{\text{th}}$ round, when Adam chooses the letter $\sigma_i$, after the sequence $\rho_0 \dots \rho_{i-1}$ of Eve's moves in the letter game, and the sequence $\rho_0'', \dots, \rho_{i-1}''$ of transitions in $\mathcal{B}_{\Sigma}$, which is the $\Sigma$-projection of the unique run of $\mathcal{B}$ on $\rho_0 \dots \rho_{i-1}$, viewed as a word over $\Delta_{\mathcal{A}}$, Berta makes the move $\rho_i' = s_1(\rho_0'', \dots, \rho_{i-1}'', \sigma_i)$ in $G_1(\mathcal{B}', \mathcal{B}_{\Sigma})$, and then Eve the move $s(\sigma_0, \rho_0, \dots, \rho_{i-1}, \sigma_i) = \rho_i = s_{\text{sim}}(\rho_0'', \dots, \rho_{i-1}')$ in $\text{Sim}(\mathcal{A}, \mathcal{B}')$ and in the letter game.

We argue that $s$ is winning against $\tau$. Indeed, the run $\rho_0'' \rho_1'' \dots$ in $\mathcal{B}_{\Sigma}$ must be accepting since the sequence of transitions $\rho_0 \rho_1 \dots$ that Eve plays agrees with $\tau$. Then, since Berta is playing a winning strategy in $G_1(\mathcal{B}', \mathcal{B}_{\Sigma})$, the sequence $\rho_0' \rho_1' \dots$ is also an accepting run over the same word. Since Eve is playing a winning strategy in $\text{Sim}(\mathcal{A}, \mathcal{B}')$, the sequence $\rho_0 \rho_1 \dots$ is also an accepting run over the same word. This contradicts $\tau$ being a winning strategy for Adam. We conclude that $\mathcal{A}$ does not simulate $\mathcal{B}'$ and is therefore not guidable. ◀

Lemma 9 can be applied to various automata classes, as summarised in Table 1, including $\omega$-regular automata with an $[i, j]$-parity acceptance condition (Section 5.1), linear automata (Section 5.4), and visibly pushdown automata (Section 5.3).

This concludes our criteria. Concerning the necessity of each criterion, notice that:

- The first criterion (Theorem 1.1) is not subsumed by the others, as demonstrated with the class of all LTSs—it is closed under determinization [7, Theorem 3.4], but $G_1$ does not characterise history-determinism, which is required for the second criterion, and the letter game need not always be determined, which is required for the third.

- The second criterion (Theorem 1.2) does not imply the first one, as demonstrated by, for instance, safety pushdown automata [11, Theorem 4.1]. The implication from the second criterion to third criterion is unclear, however, and connects to the case of PDA, where the strategies for the players in letter game are not yet understood [11, Section 6].

- Finally, the third criterion (Theorem 1.3) is not subsumed by the other two, as evident from the case of linear automata (Section 5.4).
# 5 Automata Classes for which History-Determinism = Guidability

## 5.1 Straightforward cases

By Theorem 1.1, history-determinism and guidability coincide for all automata classes closed under determinisation, including: regular automata (NFAs); VPAs on finite words; $\omega$-regular automata [17]; co-Büchi [18]; and subclasses of $\omega$-regular automata whose deterministic fragment is $\omega$-regular-complete, such as parity, Rabin, Streett, Muller, and Emerson-Lei. Some subclasses of $\omega$-regular automata are not closed under determinisation, e.g., Büchi automata, but as long as they subsume safety automata, we can build on the fact that Adam's letter-game strategies are recognised by deterministic safety automata, and apply Theorem 1.3: since safety automata are determinisable they are closed under 1-token ghost.

**► Corollary 10.** *History-determinism and guidability coincide for classes of $\omega$-regular automata with an $[i, j]$-parity acceptance condition, as well as for the class of weak automata.*

## 5.2 Uniform infinite state systems

In this section, we show that the notions of history-determinism and guidability coincide on the following classes with safety and reachability acceptance conditions: pushdown automata, one-counter automata, vector addition system with states, one-counter nets and Parikh automata. We take a unified approach by defining all of these classes as cases of “uniform automata classes”, and showing that the two notions coincide for such classes (Theorem 14).

These uniform automata classes are specified by a content space $\mathcal{C}$ (e.g., stack contents) and a set $\mathcal{K}$ of partial functions $f: \mathcal{C} \to \mathcal{C}$ that contains the identity function $f_{id}$ that maps each element in $\mathcal{C}$ to itself (e.g., stack updates). The class specified by $\mathcal{C}$ and $\mathcal{K}$ contains all the automata $\mathcal{A} = (\Sigma, Q, \iota, c_0, \Delta, F_A, F_C)$ that have a finite alphabet $\Sigma$, a finite state space $Q$, and finitely many transitions $(q, \sigma, f, q') \in \Delta$, labelled by a letter $\sigma \in \Sigma_{\varepsilon} = \Sigma \cup \{\varepsilon\}$ and a function $f \in \mathcal{K}$. The automaton $\mathcal{A}$ induces an LTS that has states $(q, c) \in Q \times \mathcal{C}$, with transitions $(q, c) \xrightarrow{\sigma} (q', c')$, such that $(q, \sigma, f, q')$ is a transition in $\mathcal{A}$ and $f(c) = c'$.

The acceptance semantics of an automaton in such a class is specified by a set of accepting states $F_A \subseteq Q$ and a set of accepting contents $F_C \subseteq \mathcal{C}$. We will often desire some structure on $F_C$, so we impose the restriction that $F_C$ belongs to a set $\mathcal{S} \subseteq \mathcal{P}(\mathcal{C})$ of subsets of $\mathcal{C}$. We call “$(\mathcal{C}, \mathcal{K}, \mathcal{S})$-automata” the class of all automata $\mathcal{A} = (\Sigma, Q, \iota, c_0, \Delta, F_A, F_C)$ as above with $F_C \in \mathcal{S}$. Safety automata require an accepting run to have all states in $F_A$ and all content in $F_C$. We distinguish between synchronous reachability that requires an accepting run to reach an accepting state and an accepting content at the same time, and asynchronous reachability that requires an accepting run to just reach an accepting state and an accepting content, not necessarily at the same time.

**► Definition 11.** *A class of automata is uniform if it can be specified as $(\mathcal{C}, \mathcal{K}, \mathcal{S})$-automata with either safety, synchronous reachability, or asynchronous reachability acceptance semantic.*

We show that uniform automata classes are closed under 1-token ghost by explicitly constructing for each automaton $\mathcal{A}$ in the class a 1-token ghost, called Delay($\mathcal{A}$), inspired by Prakash and Thejaswini [20, Lemma 11]. For each run in $\mathcal{A}$, we will have a run in Delay($\mathcal{A}$) that lags one transition behind. This one-step lag is implemented by storing the previous letter in the state space of $\mathcal{A}$, in addition to the state of $\mathcal{A}$; transitions are then taken based on the previous letter, while reading the current letter, which is now stored.

**► Definition 12 (Delay).** Let $\mathcal{A} = (\Sigma, Q, \iota, c_0, \Delta, F_Q, F_C)$ be an automaton in a uniform class $(\mathcal{C}, \mathcal{K}, \mathcal{S})$. The automaton Delay($\mathcal{A}$) = $(\Sigma, Q', \iota', c_0, \Delta', F'_Q, F_C)$ is the Delay of $\mathcal{A}$, where
1. The set of states $Q'$ is $(Q \times \Sigma) \cup \{\iota'\}$

2. The set of transitions $\Delta'$ is given by the union of:

- $\{(\iota', \sigma, f_{id}, (\iota, \sigma)) \mid \sigma \in \Sigma\}$

- $\{((q, \sigma), \sigma', f, (q', \sigma')) \mid \sigma, \sigma' \in \Sigma, \text{ and } (q, \sigma, f, q') \in \Delta\}$

- $\{(q, \sigma), \varepsilon, f, (q', \sigma) \mid \sigma \in \Sigma, \text{ and } (q, \varepsilon, f, q') \in \Delta\}$

3. The set $F'_Q$ consists of state of the form $(q, \sigma)$ such that $q \in F_Q$, and $\iota$ if $\iota \in F_Q$.

The automaton $\text{Delay}(\mathcal{A})$ has the same acceptance semantics as $\mathcal{A}$ (safety, synchronous reachability or asynchronous reachability).

**Lemma 13.** *Given an automaton $\mathcal{A}$ in a uniform automata class $C$, the automaton $\text{Delay}(\mathcal{A})$ is in $C$ and is a 1-token ghost of $\mathcal{A}$.*

We show that $G_1$ characterises history-determinism on all uniform automata classes (Lemma 22), by reducing to safety and reachability LTSs [7]. With Lemma 13 and Theorem 1.2, we get that history-determinism and guidability coincide on all uniform automata classes.

**Theorem 14.** *History-determinism and guidability coincide for uniform automata classes.*

It now suffices to represent various automata classes as uniform ones to show that guidability and history-determinism coincide on them. For pushdown and one-counter automata, vector addition systems and one-counter nets, as well as for Parikh automata, the contents are the counter or stack contents, while the update functions are their increments, decrements, pops and pushes. The update partial functions also implement which parts of the contents can be used to enable transitions: for example, for pushdown automata, the partial functions are either defined for all contents where the stack is empty, or undefined for all such contents; for Parikh automata, the contents do not influence which transitions are enabled, so the functions are fully defined. (Formal definitions are given in Definitions 23–25.)

**Corollary 15.** *History-determinism and guidability coincide for the classes of pushdown automata, one-counter automata, vector addition systems with states, one-counter nets with safety and reachability acceptance conditions, and for Parikh automata with safety, synchronous reachability and asynchronous reachability acceptance conditions.*

## Non-uniform classes

The class of visibly pushdown automata is not uniform, as there are additional constraints on transitions, namely the kind of function that changes content depends on the letter seen. Timed automata also do not constitute a uniform class, since the alphabet is infinite as it consists of all timed letters, and the clock valuations are updated according to both the transition (resets) and the delay of the input letter. In Section 5.4, we consider linear automata: these are Büchi automata that have no cycles apart from self-loops. Linear automata also does not form a uniform class, since they restrict the state-space. In what follows, we give alternative constructions of 1-token-ghosts for these classes. The case of linear automata is trickier, as we show that it is not closed under 1-token ghost. We therefore use, in Section 5.4, a more involved argument that allows us to use Theorem 1.3.

## 5.3 Visibly pushdown and timed automata

Visibly pushdown automata over infinite words $(\omega$-VPAs) are neither (history-) determinisable, nor does $G_1$ characterise history-determinism on them. Nevertheless, we can use Theorem 1.3 to show that history-determinism and guidability coincide for this class.
**Theorem 16.** *History-determinism and guidability coincide for the class of visibly pushdown automata with any $\omega$-regular acceptance condition.*

**Proof sketch.** First we show that the class is closed under 1-token ghost. Like in the previous cases, we build an automaton that executes the same transitions, but one step later. The technical challenge is executing transitions with a delay, as an $\omega$-VPA must respect the stack discipline of the input alphabet. We overcome this by maintaining a “semantic stack” that consists of the actual stack and one additional letter that is embedded in the state space and stores, when necessary, the letter that should have been in the top of the stack.

Then, we describe the letter-game for an $\omega$-VPA as a game on a visibly pushdown arena with a “stair parity” acceptance condition, to show that Adam’s winning strategies can be implemented by $\omega$-VPA transducers. We then turn this transducer into a deterministic $\omega$-VPA recognising the plays that agree with Adam’s strategy, and apply Theorem 1.3. ◀

We turn to safety and reachability timed automata, for which we apply Theorem 1.2, yet with a specially tailored *Delay* construction.

**Theorem 17.** *For the class of timed automata with safety or reachability acceptance conditions, the notions of history-determinism and guidability coincide.*

**Proof sketch.** The goal is to simulate such an automaton $\mathcal{A}$ with a delay, as in Definition 12. Yet, the difficulty is that delaying a clock-reset by a step will affect the value of the clock for future comparisons, and there is no delaying of the passage of time. Hence a naive construction would end up recognising the timed language of words in which timestamps are shifted by one. We overcome the difficulty by duplicating in the 1-token ghost construction each clock of $\mathcal{A}$, using one copy for comparisons in guards and the other to simulate retroactive resets. In addition, the state-space stores the effect of the previous delay, by remembering the corresponding region, that is, how the timestamp compares to existing clocks and constants. With this construction, and the $G_1$-characterisation of history-determinism for safety and reachability automata, we complete the proof. ◀

## 5.4 Linear automata

A *linear* (also called *very weak*) automaton is a Büchi automaton in which all cycles are self loops. (In linear automata, the acceptance condition does not really matter, since over an automaton with only self loops, all the standard $\omega$-regular acceptance conditions coincide.)

First, observe that linear automata are not closed under (history-)determinisation. (The standard Büchi automaton over the alphabet $\Sigma = \{a, b\}$ recognizing the language of finitely many $a$'s is linear.) We show that they are also not closed under 1-token ghost, by proving that the linear automaton depicted in Figure 1 admits no 1-token ghost in the class.

**Theorem 18.** *The class of linear automata is not closed under 1-token ghost.*

**Proof.** Let $\mathcal{A}$ be the linear automaton depicted in Figure 1, and assume toward contradiction that there is a linear automaton $\mathcal{A}'$, satisfying $\text{1-TokenGhost}(\mathcal{A}', \mathcal{A})$, witnesses by a winning strategy $s$ of Eve in $G_1(\mathcal{A}', \mathcal{A})$.

In a play $\pi_1$ of $G_1(\mathcal{A}', \mathcal{A})$ in which Eve plays along $s$ and Adam plays $(ab)^*$ while staying in $q_0$, at some points of time $2k-1$ and $2k$, Eve must remain in the same state $q'$ of $\mathcal{A}'$ after Adam chose the letters $a$ and $b$, respectively, since $\mathcal{A}'$ is linear.

In a play $\pi_2$ of $G_1(\mathcal{A}', \mathcal{A})$ in which Eve plays along $s$ and Adam starts with $(ab)^{k-1}a$ while staying in $q_0$, Eve reaches, as per the previous claim, the state $q'$ of $\mathcal{A}'$. Then, if Adam
<figure><img src="image_12.png" /><figcaption>Figure 1 A linear automaton which admits no linear automaton that is a 1-token ghost of it.</figcaption></figure>

continues with the word $ca^ω$, while moving from $q_0$ to $q_1$ (over the previous $a$) and then to $q_3$ (over $c$), Eve has some accepting continuation run $ρ$ from the state $q'$ over the suffix $ca^ω$, since $s$ is winning for Eve in $G_1(\mathcal{A}', \mathcal{A})$ and Adam's run is accepting.

Thus, there is an accepting run of $\mathcal{A}'$ on the word $w = (ab)^k ca^ω$, following in the first $2k$ steps the run of Eve in the play $π_1$, reaching the state $q'$, and then in the next steps following her accepting continuation in $π_2$. Yet, $\mathcal{A}$ does not have an accepting run on $w$, contradicting the equivalence of $\mathcal{A}$ and $\mathcal{A}'$, and thus the assumption that 1-TokenGhost($\mathcal{A}', \mathcal{A}$). ◀

Yet, history-determinism and guidability do coincide for the class of linear automata. The underlying reason is that when a linear automaton $\mathcal{A}$ is not history-deterministic, Adam's winning strategy in the letter game can be adapted to a linear automaton that does have a 1-token ghost within the class of linear automata, thus satisfying Theorem 1.3.

**Theorem 19.** *History-determinism and guidability coincide for the class of linear automata.*

*Proof sketch.* History-determinism implies guidability with respect to all classes. For the other direction, consider a linear automaton $\mathcal{A} = (\Sigma, Q, \iota, \Delta, \alpha)$ that is not HD, and let $M = (\Delta, \Sigma, M, m_0, \Delta_M : M \times \Delta \to M, \gamma : M \to \Sigma)$ be a deterministic finite-state transducer representing a finite-memory winning strategy $s_M$ of Adam in the letter game.

We then build, by taking a product of $M$ and $\mathcal{A}$, a deterministic safety automaton $\mathcal{P}$, that recognises the set of plays that can occur in the letter game on $\mathcal{A}$ if Adam plays according to $s_M$. From $\mathcal{P}$, we take its projection $\mathcal{N}$ onto the alphabet $\Sigma$ of $\mathcal{A}$. $\mathcal{N}$ need not be linear, but we adapt it into a linear $\mathcal{N}'$ that will still correspond to a winning strategy of Adam in the letter game. $\mathcal{N}'$ will thus constitute a projection of a deterministic automaton $\mathcal{P}'$ onto the alphabet $\Sigma$, where $\mathcal{P}'$ is over the alphabet of transitions of $\mathcal{A}$ and recognises the plays of a winning strategy of Adam in the letter game. Once achieving that, we can apply the Delay construction on $\mathcal{N}'$—it will not introduce, in this case, non-self cycles, since the states of $\mathcal{N}'$ (as the projection of the states of $\mathcal{P}'$), have outgoing transitions only on a single letter. Hence, we satisfy Theorem 1.3, proving the stated claim.

The transformation of $\mathcal{N}$ into $\mathcal{N}'$ is quite technical, and is left to Appendix C.4. ◀

<figure><img src="image_13.png" /></figure>

# 6 Automata Classes for which History-Determinism ≠ Guidability

In this section we study classes which admit guidable automata that are not history-deterministic. They offer insight into how, in practice, the criteria can fail to hold, and witness that even on arguably natural automata classes, guidability and history determinism do not necessarily coincide. The main reason for the equivalence between the notions to fail for these classes is a bound on the allowed resources – the number of states in the first class and the number of clocks in the second.

Our first example of when history-determinism and guidability differ are Büchi automata with a bounded number of states, witnessed by the automaton in Figure 2.
**▶ Theorem 20.** For every $n \in \mathbb{N}^+$, history-determinism and guidability are distinct notions for the class of Büchi automata with up to $2n$ states.

<figure><img src="image_14.png" /></figure>

■ **Figure 2** A Büchi automaton that accepts words with a finite number of $a$'s. To simulate any equivalent small enough Büchi automaton $B$, Eve moves to the next accepting state once the other automaton is in a maximally strongly connected component with an accepting state. The size constraint on $B$, and the observation that a such a component can not both have a transition on $a$ and an accepting state guarantees that this strategy wins in the simulation game. However, $B$ is not history-deterministic.

This counter-example is simple, but quite artificial. We proceed with a class which is, arguably, more natural: timed automata with a bounded number of clocks.

**▶ Theorem 21.** History-determinism and guidability are distinct notions for the class $T_k$ of timed-automata over finite words with at most $k$ clocks, for each $k \in \mathbb{N}$.

**Proof sketch.** We consider the language of infinite words in which there are $k$ event pairs that occur exactly one time-unit apart both before and after the first occurrence of a $\$ letter. Then, the guidable automaton for this language can freely reset its clocks until the $\$-separator, which allows it to ensure it tracks all delays tracked by a smaller automaton with up to $k$ clocks. Crucially, any automaton that only accepts words in this language must keep track of $k$ clock values when the separator occurs, as otherwise, it will also accept some word in which the second of matching pair of event is shifted a little. ◀

## 7 Conclusions

We have presented sufficient conditions for a class of automata to guarantee the coincidence of history-determinism and guidability, and used them to show that this is the case for many standard automata classes on infinite words. As a result, we get algorithms to decide guidability for many of these classes. Guidable automata allow for simple model-checking procedures, and once guidability check is simple, one can take advantage of it whenever applicable. For example, consider a specification modelled by a Büchi or coBüchi automaton $\mathcal{A}$. Model-checking whether a system $\mathcal{S}$ satisfies $\mathcal{A}$ is PSpace-hard. Using our results, one can check first in PTime whether $\mathcal{A}$ is guidable, and in the fortunate cases that it is, conclude the model checking in PTime, by checking whether $\mathcal{A}$ simulates $\mathcal{S}$. We have also demonstrated automata classes for which guidability and history-determinism do not coincide.

We believe that our positive results extend to additional automata classes, such as register automata [15], which behave quite similarly to timed automata. Furthermore, we believe them to extend to additional families of automata classes:

- *Finite words.* We have focused on automata over infinite words, which in this context, are better behaved. Ends of words bring additional complications to our constructions, but overall we believe our approach to be amenable to the analysis of finite word automata.

- *Quantitative automata.* In quantitative automata, transitions carry additional information in the form of weights. As a result, there is an additional difference between the letter game and simulation game, which makes extending our analysis to the quantitative setting particularly relevant. We believe that many of our techniques adapt to that setting.
One could argue that for model-checking, the more interesting property is whether a (not necessarily safety) automaton is guidable by just safety automata, since we typically represent specifications by safety automata. Interestingly, this property often coincides with guidability w.r.t. the full class of automata, as demonstrated in by our third criterion (Theorem 1.3): if Adam's strategies in the letter game can be translated into automata, these automata are safety ones, and therefore guidability w.r.t. safety automata is just as hard as guidability w.r.t. the full class of automata with the more complex acceptance conditions.

References

1. Rajeev Alur and P. Madhusudan. Visibly pushdown languages. In László Babai, editor, *Proceedings of the 36th Annual ACM Symposium on Theory of Computing, Chicago, IL, USA, June 13-16, 2004*, pages 202–211. ACM, 2004. doi:10.1145/1007352.1007390.

2. Marc Bagnol and Denis Kuperberg. Büchi good-for-games automata are efficiently recognizable. In *38th IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS 2018)*, page 16, 2018.

3. Udi Boker. Why these automata types? In *Proceedings of LPAR*, pages 143–163, 2018.

4. Udi Boker, Denis Kuperberg, Karoliina Lehtinen, and Michał Skrzypczak. On succinctness and recognisability of alternating good-for-games automata. In *arXiv preprint arXiv:2002.07278*, 2020.

5. Udi Boker and Karoliina Lehtinen. Token games and history-deterministic quantitative automata. In *FoSSaCS*, pages 120–139, 2022. A submitted journal version is available at https://arxiv.org/abs/2110.14308.

6. Udi Boker and Karoliina Lehtinen. When a little nondeterminism goes a long way: An introduction to history-determinism. *ACM SIGLOG News*, 10(1):24–51, 2023. doi:10.1145/3584676.3584682.

7. Sougata Bose, Thomas A. Henzinger, Karoliina Lehtinen, Sven Schewe, and Patrick Totzke. History-deterministic timed automata, 2023. arXiv:2304.03183.

8. Thomas Colcombet. Fonctions régulières de coût. Habilitation à diriger les recherches, École Doctorale de Sciences Mathématiques de Paris Centre, 2013.

9. Thomas Colcombet and Christof Löding. The non-deterministic mostowski hierarchy and distance-parity automata. In *Proc. of ICALP*, volume 5126, pages 398–409, 2008. doi:10.1007/978-3-540-70583-3\_33.

10. Wladimir Fridman. Formats of winning strategies for six types of pushdown games. In Angelo Montanari, Margherita Napoli, and Mimmo Parente, editors, *GANDALF 2010*, volume 25 of *EPTCS*, pages 132–145, 2010. doi:10.4204/EPTCS.25.14.

11. Shibashis Guha, Ismaël Jecker, Karoliina Lehtinen, and Martin Zimmermann. A bit of nondeterminism makes pushdown automata expressive and succinct. *Log. Methods Comput. Sci.*, 20(1), 2024. doi:10.46298/LMCS-20(1:3)2024.

12. Thomas Henzinger and Nir Piterman. Solving games without determinization. In *Proceedings of CSL*, pages 395–410, 2006.

13. Thomas A. Henzinger, Orna Kupferman, and Sriram K. Rajamani. Fair simulation. *Inf. Comput.*, 173(1):64–81, 2002. doi:10.1006/inco.2001.3085.

14. Thomas A. Henzinger, Karoliina Lehtinen, and Patrick Totzke. History-deterministic timed automata. In Bartek Klin, Slawomir Lasota, and Anca Muscholl, editors, *33rd International Conference on Concurrency Theory, CONCUR 2022, September 12-16, 2022, Warsaw, Poland*, volume 243 of *LIPIcs*, pages 14:1–14:21. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2022.

15. Michael Kaminski and Nissim Francez. Finite-memory automata. *Theoretical Computer Science*, 134(2):329–363, 1994. URL: https://www.sciencedirect.com/science/article/pii/0304397594902429, doi:10.1016/0304-3975(94)90242-9.
16 Christof Löding, P. Madhusudan, and Olivier Serre. Visibly pushdown games. In Kamal Lodaya and Meena Mahajan, editors, *FSTTCS 2004: Foundations of Software Technology and Theoretical Computer Science, 24th International Conference, Chennai, India, December 16-18, 2004, Proceedings*, volume 3328 of *Lecture Notes in Computer Science*, pages 408–420. Springer, 2004. doi:10.1007/978-3-540-30538-5_34.

17 Robert McNaughton. Testing and generating infinite sequences by a finite automaton. *Information and Control*, 9:521–530, 1966.

18 Satoru Miyano and Takeshi Hayashi. Alternating finite automata on $\omega$-words. *Theoretical Computer Science*, 32:321–330, 1984.

19 Damian Niwiński and Michał Skrzypczak. On Guidable Index of Tree Automata. In Filippo Bonchi and Simon J. Puglisi, editors, *46th International Symposium on Mathematical Foundations of Computer Science (MFCS 2021)*, volume 202 of *Leibniz International Proceedings in Informatics (LIPIcs)*, pages 81:1–81:14, Dagstuhl, Germany, 2021. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. URL: https://drops-dev.dagstuhl.de/entities/document/10.4230/LIPIcs.MFCS.2021.81, doi:10.4230/LIPIcs.MFCS.2021.81.

20 Aditya Prakash and K. S. Thejaswini. On history-deterministic one-counter nets. In Orna Kupferman and Pawel Sobocinski, editors, *Foundations of Software Science and Computation Structures - 26th International Conference, FoSSaCS 2023, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2023, Paris, France, April 22-27, 2023, Proceedings*, volume 13992 of *Lecture Notes in Computer Science*, pages 218–239. Springer, 2023. doi:10.1007/978-3-031-30829-1_11.
# A Detailed Definitions

## Automata

Here we give more detailed definitions of the automata we work with. Each type of automaton induces an LTS of which the states are the configurations of the automaton and the transitions enabled at each configuration updates it as expected; runs and acceptance are defined uniformly from the induced LTS.

A pushdown automaton (PDA) $(\Sigma, Q, \iota, \Delta, \Gamma, \alpha)$ consists of a finite set of states $Q$, a finite input alphabet $\Sigma$, an initial state $\iota$, a transition relation $\Delta$ detailed hereafter, a finite stack alphabet $\Gamma$, and an acceptance condition $\alpha$. A configuration consists of a state from $Q$ and a string of stack variables in $\Gamma^* \perp$ ending in $\perp$, a distinguished bottom-of-stack symbol. The mode of a configuration $(q, XS)$, for $q \in Q$, $X \in \Gamma$ and $S \in \Gamma^* \perp$, is $(q, X)$, and of $(q, \perp)$ is $(q, \perp)$, namely the state and topmost stack symbol. The transitions of a PDA are enabled at a mode and take the form $(q, X) \xrightarrow{\sigma|_\text{op}} q'$ where $X \in \Gamma \cup \{\perp\}$, $\sigma \in \Sigma \cup \{\varepsilon\}$, $\text{op} \in \{\text{push } Y, \text{pop, noop}\}$ for $Y \in \Gamma$, and $q' \in Q$. Transitions update the configuration as follows. A push $Y$ transition adds $Y$ to the top of the configuration stack, a pop transition removes the top of the stack and can not be enabled at a mode $(q, \perp)$ indicating an empty stack, and a noop-transition leaves the stack as is. A transition changes the configuration state as expected.

A visibly pushdown automaton (VPA) is a pushdown automaton without $\varepsilon$-transitions of which the input alphabet $\Sigma$ is partitioned between push, pop and noop letters, which only occur in push, pop and noop transitions, respectively.

A timed automaton $\mathcal{T} = (\Sigma, Q, \iota, C, \delta, \alpha)$ has a finite alphabet $\Sigma$, a set of states $Q$ with an initial state $q_0$, a set of clocks $C$, a transition function $\delta$ and acceptance condition $\alpha$ as usual. Timed automata, as the name suggests, process timed words. These are sequences of pairs $\{\sigma_i, d_i\}_{i \ge 0}$ of letters $\sigma_i \in \Sigma$ and non-negative time delays in $\mathbb{R}$. A timed word may also get written as $\{\sigma_i, t_i\}_{i \ge 0}$ where $t_i$ is the timestamp of $\sigma_i$, that is, the sum of the delays up to $i$. We then say that the event $\sigma_i$ occurs at time $t_i$, or after the delay $d_i$. A timed automaton is a finite automaton equipped with a set of clocks $C$ that measure the passage of time. Each transition $(q, g, \sigma, X, q')$ of a timed automaton checks the valuation of these clocks using a guard $g$, and resets the values of a subset of clocks $X$ to 0. These guards are Boolean combinations $B(C)$ of clock constrains of the form $c \triangleleft n$, where $c$ is the value of a clock, $n$ is a natural number and $\triangleleft \in \{\le, <, =, \ge, >\}$.

A configuration of a timed automaton is a pair in $Q \times \mathbb{R}^C$ consisting of a state and a clock valuation. A transition $(q, g, \sigma, X, q')$ can be taken over a timed letter $(\sigma, d)$ at configuration $(q, \nu)$ if the valuation $\nu + d$, in which all clocks are increased by $d$ from $\nu$, satisfies the guard $g$. The next configuration is then $(q', \nu + d[X])$, where the clocks in $X$ are reset to 0. We may use $\langle q, \nu \rangle \xrightarrow{\sigma,d} \langle q, \nu + d \rangle \xrightarrow{g,X} \langle q', \nu' \rangle$ to denote the transition we just described, splitting it into a 'delay step' and a 'reset step'. The induced LTS of $\mathcal{A}$ has as its states configurations of $\mathcal{A}$ and as transitions those enabled at each configuration, labelled with letter-delay pairs.

We consider timed automata with safety or reachability acceptance conditions, which we denote by $\mathcal{T} = (\Sigma, Q, \iota, \delta, F)$ where $F$ is the safe or target region respectively.

# B Proofs of Section 4

**► Lemma 4.** History-determinism and guidability coincide for any class $C$ of LTSs in which the languages expressed by history-deterministic (or deterministic) LTSs are the same as languages expressed by nondeterministic LTSs.
**Proof.** HD always implies guidability: given $\mathcal{A}$ in $C$ that is HD, it is easy to see that Eve wins $\text{Sim}(\mathcal{A}, \mathcal{A}')$ for all $\mathcal{A}' \le \mathcal{A}$, as the strategy that chooses transitions in $\mathcal{A}$ according to the letter game on $\mathcal{A}$, ignoring Adam's token in $\mathcal{A}'$, is a winning strategy.

For the other direction, consider $\mathcal{A} \in C$ that is guidable within $C$, and let $\mathcal{A}' \in C$ be an HD LTS equivalent to $\mathcal{A}$. As $\mathcal{A}$ is guidable, it simulates, in particular, $\mathcal{A}'$. Eve can use her winning strategy $s$ in this simulation game, together with her winning strategy $s'$ in the letter game on $\mathcal{A}'$ to also win the letter game on $\mathcal{A}$: when Adam provides a letter in the letter game on $\mathcal{A}$, Eve uses the transition (or transition sequence, in the presence of $\varepsilon$-transitions) $\rho$ chosen by $s'$ in the letter game on $\mathcal{A}'$ on the same letter. She assumes Adam chooses the transition sequence $\rho$ on $\mathcal{A}'$ in $\text{Sim}(\mathcal{A}, \mathcal{A}')$ as well, and responds to Adam in the letter game on $\mathcal{A}$ with the move suggested by $s$ in $\text{Sim}(\mathcal{A}, \mathcal{A}')$. If the word generated by Adam is accepting, then the run generated by $\sigma'$ in $\mathcal{A}'$ is accepting, and therefore the run generated in $\mathcal{A}$ in $\text{Sim}(\mathcal{A}, \mathcal{A}')$ by $\sigma$ is also accepting. $\quad \lozenge$

C Proofs of Section 5

C.1 Uniform infinite state systems

► **Lemma 13.** *Given an automaton $\mathcal{A}$ in a uniform automata class $C$, the automaton $\text{Delay}(\mathcal{A})$ is in $C$ and is a 1-token ghost of $\mathcal{A}$.*

**Proof.** Consider $\mathcal{A} = (\Sigma, Q, \iota, \Delta, F_Q, F_C)$ and $\text{Delay}(\mathcal{A}) = (\Sigma, Q', \iota, c_0, \Delta', F'_Q, F'_C)$ as per Definition 12. We need to show that (i) Eve wins $G_1(\text{Delay}(\mathcal{A}), \mathcal{A})$, and (ii) $L(\mathcal{A}) = L(\text{Delay}(\mathcal{A}))$.

(i) We give a winning strategy for Eve in $G_1(\text{Delay}(\mathcal{A}), \mathcal{A})$. In the first round, after Adam chooses a letter $\sigma_0$, Eve chooses the unique transition $(\iota', \sigma_0, f_{id}, (\iota, \sigma_0))$, and then Adam a transition sequence $\rho_0 = (\iota, c_0) \xrightarrow{\sigma_0, \rho_0} (q_1, c_1)$. Eve will then preserve in next rounds the following invariant: *Suppose Adam took the transition sequence $\rho_i = (q_{i-1}, c_{i-1}) \xrightarrow{\sigma_i, \rho_i} (q_i, c_i)$ in round $i$, then Eve's configuration after $i$ rounds is given by $((q_{i-1}, \sigma'_{i-1}), c_{i-1})$.*

The invariant clearly holds after the first round. Suppose that after $i > 0$ rounds of play, the invariant holds. Eve preserves the invariant after $i + 1$ rounds as follows:

In the $(i+1)^{th}$ round, suppose Adam selects the letter $\sigma_i \in \Sigma$, after choosing the transition sequence $\rho_i = (p^0, c^0) \xrightarrow{\varepsilon, f^0} (p^1, c^1) \xrightarrow{\varepsilon, f^1} \dots (p^k, c^k) \xrightarrow{\sigma_{i-1}, f^k} (p^{k+1}, c^{k+1}) \xrightarrow{\varepsilon, f^{k+1}} \dots (p^l, c^l)$ in the $i^{th}$ round, where $(p^0, c^0) = (q_{i-1}, c_{i-1})$ and $(p^l, c^l) = (q_i, c_i)$.

By construction of $\text{Delay}(\mathcal{A})$, it has a transition sequence $\rho'_i = ((p^0, \sigma_{i-1}), c^0) \xrightarrow{\varepsilon, f^0} \dots ((p^k, \sigma_{i-1}), c^k) \xrightarrow{\sigma_i, f^k} ((p^{k+1}, \sigma_i), c^{k+1}) \xrightarrow{\varepsilon, f^{k+1}} \dots ((p^l, \sigma_i), c^l)$ on $\sigma_i$. We let Eve pick $\rho'_i$ in $(i+1)^{th}$ round, essentially copying Adam's transition sequence in the $i^{th}$ round. Adam selects a transition sequence $(q_i, c_i) \xrightarrow{\sigma_i, \rho_{i+1}} (q_{i+1}, c_{i+1})$, and it is clear that the invariant is preserved throughout. This implies that the run Eve constructs in $\text{Delay}(\mathcal{A})$ is accepting whenever Adam's is accepting. Hence, Eve wins $G_1(\text{Delay}(\mathcal{A}), \mathcal{A})$.

(ii) $L(\mathcal{A}) \subseteq L(\text{Delay}(\mathcal{A}))$ is clear, as Eve wins $G_1(\text{Delay}(\mathcal{A}), \mathcal{A})$. For the other direction of the inclusion, let $w$ be a word accepted by $\text{Delay}(\mathcal{A})$ via a run $\rho' = (\iota', c_0) \xrightarrow{\sigma_0, f_{id}} ((\iota, \sigma_0), c_0) \xrightarrow{\sigma_1, \rho_0'} ((q_1, \sigma_1), c_1) \xrightarrow{\sigma_2, \rho_1'} ((q_2, \sigma_2), c_2) \dots$, such that $w = \sigma_0\sigma_1\sigma_2\dots$. Then it is easy to see that there is a run $\rho = (\iota, c_0) \xrightarrow{\sigma_0, \rho_0} (q_1, c_1) \xrightarrow{\sigma_1, \rho_1} (q_2, c_2) \dots$ of $\mathcal{A}$ on $w$ that is accepting whenever $\rho'$ is. $\quad \lozenge$
**► Lemma 22.** Let $\mathcal{A}$ be an automaton in a uniform automata class. Eve wins $G_1$ on $\mathcal{A}$ if and only if $\mathcal{A}$ is history-deterministic.

*Proof.* Let $\mathcal{A} = (\Sigma, Q, \iota, c_0, \delta, F_Q, F_C)$. When $\mathcal{A}$ has safety or synchronous reachability acceptance semantic, Eve wins $G_1$ on $\mathcal{A}$ if and only if $\mathcal{A}$ is HD, since the one-token game characterises history-determinism on all safety and reachability LTSs [5, 7].

For the case of $\mathcal{A}$ with acceptance by asynchronous reachability, consider the reachability LTS $\mathcal{B}$, in which the states are given by $(q, c, p_1, p_2)$, where $q$ is a state in $\mathcal{A}$ and $c \in C$, and $p_1$ and $p_2$ are flags that are either 0 or 1, based on whether an accepting state in $F_A$ or $F_C$ is seen in the run so far. The initial state is given by $(\iota, c_0, 0, 0)$. The transitions of $\mathcal{B}$ are of the form $(q, c, p_1, p_2) \xrightarrow{\sigma} (q', c', p'_1, p'_2)$, such that $(q, \sigma, f, q')$ is a transition in $\mathcal{A}$, where $f(c) = c'$, $p'_1 = 1$ if $q' \in F_C$ and $p'_1 = p_1$ otherwise, and similarly, $p'_2 = 1$ if $c' \in F_C$ and $p'_2 = p_2$ otherwise. The accepting states of the LTS $\mathcal{B}$ are those in which both the flags are 1, i.e., states of the form $(q, c, 1, 1)$ where $q \in Q$ and $c \in C$.

It is easy to see that a winning strategy for Eve in $G_1(\mathcal{A})$ or the letter game on $\mathcal{A}$ can be used to get a winning strategy for Eve in $G_1(\mathcal{B})$ or the letter game on $\mathcal{B}$, respectively, and vice versa. As Eve wins $G_1$ on any reachability LTS if and only if the LTS is HD [5, 7], we get that Eve wins $G_1$ on $\mathcal{A}$ if and only if $\mathcal{A}$ is HD. ◀

We represent various classes of automata as uniform automata classes. The class of safety and reachability nondeterministic $\omega$-regular automata is a uniform automata class, as it can be given by a $(C, \mathcal{K}, S)$-automata class where $C = \{X\}$ is a singleton set, $\mathcal{K}$ only consists of the identity function, and $S = \{C\}$. Synchronous and asynchronous reachability coincides in this setting. We show that the classes of VASS, one-counter nets, and pushdown-, Parikh-, and one-counter-automata are also uniform automata classes.

**► Definition 23.** Pushdown automata is a uniform automata class given by $(C, \mathcal{K}, S)$, where $C = \bot\Gamma^*$ is the set of possible stack contents for some set $\Gamma$ of stack symbols, where $\bot \notin \Gamma$. Let $\Gamma_\bot$ be $\Gamma \cup \{\bot\}$. The set $\mathcal{K}$ consists of the following partial functions from $C$ to $C$:

1. Push transitions: $\text{Map } \gamma X \text{ to } \gamma XY$, where $\gamma X \in \bot\Gamma^*$, $X \in \Gamma_\bot$ and $Y \in \Gamma$.

2. Pop transitions: $\text{Map } \gamma X \text{ to } \gamma$, where $\gamma \in \bot\Gamma^*$ and $X \in \Gamma$.

3. Noop transitions: $\text{Map } \gamma \text{ to } \gamma$ for each $\gamma \in \bot\Gamma^*$.

The set $S$ either equals $\{C\}$, in which case the acceptance is only state-based or equals $\{\bot\}$, the set consisting of only the 'empty stack'. Both these formalisms are known to be equivalent for synchronous reachability PDA, while for safety PDA we consider only the former, as the latter coincides with finite state automata.

One-counter automata are restrictions of pushdown automata where $\Gamma = \{X\}$ is a singleton set in Definition 23 above. It is clear that imposing this restriction yields another uniform automata class.

**► Definition 24.** Vector addition systems with states (VASS) is a uniform automata class given by $(C, \mathcal{K}, S)$, where $C = \mathbb{N}^*$ is the set of vectors. The set $\mathcal{K}$ consists of partial functions specified by $\alpha \in \mathbb{Z}^d$ for some $d > 0$ that maps a vector $v \in \mathbb{N}^d$ to $v + \alpha$, provided $v + \alpha$ is in $\mathbb{N}^d$. The set $S$ equals $\{C\}$, and thus acceptance is only based on the accepting states of an automaton in this class. The accepting condition is given by (synchronous) reachability or safety semantics. Note that as synchronous reachability and asynchronous reachability coincide here due to $S$ consisting of only $C$, we just use reachability VASS to denote synchronous reachability VASS.
d-dimensional VASS are restrictions of VASS where $\mathcal{C} = \mathbb{N}^d$ for some $d > 0$. It is easy to see that d-dimensional VASSes are also a uniform automata class. The class of 1-dimensional VASS is called *one-counter nets* (OCNs).

**Definition 25.** Parikh automata is a uniform automata class given by $(\mathcal{C}, \mathcal{K}, \mathcal{S})$ where $\mathcal{C} = \mathbb{N}^*$ is the set of vectors. The set $\mathcal{K}$ consists of partial functions specified by $\alpha \in \mathbb{N}^d$ for some $d > 0$, that maps a vector $v \in \mathbb{N}^d$ to $v + \alpha$. The set $\mathcal{S}$ is the union of all semilinear $S_d$, where $S_d$ consists of all the semilinear sets in $\mathbb{N}^d$. We consider acceptance conditions based on safety, synchronous reachability and asynchronous reachability semantics.

## C.2 Visibly pushdown automata

**Lemma 26.** The class of $\omega$-VPAs is closed under 1-token ghost.

**Proof.** Given an $\omega$-VPA $\mathcal{A} = (Q, \Sigma, \iota, \Delta, \Gamma, \alpha)$, we build an $\omega$-VPA $\mathcal{A}'$ that is a 1-token ghost of $\mathcal{A}$, by morally delaying the transitions by one step, as in the previous *Delay* constructions. However, there is a difficulty in doing that, as $\mathcal{A}'$ must operate on the stack at the same rhythm as $\mathcal{A}$, rather than one step behind. In particular, when $\mathcal{A}'$ reads a *push*-letter, it has to push something onto the stack before it “knows” what to push, and when reading a *pop*- or *noop*-letter after a block of *push*-letters, it “wants” to push something to the stack, as $\mathcal{A}$ did on the previous step, but it cannot.

To manage these local asynchronicities, we maintain a “semantic stack” in $\mathcal{A}'$ that consists of the actual stack and one additional letter that is embedded in the state space and stores, when necessary, the letter that should have been in the top of the stack. At the bottom of the semantic stack there are two symbols, $\perp\perp'$, rather than just $\perp$, so that when the semantic stack has a single element, stored in the state-space, $\mathcal{A}'$ is still able to read a *pop*-letter.

Consider a run $r$ of $\mathcal{A}$ on a word $w$, and let the stack of $\mathcal{A}$ after reading the $i$th letter of $w$ be $\perp x_1 x_2 \cdots x_k$. Then the semantic stack of $\mathcal{A}'$ after reading the $i+1$ letter of $w$ is $\perp\perp' x_1 x_2 \cdots x_k$. If the $i+1$ letter is a *push*-letter, then the actual stack is the same as the semantic one, and the dedicated state-space letter that ends the semantic stack is $\varepsilon$. If the $i+1$ letter is a *pop*- or *noop*-letter, then the actual stack is $\perp\perp' x_1 x_2 \cdots x_{k-1}$, and the dedicated state-space letter is $x_k$. More formally, $\mathcal{A}'$ has:

- States $Q \times (\Sigma \cup \varepsilon) \times (\Gamma \cup \{\varepsilon, \perp'\})$, where $(q, \sigma, X)$ indicates the corresponding state of $\mathcal{A}$, the last input letter (or, initially, $\varepsilon$), and the dedicated state-space for the top of the semantic stack;

- Alphabet $\Sigma$;

- Initial state $(\iota, \varepsilon, \perp')$;

- Stack alphabet $\Gamma \cup \{\perp'\}$

- Transitions as detailed below.

- Acceptance condition $\alpha$, where treating a state $(q, \sigma, X)$ of $\mathcal{A}'$ as the state $q$ of $\mathcal{A}$.

The transitions of $\mathcal{A}'$ are the following, where from each state we consider the cases of $\sigma$, the previous letter, and $\sigma'$, the current letter, being *push-*, *pop-*, or *noop*-letters:

- From the initial state:

- $((\iota, \varepsilon, \perp'), \perp) \xrightarrow{\sigma'|\text{push}\perp'} (\iota, \sigma', \varepsilon)$;

- No pop from an empty stack;

- $((\iota, \varepsilon, \perp'), \perp) \xrightarrow{\sigma'|\text{noop}} (\iota, \sigma', \perp')$.

- After a push, that is, for $\sigma$ a *push*-letter:

- For each transition $(q, X) \xrightarrow{\sigma|\text{push}^Y} q'$ in $\mathcal{A}$ (where $X \in \Gamma$):
$$ ((q, \sigma, \varepsilon), X) \xrightarrow{\sigma'|\text{push}_Y} (q', \sigma', \varepsilon); $$

$$ ((q, \sigma, \varepsilon), X) \xrightarrow{\sigma'|\text{pop}} (q', \sigma', X); $$

$$ ((q, \sigma, \varepsilon), X) \xrightarrow{\sigma'|\text{noop}} (q', \sigma', Y). $$

- For each transition $(q, \perp) \xrightarrow{\sigma'|\text{push}_Y} q'$ in $\mathcal{A}$:

$$ ((q, \sigma, \varepsilon), \perp) \xrightarrow{\sigma'|\text{push}_Y} (q', \sigma', \varepsilon); $$

$$ ((q, \sigma, \varepsilon), \perp) \xrightarrow{\sigma'|\text{pop}} (q', \sigma', \perp); $$

$$ ((q, \sigma, \varepsilon), \perp) \xrightarrow{\sigma'|\text{noop}} (q', \sigma', Y). $$

- After a pop or noop, that is, for $\sigma$ a pop- or noop-letter:

- For each transition $(q, X) \xrightarrow{\sigma'|\text{pop}} q'$ or $(q, X) \xrightarrow{\sigma'|\text{noop}} q'$ in $\mathcal{A}$, $X \in \Gamma$, $Y \in \Gamma \cup \{\perp'\}$:

$$ ((q, \sigma, X), Y) \xrightarrow{\sigma'|\text{push}_X} (q', \sigma', \varepsilon); $$

$$ ((q, \sigma, X), Y) \xrightarrow{\sigma'|\text{pop}} (q', \sigma', Y); $$

$$ ((q, \sigma, X), Y) \xrightarrow{\sigma'|\text{noop}} (q', \sigma', X); $$

- For each transition $(q, \perp) \xrightarrow{\sigma'|\text{noop}} q'$ in $\mathcal{A}$:

$$ ((q, \sigma, \perp'), \perp) \xrightarrow{\sigma'|\text{push}\perp} (q', \sigma', \varepsilon); $$

* No pop from an empty stack;

$$ ((q, \sigma, \perp'), \perp) \xrightarrow{\sigma'|\text{noop}} (q', \sigma', \perp'). $$

Observe that there is bijection between runs of $\mathcal{A}$ and corresponding runs in $\mathcal{A}'$, where the run in $\mathcal{A}'$ is one letter behind and the stack of $\mathcal{A}$ is simulated by the semantic stack of $\mathcal{A}'$. Therefore the two automata recognise the same language.

Furthermore, $G_1(\mathcal{A}', \mathcal{A})$ since Eve can first take the dummy transition from the initial state and then copy Adam's transitions to obtain a run that is accepting whenever Adam's run is accepting. We conclude that $\mathcal{A}'$ is a 1-token ghost of $\mathcal{A}$. ◀

We proceed to show that history-determinism and guidability coincide for the class of $\omega$-VPA. We shall do this using the criterion of Theorem 1.3, that requires us to construct a safety-VPA recognising the plays of a winning strategy of Adam in the letter game on an $\omega$-VPA, if the $\omega$-VPA is not history-deterministic. Towards this, we use the so-called stair-parity VPAs as an intermediary.

## Stair-parity automata

While deterministic parity VPAs are not as expressive as nondeterministic parity VPAs, it is nevertheless possible to determinise nondeterministic parity VPAs into deterministic stair-parity VPAs. A stair-parity VPA has the same components as a parity VPA, just that the acceptance condition is different for run.

Given a run $\rho$ of a stair-parity VPA, consider the sequence $\rho'$ obtained by discarding configurations for which a future configuration of smaller stack-height exists. Observe that this sequence $\rho'$ must be infinite. We write that the run $\rho$ satisfies the stair-parity condition if $\rho'$ satisfies the parity condition. A stair-parity VPA $\mathcal{A}$ accepts a word $w$ iff there is a run of $\mathcal{A}$ on $w$ that satisfies the stair-parity condition.

We use the following two known results on stair-parity VPAs.

► **Lemma 27.** 1. Every nondeterministic parity VPA can be determinised to a language-equivalent deterministic stair-parity VPA [16, Theorem 1].
2. Let $\mathcal{G}$ be a two-player turn-based game on a potentially infinite arena between Adam and Eve whose winning condition for Eve is given by a deterministic stair-parity VPA $\mathcal{A}$. Then, the winning player has a winning strategy which can be implemented by a deterministic visibly pushdown transducer $\mathcal{M}$, that takes as input the transitions $\Delta_{\mathcal{A}}$ of $\mathcal{A}$. Furthermore, the transition on a push (resp. pop and noop) letter of $\mathcal{A}$ in $\Delta_{\mathcal{A}}$ is a push (resp. pop and noop) letter of $\mathcal{M}$ [10, Theorem 9].

**Theorem 16.** History-determinism and guidability coincide for the class of visibly pushdown automata with any $\omega$-regular acceptance condition.

*Proof.* We will use the criterion of Theorem 1.3.

First, note that an $\omega$-VPA $\mathcal{B}$ with any $\omega$-regular acceptance condition $\beta$ can be replaced by an $\omega$-VPA $\mathcal{A}$ with a parity condition, such that $\mathcal{A}$ accepts the same language as $\mathcal{B}$, and furthermore, the nondeterministic choices in $\mathcal{A}$ are exactly those of $\mathcal{B}$: we construct $\mathcal{A}$ by taking the product of $\mathcal{B}$ with a deterministic parity automaton whose alphabet is the transitions of $\mathcal{B}$, and which recognises the acceptance condition $\beta$. Such a deterministic parity automaton always exists; see [3], for instance. As $\mathcal{A}$ and $\mathcal{B}$ are equivalent and have the same nondeterministic choices, the letter games on them are isomorphic, and so are the simulation games and token games. We can thus proceed with the proof, assuming that the considered $\omega$-VPA has a parity acceptance condition.

We will describe the letter-game on an $\omega$-VPA with parity acceptance as a game with a finite arena and an $\omega$-VPA winning condition to show that Adam's winning strategies can be implemented by visibly pushdown transducers. We will then turn this transducer into an $\omega$-VPA recognising the plays that agree with Adam's strategy, to then apply Theorem 1.3.

The arena consists of the product of the state-space of $\mathcal{A}$ with the input alphabet $\Sigma$, so that at every other turn, Adam chooses a letter, and every other turn, Eve chooses a matching transition. It will be technically convenient to only label Eve's turns with the transition chosen by Eve, which includes the letter played by Adam. A play then consists of the sequence of transitions played by Eve, from which we can also read the word read by Adam. Adam's winning condition is the intersection between $\{w \mid \text{ the word component of } w \text{ is in } L(\mathcal{A})\}$ and the set of Eve's runs that are rejecting or invalid. We argue that this is recognised by an $\omega$-VPA that is synchronised with $\Sigma$. To check whether Eve's run is rejecting or invalid, we take a copy $\mathcal{D}$ of $\mathcal{A}$ that reads the transitions chosen by Eve and deterministically simulates Eve's run. It then accepts if either Eve chooses an invalid transition (pop on an empty stack or a transition that is not enabled at the right mode) or if the resulting run fails the parity condition (which we can easily complement). Then, let $\mathcal{A}'$ be the intersection of $\mathcal{A}$ and $\mathcal{D}$. Since $\omega$-VPAs are closed under intersection [1, Theorem 6], the result is still an $\omega$-VPA. By construction, it recognises Adam's winning condition.

The letter game on an $\omega$-VPA can therefore be seen as a finite-arena game with an $\omega$-VPA winning condition for Adam, which can be determinised into an equivalent deterministic stair-parity VPA (Lemma 27).

Then, the game can be seen as a game played on the LTS of a deterministic $\omega$-VPA with a stair parity winning condition. In such games, the winning player has a winning strategy implemented by a deterministic visibly pushdown transducer $\mathcal{M}$, of which the alphabet consists of the transitions $\Delta_{\mathcal{A}}$ of $\mathcal{A}$, and push, pop and noop transitions of $\mathcal{A}$ are push, pop and noop letter for $\mathcal{M}$, respectively [10, Theorem 9]. In other words, projected onto the letters of the transitions, this alphabet is synchronised with $\Sigma$.

We can now interpret this transducer $\mathcal{M}$ as a safety $\omega$-VPA $\mathcal{B}$ that recognises the plays of this winning strategy for Adam in the letter game of $\mathcal{A}$, by interpreting the outputs of the
transducer as part of the input. In other words, the automaton $\mathcal{B}$, with alphabet $\Delta_{\mathcal{A}} \times \Sigma$
has the same state-space as $\mathcal{M}$ and transitions $q \xrightarrow{(t,a)} q'$ if $\mathcal{M}$ has transition $q \xrightarrow{t:a} q'$ that
produces $a$ when reading $t$ at state $q$. To deal with the initial output of $\mathcal{M}$, the initial state
of $\mathcal{B}$ only has outgoing transitions over $(t,a)$ such that $t$ is a transition of $\mathcal{A}$ over the initial
output of $\mathcal{M}$. Then, $\mathcal{B}$, seen as a safety automaton, recognises the set of plays of the letter
game consistent with Adam's strategy given by $\mathcal{M}$.

This automaton $\mathcal{B}$ is then as required for the application of criterion Theorem 1.3, since
$\omega$-VPAs are closed under 1-token ghost from Lemma 26. We thus conclude that guidability
and history-determinism coincide for $\omega$-VPAs.

$\diamond$

### C.3 Timed automata

We define a Delay operation for timed automata and show that Delay($\mathcal{T}$) is a 1-token ghost of the automaton $\mathcal{T}$ (Lemma 31). As the one-token game characterises history-determinism on safety/ reachability timed automata [7], we get by Theorem 1.2 that history-determinism and guidability coincide for them.

The timed alphabet is infinite and therefore unsuitable for a product construction. Hence,
we have to store the region that the previous timed letter produces in the state space.
Furthermore, because time does not wait for our one-letter lag to advance, we duplicate each
clock, using one copy for comparisons in guards while the other is reset at each transition,
just in case the chosen transition actually resets this clock. The copy that is reset at each
transition is upgraded to be the clock used to check guards, while the other one is now reset
at each transition.

We first describe the regions formally. For each clock $x \in C$, let $c_x$ be the largest constant
in any guard involving $x$ in $\mathcal{T}$. Let $R_x$ be the set consisting of the following intervals in $\mathbb{R}$:

- The points $i$, for each $i \in \mathbb{N}$ with $0 \le i \le c_x$.

- The open intervals $(i, i+1)$ for each $i \in \mathbb{N}$ with $0 \le i < c_x$.

- The open interval $(c_x, \infty)$, which consists of all values greater than $c_x$.

We let $\mathcal{R} = \prod_{x \in C} R_x$ to be the set of regions. For each region $r \in \mathcal{R}$, let $g_r \in \mathcal{B}(C)$ be a
guard such that a valuation $\nu$ belongs to the region $r$ if and only if $\nu$ satisfies the guard $g_r$,
i.e. $\nu \models g_r$. Finally, we say a region $r$ satisfies a guard $g$, denoted by $r \models g$ if and only if all
valuations $\nu \in r$ satisfy $g$.

As mentioned earlier, for each clock $x$ in $\mathcal{T}$, we will have two clocks in Delay($\mathcal{T}$) that
we denote by $(x, 0)$ and $(x, 1)$. Thus, the clocks in Delay($\mathcal{T}$) are given by $C \times \{0, 1\}$. The
states in Delay($\mathcal{T}$), apart from an additional initial state, are of the form $(q, \sigma, r, f) \subseteq
Q \times \Sigma \times \mathcal{R} \times \{0, 1\}^C$, where $f: C \rightarrow \{0, 1\}$ is a function. This is used to encode which clock
amongst $(x, 0)$ and $(x, 1)$ is active in Delay($\mathcal{T}$) at any given moment, for each clock $x$ in $\mathcal{T}$.
For a valuation $\mu: C \times \{0, 1\} \rightarrow \mathbb{R}$ at a state $(q, \sigma, r, f)$ in Delay($\mathcal{T}$), the active valuation
$\mu|_f = \mu(x, f(x))$ is the values of the clocks of the form $(x, f(x))$. The clocks that are not
active are called passive, and these are of the form $(x, 1 - f(x))$.

We also extend each guard $g \in \mathcal{B}(C)$ to guards for the active clocks in $C \times \{0, 1\}$: Let
$g[f] \in \mathcal{B}(C \times \{0, 1\})$ be the guard obtained by replacing each instance of a clock $x$ in $g$ by
$(x, f(x))$. Finally, to deal with resets of clocks $X \subseteq C$, we need to switch the active and
passive clocks in Delay($\mathcal{T}$) amongst the clocks that correspond to $X$. This is done by the
function $f^X$ obtained by swapping the active and passive clocks associated to $X$ in $f$. That
is, $f^X(c) = f(c)$ if $c \notin X$, and $f^X(c) = 1 - f(c)$ if $c \in X$.

Let us denote the active and passive clocks with respect to a function $f$ by $A[f]$ and $P[f]$, respectively. If the set of clocks reset in the $i^{th}$ transition in $\mathcal{T}$ is $X$, then the following clocks would be reset in the corresponding $(i+1)^{th}$ transition in Delay($\mathcal{T}$):
1. The passive clocks $\{(c, 1 - f(c)) \mid c \notin X\}$ not in $X$.

2. The active clocks $\{(c, f(c)) \mid x \in X\}$ of $X$.

We now formally define the construction of Delay($\mathcal{T}$) described above:

**Definition 28.** Given a timed automaton $\mathcal{T} = (\Sigma, Q, q_0, C, \delta, F)$, we define the timed automaton Delay($\mathcal{T}$) = $(\Sigma, Q', s, C, \delta', F')$, where the set of states $Q'$ consists of

■ The initial state, $s$

■ Tuples $(q, \sigma, r, f) \in Q \times \Sigma \times \mathcal{R} \times \{0, 1\}^C$

The set $\delta'$ consists of the following transitions:

■ The transitions $(s, \sigma, g_r[f_0], P[f_0], (q_0, \sigma, r, f_0))$ for each $\sigma \in \Sigma, r \in R$, where $f_0$ is the function $f: C \to \{0, 1\}$ such that $f(x) = 0$ for all $x \in C$.

■ The transitions $((q, \sigma, r, f), \sigma', g_{r'}[f^X], P[f^X], (q', \sigma', r', f^X))$ such that $r \models g$, for every transition $(q, \sigma, g, X, q')$ in $\mathcal{T}$.

The set $F'$ consists of states of the form $(q, \sigma, r, f)$ where $q \in F$ is an accepting state in $\mathcal{T}$, as well as the state $s$ if $q_0$ is in $F$.

We show next, via the following two lemmas, that Delay($\mathcal{T}$) is a one-token ghost of $\mathcal{T}$.

**Lemma 29.** Let $\mathcal{T} = (\Sigma, Q, q_0, C, \delta, F)$ be a safety/reachability timed automaton. Then, Eve wins $G_1(\text{Delay}(\mathcal{T}), \mathcal{T})$.

*Proof.* We show that Eve can copy the $i^{th}$ transition of $\mathcal{T}$ in her $(i+1)^{th}$ transition of Delay($\mathcal{T}$), to establish that she wins the one-token game between Delay($\mathcal{T}$) and $\mathcal{T}$.

In the first round, after Adam selects a letter $(\sigma_0, d_0)$, Eve's transition in Delay($\mathcal{T}$) is deterministic: $(s, \sigma_0, g_r[f_0], P[f_0], (q_0, \sigma_0, r_0, f_0))$, where $r_0$ is the unique region of the valuation $\nu: C \to \mathbb{R}$ which maps all clock values to $d_0$. Then, Adam would select some transition $(q_0, \sigma_0, g_0, X, q_1)$ in $\mathcal{T}$, resulting in valuation $\nu_0$.

After $i > 0$ rounds, suppose Eve's token in Delay($\mathcal{T}$) is in state $p_i = (q_{i-1}, \sigma_{i-1}, r_{i-1}, f_{i-1})$, with valuation $\mu_i$, and Adam's token in $\mathcal{T}$ after $i-1$ rounds is at the state $q'$ with valuation $\nu_{i-1}$. We will show that Eve has a strategy to preserve the following invariant:

I1 Adam's state $q'$ after $i$ rounds is $q_{i-1}$, same as the component of $Q$ in $p_i$.

I2 The active valuation $\mu_{i-1}|_{f_{i-1}}$ equals $\nu_{i-1} + d_i$, while all the passive clocks in $\mu_i$ are assigned the value 0.

I3 The region $r_{i-1}$ is the unique region of the active valuation $\mu_{i-1}|_{f_{i-1}}$.

It is clear that the invariant holds after the first round. Suppose it holds after $i > 0$ rounds. We will show that Eve has a strategy to preserve the invariant after $i + 1$ rounds:

Suppose, after $i$ rounds, Eve's configuration is given by $\langle p, \mu \rangle = \langle (q, \sigma, r, f), \mu \rangle$, while Adam's transition in the $i^{th}$ round was $\langle q, \nu \rangle \xrightarrow{\sigma, d} \langle q, \nu + d \rangle \xrightarrow{g, X} \langle q', \nu' \rangle$. By the invariant, we know that $\mu|_f = \nu + d$, and $r$ is the region of $\mu|_f$. In the $(i+1)^{th}$ round of the play:

1. Adam selects a timed letter $(\sigma', d')$.

2. Eve the transition $\langle (q, \sigma, r, f), \mu \rangle \xrightarrow{\sigma', d'} \langle (q, \sigma, r, g), \mu + d' \rangle \xrightarrow{g[f^X], P[f^X]} \langle (q', \sigma', r', f^X), \mu' \rangle$. Note that this transition exists as, by the invariant, $r$ is the region of $\mu|_f = \nu + d$, which satisfies the guard $g$ due to Adam being able to take his transition in the $i^{th}$ round.

3. Adam a transition $\langle q', \nu' \rangle \xrightarrow{\sigma', d'} \langle q', \nu' + d' \rangle \xrightarrow{g', X'} \langle q'', \nu'' \rangle$.

It is clear that the invariant **I1** is satisfied after the $(i+1)^{th}$ round.

As for the invariant **I2**, by the induction hypothesis, we know that $\mu|_f = \nu + d$. We need to show that $\mu'|_{fx} = \nu' + d'$. Note that $\nu' + d' = (\nu+d)[X] + d'$, which is, $\nu(c)+d+d'$ if $c \notin X$, and $d'$ if $c \in X$. Let us take a look at how the valuation $\mu'$ is obtained. First, we add the
duration $d'$ to the valuation $\mu$. This causes all active clocks with respect to $f$ to have the value $\nu(c) + d' + d$, and the passive clocks to have the value $d'$. Then, the function $f^X$ swaps active and passive clocks of $X$ and resets the clocks that are now passive with respect to $f^X$ to obtain $\mu'$. Thus, we have that $\mu'(c, f^X(c)) = \mu(c, f(c)) + d' = \nu(c) + d + d' = [\nu' + d')(c)$ if $c \notin X$, and $\mu'(c, f^X(c)) = d' = [\nu' + d')(x)$ if $c \in X$. This implies that $\mu'|_{fx} = \nu' + d'$. It is clear that the passive clocks with respect to $f^X$ have value 0, as they were just reset. Thus, the condition **I2** is also an invariant.

The invariant **I3** holds as $\mu'|_{fx}$ must have satisfied the guard $g_{r'}[f^X]$ to have taken the transition, which implies that $r'$ is the unique region of $\mu'|_{fx}$.

Having shown that Eve has a strategy which preserves the invariants **I1**, **I2** and **I3**, it is easy to see that such a strategy is winning in $G_1(\text{Delay}(\mathcal{T}), \mathcal{T})$: By the invariant **I1** and the construction of the accepting states of $\text{Delay}(\mathcal{T})$, Eve's run in $\text{Delay}(\mathcal{T})$ is accepting if and only if Adam's run in $\mathcal{T}$ is accepting.

<figure><img src="image_15.png" /></figure>

We proceed with showing that $L(\text{Delay}(\mathcal{T})) = L(\mathcal{T})$.

**Lemma 30.** *Given a timed automaton $\mathcal{T}$, we have $L(\text{Delay}(\mathcal{T})) = L(\mathcal{T})$.*

**Proof.** $L(\mathcal{T}) \subseteq L(\text{Delay}(\mathcal{T}))$ is clear by Lemma 29. As for $L(\text{Delay}(\mathcal{T})) \subseteq L(\mathcal{T})$, consider a sequence $(\langle p_i, \mu_i \rangle)_{i \ge 0}$ of states of $\text{Delay}(\mathcal{T})$ that forms a run on the timed word $(\sigma_i, d_i)_{i \ge 0}$. Let $q_j$ be the state component of $p_{j+1}$, and let $\nu_j : C \to \mathbb{R}$ be obtained by subtracting $d_j$ from $\mu_{j+1}|_{f_{j+1}}$, the active valuation of $\langle p_j, \mu_{j+1} \rangle$, for each $j \ge 0$. Then, it is easy to verify from construction that the sequence $(\langle q_i, \nu_i \rangle)_{i \ge 0}$ is a run in $\mathcal{T}$ on the timed word $(\sigma_i, d_i)_{i \ge 0}$ which is accepting if and only if $(\langle p_i, \mu_i \rangle)_{i \ge 0}$ is an accepting run in $\text{Delay}(\mathcal{T})$.

<figure><img src="image_16.png" /></figure>

From Lemmas 29 and 30, we can conclude:

**Lemma 31.** *The classes of safety and reachability timed automata are closed under 1-token ghost.*

As $G_1$ characterises history-determinism on safety and reachability timed automata [7], by Theorem 1.2 history-determinism and guidability coincide:

**Theorem 17.** *For the class of timed automata with safety or reachability acceptance conditions, the notions of history-determinism and guidability coincide.*

## C.4 Linear automata

**Theorem 19.** *History-determinism and guidability coincide for the class of linear automata.*

**Proof.** History-determinism implies guidability with respect to all classes. For the other direction, consider a linear automaton $\mathcal{A} = (\Sigma, Q, \iota, \Delta, \alpha)$ that is not HD, and let $\mathcal{M} = (\Delta, \Sigma, M, m_0, \Delta_M : M \times \Delta \to M, \gamma : M \to \Sigma)$ be a deterministic finite-state transducer representing a finite-memory winning strategy $s_M$ of Adam in the letter game.

Let $\mathcal{P} = (\Delta, M \times Q, p_0, \Delta_P)$ be the deterministic safety automaton that is obtained by the composition of $\mathcal{M}$ with $\mathcal{A}$. Its states are $Q \times M$, we have the transition $(m, q) \stackrel{\delta}{\to} (m', q')$ if $\gamma(m) = \sigma$, $\delta = q \stackrel{\sigma}{\to} q'$ is a transition in $\mathcal{A}$, and $m \stackrel{\delta}{\to} m'$ is the unique transition in $\mathcal{M}$. Note that $\mathcal{P}$ recognises the set of plays that can happen in the letter game on $\mathcal{A}$ if Adam plays according to $s_M$.

Let $\mathcal{N} = (\Sigma, N, n_0, \Delta')$ be the safety automaton that results from taking the projection of $\mathcal{P}$ to the alphabet $\Sigma$ of $\mathcal{A}$. Note that $\mathcal{N}$ need not be linear. For each $q \in Q$, let $N_q$ be
states in $\mathcal{N}$ of the form $(m, q)$ for some $m \in M$. Note that there is no cycle in $\mathcal{N}$ that visits $N_q$ and $N_{q'}$, for two different states $q, q' \in Q$, as $\mathcal{A}$ is linear. Hence any cycle in $\mathcal{N}$ must be contained entirely in one of the $N_q$'s. Let $\mathcal{N}_q$ be the transition system that consists of all states in $N_q$ and transitions between them.

We proceed by adapting $\mathcal{N}$ to a linear automaton $\mathcal{N}'$ that will still correspond to a winning strategy of Adam in the letter game, and will thus constitute a projection of a deterministic automaton $\mathcal{P}'$ onto the alphabet $\Sigma$, where $\mathcal{P}'$ is over the alphabet of transitions of $\mathcal{A}$ and recognises the plays of a winning strategy of Adam in the letter game. Once achieving that, we can apply the Delay construction on $\mathcal{N}'$ – it will not introduce, in this case, non-self cycles, since the states of $\mathcal{N}'$ (as the states of $\mathcal{N}$), have outgoing transitions only on a single letter. Hence, we satisfy Theorem 1.3, proving the stated claim.

We elaborate below on how we adapt $\mathcal{N}$ into $\mathcal{N}'$.

Observe that since $M$ is a winning strategy for Adam in the letter game, every word that $\mathcal{N}$ reads is accepting in $\mathcal{A}$, and every run of $\mathcal{N}$ eventually remains in a component $\mathcal{N}_q$, where $q$ is a rejecting state of $\mathcal{A}$.

Therefore, if a component $\mathcal{N}_q$ contains a cycle, then $q$ must be a rejecting state of $\mathcal{A}$. Furthermore, note that every state of $\mathcal{N}$, and thus of $\mathcal{N}_q$, has outgoing transitions on a single alphabet, and that $\mathcal{N}_q$ is deterministic, as $\mathcal{A}$ has at most one self-loop at the state $q$ on any letter $\sigma$. Hence, from each state $n$ of $\mathcal{N}_q$, there is at most one infinite word $w_n$ that can be generated within $\mathcal{N}_q$. The following claim will be the key to linearising $\mathcal{N}$ into $\mathcal{N}'$.

**Claim:** there is a number $K \in \mathbb{N}$, such that for every state $n$ that lies within a cycle of $\mathcal{N}_q$ and finite word $u$ over which $\mathcal{N}$ can reach $n$, there is a run $\rho$ in $\mathcal{A}$ on the finite word $u \cdot w[0..K]$ such that $\rho$ ends in an accepting state $f$ of $\mathcal{A}$, and $f$ has self loops on all letters that appear in the word $w[K+1..\infty]$.

**Proof of the claim.** We will show that the result holds for $K = |N_q| \cdot 2^{|Q|}$. Let $v$ be the unique shortest finite word whose unique run in $\mathcal{N}_q$ starts at $n$ and ends at $n$. Note that the length of the word $v$ is at most $|N_q|$. For every number $i \in \mathbb{N}$, let $X_i$ be the set of $\mathcal{A}$'s states that can be reached upon reading the finite word $uv^i$ in $\mathcal{A}$.

By the pigeonhole principle, two of the subsets $X_i$ and $X_j$ for $i < j$ must be equal. Let $d$ be the difference between $j$ and $i$. It follows that the sequence $\{X_l\}_{l \ge 0}$ is eventually periodic after $i$ with period at most $d$, that is $X_{i+k} = X_{i+k+d}$ for all $k \ge 0$. As the word $uv^\omega$ is accepting, there is an accepting state $f$ of $\mathcal{A}$ reached by some $uv^l$ that has a self-loop on all the letters of $v$. This state $f$ must belong to all of $X_l$'s for all $l$ large enough. As the sequence $\{X_k\}_{k \ge i}$ is periodic, it follows that $f \in X_k$ for all $k \ge i$.

As the length of $v^i$ is at most $N_q \times 2^{|Q|}$, the state $f$ is thus reached upon reading the finite word $w[0..K]$, and has self-loops on all letters in the word $w[K+1..\infty]$. $\quad$

We now use the claim for generating the required automaton $\mathcal{N}'$ from $\mathcal{N}$, and thus completing the proof. We shall modify $\mathcal{N}_q$ to have $K + 1$ copies of the states in $\mathcal{N}_q$, that is $N'_q = N_q \times [0..K]$. Then, for each transition $n \xrightarrow{\sigma} n'$ in $\mathcal{N}_q$, we have the transition $(n, i) \xrightarrow{\sigma} (n', i+1)$ for $i \in [0..K)$, as well as the self-loop $(n, K) \xrightarrow{\sigma} (n, K)$ in the last copy.

Then, in $\mathcal{N}'$ we replace every component $\mathcal{N}_q$ with $\mathcal{N}'_q$, while replacing a transition $n' \to n$ from a state $n' \in N' \setminus N'_q$ to a state $n \in N_q$ by the transition $n' \to (n, 0)$, and adding for every transition $n \to n'$ from a state $n \in N_q$ to a state $n' \in N' \setminus N'_q$, the transitions $(n, i) \to n'$, for every $i \in [0..k]$.

The only cycles in $\mathcal{N}'$ are self loops. Furthermore, $\mathcal{N}'$ represents a winning strategy of Adam since: i) Every run of $\mathcal{N}'$ that does not eventually remain in $\mathcal{N}'_q$ has a corresponding
run in $\mathcal{N}$; and ii) Every run of $\mathcal{N}'$ that eventually remains in $\mathcal{N}'_q$ is rejecting for Eve, as $q$ is a rejecting state of $\mathcal{A}$, and it corresponds to a word in the language of $\mathcal{A}$, by the claim. ◀

# D Proofs of Section 6

## D.1 Automata with bounded resources

**Theorem 20.** For every $n \in \mathbb{N}^+$, history-determinism and guidability are distinct notions for the class of Büchi automata with up to $2n$ states.

*Proof.* Consider the Büchi automaton $\mathcal{A}$ depicted in Figure 2, accepting words with a finite number of $a$'s. $\mathcal{A}$ is not history-deterministic, as Adam can win the letter game by choosing $b$ whenever Eve is in an odd state of $\mathcal{A}$, and $a$ whenever she is in an even state.

We now show that $\mathcal{A}$ can simulate every Büchi automaton $\mathcal{A}' \le \mathcal{A}$ with up to $2n$ states. Observe that since $\mathcal{A}'$ cannot accept a word with infinitely many $a$'s, its maximally strongly connected components (MSCCs) cannot have both a transition on $a$ and an accepting state. We call an MSCC accepting if it contains an accepting state, and rejecting otherwise.

We define the following strategy for Eve in the simulation game between $\mathcal{A}$ and $\mathcal{A}'$: If Adam is in an accepting MSCC while she is in an odd state, she moves to the next even state. In other cases, she remains in her state. We claim that Eve's strategy is winning in $Sim(\mathcal{A}, \mathcal{A}')$. Indeed, if Adam's run is accepting, he must eventually end in an accepting MSCC, and by Eve's strategy, so will she, unless she runs out of states. Since $\mathcal{A}'$ can have up to $2n$ MSCCs, Adam can move at most $n$ times from a rejecting MSCC (or from the initial state of $\mathcal{A}'$) to an accepting MSCC. (If he starts in an accepting MSCC, he still needs at least $2n+1$ MSCCs in order to have $n+1$ such moves to an accepting MSCC). Hence, Eve does not run out of states and wins $Sim(\mathcal{A}, \mathcal{A}')$. ◀

## Timed Automata with bounded clocks.

**Theorem 21.** History-determinism and guidability are distinct notions for the class $\mathbb{T}_k$ of timed-automata over finite words with at most $k$ clocks, for each $k \in \mathbb{N}$.

*Proof.* For technical convenience, in this proof we use timestamps rather than delays to write timed words.

Consider the language of finite timed words $L_k \subseteq (\{a\} \times \mathbb{R}_{\ge 0})^+ \cdot (\{b\} \times \mathbb{R}_{\ge 0}) \cdot (\{a\} \times \mathbb{R}_{\ge 0})^+$ over $\Sigma = \{a, b\}$ that contain a subword $w$ of the form $w = (a, t_1)(a, t_2) \cdots (a, t_k)(b, t)(a, t_1+1)(a, t_2+1) \cdots (a, t_k+1)$, such that $t_1 < t_2 < \cdots < t_k < t < t_1+1$.

We construct a timed automaton $\mathcal{T}$ with clocks $C = \{c_1, c_2, \cdots, c_k\}$ that accepts $L_k$ and is guidable in $\mathbb{T}_k$, but not HD. The automaton $\mathcal{T}$ consists of two components: i) a nondeterministic component in which all runs stay in till a $b$ is seen; and ii) a deterministic component in which all runs of the timed automaton go to and stay in after a $b$ is seen.

At a high level, the first component consists of states from where any set of clocks may be non-deterministically reset, upon reading an $a$. Upon reading $b$, the timed automaton moves to the second component. The second component checks deterministically whether any clock value is 1 when an $a$ is read, and it moves to an accepting sink when all clocks have tested positively for 1 at least once.

We now describe the two components in detail. The first consists of states $(S, 1)$, where $S$ is a subset of $C$, and 1 indicates the first component. The set $S$ tracks which clocks are reset at least once in the run so far. The state $(\emptyset, 1)$ is the initial state in $\mathcal{T}$. The transitions on $a$
in the first component are of the form $((S, 1), a, g_{\top}, X, (S', 1))$, where $g_{\top} = \top$ is the guard that accepts all clock valuations, $X$ is the set of clocks that are reset, and $S' = S \cup X$.

The second component consists of a rejecting sink **Reject** and states of the form $(S, 2)$, where $S$ is a subset of $C$ and 2 indicates the second component. The set $S$ tracks the clocks that have not positively tested for 1 at an $a$-transition yet. Naturally, the state $(\emptyset, 1)$ is the only accepting state in $\mathcal{T}$. The transitions on $a$ in the second component are:

A1. $((S, 2), a, g[y], \emptyset, (S', 2))$, where $y \in [k]$ and $g[y] = (c_y = 1) \bigwedge_{z \in [k] \setminus \{y\}} (c_z \neq 1)$. The set $S'$ is then updated to be the set $S \setminus \{c_y\}$.

A2. $((S, 2), a, g[2], \emptyset, \mathbf{Reject})$, where $g[2] = \bigvee_{1 \le x < y \le k} ((c_x = 1) \wedge (c_y = 1))$.

A3. $((S, 2), a, g[S \neq 1], \emptyset, (S, 2))$, where $g[S \neq 1] = \bigwedge_{c \in S} (c \neq 1)$.

A4. (**Reject**, $a, g[\top], \emptyset, \mathbf{Reject}$), where $g[\top] = \top$ is the guard that accepts all clock valuations. A transition in A1 can be taken if a clock value is 1. This is the case if an $a$ is being repeated exactly one time-unit apart. Furthermore, the condition that requires other clocks to be not equal to 1 makes sure that the $a$'s that are repeated occur at distinct times. If there are two clocks that have their values equal to 1, then the automaton moves to **Reject** via a transition in A2. The transitions in A3 are self loops, which are taken when none of the clock values are 1. Finally, there are additional self loops on the sink **Reject** state. Since the guards $g[y]$ for each clock $y \in C$, $g[2]$ and $g[S \neq 1]$ are all disjoint, the second component is deterministic.

Additionally, there are the following $b$-transitions from the first to the second component:

B1. $((C, 1), b, (g[b]), \emptyset, (C, 2))$, where $S = C$ and $g[b] = \bigwedge_{c \in C} ((c > 0) \wedge (c < 1))$ is the guard that checks that all clocks have valuation strictly between 0 and 1.

B2. $((C, 1), b, \neg g[b], \emptyset, \mathbf{Reject})$

B3. $(S, 1), b, g[\top], \emptyset, \mathbf{Reject})$, where $S \neq C$

Only the transition B1 above does not immediately move the run to **Reject**, and can only be taken if the guard $g[b]$ is satisfied. Morally, the guard $g[b]$ ensures that $t_1 + 1 > t$ and $t_k < t$ in the description of words belonging to $L_k$ given at the start of the proof.

We shall argue that:

1. The timed automaton $\mathcal{T}$ accepts $L_k$.

2. $\mathcal{T}$ is not HD

3. $\mathcal{T}$ simulates every $\mathcal{T}' \le \mathcal{T}$, such that $\mathcal{T}'$ has at most $k$ clocks.

$\mathcal{T}$ accepts $L_k$.

Consider a word $w$ in $L_k$, and let $t_1 < t_2 < \cdots < t_k$ be timestamps of $k$ distinct $a$'s that occur in $w$ which are repeated one time-unit later, with the timed letter $(b, t)$ occurring in between, such that $t_1 + 1 > t > t_k$. We describe an accepting run $\rho$ of $\mathcal{T}$ on the word $w$. The run $\rho$ resets the clock $c_i$ at time $t_i$, for each $i \in [k]$. Thus, after the letter $(a, t_k)$, $\rho$ is at the state $(C, 1)$. At the letter $(b, t)$, the transition B1 is taken to the state $(C, 2)$ since the guard $g[b]$ would be satisfied: The valuation of $c_i$ is $t - t_i$ for each $i \in [k]$, and $0 < t - t_i < t - t_1 < 1$. The clock $c_i$ then tests positively for 1 at $(a, t_i + 1)$ for each $i \in [k]$ (in the transition A1), and at the (first) occurrence of the timed letter $(a, t_k + 1)$, $\rho$ moves to $(\emptyset, 2)$, and stays there. As the state $(\emptyset, 2)$ is accepting, the run $\rho$ is accepting.

Conversely, consider a word $w$ that is accepted by $\mathcal{T}$ via the accepting run $\rho$. Then, all the $k$ clocks must have been reset at least once in $\rho$ in the first component: let $(a, t_i)$ be the last timed letter at which the clock $c_i$ was reset. Without loss of generality, we may assume $t_1 \le t_2 \le \cdots \le t_k$. When the timed letter $(b, t)$ is seen, $\rho$ must take the transition B1 to $(C, 2)$ since it would be rejecting otherwise. Since the guard $g[b]$ must be satisfied to take the transition B1, we get that at the timed letter $(b, t)$, the valuation of each clock is strictly
between 0 and 1. Thus, $t - t_1 < 1$ and $t - t_k > 0$. In the second component, each clock $c_i$ in $C$ for $i \in [k]$ tests positively for 1 on a timed letter $(a, t_i+1)$ during a transition in A1, since $\rho$ eventually reaches the state $(\emptyset, 2)$. Furthermore, whenever the valuation of clock $c_i$ is 1 for the first time, we must have that the value of clock $c_j$ for $j \neq 1$ is not 1. This implies that $t_1 < t_2 < \dots < t_k$, and hence the word $w$ is in $L_k$.

T is not HD.

We describe a winning strategy for Adam in the letter game on $\mathcal{T}$. Adam starts with the timed letters $(a, \frac{1}{k+2})$, $(a, \frac{2}{k+2})$, \dots, $(a, \frac{k+1}{k+2})$, $(b, 1)$ in the first $k+2$ rounds, regardless of Eve's transitions. After the $k+2$ rounds, Eve's token can either be at Reject, or at the state $(C, 2)$. In the former case, Adam gives the letters $(a, 1 + \frac{1}{k+2})$, $(a, 1 + \frac{2}{k+2})$, \dots, $(a, 1 + \frac{k}{k+2})$ in the next $k$ rounds, and wins because the resulting word is in the language. Otherwise, Eve resets all clocks at least once in the run on her token so far. Consider the clock valuations after the transition corresponding to the timed letter $(b, 1)$. Then, either

1. There are two clocks that have the same value, say $1 - \frac{i}{k+2}$ due to them being last reset at the letter $(a, \frac{i}{k+2})$. If Adam gives letters $(a, 1 + \frac{1}{k+2})$, $(a, 1 + \frac{2}{k+2})$, \dots, $(a, 1 + \frac{k+1}{k+2})$, the resulting word would be in the language, but Eve's token would eventually move to a rejecting sink state; or

2. All clocks have distinct values. Then there is a timed letter $(a, \frac{j}{k+2})$ such that all clocks that were reset on $(a, \frac{j}{k+2})$ were reset later. In particular, it could also be the case that no clock was reset when the timed letter $(a, \frac{j}{k+2})$ was seen. Let $i \neq j$ be an element in $[k+1]$. Since all the clocks have distinct values, there is a clock $c$ with the value $a, 1 - \frac{i}{k+2}$ when the transition on the timed letter $(b, 1)$ is taken. Suppose Adam gives the timed letters $(a, 1 + \frac{l}{k+2})$ for each $l \in [k+1] \setminus \{i\}$ in the next $k$ rounds of the letter game. Then the resulting word is accepting, while the valuation of clock $c$ is never 1 at any transition, causing the run in Eve's token to be rejecting.

Thus, Adam has a winning strategy in the letter game, and hence $\mathcal{T}$ is not HD.

$\mathcal{T}$ is guidable in $\mathbb{T}_k$.

Let $\mathcal{T}'$ be a timed automaton in $\mathbb{T}_k$ accepting the language $L'$. We assume for convenience that $\mathcal{T}'$ has exactly $k$ clocks denoted by the set $C = \{c_1, c_2, \dots, c_k\}$, same as that for $\mathcal{T}$. We give a strategy $\sigma$ for Eve in the simulation game $Sim(\mathcal{T}, \mathcal{T}')$ between $\mathcal{T}$ and $\mathcal{T}'$ such that if Eve loses $Sim(\mathcal{T}, \mathcal{T}')$ when playing according to $\sigma$, then $L(\mathcal{T}')$ is not a subset of $L(\mathcal{T})$. This would imply that $\mathcal{T}$ is guidable in $\mathbb{T}_k$.

Suppose that after $i$ rounds of the simulation game, Eve's token is at the state $(S, 1)$ with the valuation $\nu$, while Adam's token is at the state $q$ in $\mathcal{T}'$ with the valuation $\nu'$. In the $(i+1)^{th}$ round, if Adam selects the letter $b$ then Eve's transition in $\mathcal{T}$ is determined. Otherwise, suppose Adam selects the letter $(a, t)$ with the duration being $d$, and the transition $(q, a, g, X, q')$. Let $X'$ be the set of clocks that are integers in the valuation $\nu' + d$. Eve's strategy $\sigma$ takes the transition that resets the clocks $X \cup X'$ in $\mathcal{T}$. As the second component of $\mathcal{T}$ is determined, Eve has at most one transition available to her from states of the simulation game, which is the transition that $\sigma$ chooses.

We will show that $\sigma$ is a winning strategy, unless $L(\mathcal{T}') \not\subseteq L(\mathcal{T})$. For each valuation $\nu: C \to \mathbb{R}$, let $\text{Frac}(\nu) = \langle \text{Frac}(\nu(c_1)), \text{Frac}(\nu(c_2)), \dots, \text{Frac}(\nu(c_k)) \rangle$ be the $k$-tuple that consists of the fractional part of the clock valuations of $\nu$. An inductive argument gives us that the strategy $\sigma$ described above preserves the invariant that after each round of the
simulation game, if Adam's token is at $q'$ with valuation $v'$ and Eve's token is at the state $(S, 1)$ with valuation $v$ in $\mathcal{T}$, then $\text{Frac}(v) = \text{Frac}(v')$.

Suppose that there is a play of the simulation game that agrees with $\sigma$, but which Adam wins. Let $w$ be a timed word accepted by $\mathcal{T}'$ via the run $\rho'$ that Adam constructs in the simulation game; then Eve's run $\rho$ in $\mathcal{T}$ constructed according to $\sigma$ is rejecting.

We assume that $w$ is of the form $w = (a, t_1)(a, t_2)\cdots(a, t_l)(b, t) (a, t'_1)(a, t'_2)\cdots(a, t'_m)$, as otherwise $L(\mathcal{T}') \not\subseteq L(\mathcal{T})$. Let $\{\alpha_1, \alpha_2, \dots, \alpha_n\} \in [l]$ be the largest set such that the timed letters $(a, t_{\alpha_i})$ and $(a, t_{\alpha_i} + 1)$ both occur in the word $w$, $t-1 < t_{\alpha_i} < t$ for each $i \in [n]$, and $t_{\alpha_i} \neq t_{\alpha_j}$ for all $1 \le i < j \le n$. We say that $n$ is the number of good pairs in the word $w$. If $n < k$, then $w \notin L_k = L(\mathcal{T})$, and hence $L(\mathcal{T}') \not\subseteq L(\mathcal{T})$. Hence, suppose $n \ge k$. We will show that there is a word $\hat{w}$ that is accepted by $\mathcal{T}'$ but has strictly less than $k$ good pairs. This will imply that $L(\mathcal{T}') \not\subseteq L(\mathcal{T})$.

Let $v'$ and $v$ be the valuations of the clocks in $\rho'$ and $\rho$ respectively, after the transition corresponding to the timed letter $(a, t_l)$ in the word $w$ is taken. Let Eve's token be at the state $(S, 1)$ at this point, and $p$ be the maximum number of clocks in $S$ such that all of them have distinct valuations in $v$ of the form $t_l - t_{\alpha_i}$ for some $i$. Without loss of generality, suppose that the valuations of these $p$ clocks are $t_l - t_{\alpha_1}, t_l - t_{\alpha_2}, \dots, t_l - t_{\alpha_p}$, respectively. Note that the run $\rho$ on the suffix $(b, t)(a, t'_1)(a, t'_2)\cdots(a, t'_m)$ is uniquely determined in $\mathcal{T}$ from the state $(S, 1)$ with valuation $v$ and, by assumption, is rejecting. Hence, $p$ is strictly less than $k$. Let $(a, t'_{\beta}) = (a, t_{\alpha_i} + 1)$ for $\beta \in [m]$ be the first occurrence of the timed letter $(a, t_{\alpha_i} + 1)$ in the word $w$, for an $i \in [n] \setminus [p]$. We claim that

▷ Claim 32. Each of the clocks in the valuation $v''$ after the delay step of the transition on $(a, t'_{\beta})$ in $\rho'$ is non-integral.

**Proof of the claim.** For each clock $c$, let $(a, t_c)$ be the last timed letter at which the clock $c$ was reset in the run $\rho$. It follows that the clock $c$ was not reset in $\rho'$ after $(a, t_c)$ while the run $\rho$ was in the first component, i.e., at least until the timed letter $(b, t)$ is seen. If the clock $c$ was reset in $\rho'$ after $(b, t)$, then $v''(c) \le t_{\alpha_i} + 1 - t < 1$. As $(a, t'_{\beta})$ is the first occurrence of a timed letter of the form $(\sigma, t_c)$, we know that $v''(c) > 0$. Thus $v''(c)$ is not an integer.

Hence, suppose that $(a, t_c)$ was the last timed letter at which the clock $c$ was reset in $\rho'$, before $(a, t'_{\beta})$. Then $v''(c) = t_{\alpha_i} + 1 - t_c$. If $v''(c)$ is an integer, then $t_{\alpha_i} - t_c$ is also an integer. As $\sigma$ resets a clock in $\rho$ in the first component whenever the valuation of the clock is 1, we get that the clock $c$ must have been last reset at a timed letter of the form $(a, t_{\alpha_i})$ in the run $\rho$. Thus, $v(c) = t_l - t_{\alpha_i}$, which is a contradiction to the fact that none of the clock valuations in $v$ equals $t_l - t_{\alpha_i}$.

<figure><img src="image_17.png" /></figure>

Since each clock has a non-integral valuation in the delay step on the first $(a, t_{\alpha_i} + 1)$, we can replace all occurrences of the timed letters of the form $(a, t_{\alpha_i} + 1)$ in $w$ with $(a, t_{\alpha_i} + \varepsilon)$ for some $\varepsilon > 0$ such that

1. $t_{\alpha_i} + \varepsilon \neq t_{\alpha_j}$ for any $j \in [n] \setminus \{i\}$,

2. $w'$ is still accepted in $\mathcal{T}'$ by an accepting run $\rho''$ that visits the same states $\rho'$.

The number of good pairs in $w'$ now is $n-1$. We can iteratively repeat the above procedure on $w'$ to get a word $\hat{w}$ that has exactly $p$ good pairs and is accepted by $\mathcal{T}'$. As $p < k$, however, $\hat{w}$ is not in $L_k$, and hence, $L(\mathcal{T}')$ is not a subset of $L(\mathcal{T})$.

<figure><img src="image_18.png" /></figure>