 Okay, so this is about a six-point extension of the guarded fragment and It is inspired by the muciculus. So the muciculus is a very very pleasant logic for well logicians it's Like an assembly language if you want to work with transition systems or with directed graphs And you can translate all specification languages into it and unlike some of the specification languages it has Reasonable model theoretic properties. So what the muciculus does is Set out with a very simple logic so basic model logic that That means propositional logic plus the ability to quantify over successors of a current state. So it's a very very restricted quantification pattern and Then add fixed-point constructs, which are useful if we want to to write formula the way we would write programs. So What we can do is we have a notation for loops of this kind It starts with the empty set and then apply an operator Until nothing happens anymore and then stop Return the value and okay the alternative is to start with the whole universe and apply the operator and get nothing more happens so we have a very weak local logic that talks about About what happens to the current state and about the immediate successors and then we have this simple recursion mechanism that lets us Move local assertions along passes essentially and that explains why It is it can be interesting for verification because in verification We are very interested in in executions and this is what the muciculus can do. Well, it can run along executions and Describe how local properties evolve and it has also the branching ability that the muciculus has so sorry the model logic has and there's something about Branching ability that to which we will come. So first if we look the muciculus abstractly is it is a Very friendly logic as it has a tree model property. So we have Whenever a formula is satisfiable we can find it satisfied in a tree and also it has finite model property and then You can Reprove preservation tolerance mean that show that things that I mean syntax and semantics are in a healthy relation and interpolation and so on and also, it is algorithmically friendly, so we are Quite close to P for the evaluation of calculus formula. So actually we are in a class in which the parity the Primes were before NP and call and P and This gives us hopes to that one day it will be shown to be in P at the moment It is not known yet and satisfiability is next time Okay, and then well, it is somehow maximal in what we could expect to have as a friendly logic and This maximality has to do with dissimulation invariance. So by simulation Is a is logical equivalence for model logic and it means behavioral equivalence for four systems we can We will talk about different dissimulation relations later on but I mean as long as we don't want to distinguish Bissimilar models model logic is as strong as first order. This was a very interesting characterization by von Benton and and and calculus is the Bissimulation fragment. I mean of monadic second-order logic, so it is like the lifting of model logic to a second-order and Well the key to to most of the proofs that are relevant here Have been relevant for the mucculus are that we have this B-simulation relation That allows us to manipulate models. So instead of working with arbitrary complicated models. We can also we can always Massage things into trees and then we can let automata run and then we get whatever we like automata very nicely behave and Well the ambition is to to have a logic that is equally friendly But does not is not restricted to to talk about executions I mean not to about about transitions in in graphs and only forward moving things, but Well, it should be able to speak about databases and it should be So it should be able to talk about higher erities and not Have a notion of direction and we can see how far we get So the idea for the model for for the gadget fragment is that to to take the model Fragment and replace these guards which tell look at successors with new more general guards that say, okay new new look at new variables that are linked to those who In which we are free. I mean to our currently Free lab variables In in a simpler way, okay This is the just the point So We will look at a very basic The basic artist fragment where this Relativization guards are Atomic formula, so we have the relations from the vocabulary and we have equality and nothing else and Then To to make some efforts. I mean to explain why we do some efforts We will talk about a bit more. I mean more general fragment and there So the guards So this formula that tell us how the newly quantified variables should relate to the old ones they talk about a generalization of being an atom and Being an atom. I mean if we forget about erities And so if we just look just look at the underlying structure of a of a relational structure So I Mean the Gaffman graph of a relational structure What does it do to a couple that is? That is in a relation it makes a click out of it And here we say we can because I mean a relation relates every two elements in its entry now we we allow Quantification over any members of a click and And one consequence is of this is that as long as we are in the basic guarded fragment So every time we quantify of a new variables They have to to be connected Through a relation so we can never talk about more Variables than our signature Our vocabulary is large. I mean if our maximal erities three We can never talk about for variables that are alive at the same time Okay, we can use equality, but it doesn't really help so This is a I mean we can get rid of this of this Restriction by looking at this guy from an Sense of gardening and there we can have formula that are I mean that have sub formula with arbitrarily many Free variables, so that's this one of the reason we don't want I mean complexity Results that are good because the weeds are bounded by definition Yes, I mean we can write it and we know how the relations are called so we can say that every two members in this in this Couple They are related in some way, so we will Quantify over the remaining members and we'll say okay. These are I mean they are part of relation So you see for example, if we have ternary relations So well, I told them so say I related these three things With an R and these three things and these three things now I Mean a priority this tree. They would not be or I mean all the four They they are not guarded in the strict sense, but they are guarded in the the Gaifman sense So I can write a little formula that expresses that That I'm talking about Four elements which are in this configuration. I mean the syntactical. It's this is a formula that guesses whatever is needed to complete The topless and semantically this in the moment I have a valuation and I try to so early to sub formula. I have to make sure that The variables are allocated to something that's So now we go to a logic that is strong and I'm in the calculus and we can then first order logic plus fixed point so we extend this goddess fragment with with the least fixed point construct and Then we have the dual greatest fixed point construct. So the least fixed point you have seen already today an ocean Jam and the greatest fixed point Well, it's just the dual notion and Well, I mean what we are sure immediately that we can do is we can talk about The mucus by referring to backwards modalities. So instead of saying I have a successor with certain properties I can say I have a predecessor. I can talk about Edges that form a loop or but then on the other hand, I can also speak about database. I mean About about higher topless of hierarchy. Okay, and Well, I will try to put together some tools so that It I mean we have everything that we used to have for my calculus kind of Logics to do satisfiability and then show you that actually these tools are not enough and then maybe you I mean then then we have a better insight on on Why that this this logic is a bit more than just a miraculous. Okay, that's my intention so I mean up early we want to look at Questions of I mean, okay, we have a formula. We have a structure We want to know whether the formula is true in the structure and then We have two structures We want to know whether there exists any formula that can distinguish them And then we have only a formula. We have no structure. We want to know whether there exists a model or Even less so we have a formula and we want to know whether there exists a finite model so let's see How we approach these things with I mean knowing less and less about the structure so if we know all about the structure then it's about Model checking and here. Oh, sorry So this is the problem Yes, we we want to know we just want to evaluate Got a fixed point formula. This is not I mean there is nothing very deep To this point. Okay, so now up here. I would just take Relations from the initial vocabulary as guards. Okay, so There will be some games that come in over and over again and John already made fun of me in saying that I'm I Will probably talk about games. So but I will not it's about automata. So the underlying Tool for for doing Model checking and also I mean to to build up the automata later on our parity games and So if we forget about the logics, these are quite simple Games we have two players and they form an infinite path. So they are parity games are described by Graph. Is there anybody who has not seen I? Mean, do I need to explain parity games? Okay Yes, okay So This is the description. We have a directed graph and then some of the north nodes are marked as belonging to one of the players and then we have a labeling with of of nodes with numbers and For this labeling, it's important that it has finite range. Otherwise, I would not I mean I would not expect that this graph is finite It can be an infinite graph, but I want this priority labeling to talk only about finitely many numbers and then you we can so to play on such a On such a graph what happens is that we start at a given Position, but this is a constant of the description and then the two players form a path This goes like said if the current I mean if we are at a node that is marked to belong to what player alloys then she chooses the successor and If it is not her node and it is a blackwood chooses a successor and this way we continue a path but it can happen that a Player gets stuck and then he has lost and the game is I mean the place over These are the clear cases, but it can happen that we have we have an infinite Way to the path and then we look at the priorities that Were on the that we met and since the range is finite We have seen infinite many nodes and there must be some Priority, I mean there must be several priorities that appeared infinitely often But we look at the lowest one and that needs to be even so it's a this may be a bit strange but the point is we want to I Mean I probably want to talk about things that happen over and over and again And then we want to to talk about them in a in a nested way we want to to just not just talk about things that happen over and over again, but We want to have some degree of freedom there. Okay, and In such kind of games in a strategy, okay for one of the players would be a Function that has for a given prefix how to continue and Here we are talking mostly about memory less strategies. These are Strategies, I mean there are functions that just tell you at one node which successor to choose So with a memory less strategy you can also play You may not be able to win So following a strategy means Whenever you are asked to move then you look at your prefix or at your card node And you apply your strategy to choose your successor and the winning strategy is one that guarantees that you will win everything I mean all the place if you follow it and So if we if we think in terms of graph and off So we said a game is just a graph and a memory less winning strategy would be For the positions that belong to a noise a selection of nodes of Successors or just a selection of one outgoing edge so Alois has a winning strategy in a graph if she can select from each of her position one edge and throw the others away and Then to win means that every cycle that is formed in the remaining graph has a an even minimum And now for for the other player. It means that I mean he can choose one successor from every node that belongs to him and then every cycle has a an odd minimum and It's not so obvious know that either you can choose I mean from half of the nodes You can choose a successor so that all the cycles are odd or you can choose For the other half some possesses so that all the cycles are even What's up and well, this is the the term that helps a lot For automata that in parity game it is indeed a case that you I mean you are in one of these two Situations either Alois can choose one successor that makes all the cycles even or a belacan to choose a successor so that all the cycles are odd and Well, then the algorithms of parity game so easy to understand I mean up to the point to which we know them if you have only one player it is Not very difficult to see that It's in p-time to tell who is I mean whether he wins or not Means if you have a graph to tell whether all the cycles are are even or that's not difficult and So if we go to the two player version then it's about guessing I mean if you guess the strategy then you can tell whether it's a winning one So this gives you an np thing Np algorithm and so you can do it for the other player then it's a coin piece over a np coin and The deterministic algorithms they usually have the number of priorities in the exponent, but so there is a very interesting algorithm if I had huge amount of time I would tell you a bit about it so There is a An algorithm this is really easy to understand it it builds kind of a potential for the for the positions of the game and So The idea is that if you have So this potential is an encoding of a winning strategy. So it's something atomic it's it's You assign a value to every node and It's So whenever you You go lower You look at the neighbors and you you go to you find a neighbor that has a lower potential And you can take it and this will guarantee finally that you that you win something like this and So a quite simple algorithm shows that If you start with potentials, I mean a vector of potentials that is about half the priorities So this this is why we have this d half then Well, I mean this is enough to put in the exponent and in the for the remainder we are Well, I mean we have the the number of nodes in the basis. So that determines the complexity Okay now So model checking for for new for gather six point logics is it's exactly parity games so What we do is we take the first order evaluation game Hintika and then we we do something about the fixed parts. So For the first order part There will be no secrets and the fixed points they do exactly what the priorities are responsible Okay, so what is this? I mean morally this game is a product between the formula and the structure so the formula you can think of the Of the syntax tree. Okay, it's not really tree. It has some loops because we do I mean because of the fixed point variables, but think of the syntax tree and then you have the structure so the positions in the game are a pointer to a place in the formula pointer to a place in the structure and we start in the with the entire formula and we point to Well, no particular place in the structure because the entire formula doesn't have I mean we talk about sentences with no free variables And then the moves they are designed in such a way that if a formula is true With uh, the free variable is bound to the point of to the structure then Alloys should be able to keep it true and if it falls then our blash should be able to keep it for us. So this means that Disjunctions and existential quantifiers are removed Like in the hintika games fixed point variables are just regenerated and we end in the atom. So this is the What happens in detail So Okay, this is not surprising everyone to so say We talk about alloys. She wants to prove that the disjunction is true and has a certain valuation But well, then she will choose one of the two members of the disjunction and we will have we need to stay with the same Valuation, so this is what happens in a disjunction step in conjunction is dual Then for the quantifiers we say alloys should prove that there is a witness y that is Tightened with the guard alpha to the open variables And then makes phi true And we have so the current valuation is is beta So what we will do I mean what possible successors are the formula will certainly be phi that we need to prove but then the valuations So there we will choose valuations that satisfy the guard and this means guarding whatever sense and they do I mean The new valuation should agree with the current one on the variables that That I mean on the on the data kept So we have new variables that are bound now and then the x variables they they are kept so they should not Be changed by this transition. So should be quite natural thing. But what is important is that Well, whenever we choose Something new from the structure we move from a guarded tuple to something which is again guarded We never move away from some from guarded spots And okay, the rest is A trivial for the game. I mean we fixed point variables are regenerated with our definitions And when we meet an atom, then we can locally check because we have a valuation. We have a formula who is winning Okay, so we have to To monitor what happens with these fixed point regenerations and they are the idea is that So The outermost verb that is regenerated Definition that is regenerated infinitely often should be should be a greatest variable to make Alloys win and then we distribute As many priorities as there are Real alternations between greatest and least expended variables to to make this happen So we have to take care that least fixed point variables get bad priorities for alloys and Greatest fixed point good ones and That the dependencies are reflected in the significance of of priorities Okay, so in the end we will give as many I mean we'll distribute as many priorities as there are real alternations of fixed point variables Okay, and now Well, it turns out that this is alternative semantic for truce of guarded fixed point formula in structures and the proof is Well, I mean the important part of the proof is what you do with the fixed points and There is a very nice correspondence there you can take A fixed point formula and unravel them syntactically and count how many time you have unraveled them Until they become true. I mean since you have a structure if the formula is true it will I mean by by progressively coming embedding it into an infinitary variant of Of the model logic you will find True statements we find the find the two approximate and this approximate I mean you you do this for every Say every least fixed point variable You calculate the approximate at which it becomes true and they give exactly the progress measure So this gives us immediately a proof that That if a formula is true, then we can we have a winning strategy to To win this game. So if the formula is true, then We win the game and the other way around as well And this does not depend on on having finite structures. So we can all we need is finitely many priorities So find it for Okay Um What the story is more I mean what is most important in this part is that I mean we have the So this is our syntax tree of the formula and we have disjunctions and conjunctions and sometimes we regenerate a variable So it goes to its definition and there they are these regenerations. They are somehow Um Nested and we are interested about what is regenerated infinitely up But I mean this is happens on the on the formula side and then on the structure side Whenever we talk As a sub formula we talk about A spot so something which is well at least click guarded. I mean if it is Normally guarded so something very very dense and very local in the structure And when we move to another formula because say if this was an existential quantifier, then we go to another guarded structure So the elements of the structure about which we talk they are somehow close together all the time And this we will need to use Okay, for the rest we can use the game to tell What is the complexity of model checking actually the complexity of model checking is quite close to to I mean it's much closer to model logic than to first order in general Okay, so Let me see no too too miraculous than to least fix point logic So the same the games don't become very big especially in the case of strong Of strict guards, then we have only I mean what we are interested In the structure there are only entries in the relation tables and entries in the relation tables They must appear in the description of the structure. So you're your I mean the size of the game is linear in the size of the description of your input structure And okay, this determines the space that you need to To solve the game, but uh, the complexity is still quite good Which this is the space complexity And where the time complexity is just bothered by these alternation gaps Then when we have uh click So with click guards, it's a bit more difficult Oh, yeah, yeah, sorry To to tell that they are They give us some advantage in complexity, but well, I mean if you know a bit about three width, you know, so We have to so this bots in the structure in the case of click-ardedness are clicks in the geifman graph So The question is how many clicks can we have in the geifman graph? And what happens is that clicks? I mean big clicks make the three width very high So one way to parameterize the complexity here is to say to look at the three width If this three width is small the clicks cannot be big So this gives you a bound on the on the on the sides of the game, especially I mean games that are somehow Close to looking like uh trees they they will be small And those structures will give small gains okay, uh now we have model checking complexity, but So um in the case of mu calculus and I mean the traditional approach of of doing satisfiability with with, uh Automata is that you design I mean you come up with a model checking Automaton I mean automaton that you can feed in An input structure and it tells you whether it's a model or not and then you try to Do some emptiness test and of course you have to To have the correct coatings of the structure, but this can come So Now it's a matter of the of the coding we we know the model checking game And we will be able to make an automaton that does the The formula part that reflects the formula part of our guarded It's uh Well of our model checking problem so that guess is the part of the structure But the question is how to massage the structure so that we will get something that automata can eat And uh So the the main tool is It's the guarded variant of bi-simulation And we we can think of it The easiest way to think of it is an errant for it for a C game It goes just like the first order and for it's for a C game The only thing is that you are The spoiler is restricted to to put his pebbles on guarded tuples. So he can never Put If he Let's say I mean he cannot put his third tuple And the position that is not connected to the other two So he always has to live on islands and uh Well, that's it. I mean if since the the spoiler has this restriction and the duplicator must of course also stay on guarded tuples and if you If you have two structures on which duplicator would win The errant for its for C game in this case Then uh for any formula you could also see that the model checking would work in the same way on the two structures. So I mean this game would guarantee that The evaluation games don't distinguish the structures for any formula. So God the simulation is defined here is I mean god logics are invariant under this time of by simulation And well, you can also do it. I don't know whether we need it today So you can view it as a system of partial isomorphisms that you Can extend back and forth Uh Okay But um, so There's one very very nice idea here um So the idea to To encode of a structure everything that we will need to know While playing the errant for its for C game on this structure But that's a bit we have no because you play errant for its for C game on two structures But look what I mean what this Structure encode so we take Right, we take a first order structure here with horrible erities and so And then we construct a graph and we label this graph Uh With the guarded tuples and then okay, so we we associate we take a note for every guarded tuple We make individual elements for this For these tuples in our new graph So here will be an element and here will be and then We label them with the shape. I mean Well with the structure that we copy. I mean we copy the structure As a label to this graph and then we link Uh Two notes with an edge that has Which part of the I mean of the label from here Overlaps with the label from here This is something we will use quite often so it's a way to I mean this this This graph tells us how the The the guarded tuples are arranged in our original structure and now it turns out that I mean if you have two games I mean the errant for its for C game between two structures and if you take their Their game graphs, I mean the graphs constructed in this way, then you have guarded the simulation between the complicated structures even only if you have traditional model B simulation between the Between the game graphs and uh so this will be Usefully in a while because um Okay, so once we have a traditional graph representation of Of our I mean it's not really our structure. It's not the guarded structure It's only the representation of the errant for its for C game on this structure. This is a guarded B simulation graph but um Well, it it carries a lot of information about this structure. So Well, whenever we have a graph and we want to do automata we are we are tempted to unravel it So the data structure with which we work are the composition trees and they So they look I mean there are particular kinds of of graphs of of game graphs guarded B simulation game graphs so they are Their nodes are labeled with little structures of of small size Of a bounded size. So this we fixed in the beginning Okay So I described the data structure. Maybe we can forget for a moment why it is good. So we take our a vocabulary and we take a width and then We create trees that have little structures. I mean structures that have not more elements than than this width And talk about this vocabulary So we populate a tree with such a structure and then well, um So what we wrote on the on the nodes of the tree, we will call bags and What is written on the edges this we will call overlap Okay, and we'll ask one condition namely that if you have two neighboring nodes and the edge label speaks about an overlap then I mean the the induced structure At the ends of the edge should be really overlapping. So there should be no conflict between neighbors if an overlapping part Okay, and this is a generalization of the standards tree decomposition. So the standard tree decomposition I mean if you take a graph and you find the tree decomposition, okay, you will find you will need to to be sure that it fits into this width so that These small structures are enough to carry all the information But you will get a tree that you can view in this way. So with bags and overlaps I mean typically People would maybe draw a tree and write on every edge, uh, which elements of the structure Are allocated to this node But we don't want to to carry the structure with us So the target is one day to to get rid of structures and to to guess structures and to go compose them Okay, and the other thing that we can do is to take a This guarded the simulation game graph That we get from the entrance procedure and then to unravel it when we have a tree Also the composition You will see what it is good for Well, once you have such a decomposition tree, I mean from the tree decomposition of Of a structure we can rebuild the structure. So we can do something similar With the decomposition well with the trees that we get by unraveling the the game description Okay, so the recovering process is just undoing I mean interpreting what this overlap should mean. Maybe it's a bit more complex than once it's written here So what we say is that for example, if we have two nodes and they say that we are sharing Well the first element Or so the first and the third element and then we have another Node and says here. I'm still talking about the same first element And here this guy is still talking about the same first element, but He shared the tree with this one, but here the tree was not shared. So It means that I mean in this path or maybe So this part of the tree all all speaks about one element and we contract This part Okay, and we do this with all the elements And then we have to see how so this gives us the individual elements. It's just contraction of every every neighborhood That declares itself as being an overlapping copy of an element and then we have to see What we do with the relations, but that is quite easy because I mean since we have this overlap consistency condition means that The story about an element is told in a subtree. And so if we have several elements then The intersection of the subtree is that talk about them. It will still be a tree So in this in this tree, we will find the Description of what happens to all these elements together Okay, so this is very much like what happens in in in tree decomposition and Well What we what we get here is so if we Take the game graph and unravel it in such a way And then Reconstruct something I mean reconstruct the structure Then we get something be similar to the structure with which we started We will not get exactly the same but something be similar and that is a tree. I mean, that's the the tree model property says that every Every formula that can be satisfied has a model that can be represented as a tree with With small widths. I mean the width is the one that we get in the formula I mean, this is the the formula tells us how big the clicks the The guard the the guarded topples are and but what which we can speak The guarded topples are the ones that the air force a game cares for and We unravel this game graph and then we get the composition So here is the way it looks. Ah, okay Pardon me So we we fix I mean we take Yeah, it's it's defined for a fixed k Yeah, yeah, so every formula for certain width will have a decomposition tree of this width But I mean usually it will be infinite and I mean worth so What we get from the from the game is something very rich very redundant Here I I try to draw something which was already much less redundant But the point is I mean if we just record this information that we need to win the air for a game, so we will have I mean for example Every guarded topple to which you're not related will appear at I mean As your neighbor at every level, so you will have I mean all all the guarded topples are your neighbors and you don't really want uh I mean if we If we hope to to make a satisfaction algorithm That that has to To work with such kind of trees. We are lost in this are I mean we'll never be able to tell whether Three decomposition stems from uh, the direct unraveling of uh, So yeah, but what we can be here more relaxed and to say we are so we we call At the composition of a structure any Any tree of this shape I mean of this the composition shape That if you recompose it gives you something guarded be similar to your original structure So we we talk about the compositions up to guarded the simulation and this is Here a candidate for other composition So pity them So here this was a structure and we did a decomposition of width three so we took A neighborhood and then we told how it relates to His its neighborhoods and then how it relates to its neighborhoods and then I mean Well, we it never stops because uh with width three Yes, we have here I mean we have four clicks. So I mean of course we will always generate new New guarded neighbors, but it is already the composition that is uh Smaller than what you would get if you would take just a game But okay, you cannot see it Okay, and if we take this structure and recompose it we get something like this So this was the decomposition And we would get something I mean for the for the guarded fragment this and this is Is the same So we're fine and we have a tree decomposition so we're set Or we're close to something That will help us With uh, satisfiability Uh, maybe I quickly tell why we're not ready and then suggest what we also would I mean So why are we not happy yet? Yeah, so the idea is Well, we knew how to do the game We know how to do an automaton that tells whether the composition tree is a model or not I mean well of a formula And such the composition tree uh, sorry I mean what we need is To write an automaton that reads such kind of trees And tells us whether in the formula that we would get if we would recompose it um No, sorry in the structure that we get if we would recompose it we the formula would be true Yeah, then we know something about our original structure so, um Well The problem is we cannot expect to To have a full description of Of the neighborhood of a guarded tuple Immediately available so we will need to run through the tree to collect our description We have two choices here either we say everything's there But then we have to check that our input is consistent and this is too complicated Or we have to run through the tree to collect all the data that we need locally So here the choice will be to To go away from one-way automata and I mean to use two-way automata That have the ability to climb around in trees and collect the information about neighbors And well, the second problem is that we don't get a finite model. So we get something which is ostentatively infinite and Well, I mean here Many people have been working several years me too and I didn't find I mean I didn't manage to solve it but Vince Barani and Giorgot Lobo and Martin Otto they they came up with a magic tell him last year and leaks and they say If you take like Well to make it short we take a small representation of of the errant fruit foresee game Digest that we I mean this Guarded with simulation game graph. So we we factorize it under by simulation We don't care about the similar copies. So we take this thing and we call it the invariant of a structure and it turns out that If you give me something that looks like the finite invariant of something that I don't know I mean you just give me something and tell me it's a finite invariant Then there is an algorithm that builds a structure that we really have this invariant And the good thing is if the I mean the invariant is finite then the structure is also finite and we can I mean you can also build it in polynomial time and that's something that Well, it is very relevant for Well, the descriptive complexity of the guarded fragment it helps us to To do find Satisfiability for the For the I mean Once we have done the satisfiability knowing this we're almost done for finite satisfiability in our guarded fixed point logic So That's it. Thank you