Abstract 1 Introduction 2 Basic notions 3 Problem formulation 4 The dichotomy game 5 Intuitions 6 Soundness 7 Auxiliary game 8 Completeness 9 Definability of ranks in MSO 10 Closure ordinals 11 Conclusions References

A Dichotomy Theorem for Ordinal Ranks in MSO

Damian Niwiński ORCID Institute of Informatics, University of Warsaw, Poland Paweł Parys ORCID Institute of Informatics, University of Warsaw, Poland Michał Skrzypczak ORCID Institute of Informatics, University of Warsaw, Poland
Abstract

We focus on formulae X.φ(Y,X) of monadic second-order logic over the full binary tree, such that the witness X is a well-founded set. The ordinal rank rank(X)<ω1 of such a set X measures its depth and branching structure. We search for the least upper bound for these ranks, and discover the following dichotomy depending on the formula φ. Let ηφ be the minimal ordinal such that, whenever an instance Y satisfies the formula, there is a witness X with rank(X)ηφ. Then ηφ is either strictly smaller than ω2 or it reaches the maximal possible value ω1. Moreover, it is decidable which of the cases holds. The result has potential for applications in a variety of ordinal-related problems, in particular it entails a result about the closure ordinal of a fixed-point formula.

Keywords and phrases:
dichotomy result, limit ordinal, countable ordinals, nondeterministic tree automata
Copyright and License:
[Uncaptioned image] © Damian Niwiński, Paweł Parys, and Michał Skrzypczak; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Automata over infinite objects
; Theory of computation Tree languages
Related Version:
Full Version: https://arxiv.org/abs/2501.05385
Acknowledgements:
The authors would like to thank Marek Czarnecki for preliminary discussions on related subjects.
Funding:
All authors supported by the National Science Centre, Poland (grant no. 2021/41/B/ST6/03914).
Editors:
Olaf Beyersdorff, Michał Pilipczuk, Elaine Pimentel, and Nguyễn Kim Thắng

1 Introduction

The concept of well-founded relation plays a central role in foundations of mathematics. It gives rise to ordinal numbers, which underlie the basic results in set theory, for example that any two sets can be compared in cardinality. Well-foundedness is no less important in the realm of computer science, where it often underlies the proofs of termination of non-deterministic processes, especially when no efficient bound on the length of a computation is known. In such cases, the complexity of possible executions is usually measured using an ordinal called rank. Such a rank can be seen as a measure of the depth of the considered partial order, taking into account suprema of lengths of possible descending chains. Estimates on a rank can provide upper-bounds on the computational complexity of the considered problem [26].

In this work, we adopt the perspective of mathematical foundations of program verification and model-checking. We focus on the monadic second-order logic (MSO) interpreted in the infinite binary tree (with the left and right successors as the only non-logical predicates), which is one of the reference formalisms in the area [29]. The famous Rabin Tree Theorem [25] established its decidability, but – half a century after its introduction – the theory is still an object of study. On one hand, it has led to numerous extensions, often shifting the decidability result far beyond the original theory (see e.g. [4, 24]). On the other hand, a number of natural questions regarding Rabin’s theory remain still open, including a large spectrum of simplification problems. For example, we still do not know whether we can decide if a given formula admits an equivalent form with all quantifiers restricted to finite sets. Similar questions have been studied in related formalisms like μ-calculus or automata; for example if we can effectively minimise the Mostowski index of a parity tree automaton [11, 15], or the μν-alternation depth of a μ-calculus formula [5].

On positive side, some decidability questions have been solved by reduction to the original theory. For example, it has been observed [22] that for a given formula φ(X), the cardinality of the family of tuples of sets X satisfying φ(X) can be computed; this cardinality can be either finite, 0, or 𝔠. Later on, Bárány, Kaiser, and Rabinovich [3] proved a more general result: they studied cardinality quantifiers κX.φ(Y,X), stating that there are at least κ distinct sets X satisfying φ(Y,X), and showed that these quantifiers can be expressed in the standard syntax of MSO; thus the extended theory remains decidable.

In the present work, instead of asking how many sets X witness to the formula X.φ(Y,X), we ask how complex these witnesses must be in terms of their depth-and-branching structure. A set X of nodes of a tree is well-founded if it contains no infinite chain with respect to the descendant order. In this case, a countable ordinal number rank(X) is well defined (see Section 2 below); intuitively, the smaller rank(X), the simpler the set X is, in terms of its branching structure.

We consider formulae of the form X.φ(Y,X), where φ is an arbitrary formula of MSO (it may contain quantifiers). We assume that, whenever the formula is satisfied for some valuation of variables Y, the value of X witnessing the formula is a well-founded set. Note that well-foundedness of a set is expressible in MSO (it suffices to say that each branch contains only finitely many nodes in X), hence the requirement can be expressed within φ. For a fixed formula as above, we ask what is the minimal ordinal ηφ, such that the rank of a witness can be bounded by ηφ,

ηφ=defsupYminXrank(X), (1.1)

where Y and X range, as expected, over the values satisfying φ(Y,X).

Since ηφ is a supremum of countable ordinals, its value is at most ω1 (the least uncountable ordinal). It can be achieved, for example, by the formula “X=Y and Y is a well-founded set”, as there are well-founded sets of arbitrarily large countable ranks. On the other hand, for each pair of natural numbers (k,l), one can construct a formula φ with rank ηφ=ωk+l in an analogous way to Czarnecki [12], see Lemma 9.4 below. The main result of this work shows that no other ordinals can be obtained:

Theorem 1.1.

For any formula X.φ(Y,X) as above, the ordinal ηφ is either strictly smaller than ω2 or equal to ω1. Moreover, it can be effectively decided which of the cases holds. In the former case, it is possible to compute a number N such that ηφ<ωN.

We also show that, in contrast to the aforementioned cardinality quantifiers, the property that rank(X) is smaller than ω2 cannot be expressed directly in MSO (see Corollary 9.3).

The proof of Theorem 1.1 develops the game-based technique used previously to characterise certain properties of MSO-definable tree languages (see e.g. [9, 28]). Each application of this technique requires a specific game, designed in a way which reflects the studied property. The game should have a finite arena and be played between two perfectly-informed players and . The winning condition of the game is given by a certain ω-regular set. Then, the seminal result of Büchi and Landweber [8] yields that the game is determined and the winner of this game can be effectively decided. The construction of the game is such that a winning strategy of each of the players provides a witness of either of the considered possibilities: if wins then ηφ=ω1 and if wins then ηφ<ωN for some computable N. The crucial difficulty of this approach lies in a proper definition of the game, so that both these implications actually hold.

Related work

In the context of μ-calculus, one asks how many iterations are needed to reach a fixed point; this aspect concerns complexity of model checking (cf. [7, 14]), as well as expressive power of the logic (cf. [7, 6]). Recall that, in an infinite structure, a least fixed point μX.F(X) is in general reached in a transfinite number of iterations: ,F(),,Fα(),, where, for a limit ordinal α, Fα()=ξ<αFξ(). It is therefore natural to ask if, for a given formula, one can effectively find a closure ordinal ηF, such that, in any model, the fixed point can be reached in ηF, but in general not less, iterations. Fontaine [18] effectively characterised the formulae such that in each model the fixed point is reached in a finite number of steps. Czarnecki [12] observed that some formulae have no closure ordinals but, for each ordinal η<ω2, there is a formula whose closure ordinal is η. He also raised the following question.

Question 1.2 (Czarnecki [12]).

Is there a μ-calculus formula of the form μX.F(X) that has a closure ordinal ηFω2?

Gouveia and Santocanale [19] exhibited an example of a formula with an essential alternation of the least and greatest fixed-point operators whose closure ordinal is ω1; clearly this limit can be achieved only in uncountable models. In general, it remains open whether a formula μX.F(X) of the μ-calculus may have a countable closure ordinal ηFω2. Afshari and Leigh [2] claimed a negative answer for formulas of the alternation-free fragment of μ-calculus; however, as the authors have later admitted [1], the proof contained some gaps. In a recent paper [1], Afshari, Barlucchi, and Leigh update the proof and extend the result to formulae of the so-called Σ-fragment of the μ-calculus. More specifically, the authors consider systems of equations X1=F1(X1,,Xn),,Xn=Fn(X1,,Xn), where the formulae Fi may contain closed sub-formulae of the full μ-calculus, but the variables Xi do not fall in the scope of any fixed-point operators. The authors show that if a countable number of iterations η suffice to reach the least fixed point of such a system in any Kripke frame then η<ω2. (Note that, by Bekič principle, each component of such a solution can be expressed by a single formula with the nested μ-operators.)

As a direct consequence of our result, we obtain an alternative proof for formulae of the form μX.F(X), where X does not fall in the scope of any fixed-point operator, but arbitrary closed subformulae may appear in F. (This corresponds to the case of n=1 in the equation system of [1].) We show that no such formula has a closure ordinal ηF satisfying ω2ηF<ω1, and moreover, it can be decided whether ηF<ω2; see Section 10. This is achieved via a well-known reduction of the μ-calculus to the MSO theory of the binary tree, based on the tree-model property [7], and a natural encoding of a tree model.

In the studies of topological complexity of MSO-definable tree languages, it has been also observed that dichotomies may help to solve decision problems. An open problem related to the aforementioned question of definability with finite-set quantifiers, is whether we can decide if a tree language belongs to the Borel hierarchy (in general, it need not). A positive answer is known if a tree language is given by a deterministic parity automaton [23], based on the following dichotomy: such a language is either Π11-complete (very hard), or on the level Π30 (relatively low) of Borel hierarchy. Skrzypczak and Walukiewicz [28] gave a proof in the case when a tree language is given by a non-deterministic Büchi tree automaton, inspired by a rank-related dichotomy conjectured in the previous work of the first author [27, Conjecture 4.4]. There, an ordinal has been associated with each Büchi tree automaton, and it turns out (in view of [28]) that this ordinal either equals ω1 or is smaller than ω2, in which case the tree language is Borel. It should be mentioned that a procedure to decide if a Büchi definable tree language is weakly definable was given earlier by Colcombet et al. [10].

Relation between ordinals and automata has been also considered in the studies of automatic structures. In particular, Delhommé [13] showed that automatic ordinals are smaller than ωω while tree-automatic ordinals (defined in terms of automata on finite trees) can go higher, but not above ωωω. Later, Finkel and Todorcevic [17] showed that ω-tree automatic ordinals are smaller than ωωω as well. These results may appear in contrast with our more restrictive bound of ω2; however, representation by automatic structures is in general more powerful than expressibility in MSO, so the two approaches are not directly related.

2 Basic notions

={0,1,2,} denotes the set of natural numbers. We use standard notation for ordinal numbers, with 0 being the least ordinal number, ω being the least infinite ordinal, and ω1 the least uncountable ordinal. Although ω and coincide as sets, we distinguish the two notations to emphasise the perspective.

Words.

An alphabet A is any finite non-empty set, whose elements are called letters. A word over A is a finite sequence of letters w=w0wn1, with wiA for i<n, and n being the length of w. The empty word, denoted ε, is the unique word of length 0. By uv we denote the concatenation of words u=u0un1 and v=v0vm1, that is, uv=u0un1v0vm1.

A denotes the set of all finite words over the alphabet A, while Aω denotes the set of all ω-words over A, that is, functions α:A. If αAω is an infinite word and n then by αn we denote the finite word consisting of the first n letters of α, that is, α0αn1A.

Trees.

Let 𝙻 and 𝚁 denote two distinct letters called directions. For a direction d{𝙻,𝚁}, the opposite direction is denoted d¯d. Words over the alphabet {𝙻,𝚁} are called nodes, with the empty word ε often called the root. An ω-word α{𝙻,𝚁}ω is called an infinite branch. A node u is called the parent of its children u𝙻 and u𝚁.

A (full infinite binary) tree over an alphabet A is a function t:{𝙻,𝚁}A, assigning letters t(u)A to nodes u{𝙻,𝚁}. The set of all trees over A is denoted TrA. A subtree of a tree tTrA in a node u{𝙻,𝚁} is the tree tu over A defined by taking tu(v)=t(uv).

Automata.

Instead of working with formulae of MSO, we use another equivalent formalism, namely non-deterministic parity tree automata [29]. An automaton is a tuple 𝒜=(A,Q,qI,Δ,Ω), where A is an alphabet, Q is a finite set of states, qIQ is an initial state, ΔQ×A×Q×Q is a transition relation, and Ω:Q{i,,j} is a priority mapping. A run of an automaton 𝒜 from a state qQ over a tree tTrA is a tree ρTrQ such that ρ(ε)=q and for every node u{𝙻,𝚁} the quadruple

(ρ(u),t(u),ρ(u𝙻),ρ(u𝚁)),

is a transition of 𝒜 (i.e., belongs to Δ).

A sequence of states (q0,q1,)Qω is accepting if lim supnΩ(qn) is an even natural number. A run ρ is accepting if for every infinite branch α{𝙻,𝚁}ω the sequence of states (ρ(αn))n that appear in ρ on α is accepting.

A tree tTrA is accepted by an automaton 𝒜 from a state qQ if there exists an accepting run ρ of 𝒜 from the state q over t. The language of 𝒜, denoted L(𝒜)TrA, is the set of trees which are accepted by the automaton from the initial state qI. A language LTrA is regular if it is L(𝒜) for some automaton 𝒜.

We now recall the famous theorem of Rabin, which allows us to transform MSO formulae into equivalent tree automata.

Theorem 2.1 ([25], see also [29]).

For every MSO formula φ(X0,,Xn1) the set of valuations satisfying φ is a regular language over the alphabet {0,1}n.

We say that an automaton is pruned if every state qQ appears in some accepting run, that is, there exists an accepting run ρ of 𝒜 over a tree t such that ρ(u)=q for some node u{𝙻,𝚁}. Note that every automaton can effectively be pruned, without affecting its language, by detecting and removing states that do not appear in any accepting run.

Games.

We use the standard framework of two-player games of infinite duration (see e.g., [8, 16]). The arena of such a game is given as a graph with both players having perfect information about the current position. The winning condition of the game is given by a language of infinite plays won by one of the players.

Ranks.

Recall that an ordinal η can be seen as the linearly ordered set of all ordinals smaller than η. Given a set X{𝙻,𝚁}, a counting function is a function :Xη such that (u)<(v) whenever uX is a proper descendant of vX (such a function exists for some η whenever X is well-founded). The rank of a well-founded set X is the least ordinal η for which a counting function from X to η exists.

Taking the automata-based perspective, instead of working with monadic variables Y and X, we consider labellings of the tree by certain finite alphabets. In particular, a set of nodes X{𝙻,𝚁} can be identified with its characteristic function, that is, a tree xTr{0,1} over the alphabet {0,1}. Such a tree is well-founded if no infinite branch contains infinitely many nodes labelled by 1. The set of well-founded trees is denoted WFTr{0,1}. Likewise, we define the rank of xWF, denoted rank(x), as the least η for which there is a counting function from the set of 1-labelled nodes of x to η. The considered rank is analogous with the standard rank of well-founded trees (e.g., [21, Section 2.E]).

Example 2.2.

The tree x0Tr{0,1} with all nodes labelled by 0 has rank 0.

Consider a tree xω where a node v has label 1 if v=𝚁i𝙻j with 1ji. It is a comb: the rightmost branch is labelled by zeros, and below its i-th node we have a tooth of i nodes labelled by ones, going left. The rank of xω is ω.

Such combs can be nested: suppose that xω2 starts analogously to xω, but below every tooth we again insert xω (i.e., xω2𝚁i𝙻i+1=xω for every i); then rank(xω2)=ω2. Repeating this, we can insert xωn below every tooth of xω, and obtain xω(n+1) of rank ω(n+1), for every n.

Then, we can place every xωn at node 𝚁n𝙻, below a 0-labelled rightmost branch; the resulting tree has rank ω2. In a similar manner we can create a tree having rank equal to any countable ordinal η.

3 Problem formulation

We begin by formulating the problem under consideration. Instead of working with a formula φ(Y,X), we assume that A is some alphabet and Γ is a regular language over the alphabet A×{0,1}. We identify a tree τ over A×{0,1} with a pair (t,x), where tTrA and xTr{0,1} such that τ(u)=(t(u),x(u)) for every node u{𝙻,𝚁}. Thus, ΓTrA×{0,1} can be seen as a relation whose elements are pairs (t,x). We additionally require that whenever (t,x)Γ then x is well-founded, which means that Γ (treated as a relation) is contained in TrA×WF. We say that such a relation is regular if it is regular as a language over A×{0,1}.

Let πA(Γ) be the projection of Γ onto the A coordinate, that is, the set of those trees tTrA for which there exists a (necessarily well-founded) tree xTr{0,1} such that (t,x)Γ. Similarly, for a tree tTrA by Γt we denote the section of Γ over the tree t, that is, the set {xTr{0,1}(t,x)Γ}.

The following definition is just a reformulation of Formula 1.1 in terms of a relation Γ.

Definition 3.1.

The closure ordinal of a relation ΓTrA×WFTrA×{0,1} (or of an automaton recognising it) is defined as

ηΓ=defsuptπA(Γ)minxΓtrank(x).
Example 3.2.

Consider the following automaton 𝒜 over the alphabet {𝖻,𝖼}×{0,1}. Its states are p0,q1,q2,q3,r0,r1 with q1 being initial, where the subscript provides the priority of a state (i.e., Ω(pi)=Ω(qi)=Ω(ri)=i). The transitions are, for all i{0,1}, j{1,2,3}, and a{𝖻,𝖼},

(p0,(a,0),p0,p0), (qj,(𝖼,0),q3,p0), (qj,(𝖼,0),p0,r0),
(qj,(𝖻,0),q2,p0), (qj,(𝖼,0),p0,q3), (ri,(𝖻,i),r1,r0),
(qj,(𝖻,0),p0,q1), (qj,(𝖼,0),r0,p0), (ri,(𝖼,0),p0,p0).

In this example, we should see 𝖼-labelled nodes as separators, splitting the whole tree into 𝖻-labelled fragments. Let us see when a pair (t,x)Tr{𝖻,𝖼}×{0,1} can be accepted. Note first that 𝒜 accepts (t,x0) from p0 for every tree t, and for x0 having all nodes labelled by 0. Next, observe that states qj become aligned along a single branch, either finite or infinite. If in t there is a branch that infinitely often goes left, but visits only finitely many 𝖼-labelled nodes, then we can align the qj states along this branch, and (t,x0) will be accepted. Indeed, just below every 𝖼 we have q3 (state of large odd priority; has to occur finitely often); below every 𝖻, if we go left we have q2, and if we go right we have q1 (so the parity condition requires infinitely many left-turns). Another possibility is that the branch with states qj is finite, and below some 𝖼-labelled node the state changes to r0. Now the run sends r1 to every left child, and r0 to every right child; hence every left child in x should have label 1, and every right child – label 0. We can continue the zone of states ri until reaching a node labelled by 𝖼; such a node allows us to change the state into p0 and accept anything below. The acceptance condition requires that there are only finitely many states r1 (hence also nodes with label 1 in x) on every branch; the tree x is necessarily well-founded.

This determines the optimal rank of a witness x for a tree t. Namely, if in t there is a branch that infinitely often goes left, but visits only finitely many 𝖼-labelled nodes, we have a witness of rank 0. Otherwise, we should consider every zone of 𝖻-labelled nodes in t, surrounded by 𝖼-labelled nodes; consider x having 1 in every left child in that zone; and take the minimum of ranks of such trees x, over all choices of zones (not including the topmost zone, above the first 𝖼 on a branch). Thus, every witness of a tree t has rank at least η if and only if every such zone results in rank at least η, and the former case does not hold. Such a tree exists for every η<ω1, so the closure ordinal of 𝒜 is ω1.

4 The dichotomy game

We now move to the definition of the game 𝒢𝒜 designed to decide the dichotomy from Theorem 1.1.

Note that for every regular relation ΓTrA×{0,1} there exists another regular relation ΓTrA×{0,1} with the same closure ordinal, but such that πA(Γ) is the set of all trees over A. To see this, it is enough to take Γ=Γ{(t,x)xWF¬x.(t,x)Γ}. Then minxΓtrank(x)=minxΓtrank(x) for tπA(Γ) and minxΓtrank(x)=0 for tπA(Γ).

Towards the proof of Theorem 1.1, we consider some relation ΓTrA×{0,1} such that ΓTrA×WF and πA(Γ)=TrA. Reformulating Theorem 1.1, we need to show that either ηΓ<ωN for some N, or ηΓ=ω1, and we can effectively decide which case holds. We assume that Γ is given by a pruned (i.e., all states appear in some accepting run) automaton 𝒜=(A,Q,qI,Δ,Ω).

First, a side is a symbol s{𝖳,𝖱} (which stands for “trunk” and “reach”), and a mode is a symbol m{[Uncaptioned image],[Uncaptioned image]} (which stands for non-branching and binary-branching).

A quadruple (δ,s,m,d)Δ×{𝖳,𝖱}×{[Uncaptioned image],[Uncaptioned image]}×{𝙻,𝚁} such that s=𝖱 implies m=[Uncaptioned image] (i.e., m=[Uncaptioned image] is allowed only for s=𝖳) is called a selector for (δ,s), where δ is of the form (q,(a,i),q𝙻,q𝚁) with aA, i{0,1}. Such a selector agrees with a direction d{𝙻,𝚁} if either m=[Uncaptioned image] or d=d (i.e., both directions d are fine if m=[Uncaptioned image], but if m=[Uncaptioned image] then we require d=d). The output side of a selector (δ,s,m,d) in direction d, where δ=(q,(a,i),q𝙻,q𝚁), is

  • 𝖳 if s=𝖳 and d=d, or s=𝖱 and i=1, and

  • 𝖱 otherwise: if s=𝖳 and dd, or s=𝖱 and i=0.

A state-flow is a triple ((q,s),m,(q,s)), where q,qQ, s,s{𝖳,𝖱}, and m{[Uncaptioned image],[Uncaptioned image]}. A flow μ is a set of state-flows. The set {(q,s)((q,s),m,(q,s))μ} is called the image of μ. Note that the number of all possible state-flows, hence also of all possible flows, is finite.

Given a flow μ, we say that a flow μ¯μ is a back-marking of μ if for every pair (q,s) in the image of μ, precisely one state-flow leading to (q,s) belongs to μ¯. This state flow is called back-marked for (q,s).

Given a sequence of flows, μ1,μ2, we can define their composition as the graph with vertices (q,s,n)Q×{𝖳,𝖱}× and with a directed edge from (q,s,n) to (q,s,n+1) labelled by m for every state-flow ((q,s),m,(q,s))μn+1, n. Note that in a flow there may be two state-flows with the same pairs (q,s) and (q,s), with modes m=[Uncaptioned image] and m=[Uncaptioned image], leading to two parallel edges in this graph.

Assume that we are given a set QQ and a letter aA. By Δa(Q) we denote the set of transitions of the form (q,(a,i),q𝙻,q𝚁) with qQ.

Finally, for two sets of states T,RQ we denote T,R=def(T×{𝖳})(R×{𝖱}). Note that every subset of Q×{𝖳,𝖱} can be uniquely represented as T,R for some T,RQ.

We can now move to the definition of the crucial game 𝒢𝒜, used to prove the desired dichotomy. The positions of 𝒢𝒜 are of the form T,RQ×{𝖳,𝖱} (formally, one also needs additional auxiliary positions to represent the situation between particular steps of a round; we do not refer to these positions explicitly). The initial position is {qI},, where qI is the initial state of the automaton 𝒜. The consecutive steps in a round n from a position Tn,Rn are as follows:

  1. 1.

    declares a subset TnTn.

  2. 2.

    declares a letter anA.

  3. 3.

    declares a set Fn of selectors, containing one selector for each (δ,s)(Δan(Tn)×{𝖳})(Δan(Rn)×{𝖱}).

  4. 4.

    declares a direction dn+1{𝙻,𝚁}.

  5. 5.

    We define a flow μn+1 as the set containing the state-flows ((q,s),m,(qdn+1,s)) for each selector (δ,s,m,d)Fn that agrees with direction dn+1, where s is the output side of the selector in the direction dn+1, and δ=(q,(an,i),q𝙻,q𝚁) (so q is the source state of δ and qdn+1 is the state sent by δ in direction dn+1).

  6. 6.

    declares some back-marking μ¯n+1 of the flow μn+1.

The new position of the game, Tn+1,Rn+1, is the image of the flow μn+1.

Given a play Π of the game, the winning condition for is the disjunction A)B) of the following parts.

A)

In the graph obtained as a composition of the back-markings μ¯1,μ¯2, there exists a path which infinitely many times changes sides between 𝖳 and 𝖱.

B)

In the graph obtained as a composition of the flows μ1,μ2, every infinite path either is rejecting or contains infinitely many state-flows of mode [Uncaptioned image].

Above, while saying that a path going through (q0,s0,0),(q1,s1,1), is rejecting, we mean that the sequence of states (qn)n is rejecting, that is, lim supnΩ(qn) is odd.

 Remark 4.1.

The arena of the game 𝒢𝒜 is finite and the winning condition defined above is ω-regular. Thus, the theorem of Büchi and Landweber [8] applies: one can effectively decide the winner of 𝒢𝒜. Moreover, there exists a computable bound M such that whoever wins 𝒢𝒜, can win using a finite-memory strategy that uses at most M memory states.

The following proposition formalises the relation between 𝒢𝒜 and Theorem 1.1.

Proposition 4.2.

Assume that 𝒜 is a pruned automaton which recognises a relation ΓTrA×WF such that πA(Γ)=TrA (i.e., the projection of Γ is full). Then, we have the following two implications:

  1. 1.

    if player wins 𝒢𝒜 then ηΓ=ω1;

  2. 2.

    if player wins 𝒢𝒜 then ηΓ<ωN, for a number N computable based on the automaton 𝒜.

Figure 4.1: A depiction of a round of the game 𝒢𝒜.

Depiction of a round of 𝓖𝓐.

Figure 4.1 depicts an example of a round of the game 𝒢𝒜. First declares a subset Tn={q0,q1} effectively removing the state q2 from the 𝖳 side. Note that some states might repeat on both sides. Once the letter an=a is chosen by , there are six possible transitions from the considered states: one from each of them, except the state q1 which has two possible transitions, δ1 over (a,0) and δ2 over (a,1). declares a set of selectors

Fn={ (δ0,𝖳,[Uncaptioned image],𝙻),(δ1,𝖳,[Uncaptioned image],𝙻),(δ2,𝖳,[Uncaptioned image],𝚁),(δ3,𝖱,[Uncaptioned image],𝙻),(δ4,𝖱,[Uncaptioned image],𝙻),(δ5,𝖱,[Uncaptioned image],𝚁)}.

Thus, the selectors for the transitions δ0 and δ2 are in the mode [Uncaptioned image], while the remaining selectors are in the mode [Uncaptioned image]. Once chooses the direction dn+1=𝙻, we gather into new sets Tn+1 and Rn+1 the states sent by the transitions in the direction 𝙻. The transitions δ0 and δ1 provide their left states into Tn+1. However, in the case of transition δ2 the direction of the selector is 𝚁 while the direction chosen by is 𝙻 and therefore the left state of this transition goes to Rn+1. Regarding the transitions on the 𝖱 side, δ3 provides its state to Tn+1 because this transition is over (a,1). The transition δ4 provides its state to Rn+1 because this transition is over (a,0). Finally, the transition δ5 does not provide its state anywhere, because its mode is [Uncaptioned image] and its direction is 𝚁, different than the direction 𝙻 chosen by . The states provided by the transitions δ0 and δ1 are both q0 and are therefore merged. This means that the final flow μn+1 is

{((q0,𝖳),[Uncaptioned image],(q0,𝖳)),((q0,𝖳),[Uncaptioned image],(q0,𝖳)),((q1,𝖳),[Uncaptioned image],(q2,𝖱)),
((q3,𝖱),[Uncaptioned image],(q1,𝖳)),((q4,𝖱),[Uncaptioned image],(q3,𝖱))}.

When chooses a back-marking μ¯n+1 of the flow μn+1, he needs to make a choice which state-flow to select for the pair (q0,𝖳) as there are two possible choices.

5 Intuitions

Let us explain the intuitions behind the game. First very generally: the game is designed so that wins when there are trees t requiring witnesses x of arbitrarily large ranks. Conversely, wins if there is a bound η such that every tree t has a witness x of rank at most η. But because this is a finite game with an ω-regular winning condition, if wins then he wins with a finite-memory winning strategy; from such a strategy we can deduce that the bound η is actually of the form ωN for some natural number N depending on the size of the memory of .

Having the above in mind, let us discuss details of the game. The role of should be to show a tree t (whose all witnesses x have large rank), so we allow her to propose a label of a node in step 2. However, as usually in games, we do not continue in both children of the current node, but we rather ask to choose one direction (dn+1 in step 4), where has to continue creating the tree, and where thinks that it is impossible to continue.

Recall now that arbitrarily large countable ordinals can be obtained by alternately applying two operations in a well-founded way: add one, and take the supremum of infinitely many ordinals. Similarly, in a tree x of a large rank, we can always find a comb: an infinite branch – a trunk – such that from infinitely many nodes on the side of this trunk we can reach a node labelled by 1, below which the rank is again large (but slightly smaller). In these places we can repeat this process, that is, again find an analogous comb, and so on, obtaining a tree of nested combs that is well-formed but itself has a large rank. Obviously the converse holds as well: such a tree of nested combs having large rank can exist inside x only if x has a large rank. Let us also remark that in the case of a finite-memory strategy of  we obtain that such combs in x can be nested at most N times, which itself implies that the rank of x is at most ωN.

Thus, in order to show that the constructed tree t allows only witnesses x of large rank, shows a nested comb structure. But this has to be done for every x such that (t,x)Γ, so, in a sense, for every run of 𝒜 over (t,x) for some x. As usual, we cannot require from to choose a run on the fly, during the game; an interesting (even an accepting) run of 𝒜 can only be fixed after the whole tree (i.e., the whole future of the play) is fixed. This means that during the game we have to trace all possible runs of 𝒜. However, there are infinitely many runs, so we cannot do that. To deal with that, we keep track of all “interesting” states in the sets Tn, Rn, and we consider all possible transitions from them in step 3. This makes the situation of a bit worse: she has to make decisions based only on the current state, not knowing the past of the run (the same state may emerge after two different run prefixes). But it turns out that can handle that; in our proof this corresponds to positionality of strategies in an auxiliary game considered in Section 7.

Now, how exactly does show the nested comb structure? This is done via selectors proposed in the sets Fn. For states in Tn (i.e., on the “trunk” side) has to show in which direction the trunk continues. Moreover, has to show places where on side of the trunk we can reach label 1 followed by a nested comb; in these places plays mode [Uncaptioned image] (“branch”). If chooses a direction in which the trunk (as declared by ) continues, we trace the resulting state again on the 𝖳 side. If he chooses the opposite direction, and the mode is [Uncaptioned image] (no branching here), we just stop tracing this run. But if chooses the non-trunk direction while the mode is [Uncaptioned image], the resulting state ends up on the 𝖱 (“reach”) side. The role of is now to show a direction in which we can reach a node with label 1. If follows this direction, and the label of x is 0, we continue searching for label 1 on the 𝖱 side. When label 1 is found, we put the resulting state on the 𝖳 side; has to show a next comb. The B) part of the winning condition ensures for every accepting run that the trunk of each comb has infinitely many branching points (i.e., points with mode [Uncaptioned image]) and that on the 𝖱 side we stay only for finitely many steps (as mode [Uncaptioned image] does not occur there). Note that by arbitrarily composing transitions we may obtain also rejecting runs; the B) condition does not require anything for them.

There is one more issue taken into account in the design of the game: should be obliged to produce the combs nested arbitrarily many times, but not infinitely many times. The number of nestings (i.e., of switches between sides 𝖳 and 𝖱) is controlled by . When he is satisfied with the nesting depth provided by for runs ending in some state, he can remove this step from the position in step 1, and let provide appropriate comb structures only from remaining states (we allow this removal only on the 𝖳 side, but we could equally well allow it on the 𝖱 side, or on both sides). The A) part of the winning condition obliges to indeed remove a state after seeing finitely many nestings. To see the usefulness of back-marking used to formulate this condition, consider a situation with two runs leading to some state: one with already many nestings of combs provided by , and other where we are still on the trunk of the first comb. Because should provide many nested combs for all runs, in such a situation should still be able to analyse the latter run. To this end, he can select the latter run as the back-marked history of the considered state, and continue waiting for further nested combs, without worrying that he will lose by the A) part of the winning condition due to the former run.

Example 5.1.

Let us see how the game 𝒢𝒜 behaves for the automaton 𝒜 from Example 3.2. Recall that the closure ordinal of 𝒜 is ω1, so should be able to win.

The strategy of from a position Tn,Rn is as follows. If TnRn contains a state ri, then plays letter 𝖻, otherwise letter 𝖼. Then proposes selectors: transitions δ originating from states qj are handled by selectors (δ,s,m,d) with mode m=[Uncaptioned image] and with direction d being such that δ sends state p0 to the opposite direction d¯ (i.e., d=𝙻 for δ=(qj,(a,0),q2,p0), etc.); transitions originating from ri are handled by direction d=𝚁, and by mode m=[Uncaptioned image] on the 𝖳 side and mode m=[Uncaptioned image] on the 𝖱 side. As we argue below, p0 never becomes an element of TnRn, so transitions from p0 need not to be handled.

The initial position is {q1},. Here plays letter 𝖼 and some selectors with mode [Uncaptioned image], and chooses a direction. There are two selectors (δ,s,m,d) that agree with this direction, and they send there states q3 and r0. Thus the next position is {q3,r0},, reached by the flow {((q1,𝖳),[Uncaptioned image],(q3,𝖳)),((q1,𝖳),[Uncaptioned image],(r0,𝖳))}. This time plays letter 𝖻. If goes right, the new position is {q1,r0},, reached by the flow {((q3,𝖳),[Uncaptioned image],(q1,𝖳)),((r0,𝖳),[Uncaptioned image],(r0,𝖳))}; this position behaves identically to the previous one, as from q1 and q3 we have the same transitions. If goes left, the new position is {q2},{r1}, reached by the flow {((q3,𝖳),[Uncaptioned image],(q2,𝖳)),((r0,𝖳),[Uncaptioned image],(r1,𝖱))}. From {q2},{r1} once again letter 𝖻 is played. Note that the only transition from r1 reading letter 𝖻 on the first coordinate, reads 1 on the second coordinate. So, if goes right, the new position is back to {q1,r0},, reached by the flow {((q2,𝖳),[Uncaptioned image],(q1,𝖳)),((r1,𝖱),[Uncaptioned image],(r0,𝖳))}; if he goes left, he reaches {q2},, which behaves like the initial position.

It is also possible that erases a state from the 𝖳 side (i.e., plays Tn being a proper subset of Tn). If state r0 is erased, we end up in a position {qj},, being like the initial position. We may also have positions {r0}, and ,{r1}, and flows {((r0,𝖳),[Uncaptioned image],(r0,𝖳))}, {((r0,𝖳),[Uncaptioned image],(r1,𝖱))}, {((r1,𝖱),[Uncaptioned image],(r0,𝖳))} between them. Finally, we may also reach ,.

Note that in our example there is always only one state-flow leading to every pair (q,s); in consequence, every state-flow is back-marked.

Let us now check the winning condition. One possibility is that infinitely many letters 𝖼 were played. In these moments no state ri was present in the position, so the only infinite path in the composition of flows is the path going through appropriate qj states. But after seeing every 𝖼 this state was q3, so the path is rejecting; part B) of the winning condition is satisfied (we may also have no infinite path, if the qj state was removed by , but then condition B) holds even more). The opposite case is that from some moment on, only letter 𝖻 was played. We then also have an infinite path going, from some moment, through the ri states (this path really exists: if removes the state r0, then letter 𝖼 is played). Note that whenever goes left, this path changes sides from 𝖳 to 𝖱, and in the next round returns back to the 𝖳 side. If this happens infinitely often, wins by condition A). Otherwise, from some moment on constantly goes right. After that, the path going through the ri states has all state-flows of mode [Uncaptioned image], and the other path (if exists) remains in state q1, so it is rejecting; condition B) is satisfied.

6 Soundness

We begin by proving Item 1 of Proposition 4.2: if wins 𝒢𝒜 then ηΓ=ω1. To this end, assume that wins the game and fix any winning strategy for her. For every countable ordinal η>0, our goal is to construct a tree t such that rank(x)η whenever (t,x)Γ. We do this by inductively unravelling the fixed strategy of . During this process, we keep track of

  • the current node v{𝙻,𝚁},

  • the current position Tv,Rv of the game,

  • a mapping κv, which assigns some ordinals η to all elements of the set Tv,Rv.

Initially v=ε, the position Tε,Rε is the initial position of the game (i.e., {qI},), and κε={(qI,𝖳)η}. Then, in every node v, the letter declared by provides a label of this node in t, and while moving to a child vd of v we trace a play in which declares the respective direction d. What remains is to declare the remaining choices of and say how the mapping κv is updated. The role of the ordinal κv(q,s) is to provide a lower bound for ranks of witnesses x such that (tv,x) can be accepted by 𝒜 from the state q. While going down the tree, this ordinal decreases whenever we change the side from 𝖳 to 𝖱; when it becomes 0, removes the respective state from the set Tv in his move. The back-markings are declared by in a way that maximises the ordinals κv(q,s) of the respective state-flows.

It remains to show that if (t,x)Γ then rank(x)η. This is achieved by considering any accepting run ρ of 𝒜 over (t,x). Since all possible transitions of 𝒜 are taken into account in each round of 𝒢𝒜, one can trace the run ρ in the simulated plays of 𝒢𝒜. The policy of updating the mapping κv inductively assures that for every node v and currently traced side sv we have (ρ(v),sv)Tv,Rv and rank(xv)κv(ρ(v),sv). Moreover, this policy guarantees that condition A) is never satisfied in these plays. Thus, condition B) must hold, inductively guaranteeing the inequality on rank(xv).

7 Auxiliary game

Before moving towards a proof of the other implication, we need to be able to construct reasonable strategies of in 𝒢𝒜. This is achieved by considering an auxiliary game, based directly on 𝒢𝒜, when considering a single transition of 𝒜 at each round. The players of the game are called Automaton (responsible for choosing transitions and choices of in 𝒢𝒜) and Pathfinder (responsible for choices of in 𝒢𝒜). The game is denoted 𝒜,t,N and depends on the fixed automaton 𝒜, a tree tTrA, and a number N. Positions of 𝒜,t,N are triples (v,q,s){𝙻,𝚁}×Q×{𝖳,𝖱}, plus some additional auxiliary positions, to which we do not refer explicitly.

For a node vdom(t) and a state qQ define

valt(v,q)=inf{rank(x)(tv,x) can be accepted from q}.

We assume inf= (which is greater than all ordinals).

In positions (v,q,s) such that valt(v,q)=0 the game reaches an immediate victory in which Pathfinder wins. A round from a position (v,q,s) such that valt(v,q)>0 consists of the following steps:

  1. 1.

    Automaton declares a transition δ=(q,(t(v),i),q𝙻,q𝚁) from the current state q over (t(v),i) for some i{0,1}.

  2. 2.

    Pathfinder declares a selector (δ,s,m,d) for (δ,s).

  3. 3.

    Automaton declares a direction d that agrees with the selector.

Let v=vd, q=qd, and let s be the output side of the selector in the direction d. Now, for every possible number kN, the following four conditions of immediate victory may end the game, making Automaton win:

s=𝖳 valt(v,q)ωk s=𝖳 valt(v,q)<ωk,
s=𝖳 valt(v,q)ωk s=𝖱 valt(v,q)ω(k1),
s=𝖱 valt(v,q)>ωk s=𝖱 valt(v,q)ωk,
s=𝖱 valt(v,q)>ωk s=𝖳 valt(v,q)<ωk.

If no immediate victory happened, the game proceeds to the new position which is (v,q,s). Note that the conditions of immediate victory depend only on (v,q,s) and (v,q,s), so can be directly hardwired in the structure of the game.

An infinite play (i.e., without any immediate victory) of 𝒜,t,N is won by Pathfinder if the sequence of visited states is rejecting or a selector with mode [Uncaptioned image] is played infinitely often.

The main result about 𝒜,t,N is the following lemma. First, the winning condition of 𝒜,t,N guarantees that if Pathfinder wins the game then he wins it positionally. To prove that he wins, one assumes that Automaton wins from some position, which leads to a contradiction.

Lemma 7.1.

Pathfinder has a positional strategy in 𝒜,t,N that is winning from every position of the game (we call such a strategy uniform).

8 Completeness

We now move to the proof of Item 2 of Proposition 4.2: if wins 𝒢𝒜 then ηΓ<ωN for some computable N. First observe the following important consequence of the winning condition of the game.

Proposition 8.1.

There exists a computable bound N such that if wins 𝒢𝒜 then he has a winning strategy that guarantees the following. In every play Π (either finite or infinite) consistent with this strategy, every path in the graph obtained as the composition of back-markings μ¯1,μ¯2, contains less than N changes of sides from 𝖳 to 𝖱.

Compute the bound N as above. Assume that wins the game 𝒢𝒜 and fix his winning strategy satisfying the thesis of the above Proposition. We claim that then the closure ordinal of the automaton is bounded by ωN. Assume for the sake of contradiction that there exists a tree t which does not have a witnessing tree x of rank smaller than ωN. The above assumption about t implies that valt(ε,qI)ωN.

Based on the tree t, we now construct a play that is consistent with the fixed ’s strategy, but is won be , leading to a contradiction. Together with the current position of the game, Tn,Rn, we store some node vn of the tree, starting with v0=ε. In order to construct the play, we need to provide choices of : she declares a letter based on the label of vn in the fixed tree t, and a set of selectors based on a fixed uniform positional strategy π0 of Pathfinder in 𝒜,t,N, given by Lemma 7.1. The current node vn is then updated according to the direction declared by in 𝒢𝒜.

For a pair (q,s)Tn,Rn denote by histn(q,s) the number of switches from the side 𝖳 to the side 𝖱 on the back-marked history of (q,s). We keep a val-preserving invariant saying that for every pair (q,s)Tn,Rn with k=Nhistn(q,s) either

  1. 1.

    s=𝖳 and valt(vn,q)ωk, or

  2. 2.

    s=𝖱 and valt(vn,q)>ωk.

Note that the val-preserving invariant is initially met, because valt(ε,qI)ωN. Note also that always k>0 because Proposition 8.1 implies that histn(q,s)<N. The fact that the Pathfinder’s strategy π0 is winning in 𝒜,t,N can be used to deduce that the constructed play is won by in 𝒢𝒜. This concludes the proof of Proposition 4.2, hence also of Theorem 1.1.

9 Definability of ranks in MSO

We now move to a study of definability of particular rank bounds in MSO.

With some analogy to the cardinality quantifier by Bárány et al. [3], one can propose a quantifier ηX.φ(Y,X), expressing that there exists a well-founded set X of rank at most η such that φ(Y,X) holds. Note that this can be equivalently rewritten using the predicate rank(X)η, defined by ηZ.X=Z. Below we show that the predicate rank(X)η, and consequently the respective quantifier, cannot be expressed in MSO except for the basic case of natural numbers (or ω1). Definability of this predicate in MSO boils down to checking if the following language is regular:

Lη=def{xTr{0,1}rank(x)η}.

Clearly, rank(x)<ω1 holds for every well-founded tree, thus it remains to consider η<ω1.

We first show that these languages are regular for η<ω.

Fact 9.1.

For every l<ω the language Ll is regular.

Going beyond ω, the languages stop being regular. First, a simple pumping argument shows the following.

Lemma 9.2.

For all ordinals η<ω1 and all l<ω the language Lη+ω+l is not regular.

The argument from Lemma 9.2 applies in particular to all ordinals η such that ωη<ω2, whereas the ordinals ηω2 are covered by Theorem 1.1. Thus we may conclude.

Corollary 9.3.

For an ordinal η<ω1 the language Lη is regular if and only if η<ω.

The above Corollary does not exclude the possibility that a higher ordinal η may be a supremum of a regular subset of Lη.

Lemma 9.4.

For each pair of natural numbers k, l there exists a regular language LWF such that supxLrank(x)=ωk+l.

 Remark 9.5.

Clearly no countable formalism can define all the languages Lη for η<ω1. However, certain formalisms can go beyond MSO. For instance, the logic WMSO+U (for which the satisfiability problem is known to be decidable [4]) is capable of defining the language Lω: a tree x has rank at most ω if below every node u labelled by 1 there is a bound K on the number of nodes labelled by 1 that can appear on branches of x passing through u. This construction can be iterated to define the languages Lωk+l and possibly even beyond that.

10 Closure ordinals

In this section we show how a negative answer to Czarnecki’s question on closure ordinals can be derived from the present result. We use the standard syntax and semantics of modal μ-calculus [7], with its formulae constructed using the following grammar:

F::=aXμX.FνX.FF1F2F1F2FF,

where aA is a letter from a fixed alphabet, X is a variable from some fixed set of variables, μ and ν are the least and the greatest fixed-point operators, and and are the standard modalities (“exists a successor” and “for all successors”). For technical convenience we make an assumption that, in each point of our model, exactly one proposition (letter in A) is satisfied. For the sake of readability we often identify a formula with its semantics, that is, we read a closed formula as a subset of the domain, and a formula with k free variables as a k-ary function over its powerset.

Given an ordinal number η, we use the standard notation μηX.F(X) for the η-approximation of the fixed point in a given model (which amounts to the η’s iteration Fη()). Given a model τ, we define the closure ordinal of μX.F(X) in τ as the least ordinal η such that μX.F(X)=μηX.F(X). Then, the closure ordinal of μX.F(X) (as considered in 1.2) is the supremum of these ordinals over all models τ (or if the supremum does not exist). We aim at providing an (alternative to Afshari, Barlucchi, and Leigh [1]) proof of the following Theorem.

Theorem 10.1.

Let F(X) be a μ-calculus formula in which the variable X does not occur in scope of any fixed-point operator. Then, the closure ordinal of μX.F(X) is either strictly smaller than ω2, or at least ω1 and it can be effectively decided which of the cases holds.

Note that we allow arbitrary closed formulae of μ-calculus to be nested in F; however, we do not cover the whole μ-calculus, because of the restriction on occurrences of X. This stays in line with the fragment considered by Afshari, Barlucchi, and Leigh [1] (as explained in Section 1), but we additionally provide a decision procedure that makes the dichotomy effective.

Towards a proof of Theorem 10.1, as a first step, we eliminate from F all occurrences of X that are not in scope of any modal operator; this can be done without changing the closure ordinal. Next, using standard techniques we obtain the following Lemma.

Lemma 10.2.

Let F(X) be a formula as in Theorem 10.1, with all occurrences of X being in scope of a modal operator. The following three conditions are equivalent for every countable limit ordinal η:

  1. 1.

    the closure ordinal of μX.F(X) is bounded by η;

  2. 2.

    for every model τ that is a countable tree with its root in μX.F(X), this root belongs to μηX.F(X);

  3. 3.

    for every model τ that is a countable tree with its root in μX.F(X), there exists a well-founded set Zdom(τ) containing the root, such that F(Z)Z and rank(Z)η.

A countable tree τ, occurring in Items 2 and 3 above, can be seen as a function τ:XA from a prefix-closed subset X to a finite alphabet A. Now, recall a natural encoding (n1,n2,,nk)𝚁n1𝙻𝚁n2𝙻𝚁nk𝙻 of into {𝙻,𝚁}. This encoding preserves the prefix order on and moreover preserves ranks of well-founded sets. Take the relation ΓF that contains (t,x)TrA×Tr{0,1} if:

  • t encodes a model τ,

  • x encodes a set Zdom(τ),

  • the root of τ belongs to μX.F(X),

  • the root of τ belongs to Z, and F(Z)Z.

The μ-calculus formulae F(Z) and μX.F(X) can be rewritten into MSO [7] and then modified to read the above encoding of τ in the binary tree, instead of τ itself. It follows that the relation ΓF is MSO-definable.

Observe that Item 3 of Lemma 10.2 can be rephrased by saying that the closure ordinal of ΓF is bounded by η. Applying Theorem 1.1 to ΓF, and then Lemma 10.2, we have one of two possibilities: If the closure ordinal of ΓF is smaller than ω2, then it is bounded by ωN for some N; then also the closure ordinal of μX.F(X) is bounded by ωN<ω2. Otherwise, the closure ordinal of ΓF is ω1, so it is not bounded by any countable limit ordinal; then also the closure ordinal of μX.F(X) is not bounded by any countable limit ordinal, hence it is at least ω1. This concludes the proof of Theorem 10.1.

 Remark 10.3.

One may ask if Theorem 10.1 is merely a consequence or it is in some sense equivalent to our main result Theorem 1.1. To the best of our understanding, Theorem 10.1 does not transfer back to the general realm of MSO-definable relations, as in Theorem 1.1. One of the reasons is that the iterations of fixed points are required to proceed in a monotone fashion, driven by the internal formula F; while in full MSO one can express arbitrary correspondence between the parameters Y and a well-founded witness X.

11 Conclusions

This work contributes to the study of expressive power of the MSO theory of binary tree. We investigate to what extent this theory can express properties of well-founded trees, and in particular distinguish between their ordinal ranks. We observe that the ability of explicit expression of properties of ranks is practically limited to statements of the form: all trees X satisfying φ(X) have rank(X)<N, for a fixed N (cf. Corollary 9.3 above). However the implicit expressive power of MSO logic goes much higher. In particular, our main result (Theorem 1.1) allows us to decide whether the property

X.φ(Y,X)X is well-founded with rank(X)<ω2,

is generally true (for all Y), although the property itself is not expressible in MSO.

There is, however, a number of questions that remain to be answered. As ordinals smaller than ω2 can be effectively represented, we would like to have an effective procedure that, given a formula φ, computes the exact bound, that is, (a representation of) the least ordinal ηφ that can be substituted for ω2 in the construction above. Even more elementarily, given an MSO-definable set L of well-founded trees, we would like to compute the supremum of ranks of trees in L. These questions are subjects of ongoing research.

A more far-reaching direction is to relate the techniques of the present paper to the open problem of computing the Mostowski index, mentioned in Introduction. The parity condition itself imposes well-foundedness restriction on the occurrences of each odd label m in the fragments of tree where this label is the highest. Colcombet and Löding [11] have approached the index problem (still unsolved) by reducing it to the boundedness problem for distance automata (see also Idir and Lehtinen [20] for a simplified version of this reduction). One may consider an alternative approach towards the index problem by studying the ordinal ranks which arise from the well-foundedness restriction of the parity condition.

References

  • [1] Bahareh Afshari, Giacomo Barlucchi, and Graham E. Leigh. The limit of recursion in state-based systems. In FICS, 2024. URL: https://www.irif.fr/_media/users/saurin/fics2024/pre-proceedings/fics-2024-afshari-etal.pdf.
  • [2] Bahareh Afshari and Graham E. Leigh. On closure ordinals for the modal mu-calculus. In CSL, volume 23 of LIPIcs, pages 30–44. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2013. doi:10.4230/LIPICS.CSL.2013.30.
  • [3] Vince Bárány, Łukasz Kaiser, and Alexander M. Rabinovich. Expressing cardinality quantifiers in monadic second-order logic over trees. Fundam. Inform., 100(1-4):1–17, 2010. doi:10.3233/FI-2010-260.
  • [4] Mikołaj Bojańczyk. Weak MSO+U with path quantifiers over infinite trees. In ICALP (2), volume 8573 of Lecture Notes in Computer Science, pages 38–49. Springer, 2014. doi:10.1007/978-3-662-43951-7_4.
  • [5] Julian C. Bradfield. Simplifying the modal mu-calculus alternation hierarchy. In STACS, volume 1373 of Lecture Notes in Computer Science, pages 39–49. Springer, 1998. doi:10.1007/BFB0028547.
  • [6] Julian C. Bradfield, Jacques Duparc, and Sandra Quickert. Transfinite extension of the mu-calculus. In CSL, volume 3634 of Lecture Notes in Computer Science, pages 384–396. Springer, 2005. doi:10.1007/11538363_27.
  • [7] Julian C. Bradfield and Igor Walukiewicz. The mu-calculus and model checking. In Handbook of Model Checking, pages 871–919. Springer, 2018. doi:10.1007/978-3-319-10575-8_26.
  • [8] Julius R. Büchi and Lawrence H. Landweber. Solving sequential conditions by finite-state strategies. Transactions of the American Mathematical Society, 138:295–311, 1969.
  • [9] Lorenzo Clemente and Michał Skrzypczak. Deterministic and game separability for regular languages of infinite trees. In ICALP, volume 198 of LIPIcs, pages 126:1–126:15. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPICS.ICALP.2021.126.
  • [10] Thomas Colcombet, Denis Kuperberg, Christof Löding, and Michael Vanden Boom. Deciding the weak definability of Büchi definable tree languages. In CSL, volume 23 of LIPIcs, pages 215–230. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2013. doi:10.4230/LIPICS.CSL.2013.215.
  • [11] Thomas Colcombet and Christof Löding. The non-deterministic Mostowski hierarchy and distance-parity automata. In ICALP (2), volume 5126 of Lecture Notes in Computer Science, pages 398–409. Springer, 2008. doi:10.1007/978-3-540-70583-3_33.
  • [12] Marek Czarnecki. How fast can the fixpoints in modal mu-calculus be reached? In FICS, pages 35–39. Laboratoire d’Informatique Fondamentale de Marseille, 2010. URL: https://hal.archives-ouvertes.fr/hal-00512377/document#page=36.
  • [13] Christian Delhommé. Automaticité des ordinaux et des graphes homogènes. Comptes Rendus de L’Académie des Sciences, Mathématiques, 339(1):5–10, 2004.
  • [14] Javier Esparza, Stefan Kiefer, and Michael Luttenberger. Derivation tree analysis for accelerated fixed-point computation. Theor. Comput. Sci., 412(28):3226–3241, 2011. doi:10.1016/J.TCS.2011.03.020.
  • [15] Alessandro Facchini, Filip Murlak, and Michał Skrzypczak. Rabin-Mostowski index problem: A step beyond deterministic automata. In LICS, pages 499–508. IEEE Computer Society, 2013. doi:10.1109/LICS.2013.56.
  • [16] Nathanaël Fijalkow, Nathalie Bertrand, Patricia Bouyer-Decitre, Romain Brenguier, Arnaud Carayol, John Fearnley, Hugo Gimbert, Florian Horn, Rasmus Ibsen-Jensen, Nicolas Markey, Benjamin Monmege, Petr Novotný, Mickael Randour, Ocan Sankur, Sylvain Schmitz, Olivier Serre, and Mateusz Skomra. Games on graphs. CoRR, abs/2305.10546, 2023. doi:10.48550/arXiv.2305.10546.
  • [17] Olivier Finkel and Stevo Todorcevic. Automatic ordinals. Int. J. Unconv. Comput., 9(1-2):61–70, 2013. URL: http://www.oldcitypublishing.com/journals/ijuc-home/ijuc-issue-contents/ijuc-volume-9-number-1-2-2013/ijuc-9-1-2-p-61-70/.
  • [18] Gaëlle Fontaine. Continuous fragment of the mu-calculus. In CSL, volume 5213 of Lecture Notes in Computer Science, pages 139–153. Springer, 2008. doi:10.1007/978-3-540-87531-4_12.
  • [19] Maria J. Gouveia and Luigi Santocanale. 1 and the modal μ-calculus. Log. Methods Comput. Sci., 15(4), 2019. doi:10.23638/LMCS-15(4:1)2019.
  • [20] Olivier Idir and Karoliina Lehtinen. Mostowski index via extended register games. CoRR, abs/2412.16793, 2024. doi:10.48550/arXiv.2412.16793.
  • [21] Alexander Kechris. Classical descriptive set theory. Springer-Verlag, New York, 1995.
  • [22] Damian Niwiński. On the cardinality of sets of infinite trees recognizable by finite automata. In MFCS, volume 520 of Lecture Notes in Computer Science, pages 367–376. Springer, 1991. doi:10.1007/3-540-54345-7_80.
  • [23] Damian Niwiński and Igor Walukiewicz. A gap property of deterministic tree languages. Theor. Comput. Sci., 1(303):215–231, 2003. doi:10.1016/S0304-3975(02)00452-8.
  • [24] C.-H. Luke Ong. On model-checking trees generated by higher-order recursion schemes. In LICS, pages 81–90. IEEE Computer Society, 2006. doi:10.1109/LICS.2006.38.
  • [25] Michael O. Rabin. Decidability of second-order theories and automata on infinite trees. Transactions of the American Mathematical Society, 141:1–35, 1969.
  • [26] Sylvain Schmitz. Algorithmic Complexity of Well-Quasi-Orders. (Complexité algorithmique des beaux pré-ordres). École normale supérieure Paris-Saclay, 2017. URL: https://tel.archives-ouvertes.fr/tel-01663266.
  • [27] Michał Skrzypczak. Descriptive Set Theoretic Methods in Automata Theory – Decidability and Topological Complexity, volume 9802 of Lecture Notes in Computer Science. Springer, 2016. doi:10.1007/978-3-662-52947-8.
  • [28] Michał Skrzypczak and Igor Walukiewicz. Deciding the topological complexity of Büchi languages. In ICALP, volume 55 of LIPIcs, pages 99:1–99:13. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2016. doi:10.4230/LIPICS.ICALP.2016.99.
  • [29] Wolfgang Thomas. Languages, automata, and logic. In Handbook of Formal Languages (3), pages 389–455. Springer, 1997. doi:10.1007/978-3-642-59126-6_7.