Abstract 1 Introduction 2 Preliminaries 3 Game characterisation of the parity index 4 Characterisation via attractor decompositions 5 Characterisation via universal trees 6 Conclusion References

Using Games and Universal Trees to Characterise the Nondeterministic Index of Tree Languages

Olivier Idir ORCID Université Paris Cité, CNRS, IRIF, France Karoliina Lehtinen ORCID CNRS, Université Aix-Marseille, LIS, Marseille, France
Abstract

The parity index problem of tree automata asks, given a regular tree language L and a set of priorities J, is L J-feasible, that is, recognised by a nondeterministic parity automaton with priorities J? This is a long-standing open problem, of which only a few sub-cases and variations are known to be decidable. In a significant but technically difficult step, Colcombet and Löding reduced the problem to the uniform universality of distance-parity automata. In this article, we revisit the index problem using tools from the parity game literature.

We add some counters to Lehtinen’s register game, originally used to solve parity games in quasipolynomial time, and use this novel game to characterise J-feasibility. This provides a alternative proof to Colcombet and Löding’s reduction.

We then provide a second characterisation, based on the notion of attractor decompositions and the complexity of their structure, as measured by a parameterised version of their Strahler number, which we call n-Strahler number. Finally, we rephrase this result using the notion of universal tree extended to automata: a guidable automaton recognises a [1,2j]-feasible language if and only if it admits a universal tree with n-Strahler number j, for some n. In particular, a language recognised by a guidable automaton A is Büchi-feasible if and only if there is a uniform bound n such that all trees in the language admit an accepting run with an attractor decomposition of width bounded by n. Equivalently, the language is Büchi-feasible if and only if A admits a finite universal tree.

While we do not solve the decidability of the index problem, our work makes the state-of-the-art more accessible and brings to light the deep relationships between the J-feasibility of a language and attractor decompositions, universal trees and Lehtinen’s register game.

Keywords and phrases:
Tree automata, parity automata, Mostowski index, Strahler number, attractor decomposition, universal trees
Category:
Track B: Automata, Logic, Semantics, and Theory of Programming
Copyright and License:
[Uncaptioned image] © Olivier Idir and Karoliina Lehtinen; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Automata over infinite objects
Related Version:
Full Version: https://arxiv.org/abs/2504.16819 [16]
Acknowledgements:
We are grateful to Marcin Jurdziński for insightful discussions about attractor decompositions at Dagtuhl Seminar 24231, and of course to Dagstuhl for enabling such discussions.
Editors:
Keren Censor-Hillel, Fabrizio Grandoni, Joël Ouaknine, and Gabriele Puppis

1 Introduction

Finite-state automata running on infinite structures are fundamental to the theory of verification and synthesis, where they model non-terminating systems. The complexity of an automaton is measured not only by the size of its state-space, but also by the complexity of the acceptance condition. For instance, while the membership and non-emptiness questions for Büchi and coBüchi tree automata are in PTime, for parity automata they are fixed-parameter tractable in the number of priorities in the parity condition, called its index [2]. In the modal μ-calculus, the logic corresponding to parity tree automata, the alternation depth of a formula – that is, the nesting depth of alternating least and greatest fixpoints – coincides with the index of the corresponding parity automaton.

While for nondeterministic automata over infinite words, the Büchi acceptance condition suffices to recognise all ω-regular languages [23], the classes of languages recognised by parity tree automata of each index form an infinite hierarchy, often called the parity, Mostowski, or Rabin-Mostowski index hierarchy. In other words, no fixed parity index suffices to recognise all ω-regular tree languages, and this is the case for both nondeterministic [19], and alternating [1, 17] tree automata. A language is said to be J-feasible if it is recognised by a nondeterministic parity automaton of index J. The nondeterministic index of an ω-regular tree language is the minimal index J for which it is J-feasible. The decidability of the index of a language is one of the major open problems in automata theory.

In the case of infinite words, the deterministic index of a language is decidable in PTime [21]. In the case of infinite trees, however, not much is known. For languages given by deterministic parity automata, deciding their nondeterministic index is decidable [22]. Similarly, deciding if a language is recognisable with a safety/reachibility condition can be done in EXPTIME [26]. CoBüchi-feasibility, as well as the weak feasability of Büchi languages, are also decidable [3, 25]. For the restricted class of game automata (which can be seen as the closure of deterministic automata under complementation and composition), the nondeterministic and alternating index problems are decidable [10]. The most recent advance on the topic is that the guidable index of a language is decidable [20], where guidable automata, introduced by Colcombet and Löding [4], restrict the nondeterminism of the automaton without the loss of expressivity imposed by determinism.

The general nondeterministic index problem remains wide open. However, in a significant step, in 2008, Colcombet and Löding [4] reduced the index problem of a tree language to the uniform universality of distance-parity automata. This remarkable result is, however, quite technical. In this article we present a similar result, (from which Colcombet and Löding’s result can be obtained as a corollary, see Remark 12), using variations of known tools from the parity game literature – namely, attractor decompositions, universal trees, the register index of parity games, and Strahler numbers. These are all notions that (re-)emerged in the aftermath of Calude et al.’s first quasipolynomial algorithm for solving parity games [2] to provide clarity on the newly established complexity bound. Here, we demonstrate that these tools also provide insight into the index hierarchy by using them to reformulate Colcombet and Löding’s result and give an alternative proof.

Let us discuss each of these notions in more detail, in order to state our results.

The register index of parity games and 𝑱-feasibility.

Parity games are infinite two-player games in which two players, Adam and Eve, take turns moving a token along the edges of a graph labelled with integer priorities. Eve’s goal is to ensure that the infinite path taken by the token satisfies the parity condition, that is, that the highest priority occuring infinitely often along the path is even. The acceptance of a tree by a parity tree automaton is determined by whether Eve wins a parity game based on the input tree and the automaton.

In this article, we use the data-structure introduced in Lehtinen’s quasipolynomial parity game algorithm [15]. Lehtinen reduces solving a parity game to solving a new game, in which Eve must map the original game’s priorities into a smaller priority range using a purpose-built data-structure, while guaranteeing that the sequence of outputs in this smaller range still satisfies the parity condition. Lehtinen shows that for a parity game of size n, Eve wins if and only if she also wins this new game with output range O(logn), which can be solved in quasipolynomial time.

Here we extend this game to the acceptance parity games of nondeterministic parity tree automata, that is, parity games with unbounded or even infinite arenas. We furthermore add some counters (inspired by the Colcombet and Löding construction), which give Eve some additional (but bounded) leeway in her mapping. We obtain a game that we call the parity transduction game 𝒯Jn(G), played over a parity game G, parameterised by the output priority range J , and the bound n on the counters.

Our first contribution is showing that the J-feasibility of the language of a guidable automaton A (and we can always make the input guidable) is characterised by the existence of an integer n such that the parity transduction game with parameters J and n coincides with the acceptance game of A, written 𝒢(A,t) for an input tree t. In other words, a language is J-feasible whenever there is a uniform parameter n, such that whenever Eve wins the acceptance game 𝒢(A,t), she also wins the transduction game over it, with output range J and parameter n.

Theorem 1.

Given a guidable automaton A, J an index, the following are equivalent:

  • (A) is J-feasible.

  • There exists n such that for all Σ-tree t, t(A) if and only if Eve wins 𝒯Jn(𝒢(A,t)).

This corresponds to our version of the Colcombet-Löding reduction. We then proceed to reinterpret this characterisation in terms of attractor decompositions and universal trees.

Attractor decompositions.

describe the structure of Eve’s winning strategies in a parity game, or, equivalently, of accepting runs of a parity tree automaton. While this notion appears at least implicitly in many seminal works, e.g. Zielonka’s algorithm for parity games [27], Kupferman and Vardi’s automata transformations [14] and Klarlund’s [13] proof of Rabin’s complementation theorem, it has more recently been explicitly studied for mean payoff parity games [6] and parity games [7, 12].

While similar in spirit and structure to progress-measures [11], which count the number of odd priorities that might occur before a higher priority, attractor decompositions are more suitable for parity games on infinite arenas, where Eve might see an unbounded number of odd priorities in a row, as long as she is advancing in the attractor of some larger even priority. While progress measures, bounded by the size of a finite game, can be seen as a way to reduce parity games to safety games, here we use attractor decompositions with bounded structure to reduce the priority range of the parity condition. Like progress-measures, attractor decompositions have a tree-like structure, where the play only moves to the right if a suitably high even priorities occurs. The structure of these trees turns out to be closely tied to the index of a language.

𝒏-Strahler number

The Strahler number of a tree t consists in the largest h such that t admits a complete binary tree of height h as a minor. Daviaud, Jurdziński and Thejaswini [8] proved an equivalence between the output range that Eve needs in Lehtinen’s game, called the game’s register index, and the Strahler-number of the attractor decompositions of Eve’s strategies. Inspired by this, we define, for n, the n-Strahler number of a tree t, that consists in the largest h such that t admits a complete (n+1)-ary tree of height h as a minor (by subtree deletion and single-child contraction; we do not allow edge contraction in the presence of siblings). The Strahler number corresponds to our 1-Strahler number. Our second characterisation of the index of a languages is based on the n-Strahler number of attractor decompositions.

Theorem 2.

Given a guidable nondeterministic parity tree automaton A, the following are equivalent:

  • L(A) is [1,2j]-feasible.

  • There is an n such that for all tL(A) there exists a run of A on t with an attractor decomposition of n-Strahler number at most j.

In particular, Büchi feasibility coincides with the existence of a uniform bound on the width (i.e branching degree) of attractor decompositions needed by Eve. Finally, we restate this result in terms of universal trees, extended to automata, as follows.

Universal trees.

Given a set 𝒯 of ordered trees of bounded depth, a tree U is said to be universal for 𝒯 if all t𝒯 can be obtained from U by removing subtrees. We then say that t is isomorphically embedded in U. This elegant notion emerged in the analysis of quasi-polynomial time parity game algorithms, as a unifying combinatorial structure that can be extracted from the different algorithms [5].

We say that an ordered tree U is universal for an automaton A if for all regular trees in the language of A, there exists an accepting run with an attractor decomposition (seen as a tree) that can be isomorphically embedded in U.

Then, the [1,2j]-feasibility of the language of a guidable automaton A is characterised by the existence of an ordered tree universal for A of n-Strahler j, for some n. Büchi-feasibility is equivalent to the existence of a finite universal tree for A.

Theorem 3.

Given a guidable nondeterministic parity tree automaton A, the following are equivalent:

  • L(A) is [1,2j]-feasible.

  • There exists an n and a tree 𝒰 of n-Strahler number at most j that is universal for A.

While our work does not give us the decidability of the index problem, it provides new tools for tackling it and makes the state-of-the-art more accessible by relating it to other familiar concepts. We hope that the deep link between the index of a language and the structure of attractor decompositions will be helpful for future work. The remarkably simple characterisation of Büchi feasible languages, as those with attractor decompositions of bounded width, or, equivalently a finite universal tree, is particularly encouraging, as deciding Büchi-feasibillity is the next challenge for advancing on the index problem.

A full version of this article, with all the missing proofs, can be found on Arxiv [16].

2 Preliminaries

The set of natural numbers {0,1,} is denoted , the set of strictly positive numbers is denoted +. The disjoint union of two sets A and B is denoted AB. An alphabet is a finite non-empty set Σ of elements, called letters. Σ and Σω denote the sets ot finite and infinite words over Σ, respectively. For u a (possibly infinite) word and n, the word u|n consists of the first n letters of u. For u and v finite words, uv denotes the concatenation of u and v. The length of a finite word u is written |u|.

An index [i,j] is a non-empty finite range of natural numbers I={i,i+1,,j}. Elements cI are called priorities. We say that an infinite sequence of priorities (cn)n is parity accepting (or simply accepting) if lim supncn0mod2, else it is parity rejecting (or rejecting).

2.1 Parity games

For I an index, (V,E) a graph with V a countable set of vertices and L:EI an edge labeling, we call G=(V,E,L) a I-graph, or a parity graph. We work with graphs in which every vertex has at least one successor. A graph (or tree) is said finitely branching if all its vertices have a finite number of exiting edges.

A graph is said even if all its infinite paths are parity accepting. For G=(V,E,L) a parity graph and VV, the graph GV is the subgraph restricted to the vertices in V. Similarly, for EE, the graph GE corresponds to (V,EE,L) with L the restriction of L to EE.

Let G=(V,E,L) a parity graph, and EE. The attractor of E in G is the set 𝙰𝚝𝚝𝚛(E,G):={vV| infinite path ρ from v in G,ρ has an edge in E}. Similarly, if VV, we define its attractor as the set 𝙰𝚝𝚝𝚛(V,G) of vertices from which all infinite paths eventually pass by V. Note that V𝙰𝚝𝚝𝚛(V,G).

A parity game played by players Eve and Adam consists in a parity graph 𝒢=(V,E,L) with a partition of V in two sets: V=VEVA, controlled respectively by Eve and Adam. A play of 𝒢 starting in vV consists in an infinite sequence of edges ρ:=(ei)i forming an infinite path starting in v. A play (ei)i is winning for Eve (or simply winning) if (L(ei))i is parity accepting, else it is said to be losing (for Eve, and winning for Adam).

A strategy for Eve consists of a function σ:EE such that, for all play ρ, for all n, if ρ|n ends in a vertex vVE, σ(ρ|n) is an edge from v. A play ρ is said to be consistent with the strategy σ if for all n, ρ|n ending in a vertex of VE implies that ρ|n+1=ρ|nσ(ρ|n). We say that a Eve strategy σ is winning from vertex vV if all plays consistent with σ starting in v are winning. We similarly define strategies for Adam, winning when all plays consistent with them are winning for Adam.

Parity games enjoy positional determinacy: one of the players always wins with a strategy that only depends on the current position [9].

A strategy for Eve in a game 𝒢=(VEVA,E,L) induces an Adam-only game 𝒢 played on the unfolding of 𝒢, from which are removed all the edges that Eve does not choose. This game can be seen as a parity graph, as the partition of the vertex set is now a trivial one, and it is even if and only if Eve’s strategy is winning.

2.2 Attractor decomposition

An attractor decomposition of an even parity graph G is a recursive partitionning of G. The intuition is that it identifies subgames of G in which the top priorities h (even) and h1 (odd) do not occur and orders them so that a path must always eventually either stay within a subgame (and never see h1 again), advance in the order (potentially seeing h1 finitely many times in between by advancing through the attractor of a subgame), or see the higher even priority h. Each subgame is then decomposed recursively, with respect to the priority h2. As the number of subgames is countable, such a decomposition witnesses that the parity graph is indeed even. An attractor decomposition has a tree-like structure, induced by the order on the subgames (which corresponds to the order of sibling nodes), and their sub-decompositions.

Given a parity graph G=(V,E,L) with maximal priority at most some even h, and κ an ordinal, a (h-level, κ-width)-attractor decomposition of G, if it exists, is recursively defined to be D=(H,A0,{(Si,Ai,Di)}0<i<) where:

  • κ,

  • HE is the set of edges in G of priority h,

  • A0=𝙰𝚝𝚝𝚛(H,G),

  • For every 0<i<, let Vi=Vj<iAj and Gi=(GH)Vi. Then:

    • SiVi is non-empty, such that (GH)Si only contains edges with priorities up to h2, has no terminal vertices and is closed under successors in Gi,

    • Ai is 𝙰𝚝𝚝𝚛(Si,Gi),

    • Di is a ((h2)-level, κ-width)-attractor decomposition of (GH)Si,

  • V=i<Ai,

  • A (0-height, κ-width)- and a (h-level, 0-width)-attractor decomposition is just (H,V): the entire graph is in the attractor of the edges of highest priority.

Lemma 4.

Given a parity graph G that admits an attractor decomposition
(H,A0,{(Si,Ai,Di)}0<i<κ)
, the set Aj is unreachable from Ai in G0<<κA for all i and j such that 0<i<j<κ.

Proof.

We proceed by transfinite induction on i. Aj is unreachable from A1 in G0<<κA=GV1 since all paths from A1 lead to S1, which is closed under successors in GV1 by definition and Aj is disjoint from A1 (by definition since it is an attractor in GVj, a graph disjoint from A1 for j>1).

For the induction step, assume Aj is unreachable in GV1 from all A for 0<<i. Since Ai is by definition an attractor of Si in GVi, any path from Ai in GVi ends up in Si without leaving Ai, and then Si is closed under successors in GVi. Therefore, all paths from Ai in GVi can only exit Ai by entering 0<<iA. Then, from the induction hypothesis, such a path cannot reach Aj.

Lemma 5.

A parity graph is even if and only if it admits an attractor decomposition.

Proof.

If a parity graph G, of maximal priority at most some even h, is even, we can construct an attractor decomposition recursively for it as follows. Let H be the set of edges of priority h and A0 the attractor of H.

Then, we define each Si and Ai for i>0 inductively. First let Vi=V<iA for i or an ordinal. Vi is either empty, or Gi=GVi is an even parity graph with maximal priority no larger than h1. Let Si consist of all positions of Gi from where h1 can not be reached. That is, Si is even (being a subgraph of G) and only has edges of priority up to h2 If Vi is non-empty, there must be such positions, since otherwise one could build a path which sees infinitely many h1, contradicting that Gi is an even graph. Let Ai be the attractor of Si in Gi and let Di be an attractor decomposition of level h2 of Si, which we can exhibit by recursion.

Let us assume Vi is non-empty for all countable ordinals i. Since all the Vis are disjoint, their union is uncountable, since there are uncountably many ordinals smaller than ω1. However we only work with countable graphs, which gives a contradiction. Thus Vi must be empty for some countable ordinal i. Hence V=<iAi.

For the other direction, assume that a parity graph has an attractor decomposition (T,A0,{(Si,Ai,Di)}0<i<κ) of level h.

We proceed by induction on the level of the attractor decomposition, that is, the number of priorities in G. The base case of the unique priority 0 is trivial since all paths are parity accepting.

For the induction step, we observe that any infinite path of G must either eventually remain in some S for 1<κ or reach H infinitely often, due to Lemma 4. In the latter case, the path is parity accepting since all edges in H are of the highest possible priority. In the former case, since each S has an attractor decomposition of height h2, by the induction hypothesis, we are done.

2.3 𝚺-trees and automata

A Σ-tree (or just tree) is a function t:{0,1}Σ. The set of all Σ-trees is denoted TrΣ. A tree is regular if it is finitely representable, that is, if it is the unfolding of a rooted graph. We denote 𝚁𝚎𝚐Σ the set of regular trees of TrΣ.

An infinite word b{0,1}ω is called a branch. Given a tree tTrΣ, a path p (along a branch b) is a sequence (pi)i:=(t(b|i))i.

A nondeterministic I-parity tree automaton (also called I-automaton, or automaton of index I) is a tuple A=(Σ,QA,qi,A,ΔA,ΩA), where Σ is an alphabet, QA a finite set of states, qi,AQA an initial state, ΔAQA×Σ×QA×QA a transition relation; and ΩA:ΔAI2 a priority mapping over the edges. A transition (q,a,q0,q1)ΔA, is said to be from the state q and over the letter a. By default, all automata in consideration are complete, that is, for each state qQA and letter aΣ, there is at least one transition from q over a in ΔA. When an automaton A is known from the context, we skip the subscript and write just Q,Δ, etc.

For q,qQ, a path from q to q is a finite transition sequence (qj,aj,qj,0,qj,1)j<NΔN such that q=q0, and j<N,qj+1{qj,0,qj,1} with qj+1=q.

A tree is said to be accepted by an automaton A if Eve wins a game defined by the product of this tree and the automaton, in which Eve chooses the transitions in A and Adam chooses the direction in t. More formally, given a tree tTrΣ, and an I-automaton A, the acceptance game of A on t, also denoted 𝒢(A,t), is the parity game obtained by taking the product of A and t. Its arena consists in {0,1}×(QAΔA), where all the positions of the shape {0,1}×QA are controlled by Eve, and the others by Adam.

  • When in a position (w,q){0,1}×QA, Eve chooses a transition eΔA of the shape (q,t(w),q0,q1), and the play proceeds to the state (w,e). All these transitions have for label the minimal priority in I.

  • Let qQA and e=(q,a,q0,q1)ΔA. In a position (w,e), Adam chooses either 0 or 1, and the games then moves towards either (w0,q0) or (w1,q1). For ΩA(e)=(i0,i1), these transitions have priorities i0 and i1, respectively.

We say that t is accepted by A if Eve wins 𝒢(A,t). The set of trees accepted by A is called the language of A and is denoted (A). We say that A recognizes (A).

If we fix a strategy for Eve, the acceptance game becomes an Adam-only game, called a run of A on t. We observe that it is played on a parity graph in the shape of a binary tree. We thus observe that a run can be considered as a tree in TrΔA. This run is won by Adam if and only if there exists a parity rejecting branch. In this case, it called a rejecting run, else it is an accepting run.

If A is an I-automaton, such a run over t induces an I-labelling of t, which, for convenience, we consider to be on edges.

A set of trees LTrΣ is an ω-regular tree language if it is of the form (A) for some automaton A. It is said to be I-feasible if furthermore A is of index I.

2.4 Guidable automata

The notion of a guidable automata was first introduced in [4]. Intuitively, they are automata that fairly simulates all language equivalent automata. Guidable automata are fully expressive [4, Theorem 1] and are more manageable than general nondeterministic automata.

Fix two automata A and B over the same alphabet Σ. A guiding function from B to A is a function g:QA×ΔBΔA such that g(p,(q,a,q0,q1))=(p,a,p0,p1) for some p0,p1QA (i.e. the function g is compatible with the state p and the letter a).

If ρTrΔB is a run of B over a tree tTrΣ then we define the run g(ρ)TrΔA as follows. We define inductively q:{0,1}QA in the following fashion: q(ε)=qi,A, and supposing q(u) to be defined, for g(q(w),ρ(w))=(q(w),t(w),q0,q1), we let q(u0),q(u1) to be respectively q0,q1. We can then define the run g(ρ)TrΔA as

g(ρ):ug(q(u),ρ(u)).

Notice that directly by the definition, the tree g(ρ) is a run of A over t.

We say that a guiding function g:QA×ΔBΔA preserves acceptance if whenever ρ is an accepting run of B then g(ρ) is an accepting run of A. We say that an automaton B guides an automaton A if there exists a guiding function g:QA×ΔBΔA which preserves acceptance. In particular, it implies that (B)(A).

An automaton A is guidable if it can be guided by any automaton B such that L(B)=L(A) (in fact one can equivalently require that L(B)L(A), see [18, Remark 4.5]). We will use the following fundamental theorem, stating that guidable automata are as expressive as non-deterministic ones.

Theorem 6 ([4, Theorem 1]).

For every regular tree language L, there exists a guidable automaton recognizing L. Moreover, such an automaton can be effectively constructed from any non-deterministic automaton for L.

2.5 Ordered trees

We define inductively ordered trees of finite depth. They are either the leaf tree of depth ()=1, or a tree T=(Tk)kK where k,Tk is an ordered tree of finite depth, and K is a well-ordered countable set. The children, siblings and subtree relation are defined in the usual way. We denote the order relation between the siblings of a tree (Tk)kK. That is, for k,kK, we have TkTk when k<k for < the well-order of K. By abuse of notation, we say that T1T2 if T1T1,T2T2 and T1T2.

From their definitions, it is clear that attractor decompositions are tree-shaped. To make this explicit, the tree-shape of an attractor decomposition D=(H,A0,{(Si,Ai,Di)}0<i<κ) is defined inductively as if κ=0, else, defining (Ti)0<i<κ the tree-shapes of the (Di)0<i<κ, D has tree-shape (Ti)0<i<κ. Observe that the width of an attractor decomposition corresponds to an upper-bound on the branching degree of its tree-shape.

We extend the notion of tree-shape to runs: a run has tree-shape t if it has an attractor decomposition of tree-shape t.

We say that an ordered tree T=(Ti)iI is isomorphically embedded in a tree T=(Tj)jJ if either I is empty, or of there exists ϕ:IJ, strictly increasing, such that iI, Ti is isomorphically embedded in Tϕ(i). Intuitively, this implies the existence of a map from the subtrees of T to the subtrees of T, where the root of T is mapped onto the root of T, and the children of every node must be mapped injectively and in an order-preserving way onto the children of its image.

Let 𝒯 be a set of ordered trees. We say that a tree U is universal for 𝒯 if all the trees of 𝒯 can be isomorphically embedded in U.

3 Game characterisation of the parity index

In this section we define priority transduction games, based on the register games from Lehtinen’s algorithm in [15], augmented with some counters. We characterise the J-feasibility of a language (A), where A is a guidable automaton, by the existence of a uniform bound n such that a tree is in (A) if and only Eve wins the J-priority transduction game on 𝒢(A,t), with counters bounded by n.

The idea of these priority transduction games is that in addition to playing the acceptance game of an I-automaton A over a tree t, which has priorities in I, Eve must map these priorities on-the-fly into the index J. In the original games from [15], she does so by choosing at each turn a register among roughly |J|2 registers. Each register stores the highest priority seen since the last time it was chosen. Then, the output is a priority in J which depends on both the register chosen and the parity of the value stored in it. Here, the mechanism is similar, except that we additionally have counters that allow Eve to delay outputting odd priorities a bounded number of times.

Intuitively, the registers, which store the highest priority seen since the last time they were chosen, determine the magnitude of the output, while their content’s parity decides the output’s parity. This allows Eve to strategically pick registers so that odd priorities get eclipsed by higher even priorities occuring soon after. However, a large odd priority occuring infinitely often will force Eve to produce odd outputs infinitely often. The counters give Eve some error margin, whereby she can pick a register containing an odd value without outputting an odd priority, up to n times in a row.

Formally, for J a priority index (of minimal value assumed to be 1 or 2 for convenience), n, the J,n-priority transduction game is a game played by Eve and Adam, over an I-parity graph G=(V,E,L) for I an index. It has two parameters, J the output index and n the bound of its counters, and is denoted 𝒯Jn(G). A configuration of the game corresponds to a position pV, a value in I for each register rj for even 2jJ (if 1J, there is an additionnal register r0), and a value between 0 and n for each counters ci,j with i odd I,j such that rj is a register.
Starting from some initial vertex p0V with counters set to 0 and registers set to the maximal even priority in I, the game proceeds as follows at step l :

  • Adam chooses an exiting edge e=(p,p)E ; the position becomes p.

  • Eve chooses a register rj.

  • The game produces the output wl :

    • if j=0, wl=1 (recall that r0 is a register iff 1J). Else,

    • if rj is even, wl=2j.

    • Else, if crj,j=n, it is said to reach n+1 before being reset: wl=2j+1 and crj,j:=0. If 2j+1J, Eve loses instantly.

    • else, wl=2j and crj,j:=crj,j+1

  • If L(e) is even, let i:=L(e) be the label of the current edge, else Eve chooses an odd i such that L(e)i (choice ). Then the following updates occur :

    • Smaller counters are reset : i<i,ci,j:=0 and j<j,crj,j:=0,

    • Registers get updated : rj:=i and j>j, rj:=max(i,rj),

Eve wins if the infinite sequence of outputs (wl)l is parity accepting, else Adam wins.

In order to explain two aspects of this game that were not covered in the initial intuition: the minimal register r0 allows Eve to wait, for a finite but unbounded time, for better priorities to override the register contents. It thus corresponds to outputting a minimal odd priority. The choice allows her to break a sequence dominated by many identical odd priorities i in a sequence with some greater odd i in between, resetting the counters albeit at the cost of witnessing a greater odd priority.111This is a technical adjustement that is convenient in the proof of Proposition 15

Let 𝒢 be a parity game of index I, n, J an index. We define the game 𝒯Jn(𝒢) as the game 𝒯Jn where, instead of following a path of parity graph chosen by Adam, it follows an ongoing play of 𝒢 where the player owning the current position q chooses its move in 𝒢 at each step, before Eve chooses her register. It corresponds to the composition of 𝒯Jn with the game 𝒢. If we fix a strategy σ for Eve in 𝒢, we observe that 𝒯Jn(𝒢) corresponds exactly to the priority transduction game 𝒯Jn over the Adam-only game 𝒢σ induced by σ in 𝒢, and that Eve wins 𝒯Jn(𝒢) if and only if she wins 𝒯Jn(𝒢σ).

Note that 𝒯Jn(𝒢) is a parity game, and therefore determined.

We show that this transduction game characterises the index of a regular tree language.

See 1

For the upward implication, it suffices to observe that the transduction game is captured by a finite state J-automaton describing the register contents and counter values (bounded by n), with nondeterministic choices corresponding to Eve’s choices, and a J-parity condition corresponding to the outputs. Then, the J-automaton equivalent to A is the composition of A with this J-automaton. The details, which are as one would expect, are in the full version.

Lemma 7.

Let J be a priority index and let A be a guidable automaton such that there exists n such that for all Σ-tree t, t(A) if and only if Eve wins 𝒯Jn(𝒢(A,t)). Then there exists an automaton of index J such that (B)=(A).

The rest of the section focuses on the downward implication of Theorem 1. We first show that Eve can only win 𝒯Jn(G) for G an even parity graph, which implies that Eve loses 𝒯Jn(𝒢(A,t)) for any t(A).

Lemma 8.

Let G a parity graph. If G is not even, then for all J,n, Adam wins 𝒯Jn(G)

Proof sketch.

If the underlying play in the parity graph sees a maximal odd priority i infinitely often, then the most significant register rj that Eve picks infinitely often contains i infinitely often when picked. The counter ci,j, which is eventually never reset, reaches n infinitely often, making the maximal output priority that occurs infinitely often odd.

Then, it remains to show that if the language of guidable A is J-feasible, then for some n Eve wins 𝒯Jn(𝒢(A,t)) for all t(A). To do so, we first analyse the relation between guided and guiding runs, and show that the preservation of global acceptance implies a more local version that resctricts differences in the parity of the dominant priority over long segments of both runs. We will then use this to show that Eve can win the transduction game by using a run of A guided by an accepting run of an equivalent J-automaton and choosing registers corresponding to the priorities of the guiding run.

The following lemma, obtained by a simple pumping argument (see full version) expresses that between all pumpable pairs of states, that is, pairs of states that are not distinguished by either run, if the guiding run is dominated by en even priority, then so is the guided one.

Lemma 9.

Let A,B be automata, let tTrΣ, let ρA,ρB be accepting runs over t of A and B, respectively, where ρA is guided by ρB. We consider these runs as trees in TrΔA,TrΔB respectively. Given u,v{0,1},{0,1}+ such that ρA(u)=ρA(uv), and such that ρB(u)=ρB(uv), if the greatest priority encountered between positions u and uv in ρB is even, so is the greatest priority encountered in this segment in ρA.

We now capture this relation with the notion of a labelling being n-bounded by the other. Let LI:EI and LJ:EJ be two labellings of a graph G=(V,E) (or tree) and let n. We say that LI is n-bound by LJ if there is no finite path π in G, segmented into consecutive paths π0,π1,πn such that for some odd i and some even j, the maximal priority on the LI- and LJ-labels of each πm,m[0,n] are i and j, respectively.

From Lemma 9 we obtain that the labelling induced by a guided run is n-bound by the one induced by its guide, with n the product of the sizes of the two automata:

Lemma 10.

Let A a guidable automaton. If (A) is J-feasible witnessed by an automaton B, for n:=|A||B|+1, for all Σ-tree t(A), for ρA the run of A on t guided by an accepting run ρB of B over t, the labelling LA induced by ρA is n-bound by the labelling LB induced by ρB.

We use n-boundedness to show that Eve can use a run ρB of an equivalent J-automaton to choose her registers to win in 𝒯Jn+1(ρA) for ρA accepting run of A guided by ρB.

Lemma 11.

Let I,J be indices, n+, and ρI:EI and ρJ:EJ two even I- and J- labelling of the same graph (E,V). If ρI is n-bound by ρJ, Eve wins 𝒯Jn+1(ρI).

Proof.

We will describe a winning strategy σ for Eve in 𝒯Jn(ρI). We recall that at each step, she has two choices : the choice of register and the choice of some iI (choice ). We once again suppose for convenience that min(J){1,2}. After seeing an edge of priority i in ρI, Eve chooses i:=i. Given priority j seen in ρJ, for j:=j2, Eve chooses the register rj. This strategy being fixed, let us verify that Eve wins in all plays consistent with σ. Let b such a play.

As ρJ is even, its maximal infinitely recurring priority along b is even; we denote it 2jJ (and j0, as 0J). We look past the position where we no longer see any priority superior to 2j. Then, as 2j is infinitely recurring, we observe that infinitely often the output is wl=2j, as this is the default output when choosing the register rj. Let us show that the game outputs at most |I|2 times 2j+1.

If it were to output 2j+1 more than |I|2 times, then there would be some counter ci,2j that would reach n+2 twice, for some odd i. We look at the first time t0 where this counter reaches n+2: after time t0, the counter ci,j has value 0. We look at the n+2 times at which ci,2j is incremented after t, denoted (tl)l[1,n+2], and note πl the path between tl and tl+1. Along these paths, we encounter no priority greater than i in ρI, nor greater than j in ρJ, as these would reset ci,j (except, possibly, at time tn+2 where we can witness a i>i after the counter has reached n+2). Additionally, for l[1,n+1], as ci,j is incremented at time tl, then there is a 2j in ρJ at the edge preceding tl (as this priority cannot be 2j+1) and rj=i at time tl, after which rj becomes the priority just seen in ρI. Therefore, l[1,n+1] between tl1 and tl, we see at least once a 2j in ρJ, and at least once a i in ρI – and they thus dominate these segments. This contradicts that ρI is n-bound by ρJ; therefore the output 2j+1 does not repeat more than |I|2 times.

If 2j=max(J), we set t0:=0. The hypothesis used for the previous reasoning still hold – initially all counters have value 0 and there is no 2j+1 in ρJ – so we obtain that there no counter ci,j that reaches n+2, which prevents instant loss. Therefore, the play along b is won by Eve, which concludes.

Lemma 8 implies that Eve loses 𝒯Jn+1(𝒢(A,t)) for t(A). If (A) is J-feasible as witnessed by a J-automaton B, then for all t(A), from Lemma 10, Eve has a run ρA that is n-bounded by an accepting run of B, which, from Lemma 11, implies that Eve wins 𝒯Jn+1(𝒢(A,t)), concluding the proof of Theorem 1.

 Remark 12.

To obtain Colcombet and Löding’s result from ours, it suffices to encode the transduction game as a distance-parity automaton that on an input tree t computes a bound n on the counters such that Eve wins 𝒯Jn(𝒢(A,t)). Then, like in [4, Lemma 3], there is a distance-parity automaton that is uniformly universal if and only if A is J-feasible.

4 Characterisation via attractor decompositions

4.1 Strahler number

The Strahler number of a tree, given by the height of the largest full binary tree that appears as a minor, measures the arborescence of a tree. We generalise this notion.

Let n. The n-Strahler number of T a tree of finite depth, denoted 𝒮n(T), is defined by recurrence:

  • if T=, 𝒮n(T)=1.

  • Else, T=(Tk)kK. We consider m:=max{𝒮n(Tk)|kK}. If there are at least n+1 Tk’s of n-Strahler number m, 𝒮n(T)=m+1. Else, 𝒮n(T)=m.

The n-Strahler number of T is at most its depth. Having a n-Strahler number k is equivalent to having a complete n-ary tree of detph k as a minor, for the operations of child deletion and replacing a node by one of its children. Figure 1 gives an example.

Figure 1: An ordered tree of depth 4, of 3-Strahler number 3, as exemplified by the red edges.

We say that a parity game G has n-Strahler number j if there exists a strategy σG, winning for Eve, such that the resulting parity graph admits an attractor decomposition of tree-shape whith n-Strahler number j.

In the next two sections we prove each direction of the following theorem, using Theorem 1 for the upward implication.

See 2

 Remark 13.

Note that this theorem, based on a range [1,2j], is less precise than Theorem 1, which handles all ranges J. This is because the parity of the minimal and maximal priorities are not reflected in the tree-shape of the attractor decomposition. For example, if there is a uniform bound on the lengths of paths in attractors, then there is no need for a minimal odd priority. The maximal even priority on the other hand is not required if there are no edges that go from Ai to Aj with j>i. While the extremal parities are hard to characterise from the attractor decompositions, they are neatly captured by the transduction game.

4.1.1 From feasibility to attractor decompositions

Let A be a guidable automaton of index I. If (A) is [1,2j] feasible by some automaton B, by Lemma 10, there exists n and a run ρB guiding A such that the resulting run ρA is n-bound by ρB. From this, we exhibit an attractor decomposition of G of n-Strahler number j. More precisely these runs over 𝒢(A,t) and 𝒢(B,t) are considered as an I-tree and a [1,2j]-tree, respectively. We will use these two trees in order to exhibit an attractor decomposition of 𝒢(A,t) of n-Strahler number j.

Proposition 14.

Given a tree-shaped graph G=(V,E), finitely-branching and without terminal vertices, two indices I=[0,2i] and J=[1,2j] and labellings ρI:EI and σJ:EJ such that (G,ρI) and (G,σJ) are even parity graphs, if ρI is n-bound by σJ, then (G,ρI) admits an attractor decomposition of n-Strahler number at most j.

Proof sketch.

In this proof, we begin with an attractor decomposition (H,A0,(Sk,Ak,Dk)k<κ) of GI, the graph G labelled by the run ρI. We then use σJ to refine this decomposition.

Within each Sk, we identify the vertices Sk such that the path leading up to them has seen 2j since entering Ak. We then partition and order the sets Sk into sets Θm such that a path that goes from one such set to another must see 2j in its σJ labelling and 2i1 in its ρI labelling. The n-boundedness condition guarantees that there are no more than n of these sets. These sets, with priorities in ρI and σJ bounded by 2i2 and 2j respectively, have attractor decompositions of n-Strahler number up to j.

The remaining vertices of Sk form subgames in which 2j does not occur, so they can be decomposed by an attractor decomposition following σJ (even) into subgames in which priorities are dominated by i2 and j2: these admit attractor decompositions of n-Strahler number up to j1, by induction hypothesis.

Then, assembled into the appropriate order, these up to n attractor decompositions of Strahler number up to j and arbitrarily many attractor decompositions of n-Strahler number up to j1 are used to display the attractor decomposition of n-Strahler number at most j.

The details of this proof, in the full version, get quite technical, as it handles two different types of sub-decompositions that must be interleaved in the right order, with the appropriate attractors computed in between, while checking that all of the built sets satisfy the requirements to be in an attractor decomposition.

4.1.2 From attractor decomposition to feasibility

For the backward direction of Theorem 2, we show that if Eve has a winning strategy in a game with a corresponding attractor decomposition of n-Strahler number h, then she can win the corresponding priority transduction game with h registers and counters going up to n. Then, using Theorem 1, we obtain the required implication.

Proposition 15.

Given a game G and n{0}, if G has n-Strahler number h, then Eve wins 𝒯[1,2h]n+1(G).

Proof sketch.

Given an attractor decomposition of G of n-Strahler number h, we build a winning strategy for Eve in 𝒯[1,2h]n+1(G).

The idea of her strategy is that when the underlying parity game takes an edge (q,q), Eve identifies the smallest sub-attractor decomposition that contains both q and q. For technical reasons, if the priority of the move is odd and smaller than the maximal odd priority in the sub-attractor decomposition, then she picks for her choice of priority in I the said maximal odd priority. Otherwise, she uses the actual priority of the move.

If the edge advances to the left in the attractor decomposition, Eve picks the smallest register r0, if it advances to the right (and hence is labelled with a relatively large even priority), she picks the register corresponding to the n-Strahler number of the sub-attractor decomposition. If it stays within the same attractor, she picks r0 or r1 depending on the priority of the move.

The technical part of the proof, detailed in the full version, then consists of checking that this strategy is indeed winning. The main idea is that a play will eventually stay in some minimal sub-attractor decomposition, where it will see a maximal even priority from I infinitely often. Then, Eve’s strategy ensures that the maximal register rj used infinitely often corresponds to the n-Strahler-number of this decomposition. Since there are at most n children of the same n-Strahler number, the counters ci,j are only incremented up to n times before being reset by the occurence of a higher even priority, thus avoiding seeing a large odd output infinitely infinitely often.

 Remark 16.

Eve also has a winning strategy in 𝒯[1,2h]n(G), but the proof is more elaborate, as we need to do a case analysis of the behaviour of the last counter incrementation.

If Eve has such an attractor decomposition over all the games 𝒢(A,t) for t(A), the corresponding n is a uniform bound such that Eve wins all the 𝒯[1,2j]n. From this, we conclude the proof of Theorem 2 using the upwards direction of Theorem 1.

5 Characterisation via universal trees

We now show that the previous characterisations of J-feasibility of a guidable automaton A can be reformulated in terms of the existence of a universal tree for A. Note that in this section we use both trees, which are binary, infinite and inputs to automata, and ordered trees, which are of potentially infinite branching but finite height and describe attractor decompositions.

We say that an ordered tree is universal for an automaton A if it is universal for some set of ordered trees T such that for all regular trees tL(A), Eve has a strategy in 𝒢(A,t) with an attractor decomposition of tree-shape in T.

See 3

To prove this theorem, we show that that for fixed n,j,d+, there is an infinite ordered tree 𝒰 of n-Strahler number j and depth d that is universal for the set of finite ordered trees of n-Strahler number at most j and depth at most d. Over regular trees, because of the positionality of parity games, Eve’s strategies can be chosen to be regular, which implies that their attractor decompositions can be finite, making U universal for guidable automata recognising a [1,2j]-feasible language. For the other direction, we recall that if two tree automata are equivalent over regular trees, they are equivalent over all trees [24].

Let n,k,d+. We define recursively the universal tree 𝒰n,k,d of n-Strahler number k and depth d as follows, where ω(T) denotes the repetition of ω times the ordered tree T:

  • 𝒰n,1,1:=

  • When d<k, 𝒰n,k,d is undefined.

  • Else, dk, and by denoting U:=𝒰n,k1,d1, we have
    Un,k,d:=ω(U),𝒰n,k,d1,ω(U),,𝒰n,k,d1,ω(U), with n repetitions of 𝒰n,k,d1 (or, if it is not defined, no such repetition). Similarly, if U=𝒰α,n,k1,d1 is undefined due to k being equal to 0, these children are omitted.

Figure 2: The recursion step in the construction of 𝒰α,n,k,d.

An example of such a construction can be found in figure 2. Observe that 𝒰n,k,d has width greater than ω as soon as 2kd. Furthermore, n,k,d, 𝒰α,n,k,d has depth d, and we establish that it also has n-Strahler number exactly k:

Lemma 17.

For all n,k,d{0}, if kd, then 𝒰n,k,d is defined, and 𝒮n(𝒰n,k,d)=k.

Proof.

We proceed by induction on (d,k) ordered by the sum d+k.

  • If (d,k)=(1,1), the result is immediate.

  • Else, by induction 𝒰n,k1,d1 is defined and has n-Strahler number k1, and if defined 𝒰n,k,d1 has n-Strahler number k. We observe that 𝒮n(𝒰n,k,d)=k, as it has at most n children of n-Strahler number k, and more than n children of n-Strahler number k1.

We can now prove its universality:

Lemma 18.

Let 𝒯 be a set of finite ordered trees, all of depth bounded by d and n-Strahler number at most k. Then 𝒰n,min(k,d),d is universal for 𝒯.

Proof.

We reason by recurrence on (d,k) ordered by the sum d+k.
If k=d=1, then T𝒯,T=, and is trivially isomorphically embedded in 𝒰n,1,1.
Else, let (d,k)(1,1), and we suppose by recurrence that (d,k) such that d+k<d+k, the proposition holds. If d<k, then there is no ordered tree of depth d and n-Strahler number k: they all are of n-Strahler number at most d. Then, by recurrence, as 2d<d+k, 𝒰n,d,d is universal for 𝒯.

Else, 𝒰n,k,d=ω(𝒰n,k1,d1),𝒰n,k,d1,ω(𝒰n,k1,d1),,𝒰n,k,d1,ω(𝒰n,k1,d1), with n repetitions of 𝒰α,n,k,d1 if it is defined (else zero such repetition). Let T𝒯. By definition, if T=, it is isomorphically embedded in all ordered trees. Else, for T=(Ti)iI, then 𝒮n(T)k, and notably it admits at most n Ti’s of n-Strahler number k. We denote the corresponding indices (i1,,im) with mn. Denoting (j1,,jn) the (ordinal) indices of the 𝒰n,k,d1’s in 𝒰n,k,d, we define ψ:iljl, for all lm. By recurrence, we have that lm,Til is isomorphically embedded in Uα,n,k,d1 (as d+(k1)<d+k). All the other Ti’s are such that 𝒮n(Ti)k1, and are thus isomorphically embedded in 𝒰α,n,k1,d1 by recurrence (if k10, that is. If k1=0, these Ti do not exist, as they would be of n-Strahler number 0). Then, defining i0=1 and im=ω as for all l[0,m] there is only a finite number of such ordered trees Ti between the indices il and il+1, we can easily map in order (Ti)i[il,il+1) in the corresponding ω(𝒰n,k,d1) with a map ϕl. We finally observe that the function obtained by combining ψ and the different ϕl is indeed injective, increasing, and that it maps Ti’s to ordered trees in which they are isomorphically embedded, and thus describes an isomorphic embedding of T in 𝒰n,k,d.

 Remark 19.

As established by Rabin [24, Theorem 20], a non-empty tree automaton accepts a regular tree, therefore, if two automata are equivalent in 𝚁𝚎𝚐Σ, they are equivalent over all trees. This notably implies that, for A an automaton and J an index, (A) is J-feasible over 𝚁𝚎𝚐Σ if and only if it J-feasible over all trees.

Lemma 20.

Let A a guidable I-automaton, let t a regular tree in (A). If (A) is [1,2j]-feasible, then there exists a finite attractor decomposition of 𝒢(A,t) of n-Strahler number at most j.

Proof.

As (A) is [1,2j]-feasible, there exists a [1,2j]-automaton B that recognizes (A). As t is a regular tree, using the positional determinacy of parity games, we can exhibit the existence of an accepting run ρB of B such that ρB is a regular tree. From this, we obtain that the run ρA of A guided by ρB is also regular. There thus exists GρA finite graph whose unfolding is ρA, similarly there exists GρB of unfolding ρB. Neither of them has any terminal vertices, else it would imply the existence of terminal vertices in ρA or ρB.

We consider the graph G=GρA×GρB, still finite and without terminal vertices. We then define G, consisting of G with some memory M: for each 2i1I,2j[1,2j], it stores whether a 2j was seen in its ρB component since the last 2i1 in its ρA component, and, conversely, whether 2i1 has been seen in the ρA component since the last 2j in the ρB component. We denote LA and LB the labelling fonctions of G in I and [1,2j], respectively. We observe that unfolding G on LA is still induced by the run ρA, and similarly with LB and ρB. Then, by Lemma 10, LA is n-bound by LB.

We can then apply a variant of Proposition 14 on LA and LB with underlying graph G. The graph G being finite, it does not satisfy the tree-shaped condition; however this hypothesis is used only twice in the initial proof, to find vertices to which every path has seen a 2j since entering the current Ak and vertices to which every path has seen 2i1 since the last 2j (through a property we call tightness). As the memory M stores exactly this information, we can instead define Sk as the vertices in Sk that saw a 2j since the last 2i1, and increases in the star-rank now only take place if the memory states that a 2i1 was seen since the last sighting of a 2j (intuitively, a state belongs to some Θm if and only if its memory states that a 2j was seen last). The remainder of the proof is identical, and it still builds an attractor decomposition of G of n-Strahler number j, which is finite since G is finite.

We finally obtain the direct implication of Theorem 3 from this lemma and Lemma 18.

For the converse direction, by Proposition 15, Eve wins all the 𝒯[1,2j]n+1(𝒢(A,t)) for t(A)𝚁𝚎𝚐Σ. Conversely, for t(A)C𝚁𝚎𝚐Σ, by Lemma 8, Eve looses. Therefore, by Lemma 7 (restricting ourselves to the regular trees), we can construct B a [1,2j]-automaton recognizing (A)𝚁𝚎𝚐Σ over the regular trees. Therefore (A) is [1,2j]-feasible over the regular trees, and by  Remark 19 is thus [1,2j]-feasible.

6 Conclusion

We have given three closely related new characterisations of the J-feasibility of ω-regular tree languages: one via the transduction game, one via attractor decompositions and one via universal trees. While we do not solve the decidability of the index problem, our work brings to light the deep relationships between the tools we are used to manipulate in the context of solving parity games, such as attractor decompositions, universal trees and Lehtinen’s register game, and the J-feasibility of a language. In particular, the n-Strahler number turns out to have great explanatory power by relating the transduction game, the structure of attractor decompositions and the index of a language.

The Büchi case, which is at the frontier of the state of the art, is particularly appealing because of its simplicity: the language of a guidable automaton A is Büchi feasible if and only if there is a finite bound n such that Eve can win in the acceptance games with strategies with attractor decompositions of width at most n, or, equivalently, if A admits a finite universal tree. We hope that these insights will help unlock the next steps in tackling this long-standing open problem.

References

  • [1] Julian C. Bradfield. The modal μ-calculus alternation hierarchy is strict. Theor. Comput. Sci., 195(2):133–153, 1998. doi:10.1016/S0304-3975(97)00217-X.
  • [2] Cristian S. Calude, Sanjay Jain, Bakhadyr Khoussainov, Wei Li, and Frank Stephan. Deciding parity games in quasipolynomial time. In Hamed Hatami, Pierre McKenzie, and Valerie King, editors, Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2017, Montreal, QC, Canada, June 19-23, 2017, pages 252–263. ACM, 2017. doi:10.1145/3055399.3055409.
  • [3] Thomas Colcombet, Denis Kuperberg, Christof Löding, and Michael Vanden Boom. Deciding the weak definability of Büchi definable tree languages. In Simona Ronchi Della Rocca, editor, Computer Science Logic 2013 (CSL 2013), CSL 2013, September 2-5, 2013, Torino, Italy, volume 23 of LIPIcs, pages 215–230. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2013. doi:10.4230/LIPIcs.CSL.2013.215.
  • [4] Thomas Colcombet and Christof Löding. The non-deterministic Mostowski hierarchy and distance-parity automata. In Luca Aceto, Ivan Damgård, Leslie Ann Goldberg, Magnús M. Halldórsson, Anna Ingólfsdóttir, and Igor Walukiewicz, editors, Automata, Languages and Programming, 35th International Colloquium, ICALP 2008, Reykjavik, Iceland, July 7-11, 2008, Proceedings, Part II - Track B: Logic, Semantics, and Theory of Programming & Track C: Security and Cryptography Foundations, volume 5126 of Lecture Notes in Computer Science, pages 398–409. Springer, 2008. doi:10.1007/978-3-540-70583-3_33.
  • [5] Wojciech Czerwinski, Laure Daviaud, Nathanaël Fijalkow, Marcin Jurdzinski, Ranko Lazic, and Pawel Parys. Universal trees grow inside separating automata: Quasi-polynomial lower bounds for parity games. In Timothy M. Chan, editor, Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2019, San Diego, California, USA, January 6-9, 2019, pages 2333–2349. SIAM, 2019. doi:10.1137/1.9781611975482.142.
  • [6] Laure Daviaud, Marcin Jurdzinski, and Ranko Lazic. A pseudo-quasi-polynomial algorithm for mean-payoff parity games. In Anuj Dawar and Erich Grädel, editors, Proceedings of the 33rd Annual ACM/IEEE Symposium on Logic in Computer Science, LICS 2018, Oxford, UK, July 09-12, 2018, LICS ’18, pages 325–334. ACM, July 2018. doi:10.1145/3209108.3209162.
  • [7] Laure Daviaud, Marcin Jurdzinski, and Karoliina Lehtinen. Alternating weak automata from universal trees. In Wan J. Fokkink and Rob van Glabbeek, editors, 30th International Conference on Concurrency Theory, CONCUR 2019, August 27-30, 2019, Amsterdam, the Netherlands, volume 140 of LIPIcs, pages 18:1–18:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2019. doi:10.4230/LIPIcs.CONCUR.2019.18.
  • [8] Laure Daviaud, Marcin Jurdzinski, and K. S. Thejaswini. The Strahler number of a parity game. In Artur Czumaj, Anuj Dawar, and Emanuela Merelli, editors, 47th International Colloquium on Automata, Languages, and Programming, ICALP 2020, July 8-11, 2020, Saarbrücken, Germany (Virtual Conference), volume 168 of LIPIcs, pages 123:1–123:19. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2020. doi:10.4230/LIPIcs.ICALP.2020.123.
  • [9] E. Allen Emerson and Charanjit S. Jutla. Tree automata, mu-calculus and determinacy (extended abstract). In 32nd Annual Symposium on Foundations of Computer Science, San Juan, Puerto Rico, 1-4 October 1991, pages 368–377. IEEE Computer Society, 1991. doi:10.1109/SFCS.1991.185392.
  • [10] Alessandro Facchini, Filip Murlak, and Michal Skrzypczak. Rabin-Mostowski index problem: A step beyond deterministic automata. In 28th Annual ACM/IEEE Symposium on Logic in Computer Science, LICS 2013, New Orleans, LA, USA, June 25-28, 2013, pages 499–508. IEEE Computer Society, 2013. doi:10.1109/LICS.2013.56.
  • [11] Marcin Jurdzinski and Ranko Lazic. Succinct progress measures for solving parity games. CoRR, abs/1702.05051:1–9, 2017. doi:10.48550/arXiv.1702.05051.
  • [12] Marcin Jurdzinski, Rémi Morvan, and K. S. Thejaswini. Universal algorithms for parity games and nested fixpoints. In Jean-François Raskin, Krishnendu Chatterjee, Laurent Doyen, and Rupak Majumdar, editors, Principles of Systems Design - Essays Dedicated to Thomas A. Henzinger on the Occasion of His 60th Birthday, volume 13660 of Lecture Notes in Computer Science, pages 252–271. Springer, 2022. doi:10.1007/978-3-031-22337-2_12.
  • [13] Nils Klarlund. Progress measures for complementation of omega-automata with applications to temporal logic. In 32nd Annual Symposium on Foundations of Computer Science, San Juan, Puerto Rico, 1-4 October 1991, pages 358–367. IEEE Computer Society, 1991. doi:10.1109/SFCS.1991.185391.
  • [14] Orna Kupferman and Moshe Y. Vardi. Weak alternating automata and tree automata emptiness. In Jeffrey Scott Vitter, editor, Proceedings of the Thirtieth Annual ACM Symposium on the Theory of Computing, Dallas, Texas, USA, May 23-26, 1998, STOC ’98, pages 224–233, New York, NY, USA, 1998. ACM. doi:10.1145/276698.276748.
  • [15] Karoliina Lehtinen. A modal μ perspective on solving parity games in quasi-polynomial time. In Anuj Dawar and Erich Grädel, editors, Proceedings of the 33rd Annual ACM/IEEE Symposium on Logic in Computer Science, LICS 2018, Oxford, UK, July 09-12, 2018, LICS ’18, pages 639–648, New York, NY, USA, 2018. ACM. doi:10.1145/3209108.3209115.
  • [16] Karoliina Lehtinen and Olivier Idir. Using games and universal trees to characterise the nondeterministic index of tree languages, 2025. arXiv:2504.16819.
  • [17] Giacomo Lenzi. A hierarchy theorem for the μ-calculus. In Friedhelm Meyer auf der Heide and Burkhard Monien, editors, Automata, Languages and Programming, 23rd International Colloquium, ICALP96, Paderborn, Germany, 8-12 July 1996, Proceedings, volume 1099 of Lecture Notes in Computer Science, pages 87–97. Springer, 1996. doi:10.1007/3-540-61440-0_119.
  • [18] Christof Löding. Logic and automata over infinite trees. PhD thesis, RWTH Aachen, Germany, 2009. URL: https://www.lics.rwth-aachen.de/global/show_document.asp?id=aaaaaaaaabcqdrw.
  • [19] Damian Niwinski. On fixed-point clones (extended abstract). In Laurent Kott, editor, Automata, Languages and Programming, 13th International Colloquium, ICALP86, Rennes, France, July 15-19, 1986, Proceedings, volume 226 of Lecture Notes in Computer Science, pages 464–473. Springer, 1986. doi:10.1007/3-540-16761-7_96.
  • [20] Damian Niwinski and Michal 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, August 23-27, 2021, Tallinn, Estonia, volume 202 of LIPIcs, pages 81:1–81:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPIcs.MFCS.2021.81.
  • [21] Damian Niwinski and Igor Walukiewicz. Relating hierarchies of word and tree automata. In Michel Morvan, Christoph Meinel, and Daniel Krob, editors, STACS 98, 15th Annual Symposium on Theoretical Aspects of Computer Science, Paris, France, February 25-27, 1998, Proceedings, volume 1373 of Lecture Notes in Computer Science, pages 320–331. Springer, 1998. doi:10.1007/BFb0028571.
  • [22] Damian Niwinski and Igor Walukiewicz. Deciding nondeterministic hierarchy of deterministic tree automata. In Ruy J. G. B. de Queiroz and Patrick Cégielski, editors, Proceedings of the 11th Workshop on Logic, Language, Information and Computation, WoLLIC 2004, Fontainebleau, France, July 19-22, 2004, volume 123 of Electronic Notes in Theoretical Computer Science, pages 195–208. Elsevier, 2004. doi:10.1016/j.entcs.2004.05.015.
  • [23] Michael O. Rabin. Decidability of second-order theories and automata on infinite trees. Bulletin of the American Mathematical Society, 74:1025–1029, 1968. URL: https://api.semanticscholar.org/CorpusID:6015948.
  • [24] Michael O. Rabin. Automata on infinite objects and Church’s problem. In CBMS Regional Conference, 1972. URL: https://api.semanticscholar.org/CorpusID:119846488.
  • [25] Michal Skrzypczak and Igor Walukiewicz. Deciding the topological complexity of Büchi languages. In Ioannis Chatzigiannakis, Michael Mitzenmacher, Yuval Rabani, and Davide Sangiorgi, editors, 43rd International Colloquium on Automata, Languages, and Programming, ICALP 2016, July 11-15, 2016, Rome, Italy, volume 55 of LIPIcs, pages 99:1–99:13. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2016. doi:10.4230/LIPIcs.ICALP.2016.99.
  • [26] Igor Walukiewicz. Deciding low levels of tree-automata hierarchy. In Ruy J. G. B. de Queiroz, Luiz Carlos Pereira, and Edward Hermann Haeusler, editors, 9th Workhop on Logic, Language, Information and Computation, WoLLIC 2002, Rio de Janeiro, Brazil, July 30 - August 2, 2002, volume 67 of Electronic Notes in Theoretical Computer Science, pages 61–75. Elsevier, 2002. doi:10.1016/S1571-0661(04)80541-3.
  • [27] Wieslaw Zielonka. Infinite games on finitely coloured graphs with applications to automata on infinite trees. Theor. Comput. Sci., 200(1-2):135–183, 1998. doi:10.1016/S0304-3975(98)00009-7.