Determinization of B\"uchi Automata: Unifying the Approaches of Safra and Muller-Schupp

TL;DR

This paper introduces a unified determinization method for B"uchi automata that combines Safra's and Muller-Schupp's approaches, enabling improved heuristics and a deeper understanding of the structures involved.

Contribution

A new meta-construction that subsumes both Safra's and Muller-Schupp's determinization procedures for B"uchi automata, based on a novel correspondence between their structural representations.

Findings

The new construction strictly subsumes both existing methods.

It reveals a correspondence between Safra trees and Muller-Schupp levels.

The approach enables combining existing techniques and developing heuristics.

Abstract

Determinization of B\"uchi automata is a long-known difficult problem and after the seminal result of Safra, who developed the first asymptotically optimal construction from B\"uchi into Rabin automata, much work went into improving, simplifying or avoiding Safra's construction. A different, less known determinization construction was derived by Muller and Schupp and appears to be unrelated to Safra's construction on the first sight. In this paper we propose a new meta-construction from nondeterministic B\"uchi to deterministic parity automata which strictly subsumes both the construction of Safra and the construction of Muller and Schupp. It is based on a correspondence between structures that are encoded in the macrostates of the determinization procedures - Safra trees on one hand, and levels of the split-tree, which underlies the Muller and Schupp construction, on the other. Our construction allows for combining the mentioned constructions and opens up new directions for the development of heuristics.

Equations

$${\Delta }_t(q,x):=\Delta (q,x)\setminus \Delta (\bigcup _{i=1}^{\mathsf{idx}(q)-1}{S}_i,x),$$

$$\forall i\in [n^{\prime }],l\in I_i:\tilde{\alpha }(l)\in G⟹\leftarrow (l)+1\in I_i\text{(complete subtrees collapsed)}.$$

$$g^{li}\circ g={\mathsf{id}}_B\Rightarrow g^{li}\circ \stackrel{={\mathsf{id}}_A}{\overbrace{g\circ f}}\circ \stackrel{={\mathsf{id}}_A}{\overbrace{g\circ f}}={\mathsf{id}}_B\circ f\circ \stackrel{={\mathsf{id}}_A}{\overbrace{g\circ f}}\Rightarrow g^{li}=f$$

Full text

1 Introduction

Büchi automata are finite automata for infinite words, and were initially introduced to show decidability of the logic S1S [2]. Infinite words can be used to model infinite execution traces of reactive, non-terminating systems, and serve as a translation target from logics like LTL (see, e.g., [15, 5]), which is a popular and well-understood specification formalism. For this reason, Büchi automata nowadays play a central role in formal methods like model-checking [1] and runtime-verification [6], because they can represent all $\omega$-regular languages and are suitable for efficient algorithmic treatment. Unfortunately, the simplicity of the Büchi acceptance condition makes it crucially dependent on nondeterminism, i.e., not every $\omega$-regular language (or LTL formula) can be accepted by a deterministic Büchi automaton (see, e.g., [16]). In some settings, this nondeterminism causes difficulties, such that algorithms require a representation of the property by a deterministic automaton, like in probabilistic model-checking (see, e.g., [1, Section 10.3]), or in synthesis (see [17] for an overview of the theory, and [9] for recent developments in practice).

A first determinization procedure that translates nondeterministic Büchi automata into deterministic automata was presented in [8]. The first asymptotically optimal and most well-known determinization construction for Büchi automata is the construction of Safra [13]. It translates a nondeterministic Büchi automaton with $n$ states into a deterministic Rabin automaton with at most $2^{\mathcal{O}(n\log n)}$ states and $\mathcal{O}(n)$ sets in the acceptance condition. In applications like synthesis, the deterministic automaton is used to build a game that inherits as winning condition the acceptance condition of the automaton. In the theory of infinite duration games, the parity condition plays a central role (see, e.g., the survey [18]). For this reason, Piterman modified Safra’s construction in order to directly obtain a parity automaton [11]. This construction was reformulated in [14], where also a tighter analysis of its state complexity is given with an upper bound of $\mathcal{O}(n!^{2})$ for the number of states. A similar construction is presented in [12], adapted to the translation of $\omega$-regular expressions directly into parity automata.

It is known that the Safra construction is essentially optimal [3], so there is no hope of significantly improving the worst-case upper bounds of the known constructions. However, the data structure of Safra trees (or history trees) that is used for the states of the deterministic automata, is challenging to deal with in implementations. Therefore, alternative approaches for determinization have been studied, leading to a family of constructions that are based on a construction by Muller and Schupp, which appeared in [10] as a by-product of a translation from alternating to non-deterministic tree automata. An explicit description of the construction specifically for determinization of Büchi automata is presented in [7]. A refinement of that construction is presented in [4], in which the states of the deterministic automaton are no longer represented as trees but as ordered and labelled tuples of sets.

The two approaches of Safra and Muller-Schupp show some similarities, as pointed out in the conclusion of [4], but from the existing formulations of the constructions, their precise relationship is not clear.

In this paper, we provide a construction for transforming nondeterministic Büchi automata into deterministic parity automata that cleanly explains the connections between the approaches of Safra and Muller-Schupp. It turns out that both types of constructions can be formulated on the same data structure, which can either be understood as ordered tuples of sets in which each set has an additional rank (a natural number), or as Safra trees in which each node has an additional rank (the same structure is essentially used in the constructions from [11] and [14]). The transitions are defined in terms of a sequence of simple operations, and it turns out that the two constructions only differ in one of these operations. In summary, our contributions are the following:

• •

We provide a new and relatively simple formulation of a Muller-Schupp style determinization construction that yields deterministic parity automata. Compared to previous constructions from [7] and [4], we encode less information in the states, and obtain a construction that has the same worst-case upper bound as the Safra style constructions.

• •

We extend our Muller-Schupp style construction by introducing a degree of freedom in the choice of the successor states. This freedom can be used to make the construction correspond to Safra’s construction as presented in [11] and [14]. We therefore obtain a construction that unifies the approaches of Safra and Muller-Schupp in one general construction. Furthermore, the freedom in the choice of the successors of transitions also yields new ways of obtaining deterministic parity automata, and can be used in implementations as a heuristic to reduce the state space of the resulting automaton.

This work is organized as follows. After introducing the basic notations in Section 2, we present the new variant of the Muller-Schupp construction in Section 3, and then briefly review Safra’s construction in Section 4. We explain the structural relationship between those two constructions in Section 5, and finally introduce our generalized construction as a simple extension of the presented Muller-Schupp construction in Section 6. In Section 7 we discuss and conclude.

2 Preliminaries

First we briefly review basic definitions concerning $\omega$-automata and $\omega$-languages. If $\Sigma$ is a finite alphabet, then $\Sigma^{\omega}$ is the set of all infinite words $w=w_{0}w_{1}\ldots$ with $w_{i}\in\Sigma$. For $w\in\Sigma^{\omega}$ we denote by $w(i)$ the $i$-th symbol $w_{i}$. For convenience, we write $[n]$ for the set of natural numbers $\{1,\ldots,n\}$. A Büchi automaton $\mathcal{A}$ is a tuple $(Q,\Sigma,\Delta,Q_{0},F)$, where $Q$ is a finite set of states, $\Sigma$ a finite alphabet, $\Delta\subseteq Q\times\Sigma\times Q$ is the transition relation and $Q_{0},F\subseteq Q$ are the sets of initial and accepting states, respectively. When $Q$ is understood and $X\subseteq Q$, then $\overline{X}:=Q\setminus X$. We write $\Delta(p,x):=\{q\mid(p,x,q)\in\Delta\}$ to denote the set of successors of $p$ on symbol $x$ and $\Delta(P,x)$ for $\bigcup_{p\in P}\Delta(p,x)$. A run of an automaton on a word $w\in\Sigma^{\omega}$ is an infinite sequence of states $q_{0},q_{1},\ldots$ starting in some $q_{0}\in Q_{0}$ such that $(q_{i},w(i),q_{i+1})\in\Delta$ for all $i\geq 0$. An automaton is deterministic if $|Q_{0}|=1$ and $|\Delta(p,x)|\leq 1$ for all $p\in Q,x\in\Sigma$, and non-deterministic otherwise. In this work, we assume Büchi automata to be non-deterministic and refer to them as NBA. A transition-based deterministic parity automaton (TDPA) is a deterministic automaton $(Q,\Sigma,\Delta,Q_{0},c)$ where instead of $F\subseteq Q$ there is a priority function $c:\Delta\to\mathbb{N}$ assigning a natural number to each transition.

A run of an NBA is accepting if it contains infinitely many accepting states. A run of a TDPA is accepting if the smallest priority that appears infinitely often on transitions along the run is even. An automaton $\mathcal{A}$ accepts $w\in\Sigma^{\omega}$ if there exists an accepting run on $w$, and the language $L(\mathcal{A})\subseteq\Sigma^{\omega}$ recognized by $\mathcal{A}$ is the set of all accepted words. To avoid confusion, we sometimes refer to states of TDPA that we construct as macrostates to distinguish them from the states of the underlying Büchi automaton.

3 A Simplified Muller-Schupp Construction

The essential idea for determinization using the Muller-Schupp construction is the following: given some Büchi automaton $\mathcal{A}$ and input word $w$, the resulting deterministic automaton conceptually traverses a specific run-tree of $\mathcal{A}$ on $w$, called reduced split-tree in [7], and tracks enough information to decide whether an infinite path with a specific shape exists in this tree. Such a path is known to exist if and only if $w$ is accepted by $\mathcal{A}$. The construction presented in [7] uses a structure called contraction trees in order to track the relevant information. This has been simplified in [4] to macrostates that consist of an ordered tuple of disjoint sets of Büchi states, and two preorders over the states appearing in the tuple.

In this section, we further simplify the structure of the macrostates for the deterministic automaton to ordered tuples of disjoint sets of Büchi states, and a single additional linear order on these sets (formally expressed as a ranking function that assigns to each set a natural number). This also results in a relatively simple transition function on the macrostates.

The reduced split-tree $t^{rs}(\mathcal{A},w)$ for NBA $\mathcal{A}$ and word $w\in\Sigma^{\omega}$ is an ordered infinite tree in which the nodes are labelled by state-sets, and each node has at most two successors. Formally, it is constructed as follows. The first level of the tree consists of the root node labelled by the initial states $Q_{0}$. To construct level $i+1$ from level $i$, for each node at level $i$ labelled by set $S$ of states, let the left child of $S$ be labelled by $\Delta(S,w(i))\cap F$ and the right child by $\Delta(S,w(i))\cap\overline{F}$, i.e., accepting and non-accepting successor states are separated. Then keep only the leftmost (wrt. the natural ordering of neighbors) occurrence of each state in the level and finally remove nodes labelled by $\emptyset$. Clearly, because of the normalization, the number of nodes on each level can be at most $|Q|$. An example of a reduced split-tree is shown in Figure 1. We call an infinite path in the tree that takes the left branch infinitely often a left-path. Reduced split-trees have the following useful property:

Lemma 3.1** ([7], Lemma 2).**

$\mathcal{A}$* accepts $w\Longleftrightarrow t^{rs}(\mathcal{A},w)$ has a left-path.*

In the following, we identify nodes in the same level with their label sets. To obtain a deterministic automaton, we augment the nodes of the reduced split-tree with number tokens that we call (age-)ranks, which are used to infer a left-path.

The new macrostates in the deterministic automaton represent levels of reduced split-trees and consist of a tuple of disjoint non-empty sets $t:=(S_{1},S_{2},\ldots,S_{n})$ equipped with a bijection $\alpha:[n]\to[n]$ satisfying $\alpha(n)=1$, which assigns to each set $S_{i}$ the rank $\alpha(i)$. We call a pair $(\alpha,t)$ that satisfies these constraints ranked slice and we call it pre-slice, if $t$ contains empty sets or $\alpha$ is not a bijection. Notice that all macrostates are ranked slices, whereas pre-slices occur only during intermediate steps. We introduce the following useful notations to work with ranked slices. Let $|t|:=n$ and $Q_{t}:=\bigcup_{i=1}^{|t|}S_{i}$. The function $\mathsf{idx}:Q_{t}\to[|t|]$ maps each state $q\in Q_{t}$ to the tuple index $i$ such that $q\in S_{i}$, and by $\alpha(q)$ we denote $\alpha(\mathsf{idx}(q))$ for $q\in Q_{t}$.

When reading symbol $x\in\Sigma$ in macrostate $(\alpha,t)$, the successor macrostate $(\alpha^{\prime},t^{\prime})$ is obtained by a sequence of successive operations $\mathsf{step}$, $\mathsf{prune}$ and $\mathsf{normalize}$, where, roughly,

• •

$\mathsf{step}$ interprets $t$ as nodes on a reduced split-tree level and calculates the next level sets,

• •

$\mathsf{prune}$ removes the empty sets produced by $\mathsf{step}$, reassigning ranks in a specific way, and

• •

$\mathsf{normalize}$ just turns the ranking function obtained after $\mathsf{prune}$ into a bijection again.

Below, we formally define these operations ($\mathsf{step}$ and $\mathsf{prune}$ are illustrated in Figure 2).

First we describe $\mathsf{step}$, which constructs the next level of the reduced split-tree and passes each existing rank on to the respective right child. Let

[TABLE]

restricting for each state $q\in Q_{t}$ the successors to only those which are not reached by some other state located in a set to the left of $q$. Then, for each node $S_{i}$ let $\hat{S}_{2i-1}:=\Delta_{t}(S_{i},x)\cap F$ be the left child and $\hat{S}_{2i}:=\Delta_{t}(S_{i},x)\cap\overline{F}$ the right child, containing the accepting and non-accepting normalized successors, respectively. Let $\hat{\alpha}(2i):=\alpha(i)$ and $\hat{\alpha}(2i-1):=n+1$, i.e., the right children inherit the rank of the parent and the left children all get the same new maximal rank $n+1$, resulting in a pre-slice $(\hat{\alpha},\hat{t})$.

Intuitively, in the $\mathsf{prune}$ operation, all ranks that mark empty sets after $\mathsf{step}$ are relocated onto the closest non-empty set to the left (or removed, if no such set exists). When multiple ranks occupy the same set, then the smallest one is preserved. Ranks that moved to the left in this way and are not removed, indicate a good (green) event, whereas ranks which were removed indicate a bad (red) event.

Formally, let $x_{1}<x_{2}<\ldots<x_{\tilde{n}}$ be the increasing sequence of all indices such that $\hat{S}_{x_{j}}\neq\emptyset$. Then $\mathsf{prune}$ returns $(\tilde{\alpha},\tilde{t})$ with the tuple $\tilde{t}:=(\hat{S}_{x_{1}},\ldots,\hat{S}_{x_{\tilde{n}}})$ without empty sets, where $\tilde{\alpha}$ is defined as $\tilde{\alpha}(i):=\min\{\hat{\alpha}(j)\mid x_{i}\leq j<x_{i+1}\}$ with $x_{\tilde{n}+1}:=|\hat{t}|+1$.

The set of green ranks is given by $G:=\mathsf{img}(\tilde{\alpha})\cap\{\hat{\alpha}(j)\mid\hat{S}_{j}=\emptyset\}$, where $\mathsf{img}(\tilde{\alpha})$ denotes the image of $\tilde{\alpha}$. These are the ranks that mark empty sets after $\mathsf{step}$ and are not removed by $\mathsf{prune}$. The set of red ranks given by $R:=\mathsf{img}(\hat{\alpha})\setminus\mathsf{img}(\tilde{\alpha})$ contains the ranks that were not preserved during $\mathsf{prune}$. The set of active ranks is $A:=G\mathbin{\mathaccent 0{\cdot}\cup}R$. Let $k:=\min A$ (or $k:=|Q|+1$ if $A=\emptyset$) denote the dominating rank of the transition, i.e., the smallest active rank. We define the priority $p$ of the transition as $2k$ if $k\in G$ and $2k-1$ otherwise.

The function $\tilde{\alpha}$ might assign the same rank to several sets, and it might have gaps (unused rank values between used ones). So finally, $\mathsf{normalize}$ returns $(\alpha^{\prime},t^{\prime})$ with $t^{\prime}:=\tilde{t}$ and a final bijective ranking function $\alpha^{\prime}:[|t^{\prime}|]\to[|t^{\prime}|]$ such that $\tilde{\alpha}(j)<\tilde{\alpha}(k)\Rightarrow\alpha^{\prime}(j)<\alpha^{\prime}(k)$ for all $j,k\in\{1,\ldots,|t^{\prime}|\}$, i.e., a total order which is compatible with the preorder induced by $\tilde{\alpha}$. If there are several such ranking functions $\alpha^{\prime}$, then any of these works.

A TDPA $\mathcal{B}$ is obtained by taking the initial state $(\alpha_{0},t_{0})$ with $t_{0}:=(Q_{0}),\alpha_{0}(1):=1$ and a transition function that picks for each state a valid successor that satisfies the description above, and assigns the corresponding priority $p$ to the edge. Observe that by construction, the sequence of states visited along some word $w\in\Sigma^{\omega}$ from the initial state represents exactly the levels of $t^{rs}(\mathcal{A},w)$, marked with ranks.

Theorem 3.2**.**

For a given NBA with $n$ states, the TDPA obtained by the Muller-Schupp construction accepts the same language as the NBA, and its number of states is in $\mathcal{O}(n!^{2})$.

The correctness follows from the correctness of the generalized construction presented in Section 6. The claim on the state complexity directly follows from the upper bound given in [14, Proposition 2], and the bijection between the set of ranked slices and the set of ranked Safra trees presented in Section 5.

4 Sketch of the Safra Construction

In this section, we roughly illustrate the used structures and operations of the Safra construction along the lines of [11, 14], so that we can demonstrate its relationship with the Muller-Schupp construction in the next section. As before, $\mathcal{A}$ is an NBA with the usual components.

A Safra tree is a finite ordered tree with non-empty state-sets as labels. Usually, it is required that a parent is labelled by a strict superset of all states in its subtree and siblings are labelled by pairwise disjoint sets. We use the equivalent requirement that all labels in the tree are pairwise disjoint, i.e., refrain from listing states in the parent label which are already present in some descendant. One can easily reconstruct the “full” label set of a node wrt. the classical definition by taking the union of all the labels in its subtree. To obtain parity automata, each node of the Safra tree is associated with a number from $\{1,\ldots,n\}$, where $n$ is the number of nodes in the Safra tree [11]. These numbers satisfy the property that parent nodes have smaller numbers than their children, and a node has a smaller number than its right sibling. The numbers correspond to the ranks that we use in Section 3, and we therefore refer to Safra trees in combination with these numbers as ranked Safra trees. Two ranked Safra trees are shown in Figure 3 (and an intermediate tree in the middle).

In [14], a slightly different representation is used based on a later introduction record (LIR), which just lists the tree nodes in their introduction order, i.e., nodes appear in this list after parents and older siblings (in this representation, nodes have canonical names depending only on their position in the tree). Safra trees with LIR directly correspond to ranked Safra trees by annotating each tree node with its position in the LIR.

A transition on symbol $x\in\Sigma$ is constructed as follows (see Figure 3 for an example). First, for each label set $S$, the set $S^{\prime}:=\Delta(S,x)$ of successor states is calculated. After this, each node gets a fresh right-most child, and the accepting states in $S^{\prime}$, that is $S^{\prime}\cap F$, are moved into the label of this child. Then, disjointness is ensured by keeping of each state only the copy which is located at the deepest node along the leftmost branch where that state occurs (this stage is represented by the middle tree in Figure 3). If now some internal node has an empty label, but a non-empty subtree (a good event for the node), its subtree is collapsed into a single node by removing all descendants and moving the states in their labels into the parent label. Finally, all remaining sets that are labelled by $\emptyset$ are removed (being removed is a bad event for a node). In the following, we refer to good and bad events as green and red, respectively. The priority for the transition is derived from the green and red events, which are associated with the relative position of the corresponding nodes in the LIR. The LIR for the new tree is obtained by deleting removed nodes from the LIR and appending fresh nodes that remain in the resulting tree in arbitrary order.

5 From Safra-trees to ranked slices and back

In this section we state the key observation that was the starting point of this work: there is a bijection between the set of ranked slices and the set of ranked Safra trees. From a ranked Safra tree, one obtains the ranked slice by simply listing the nodes of the Safra tree by a depth-first post-order traversal (i.e., a parent processed after all its children). We formalize this relationship below, and then explain that the transitions defined in the Muller-Schupp construction and in the Safra construction are very similar, which then leads to the unified construction.

Let $(\alpha,t)$ be a ranked slice with $t=(S_{1},\ldots,S_{n})$. The tuple index of the parent of $S_{i}$ is the closest index to the right of $i$ that has a smaller rank and is formally defined as $\mathsf{\uparrow}(i):=\min_{i<k\leq n}\{k\mid\alpha(k)<\alpha(i)\}$. As we require by definition of ranked slices that the right-most position in the tuple always has rank 1, this is the only position in the tuple for which the parent is undefined. The ordered tree induced by $\mathsf{\uparrow}$, with siblings in tuple index order, is called the rank tree of $(\alpha,t)$. The tuple index of the left subtree boundary of $S_{i}$ is the closest index to the left with a smaller rank, and is denoted by $\mathsf{\leftarrow}(i):=\max_{1\leq k<i}\{k\mid\alpha(k)<\alpha(i)\}$ or [math] if no such index exists. It points to either the direct left sibling of $i$, or the left sibling of the closest ancestor, if one exists. Effectively, $\mathsf{\leftarrow}(i)$ is the closest neighbor to the left which is not a descendant of $i$. As children by definition are always to the left of their parents, every node at indices $\mathsf{\leftarrow}(i)+1,\ldots,i$ is in the subtree of $i$.

For an example, consider the tuple $(\{q_{3}\}^{4},\{q_{1}\}^{2},\{q_{2}\}^{3},\{q_{0}\}^{1})$, where the superscripts denote the assigned rank (e.g., $\alpha(1)=4$). The rightmost position $4$ of the tuple is the root of the tree. For the positions 2 and 3, which have rank 2 and 3 respectively, the next position to the right with a smaller rank is in both cases position 4, i.e., $\mathsf{\uparrow}(2)=\mathsf{\uparrow}(3)=4$. Finally, position 1 in the tuple has position 2 as parent, i.e., $\mathsf{\uparrow}(1)=2$. The discussed tuple is depicted with the parent edges at the bottom right of Figure 4. There is also one non-trivial left subtree boundary in this tuple, assigned by $\mathsf{\leftarrow}(3)=2$, i.e. index 2 is not in the subtree of index 3, and in this case is an actual left sibling of index 3.

We use the notation $\mathsf{\uparrow}_{\alpha}:=\alpha\circ\mathsf{\uparrow}\circ\alpha^{-1}$ to denote the parent rank of another rank directly, without mentioning the indices in the tuple. In the previous example, we have $\mathsf{\uparrow}_{\alpha}(4)=2$, and $\mathsf{\uparrow}_{\alpha}(2)=\mathsf{\uparrow}_{\alpha}(3)=1$. We identify the age-ranks $\alpha(i)$ as nodes of the tree, while each set $S_{i}$ determines the label of the node $\alpha(i)$, called hosted set. We write $S_{i}^{\downarrow}:=\bigcup_{k=\mathsf{\leftarrow}(i)+1}^{i}S_{k}$ for the subtree set of node $\alpha(i)$.

Definition 5.1**.**

Let safra2slice be the mapping which takes a ranked Safra tree and returns $(\alpha,t)$, with $t:=(S_{1},\ldots,S_{n})$ being the label sets of the nodes in depth-first post-order (i.e., a parent processed after all its children) traversal order and ranking $\alpha$ defined by the ranks of the corresponding Safra tree nodes.

Let slice2safra be the mapping which takes a ranked slice $(\alpha,t)$ and returns the ranked Safra tree given by the rank tree of $(\alpha,t)$, i.e. the tree structure defined by $\mathsf{\uparrow}$ and the ordering of siblings given by the order of the corresponding sets in $t$.

It is easy to see from the definitions that safra2slice and slice2safra are injective and return a valid ranked slice and ranked Safra tree, respectively. This implies that there exists a bijection between the sets of ranked Safra trees and ranked slices. It is also not very hard to see that the following holds (a proof can be found in Appendix A):

Lemma 5.2**.**

$\mathsf{safra2slice}$* and $\mathsf{slice2safra}$ are inverses of each other and provide a bijection between ranked Safra trees and ranked slices.*

As we have established that both constructions, Muller-Schupp and Safra, operate on essentially the same structures, from now on we talk about ranked slices and trees interchangeably. Using this relationship, one can take the same tree/slice and apply both the successor calculation of the Safra construction and of the Muller-Schupp construction to it. What one first notices, is that the resulting tree/slice is very similar or equal in many cases. This is owed to the fact that most operations in one construction have an equivalent operation in the other, just formulated for the other representation.

For example, moving accepting successor states into a fresh child node in Safra’s construction corresponds to splitting accepting successors from non-accepting ones during $\mathsf{step}$ in the Muller-Schupp construction, as in the successor tuple the new child (in the conceptual split-tree) gets a fresh, larger rank and by definition becomes the rightmost child in the rank tree of the resulting new slice. The normalization steps that make the successor sets pairwise disjoint also yield the same results. The ranks of nodes with green events in the Safra construction coincide with ranks of sets that signal green in the ranked slices, and ranks of Safra nodes with red events with ranks of sets that signal red. The removal of empty sets by $\mathsf{prune}$ and renumbering the ranks with $\mathsf{normalize}$ is the same as the removal of the corresponding nodes in the Safra tree and updating the LIR, i.e., the ranks of Safra nodes.

In fact, the only difference between the constructions is what happens with a tree node in case of a green event. Recall that in Safra’s construction, the whole subtree of a green node is collapsed to a single node. In the Muller-Schupp construction, the green ranks are those that end up on an empty set after $\mathsf{step}$, and that survive the $\mathsf{prune}$ operation, in which the ranks are moved to the next non-empty set to the left, and only the minimal ones are kept on each non-empty set. In the view of ranked trees, this corresponds to a green node absorbing its rightmost, uppermost child node into it, while keeping the rest of the subtree unchanged. See Figure 4 for an illustration.

After observing that both constructions differ in only a minor step and noticing that both yield correct (but possibly different) automata, it becomes apparent that the exact step performed for green events is not essential and there must be a more general mechanism to uncover. The construction we present in Section 6 results from this line of thought.

On the practical side, it is worth mentioning that the cost of switching between the representations using the presented bijection is negligible—the traversal of a ranked Safra tree to obtain a ranked slice is obviously possible in linear time. For the other direction there also exists a simple linear time algorithm (presented in Appendix B) that calculates the parent and left subtree boundary relation from the ranking $\alpha$.

6 The unified construction

In this section, we present a construction that builds on the Muller-Schupp construction from Section 3, and unifies it with Safra’s construction by adding another operation, called $\mathsf{merge}$, between $\mathsf{prune}$ and $\mathsf{normalize}$: $(\alpha,t)\xrightarrow{\mathsf{step}}(\hat{\alpha},\hat{t})\xrightarrow{\mathsf{prune}}(\tilde{\alpha},\tilde{t})\xrightarrow{\mathsf{merge}}(\check{\alpha},\check{t})\xrightarrow{\mathsf{normalize}}(\alpha^{\prime},t^{\prime})$. This new operation is nondeterministic, and can be instantiated in different ways. In particular, it can be instantiated trivially and thus corresponds to the Muller-Schupp construction, and it can be used to emulate the Safra construction.

We first describe the idea of $\mathsf{merge}$, and then give a formal definition. Assume that, after $\mathsf{step}$ and $\mathsf{prune}$ have been applied to some ranked slice $(\alpha,t)$, we have the pre-slice $(\tilde{\alpha},\tilde{t})$, and the dominating (minimal active) rank $k$ (determined by $\mathsf{prune}$, see Section 3). Then $\mathsf{merge}$ can collapse groups of neighbouring sets in the tuple, and preserves the minimum rank from each collapsed range, similar to $\mathsf{prune}$. In contrast to $\mathsf{prune}$, which “merges” one non-empty set with multiple empty sets in a deterministic manner, $\mathsf{merge}$ may actually take the union of multiple adjacent non-empty sets, depending on the ranks currently assigned to them.

The non-overlapping intervals of sets that are collapsed together are not uniquely determined in general. They only have to satisfy the constraints that no sets with rank smaller than the dominating rank $k$ are merged with anything else, and that the set with rank $k$ is not merged with anything to the right of it. These constraints are important for the correctness, and ensure that in the ranked Safra tree perspective, the nodes with rank smaller than $k$ do not change, and that the node with the dominating rank $k$ is not merged with sets outside of its subtree.

Formally, $\mathsf{merge}$ returns a pre-slice $(\check{\alpha},\check{t})$ obtained in the following way (see Figure 5 for an illustration). Let $I_{1},I_{2},\ldots,I_{n^{\prime}}$ be a sequence of sets partitioning the set of indices $\{1,\ldots,\tilde{n}\}$ in $\tilde{t}$ into adjacent groups, i.e., $\min I_{1}=1$, $\max I_{n^{\prime}}=\tilde{n}$ and for all $j>1$ we have $\min I_{j}=\max I_{j-1}+1$. This grouping should satisfy the following property for all $1\leq j\leq n^{\prime}$ and $l\in I_{j}$: if $\tilde{\alpha}(l)<k$, then $|I_{j}|=1$, and if $\tilde{\alpha}(l)=k$, then $\max I_{j}=l$. Then the pre-slice $(\check{\alpha},\check{t})$ is defined by the sets $\check{S}_{i}:=\bigcup_{j\in I_{i}}\tilde{S}_{j}$ and the ranking function $\check{\alpha}(i):=\min\{\tilde{\alpha}(j)\mid j\in I_{i}\}$ for all $i\in\{1,\ldots,n^{\prime}\}$, i.e., for each interval, the union of the sets and the smallest rank is taken.

As in the Muller-Schupp construction, $\mathsf{normalize}$ is applied to $(\check{\alpha},\check{t})$ to obtain the successor macrostate $(\alpha^{\prime},t^{\prime})$. This extended transition relation is used to obtain the transition-based deterministic parity automaton, as before.

An example showing how the choice of different merge strategies leads to different successor states is illustrated in Figure 6. Observe that we can recover the Muller-Schupp construction by using the identity function for $\mathsf{merge}$, or in other words, putting each index into its own interval, which is the finest partitioning of indices that satisfies the requirements on $\mathsf{merge}$. On the other hand, we can also take the coarsest compatible partitioning, i.e., minimize the number of intervals. We call this kind of update maximal collapse.

We can emulate a Safra-update by imposing some additional constraints on the intervals, ensuring that only the complete subtrees of nodes with green ranks are merged. More concretely, we require that intervals that are not singletons span exactly the nodes of the complete subtree that is rooted in a green rank in the view of the slice as ranked Safra tree. Note that for an index $\ell$ in the tuple, the subtree of the corresponding node in the ranked Safra tree corresponds to the interval that starts one step right of the left subtree boundary of $\ell$, and ends in $\ell$, that is, the interval $\mathsf{\leftarrow}(l)+1,\ldots,\ell$. Thus, for imitating the Safra merge rule, the intervals $I_{1},I_{2},\ldots,I_{n^{\prime}}$ from $\mathsf{merge}$ are the unique smallest intervals satisfying

[TABLE]

Proposition 6.1**.**

The operation $\mathsf{merge}$ can be instantiated such that the transitions of the constructed TDPA correspond to the transitions of the Muller-Schupp construction or to the transitions of the Safra construction.

Notice that for all merge rules except for the Muller-Schupp update, the relationship of ranked slices and consecutive levels of the reduced split-tree (see Section 3) breaks down. One can, however, reflect the merges also in the reduced split-tree by doing the merges of the corresponding sets on each level, which leads to an acyclic graph instead of a tree. This view is helpful in the correctness proof of the construction.

Theorem 6.2**.**

Let $\mathcal{A}$ be an NBA. Then a deterministic parity automaton $\mathcal{B}$, obtained by the described determinization construction, has at most $\mathcal{O}(n!^{2})$ states and recognizes the same language as $\mathcal{A}$.

The upper bound holds because the same macrostates are used as in the presented Muller-Schupp construction in Section 3. The correctness can be shown by a refinement of the original correctness proof of the Safra construction [13], and is given in Appendix C.

7 Discussion and Conclusion

We have presented a new variant of the Muller-Schupp construction for determinization of Büchi automata into parity automata, reducing the information stored in the macrostates to ordered tuples of disjoint sets annotated with ranks. These ranked slices are in bijection with ranked Safra trees, which leads to a general construction that can emulate the Muller-Schupp construction and the Safra-construction. This answers, in some sense, the question from [4] on the relation between the two types of constructions.

In general, one can obtain many different valid deterministic automata by choosing different deterministic transition functions that are compatible with the described successor relation. One can also imagine this as constructing a non-deterministic automaton with all permitted successors, and then pruning the edges arbitrarily, while preserving for each state only one outgoing transition for each symbol, to “carve” out a valid deterministic automaton.

This non-determinism comes from two sources. One degree of freedom in our construction comes from the different ways of assigning ranks (to new nodes, and when closing gaps resulting from deleted ranks). This freedom is already mentioned in [14]. But here the flexibility is just in the choice of the specific permutation, which still describes structurally the same tree in any case. The novel and in our opinion powerful degree of freedom in our construction is the possibility for different valid $\mathsf{merge}$ operations, which allows for a vastly larger pool of possible successors, as the results may describe structurally different trees. Furthermore, the smaller the smallest active rank, the more different a permitted successor may look like.

We have explicitly mentioned the merge strategies that lead to the Muller-Schupp and Safra constructions, and also have mentioned a third strategy, the maximal collapse rule that merges as many sets as possible (as shown in e.g. Figure 6). We also want to point out that, while fixing one such $\mathsf{merge}$-rule for the whole construction is the simplest implementation, the construction permits using any valid successor without the need to disambiguate the $\mathsf{merge}$ operation beforehand, i.e., picking the successor of a state from the set of permitted ones is a local choice. One may think of schemes where the successor is chosen dynamically, depending on the input or already computed information. For example, one can check whether a valid successor has already been constructed, and only add a new state according to a fixed policy if this is not the case. We have already implemented a prototype making use of such an optimization (among others) with encouraging results.

We also want to point out that the presented construction works equally well with transition-based Büchi automata as input, in which case the $\mathsf{step}$ operation separates states which are reached by at least one accepting transition from those that are not. One can easily verify that this does not impact the reasoning in the proofs.

It is also possible to adapt the construction to yield Rabin automata, such that the corresponding Safra construction as presented in [14] is subsumed. In this setting, however, the presentation of macrostates as ordered tuples of sets is less natural. Furthermore, in this setting the merges of sets needs to be restricted to subtrees of green nodes, because there is no total order of importance of nodes as provided by the ranks.

Appendix A Proof of the bijection between ranked Safra trees and ranked slices

In this section we provide the missing proof for Lemma 5.2. We make use of the following technical lemma to omit one direction of the proof, using the property that both functions are already known to be injective:

Lemma A.1**.**

Let $f:A\to B,g:B\to A$ be two injective functions and $g\circ f=\mathsf{id}_{A}$. Then it follows that $f$ and $g$ are inverse mappings of a bijection.

Proof A.2**.**

From injectivity of $g$ follows that $g$ has a left inverse $g^{li}$. Hence:

[TABLE]

As both are left inverses of each other, they are also right inverses of each other by definition and therefore $f^{-1}=g$ and $g^{-1}=f$.

Now we can show the actual statement:

See 5.2

Proof A.2**.**

As both mappings are injective, by Lemma A.1 it suffices to argue that $\mathsf{slice2safra}\circ\mathsf{safra2slice}$ returns the original ranked Safra tree to prove the statement.

Take a ranked Safra tree with $n$ nodes. Recall that a parent node always has a smaller rank than its children, and siblings to the right of a node have larger ranks than that node.

Construct the ranked slice $(\alpha,t)$ using $\mathsf{safra2slice}$ and then consider its rank tree. Clearly, both trees have the same number of nodes and the same set of labels. Also, nodes with the same label also have the same rank. What remains to be shown is the equality of the tree structure. Let $\mathsf{node}(S_{i})$ denote the tree node in the original ranked Safra tree that is labelled by set $S_{i}$ from $t$.

Notice that by the visiting order of the post-order traversal it is ensured that parent nodes, which have smaller assigned ranks, appear to the right of all their descendants in the tuple and thus closer ancestors of a node are listed earlier than further ancestors. Thus, the set $S_{j}$ of the parent $\mathsf{node}(S_{j})$ of some node $\mathsf{node}(S_{i})$ will be the closest set to the right of the set $S_{i}$ in the tuple $t$ which has a smaller rank. Hence, by definition of $\mathsf{\uparrow}$, the original tree is reconstructed. For the ordering of siblings, observe that if $\mathsf{node}(S_{i})$ is the left sibling of $\mathsf{node}(S_{j})$, then $\mathsf{node}(S_{j})$ is visited only after completing the subtree of $\mathsf{node}(S_{i})$ and hence $S_{j}$ appears later in the tuple. Hence, the rank tree obtained via $\uparrow$ from the ranked slice is exactly the original ranked Safra tree.

Appendix B From ranked slices to rank trees in linear time

It is easy to see that going from a ranked Safra tree to a ranked slice is possible in linear time, as $\mathsf{safra2slice}$ is just a depth-first traversal. In this section we show how to efficiently compute $\mathsf{slice2safra}$, i.e., how the rank tree can be obtained in linear time from a ranked slice, which can be useful in implementations of the presented determinization construction.

The parent and left subtree boundary relationships, which capture the tree structure of the ranked slice, can be computed using the following algorithm:

Lemma B.1**.**

unflatten* calculates the rank tree from a ranked slice $(\alpha,t)$ in linear time.*

Proof B.2**.**

Let $(\alpha,t)$ be a ranked slice with $t=(S_{1},\ldots,S_{n})$. The main loop is repeated exactly $n$ times. In each iteration one index is pushed onto the stack. All other loops are iterated at most $n$ times in total, as they require a non-empty stack and pop an element in each iteration. Hence, the algorithm completes in linear time. It remains to be shown that the resulting arrays $P$ and $L$ correspond to $\mathsf{\uparrow}$ and $\mathsf{\leftarrow}$.

In the first iteration of the main loop the stack is empty and hence only the index of the last set $S_{n}$ with rank $1$ (i.e., the root) is pushed. This index is never popped from the stack during the main loop, as is has the smallest rank, and in the last iteration of the clean-up loop is assigned [math] as left subtree boundary index and has an undefined parent. Therefore, the root is treated correctly.

Next we analyze under which conditions the assignments to $P$ and $L$ can be incorrect and show that they lead to a contradiction. Let $j$ and $k$ with $1\leq j<k\leq n$ be two indices. Notice that index $k$ is pushed onto the stack before $j$ by the main loop.

First consider the case that $\mathsf{\uparrow}(j)=k$.

For contradiction, assume that $k$ is popped from the stack before the loop iteration with $i=j$ ($i$ referring to the variable in the algorithm). This implies that there is an index $l$ with $j<l<k$, $\alpha(l)<\alpha(k)$ and $k$ being on top of the stack in the loop iteration with $i=l$. But as $\alpha(j)>\alpha(l)>\alpha(k)$ violates the assumption that $\mathsf{\uparrow}(j)=k$ by definition of $\mathsf{\uparrow}$, because then $l$ should be the parent of $j$.

Next, assume that $k$ is not on top of the stack in the iteration with $i=j$. Then there is an $l$ with $j<l<k$ and $\alpha(l)>\alpha(k)$ which is pushed onto the stack and stays there until $P(j)$ is assigned. As $\alpha(l)>\alpha(j)$, $j$ must be in a different subtree to the left of $l$. But then index $l$ must be removed in the inner loop during the iteration $i=j$, before $P(j)$ is assigned, which is a contradiction. Hence, we conclude that the parent array is assigned correctly.

Now, consider the case that $j=\mathsf{\leftarrow}(k)$.

First assume that $j=0$. Then there is no index with a smaller rank to the left of $k$ and hence the inner loop was not entered whenever $k$ was on top of the stack, so that $k$ remained on the stack during the main loop. But then $k$ will be assigned [math] as left subtree boundary in the clean-up loop.

Now assume that $j>0$, i.e., there exists a non-trivial left subtree boundary. Again, assume for contradiction that $k$ is popped before loop iteration with $i=j$. Then there was an index $l$ with $j<l<k$ such that $k$ was on top of the stack and $\alpha(l)<\alpha(k)$, so that $k$ was popped from the stack in the inner loop. By definition of $\mathsf{\leftarrow}$ this implies that $l$ is the left subtree boundary of $k$, violating the assumption.

Finally, assume that $k$ is not on top of the stack when $i=j$. Then some index $l$ with $j<l<k$ was pushed onto the stack with $\alpha(l)>\alpha(k)$ and in the main loop iteration with $i=j$ the last such index $l$ was assigned as parent of $j$, because $\alpha(j)>\alpha(l)$ (implied by the fact that $l$ remained on the stack). But then $\alpha(j)>\alpha(k)$, contradicting the assumption that $j$ is the left subtree boundary index of $k$, which must have a smaller rank. Hence we conclude that the left subtree boundary must also be assigned correctly, completing the proof.

Appendix C Correctness proof for the determinization construction

In this section, we provide the proof for the main result:

See 6.2

As discussed, the claim on the state complexity directly follows from the upper bound given in [14, Proposition 2], and the bijection between the set of ranked slices and the set of ranked Safra trees presented in Section 5.

Hence, it remains to be shown that an automaton $\mathcal{B}$ with transitions that satisfy the described successor relation of the determinization construction presented in Section 6 indeed recognizes the same language as $\mathcal{A}$.

For the rest of this section, fix some arbitrary word $w\in\Sigma^{\omega}$, NBA $\mathcal{A}$ and let $\mathcal{B}$ be the obtained TDPA.

C.1 From an accepting NBA run to an accepting TDPA run

To show that $\mathcal{B}$ accepts $w$ if there exists an accepting run in $\mathcal{A}$, we introduce the concept of the rank-profile of a state in a pre-slice $(\alpha,t)$, which is just the sequence of nodes in the corresponding ranked Safra tree starting from the root, down to the node labelled by the set containing the state. The sequence is strictly ascending, because children have larger ranks than their parents. Formally, the rank-profile $\mathsf{rp}:Q_{t}\to[n]^{*}$ maps each state $q$ to a sequence $a_{1}a_{2}\ldots a_{m}$ such that $a_{1}=\alpha(n)=1$, $a_{m}=\alpha(q)$, and $a_{i-1}=\mathsf{\uparrow_{\alpha}}(a_{i})$ is the rank of the parent of the node with rank $a_{i}$, for all $i>1$. Consider, for example, the ranked slice $(\{q_{3}\}^{4},\{q_{1}\}^{2},\{q_{2}\}^{3},\{q_{0}\}^{1})$. The rank profile of $q_{3}$ is $1,2,4$, and the rank profile of $q_{2}$ is $1,3$. Notice that rank-profiles have at most the length $|Q|$ and are fully determined by the ascending set of ranks, so we can interpret the profile also as a set of ranks.

Let $a=a_{1}\ldots a_{n_{a}},b=b_{1}\ldots b_{n_{b}}$ be two rank profiles with $m:=\min(n_{a},n_{b})$ being the length of the shorter one. We say that $a$ is better than $b$ and write $a\prec b$, if $a_{1}\ldots a_{m}<b_{1}\ldots b_{m}$ wrt. lexicographic order, or if $a_{1}\ldots a_{m}=b_{1}\ldots b_{m}$ and $n_{a}>n_{b}$. So the “better than” relation almost corresponds to “being smaller in the lexicographic ordering” but with the difference that in our ordering a strict prefix of another rank profile is not better but worse. This definition is useful because of the following property:

Lemma C.1**.**

Let $(\alpha,t)$ be a ranked slice, and $p,q\in Q_{t}$.

Then $\mathsf{idx}(p)<\mathsf{idx}(q)\Longleftrightarrow\mathsf{rp}(p)\prec\mathsf{rp}(q)$.

Proof C.2**.**

If $\mathsf{idx}(p)<\mathsf{idx}(q)$, then, by definition of the rank tree, either $p$ is in the subtree of $\alpha(q)$ or in the subtree of some left sibling of $q$ or one of its ancestors. In the first case, the rank profile of $p$ must agree with the rank profile of $q$ on the whole length of the latter and then, as $p$ is a descendant, there must be at least one additional node along the branch leading to $p$ from $q$, i.e., the rank profile is longer. Hence, $\mathsf{rp}(p)\prec\mathsf{rp}(q)$. In the second case, the rank profiles of $p$ and $q$ must agree on some prefix up to their latest common ancestor, whereas afterwards the rank profile of $p$ continues with a node at the root of some different subtree, which is located more to the left in the rank tree and has a smaller rank. But then the rank profile is lexicographically smaller and again we have $\mathsf{rp}(p)\prec\mathsf{rp}(q)$. Clearly, reversing this case analysis shows the other direction.

The $k$-cut of a rank-profile $a$ is a prefix of the rank-profile including all ranks less than $k$ and, if possible, the first rank which is larger than or equal to $k$. Formally, $k\text{-}\mathsf{cut}(a_{1}\ldots a_{n}):=a_{1}\ldots a_{i}$ with $i:=\min(\{n\}\cup\{i\mid a_{i}\geq k\})$. Consider, for example, the rank profile $1,2,4$. For $k\geq 3$, the $k$-cut is the complete profile $1,2,4$, the $2$-cut is $1,2$, and the $1$-cut is $1$. The ordering $\preceq_{k}$ compares the $k$-cuts of two rank profiles, i.e., for rank profiles $a$ and $b$, $a\preceq_{k}b$ iff $k\text{-}\mathsf{cut}(a)\preceq k\text{-}\mathsf{cut}(b)$ and consequently, $a=_{k}b$ iff $a\preceq_{k}b$ and $b\preceq_{k}a$. For example, $1,2,4=_{2}1,2,5$, but $1,2,4\prec_{3}1,2,5$.

We write $k\text{-}\mathsf{cut}(q)$ for $k\text{-}\mathsf{cut}(\mathsf{rp}(q))$. This notion is useful when we analyze how the rank profile can change over time in case that the smallest rank that is active infinitely often is $k$.

In the presentation of the construction in Sections 3 and 6 it was specified that the rank assigned to the left child sets during the $\mathsf{step}$ operation is the same fresh rank, and only after $\mathsf{normalize}$ all sets have different ranks. To simplify the reasoning in the proofs, in the following we assume that the left child sets all get fresh and unused, but already different ranks. In this case, $\mathsf{normalize}$ only closes “gaps” due to removed ranks. It is easy to see, that both formulations are equivalent, but this variant has the advantage that the rank-tree (and also rank-profiles) is also defined on all intermediate pre-slices and that $\mathsf{normalize}$ never makes the rank assigned to a set larger than before.

We start by showing that the constructed DPA $\mathcal{B}$ accepts all words that are accepted by the NBA $\mathcal{A}$.

Lemma C.3**.**

$w\in L(\mathcal{A})\implies w\in L(\mathcal{B})$**

Proof C.4**.**

Let $\rho=q_{0}q_{1}\ldots$ be an accepting run of $\mathcal{A}$ on $w$. Take the run of $\mathcal{B}$ on $w$ and consider its sequence of ranked slices $s_{0},s_{1},\ldots$ with $s_{i}=(\alpha_{i},t_{i})$. Let $p_{0},p_{1},\ldots$ be the sequence of rank-profiles such that $p_{i}=\mathsf{rp}(q_{i})$ are the rank profiles of states along the run, let $k_{0},k_{1},\ldots$ be the sequence of dominating ranks, where $k_{i}$ is the dominating rank in the transition from $s_{i}$ to $s_{i+1}$, let $k$ be the smallest $k_{i}$ appearing infinitely often in this sequence, and finally, let $c_{i}:=k_{i}\text{-}\mathsf{cut}(p_{i})$ and $m_{i}:=\max c_{i}$ be the $k_{i}$-cuts of the rank profiles and the last rank along those prefixes, respectively. The proof is structured as follows:

First, we show that $p_{i}\succeq_{k_{i}}p_{i+1}$ holds in every transition. 2. 2.

This implies that for some time $i_{0}$, $p_{i}=_{k}p_{i+1}$ must hold for all $i>i_{0}$. 3. 3.

We show that the last ranks $m_{i}$ of the $k_{i}$-cuts $c_{i}$ must be $\geq k$ for all $i>i_{0}$. 4. 4.

Finally, we show that rank $k$ cannot be red after $i_{0}$ and thus must be inf. often green.

1: Pick some time $i$ and consider the transition from $i$ to $i+1$.

Notice that regardless of the current dominating rank $k_{i}$, the rank profile $p_{i}$ cannot get worse (i.e., increase) during $\mathsf{normalize}$ or $\mathsf{step}$. For $\mathsf{normalize}$ this is easy to see, because by definition it must preserve the relative ordering and only closes the unused rank “gaps” after removal of empty sets and eventual merges. Hence it can make a rank profile only lexicographically smaller in each position by reassigning ranks, without changing the length. For $\mathsf{step}$, observe that if $q_{i+1}\in\Delta_{t_{i}}(q_{i},w(i+1))$, then $\mathsf{step}$ either puts $q_{i+1}$ into a set with the same rank as before (right branch) or, if $q_{i+1}$ is accepting (left branch), moves it into a child wrt. the rank tree, thereby increasing the length of the rank profile. If $q_{i+1}\not\in\Delta_{t_{i}}(q_{i},w(i+1))$, then, by definition of the restricted transition relation $\Delta_{t_{i}}$, $q_{i+1}$ must have a predecessor $q_{i}^{\prime}$ in a set with lower tuple index. By Lemma C.1 this implies that $\mathsf{rp}_{\hat{t}_{i}}(q_{i+1})\preceq\mathsf{rp}_{t_{i}}(q_{i}^{\prime})\prec\mathsf{rp}_{t_{i}}(q_{i})$. Therefore, the $\mathsf{step}$ operation also can only make the rank profile better.

As we have the dominating rank $k_{i}$, it means that no rank $<k_{i}$ was red or green, which means for the rank profile $p_{i}$ that no rank $<k_{i}$ marked an empty set after $\mathsf{step}$ or was overwritten during $\mathsf{prune}$. Also, $\mathsf{merge}$ may not modify sets with ranks $<k_{i}$. Hence, if $m_{i}<k_{i}$, then clearly the $k_{i}$-cut $c_{i}$ is not influenced in the transition.

If $m_{i}\geq k_{i}$, notice that regardless whether $k_{i}$ was red or green, at least one rank was removed during $\mathsf{prune}$. If $k_{i}$ itself was red, then all sets with ranks $>k_{i}$ will be reassigned a smaller rank to close the gap. If $k_{i}$ was green, it means that it has overwritten some larger rank during $\mathsf{prune}$. If the overwritten rank was $m_{i}$, then the $k_{i}$-cut decreased directly. Otherwise, some other rank was overwritten and the set with rank $m_{i}$ either keeps the same rank during $\mathsf{normalize}$ (if $m_{i}$ was smaller than the overwritten rank), or it will be reassigned to smaller rank (if it was larger). Neither $\mathsf{prune}$ nor $\mathsf{merge}$ can make the $k_{i}$-cut shorter than before, as for $\mathsf{prune}$ this would imply that a rank $<k_{i}$ was green and for $\mathsf{merge}$, that it collapses sets with ranks $<k_{i}$, which is forbidden.

2: There is some time $i^{\prime}$ after which no rank $<k$ is dominating again. After that, we have $p_{i}\succeq_{k}p_{i+1}$ for all $i>i^{\prime}$, as $p_{i}\succeq_{k^{\prime}}p_{i+1}$ implies that $p_{i}\succeq_{k}p_{i+1}$ for all $k^{\prime}>k$ (if one sequence is not lexicographically larger than the other, clearly this also applies to their prefixes). Hence, eventually, after some $i_{0}>i^{\prime}$ we have that $p_{i}=_{k}p_{i+1}$ for all $i>i_{0}$, i.e., the $k$-cut prefix eventually stabilizes and the rank profile then can only change at positions after this prefix.

3: Next, we show that $m_{i}\geq k$ for all $i>i_{0}$. For contradiction, assume that $m_{i}<k$ at some time $i>i_{0}$. Observe that the accepting run $\rho$ visits an accepting state $q_{F}$ infinitely often. This means, that eventually $q_{F}$ goes into the left child set during $\mathsf{step}$, which would either make $m_{i}$ (which is $<k$ by assumption) green, if the right child set is empty, or otherwise it would make the $k$-cut longer, violating either the fact that no rank $<k$ is active after $i_{0}$, or that the $k$-cut does not change anymore after $i_{0}$.

4: Finally, observe that $k$ cannot be red after $i_{0}$. If $k$ was red after $i_{0}$, it means that it was either overwritten by some smaller green rank, which we excluded by choice of $k$ and $i_{0}$, or it would mark an empty set after $\mathsf{step}$ and be removed during prune, which is also not possible, because if a rank is removed not due to being overwritten, it means that all sets to the left were empty, whereas some set must contain the current state of the run $\rho$, and it cannot be to the right of $k$ because $m_{i}\geq k$.

As $k$ is active infinitely often and cannot be red after $i_{0}$, it can only be red finitely often and must be green infinitely often, which implies that the smallest assigned priority is even and $\mathcal{B}$ accepts $w$.

C.2 From an accepting TDPA run to an accepting NBA run

To show the other direction, it is convenient to define the notion of the run-DAG. Intuitively, the run-DAG can be obtained from the reduced split-tree (see Section 3) by applying the corresponding $\mathsf{merge}$ operation on each level of the tree (i.e., merging the corresponding sets and redirecting the edges to the new union set), before constructing the next level.

Definition C.5**.**

Let $w\in\Sigma^{\omega}$ and $s_{0},s_{1},\ldots$ with $s_{i}=(\alpha_{i},t_{i})$ the sequence of macrostates on $w$. The run-DAG of $\mathcal{B}$ on $w$ is defined as follows. Level $i$ of the DAG has the sets $S_{i,1},\ldots,S_{i,n}$ of the tuple $t_{i}$ as nodes. An edge $S_{i,j}\to S^{\prime}_{i+1,j^{\prime}}$ exists between sets on two adjacent levels $i$ and $i+1$ of the DAG, if the target set contains a non-trivial subset of normalized successors of the source set, or formally, if $\emptyset\neq\Delta_{t_{i}}(S_{i,j},w(i))\subseteq S^{\prime}_{i+1,j^{\prime}}$. The edge is marked (written $S_{i,j}\overset{M}{\to}S^{\prime}_{i+1,j^{\prime}}$), if $\Delta_{t_{i}}(S_{i,j})\cap S^{\prime}_{i+1,j^{\prime}}\subseteq F$, i.e., if it contains no non-accepting normalized successors from the source set. Otherwise, it is unmarked. An infinite path in the run-DAG is a bad path, if it contains only unmarked edges.

See Figure 7 for an illustration of the relationship of the determinization transitions and the run-DAG. We also need the following related definitions, collected here for reference:

Definition C.6**.**

Let $w\in L(\mathcal{B})$ and let $k$ be the smallest rank that is infinitely often green and finitely often red during the run of $\mathcal{B}$ on $w$, i.e. the rank witnessing the acceptance.

Let $i_{0}$ be some time after which no rank $<k$ is ever active again and $k$ is never red again.

Let $r_{i}$ denote the tuple index of the set with rank $k$ at time $i$, and let $l_{i}<r_{i}$ be the index of the bad left neighbor, defined as the maximal index less than $r_{i}$ such that there is a bad path of the run-DAG starting in the set $S_{i,l_{i}}$ (if no such left bad neighbor exists, let $l_{i}:=0$).

Finally, let $\mathsf{good}(i):=\bigcup_{j=l_{i}+1}^{r_{i}}S_{i,j}$.

Intuitively, if the DPA accepts a word, this means that the smallest rank $k$ which is infinitely often active is only finitely often red, and therefore will not be reassigned to a completely unrelated set of states in the ranked slices. We show that $k$ must eventually mark sets containing states of at least one accepting run infinitely often. Unfortunately, considering only the sets with rank $k$ in isolation is not sufficient to verify that this is the case, but the following Lemma C.7 gives us a sequence of “checkpoints” and sets such that we can obtain an infinite sequence of suitable pieces to construct an accepting NBA run using König’s Lemma. An illustration of this technical result is found in Figure 8.

Lemma C.7**.**

Let $w,i_{0}$ and $\mathsf{good}(i)$ be defined as in Definition C.6. Then for every time $i\geq i_{0}$ it holds that $\mathsf{good}(i)\neq\emptyset$, and there is some $i^{\prime}>i$ such that for every $q\in\mathsf{good}(i^{\prime})$ there is some $p\in\mathsf{good}(i)$ such that there is a path from $p$ to $q$ that is labelled by the substring $w(i)\ldots w(i^{\prime}-1)$ of $w$ and visits at least one accepting state.

Proof C.8**.**

Fix a time $i\geq i_{0}$ and let $k$, $r_{i}$ and $l_{i}$ also be defined as in Definition C.6.

Clearly, $\mathsf{good}(i)$ is not empty, as it at least contains the set $S_{i,r_{i}}$. Notice that by choice of time $i_{0}$ and rank $k$, the set with rank $k$ will never be merged together with some set to the right, i.e. a set with index $>r_{i}$, as this would violate the constraints of $\mathsf{merge}$ (because after $i_{0}$ no rank $<k$ can be active). For the same reason, it will also be never merged with its left subtree boundary set (if any), which by definition has a smaller rank and therefore must be preserved unchanged.

Next, observe that the set with rank $k$ can also never be merged with a set that lies on a bad path (and also cannot be a bad path itself), because lying on a bad path means that during $\mathsf{step}$ the set of non-accepting normalized successors (the right child set) would never become empty (leading to the unmarked edges in the run-DAG), hence it would always inherit the rank $k$ and forever prevent $k$ from becoming green (which requires the right successor set $\Delta_{t_{i}}(S_{i,r_{i}},w(i))\cap\overline{F}$ to be empty), contradicting the choice of $k$.

As after time $i_{0}$ no rank $<k$ will be active again, it means that the left subtree boundary set of $k$ (if it exists) will be neither red nor green ever again. But this implies, that in $\mathsf{step}$ it always has a non-empty set of non-accepting successor states, which inherits its rank and therefore this set, by definition, must lie on a bad path in the run-DAG. Hence, $l_{i}\geq\mathsf{\leftarrow}_{t_{i}}(r_{i})$.

This motivates the definition of $\mathsf{good}(i):=\bigcup_{j=l_{i}+1}^{r_{i}}S_{i,j}$ as the union of all sets whose successors could (in principle) be merged with the successors of $S_{i,r_{i}}$ without violating the assumptions.

As, by definition, no set contained in $\mathsf{good}(i)$ can lie on a bad path, it means that eventually every path of the run-DAG starting in some set inside $\mathsf{good}(i)$ must either terminate or eventually go through a marked edge. Pick some $i^{\prime}>i$ such that this is the case.

Observe that tracing the left and right boundary indices $l_{i}$ and $r_{i}$ over time gives us an interval $(l_{i},r_{i}]$ of indices for each level of the run-DAG such that no edge in the run-DAG from outside this interval can ever go inside this interval (if an edge enters from the left, then it contains a bad path and if an edge enters from the right, then the set with rank $k$ is merged with sets to the right, both cases we excluded).

For this reason, every state $q\in\mathsf{good}(i^{\prime})$ must have been reached from some state $p\in\mathsf{good}(i)$. As every path of the run-DAG starting in a set contained in $\mathsf{good}(i)$ must go through at least one marked edge to reach a set in $\mathsf{good}(i^{\prime})$, it means that every path from a state $p\in\mathsf{good}(i)$ to some state $q\in\mathsf{good}(i^{\prime})$ agreeing with the run-DAG must contain at least one accepting state, because a run-DAG edge is only marked, if only accepting successors of the source set end up in the target set of the edge.

Using this result, we can show how an accepting run of the NBA can be constructed from an accepting run of the DPA:

Lemma C.9**.**

$w\in L(\mathcal{B})\implies w\in L(\mathcal{A})$**

Proof C.10**.**

Let $w\in L(\mathcal{B})$, rank $k$, time $i_{0}$ and sets $\mathsf{good}(i)$ as defined in Definition C.6.

Then, by Lemma C.7, there is a set $\mathsf{good}(i_{0})$ that contains the current set with rank $k$ and thus is non-empty, and furthermore has the property that there exists some $i_{1}>i_{0}$ such that $\mathsf{good}(i_{1})$ also is non-empty and all states in $\mathsf{good}(i_{1})$ are reached from at least one state in $\mathsf{good}(i_{0})$ by some path that visits some accepting state. By iteratively using Lemma C.7, we can construct an infinite sequence of times $i_{0},i_{1},i_{2},\ldots$ such that every pair of times $i_{j}$ and $i_{j+1}$ satisfies these properties.

We now can construct a finitely branching infinite DAG in which the edges are labelled by finite run segments of the NBA. Level 0 of the DAG has one node for each initial state of the NBA. For $j\geq 1$, level $j$ has one node for each state in $\mathsf{good}(i_{j-1})$. From level [math] to level $1$, there is an edge from $q_{0}$ to $q$ if there is a run of $\mathcal{A}$ from $q_{0}$ to $q$ on the input $w(0)\cdots w(i_{0}-1)$. For $j\geq 1$, there is an edge from $p\in\mathsf{good}(i_{j-1})$ on level $j$ to $q\in\mathsf{good}(i_{j})$ on level $j+1$, if there is a run from $p$ to $q$ on the input $w(i_{j-1})\cdots w(i_{j}-1)$ that visits an accepting state. Label the edge by this run. By Lemma C.7, for each $q$ on level $j+1$ there is some $p$ on level $j$ such that there is an edge from $p$ to $q$.

By König’s lemma, there is an infinite path through this DAG starting on level 0. The concatenations of edge labels of this path yields a run of $\mathcal{A}$ on $w$ by construction. Starting from level 1, all edge labels contain at least one accepting state, and therefore this run must be accepting.

By Lemmas C.3 and C.9, we have shown that $L(\mathcal{A})=L(\mathcal{B})$, which completes the proof of Theorem 6.2.