 So, this talk will be about idempotent elements of finite semi-groups. So there are several reasons to study idempotent in computer science. Here we will focus on idempotent as a way to identify, given an abstract model, what are the behaviors of this abstract model that have good properties with respect to iteration? So let's start with some basic definitions. What is a semi-group? So, basically a semi-group is just a set with an associative binary low, and an idempotent element of a semi-group is just an element that is stable when multiplied by itself, okay? So let's look at some examples. For example, any group is actually a semi-group, and what are the idempotent elements of a group? Well, every group has a single idempotent, which is its identity element, okay? But not all semi-groups are groups. So for example, if you take the set, the max semi-group mn, which is the set of n integers with the max operation, well, this is clearly not a group. And what we can see in this particular semi-group is actually every element is an idempotent. If you take any i, the max between i and itself is, of course, itself, okay? Some more examples that will be used throughout this talk are the set of functions over a finite number of elements equipped with the composition. So here the idempotent, you have several different idempotent, so it's not like the max semi-group. Not everything is an idempotent, but you still have a lot. So for example, the identity function is one, but you also have every constant function that maps every element to the same element, and many others. So yeah, basically you can kind of combine these two ideas, be the identity in a subset of your domain and be the constant function in some other subsets, and you still end up with some idempotent, okay? And the last example I will present is the set of binary relations over a finite number of elements. So this time what are the idempotent? So one example would be the relation smaller than or equal to. So this is an idempotent. Once again there are several other idempotent elements. They are all partial orders, but not all partial orders is an idempotent, yeah, don't care too much about that, there's a lot of them, but of course once again not every element of this set is an idempotent, okay? So how to use idempotent to identify iterable behavior? Well, let's start with the very basic model of computation, so just an automaton. You have a finite number of states, transitions, labelled by letters, and you accept every word for which you can go from an initial state to a final state. So for example here, a, a, b, b, b, b is accepted. And what you can notice is that here in the middle we have what is called a loop. One state is repeated. So what does it mean? Well, actually the part here can be iterated any number of times and we are still in the language, okay? So yes, for finite state automata loops are a great way to characterize iterable behavior because, well, first they can be iterated, I mean, when we iterate the loop, yeah, we really iterate just this part, it's a very local change so we don't modify other parts of the word, which is good, and on top of that, loops are guaranteed to appear as soon as you have a run that is longer than your number of states, of course a loop will happen somewhere, okay? So loops are great for finite state automata, but this does not work as well when we go to more complicated models of computations. For example, if you have a model that uses all of the runs to produce the input, so for example weighted automata or universal automata, then the notion of loop is not that well because so either you say that you have a loop if at least one of your runs is looping, but then you cannot really iterate it because what happens with the other run could be a totally chaotic, or the other way to define a loop could be, yeah, I have a loop if and only if all of my runs are looping simultaneously, but then you cannot guarantee that such kind of loops will appear, so we see that here, yeah, the notion of loop doesn't work that well. Same thing when we have models of automata that read the input in the non-standard way, so for example two-way transducers or a bevel automata. The problem is kind of the same here, so maybe the first time we go through a factor of our word, I will actually loop, but then if I come back later, I might do something else, so do I still consider this as a loop or not? And same thing, whatever I choose, either this will be something that might produce chaotic behaviors once iterated, or I ask too much and I have no guarantee that this thing will appear. And finally, the notion of loop also fails to work in models that have non-standard output production, so for example, yeah, automata that produce outputs with the use of registers, so cost registers, automata or streaming string transducer, so yeah, let's have a look in more details in this last case in why it fails, why loop fails to work. So here is an example of cost register automata, I hope you can see it, so yeah, how does it work? Well, it's like an automata, you read some letter and you have a finite number of registers that are updated along the computation, so here you have two registers, x and y, you see that first while going further in this automata, in this automaton, whenever you read an a, you increment x, and whenever you read a b, you increment y, yeah, sorry, I should have stated that, your registers contain integers, so they start with value 0, and then, yeah, you'll play some operations on them, so here you increment them, and finally here you have a loop, you can read some c's, and whenever you read a c, you put the value of y into x and you reset y. So that's something you can do, that's a cost register automaton, let's have a look at a run, so if we have the word b, a, b, b, c, we start at the beginning with registers, register values 0, we read the first b, so we increment y, we read an a, we increment x, b, b, two more increments to the y, and then when we read the c, we put the value of y into x and we reset y, so from 1, 3, we go to 3, 0, okay? This is a loop, and we said before, yeah, loops are well behaved with respect to iteration, so let's add one more, and you see that here, obviously, it will fail, because if you iterate this one once more, so you put the value of y into x and you reset y, so you end up putting the zeros into the x and reset y, so you lose everything, you lose all the computation done on your previous run, and so, yeah, this is terrible, this is not a local change, and we would like to avoid that, so yeah, are all loops terrible? Actually no, some of the loops can be iterated, so if we just change the register update on the last loop here, so instead of the previous one, now I just sum up the content of both of my variables into x, and I reset y to the value 1, so what happens? This time, well, the beginning of the run is the same as before, I end up with a value of 1 into x and a value of 3 into y, and then when I read my c, so I sum them both in x and reset y to 1, so I end up with 4, 1, and this time, if I choose to iterate this loop even more, what happens? So I sum them into x, I reset y to 1, so in the end, I just add 1 to x, and we can see that if I keep doing that, I'll just keep adding 1 again and again to the value of x, so yeah, this is what I consider as well-behaved with respect to iteration, and what we can remark here is that the structure of the register update here is actually an idempotent, so if we just forget about the integer numbers and we just look at which variables end up in which variables, we see that we can combine this with itself as many times as we want, we will always end up with x and y in the variable x and no variable in the variable y, okay? And this is not a coincidence, actually, we can show that whenever we have a register update that has an idempotent structure, we will always have these nice properties with respect to iteration, that if we iterate this variable update, register update, and plus 1 times, well it will be kind of like if we have already only iterated, if we have only applied it once, and then yeah, we just add something that is fixed every single time, okay? And actually this is an if and only if, so this nice thing is also characterization of registered updates with idempotent structures, okay? So yes, let's go back to this slide, so I hope that I kind of convinced you that idempotents are a nice way to look at good iterable behavior for cost reducer automata, and yeah, it's also the case for some other models, I won't go into the details, but for example, so idempotent elements corresponding to the transition monoid of weighted automata, for example, have been studied here to expose some pumping lemmas, and here once again you have some notion of idempotent element for two-way transducers, a transition monoid of two-way transducers that have good properties with respect to iteration that have been used to prove some other results, so in general it seems like idempotent elements are well behaved with respect to iteration, well it's not always that trivial, you always need to try and think which kind of semi-group would be good to modelize your problem, which kind of, yeah, the problem is finding a finite semi-group to modelize the thing you have, because basically you always have a trivial infinite semi-group, but the difficult part is, yeah, finding a finite one that still contains all the useful information. So yes, well behaved with respect to iteration, so the question that's left is, are these idempotent elements guaranteed to appear? The easy answer is yes, so one most usual way of obtaining this result is applying the forest factorization theorem that will give you that for free, I mean if you have a run that is long enough you will end up with a nice structure with lots of idempotents, but what I want to present right now is kind of a weaker version of the forest factorization theorem, and why is that interesting? Well we'll see that having a weaker version of this theorem allows us to get way better bounds on the actual size of the runs we need to consider in some cases, okay? So yes, just before going further, one thing I should add is, yes, idempotent elements are well behaved with respect to iteration, but sometimes it's not enough to have a single idempotent element. Sometimes, actually for all of these two results I think, you need several repetitions of the same idempotent in a row, so about the number of times, so like here it's two times or something, and here it depends on the number of states of your automaton, but yes, having a single idempotent is sometimes not enough, you might need several of them, so this leads us to the following definition. So if we're given a sequence u of elements of a finite semi-group S, we say that a Ramsey lambda decomposition of u is just a sequence of consecutive factors of u that all correspond to the same idempotent. Let's have a look at an example, it might be easier to understand it with that, so here I have a sequence of element of the max semi-group M4, so remember it's the semi-group on four elements, the product is just the max. So for example, this is a Ramsey 3 decomposition. Why is that? Well, I have three factors, they are consecutive, and on top of that the maximum in each of them is three, and as I said at the beginning three is an idempotent element of this semi-group. Let's have another example, so once again a word over the same semi-group, so this time this word actually does not admit any Ramsey 3 decomposition, but we can find here a small Ramsey 2 decomposition, both the maximum are two. Now the question I will try to ask is a good thing, but I want to answer it also, and the rest of this talk is how long does a sequence of elements needs to be to guarantee the existence of Ramsey lambda decomposition? Yes, as I said to you earlier, a way to answer to this question would be applying the forest factorization theorem. This will give you a bound, but yes, what I would like, I mean ideally, I would like to have something exact to know given a semi-group S, what is exactly the length of the maximal sequence of elements of S that does not admit a Ramsey lambda decomposition. So yes, one more thing I should add before going further, so yeah, actually in the remainder of the talk I will consider the case lambda equal 2, because it's easier to present the ideas of the proof in this way, but actually all the thing I will present now is easily generalizable to any lambda. Okay, so let's continue. So yeah, first let's consider some easier cases. So first what happens in groups? So here we actually have a tight bound. We can prove that, so if we have a group G, and we're given a sequence of element of G that is longer than two times twice the size of G, then the sequence admits a Ramsey decomposition, and on the other hand we can prove that there exists a sequence that well has size just this minus one, and that does not admit any Ramsey to decomposition. Okay, so how do we prove that? Well, let's start with the first, and for this example I will prove this in a very specific case, but as you will see the proof is easily generalizable. So I consider the cyclic group over five elements, so yeah the sum or the product or here I will denote it with a plus, it's just well the sum of two classes is the class of the sum, model of five. Okay, so if I'm given a word of size two times twice the size of G, so here, ten, how do I find a Ramsey to decomposition? Well, it's by considering the sequence of prefixes, so what do I mean by that? Well, I just compute the sequence which corresponds to the prefixes of U, so I start with a zero, this kind of corresponds to the empty prefix, and then I just write the element that corresponds to every prefix, so here I have a three, so it's just three, here three plus four is seven, which is two, model of five, plus three I end up back with zero, and I continue that way. Okay, okay, and so this thing, since I added an element corresponding to the empty prefix, the length of this sequence will be one more than the previous one, so this will be strictly more than twice the size of G, and so I know for sure that one element will be repeated three times, okay, since the length is more than twice the size, one element is repeated three times, and what's good about that? Well, since I'm in a group, actually, identical element of this sequence of prefixes correspond to neutral factors of U, so if I consider here the factors that are between these identical elements of the prefix sequence, well they are actually the neutral element, which is an idempotent, and so here I directly get my RAMC2 decomposition, okay, okay, perfect, so no, so and yes, I mean this works here with this precise group, but this works exactly the same with any other group, and so what about the lower bound, so how do we construct a sequence of twice the size of G minus one that admits no RAMC decomposition? Well, we only use the fact that this is actually an equivalent, so we begin by a prefix sequence and we construct U out of it, which prefix sequence do we choose? Well, just any prefix sequence that contains two times every element, so yeah, the important thing is that no element appears three times, so that if afterwards we just compute the word that corresponds to this prefix sequence, well here the word, sorry, the word is not that interesting, but the thing is, since here we have an equivalence, we know that we will never have two consecutive neutral factors of U, because this would correspond to three times the same element here and we don't have that, okay, so yeah, once again this works exactly the same for any group, so this concludes the proof of this theorem here, okay, so that's a good start, in the case of groups we have a bound that is tight, good, now let's look at something else, max semigroups, so remember it's mn is the integers from 1 to n and the operation is the max, so once again here we have a bound that is tight, we prove that whenever the sequence is longer than 2 to the n, then there exists a RAMC decomposition and on the other hand there exists a sequence of length 2 to the n minus 1 that has no RAMC to decomposition, so once again I will present the proof on a very precise example, so here I fix n equal 4, but it's generalizable to anyone, just to remember that this is the product, so how does the proof work, well it's just a basic divide and conquer algorithm, so if I start with a sequence of elements of m4 which has size 2 to the 4, I just split it in two equal parts, okay, and then I look at the maximum in both of the parts, so here it's 4, here it's 4, okay I got lucky, so here I'm done, I already have my RAMC 2 decomposition, okay, now what happens if it's not the case, so here I take a new one, same thing it's sequence of m4 and of size 2 to the 4, I split it in two parts, this time one has max 4 and the other has max 3, the thing is well if I keep the smaller one since the max is not 4, I know that it does not contain any 4, okay, so it's actually an element, it can actually be considered as an element of m3 and since I just divided the size, the initial size by 2, its size is 2 to the 3, so yeah by induction this seems good, so let's have a look what happens if I continue, here I split it in two, the max is 2, the max is 3, I keep the smallest one, now I have something of m2, whose size is 2 to the 2, I split it in two, the max is distinct, I keep the smaller one and finally when I'm done to m1, well then I'm bound to have my 2-day composition because the only element of m1 is 1, okay, so yes of course sometimes, so here are the two examples, once it stopped at the very beginning and once it stopped at the very end, but sometimes yeah, you just stop in the middle, for example here you find another ramse 2-day composition in the middle, okay and so yes that's all for this algorithm I think, yes, and so now how do we constrict to prove the lower bound, how do we constrict a sequence of elements of mn with size 2 to the n-1 and no ramse 2-day composition, it's a basic inductive construction, so we start with u1, which is just a single one, then to constrict the next one, well we take two copies of the previous one and we add the new element in the middle and so why does this not admit any ramse 2-day composition, well we know that ramse 2-day composition needs two factors, so here since there is a single 2, we know that I mean two cannot be in two both factors, so both factors need to be just one but then they cannot be consecutive because there is a two in the middle and the idea is the same for the rest, u3 I take two copies of u2 and I put a three in the middle, once again three cannot be in both factors, so either the two factors are to the left of the three or the two factors are to the right of the three and as we just proved it's not possible to have two consecutive item-potent factor in this word, so this has no ramse 2-day composition and so on, okay, so in general yes we construct u1 by putting a one copy of n in the middle of two copies of un-1, okay, so for groups we have a tight bound for max semi-groups, we also have a tight bound, unfortunately yes that's where it stops, for a more complicated semi-groups I mean no tight bound is known yet and it seems kind of complicated to get one but so how can we try to approximate it? Well by introducing a parameter of semi-groups called the regular gel length, so what is the regular gel length? Basically it's the answer to the question what is the biggest max semi-group that fits in my semi-group, okay, so formally we say that this regular gel length is the largest integer n such that mn is a subsemi-group of s, okay, alternatively we can define that as the size of the largest chain of regular j-classes of s, but since I guess not everyone here is familiar with Green's relation, I think this definition is a bit easier, yes and just for the rest of the talk I will sometimes also speak, I mean I will sometimes compare their regular gel length with the j-length, so yes regular gel length is really the size of the largest chain of regular j-classes of s and j-length is just the size of the largest chain of any kind of j-classes of s, okay and so what's about this regular, yeah so first what does this regular gel length look like for the semi-groups we had as examples? So for example in the max semi-group, yeah and I will compare the size of the semi-group with its regular gel length, so for the max semi-group its size is n and of course the biggest mn that fits into mn is mn itself so its regular gel length is also n, for a group well its size depends on the group of course and its regular gel length is only one because in order to fit m2 in a group we would need two distinct idempotent elements and as we already said groups have a single idempotent element so the regular j-length of a group is one, what about functions, so the size of, so yeah remember fn is the set of functions over n element equipped with composition so it's partial functions so yeah that's why you have an n plus one factorial and the regular gel length is n plus one I won't prove that it's a classical result I mean yeah this semi-group has the green's relation of this semi-group has been well studied did I make a mistake the idea is that for every element you choose its image amongst the n element or nothing since we have partial functions yeah yeah no sorry it's not a factorial at all it's n plus one to the n yes so sorry about that okay okay and what about the semi-group of relations over n element so here I think the size is two to the n squared I hope I haven't done a mistake here and its regular g-length is this thing which looks kind of curious so the proof that this is the regular g-length of this semi-group is kind of complicated so I want to try to give an idea here but maybe I can try and see why it's surprising in some sense the thing is so so yes I told you before about the difference between the regular g-length and the g-length so computing the g-length of our n is an open problem has been open for quite a while if I'm not mistaken it is known to be super polynomial and you have some exponential bounds upper bounds and so yeah I find it kind of surprising that I mean it's not that incredible but still that when you actually drop the j classes that are not regular you end up with something that is polynomial whereas initially you were super polynomial okay so that's all about that yeah so more things about this regular g-length it has nice properties so for example if you have an injective semi-group homomorphism well the g-length goes in the way you expect it to be and same thing for a subjective homomorphism okay and if you take the g-length of the regular g-length of a direct product well it's just the sum of the regular g-length and so yeah once again these properties here they are not true for the j-length you can have semi-groups sub-semi-groups of your semi-group that have a bigger g-length than the semi-group itself for the regular g-length it's not possible because of that if you take a sub-semi-group your regular g-length has to be decreasing okay and so now that I introduced this notion of g-length I can finally define my main theorems so it's about this Ramsey 2 decomposition in a general case and so what we can prove is that well if we are longer than this thing we have a Ramsey 2 decomposition so let's have a closer look at what this thing here this thing is so yes at the exponent we have twice the regular g-length plus one and here the base is twice than the size of our sub-semi-group squared okay and well this is not tight at all unfortunately but still I mean we still have that it seems like the exponential behavior is really determined by this regular g-length so the gap is still huge but at least we kind of identify what happens at the exponent okay so yeah I won't do the full proof proofs of this theorem but I will at least give you an idea well actually for a theorem 2 I can do the full proof because we already did it in some sense this is a trivial consequence of the lower bound for the m and k's since the regular g-length is defined as the biggest m gs that is inside of us well we just take this isomorphism and we construct it exactly as we did before by starting with one and then copying it and putting a single times the next one in between okay so yeah this is the direct consequence of the previous one this is more complicated but basically the algorithm that constructs a ramc 2 decomposition of such a sequence is obtained by just combining the two algorithm I presented to you earlier so what's the idea so if you start with the sequence that has size two sides of s squared to the n plus one what you do first you compute so before in the case of a group we just computed the prefix sequence now we actually we actually need both the prefix on the suffix sequence since the prefixes can take at most size of s different values same thing same thing for the suffixes this two sequences allows us to show that there is this number of consecutive factors that preserve a prefix on a suffix so yeah basically this is just that divided by size of s squared corresponding to yeah one suffix one prefix one suffix once you have all these consecutive factors well you just split them into two parts so yeah each part has the size this divided by two if both parts correspond to the same idempotent we're done we have a ramc 2 decomposition so we're happy and if it's not the case I just keep one part and I start over again so n here decreased by one so yeah from n plus one I went to n yeah here I say keep one part actually you cannot keep whatever but defining which part to choose would be complicated I mean it's just technical it's not actually not complicated at all but yeah and so I mean yeah I guess you can understand this algorithm based on what I explained earlier what is not that trivial is why does this work well actually we can prove that it ends in at most this number of steps and since we started so yeah so if we start with u that actually for which n is actually twice the twice the regular gel length of s well we will the algorithm will stop while we are we still have a size high enough to to iterate the algorithm kind of yes okay so that's the idea and that is all for the proof of this theorem so yeah let me state once again my my two main theorems so we just proved them and yeah I can also add this theorem about the regular g-length I mean so yeah I really think this is interesting and kind of surprising so I also think it's a main theorem of this talk and so yes what should I add yeah what should you remember of this talk well if you want to find some iterable behavior idempotence are a great way to look at but then if you want to actually find some idempotence factorization for a theorem is the best of course but if we if you don't need the full power of the factorization for a theorem and if you're actually interested in optimizing the complexity of your algorithm thinking with the regular g-length might sometimes actually be better okay so that's all for my talk