# Lower bounds on separation automata for Parity Games

Several recently developed quasi-polynomial time algorithms for Parity Games rely on construction of an automaton with quasi-polynomial number of states that separates specific languages of infinite words. This motivates a question of whether a matching quasi-polynomial lower bound on the number of states can be proved. This would mean impossibility for a separation approach to give a polynomial-time algorithm for Parity Games. In this paper we study a restricted version of the problem. We bound the number of moves to be read by a separation automaton before it makes a decision. In the general problem there is no restriction of this sort. But we show that lower bounds for unrestricted version of the problem are related to lower bounds for a restricted one with some explicit bound on the number of moves. We apply communication complexity techniques to get an exponential lower bound on the number of states of a separation automata which makes a decision after reading linear number of moves. We also prove an exponential lower bound on the number of states of any deterministic automaton which outputs any repetition in an infinite string after reading some finite prefix of it. The motivation of this result in context of separation automata is discussed in a paper. Finally, we show an upper bound on a communication problem that we call Inevitable Intersection problem. Using this upper bound we conclude that a certain class of reductions from communication complexity are unable to show super-polynomial lower bounds on separation automata.

## Authors

• 10 publications
• 3 publications
09/19/2021

### Lower Bounds on Unambiguous Automata Complementation and Separation via Communication Complexity

We use results from communication complexity, both new and old ones, to ...
07/27/2018

### Universal trees grow inside separating automata: Quasi-polynomial lower bounds for parity games

Several distinct techniques have been proposed to design quasi-polynomia...
02/03/2020

### Conditional Indexing Lower Bounds Through Self-Reducibility

We provide a general technique to turn a conditional lower bound result ...
04/17/2019

### Re-pairing brackets

Consider the following one-player game. Take a well-formed sequence of o...
11/05/2019

### Limitations of the Hyperplane Separation Technique for Bounding the Extension Complexity of Polytopes

This note illustrates the limitations of the hyperplane separation bound...
03/01/2019

### Sign-Rank Can Increase Under Intersection

The communication class UPP^cc is a communication analog of the Turing M...
03/30/2020

### A faster algorithm for the FSSP in one-dimensional CA with multiple speeds

In cellular automata with multiple speeds for each cell i there is a pos...
##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

For a game with two competitive players one can consider a problem of deciding which player has a winning strategy. Parity games are classical example when this problem lies in NPcoNP yet for which no polynomial-time algorithm is known. To specify an instance of a parity game one needs to specify:

• -node directed graph in which any node has at least one outgoing-edge;

• indicated initial node;

• labeling of edges by integers from (priorities);

• partition of nodes into two parts, and .

There are two players named Player 0 and Player 1. A position of a game is specified by a node of a graph. It is possible to move from node to node if and only if is an edge of a graph. For each node it is predetermined which player makes a move in . Namely, Player 0 makes a move in and Player 1 makes a move in .

Since all nodes have out-going edges, the game can always last for infinite number of moves. In this way we obtain an infinite sequence of nodes visited by players. We can also look at the sequence of corresponding priorities. Namely, let be a priority of an edge . Winning conditions in parity game are the following: Player wins if and only if

 limsupk→∞lk≡i(mod2).

Such a winning condition is Borel, which means due to Martin’s theorem ([13]) that either Player or Player has a winning strategy. Moreover, it turns out that a player having a winning strategy in a parity game has also a memoryless winning strategy, i.e. one in which every move depends only on a current node ([4, 15]). This fact means a lot for the complexity of , a problem of determining the winner of a parity game. Namely, due to this fact is in NPcoNP (a short certificate for a player is his memoryless winning strategy). More involved argument shows that actually is in UPcoUP ([9]).

All this leaves a hope that is solvable in polynomial time. Yet this is still an open problem, a lot of work was done to improve an obvious -time algorithm checking all memoryless strategies (see, e.g., [16, 11, 14, 17]). This finally led in 2017 to a quasi-polynomial time algorithm for :

###### Theorem 1 (Calude et. al., [2]).

with nodes and priorities can be solved in time.

Technically speaking, we made no assumptions on but it is clear that we can always reduce a given instance of parity game to one in which is linear in the number of edges. Thus in a worst case the algorithm of Calude et. al. takes time.

### 1.1 Separation approach to ParityGames

Since the paper of Calude et. al., several other quasi-polynomial time algorithms were invented for ([10, 5, 12]). The paper of Czerwiński et. al. ([3]) argues that all these works follow so-called separation approach. According to this approach one consider infinite plays of a parity game as infinite words. In this way we can imagine that a play is written on an infinite tape which can be read by a deterministic finite automaton. The ultimate goal is to construct an automaton which in some sense separates plays won by one player from plays won by the other player.

In more detail, if is a finite alphabet and are two disjoint languages consisting of infinite words over , then we say that a deterministic finite automaton separates from if for all :

• if , then on some finite prefix of an automaton reaches an accepting state (some special state indicated in advance);

• if , then never reaches an accepting state on .

To encode plays of a parity game we use an alphabet . A sequence of vertices of a graph corresponds to a word:

 (v1,l1)(v2,l2)…∈ΣN,

where is a priority of an edge . Using this encoding we may define languages corresponding to ‘plays’ won Player and to ‘plays’ won by Player :

 LimSupEvenn,d ={(v1,l1)(v2,l2)…∈ΣN:limsupk→∞lk≡0(mod2)}, LimSupOddn,d ={(v1,l1)(v2,l2)…∈ΣN:limsupk→∞lk≡1(mod2)}.

(Note that some infinite words do not encode an actual play on a graph. Nevertheless we call them plays also.)

However it is not enough to deal only with these two languages — it is pretty straightforward that no deterministic automaton separates one from another. Nevertheless, one can change a winning condition of a parity game so that corresponding languages could be separated.

Namely, consider the following winning condition: Player wins if in a resulting infinite path of a graph the maximum of priorities on every cycle is of the same parity as . It turns out that this modification does not affects who has a winning strategy. More specifically, Player has a winning strategy with a new winning condition if and only if he has a winning strategy with a standard parity condition. The “only if” direction is obvious; the “if” direction once again requires a fact that parity games are memoryless determined.

In a similar manner as and were defined, we can now define languages and corresponding to a new winning condition. Namely, consists of all infinite words over in which the maximum of on every “cycle” is even (see Preliminaries for precise definition). Language is defined similarly.

The following theorem by Bojańczyk and Czerwiński establishes formal connection of separation approach to complexity of .

###### Theorem 2 ([1]).

Assume that there is a deterministic finite automaton with states separating from . Then with nodes and priorities can be solved in time plus time to construct .

It turns out that can be separated from even by an automaton with states. A work of Czerwiński et. al. ([3]) demostrates that essentially such an automaton was constructed in a paper of Calude et. al., as well as in several subsequent papers. Actually, the main question Czerwiński et. al. address is whether corresponding lower bound can be proved. This would confirm that a separation approach is unable to yield a polynomial-time algorithm for . What Czerwiński et. al. show is that states are needed to separate from . Their proof is based on an analysis of the structure of a separation automaton.

It holds that , so the lower bound of Czerwiński et. al. does not automatically imply lower bound on separating from . Our paper does not resolve this problem as well, but we make some progress towards this goal by considering a restricted version of the problem.

### 1.2 Our results

Namely, for any a separation automaton should reach an accepting state on some finite prefix on . The length of such prefix is not anyhow bounded. We suggest to first study this problem for automata in which such prefix is of length at most some bound .

More specifically, we say that a deterministic finite automaton separates from in -time if for all :

• if , then an automaton reaches an accepting state while reading ;

• if , then an automaton never reaches an accepting state on .

In Section 3 we observe that to obtain a lower bound on the unbounded version of the problem it is enough to do so for the bounded one. More precisely, we show via simple pumping argument that a -state deterministic finite automaton separating from does it in -time. This means that to obtain lower bound on separating from it is enough to do so for -time.

In Section 4 we obtain some progress towards this goal. Namely we show that a deterministic finite automaton separating from in -time has number of states. This bound holds even for . Let us remark here that only linearly many states are needed to separate from in -time (count the number of letters with priority 2 and accept if there are at least of them). It seems plausible that for and the state complexity of separating from in -time is sub-exponential but super-polynomial. We do not know how to prove it.

The basic idea of our proof is simple. Assuming that an automaton has too few states, we provide two words of length , one is a prefix of a word from and the other is a prefix of a word from , on which automaton reaches the same state. To do so we reduce from multiparty communication complexity of a variant of Disjointness problem. However, we reduce not just once but about times. Each reduction allows us to extend our words by about symbols.

In Section 5 we give an evidence why we need such a multiple-reduction proof. One can consider a communication problem in which parties come up with a word . Each coordinate is known to at least one party and it is promised that cycles of

are all of the same parity. The goal is to determine whether they are all even or all odd.

This problem can be viewed as a formalization of a “direct” reduction from communication complexity to separation automata for parity games. We show, however, that even for , when the number of parties is constant, such a reduction is unable to show super-polynomial lower bounds. We do so by demonstrating an upper bound on the following communication problem which we call Inevitable Intersection problem and which may be of independent interest. In this problem there are parties, and the input of the party is a set . It is promised that . The goal of parties is to output any element which belongs to at least two parties. We show that for and this problem can be solved by a deterministic protocol with -communication and rounds.

Finally in Section 6 we explore the following problem related to vs problem. Assume that an infinite word over is written on a tape. Our goal is to find any repetition on a tape, i.e. any which appears in at least two distinct places. This task can be formalized as follows. Assume that we have a deterministic finite automaton which has special states and also some other states. Whatever written on a paper, the automaton should reach a state from . Moreover, if the automaton reaches , then should appear at least twice on a prefix the automaton has read so far. We show that any deterministic finite automaton performing this task should have at least states. This bound is obviously tight, because in this number of states an automaton can remember all elements of it has read so far.

This result is connected with the fact that the task of separating from is easy for non-deterministic automata. Namely, cycles of a given infinite word correspond to repetitions in In other words, if it could be possible to guess any repetition in , then it costs only polynomially-many states to calculate a maximum of between two occurrences of . Our result shows that it takes states to naively remove non-determinism from this solution.

## 2 Preliminaries

Let be a finite alphabet. For by we denote the length of . We enumerate letters of starting with , i.e. we write Let denote an empty word.

A deterministic finite automaton over is specified by a finite set of its states, an indicated initial state and a transition function . As usually we can extend to be a function of the form by setting to be a state reached by automaton from after reading .

For , we say that a deterministic finite automaton separates from if there exists a state such that for all the following holds:

• if , then there exists such that ;

• if , then for all it holds that .

Further, we say that an automaton separates from in time if instead of the first condition the stronger one holds: if , then there exists such that .

Denote , where and are positive integers. Define the following two functions (projections)

 v:Σ→{1,…,n},v((i,c))=i,l:Σ→{1,…,d},l((i,c))=c. (1)

Fix . We call a pair of positive integers a cycle of if and . A cycle of is called even (odd) if is even (odd).

Further, define the following two languages, consisting of infinite words over :

 AllCycleEvenn,d ={w∈ΣN:all cycles of w are even}, AllCycleOddn,d ={w∈ΣN:all cycles of w are odd}.

For our main lower bound we use deterministic communication complexity in the number-in-hand model. In this model there are parties and their goal is to compute some (fixed in advance, possibly partial) function , where sets are finite. The party receives an element of on input. Parties have a shared blackboard on which they can write binary messages. Blackboard is seen by all players.

More formal introduction to the number-in-hand model can be found, for instance, in [8], Chapter 5. For our lower bound we use only very basic technique of monochromatic boxes. This technique is a generalization of a standard two-party monochromatic rectangle technique. Namely, we exploit the following feature of protocols: a deterministic protocol for with bits of communication induces a partition of into at most boxes, i.e. sets of the form for some . Moreover, none of these boxes contains two tuples from on which is defined and takes different values.

## 3 Reduction to finite time

###### Proposition 3.

Assume that a deterministic finite automaton with states separates from . Then this automaton separates from in -time.

###### Proof.

Assume for contradiction that for some infinite word and for all it holds that . Our goal is to find an even priority and distinct indices , where , such that

• ;

• for all , .

Let us explain why this would be a contradiction. By pigeonhole principle there are distinct , such that:

 δ(q0,w1…wia)=δ(q0,w1…wib) % and v(wia)=v(wib).

In particular we simply have . Now we can transform into an infinite word from on which , however, never reaches . To do so just leave a prefix as it is and then repeat a cycle infinitely many times. There will be no odd cycles because the maximal priority on is and is attained on .

It only remains to explain how to find such . To do so consider the following procedure. This procedure operates with variables and and maintains the following invariant: , , and for all it holds that . At the beginning, set , and observe that invariant is satisfied. Also note that this invariant can not be satisfied if , because otherwise there are at least consecutive letters in those priority is .

So the procedure runs as follows. Below we assume that . Let , where , be a set of such that .

If is odd, observe that . Cut into subwords by removing . The value of on each of these subwords is at most . At least one of them is of length at least . The latter number is at least , because

 (qn+2)k′=(qn+1)(qn+2)k′−1+(qn+2)k′−1≥(p+1)(qn+2)k′−1+p, (2)

where the latter is due to the fact that and . We then set to be the coordinate of the beginning of the longest subword, to be the coordinate of the end of the longest subword and . Obviously invariant is preserved.

If is even and , then we output and we are done. Otherwise and we can decrease by one while preserving invariant exactly the same way as when was odd (note that (2) works as well for ).

We finish the proof by noticing that we can not reach . ∎

## 4 Lower bound on separating even cycles from odd cycles

This section is devoted to the proof of the following

###### Theorem 4.

For any there exists such that any deterministic finite automaton separating from in -time has at least number of states.

For our lower bound we define the following communication problem which is a variation of Disjointness problem. Fix and . There are parties. The party receives a set of size . It is promised that either are disjoint or . The goal of players is to determine, which of two cases holds. We denote this problem by -element .

We show the following lower bound on :

###### Theorem 5.

For any fixed and deterministic communication complexity of -element is .

A similar problem (without restrictions on sizes of input sets) in two-party setting was considered in [7].

### 4.1 Extremal combinatorics lemma and communication lower bound

We need the following result from extremal combinatorics due to Frankl and Rödl.

###### Proposition 6 ([6], Corollary 1.6).

For any and there exist such that for all the following holds. Let and be two families of -element subsets of such that for all , where . Then

 |F1|⋅|F2|⩽(1−ε)n(n⌊αn⌋)2.

The following obvious corollary of proposition 6 is more convenient for our needs.

###### Proposition 7.

For any and there exists such that for all the following holds. Let and be two families of -element subsets of such that and . Then there are and such that .

Moreover, since we are dealing with -party setting, we need the following -dimensional generalization of proposition 7. Fortunately, this generalization can be obtained via very simple induction argument.

###### Lemma 8.

For any and there exists such that for all and for all the following holds. Let be families of -element subsets of such that for all . Then there are such that for all .

###### Proof.

Let be the minimal positive integer such that for all the following holds. If are families of -element subsets of satisfying for all , then there are such that for all .

Proposition 7 can be stated as follows: for any and there exists such that . To show the lemma it is enough to demonstrate that

 Ak+1,nα,ρ⩽2⋅Ak,nα,ρ.

To do so, fix families consisting of -element subsets of . Assume that for all . Our goal is to show that there are satisfying

 |F1∪Fi|=⌊ρn⌋ for all i∈{2,…,k+1}.

Denote . We claim that there are distinct such that for every there are satisfying for all .

We construct such one by one. Assume that for some are already constructed. We notice that:

 ∣∣F1∖{G1,…,Gj}∣∣⩾2⋅Ak,nα,ρ−j⩾2⋅Ak,nα,ρ−N=Ak,nα,ρ,
 |F2|⩾2⋅Ak,nα,ρ⩾Ak,nα,ρ.

This means that by definition of there are , satisfying:

 |G∩Hi|=⌊ρn⌋ for all i∈{2,…,k}.

Then we set . Note that is distinct from since .

Finally we apply definition of to and . These two families are both of size at least , hence there are and such that . To finish the proof set and . ∎

We are now ready to prove theorem 5.

###### Proof of theorem 5.

Let denote the set of all -element subsets of . Let be a set of all such that are disjoint and let be a set of all such that for all . Note that

 |D|=(n⌊n/k⌋)⋅(n−⌊n/k⌋⌊n/k⌋)⋅…⋅(n−(k−1)⋅⌊n/k⌋⌊n/k⌋)>0.

Assume that there is a -bit deterministic communication protocol for . Hence there is a partition of into at most boxes such that each box is disjoint either with or with . Among these boxes there is one which contains at least elements of . Let this box be for some .

Take such that the statement of lemma 8 holds for . Note that depends on and , but not on . We now claim if for some , which depends only on , and , then there are such that . Indeed, otherwise there is such that for all . This implies that for all the following holds:

 |Fi△Fi′| ⩽|Fi△F1|+|Fi′△F1|=|Fi|+|F1|−2|Fi∩F1|+|Fi′|+|F1|−2|Fi′∩F1| ⩽4⋅⌊n/k⌋−4⋅⌊(1−γ/8)n/k⌋⩽γn/(2k)+4<γ⌊n/k⌋,

for all starting from some which depends only on and . This would mean that box intersects , but in the same time this box intersects , contradiction.

So in this box there are at least elements of by definition, but on the other hand there are at most

 |Fi|⋅(n−⌊n/k⌋⌊n/k⌋)⋅…⋅(n−(k−1)⋅⌊n/k⌋⌊n/k⌋)

elements of . Since , we have

 |D|/2c⩽2k−1⋅(1−ε)n(n⌊n/k⌋)⋅(n−⌊n/k⌋⌊n/k⌋)⋅…⋅(n−(k−1)⋅⌊n/k⌋⌊n/k⌋),

and the latter means that , i.e. .

### 4.2 Proof of theorem 4

Let be a deterministic finite automation separating from in -time. Without loss of generality we assume that once reaches , it always remains in this state. In particular this means that for all and for all it holds that .

Set and . By theorem 5 there exists which depends only on such that deterministic communication complexity of -element is at least . We will show that has at least number of states.

Assume the contrary. Denote for brevity and . Note that are symbols of the alphabet if . Let us also introduce the following notation. For a word define .

Let us show that for all there are words

 f1,…,fj,g1,…,gj∈({1,…,m}×{1})∗

satisfying the following list of conditions:

 |f1|=|g1|⩾n/3,…,|fj|=|gj|⩾n/3, (3) v(f1),…,v(fj) are disjoint and |v(f1)|⩽2n/k,…,|v(fj)|⩽2n/k, (4) |v(g1)|=|g1|,…,|v(gj)|=|gj|, (5) δ(q0,f1#1f2#2…fj#j)=δ(q0,g1#1g2#2…gj#j). (6)

We will prove this by induction on . Induction base is obvious.

Let satisfy (36) for some . Denote

 q=δ(q0,f1#1f2#2…fj#j)=δ(q0,g1#1g2#2…gj#j).

Assume for contradiction that for all it holds that

 δ(q,f#j+1)≠δ(q,g#j+1) (7)

whenever are such that , , and is disjoint with . We will use this to construct a deterministic communication protocol with less then bits of communication for -element