Register Games

TL;DR

This paper introduces register games, a novel approach that leads to a quasi-polynomial algorithm for parity games, a new complexity measure called register index, and improved automata translations, advancing understanding of parity game complexity.

Contribution

It presents register games as a new method for solving parity games in quasi-polynomial time and introduces the register index as a new complexity measure, along with automata translation improvements.

Findings

Quasi-polynomial algorithm for parity games.

Polynomial algorithm for restricted classes of parity games.

Improved automata translation with quasi-polynomial size increase.

Abstract

The complexity of parity games is a long standing open problem that saw a major breakthrough in 2017 when two quasi-polynomial algorithms were published. This article presents a third, independent approach to solving parity games in quasi-polynomial time, based on the notion of register game, a parameterised variant of a parity game. The analysis of register games leads to a quasi-polynomial algorithm for parity games, a polynomial algorithm for restricted classes of parity games and a novel measure of complexity, the register index, which aims to capture the combined complexity of the priority assignement and the underlying game graph. We further present a translation of alternating parity word automata into alternating weak automata with only a quasi-polynomial increase in size, based on register games; this improves on the previous exponential translation. We also use register games to investigate the parity index hierarchy: while for words the index hierarchy of alternating parity automata collapses to the weak level, and for trees it is strict, for structures between trees and words, it collapses logarithmically, in the sense that any parity tree automaton of size n is equivalent, on these particular classes of structures, to an automaton with a number of priorities logarithmic in n.

Equations

$${\mathsf{subtrees}}(t)\times\Big{(}(Q\times I^{k}\times[1..2k+1])\cup{\mathsf{B}}^{+}(\{\Diamond,\Box\}\times Q\times I^{k}\times[1..2k+1])\Big{)}$$

Full text

This article presents a third, independent approach to solving parity games in quasi-polynomial time, based on the notion of register game, a parameterised variant of a parity game. The analysis of register games leads to a quasi-polynomial algorithm for parity games, a polynomial algorithm for restricted classes of parity games and a novel measure of complexity, the register index, which aims to capture the combined complexity of the priority assignement and the underlying game graph.

We further present a translation of alternating parity word automata into alternating weak automata with only a quasi-polynomial increase in size, based on register games—this improves on the previous exponential translation.

We also use register games to investigate the parity index hierarchy: while for words the index hierarchy of alternating parity automata collapses to the weak level, and for trees it is strict, for structures between trees and words, it collapses logarithmically, in the sense that any parity tree automaton of size $n$ is equivalent, on these particular classes of structures, to an automaton with a number of priorities logarithmic in $n$.

Research supported by the Israel Science Foundation grant 1373/16 and the EPSRC grant EP/P020909/1 (Solving Parity Games in Theory and Practice)

1. Introduction

A play in a parity game consists of a player, whom we shall call Eve, and her opponent, Adam, moving a token along the edges of a graph labelled with integer priorities, forever, thus forming an infinite path. Eve’s objective is to force the highest priority that occurs infinitely often to be even, while Adam tries to stop her.

These games arise at the intersection of logic, games, and automata theory. In particular, they are the acceptance games for alternating parity automata, both on trees and on $\omega$-words. The complexity of solving parity games—that is, of deciding which player has a winning strategy—still is, despite extended efforts, an open problem: it is in UP$\cap$coUP [Jur98] yet it is not known to admit a polynomial algorithm. After over twenty-five years of incremental improvements, Calude, Jain, Khoussainov, Li, and Stephan published the first quasi-polynomial solution [CJK*+*17]. Only a little later in the same year, Jurdziński and Lazić presented an independent progress-measure based algorithm that achieves the same complexity [JL17]. This article presents a third, independent approach to solving parity games in quasi-polynomial time. The automata-theoretic method also solves the more general problem of translating alternating parity word automata into alternating weak automata with quasi-polynomial increase in state space, and offers some new insights into the descriptive complexity of parity games—that is, the complexity of formalisms that can recognise winning regions in parity games—and the parity index problem.

Register Games

Our first contribution is to present register games, a parameterised variant of parity games, that we then use to analyse the complexity of parity games and parity automata, both on infinite words and infinite trees. A register game consists of a normal parity game, augmented with a fixed number of registers that keep partial record of the history of the game. Although the register game is harder for Eve than the parity game on the same arena, if she can win the parity game, then she can also win the register game as long as she has a large enough number of registers. Exactly how many registers she needs depends on the parity game arena. We call this the register-index of the parity game: it is a measure of complexity which takes into account both the priority assignment of the parity game and the structure of the underlying graph.

Two key properties of register games then enable us to derive complexity results for finite parity games as well as for parity automata on both words and restricted classes of trees. First, register games are automata-definable: there is, for every integer $k$, an alternating parity tree automaton that accepts infinite parity games of fixed maximal priority in which Eve wins the $k$ register game; furthermore, for any alternating parity automaton ${\mathcal{A}}$, we can define a family of parameterised automata ${\mathcal{A}}_{k}$ that use the $k$-register game as their acceptance game instead of standard parity games. Second, the register-index is bounded logarithmically in the number of disjoint cycles of a parity game arena.

A quasi-polynomial algorithm for parity games

For finite arenas, where the number of disjoint cycles is bounded by the number of positions, solving parity games reduces to solving the register game with a number of registers logarithmic in the size of the game. This results in a quasi-polynomial parity game algorithm with running time in $2^{O((\log n)^{3})}$, as well as a parameterised polynomial algorithm that solves classes of parity games with bounded register-index.

Word automata transformations

The complexity of solving parity games is intimately related to the complexity of turning alternating parity word automata (APW) into alternating weak word automata (AWW). Indeed, solving parity games amounts to checking the emptiness of an APW on the trivial singleton alphabet. Since the emptiness of AWW on the singleton alphabet can be checked in linear time [KV98], a translation from APW to AWW immediately yields an algorithm for solving parity games of which the time complexity matches the size-increase and time-complexity of the automata translation. Note, however, that the automata-translation question is more general, since automata need not be defined over a one-letter alphabet, and even a binary alphabet can add substantial complexity.

Nevertheless, until 2017, the best known algorithms for the two problems were roughly the same: exponential in the number of priorities. A competitive tool for solving parity games is even based on the translation from parity to weak automata [SMPV16]. In 2017, however, the advent of quasi-polynomial algorithms created a gap between the complexity of solving parity games, and the automata translation.

In this article, we show that the analysis of parity games that are infinite, or at least of unbounded size, allows us to generalise the quasi-polynomial time complexity of solving parity games to the blow-up incurred when turning alternating parity word automata into alternating weak automata111Recently a translation based on universal trees and infinite progress measures has further improved this upper bound to $n^{O(\log\frac{d}{\log n})}$[DJL19]..

The index hierarchy

While the translation of alternating parity automata into weak is always possible for word automata [KV01], this is not the case for tree automata. Indeed, while alternating weak automata suffice to capture all $\omega$-regular word languages, no fixed number of priorities suffices to capture all regular tree languages—this follows from the equivalence between alternating parity automata and the modal $\mu$-calculus [Wil01], and the strictness of the modal $\mu$-calculus alternation hierarchy [Bra98]. We say that the parity index hierarchy is strict on trees, but collapses to the weak level over words.

We study automata on structures that are, in some sense, between words and trees and show, using register games, a logarithmic collapse of the index hierarchy: for every alternating parity automaton ${\mathcal{A}}$ with $n$ states, there is an alternating parity automaton ${\mathcal{A}}^{\prime}$ with only $O(\log n)$ priorities that is equivalent to ${\mathcal{A}}$ over these structures.

Of other quasi-polynomial automata

Separating automata have been proposed as a way to understand the underlying combinatorial structure of the different quasi-polynomial algorithms [BC18]. We conclude with a discussion on what it would take for other quasi-polynomial algorithms for parity games, when seen as separating automata, to be extended into translations of alternating parity automata into weak automata.

This article is based on Lehtinen’s quasi-polynomial algorithm for parity games [Leh18], which introduced the notion of register games, and Boker and Lehtinen’s extension of this technique into a translation of alternating parity word automata into weak automata [BL18]. Here the definition of register games is simplified, generalised to infinite parity games, and presented from an automata-theoretic, rather than modal $\mu$-calculus, perspective.

2. Parity Games

{defi}

[Parity games] A parity game is an infinite-duration two-player zero-sum path-forming game, played between Eve and her opponent Adam on a potentially infinite game graph $G=(V,V_{\text{\sc e}},V_{\text{\sc a}},E,\Omega)$ called the arena. The positions $V$ of the arena are partitioned into those belonging to Eve, $V_{\text{\sc e}}$, and those belonging to Adam, $V_{\text{\sc a}}$. The priority assignment $\Omega:V\rightarrow I$ maps every position in $V$ to a priority in a finite co-domain $I=\{i,i+1..,d\}$ where $i\in\{0,1\}$. The edge-relation $E\subseteq V\times V$ defines the successors of each position. Without loss of generality we assume all positions to have at least one successor. On finite parity games of size $n$, we can assume $d\leq n$.

A play is an infinite sequence of positions $\pi=v_{0}v_{1}...$ such that $(v_{i},v_{i+1})\in E$ for all $i\geq 0$. A play $\pi$ is winning for Eve if the highest priority that occurs infinitely often along $\pi$ is even; otherwise it is winning for Adam.

A (positional) strategy $\sigma$ for a player $P\in\{\text{Adam,Eve}\}$ in a parity game $G$ maps every position $v$ belonging to $P$ in $G$ to one of its successors. A play is said to agree with a strategy $\sigma$ for $P$ if $v_{i+1}=\sigma(v_{i})$ whenever $v_{i}$ belongs to $P$. A strategy $\sigma$ for player $P$ is said to be winning for $P$ from a position $v$ if all plays starting at $v$ that agree with $\sigma$ are winning for $P$. We call the positions from which Eve has a winning strategy Eve’s winning region in $G$, written $\text{\sc W}_{\text{\sc{e}}}(G)$; Adam’s winning region is written $\text{\sc W}_{\text{\sc{a}}}(G)$.

We write $G,v$ for the parity game $G$ with a designated initial position $v$. A winning strategy in $G,v$ is a strategy that is winning from $v$.

Theorem 1** (Positional Determinacy [EJ91, Mos91]).**

In all positions in a parity game, one of the players has a positional winning strategy.

It will sometimes be convenient, for clarity and aesthetics, to assign priorities to edges, with $\Omega:E\rightarrow I$. A parity game with edge priorities can be converted into one with vertex priorities by introducing intermediate, priority-carrying nodes onto edges and giving a low priority to other vertices. Conversely, a vertex-labelled parity game can be converted into an edge-labelled one by assigning the priority of a vertex to its outgoing edges.

3. Register Games

This section describes the key technical development of this article: register games. These are parameterised variations of parity games, also played on a parity game arena. Crucially, the winning condition of a $k$-register game is a parity condition that ranges over priorities $[0..2k+1]$ rather than the priorities of the arena. The larger the parameter $k$, the easier the $k$-register game becomes for Eve who, on arenas in which she has a winning parity game strategy, is guaranteed to also have a winning $k$-register game strategy, for some large enough $k$. Note that the mechanics of register games have been simplified, compared to their first appearance in [Leh18]; see Remark 4.

3.1. Definitions and Observations

Informally, the $k$-register game consists of a normal parity game, augmented with a tuple $(r_{0},...,r_{k})$ of registers that keeps a partial record of the history of the game. During a turn, several things happen: the player whose turn it is in the parity game moves onto a successor position of their choice, which has some priority $p$ and Eve chooses an index $i$, $0\leq i\leq{k}$; then, the registers get updated according to both $i$ and $p$, and an output between [math] and $2k+1$ is produced, also according to $i$ and $p$.

The update wipes out the contents of registers with index lower than $i$: for $j<i$, $r_{j}$ is set to [math]. Meanwhile $r_{i}$ is set to $p$ and $r_{j}$ for $j>i$ to $\max(r_{j},p)$. In other words, each register $r_{j}$ keeps track of the highest priority seen since Eve last chose $i$ with $i\geq j$. The output is $2i$ if $\max(r_{i},p)$ is even, and $2i+1$ otherwise. Then, in the limit, Eve wins a play if the largest output that occurs infinitely often is even.

Since the winning condition of the register game is a parity condition, we can formally define the $k$-register game on a parity game arena $G$ as a parity game on an arena $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$, of which the positions are positions of $G$ paired with vectors in $I^{k+1}$ that represent the contents of the registers. An additional binary variable $t$ indicates whether the next move consists of Eve’s choice of register ($t=0$), or a move in the underlying parity game ($t=1$).

{defi}

[Register game] Let $G$ be a parity game $(V^{G},V^{G}_{\text{\sc e}},V^{G}_{\text{\sc a}},E^{G},\Omega^{G})$ and let $I$ be the co-domain of $\Omega^{G}:V^{G}\rightarrow I$. For a fixed parameter $k\in\mathds{N}$, the arena of the $k$-register game $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ on $G$ in which Eve controls the registers, consists of $\mathcal{R}^{k}_{\text{\sc{e}}}(G)=(V,V_{\text{\sc e}},V_{\text{\sc a}},E,\Omega)$ as follows.

While $G$ carries its priorities on its vertices, for the sake of clarity, $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ carries them on its edges, $\Omega:E\rightarrow[0..2k+1]$.

• •

$V$ is a set of positions $(v,\bar{r},t)\in V^{G}\times I^{k+1}\times\{0,1\}$,

• •

$V_{\text{\sc a}}$ consists of $(v,\bar{r},1)$ such that $v\in V^{G}_{\text{\sc a}}$,

• •

$V_{\text{\sc e}}$ consists of $V\setminus V_{\text{\sc a}}$,

• •

$E$ is the disjoint union of sets of edges $E_{\mathit{move}}$ and $E_{i}$ for all $i\in[0..k]$ where:

$E_{\mathit{move}}$ consists of edges $((v,\bar{r},1),(w,\bar{r},0))$ such that $(v,w)\in E^{G}$.

For each $i\in[0..k]$, $E_{i}$ consists of edges $((v,\bar{r},0),(v,\bar{r}^{\prime},1))$ such that:

• –

$r^{\prime}_{j}=\max(r_{j},\Omega^{G}(v))$ for $j>i$,

• –

$r^{\prime}_{j}=\Omega^{G}(v)$ for $j=i$, and

• –

$r^{\prime}_{j}=0$ for $j<i$.

• •

$\Omega$ assigns priorities from $[0..2k+1]$ to edges as follows:

• –

Edges of $E_{\mathit{move}}$ have priority [math];

• –

$((p,\bar{r},0),(p,\bar{r}^{\prime},1))\in E_{i}$ has priority $2i$ if $\max(r_{i},p)$ is even, and priority $2i+1$ otherwise.

Terminology

Given a play in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$, we call the underlying play its projection onto the first element of each visited position. At a position $(v,\bar{r},t)$, we write that: a priority $p\in I$ occurs if $\Omega^{G}(v)=p$; a register $i\in[0..k]$ contains a priority $p\in I$ if $r_{i}=p$; Eve chooses register $i$ and outputs $j\in[0..2k+1]$ if the play follows an edge in $E_{i}$ of priority $j$.

A strategy for Adam in $G$ induces a strategy for Adam in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$. A strategy for Eve in $G$ paired with a register-choosing strategy in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ induces a strategy for Eve in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$. Observe that as the winning condition depends on the outputs that occur infinitely often, and that registers up to the largest one chosen infinitely often renew their contents infinitely often, if a player has a winning strategy in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ from $(v,\bar{r},t)$, then they have a winning strategy from all $(v,\mathunderscore\,,\mathunderscore)$. We will then simply say that they have a winning strategy from $v$.

The $k$-register game arena $\mathcal{R}^{k}_{\text{\sc{a}}}(G)$ where Adam controls the registers is similar to $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ except that positions $(v,\bar{r},0)$ are in $V_{\text{\sc a}}$, edges in $E_{\mathit{move}}$ have priority [math], and edges $((v,\bar{r},0),(v,\bar{r}^{\prime},1))$ of $E_{i}$ have priority $2i+2$ if $r_{i}$ is even, and $2i+1$ otherwise. The $k$-register game with Eve (resp., Adam) in control of registers on an arena $G$ is the parity game on the arena $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ (resp., $\mathcal{R}^{k}_{\text{\sc{a}}}(G)$). Unless specified, the $k$-register game on $G$ refers to $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$.

For fixed $k$, $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ is a parity game on an arena of size polynomial in the size of $G$ and of priority domain $[0..2k+1]$: it can be solved in polynomial time in the size of $G$ using any solver exponential in the number of priorities (e.g. a progress measure algorithm [Jur00]).

We now establish two important facts about register games: if Adam has a winning strategy from a position $v$ in a parity game $G$, then he has a winning strategy from all positions $(v,\bar{r},t)$ in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ for any $k$. However, if Eve has a winning strategy in $G$ from $v$, then she also has a winning strategy from all $(v,\bar{r},t)$ in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ as long as $k$ is large enough.

Lemma 2**.**

If Adam has a winning strategy in the parity game $G$ starting at $v$, then he also has a winning strategy in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ starting at $v$ for all $k$.

Proof 3.1**.**

Assume Adam has a strategy $\tau$ in $G$ that is winning from $v$. On any play $\pi$ starting at $v$ that agrees with $\tau$, the highest priority $p$ seen infinitely often is odd. Let $i$ be the highest register chosen infinitely often by Eve during $\pi$. Then, eventually—that is, after the last occurrence of anything higher than $p$ and after Eve no longer chooses registers higher than $i$—whenever $p$ is seen, $r_{i}$ is set to $p$ and remains at $p$ until Eve again chooses $i$. Then, since $p$ is odd, this outputs $2i+1$. Since $p$ occurs infinitely often and $i$ is picked infinitely often, $2i+1$ is output infinitely often. It is also the highest value output infinitely often because $i$ is the highest index picked infinitely often. Since $2i+1$ is odd, $\pi$ is winning for Adam. The strategy $\tau$ is therefore winning for Adam in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ from position $v$.

Lemma 3**.**

If Eve has a winning strategy in the parity game $G$ with parity co-domain $I$ at a position $v_{\iota}$, then she also has a winning strategy in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ from $v_{\iota}$ for $k\geq i$ where $2i$ is the largest even priority in $I$.

Proof 3.2**.**

Given a strategy $\sigma$ in the parity game $G$ that is winning for Eve from $v_{\iota}$, let $\sigma^{\prime}$ be the following strategy for Eve in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ where $k\geq i$ and $2i$ is the largest even priority in $I$: at positions $(v,\bar{r},1)$ the strategy $\sigma^{\prime}$ follows $\sigma$, that is if $v$ belongs to Eve, then $\sigma^{\prime}(v,\bar{r},1)=(w,\bar{r},0)$ where $\sigma(v)=w$; at positions $(v,\bar{r},0)$ where $\Omega^{G}(v)=2i$ or $2i+1$ for some $i$, the strategy $\sigma^{\prime}$ chooses register $i$.

We now argue that $\sigma^{\prime}$ is winning for Eve in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ from $v_{\iota}$. Since $\sigma^{\prime}$ follows $\sigma$ in the underlying game, the highest priority $p$ that occurs on any play beginning at $v_{\iota}$ that agrees with $\sigma^{\prime}$ is even, say $p=2i$ for some $i$. The highest register chosen infinitely often is therefore $i$. Since eventually nothing higher than $p$ occurs anymore, $r_{i}$ will eventually remain $p$ in perpetuity, and therefore, eventually, every time Eve chooses $i$, this outputs $2i$; since this is the highest register chosen infinitely often, nothing higher is output infinitely often. Hence Eve wins every play that agrees with $\sigma^{\prime}$ from $v_{\iota}$.

The number of registers that Eve needs to win the register game on a parity game in which she has a winning strategy depends on the complexity of her winning strategy. We define this as the register index of a parity game and consider it as a measure of complexity for parity games, comparable to measures such as entanglement [BGKR12].

{defi}

[Register-index] A parity game $G$ has register-index $k$ at $v\in\text{\sc W}_{\text{\sc{e}}}(G)$ if $k$ is the smallest integer such that Eve wins $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ from $v$, and at $v\in\text{\sc W}_{\text{\sc{a}}}(G)$ if $k$ is the smallest integer such that Adam wins $\mathcal{R}^{k}_{\text{\sc{a}}}(G)$ from $v$. A parity game $G$ has register index $k$ if $k$ is the minimal integer such that it has register index up to $k$ at all positions.

Remark 4**.**

The register game defined here differs slightly from the one defined in [Leh18] and used in [BL18]. Here, for a more elegant presentation, Eve chooses a register at every turn, but has an additional [math]-indexed register she can default to. This avoids having an additional priority that encodes that Eve must reset infinitely often. Furthermore, and perhaps more significantly, the register update mechanism is simplified: instead of values shifting between registers, all registers below the chosen one get reset to [math] while the chosen register updates to the current priority. This new game mechanism simplifies Eve’s strategies and in particular the proof of Theorem 6. Finally, we do not restrict register games to finite arenas, but consider them on potentially infinite ones.

3.2. Examples

In this section we explore which features of parity games affect the register index, and which do not. Since the register-index depends on a player’s winning regions, the examples presented in this section are all on one-player games: all positions belong to Adam. They can be embedded into two-player games of arbitrary complexity; however, for the register-index, only the game induced by the simplest winning strategy matters.

We begin by looking at register games with a small number of registers, starting with [math]-register games. We observe that Eve wins the [math]-register game if she has a strategy $\sigma$ such that plays that agree with $\sigma$ see finitely many odd priorities, such as the game depicted in Figure 3. Indeed, if Eve follows such a strategy, then eventually all outputs in the [math]-register games are [math]. Among well-known parity games with register-index [math] are the example games for which strategy improvement and divide-and-conquer algorithms exhibit worst-case complexity [BDM17, Fri09].

While parity games with register-index [math] must be quite simple, register-index $1$ already captures games with more complexity. Example 3.2 for instance dicusses games with high entanglement, high tree-width, and a large number of priorities that have register-index $1$. Known examples of families of parity games of register-index $1$ are those that exhibit worst-case complexity for Zielonka’s recursive algorithm and the quasi-polynomial progress measure algorithms [Fri11, FJS*+*17]. In these games every odd priority is immediately followed by a larger even priority, so Eve still has an easy $1$-register game strategy consisting of choosing register $1$ whenever an even priority occurs, and register [math] otherwise.

{exa}

Figure 3 shows an edge-labelled arena in which Eve wins the parity game but loses the [math]-register game. In the [math]-register game, Adam’s strategy is to loop at the current position once (this clears the register), then move to the other position and repeat; Eve has no choice but to produce outputs $1$ and [math] infinitely often. Eve can win the $1$-register game by choosing register $1$ after seeing $2$, and register [math] after seeing $1$ or [math].

Figure 3 illustrates a slightly more complicated family of parity games, which has linear entanglement, tree-width and number of priorities, yet constant register-index $1$. It consists of arenas with vertices $v_{0}...v_{n}$ with priority edges $(v_{j},v_{i})$ of priority $2i$ for $j\leq i$ and $2j-1$ for $j>i$. Eve’s strategy is to choose register $1$ whenever she sees an even priority and register [math] otherwise. Since odd priorities only occur after a larger even priority, with this strategy register $1$ permanently contains even priorities. Then every occurrence of an even priority leads to output $2$, while odd priorities lead to output $1$.

We have seen some parity games of low register-index. Building parity games of high register-index is more involved and requires, as we shall see, exponentially many positions.

Lemma 5**.**

For all $n$, there exists a parity game of register-index at least $n$.

Proof 3.3**.**

Let $H_{0}$ be the game arena consisting of a single node, belonging to Adam, with a self-loop of priority [math]. This unique node is also the initial node of $H_{0}$.

Then, for all $n>0$, the arena $H_{n}$ consists of two distinct copies of $H_{n-1}$ with initial positions $v_{0}$ and $v_{1}$ respectively, with an edge $(v_{0},v_{1})$ of priority $2n-1$ and an edge $(v_{1},v_{0})$ of priority $2n$. The position $v_{0}$ is also the initial position of $H_{n}$. See Figure 4.

Eve wins these parity games $H_{n}$ because all cycles are dominated by an even priority. We will show that for $n>0$, Adam has a winning strategy in the $n-1$-register game $\mathcal{R}^{n-1}_{\text{\sc{e}}}(H_{n})$.

We reason inductively, and show that for each $H_{n}$, $n>0$, that i) from the initial position in $\mathcal{R}^{m}_{\text{\sc{e}}}(H_{n})$ for $m\geq n-1$, with a register configuration in which register contents are bounded by $2n-1$, Adam can force the game to output $2n-1$ or a higher odd priority, before returning to the initial position, and ii) Eve loses in $\mathcal{R}^{n-1}_{\text{\sc{e}}}(H_{n})$.

**Base case: **

Adam has a winning strategy in $\mathcal{R}^{0}_{\text{\sc{e}}}(H_{1})$: His strategy is to loop once in the current position to see [math]—this sets the register content to [math]; he then moves to the other position and repeats. This causes both [math] and $1$ to be output infinitely often.

If Adam uses this strategy in $\mathcal{R}^{m}_{\text{\sc{e}}}(H_{1})$ for $m\geq 0$, starting from a register configuration in which register contents are bounded by $1$, although he can’t win, he can force the game to output $1$ or a higher odd priority before returning to the initial position.

**Inductive step: **

Assume i) and ii) for $H_{n}$.

i) Consider the following strategy for Adam in $\mathcal{R}^{m}_{\text{\sc{e}}}(H_{n+1})$ for $m\geq n$. He first moves from $v$, the initial position of $H_{n+1}$ onto the initial position $v^{\prime}$ of the second component of $H_{n+1}$, via the odd priority $2n+1$. Then, he plays in $H_{n}$, which only contains priorities smaller than $2n+1$, with a strategy that is winning in $\mathcal{R}^{n-1}_{\text{\sc{e}}}(H_{n})$. To counter this strategy, Eve has to eventually choose a register of index $n$ or higher, after which Adam returns to the initial position. This is his strategy $\tau_{n}$. Observe that if at the initial position all register contents are bounded by $2n+1$, then Eve will either lose in the second $H_{n}$ component, or choose a register of index $n$ or higher when it contains the odd priority $2n+1$, outputting $2n+1$ or a higher odd priority.

ii) We now show that he also has a winning strategy in $\mathcal{R}^{n}_{\text{\sc{e}}}(H_{n+1})$. He begins by playing $\tau_{n}$ until $2n+1$ is output and the play is back at the initial position. Note that some registers now might contain $2n+2$, so he can not yet repeat $\tau_{n}$. Instead, he plays a strategy that is winning in $\mathcal{R}^{n-1}_{\text{\sc{e}}}(H_{n})$ in the first $H_{n}$ component of $H_{n+1}$. Again, Eve will lose unless she chooses register $n$. After she has chosen the register $n$, all the registers hold values smaller than $2n+1$. Adam can then return to the initial position, and again use $\tau_{n}$ to force output $2n+1$. Thus by alternating between using $\tau_{n}$ to force the maximal odd output, and clearing the registers of higher priorities in order to be able to use $\tau_{n+1}$ again, Adam forces $2n+1$ to be output infinitely often.

Hence $H_{n}$ has register-index at least $n$.

3.3. The register-index as a measure of complexity

Given the elusiveness of a polynomial algorithm for parity games, there is a rich line of research in algorithms that are polynomial for restricted classes of parity games. The size of the priority co-domain is perhaps the simplest way of measuring the complexity of parity games: many parity game algorithms are exponential in the number of priorities, and therefore polynomial on parity games with a fixed number of priorities. There are also many graph-theoretic restrictions, such as bounded tree-width, bounded clique-width and bounded entanglement, that allow for polynomial algorithms. These two classes of restrictions are orthogonal in the sense that the size of the priority assignment is agnostic to the underlying graph and vice-versa.

In contrast, the register-index can be seen as a measure of complexity that takes into account both the complexity of the priority assignment and the structure of the underlying parity game graph. Since for bounded $k$ the register game over a game $G$ is just a parity game of polynomial size in $|G|$, solving parity games of bounded register-index is polynomial. Since we may not know the register-index in advance, by solving both $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ and $\mathcal{R}^{k}_{\text{\sc{a}}}(G)$ up to fixed $k$, we obtain a parameterised polynomial algorithm which solves games of register-index up to $k$, and does not return an answer for other arenas.

From the analysis in the previous sections, this algorithm seems likely to be effective on many—perhaps most—reasonable parity games. In particular, parameter $1$ suffices to solve various parity games that are hard for existing algorithms, including other quasi-polynomial algorithms; furthermore, the register-index is independent of measures such as tree-width and entanglement. In this sense, this algorithm is complementary to existing ones. In any case, as we shall see in the next section, a logarithmic parameter suffices to solve all finite parity games, making this algorithm quasi-polynomial.

4. Register Games and Finite Parity Games

So far we have defined both parity and register games on potentially infinite arenas. In this section we consider the special case of finite arenas, which is of particular interest for verification and synthesis. We show that for finite parity games, the register-index is logarithmically bounded in the number of disjoint cycles, and by extension in the size of the game. We deduce a quasi-polynomial algorithm for solving finite parity games.

4.1. Logarithmic bound on the register index of finite parity games

This section presents the key technical result, from which the various results in the sequel follow: the register-index is logarithmic in the number of disjoint cycles in a finite parity game.

For a finite directed graph $G$, we call dc-size the maximal number of vertex-disjoint cycles in $G$; the dc-size of a parity game is that of the underlying directed graph.

In order to build strategies from subgame strategies, we define the notion of a defensive strategy. Indeed, an arbitrary winning strategy in a subgame may output a finite number of large odd priorities; this is problematic when this strategy is used in a subgame that a play can enter infinitely often. Defensive strategies avoid high odd priorities from the start.

{defi}

[Defensive register-index] For a subgame $G$ with priorities bounded by $p$, in which Eve has a winning strategy, a winning strategy $\sigma$ for Eve in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ is defensive if, from positions $(v,\bar{r},0)$ where $r_{k}\geq p$ and $r_{k}$ is even, a play that agrees with $\sigma$ never outputs $2k+1$. $G$ has defensive register-index $k$ if $k$ is the minimal integer such that Eve has a defensive winning strategy in $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ from all positions.

Theorem 6**.**

The register-index $k$ of a finite parity game of dc-size $z$ is at most $1+\log z$.

Proof 4.1**.**

From the definition of register-index, it suffices to consider the single-player parity games $G$ induced by any winning strategy for Eve in her winning region. Observe that in the register games on $G$, all positions with multiple successors belong to Adam and Eve’s strategy consists of just choosing a register after each move in the underlying game.

We show by induction on the number of positions $n$ in $G$ that the defensive register-index of $G$ is bounded by $1+\log z$; the theorem follows. The base case, $n=1$, is trivial. For the inductive step where $G$ has at least two positions, let $G^{\prime}$ be the game induced by positions of $G$ of priority up to $p-2$, where $p$ is the even supremum of priorities that appear in $G$. Then, let $G_{1},\ldots,G_{j}$ be the maximal strongly connected subgames of $G^{\prime}$. Let $k_{1},\ldots,k_{j}$ be their respective defensive register-indices, and $m$ the maximal among these. If there are no such subgames, then $p$ is the maximal priority in all cycles; then Eve wins defensively in $\mathcal{R}^{1}_{\text{\sc{e}}}(G)$ by choosing register $1$ when $p$ occurs and register [math] otherwise. Since no priority higher than $p$ occurs, $r_{1}$ always contains either $p$ or the initial value of $r_{1}$; this strategy is therefore winning and defensive.

**Case of a unique $i$ for which $k_{i}=m$ and $m>0$: **

We show that the defensive register-index of $G$ is no more than $m$. Since the dc-size of $G_{i}$ is no larger than $z$, and from the inductive hypothesis $m\leq 1+\log z$, this suffices.

Eve’s strategy in the $m$-register game on $G$ is as follows: within a subgame $G_{j}$ she uses the bottom $k_{j}$ registers to simulate her defensive winning strategy in the $k_{j}$-register game on $G_{j}$; elsewhere, she chooses register $m$ whenever $p$ occurs and register [math] otherwise.

Assume that this strategy is played from a register-configuration where the top register contains an even priority greater or equal to the largest priority in $G$. First observe that after choosing register $m$ upon seeing $p$, $r_{m}$ is set to $p$. Furthermore, this strategy encounters $p$ between any two entrances into $G_{i}$, and outside of $G_{i}$ Eve chooses register $0\neq m$ whenever $p$ does not occur; therefore plays that agree with this strategy always enter $G_{i}$ with either $p$ or the larger even initial $r_{m}$-value in register $m$. Thus, since the strategy within $G_{i}$ is defensive, it never outputs $2m+1$ in $G_{i}$. Similarly, when $p$ occurs $\max(r_{m},p)$ is always even: $r_{m}$ is either its initial value, $p$, or a smaller priority from $G_{i}$. Plays that agree with this strategy either eventually stay within a subgame $G_{j}$ where Eve follows a winning strategy, or change subgames infinitely often. In the latter case, $p$ is seen infinitely often, thus producing $2m$ as output infinitely often. This strategy is therefore both defensive and winning for Eve.

Note that if this strategy is played from a register-configuration in which the top register is not an even priority greater or equal to the highest priority in $G$, then a play might output $2k_{m}+1$ once, but the values output infinitely often will still be the same as above, so the strategy is still winning.

**Case of $i,j$ where $i\neq j$ and $k_{i}=k_{j}=m$: **

We show that the defensive register-index of $G$ is at most $m+1$. This suffices, since by the induction hypothesis, each of $G_{i}$ and $G_{j}$ has dc-size at least $2^{m-1}$; then $G$ has dc-size at least $2^{m}$ as $G_{i}$ and $G_{j}$ are disjoint. Eve’s strategy in the $m+1$-register game on $G$ is as follows: in a subgame $G_{i}$, she uses registers up to $k_{i}$ to simulate a winning strategy in the $k_{i}$-register game on $G_{i}$; elsewhere, she chooses register $m+1$ when $p$ is seen, and register [math] otherwise. This strategy is winning as a play either eventually stays within a subgame where Eve is following a winning strategy, or it enters some subgame infinitely often. In this case, it must see $p$ infinitely often; then $2(m+1)$ is the highest value output infinitely often since after the first occurrence of $p$ register $m+1$ permanently contains $p$. Furthermore, if the initial content of register $m+1$ is an even priority larger than any occurring in $G$, then every time Eve chooses register $m+1$, the output is even; the strategy is therefore defensive.

**Case of $m=0$: **

Eve can win the $1$-register game on $G$, using a strategy as above: within a subgame $G_{i}$, she uses her strategy in the [math]-register game, and chooses register $1$ whenever $p$ is seen. This strategy is winning since a play either remains in a subgame and follows a winning strategy, or sees $p$ infinitely often and therefore outputs $2$ infinitely often, but does not output $3$ infinitely often. If initially $r_{1}$ contains an even priority greater or equal to the maximal priority in $G$, this strategy never outputs $3$ and is therefore defensive.

Remark 7**.**

The logarithmic bound was shown in [Leh18] with respect to the size of a finite parity game directly; in [BL18] it was strengthened to a logarithmic bound with respect to the maximal number of disjoint strongly connected components. Here we opt for the number of vertex-disjoint cycles, which is equivalent but more intuitive.

4.2. A quasi-polynomial algorithm for parity games

The quasi-polynomial solvability of parity games then follows: to solve a parity game $G$ of size $n$, one can always solve $\mathcal{R}^{1+\log n}_{\text{\sc{e}}}(G)$ instead.

Corollary 8** (Also [CJK*+*17, JL17]).**

Parity games are solvable in quasi-polynomial time.

Proof 4.2**.**

Let $n$ be the number of positions in a parity game $G$ with $d$ distinct priorities and $m$ edges. The game $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ has $\mathcal{O}(nd^{k+1})$ positions, priorities up to $2k+1$ and $\mathcal{O}((m+nk)d^{k})$ edges. Since $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ is presented with its priorities on its edges, for the complexity analysis we take the size of $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ to be $O(knd^{k})$, to account for an additional vertex for each of the $O(knd^{k})$ edges of significant priority—that is, those in $E_{r}$ for some $r\in[0..k]$.

From Theorem 6, the register-index of a parity game of size $n$ is at most $1+\log n$. Therefore solving parity games $G$ reduces to solving $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ where $k=1+\log n$. The $\mathcal{R}^{k}_{\text{\sc{e}}}(G)$ game can then be solved with an algorithm exponential in the number of priorities of one’s choice, say the small progress measure algorithm [Jur00], to obtain a quasi-polynomial algorithm that runs in time $2^{\mathcal{O}((\log n)^{3})}$.

Without further optimisations, the complexity of this algorithm is not competitive with respect to existing quasi-polynomial algorithms; its space-complexity, due to building $\mathcal{R}^{1+\log n}_{\text{\sc{e}}}(G)$, is also quasi-polynomial. We refer the reader to Parys’s [Par20] and to Daviaud, Jurdziński and Thejaswini’s [DJT20] recent work that shows how to bring both the space and time complexity down to match other quasi-polynomial algorithms. Furthermore, as discussed in Section 3.2, many games have low register-index, including those that exhibit worst-case complexity for other algorithms; on such games this approach is expected to work well. Section 7 discusses further ideas to adapt this approach for practical usage.

One of the principal appeals of this technique for analysing parity games comes undoubtedly from the logic and automata-theoretic perspective. In the sequel, we turn our attention to infinite parity games, or at least parity games of unbounded size, which we use to build automata transformations based on register games.

5. Register Games and Parity Automata

Parity automata are closely related to parity games. On one hand, the language of parity games (represented as infinite trees) with a fixed number of priorities in which Eve has a winning strategy is recognised by an alternating parity tree automaton. On the other hand, the acceptance game for alternating parity automata—both on trees and on words—is an infinite parity game.

In this section we first establish that register games are, like parity games, automata-definable: the winning regions of $k$-register games on arenas with $d$ priorities are recognised by an alternating parity tree automaton of size $O(d^{k})$. We then use register games on infinite and unbounded arenas to define a quasi-polynomial translation from alternating parity word automata into alternating weak word automata.

We finish with a discussion of how these techniques generalise to restricted classes of tree automata, on which we observe a partial collapse of the parity index hierarchy.

We begin this section by fixing notations and definitions for $\omega$-word and tree automata with parity acceptance conditions.

5.1. Automata on Words, Trees and Games

Words, trees, games and graphs

A word over $\Sigma$ is a (possibly infinite) sequence $w=w_{0}\cdot w_{1}\cdots$ of letters in $\Sigma$. We write ${\mathsf{suffixes}}(w)$ for the set of suffixes of $w$ (which includes $w$ itself). We consider a tree to be an infinite directed rooted tree in the graph-theoretic sense; in particular, the children of a node are not ordered. A $\Sigma$-tree $t$ (resp. $\Sigma$-graph) is a tree (resp. graph) together with a mapping of each of its nodes to a letter in $\Sigma$. We write ${\mathsf{subtrees}}(t)$ for the set of $\Sigma$-subtrees of $t$ (which includes $t$ itself). A $\Sigma$-graph with an initial vertex unfolds into an infinite $\Sigma$-tree; a regular $\Sigma$-tree can be finitely represented by a $\Sigma$-graph (i.e., Kripke structures).

We will use a game alphabet $\Gamma^{d}=\{A_{i},E_{i}|i\in[0..d]\}$ to represent parity games with priorities up to $d$. A $\Gamma^{d}$-tree, or graph, is interpreted as the infinite or finite parity game on the arena consisting of the tree, or graph respectively, where positions labelled $E_{i}$ belong to Eve, positions labelled $A_{i}$ belong to Adam, and positions labelled $E_{i}$ or $A_{i}$ have priority $i$.

Automata

Several different definitions of alternating tree automata exist. One variable is the branching type of the input trees: fixed or arbitrary, with or without an order on the successors. In the context of parity games, it is most natural to operate in a setting with arbitrary branching without an order on the successor nodes—that is, an automaton can not distinguish between the left and right branch of a binary tree, unless this is encoded in the labelling. Another difference in automata definitions is how flexible the transition condition is with respect to $\epsilon$-transitions and the combination of path quantifiers ($\Diamond,\Box$) and boolean connectives ($\lor,\land$). Usually, all of these definitions give the same expressiveness ([Wil99, Proposition 1] and [Kir02, Remark 9.4]), except for the case of very restricted automata, in which they do not [BS18]. In our definition of alternating automata, there are no epsilon transitions and path quantifiers are applied directly on states.

An alternating parity tree automaton is a tuple $\langle\Sigma,Q,\iota,\delta,\Omega\rangle$ where $\Sigma$ is a finite alphabet, $Q$ is a finite set of states, $\iota\in Q$ is an initial state, $\delta:Q\times\Sigma\to{\mathsf{B}}^{+}(\{\Diamond,\Box\}\times Q)$ is a transition function, ${\mathsf{B}}^{+}(X)$ is the set of positive boolean formulas over $X$, and $\Omega:Q\rightarrow I$ is a priority assignment that assigns priorities from $I=[0..i]$ or $I=[1..i]$, for some $i\in\mathbb{N}$, to states. Intuitively, given a state and a letter, the transition function returns a positive boolean formula that defines which states the automaton can transition to, and whether it considers the next state at a non-deterministically chosen child ($\Diamond$), or at all of the children ($\Box$). Positive boolean formulas over $\{\Diamond,\Box\}\times Q$ are called transition conditions. The transition graph of ${\mathcal{A}}$ is the graph $(Q,E)$ where $(q,q^{\prime})\in E$ if $q^{\prime}$ appears in $\delta(q,\alpha)$ for some $\alpha\in\Sigma$.

Büchi and co-Büchi automata are special cases of parity automata in which $I=\{1,2\}$ and $I=\{0,1\}$ respectively. An automaton is weak if every strongly connected component in the transition graph consists of states with either only odd priorities or only even priorities. Observe that a weak automaton can be seen as either a Büchi or co-Büchi automaton by using priorities $1$ and $2$, or $1$ and [math], respectively.

The size of an automaton is the maximum of the alphabet size, the number of states, the number of subformulas in the transition function, and the acceptance condition’s index, that is $|I|$. Observe that in alternating automata, the difference between the size of an automaton and the number of states in it can stem from a transition function that has exponentially many subformulas.

How exactly nondeterminism in tree automata is defined also varies in the literature. In general, it only concerns the boolean connectives of the transition condition and not the path quantifiers. We consider an alternating automaton to be nondeterministic (resp. universal) if its transition conditions only use the $\lor$ (resp. $\land$) connective, in addition to the path quantifiers $\Diamond$ and $\Box$.

A word automaton is simply a tree automaton that operates on unary trees, that is, $\omega$-words. For word automata, the path quantifiers $\Diamond$ and $\Box$ are equivalent as there is always exactly one successor.

We will also mention deterministic word automata, in which the transition condition has no boolean connectives, and safety automata, in which the only rejecting state is a rejecting sink.

The class of an automaton is determined by its transition mode (deterministic, nondeterministic, or alternating), its acceptance condition, and whether it runs on words or trees. We often abbreviate automata classes by acronyms in $\{$D, N, A$\}\times\{$W, B, C, P$\}\times\{$W, T$\}$. The first letter stands for the transition mode; the second for the acceptance-condition (weak, Büchi, co-Büchi, and parity); and the third indicates whether the automaton runs on Words or on Trees. For example, AWW stands for an alternating weak automaton on words.

We define the semantics of automata directly in terms of their acceptance games.

{defi}

[Acceptance game] Given a $\Sigma$-tree $t$ and an APT ${\mathcal{A}}=\langle\Sigma,Q,\iota,\delta,\Omega\rangle$, the acceptance game $\mathcal{G}(t,{\mathcal{A}})$ is the following parity game:

• •

The set of positions is ${\mathsf{subtrees}}(t)\times(Q\cup{\mathsf{B}}^{+}(\{\Diamond,\Box\}\times Q))$.

• •

For $a\in\Sigma$, a $\Sigma$-tree $u$ whose root is labeled $a$, transition conditions $b$ and $b^{\prime}$, and state $q\in Q$, there is an edge from:

• –

$(u,q)$ to $(u,\delta(q,a))$

• –

$(u,b\vee b^{\prime})$ to $(u,b)$ and $(u,b^{\prime})$

• –

$(u,b\wedge b^{\prime})$ to $(u,b)$ and $(u,b^{\prime})$

• –

$(u,\Diamond q)$ to $(u^{\prime},q)$, for every child $u^{\prime}$ of $u$.

• –

$(u,\Box q)$ to $(u^{\prime},q)$, for every child $u^{\prime}$ of $u$.

• •

Positions $(\Box q,u)$ and $(b\wedge b^{\prime},u)$ belong to Adam; other positions belong to Eve.

• •

A position $(u,b)$ is of priority $\Omega(b)$ if $b$ is a state $q$, and 0 otherwise.

Observe that the acceptance games of regular, i.e., finitely representable, trees are finite since these trees only have finitely many distinct subtrees. For a Kripke structure $S$, we write $\mathcal{G}(S,{\mathcal{A}})$ for the acceptance game $\mathcal{G}(t,{\mathcal{A}})$ where $t$ is the tree represented by $S$, and observe that it is finite.

We say that an APT ${\mathcal{A}}$ with initial state $\iota$ accepts a tree $t$ if and only if Eve has a winning strategy in the acceptance game $\mathcal{G}(t,{\mathcal{A}})$ from $(t,\iota)$. A tree automaton accepts or rejects a graph according to whether it accepts or rejects its infinite tree unfolding. The set of trees accepted by ${\mathcal{A}}$ is called the language of ${\mathcal{A}}$, denoted by $L({\mathcal{A}})$. Two automata are equivalent if they recognise the same language.

As a word is a special case of a tree, Definition 5.1 and other results that will be shown on acceptance games apply also to word automata. In the word setting, the presentation of the acceptance game can be simplified: $\Diamond q$ and $\Box q$ are equivalent, and may thus be written $q$, and $Q\cup{\mathsf{B}}^{+}(Q)$ is equal to ${\mathsf{B}}^{+}(Q)$.

5.2. Automata for Register Games

We define for every APT ${\mathcal{A}}$ and positive integer $k$, the parameterised version ${\mathcal{A}}_{k}$, which is an APT that will be shown to accept a tree $t$ if and only if Eve wins the $k$-register game on $\mathcal{G}(t,{\mathcal{A}})$ starting from $(t,\iota)$. The idea is to emulate the $k$-register game by keeping track of register configurations with a tuple $\bar{r}\in I^{k+1}$ that is updated according to which priorities are seen and Eve’s register choices, which are represented as nondeterministic choices in ${\mathcal{A}}_{k}$. The outputs are captured by the priorities of the states of ${\mathcal{A}}_{k}$. Here we note a slight subtlety: In the $k$-register game on $\mathcal{G}(t,{\mathcal{A}})$, Eve chooses registers not only at positions $(u,q)$ where $q$ is a state of ${\mathcal{A}}$, but also at positions $(u,b)$ where $b$ is a boolean formula. In ${\mathcal{A}}_{k}$ only states can have priorities (i.e., there can only be one priority per move in $t$) so we aggregate the outputs from these choices between two states by taking the largest output into the priority of the next state—this is the third element $p\in[0..2k+1]$ of the states of ${\mathcal{A}}_{k}$.

{defi}

Given an APT ${\mathcal{A}}=\langle\Sigma,Q,\iota,\delta,\Omega\rangle$ with $\Omega:Q\rightarrow I$ and a positive integer $k$, we define an APT ${\mathcal{A}}_{k}=\langle\Sigma,Q^{\prime},\iota^{\prime},\delta^{\prime},\Omega^{\prime}\rangle$ as follows:

• •

$Q^{\prime}=Q\times I^{k+1}\times[0..2k+1]$

• •

$\iota^{\prime}=(\iota,(0,..,0),0)$

• •

$\Omega^{\prime}$: For every $q\in Q,\bar{r}\in I^{k+1}$, and $p\in[0..2k+1]$, we have $\Omega^{\prime}(q,\bar{r},p)=p$.

• •

$\delta^{\prime}$: For every $q\in Q,\bar{r}\in I^{k+1},p\in[0..2k+1]$, and $a\in\Sigma$, we have $\delta^{\prime}((q,\bar{r},p),a)=\bigvee_{i\in[0..k]}{\mathsf{move}}(\delta(q,a),\texttt{new}_{i}(\bar{r},\Omega(q)),\max(r_{i},\Omega(q)))$ where for transition conditions $b,b^{\prime}$:

• –

$\texttt{new}_{i}(\bar{r},p)=\bar{r}^{\prime}$ where $r_{j}^{\prime}=\max(r_{j},p)$ for $j>i$, $r_{i}=p$ and $r_{j}=0$ for $j<i$;

• –

${\mathsf{move}}(\Diamond q^{\prime},\bar{r},p)=\bigvee_{i\in[0..k]}\Diamond(q^{\prime},\texttt{new}_{i}(\bar{r},0),m)$ where $m=2i$ if $\max(r_{i},p)$ is even; $2i+1$ otherwise;

• –

${\mathsf{move}}(\Box q^{\prime},\bar{r},p)=\bigvee_{i\in[0..k]}\Box(q^{\prime},\texttt{new}_{i}(\bar{r},0),m)$ where $m=2i$ if $\max(r_{i},p)$ is even; $2i+1$ otherwise;

• –

${\mathsf{move}}(b\wedge b^{\prime},\bar{r},p)=\bigvee_{i\in[0..k]}{\mathsf{move}}(b,\texttt{new}_{i}(\bar{r},0),\max(r_{i},p))\wedge{\mathsf{move}}(b^{\prime},\texttt{new}_{i}(\bar{r},0),\max(r_{i},p))$

• –

${\mathsf{move}}(b\vee b^{\prime},\bar{r},p)=\bigvee_{i\in[0..k]}{\mathsf{move}}(b,\texttt{new}_{i}(\bar{r},0),\max(r_{i},p))\vee{\mathsf{move}}(b^{\prime},\texttt{new}_{i}(\bar{r},0),\max(r_{i},p))$

Lemma 9**.**

Given an APT ${\mathcal{A}}$ and a positive integer $k$, the parameterised APT ${\mathcal{A}}_{k}$ accepts a tree $t$ if and only if Eve wins the $k$-register game on $\mathcal{G}(t,{\mathcal{A}})$ from $(t,\iota)$.

Proof 5.1**.**

Recall that ${\mathcal{A}}_{k}$ accepts a tree $t$ if and only if Eve wins the parity game $\mathcal{G}(t,{\mathcal{A}}_{k})$ from the initial position, which consists of ${\mathcal{A}}_{k}$’s initial state and $t$’s root. Thus, we should show that Eve wins $\mathcal{G}(t,{\mathcal{A}}_{k})$ from the initial position if and only if she wins the $k$-register game on $\mathcal{G}(t,{\mathcal{A}})$ from the initial position. The intuition for the equivalence between the games is that $\mathcal{G}(t,{\mathcal{A}}_{k})$ encodes the $k$-register game on $\mathcal{G}(t,{\mathcal{A}})$ by having the register-configuration in the state space, Eve’s register choices as new disjunctions, and the highest output between two states as priorities.

Positions of $\mathcal{G}(t,{\mathcal{A}}_{k})$ are in

[TABLE]

while positions of the $k$-register game on $\mathcal{G}(t,{\mathcal{A}})$ are in {\mathsf{subtrees}}(t)\times\Big{(}Q\cup{\mathsf{B}}^{+}(\{\Diamond,\Box\}\times Q)\Big{)}\times I^{k}.

$\mathcal{G}(t,{\mathcal{A}}_{k})$* begins at $(t,(\iota,(0,..,0),0))$ while the $k$-register game on $\mathcal{G}(t,{\mathcal{A}})$ begins at $(t,\iota,(0,..,0))$.*

Now, observe that in the $k$-register game on $\mathcal{G}(t,{\mathcal{A}})$ at position $(u,q,\bar{r})$, for a state $q\in Q$ and a $\Sigma$-tree $u$ whose root is labeled $a$, Eve has to choose a register $i\in[0..k]$ before the parity game proceeds to $(u,\delta(q,a))$ with register configuration $\bar{r}^{\prime}$, which is exactly $\texttt{new}_{i}(\bar{r},\Omega(q))$. Similarly in $\mathcal{G}(t,{\mathcal{A}}_{k})$, from $(u,q,\bar{x},p)$ Eve chooses $i\in[0..k]$ before proceeding with the transition condition $\delta(q,a)$ with register configuration $\texttt{new}_{i}(\bar{r},\Omega(q))$. In the register game on $\mathcal{G}(t,{\mathcal{A}})$, this produces an output $2i$ if $\max(r_{i},\Omega(q))$ is even; $2i+1$ otherwise. In $\mathcal{G}(t,{\mathcal{A}}_{k})$ the value $\max(r_{i},\Omega(q))$ is kept in the state of the successor position.

When the games proceed, in both the register game on $\mathcal{G}(t,{\mathcal{A}})$ and in the parity game on $\mathcal{G}(t,A_{k})$, the decision falls to Adam if $\delta(q,a)$ is a conjunction or prefixed by $\Box$ and to Eve otherwise. Then, between each subformula of the transition condition, Eve again has a choice of register in both games. In the register game on $\mathcal{G}(t,{\mathcal{A}})$, this produces an output $2i$ if $\max(r_{i},0)$ (that is $r_{i}$) is even; $2i+1$ otherwise. The largest output between two positions in $Q\times{\mathsf{subtrees}}(t)$ of $\mathcal{G}(t,{\mathcal{A}})$ is recorded via the third element of the automata-component of $\mathcal{G}(t,{\mathcal{A}}_{k})$, which determines the priority of the successor state.

Then a winning strategy for Eve in one game translates into a winning strategy for Eve in the other game by mapping Eve’s choices of registers in the register game on $\mathcal{G}(t,{\mathcal{A}})$ to her choices in $\mathcal{G}(t,{\mathcal{A}}_{k})$ at disjunctions over $[0..k]$ in the transition condition of ${\mathcal{A}}$ and vice versa, and mapping her choices in the underlying parity game $\mathcal{G}(t,{\mathcal{A}})$ to the remaining choices in $\mathcal{G}(t,{\mathcal{A}}_{k})$, and vice-versa.

Remark 10**.**

The $\mu$ calculus-minded reader can get an idea of the equivalent modal $\mu$-calculus formula from [Leh18] where the definability of register games was presented from a logic-perspective, rather than in terms of automata. The following proof in particular uses the automata-equivalent of the canonical modal $\mu$-calculus formulas that witness the strictness of the alternation hierarchy [Bra98].

Corollary 11**.**

There is a parity automaton of size $d^{O(\log n)}$ that, over $\Gamma^{d}$-graphs of size $n$ and priorities up to $d$, recognises the parity games in which Eve has a winning strategy.

Proof 5.2**.**

Let ${\mathcal{P}}^{d}$ be the alternating parity automaton on $\Gamma^{d}$-trees that, over parity game graphs with priorities up to $d$, recognises parity games with priorities up to $d$ in which Eve has a winning strategy. This is simply an automaton with states $0,1\dots d$ where the priority of a state $i$ is $i$ and the transition condition is $\delta(q,E_{i})=\Diamond i$ and $\delta(q,A_{i})=\Box i$. The acceptance game $\mathcal{G}(t,{\mathcal{P}}^{d})$ for any $\Gamma^{d}$-tree $t$ is identical to $t$ once we collapse positions with a unique successor. It follows that $t$ and $\mathcal{G}(t,{\mathcal{P}}^{d})$ have identical register-index. Then, from Theorem 6 and Lemma 9, over $\Gamma^{d}$-graphs of size up to $n$ and priorities up to $d$, ${\mathcal{P}}^{d}_{\log n+1}$ recognises the same language as ${\mathcal{P}}^{d}$, which recognises the games in which Eve has a winning strategy.

This corollary casts the quasi-polynomial complexity of parity games in terms of their descriptive complexity—that is, in terms of the complexity of the logical formalisms able to capture their winning regions. Note that here we only consider the complexity of recognising parity games with a bounded number of priorities (here bounded by the size of the game) in which Eve has a winning strategy; for parity games with an unbounded number of priorities, this task is beyond the expressivity of parity automata and the $\mu$ calculus [DG08].

Remark 12**.**

Observe that the register-index is bisimulation-invariant. Indeed, we can build an automaton that accepts exactly parity games with priorities up to $d$ that have register-index at most $k$. Since alternating parity automata, like formulas of the modal $\mu$-calculus, are bisimulation invariant, so is the register-index.

5.3. Register Games and Word Automata

We turn our attention to automata over $\omega$-words. On words, deterministic parity automata, non-deterministic Büchi automata and alternating weak automata all are expressive enough to capture all $\omega$-regular languages [Lin88]. However, our understanding of the trade-offs in conciseness between different acceptance conditions is incomplete. For instance, an ABW can be turned into an AWW with quadratic size blow-up [KV01], but the current corresponding lower bound is at $\Omega(n\log n)$. Until recently the best translation from APW into AWW was exponential [KV98]; here we improve it to quasi-polynomial; the lower bound remains at $\Omega(n\log n)$.

In this section we use register games to define a quasi-polynomial translation from APW to AWW. It is based on observing that the acceptance parity games of an automaton on an ultimately periodic word have a register-index that depends solely on the automaton and is at most logarithmic in its size. Given that equivalence over ultimately periodic words implies equivalence over all words [McN66], this will suffice to turn APW into equivalent APW with a logarithmic number of priorities and of quasi-polynomial size; from there, Kupferman and Vardi’s classic translation into weak automata [KV98] produces a weak automaton which is also of only quasi-polynomial size.

We begin by showing that the dc-size of $\mathcal{G}(t,{\mathcal{A}})$, for a tree $t$ that represents the computations of a finite Kripke structure with minimum feedback vertex set size at most $d$ in each of its (maximal) strongly connected components (SCC), is linear in $d|{\mathcal{A}}|$. Then, since the register index is logarithmic in the dc-size, it is not the number of states in a Kripke structure that influences the register index of the acceptance game, but rather its minimum feedback vertex set. For Kripke structures representing ultimately periodic words, this measure is $1$. While a weaker lemma based directly on the single cycle of a Kripke structure representing an ultimately periodic word $w$ would suffice, the next section will use this stronger lemma.

{defi}

Given a directed graph $G$, a feedback vertex set is a set of vertices that contains at least one vertex of every cycle in $G$. Let the fvs-size of $G$ be the size of a minimum feedback vertex set of $G$.

Lemma 13**.**

Given a Kripke structure $S$ with fvs-size up to $d$ in each of its SCCs and an APT ${\mathcal{A}}$ with $n$ states, the parity game $\mathcal{G}(S,{\mathcal{A}})$ has register index at most $1+\log dn$.

Proof 5.3**.**

We first note that the register index of a parity game is the maximal one among its SCCs. We show that the dc-size of any SCC in $\mathcal{G}(S,{\mathcal{A}})$ is at most $dn$. Then, by Lemma 6, its register index is at most $1+\log dn$.

First note that every SCC of $\mathcal{G}(S,{\mathcal{A}})$ results from a single SCC of $S$ and a single SCC of ${\mathcal{A}}$. It is therefore enough to assume that both $S$ and ${\mathcal{A}}$ consist of a single SCC.

We consider the graph $H$ that is derived from $\mathcal{G}(S,{\mathcal{A}})$ by ignoring the intermediate positions $(v,b)$, where $b$ is a boolean formula between positions of the form $(v,q)$, for a state $q$. That is, let $H$ be the graph consisting of just the vertices $(v,q)$ of $\mathcal{G}(S,{\mathcal{A}})$, where $q$ is a state. The edges of $H$ connect positions $(v,q)$ and $(v^{\prime},q^{\prime})$ if $(v^{\prime},q^{\prime})$ is reachable from $(v,q)$ in $\mathcal{G}(S,{\mathcal{A}})$ directly, that is, with a path which does not visit yet another position $(v^{\prime\prime},q^{\prime\prime})$ where $q^{\prime\prime}$ is a state.

Observe that $\mathcal{G}(S,A)$ has dc-size no larger than that of the graph $H$: a set of disjoint cycles in $\mathcal{G}(S,A)$ induces a set of disjoint cycles in $H$.

Let $F$ be a feedback vertex set of $S$, having up to $d$ vertices. Since every cycle $C$ in $H$ corresponds to some cycle of $S$, it must contain a vertex $(v,q)$, such that $q$ is a state of ${\mathcal{A}}$ and $v\in F$. Hence, for every $v\in F$, there are up to $n$ vertex-disjoint cycles in $H$ that have a vertex of the form $(v,q)$. Therefore, there are up to $|F|n\leq dn$ disjoint cycles in $H$, and therefore in $\mathcal{G}(S,{\mathcal{A}})$.

In particular, given an ultimately periodic word and an APW ${\mathcal{A}}$ with $n$ states, since the fvs-size of a lasso Kripke structure representing a word is $1$, the parity game $\mathcal{G}(w,{\mathcal{A}})$ has register-index at most $1+\log n$. Then ${\mathcal{A}}$ is equivalent to its $1+\log n$ parameterised version. On can then obtain an equivalent weak automaton of quasi-polynomial size by applying Kupferman and Vardi’s transformation [KV98] to ${\mathcal{A}}_{1+\log n}$ instead of ${\mathcal{A}}$.

Lemma 14**.**

Every APW ${\mathcal{A}}$ is equivalent to its parameterised version ${\mathcal{A}}_{k}$, for $k=1+\log|{\mathcal{A}}|$.

Proof 5.4**.**

As two $\omega$-regular languages are equivalent if they agree on all ultimately periodic words [McN66], it suffices to argue that ${\mathcal{A}}$ and ${\mathcal{A}}_{k}$ agree on ultimately periodic words.

From Lemma 9, ${\mathcal{A}}_{k}$ accepts an ultimately periodic word $w$ if and only if if Eve wins the $k$-register game on $\mathcal{G}(S_{w},{\mathcal{A}})$ where $S_{w}$ is a finite Kripke structure representing $w$. Since $S_{w}$ is a lasso, and it has fvs-size $1$. From Lemma 13, Eve wins the $k$-register game on $\mathcal{G}(S_{w},{\mathcal{A}})$ exactly when Eve wins the parity game on $\mathcal{G}(S_{w},{\mathcal{A}})$, that is, when ${\mathcal{A}}$ accepts $w$.

Theorem 15**.**

There is a translation of alternating parity word automata into alternating weak word automata incurring at most a quasi-polynomial size increase. In particular, every APW ${\mathcal{A}}$ of size (resp. number of states) $n$ is equivalent to an AWW of size (resp. number of states) $2^{O((\log n)^{3})}$.

Proof 5.5**.**

From Lemma 14, an APW ${\mathcal{A}}$ with $n$ states and $d$ priorities is equivalent to its parameterised APW ${\mathcal{A}}_{k}$ for $k=1+\log n$, having $n\cdot d^{k}\cdot(2k+1)$ states and $2k+1$ priorities. The automaton ${\mathcal{A}}_{k}$ can then be turned into a weak automaton using standard techniques [KV98] with a $O(m^{d^{\prime}})$ blow-up, where $m$ is the number of states and $d^{\prime}$ the number of priorities, which yields an AWW with $2^{O((\log n)^{3})}$ many states, since $m$ is here $O(kn^{k+1})$, which is in $2^{O((\log n)^{2})}$ and $d^{\prime}=2k+1$ is $O(\log n)$.

If the size of ${\mathcal{A}}$ is dominated by the size $e$ of its transition function, namely when $e>n$, observe that the parameter $k$, the number of states in ${\mathcal{A}}_{k}$, and the number of priorities in ${\mathcal{A}}_{k}$ do not depend on $e$, while the size of ${\mathcal{A}}_{k}$’s transition function is $O(k^{2}ed^{k})$ is in $2^{O((\log e)^{2})}$. Since the translation in [KV98] does not blow up the transition-function size more than it blows up the number of states, we end up with an AWW of size in $2^{O((\log e)^{3})}$.

5.4. Register Games and Tree automata

While the parity hierarchy collapses for alternating word automata, that is, AWWs suffice to recognise all word languages recognised by APWs, it is strict for alternating tree automata [Lin88, Bra98, BL18]: For every positive integer $n$, there is an APT ${\mathcal{A}}$ with $O(n)$ states and $O(n)$ priorities, such that there is no APT equivalent to ${\mathcal{A}}$ with less than $n$ priorities. Hence the weak condition does not suffice to capture all tree-languages captures by parity automata, so a general translation from APT to AWT does not exist. However, even for APT that are equivalent to an AWT, such a translation is at least exponential [BL18], in contradistinction to the quasipolynomial translation of APW to AWW.

A natural question is then to consider the index hierarchy of alternating automata on entities that are “between” words and trees—that is, infinite trees generated by Kripke structures that are more complex than lassos, but more restrictive than trees. Examples of such classes are “flat Kripke structures” [DDS15], in which every SCC has a single cycle, “weak Kripke structures” [KF11], in which SCCs cannot have two vertex-disjoint cycles and Kripke structures with finite Cantor–Bendixson rank [BW18].

We show that the parity hierarchy collapses logarithmically for alternating automata on the classes of Kripke structures with bounded fvs-size in each of its SCCs. That is, for every APT ${\mathcal{A}}$ with $n$ states, there is an APT $A^{\prime}$ with $O(\log n)$ priorities, such that ${\mathcal{A}}$ and ${\mathcal{A}}^{\prime}$ are equivalent with respect to trees generated by Kripke structures of which the SCCs have bounded fvs-size. Kripke structures of which the SCCs have bounded fvs-size subsume Kripke structures that are flat, weak or of finite Cantor–Bendixson rank.

Theorem 16**.**

Every APT ${\mathcal{A}}$ with $n$ states is equivalent to an APT ${\mathcal{A}}^{\prime}$ with $1+\log dn$ priorities with respect to Kripke structures with fvs-size of up to $d$ in each of their SCCs.

Proof 5.6**.**

Let $k=1+\log dn$. Setting ${\mathcal{A}}^{\prime}$ to be the $k$-parameterised version ${\mathcal{A}}_{k}$ of ${\mathcal{A}}$ fits the bill. Indeed: ${\mathcal{A}}$ accepts a Kripke structure $S$ iff Eve wins $\mathcal{G}(S,{\mathcal{A}})$. By Lemma 13, for every Kripke structure $S$ with fvs-size of up to $d$ in each of its SCCs, the register index of $\mathcal{G}(S,{\mathcal{A}})$ is at most $k$. Hence, Eve wins $\mathcal{G}(S,{\mathcal{A}})$ iff she wins the $k$-register game on $\mathcal{G}(S,{\mathcal{A}})$, and by Lemma 9, this happens iff $A_{k}$ accepts $S$.

Corollary 17**.**

Every APT with $n$ states is equivalent to an APT with $O(\log n)$ priorities with respect to Kripke structures whose SCCs are bounded in one of the following measures: minimum feedback vertex set, minimum feedback edge set, maximal number of vertex-disjoint cycles, and maximal number of edge-disjoint cycles.

Proof 5.7**.**

Observe that the minimum feedback vertex set is always smaller than or equal to the minimum feedback edge set, and likewise the maximal number of vertex-disjoint cycles is smaller than or equal to the maximal number of edge-disjoint cycles. Hence, it is enough to consider the vertex-version of these measures.

The result with respect to the minimum feedback vertex set follows directly from Theorem 16. The result with respect to the maximal number of disjoint cycles follows from Theorem 16 and the Erdős-Pósa Theorem [EP65], which states that the maximal number of disjoint cycles is logarithmically bounded in the minimum feedback vertex set.

It may be the case that this collapse of the index-hierarchy on these structures goes further, all the way to weak, as on words, combining techniques from Kupferman and Vardi [KV98] and Daviaud, Jurdziński and Lehtinen [DJL19] for example, or to priorities $\{1,2,3\}$ as for trees with a countable number of infinite branches [ISB16]. We leave this as an open problem, as well as the related question of what is the simplest class of trees on which the hierarchy is strict.

6. Other Quasi-polynomial Automata

In this section we discuss the relationship between our approach and the notion of separating automata for solving parity games. Czerwiński et al. [CDF*+*19] have argued that the existing quasi-polynomial parity game algorithms can all be seen as separating automata. We consider the converse question: we make explicit how separating automata imply a tree automaton that recognises the winning regions of parity games of bounded size and propose a criterion delineating when a separating automaton also implies a translation of alternating parity automata into weak automata.

6.1. From separating automata to tree automata

Bojańczyk and Czerwiński consider automata that separate plays that agree with winning strategies for each player in parity games of size up to $n$ with up to $d$ priorities [BC18]. Finding a deterministic safety automaton of size $f(n,d)$ that separates these word languages suffices to solve parity games in time polynomial in $f(n,d)$. If the separation condition is strengthened to a separation between the language of plays that agree with a positional winning strategy for Eve in some parity game of size $n$ with $d$ priorities and the language of plays that do not satisfy the parity condition, then a quasi-polynomial lower bound applies [CDF*+*19].

From a deterministic separating word automaton, one can build a tree automaton that recognises parity game arenas of size up to $n$ in which Eve has a winning strategy:

Proposition 18**.**

Let ${\mathcal{A}}$ be a DPW over the alphabet $[0..d]$ that:

• •

Accepts words that agree with a positional winning strategy for Eve in some parity game of size up to $n$ with up to $d$ priorities, and

• •

Rejects words that agree with a positional winning strategy for Adam in some parity game of size up to $n$ with up to $d$ priorities.

Then, there is an APT ${\mathcal{A}}^{\prime}$ of the same size and acceptance condition as ${\mathcal{A}}$ that recognises parity game arenas of size up to $n$ with up to $p$ priorities in which Eve has a winning strategy.

Proof 6.1**.**

While ${\mathcal{A}}$ operates on an alphabet of priorities, ${\mathcal{A}}^{\prime}$ operates on the richer game alphabet $\Gamma^{d}$ that also encodes the ownership of nodes. ${\mathcal{A}}^{\prime}$ has the same state-space, initial state and priority assignment as ${\mathcal{A}}$. The only difference is the transition function of ${\mathcal{A}}^{\prime}$ which is simply $\delta^{\prime}(q,E_{i})=\Diamond\delta(q,i)$ and $\delta^{\prime}(q,A_{i})=\Box\delta(q,i)$. In other words, ${\mathcal{A}}^{\prime}$ gives the decision of which branch to choose to the player who owns the current position, but otherwise operates exactly as ${\mathcal{A}}$. Whichever player has a winning strategy in a parity game $G$ of size $n$ with up to $d$ priorities encoded as a $\Gamma$-graph can copy their positional winning strategy in the acceptance game $\mathcal{G}(G,{\mathcal{A}}^{\prime})$; since ${\mathcal{A}}$ separates the plays resulting from such strategies, ${\mathcal{A}}^{\prime}$ will accepts if and only if Eve has a winning strategy in $G$.

Remark 19**.**

Proposition 18 extends to good for games word automata [HP06, BL19]. These are (not necessarily deterministic) automata ${\mathcal{A}}$ over an alphabet $\Sigma$ for which, given any $\Sigma$-labelled arena $G$—that is, a graph of which the positions are partitioned between two players and labelled with $\Sigma$—Eve wins the synchronised product of $G$ and ${\mathcal{A}}$ if and only if she has a strategy $\sigma$ in $G$ such that every path that agrees with $\sigma$ forms a word accepted by ${\mathcal{A}}$. Good-for-games parity automata, like deterministic automata, can be turned into APTs in the way outlined in Proposition 18.

However, the register automaton that recognises whether Eve wins the $k$-register game over an arena of size $n$ with up to $d$ priorities, although separating plays that agree with a winning positional strategy for Eve from plays that are winning for Adam, is neither deterministic nor good for games. First, observe that for $k>0$, it is indeed trivially a separating automaton for words with up to $d$ priorities since all words have register index $1$. It is not good for games (of register index larger than $k$). It is only “good for small games” in the sense that when interpreted on games, it is only guaranteed to operates correctly on parity games of size up to $2^{k-1}$.

6.2. From tree automata to automata transformations

As we have seen in Section 5.3, register games are also suited for handling the parity games of unbounded size that stem from word automata, thus allowing for a quasi-polynomial translation from alternating parity word automata to alternating weak automata. The same generalisation is not immediate for Calude et al.’s and Jurdziński and Lazić’s algorithms; in particular, a safety-automata based approach, as the one proposed by Czerwiński et al. [CDF*+*19] is unlikely to suffice since safety automata are not as expressive as parity automata. This raises the following question: when does an automaton that recognises the winning regions of parity games of bounded size imply a translation from alternating parity word automata into weak automata?

We propose infinite directed acyclic graphs (dags) of bounded width as a key ingredient. The acceptance games for word automata take this shape, which make them an interesting stepping stone between words and trees. We shall see that tree automata with an acceptance condition X (e.g. Büchi or weak) that recognise infinite parity game dags of bounded width (rather than of bounded size) in which Eve has a winning strategy can be used to turn alternating parity word automata into word automata with the same acceptance condition X. The translation is easy: it consists of the synchronised composition of the two automata.

The technical details of the synchronised composition are cumbersome, but the idea is straight-forward: the synchronised composition of ${\mathcal{B}}$ and ${\mathcal{A}}$ is an automaton that accepts a tree $t$ if and only if ${\mathcal{A}}$ accepts the acceptance game of ${\mathcal{B}}$ and $t$ when viewed as a $\Gamma$-tree.

{defi}

[Synchronised Composition] Let ${\mathcal{A}}=(\Sigma^{A},Q^{A},\iota^{A},\delta^{A},\Omega^{A})$ be an APT with priorities up to $d$. Let ${\mathcal{B}}=(\Gamma^{d},Q^{B},\iota^{B},\delta^{B},\Omega^{B})$ be an APT over the game alphabet $\Gamma^{d}$.

The synchronised product ${\mathcal{B}}\times{\mathcal{A}}$ is defined as:

• •

State space $Q^{A}\times Q^{B}$;

• •

Alphabet $\Sigma^{A}$;

• •

$\Omega(q_{A},q_{B})=\Omega^{B}(q_{B})$.

• •

Transition relation: $\delta((q_{A},q_{B}),\alpha)=f^{\alpha}(q_{A},\delta^{B}(q_{B},\mathrm{label}(q_{A}))$ where:

• –

$f^{\alpha}(q_{A},\Diamond p)=\Diamond f^{\alpha}(\delta^{A}(q_{A},\alpha),p)$

• –

$f^{\alpha}(q_{A},\Box p)=\Box f^{\alpha}(\delta^{A}(q_{A},\alpha),p)$

• –

$f^{\alpha}(b\wedge b^{\prime},\Diamond p)=f^{\alpha}(b,p)\vee f^{\alpha}(b^{\prime},p)$

• –

$f^{\alpha}(b\vee b^{\prime},\Diamond p)=f^{\alpha}(b,p)\vee f^{\alpha}(b^{\prime},p)$

• –

$f^{\alpha}(\Diamond q,\Diamond p)=\Diamond(q,p)$

• –

$f^{\alpha}(\Box q,\Diamond p)=\Diamond(q,p)$

• –

$f^{\alpha}(b\wedge b^{\prime},\Box p)=f^{\alpha}(b,p)\wedge f^{\alpha}(b^{\prime},p)$

• –

$f^{\alpha}(b\vee b^{\prime},\Box p)=f^{\alpha}(b,p)\wedge f^{\alpha}(b^{\prime},p)$

• –

$f^{\alpha}(\Diamond q,\Box p)=\Box(q,p)$

• –

$f^{\alpha}(\Box q,\Box p)=\Box(q,p)$

• –

$f^{\alpha}(b,c\vee c^{\prime})=f^{\alpha}(b,c)\vee f^{\alpha}(b,c^{\prime})$

• –

$f^{\alpha}(b,c\wedge c^{\prime})=f^{\alpha}(b,c)\wedge f^{\alpha}(b,c^{\prime})$

• –

$f^{\alpha}(b,p)=f^{\alpha}(b,\delta^{B}(p,\mathrm{label}(b)))$ where $p\in Q^{B}$ and

• –

$\mathrm{label}(b\wedge b^{\prime})=\mathrm{label}(\Box q)=A_{0}$

• –

$\mathrm{label}(b\vee b^{\prime})=\mathrm{label}(\Diamond q)=E_{0}$

• –

$\mathrm{label}(q)=E_{\Omega^{{\mathcal{A}}}(q)}$

Observe that ${\mathcal{A}}\times{\mathcal{B}}$ has the acceptance condition of ${\mathcal{B}}$. Indeed, the product construction preserves the priorities and the non-reachability of states of ${\mathcal{B}}$: if $q_{B}^{\prime}$ is not reachable from $q_{B}$, then $(q_{A},q_{B}^{\prime})$ is not reachable from any $(q_{A}^{\prime},q_{B}^{\prime})$. Then, if ${\mathcal{B}}$ is weak, then ${\mathcal{A}}\times{\mathcal{B}}$ is weak.

Lemma 20**.**

${\mathcal{A}}\times{\mathcal{B}}$* accepts a $\Sigma^{A}$-tree $t$ if and only if ${\mathcal{B}}$ accepts the acceptance game $\mathcal{G}(t,{\mathcal{A}})$ seen as a $\Gamma^{d}$-tree for $d$ the maximal priority in ${\mathcal{A}}$.*

Proof 6.2**.**

We show that $\mathcal{G}(\mathcal{G}(t,{\mathcal{A}}),{\mathcal{B}})$ and $\mathcal{G}(t,{\mathcal{A}}\times{\mathcal{B}})$ have the same winner. The transition relation is designed so that $\mathcal{G}(\mathcal{G}(t,A),B)$ is identical to $\mathcal{G}(t,{\mathcal{A}}\times{\mathcal{B}})$. More precisely, we identify positions $((t,q_{A}),q_{B})$ and $((t,b_{A}),b_{B})$ in $\mathcal{G}(\mathcal{G}(t,A),B)$ with $(t,(q_{A},q_{b}))$ and $(t,f^{\alpha}(b_{A},b_{B}))$ in $\mathcal{G}(t,{\mathcal{A}}\times{\mathcal{B}})$, respectively, where $\alpha$ is the label of $t$. We now show that this mapping preserves successors, position ownership and priorities; the preservation of winner follows.

**Preservation of successors: **

We observe:

• **•: **

$((t,q_{A}),q_{B})$* has successor $((t,q_{A}),\delta^{B}(q_{B},E_{\Omega(q_{A})}))$*

• **•: **

$(t,(q_{A},q_{B}))$* has successor $(t,f^{\alpha}(q_{A},\delta^{B}(q_{B},E_{\Omega(q_{A})})))$*

• **•: **

$((t,b\wedge b^{\prime}),\Diamond p))$* has successors $((t,b),p)$ and $((t,b^{\prime}),p)$*

• **•: **

$(t,f^{\alpha}(b\wedge b^{\prime},\Diamond p))$* has successors $(t,f^{\alpha}(b,p))$ and $((t,f^{\alpha}(b^{\prime},p)))$*

• **•: **

$((t,\Diamond q),\Diamond p))$* has successors $((t^{\prime},q),p)$ for all children $t^{\prime}$ of $t$.*

• **•: **

$(t,f(\Diamond q,\Diamond p))$* has successors $(t^{\prime},(q,p))$ for all children $t^{\prime}$ of $t$.*

• **•: **

Similarly for other combinations of modalities and boolean operators.

**Preservation of ownership: **

Eve owns position $((t,b_{a}),b_{B})$ in $\mathcal{G}(\mathcal{G}(t,A),B)$ whenever $b_{A}$ is a disjunction or a $\Diamond$-formula, and positions with a unique successor. Similarly, Eve owns $(t,f^{\alpha}(b_{a},b_{B}))$ in $\mathcal{G}(t,{\mathcal{A}}\times{\mathcal{B}})$ whenever $b_{B}$ is a disjunction or $\Diamond$-formula, and positions with a unique successor.

**Preservation of priorities: **

The priority of both $((t,q_{A}),q_{B})$ and $(t,(q_{A},q_{B}))$ is $\Omega^{B}(p)$ and the priority of other positions is [math].

Then, since $\mathcal{G}(\mathcal{G}(t,{\mathcal{A}}),{\mathcal{B}})$ and $\mathcal{G}(t,{\mathcal{A}}\times{\mathcal{B}})$ must have the same winner, ${\mathcal{A}}\times{\mathcal{B}}$ accepts a tree $t$ if and only if ${\mathcal{B}}$ accepts $\mathcal{G}({\mathcal{A}},{\mathcal{B}})$.

Then, if for a class $C$ of trees, for all $t\in C$, ${\mathcal{B}}$ accepts $G(t,{\mathcal{A}})$ if and only if ${\mathcal{A}}$ accepts $t$, then ${\mathcal{A}}\times{\mathcal{B}}$ is equivalent to ${\mathcal{A}}$ over $C$. In other words, to turn an automaton ${\mathcal{A}}$ into a simpler automaton that is equivalent on a particular class of structures, it suffices to find an automaton ${\mathcal{B}}$ with a simple acceptance condition that accepts only the winning acceptance games of ${\mathcal{A}}$ over that class of structures. In particular, to turn a parity word automaton into a Büchi or weak automaton, it suffices to study Büchi or weak automata that recognise the winner in acceptance games over words.

{defi}

An infinite dag is of bounded width $m$ if its vertices can be partitioned into sets $L_{0},L_{1},L_{2},\dots$ no larger than $n$ such that every edge goes from some layer $L_{i}$ to the next layer $L_{i+1}$.

Corollary 21**.**

An alternating parity automaton ${\mathcal{B}}_{(m,d)}$ that over regular parity game dags of bounded width $m$ with up to $d$ priorities recognises those in which Eve has a winning strategy induces a translation from alternating parity word automata to alternating automata with the number of priorities of ${\mathcal{B}}_{(m,d)}$ and with state and size blow-up linear in $|B_{(m,d)}|$.

Proof 6.3**.**

The acceptance game of a ultimately periodic word $w$ and an APW ${\mathcal{A}}$ with up to $d$ priorities is a regular parity game dag of width $|{\mathcal{A}}|$ with up to $d$ priorities; hence ${\mathcal{B}}_{(|{\mathcal{A}}|,d)}$ recognises the winning regions of the acceptance games of ${\mathcal{A}}$ over ultimately periodic words. The automaton ${\mathcal{A}}\times{\mathcal{B}}_{(|{\mathcal{A}}|,d)}$ is, from Lemma 20, equivalent to ${\mathcal{A}}$ on ultimately periodic words and therefore over all words. The synchronised product ${\mathcal{A}}\times{\mathcal{B}}_{(|{\mathcal{A}}|,d)}$ is therefore equivalent to ${\mathcal{A}}$ and has the acceptance condition of ${\mathcal{B}}_{(|{\mathcal{A}}|,d)}$. The blow-up is linear in ${\mathcal{B}}_{(|{\mathcal{A}}|,d)}$

The register index approach is an instantiation of this method: indeed, the key measure we use to bound the register index, dc-size, is also bounded in finite structures that can be unfolded into a dag of bounded width. From these observations, it seems that reasoning about parity games of arbitrary size but with a bounded number of disjoint cycles, or infinite parity games of bounded width, rather than only finite parity games, is a key distinction between algorithms for solving finite parity games and translations from one type of automata into another. Indeed, this strategy was recently used by Daviaud, Jurdziński and Lehtinen to provide an alternative quasi-polynomial APW to AWW translation, based on universal trees, with size increase in $n^{O(\log\frac{d}{\log n})}$ [DJL19].

7. Conclusions

We have presented an automata-theoretic take on solving parity games in quasi-polynomial time based on the notion of register games. This perspective enabled us to go beyond finite parity games, and provide a quasi-polynomial translation of alternating parity automata into weak automata.

Solving parity games in practice

This article has focused on the automata-theoretic aspect of register games, rather than how they can be used to solve parity games in practice. We would therefore forgive the reader for questioning the practicality of this quasi-polynomial algorithm, which, among its less flattering features, has quasi-polynomial space complexity.

Recent work by Parys [Par20], as well as by Daviaud, Jurdziński and Thejaswini [DJT20], show that the register-game approach can be optimised to have both time and space-complexity in line with the state-of-the-art. Furthermore, there is much unexplored potential both for improving the practical viability of this algorithm, and for using the insights of this analysis to improve existing solvers.

Indeed, we have seen that building parity games with truly complex winning strategies—in the sense of requiring more than a small constant number of register in the register game—is subtle business: see the construction in Lemma 5. We therefore conjecture that the parameterised version of this algorithm, which solves parity games of register index $1$, is a plausible candidate for solving most reasonable parity games in polynomial time, and perhaps also in practice. Increasing the parameter to $2$ or $3$ could ensure it only fails for purpose-built counter-examples. The insight that even complex-looking parity games tend to have low register index could be useful in itself, for optimising existing solvers, which are not necessarily quasi-polynomial, but still more effective in practice.

Finally, the register index approach seems suited for a symbolic implementation: given a symbolically represented parity game, the $k$-register game can also be represented symbolically without significant blow-up. This would bypass the space-complexity of the algorithm for parity games that benefit from concise symbolic representations.

Further open problems

We have, throughout this article, pointed to some problems that remain open. The most obvious, of course, is the complexity of solving parity games. Another fundamental question is the conciseness gap between alternating parity and alternating weak word automata: a quasi-polynomial upper bound and a quasi-linear lower bound. One of the difficulties for closing this gap is the lack of techniques on one hand to prove lower bounds for alternating automata, and on the other to use alternations effectively to describe the winning regions of parity games.

We also mentioned the parity index problem, which is connected to the automata-theoretic concerns that this article touches upon. The question of where exactly, when moving from words to trees, the index hierarchy becomes strict, is particularly interesting.