 I'm going to be speaking about a decidability result for a subclass of alternating automaton trees and infinite trees but I will spend most of my time introducing the model and talking about the restriction and intuitions and context. I will just mention the I will formulate the result in one of the last slides. So this is joint work with Jacques Dupac from University of Lausanne and Alessandro Facchini who was in Warsaw when we worked on this and now is in Amsterdam. So let me just start from probably for most of you it's it's known but I will recall it anyway. So my model of automata is alternating automaton infinite trees. I'm using the parity condition. I will just point out that the form of transition function I'm using is it just follows. It takes state and and letter and it gives a positive Boolean combinations of first direction and state. Okay so it's something like this. You either go right in the state Q1 or you go right in the state Q2 and sorry and and you either go in the right in the state Q2 or left in the state Q3. This function rank is used to define accepting runs or accepting place. I will talk a little bit about that in a second. It's essential the essential parameter of this model of automata is the number of ranks that you're using. It's not just the number but also whether you start from an odd or even rank. Okay so this measure that's used for expressing how complex your acceptance condition is called index and it consists of the minimal rank used and the maximal rank used. Now let me recall the how such an automaton work. So basically a computation of such an automaton is a game that's played by two players Box and Diamond. So the player starts in the root of the tree in the initial state and then if the root has label A then we replace the initial state with the Boolean combination given by the transition function and now the players make their choices depending on the on the outermost operator. So if the Boolean combination is a disjunction then Diamond chooses whether he wants phi 1 or phi 2 and this phi i replaces phi and if it's a conjunction it's Box who chooses. Now finally you go down to a single pair direction and state and this pair tells you okay so it's zero Q so you go left so to the left child in the state Q. If it's one Q you move right in the state Q and Diamond wins such a play if the sequence if in the sequence of ranks so this is defined by the sequence of states that are visited okay so if in this sequence the the maximal rank that was seen infinitely often is even then Diamond wins okay if it's otherwise then Box wins and we say the tree is accepted by this automaton if Diamond has a winning strategy for it. Now I would like you to think of the following very very simple operation so imagine you have two automata and you fix the state QS and you look at its occurrence in some transition okay now I'll do the following thing I will substitute this state QS with the initial state of the second automaton okay so the very very simple operation so you could see that on the picture as follows you have these two automata you fix one state and occurrence of this state in the transition and then you just move this single you modify this single arrow instead of pointing to this green state it now points to the initial state of the other automaton. Now it's a kind of obvious observation but if I take a different automaton B prime that is equivalent to B what I get is again an equivalent automaton right so changing a subcomponent of the automaton to an equivalent one doesn't change the semantics of the whole automaton right yeah so basically if the language is recognized by B and C are the same then after substituting B and C I again get the same language but what if I look at Corser equivalence relations so let's first look at the one at the bottom so I will say that two languages are equivalent if the minimal index of automata A prime such that A prime recognizes L of A is the same as the minimal index of automata B prime recognizing B then they are equivalent okay so you look at the smallest index of the automaton recognizing the language this puts the language in an equivalence class and you look at this equivalence relation now the other relation is much more fine-grained you demand that there exists two continuous functions f and g such that the inverse image of L of A is L of B and the inverse image of L of B is L of A what do I mean by continuous function so you can you can equip the space of infinite trees with natural metric counter like so if you know this then then is good if you don't know this then just think of the following characterization I will say that a function is continuous if I can determine say nth level of the output after knowing some fixed number of levels of the input okay so you ask me what is the seventh level of your tree and I say if you give me 17 first levels of the input I will give you the output okay so that's a continuous function it by by no means it has to be computable okay it's just an abstract construct now so why are these important they constitute two measures of complexity of an omega regular language you can sort in a way languages using those relations so basically a language is said to be more complex in the topological sense if it can be reduced to the other so if there exists a function from a such that the inverse image of B is a then I say that a is simpler than B and for for the index equivalence relation basically the higher the index the more you can recognize yeah so these are two quite widely studied complexity measures for for languages of infinite objects not just trees also words I listed several papers this is obviously not not all that was done in this area but I just listed the ones that was influenced by most so let's focus for a second on this index hierarchy so if one tries to understand complexity of omega languages state of trees what one often wants to do is to describe the two hierarchies so kind of understand which languages are more complex than than others in terms of those hierarchies and also try to describe the whole hierarchy so in a way one can think that if one understands the structure of this hierarchy one has a kind of classification of languages so it's not precise we abstract from some aspects but we kind of understand the structure in a way so the typical questions one asks is well the description of the hierarchy and if possible an effective description so I want to have an effective characterization of every level of the hierarchy like this the index hierarchy comes in different flavors because it depends on which kind of a tomata you're using so you can ask about deterministic index that will mean the smallest index of a deterministic automaton recognizing a language or non-terministic or alternating weak alternating etc sometimes this the answer would be infinity or impossible yes if you give if you take a language that is not weakly recognizable and you ask about weak alternating index then the answer might be no chance yeah so this yes as I said that the the classes form a hierarchy the shape is like this so basically if you if you take a say class of languages recognized by 0 to a tomata so the ones that only use ranks 0 1 2 and you take the complement then you can you take the the complement the complements of the languages then you you get the class of languages recognized by my one through a tomata a question to ask is whether this so that two questions the first one is whether the hierarchy is strict and if so then and what is the minimal index needed to recognize a given language yes so that's the typical decidability question and for in general if you take alternating three automata the strictness question was answered positively some time ago I guess the first proof would be Julian Bradfields and that concrete examples of languages that cannot be recognized by by automata with with small index so this is an example for so this is the language called w 1 3 and it's an example of a language that is recognized by 1 3 automaton but not by a 0 2 automaton so not by the dual one yeah so let me just quickly explain the language so you look at the trees that are labeled with the purse so each letter is a per it contains of a box or a diamond and a number yeah 1 2 3 now on such a tree you can play the same game that I explained while defining the semantics of the automata right so the player the players start in the roots and in the root you see it's a diamond right so it's the diamond who makes the choice he goes left or right then say he says go right I'm sorry go from your point of view is go left yeah so so he goes to this node with a three again it's it's a it's a diamond node so he makes his choice again he goes to two let's say two on the right so now it's box's choice so box chooses the way and this way they produce again in the sequence of numbers and again we say the diamond wins if the highest rank seems to be often the highest number often is is even so it can be proved using a topological argument that quite a simple one beta based on on on Banach principle that such a language cannot be recognized by by a 0 to automaton so this is settled then the second question would be to defy to decide the second question would be to decide the the index this we don't know we know it for a subclass of so for a class of deterministic languages so language recognized by deterministic automata what I mean by deterministic is that basically each transition is a conjunction of two pairs zero something and one something so in other words the existential player the diamond player has no choice and box only chooses whether he wants to go left or right but there is no choice about the state yes so so this case was sold but in some sense this case is very easy because the real the real difficult part in in deciding properties of automata is non-determinism or alternation so we're trying to come up with with a class that would capture enough alternation to be non-trivial but at the same time that would have decidable properties for instance the index problem would be soluble or the wedge hierarchy problem so yeah so the general problem remains open now you might ask okay so so I want to solve this problem why did I start from substitutions so what why would substitutions help so so imagine that we have this property suppose that if I take two languages B and C S or two automata B and C such that the language is recognized our wedge equivalent suppose it means that when I substitute the obtained languages are also equivalent how does that help now it turns out that if you have this property you can somehow compute the equivalence class by bottom up evaluation so you can treat strongly connected components of automata as operations on languages on equivalence classes not just languages yeah so what I mean by this is that to each wedge equivalence class you assign a certain canonical automaton that will be it's like a name of this class okay and now you start from the bottom you look at the at the graph or a tree of strongly connected components of the automaton and you start from the bottom you look at the leaf components well those you have to analyze by hand there is no other chance right so you evaluate them you find the canonical representations for them and then you you move up you look at the at the component one level higher you look at the canonical representation of its children and if you understand the operation that stands behind this component again you can evaluate I'm sorry right so you just move up up and finally you get the representation the canonical representation of the whole automaton yeah so that's what we would like to have unfortunately if you take the class of the whole class of alternating two automata you don't have this property why well the answer is very simple because that theoretical union of languages doesn't have this property let's look at a very simple example it's going to be a word example but you'll get the the taste of what's going on so look at the following three languages the first one is just the language of infinite words such that one or two repeats infinitely often the second one is similar only now we require that to repeat infinitely often again one doesn't repeat at all but that doesn't really matter and the third language is just the set of words such that from some point some point on you only see zeros yeah now the first two languages it's quite obvious that they're equivalent because the continuous reductions are actually letter-to-letter so if you want to reduce the the first language is a second language you simply map zeros to zeros once and twos to twos and this is this is obviously a reduction in the sense I described previously and vice versa if you want to reduce the second language to the first language you just take the identity mapping and this is going to be okay so the first language is identical and also if you look at them like directly you see that they are in fact sort of the same language yeah just in disguise now the thing is that if you add to them this third language of words that are finally that finally stabilize at zero then what you get in the first case is just the set of all possible words this is as simple as it can be yeah in the topological sense and also in the sense of the index or anything you want now in the second case you get the language of words over the alphabet one sorry zero one two such that they satisfy the parity condition so that the highest index repeating highest number repeating infinitely often is two so this language is in many senses like in the topological sense it's much more difficult but also in the sense of the index if you take a deterministic word automata then this can be recognized by zero two automaton but not but by say one three automaton okay so there is huge difference between those two languages so there is no chance we can we can get this property for for all automata so we need to find we need to find a class such that this property would work of course one can imagine many different approaches many different ways of solving the problem but we kind of thought that this approach is is elegant so we tried to figure out what is the richest class such that we can use this approach and get the result and the answer is actually very simple so since the problem is caused by union you just have to get rid of union yep you have to make sure that your automaton doesn't contain union anywhere but the thing is that the union can be hidden somewhere yeah so the way you do it the way you get rid of union entirely is you say you exclude certain kind of transitions so basically you say that a transition is dangerous we call it ambiguous if it contains two occurrences of the same direction so that means that in some computation the game can reach two places in the same to two places in the tree in two different states that's what it means so this is bad this induces this lets us encode somehow union or if you get conjunction there it's it's it's intersection which is equally dangerous so we can prove the following theorem if if you take a class of automata such that well it's over a fixed alphabet with at least two letters it's just one letter there is not much to to do you you assume that it's closed under substitution because this is the operation that you need to compute to evaluate your automaton and it contains trivial automata that reject everything and accept everything then such a class is a preserved the equivalence the wedge equivalence under substitutions if no automaton has an ambiguous transition if you don't have ambiguous transitions then it's your so here's here's a proof but I would skip it if you don't have ambiguous transitions then your transitions look like this so basically you're either this is like a deterministic transition in a way and this is something I would call a code deterministic transition so it's existential player who makes the choice diamond player but again he can only choose whether he goes left or right but he cannot choose the state so this is the class of automata that we're working on it's not that weak in fact because for instance it can it captures all the languages that show strictness of the index hierarchy yeah so it's quite powerful it has enough that non-demonism to make it interesting at least for us and what we focused in this paper so this is the main result in fact I said I said it's going to be at the very last slide so we focused on weak game automata so automata that don't have ambiguous transitions and also they they are they have weak acceptance condition so that means that whenever you have a whenever you can reach Q from Q prime and Q prime from Q then the ranks of these two states are the same so for such a tomata we managed to to show that so the picture is like this so here are the deterministic automata for which we know how to decide things and on the right you get the the weak game automata for which we didn't know anything but now we do so we managed to to show that for every weak game automaton you can find a wedge equivalent automaton of a very special kind so the special kind is is obtained by by using several very very simple constructions so you can look at such a canonical automaton as if it were a term that you construct with these operations so this automaton it can be effectively constructed the canonical one and also it has the same weak index yeah so I will show you that the operations don't try to analyze them probably from the back rows you cannot even see them but the point of this slide is just to show that there is finally many of them not that many in fact and they are quite simple so the most complicated one it requires three states now the AB and LM they just stand for other components of the automata yes so that's where you put other automata so it's like an operation on first of languages for first of automata and for those operations you can show you can analyze how they operate on equivalence classes and there is a mathematical way of describing what they do to wedge equivalence classes again don't try to read this even there are formulae that that explain how how the operations act on equivalence classes and this way since the operations are are effective we can decide the wedge hierarchy and the Boral hierarchy and what about the index hierarchy well since the automata preserved since the simplification it preserved the index and also we could prove that weak index in the case of this WGA recognizable languages so weak game languages the index is the same as the position in the Boral hierarchy so basically the two hierarchies they coincide so this also gives a decidability result for for the weak index problem okay and that's it basically it now the biggest question that that I could ask at the end what is what happens if you remove this weakness condition so our conjecture is that the method should still work it will require lots of computation but we will try to do it just for fun I suppose the challenges are that well there is no Boral hierarchy beyond the weak languages languages become non-Boral so you move into the area of set theory where things behave strangely you don't have it in the axiom and and lots of different things can happen instead of Boral classes we can look at we can look at languages that are reducible to our game languages yep so the languages I was describing in the argument about the strictness of the hierarchy and then this gives kind of a skeleton and around this skeleton you could try to build the hierarchy it's going to be difficult but but it might give some further insight into the structure of automata yeah so this is our aim for future thank you