 The torque will be on relations and functions, so, as you might guess, so what is a relation for me? In the torque will be mostly a relation between strings, alright, so a set of pairs of strings and as a special case you get also the total functions or the partial functions, which are functions from strings to strings, and the alphabet could be different, like we don't really mind. If you want to contrast this with the classical setting of language theory, well a language is a set of strings, so you can see it as a particular case, for instance, of a function that maps a string to either, say, the string 0 or the string 1, if you want, okay. This theory will generalize the theory of finite automata, and we will have problems, like the nice picture that we see on automata that will not go through in general to the relational case, okay. So what are automata you will know, this is our finite grasp with edges labeled by input letters, like here, for instance, you have a transition labeled by a, which means that you consume the letter a, another one that you consume the letter b, the languages, I don't know, a, b star, a, and then transducers are, in some cases, are essentially the same, it's just that you add some outputs to the transitions, okay, so when you consume a letter, for instance, you can append in the output either a letter or a finite string or even the empty string as you want, okay, and then you have many other models, okay. But that's a particular example, so for instance, in red here, I'm trying to use this color coding, that's the output, here is a letter, but you can have a string. So in automata theory, you will find many nice models, I mean, I will not talk about these models that use alternation, like alternating automata, we mostly use deterministic and undeterministic variants of automata, and then you also, I also distinguish between two variants, maybe one is less known, it's the so-called two-way variant of automata, two-way means that the head of the automaton can move either left or right, like when you want, you can actually visit a certain position of the input several times, so in the one-way variant, instead, the input head moves all the time to the right, so you can only visit each position of the input once, that's why you usually say we consume an input symbol because you cannot see it anymore, okay, when in the two-way model you can scan the word several times, okay, and then you get the undeterministic versions, and you also know that you have all these four models of automata, they have basically the same expressiveness, because you have constructions that allow you, for instance, to get rid of undeterminism, this is the sub-substruction, power sub-construction, you have another construction which is maybe less known, but it's called crossing sequence construction that allows you to get rid of, like, two-wayness, it works essentially by guessing a couple of transitions that occur at the same position in the input, but maybe at several moments in the computation time, so you guess this tuple of transitions, and then you check between two consecutive tuples that the things match correctly, okay, and then you run a one-way device, like a one-way non-deterministic automaton that somehow simulates this two-way computation, okay, and of course you can also get rid of the two features at the same time, so that's why you get all these nice equivalences, and also you get nice closure property, like closure under union, complement, I don't know, like intersection, morphism, inverse images of morphism, and so on. You also get a correspondence with logic, which I will not even mention in this talk, so there are correspondences with logic in automata theory, and also in transducer theory, okay. So the picture when you look at transducer is similar, at least you get the four models that you had in the automata, like you get one-way transducer in the deterministic and non-deterministic version, you get two-way transducer, and then you get many other models, so for instance I will talk here about streaming strings transducer that were recently, more or less recently introduced by Alur and Cerny. I will explain later what these are, they have quite a different flavor from this type of transducer, this type of transducer that they scan the input either one-way or two-way, and they produce the output like in append mode, like they can only append strings to the output along each transition, okay. While this type of transducer called streaming, they always scan the input from left to right, so they are one-way in some sense, but they produce the output in a different way, like they produce the output piecewise, like they use some buffer if you like to compute pieces of the output, then the buffer can be concatenated with letters or can be concatenated together and put it in another buffer, and then in the end you get a single buffer that is your output, okay. But I will give you an example for this. So this is an example of a one-way transducer. You see it consumes a letter, it moves that to the right, and then it produces, for instance, two copies of the letter that it consumes. So this is a deterministic, so it can only associate one single output with each input, so it computes a partial function, in this case a function, like by doubling the letter of the input, okay. So this model of transducer can only compute functions. So then you have the nondeterministic variant, and here you can use nondeterminism for two, basically for two reasons, like you can use it for associating different outputs to the same input, by using nondeterminism you can choose to produce different outputs on the same input, but even if you have a single output associated with each input, nondeterminism can still be useful. For instance, in order to guess some property of a final part of your input, for instance, that you cannot see at some moment, and then decide based on this property whether you should output something or something else. Like, this is a case. Like, this transducer will output a function. In particular, the function will basically take the last letter and move it in front in the output, okay. But to do this, if you think a bit, you cannot do it with a deterministic transducer. Like, you need to guess what is the last letter, then produce it because you can only produce the output in append mode, you know. So that's what it does. Like, it consumes a letter, and then in the output it produces either A or B, so it guesses what is the correct letter, and then it copies the letter that it consumes, it copies the rest of the input, and then finally checks that the letter was correct. The last letter was correct, okay. So I think this should be no surprise. Also, these models are close under a few properties. For instance, it is easy to see that this model is close under composition. I mean, compositions of functions or relations. That's not so difficult to see. It's close under union, of course, because you have no determinism, while the previous model was not close under union. It is close under mirroring of both the input and the output. Like, if you mirror the input and the output at the same time, well, that corresponds to reverse in the arrows here, which means that this model is close under this operation. But if you want to mirror the input or the output independently, then this model is not appropriate, right? In particular, you cannot compute the reverse function, like the function that maps a string to its reverse. Okay? To do this, you need to move your input at backward. That's why we often consider two-way deterministic, like two-way transducer models. This is an example. It is like a one-way model. It's just that, so you scan a letter, you produce some string in the output. Okay, this is always a letter, but it could be a string. And then you tell the automaton, the automaton can decide whether to move the input head to the left or to the right, based on the contrast state and the inputs input, okay? And also, you need, in fact, to detect that you are off the input, like you are at the extremities of the input, you need to pad the input with, like you do in Turing machines, right? You need to pad it with some special markers in order to know when you are off the string. So that you can come back, maybe, for instance, okay? So this example, I think it moves right by copying the input. Then at some point when you see the marker, the hand marker, it goes a bit back and then it copies the input backward. So the result will be like an input string followed by its reverse. So these are things that you can do with a two-way deterministic model. It is also, you can also show that, I don't know whether you see it here, but it's close under composition. And this is a very nice property of two-way deterministic. It's not easy to prove. Like I think Luke, you will say something about this. So, okay. And that's it. So it has more nicer property, I would say. And then, of course, you get the non-deterministic version of this transducer, which is called, like, for instance, you can copy or input an arbitrary number of times, which you cannot do with the previous model. You can compute relations, for instance. Okay? And now for the more recent model, this is called streaming strings transducer. It comes in the deterministic and non-deterministic variant. And also there are variants called copy-full or copeless. I mean, copy-full is the most permissive, the most general definition. I will explain in a second what this means. And they were introduced by Alure and Czerny. So how this works. So you don't have, you see, you don't have strings that you append in the output. But actually, you have a bunch of registers, a finite number of registers or buffers that you can load with the letters so you can actually increase their size. Like, for instance, you have an update instruction that says x, during the transition, will take the content of x followed by b followed by the content of y. And you can actually do these things at the same time. So this, when I write something like this, I mean a simultaneous assignment, a simultaneous update. Okay? So here, of course, at the initial transition, you initialize your registers. And at the final transition, you say what is the register that you output? Okay? And remember, this is one way. Like, there are two way variants of this, but I don't know, like, how did I behave? So copyful means that, essentially, you can use the content of a register several times. It means that the content of a register can be transferred to many other registers. While when I say non-copyful or copyless or single use, I mean that each register is used at most ones. Which means that, for instance, this x is used both to assign the new value of x and to update also y. So it is used twice in some sense. And also y is used twice here, you see? So single use means that if you look at the right-hand side here, you can only see one occurrence of each register. Essentially, okay? And as a consequence of this, when you are single use or copyless, you know that the output is linear. Because each register is used only at most ones. Okay, well, yeah, by the way, when you're copyful, the output could be exponential. Like, this is an example, like, at the first a, in x, you put it b followed by b, followed by c, so b, b, c. At the next iteration, you say, x takes x, b, y, which is b, b, c, c, b, okay? And it's not a very interesting example. You show that the output can be exponential. And you have this nondeterministic variant. For instance, with this, even in the copyless restriction, you can compute functions or actually relations that are not doable by, for instance, two-way transducer. For instance, you take the relation that consists of all inputs, where you can guess a splitting point, an arbitrary splitting point, like u, v, and then you swap the order of the two factors. And that's your output. This you cannot do with a two-way transducer because you would need to guess the splitting point twice at the same position, which you cannot do. Okay, that's it. So as you can imagine, all these models actually have different expressiveness, like it doesn't happen as in automata theory that you have construction to map, transform one into the other. Sometimes you have a straight inclusion, sometimes you don't even have any way to compare it, at least in the relational case. You can recover a bit of the nice picture that you have in automata when you consider the subfamilies of functions or partial functions. So what happens when you consider functions instead of relations? So for instance, it turns out that the two-way deterministic model, the two-way non-deterministic model when it computes a function and the streaming model and the non-deterministic streaming model, when they are copyless, they have all the same expressiveness. Okay, so you can, I mean, the proofs are difficult. I know where they were proven through. I mean, the original proofs go through the logic, so they show the two-way deterministic transducer. Equally expressed is as MSO, monadisecondor definable transductions, of course, cell. Then you show that these transduction are also the same as copyless streaming transducer. Okay, I will not enter this details, but essentially in the functional case, you somehow recover a nice picture. And I guess, Nikoi, you will tell much more about this later. Even more, in a more generic setting. Okay. So things got not so nicely for expressiveness, and of course you can imagine also for algorithmic problems that we expect to have difficult problems. So in this talk, this is the main part of the talk, I will mainly consider two problems which I consider somehow fundamental in transducer theory, which is the containment and the functionality problem. Containment means that you are given two transducers, the one and the two, and then you want to decide whether the relations that you compute is contained one into the other. And with this problem, of course, you can solve emptiness, you can solve universality. Universality, I mean, given a transducer, you want to test whether this computes the, if you were able, you could solve universality by testing that the relation is universal, you can test the equivalence if you were able to solve containment, okay? And functionalities and a different problem, like you're given the input is a single transducer and it asks whether, for each input, it associates at most one output, okay? It computes a function, essentially. So let me formalize a bit what is containment, so that you can formalize it in a strange way. So the input is two transducers, imagine one way transducer, for instance, and then you can formalize containment as follows. Like you say, for every input, for every run of T1 on this input, this is row one, it's the run of T1, there exists a run of T2 on the same input that produces the same output as the run of T1. That's the way you will formalize containment, okay? And you see that, I mean, this problem is going to be difficult in general, because you have this, this alternation of quantification, essentially, right? You say, for all, like imagine, if you want to find a witness to non-containment, you would imagine that you could guess any input in the run of T1, but then you have to fight against all the possible outputs that T2 could produce in order to disprove that the T1 is contained in T2. So this, this alternation of quantification makes the problem hard. So not surprisingly, it is undecidable. And I think I wanted to present the proof because I think not because it's really nice, but because you found it many times also in several, in different models of automata. Like for instance, you find the same idea of reduction, like I mean a reduction from the PCP, post-correspondence problem. Like for instance, in trace automata, like in the theory of trace languages, like in multi-taple automata, which is essentially the same thing as one-way transducers. So I think I will try to present the proof. So PCP, you know what this problem is, post-correspondence problem. And you are given two word morphisms, F and G, that map a letter to a word, and then they are extended homomorphically to strings. And then you want to know whether there exists a word from the alphabet A such that when you map this word here through the function F and G, you get the same word. And of course, you want this word to be non-empty because otherwise, you always get a trivial solution. So this problem, you know it is undecidable, and we reduce it from it. So one idea you could have is that you could try the following approach. We will not work. We could try to declare, for instance, T2 to be the empty relation. This is easily doable by a one-way transducer. And you can try to define T1 as the transducer that computes the relation of all pairs that somehow encode good solutions of the PCP. And then you have that T1 is contained in T2 if and only if you have no solution, essentially. So this will not work because it's hard to encode actually a good solution of PCP. That's why the problem is undecidable. But if you think like a dualy, like you can actually do the opposite, you can try to encode the bad solution. And this becomes easy. So how do we do? Like we say, so if you have to do this dualy, we have to declare T1 to be the set of all possible pairs. And by pair, I mean like a pair of input string and an output string. An input string consists of two parts, like U and V. U is meant to be like this witness here. So it should not be empty. V is somehow, I mean, not in this definition, but somehow it's meant to be this word, F of U, which should be equal to G of U. So V is meant to be this word. And that is somehow a redundancy code that you put in the output to help you check that things go wrong. It's a sort of control string that you put in the output. And you will see that this proof really uses the fact that you have this output that you can associate many outputs to the same input. So these are all the pairs. Then you say, of course, you define what are the good pairs. Of course, they need to be to satisfy this relation. V needs to be equal to F of U, which needs to be equal to G of U. And the control strings, here is the property that we would like to satisfy if we were looking for good pairs, is the length of Z is equal to the length of P. And now you take the opposite. Like T2 will be exactly the complement of this language. Like T2 will be T1 minus G. So all the set of bad pairs. So that you get, of course, T1 is included in T2 if and only if all the pairs are bad, if you have no solution. So how a pair could be bad could be bad because of two reasons. Either you have the control string, which is wrong, or when the control string is correct, you can have either V different from F of U or V different from G of U. So we're going to somehow exploit this property like here. We write this set as two sets, which overlap. In fact, they overlap in the middle in this condition. Like Z could be different from V. I wrote it as an implication, but you could read it as either Z is different. Like the length of Z is different from the length of V or something like that. I wrote it as an implication because I think it's better. So and now I will show that each of these two relations, you can compute it by a one-way transducer. And then, because they are close on the reunion, yeah. Why do we need Z? Why do we need Z? I mean, you will see in a second, I think. So Z, you need it to have some redundancy in the encoding so that it becomes easier to expose a problem in your encoding. In some sense. I think you will see in a second. You add a lot of redundancies to your objects that you compute so that it is easier that things can be wrong. It is easier for you to expose the problems. You will see in a second. So once again, you have a bad pair if the control string is wrong, or if the V is different from F of U, for instance. So you can check this with a transducer. It seems difficult, but actually you can. So this is the picture that I'd like to show. So this is the input, like it is U and then V. Your transducer will guess splitting point in U and in V and also splitting point in the control string. So you have three splitting points that ideally, you would like that this splitting point, they match, they represent the same way of breaking up the things. For instance, you would like to say that this splitting point in U corresponds when I take the image under F to this splitting point in V, for instance, if things are correct. But this you cannot check. Of course, if you read the input with an automaton, you cannot check that these two splitting points are correct in some sense. That's not a regular property. But at least you can check that these splitting points corresponds to the splitting point in the control string by saying the length of it. You consume the input here, the first part of the input, and then you produce as many control symbols that you need in order to have this relation, like a length of Z1 is equal to F of U1. Then when you will read the last part of the input, like V2, the suffix of V, you will do something similar. You will check that the control string has the same, the rest of the control string has the same length as V2. So now, what happens? If the control string is correct, this automatically enforces the correspondence between these two splitting points. So indirectly, if you knew that the control string is correct, then you get the splitting points are correct. And by means of this, you can check that the rest of this string is not the F image of, I mean, you map it through F, and that's not V2. And you can do this by checking that this letter, for instance, is not, when you map it to F, it's not a prefix of V2. Otherwise, maybe the control string is wrong, but that's exactly the definition that we put. That's why we put this redundancy. So I think the bottom line of this proof is that it really exploits the fact that you have multiple outputs associated with the same input. So now, the natural question is, what happens if you restrict this number of inputs? For instance, if you have at most one output associated with each input, for instance, you have a function, well, does the containment probably become simpler? And the answer is yes. So in fact, you can show that the containment inside the function, so when T2 is a function, containment reduces to functionality. T1 is contained in T2. If T2 is a function, if and only if T1 union T2 is a function. Here, there is a catch. I mean, you need T2 to be a total function, because otherwise, you could have T2 empty, and then you can still have a function, even though you're not contained. This is not really important. I think it's important if you care about complexity, because now, now that I know that containment reduces to functionality, I will try to show functionality. I will give you some complexity bounds. But you have to remember that if you deal with partial functions, implicitly, you have to test also domain inclusion, which is a property of regular languages. And sometimes, the complexity of checking domain inclusion like dominates the complexity of checking functionality. So you have to be careful. I will state complexity for functionality. Most of the time, they will transfer to containment, except when the complexity is really low. We'll see in a second. So functionality, let me define it as before, in the same way I define it for containment. You are given in our single transducer, and you want to check whether for every input and every pair of runs on the same transducer on the same input, like row and row prime, then you get the same output. That's the definition of functionality. And you see that the quantifier alternation here has disappeared, which is like a signal that the problem could be simpler. So now I will describe it like I think two approaches. Like one is a bit older. I think, I mean, I'm not sure why that. I think it was first proposed by Alur and Dexmond, but I'm not sure about this. Maybe there were similar ideas before. So this approach will work for most of the transducer types, except the most expressive one, which is the copy, full, streaming transducer. Of course, here I'm talking about non-deterministic transducer because I want it in general to be computer relations, otherwise the answer to the problem is yes. Okay, so the idea would be that if you want to check equality between two outputs, you can do by checking two properties. Like you want to check that the length is the same, like I wrote it like this, the length of the output of row minus the length of output of row prime is equal to zero. I wrote it as a statement about numbers, okay? And at the same time, you also want to check, well, don't read it here, you want to check that in every position, the two outputs have the same letter. So I will rephrase it, I think, contrapositively, I will say it, whenever you find two positions in the two outputs that have different letters, then these two positions must be different. That's an involuted way to say the same. But if I write it like this, like for every pair of positions, whenever I see different letters, then the two positions are different, you see that it has a similar flavor as this problem here. Like it is about counting stuff and making differences and checking that something is either equal to zero or different to zero. So let's see how you first decide this property here. Like for one way transducer, actually this is quite simple. You can imagine that you run, you have your input and you annotate your input with two possible runs of T. Like you have now, you can read the annotation of the runs, like you can encode it on the input, okay? Now each run at each position as the transition that produces some symbols, like a certain number of symbols, usually this number is bounded because you have a finite number of transitions. So for instance here you can produce five letters and here you can produce three letters in the two runs. And then you take the difference and you put this difference into a counter. So like you increment or decrement the counter according to how many letters you see one run or the other. And finally you check that the counter is zero. Like that's exactly how you check the different, the two lines are the same, okay? So this reduces the problem. Like this type of machine that reads the input and two annotating runs. And then it uses a single counter and checks zero that you can think of as a one counter automaton which you can decide, like for instance, universality or emptiness as you want to like in good complexity in the end. If you prefer you can also like phrase it like you can see a one counter automaton as a push down automaton. For instance, where the stack symbol is the same if you prefer. So for two way you do actually something similar. The only difficulty here is that the run can go back and forth on the same position. So what you do, you annotate with what we call the crossing sequences. I gave an intro before. So the crossing sequence is a tuple of transition that occur at the same position of the input, maybe in different moments in time of the run. You will check that these tuples match in consecutive steps. And then you count how many symbols are produced in each of these transition and then you start to have the number of symbol produced in the other run, okay? And you do the same. You have one counter and you increment and decrement it. The only difference is that because you are guessing tuples, now the automaton is going to be exponential. So the complexity is going to be p-space. So by the way, for instance, in this case, you can solve containment in p-space. In this case, if you deal with partial function, you will be able to solve containment in nl, the max between nl and domain containment, yeah? Yeah. The p-space algorithm, it was already in Burari in 1982. Yeah, you're right. They knew the p-space complexity. They knew the p-space, but I'm not sure this is the algorithm. I think it's the same. Counting the, guessing a counter example. Okay, see, okay. Thanks, thanks a lot. Yeah, so for streaming transducer, remember the streaming transducer was this model where you have buffers like registers, which you update by concatenating, and copy less or single use means that you can use a register only at most once. They will be the same, essentially. Like if you are copy less, essentially the number of symbols, you count the sum of symbols that are inside your registers, and then you increment your counter accordingly. Like if you're copy less, this increment will be bounded, like you can deal with one counter. Essentially, it is the same. There is only one catch here is that some register can get reset. So you have to guess which registers are eventually reset and which are not, and then you count only the register that survived until the end, okay? So for copyful streaming, you cannot do this trick because actually you have several registers, and for instance, the length of the output is exponential, so of course you cannot do with one counter. So you will associate one counter to each register, and then you update the counters as the updates do. Like for instance, you get updates of the form x plus two y plus one, et cetera. And then you want still to check the final result is identically always zero. So this is called the zeroness problem, and the type of automata that you have are the so-called a fine automata or a fine programs. A fine just means linear, okay? So the updates in this, the transition in this automata are linear functions. And now for the second part, I think I will try to be a bit quicker. You essentially do the same, like you can imagine you can compute a transistor TA that produces prefixes of the output and in the symbol A, you can do the same for TB, then you take the product of these two and take the difference in the length of the outputs, okay? And then you check that this difference is always different from zero. This approach was for the first three cases where you can deal with the one counter machine, just because one counter machine you can test for zero, you can, if you want, you can easily complement or the algorithm actually works also for the MPS problem. It doesn't work for a copyful streaming, essentially because here we want to check, I mean, look, we want to check something is known, always known zero, which is a non-reachable property, like it's exactly the dual of the zeroness problem, which starts now to be undecided. Well, the previous problem I didn't say, but I didn't show why it is decidable, okay? So I didn't say because actually for this model, we have another approach which I think is much nicer. It gives much worse complexity. So now we'll explain what is the second approach that you would use it for copyful streaming transducer or for other models of transducer where the one counter reduction doesn't work, okay? So even here, I'm not sure about who in, like, I think it is a series of papers. I think the presentation style I will adopt is more consistent with what Niko has been presenting. So the idea would be that we are trying to reduce again to the zeroness problem, but we don't make any distinction between length of the output and letters in the output, okay? So we are actually encoding the entire output with a number or with a couple of numbers. The idea would be to encode a string with a couple of numbers, okay? And then, like, as you update the strings in the register, you can update these numbers using special functions. The idea would be that instead of having, for instance, linear updates, we will have polynomial updates because the encoding is a bit more complicated. Let me show you the encoding. So again, the idea is to encode strings into numbers and I'm here and I'm simplifying the stuff. So you encode the strings in the output with the, for instance, if you want, you can encode strings with just a single number. You can enumerate all the strings in the natural numbers, okay? But to make things work, we will need that this structure is going to be a ring because there is a theorem that says that it's only applicable to rings. We will also need this structure to be countable because at some point you want to enumerate the coefficient in this structure. Also, here I don't, I think there's something wrong in the slide, but I think we also need another property that this ring is, I think it's called algebraic, like somehow it contains all the roots of the polynomials because at some point we need this property, but anyway. I think it's fine if you think of this ring as being the pair of rational numbers. And the idea is that you encode a string with two numbers, like the y coordinate is the exponent, like the number of output symbol power to the length of w, for instance, epsilon here, the one letter strings here, the two letters strings here and so on, okay? And then you just, for the x, you just take the lexicographic order on the strings. You can think of if gamma is a binary alphabet, you can think of this being the valuation of a binary expansion, okay? But why did we choose to have this second coordinate here to be the exponent? That's because we want to have a mapping also for the operation that we can apply to the strings, like in particular, if you want to concatenate, we want to express the concatenation in terms of a simple function on pairs of numbers, okay? So in particular, here it is, you concatenate two strings and then you take the encoding, like you can see it as a polynomial applied to the encodings of the arguments, okay? So if x, y are the encodings of w and x prime, y prime are the encodings of w prime, then, for instance, the y coordinate will be the product because that's the sum in the exponent. And here you're basically shifting the encoding of x to the left by a certain number, exactly the number of letters that are contained in w prime and shifting means multiplied by y prime and then you add the encoding of w prime, okay? So the takeaway message is that the concatenation becomes a polynomial function and if you have an update now that is essentially a bunch of concatenations in the register, they become polynomial function applied to pairs of numbers, okay? Or tuples of numbers. So when we encode our transducer, our semi transducer with this approach, we get what we call a polynomial program or a polynomial automaton that is an automaton in which the transition or polynomial functions and the register are numbers, okay? Like rational numbers or algebraic numbers. And now the problem becomes the zeroness problem because if you want to do, to check, say, functionality you take the difference and you check that it is always zero. Now you see that you don't need this distinction between the two cases, okay? So how do we solve this problem? One idea, so I will try to be quick here. One idea is that, well, first, if you want to witness something is known, zero, that's easy, just enumerate all the possible inputs and run and you'll see whether something is going to be known empty, okay? So you have a semi decision procedure for witnessing non-zeroness. So you can focus on the other part of the procedure that proves zeroness, okay? Then also you can assume that you have no states if you want to simplify, this is not really important. The idea would be when you want to prove like a property like this, which is an invariant, actually you use invariants. So what is an invariant? An invariant is just a set of configurations of your machine, in this case, like a set of tuples of numbers, which contains the initial configuration, like this is your machine, for instance, it has an initialization in the register and then it applies a bunch of polynomial functions and the invariant needs to contain the initial configuration and needs to be closed under the application of these functions, okay? That's the definition of invariant and you say that invariant proves zeroness when in the coordinate that would correspond to the final state, I mean assuming that we got rid of the states, you always see zero. And of course this is not so nice because you see, but like invariants are very complicated sets. Like for instance, you can imagine that you have a polynomial automaton that rotates a certain configuration by applying a function and then it multiplies like it makes a spiral like this. It's very hard to deal with this, in particular it's hard to test whether something is zeroness for instance, okay? So what we want to do, we want to have simpler variant, actually a subclass of possible of the set of a family of invariants and that's how we define it like this subclass we call the S, a generic set of numbers is algebraic and closed. If, I mean this is, I think this is the way I think of it, if you can describe S as being the set of solutions to a system of equations that consist of polynomials function, okay? Or equivalent you can say that S is the set of roots common roots to a set of polynomials. That's the same. Here the system of equation a priori could be infinite, okay? So we need this because we want to form a nice topology in particular want to be closed under infinite intersection and finite unions. So for instance you want to be closed under infinite intersection, you take the, you make the union of your system, your conjunction of your system. But if it is infinite the system will become infinite, okay? If you want to be closed under union, you can see it by, for instance if you have an equation, a single equation, another one and you want to take the union of the corresponding solutions, you multiply the two polynomials, okay? Let's see. Once you have a topology you can describe easily a closure operator, which is the least closed set that contains the set that you want to deal with, okay? It is the intersection of all the sets which are closed and that contains your set, okay? So I think I'm still, yeah. But what you prove essentially is that you, by restricting to the feminist of closed sets you don't, don't miss actually some invariance. You prove that whenever S is an invariant you can prove that the closure of S is also an invariant. You can also prove it, let me skip this. That if S proves zeroness, then also the closure proves zeroness because essentially the set zero is already closed by itself, okay? And now there is the last piece, is that still but are these sets simple enough? Like can we enumerate? But the point is that we have to use this fundamental theorem, Hilbert's theorem that says, even though you allow the system of equation to be infinite, whenever you get a closed set, actually you can represent it by a finite system of equations. Not given a proof. Like the, I think the analogy is with Dixon lemma, for instance, when you have, you show that a certain order is well-founded. Here is essentially the proof is the same. So you know that every closed set can be represented by a finite system of equations. And now you can enumerate these sets essentially and try to search for an invariant, okay? So that's how the semi-decision procedure works. You enumerate all the finite sets of equations. You check that they define invariance by checking that here I think there is a hidden problem but you check, you need to test that the initial configuration belongs to the set. It is closed under the polynomial updates that you have in your automaton and then you check that it proves zeroness, for instance, okay? So to check this, actually I think you need to, I'm not sure but I have to think a bit, I think you need not rational numbers because actually otherwise you would be able to solve Hilbert problem, no? You need a bit more structure but still you can make it countable, okay? So the corollary of this would be that you can test functionality for even copyful streaming transducers and you can check functional containment and this works for basically many models of transducers including I think I saw Miko also presenting, actually this was proved first by Saddlemanet and Kemper. You can use essentially the same approach to prove that three to three transducer. You can also for this transducer you can test functional containment or functionality, okay? Yeah, let me just briefly mention like some other open problems that I'm actually, I'm trying to work on but I find them difficult and the reason I think is because you cannot avoid the combinatorics, you cannot use this method essentially, you have to make your hands dirty and like use real combinatorial arguments like pumping lemmas and stuff like this. So this is a problem, the following problem is say, imagine that I didn't explain what is K-valued. K-valued means it's just a finite union of functions like T computes a finite union of functions or you can rephrase it as saying you have at most K output associated with each input and once you're given T you would like maybe to decompose it as a finite union of functional transducer like you want to have a structural way to see this, okay? This is the most, you can do it for one way and to way it is open for even copyless transducers. I don't know how to do, I think we tried it for one register in special cases but the corollary, but if you're able to do this you would prove nicer corresponding property between different models, okay? And you will get for free that containment is also decidable. Another problem which is open and it seems that it has to do with combinatorics is to determine, I'm not a fan of complexity but if you want to determine the extra complexity of the containment problem of say copyless streaming transducer which are deterministic then you see that the only bounded upper bound you have is space and the lower bound I think is an L. So, and if you try to solve the problem you see that there are combinatorics in it, so. And that's it, I think that there are other things that yeah, I will not be able to mention. Many others, yeah, thanks.