 Let's let's proceed to the talk. So today we will have talked by Sylvia but that will be on distributed constraint satisfaction problem. Oh, yes. Thanks, Jacko. So I'm hoping you can also my screen. And so thank you. I'm going to talk about the distributed constraint satisfaction problem and in particular, I will be looking at this complexity. So this is some joint work with Victor that knows my supervisor. Okay. I will just start by defining what I mean by CSP. I'm sure everyone is familiar with the topic, but just to summarize the notation. Let D be a final domain and let gamma be a finite set of relations over T. Now an instance of the constraint satisfaction problem of over gamma is a triple where X is a set of variables. D is the domain as we said before is finite and C is the set of constraints over the variables. And now constraint is a pair where consisting of a scope that is a couple of variables from X and the relation from the constraint language come. And I would say that I is satisfiable if there exists a map from the set of variables to the set of domains such that every relation, well, every constraint is satisfied. That means that the component wise application of this map to the scope of the constraint belongs to the respective relation. And now just to point out, we consider the case where the domain is unique so every variable has the same domain. The distributed CSP framework is very similar. It originated in 1992 as a formal framework for some multi-agile system problem. And similarly, so we have a finite domain D and the constraint relation gamma over D. An instance of the distributed CSP over gamma is a table that contains, again, a set of variables, a finite domain and a set of constraints that are defined as above. And additionally, we have a finite set of agents, which we call a and a subjective function alpha, which basically assigns the control of every variable and every constraint to a single agent in the set of agents. So we make a fundamental assumption that there are as many agents as the sum of variables and constraints, which means that every agents will control control exactly either one variable or one constraint. And now originally the DCSB was defined for just binary relations. In our work, we extended so that it's also allows for non-binary relations. However, I want to point out that all this framework can be simplified in the binary case, so that we only have agents controlling the variables and we do not meet agents for the constraints as well. Now, the decision problem for the distributed CSP is defined as follows. We have a distributed algorithm will solve the CSP of gamma if this algorithm terminates and at termination every process correctly states that the instance I is satisfiable if it is. And that it is not satisfiable if it is not. Similarly, a distributed algorithm solves the search problem for the CSP of gamma, if given an instance of the CSP of gamma, it solves the decision problem first. And then if the instance is satisfiable and the terminated state also contains a value of the domain for every variable, such that the as a whole the assignment given by these values is a satisfying assignment. And later I will describe exactly what I mean by a distributed algorithm. So now about this system, a message passing network or a distributed network consists of a finite set of processes that are connected by communication channels. These processes can perform free kind of events. They can send messages receive messages and perform any kind of internal events that can be calculations changes of states decisions, etc. So let me make some fundamental assumptions on this network. First of all, we assume that communication is synchronous that means in proceeding around and no message is sent in the new round before every every process has received the messages in the previous round. So this is an assumption that is just made to simplify our computations. And indeed, all our algorithms can also be run in the asynchronous framework, just by applying a simple synchronizers. However, the opposite is not true. So, there are some algorithms that might work in the asynchronous framework that do not work in the synchronous one. So the complexity here might be different. Secondly, we assume that the network is anonymous. So that means that the processes do not have ideas. And, or rather, either they do not have ideas, for example, because they don't have the hardware to create them, or they cannot store them, or they might have the ideas, but they are unable to share them with their neighbors. And these, again, this assumption can be justified by privacy reasons but we will see later that it is very important to make the problem interesting in itself. And we assume that every process runs the same algorithm and that this algorithm is deterministic. Again, this assumption goes together with the anonymity assumption because if the processes had access to randomness, then they could create random ideas just by flipping a coin or with a random number generator. And they could also break ties in just by flipping coins, for example. So these assumptions, it follows that in general it is impossible to elect a leader in the network. That means that it is also impossible to gather all the information about the CSP to a single process. And therefore, we cannot solve the CSP just by gathering all this information and then using a standard CSP classical CSP algorithm, which means that our framework, the CSP framework is strictly different from the classical CSP. There is space for some interesting new results here. Now, how do we encode an instance of the CSP in a message passing network? This is very simple. We consider a bipartite graph and labeled bipartite graph. So the vertex set is given by the set of agents. In particular, the bipartition is given by on the one side, the set of agents that control variables, and on the other side, the set of agents that control the constraints. And obviously there is an edge between a variable agent and a constraint agent, if and only if that variable participates in the scope of that constraint. Now the edges are labeled with the position where the variable appears in the scope and the relation of that constraint. Which means that all the variables and constraints can have all the information that they need about the CSP instance just by looking at the labels of the edges that are incident. They're the incident to them in this constraint network, sorry, in the message passing network. Now before I state the main results, I need to just define what I mean, what is polymorphism. Again, I'm sure everyone knows this already, but just to be clear. Polymorphism of RITM is a function on the domain of sorry, polymorphism of a constraint language of RITM is a function on the domain of that constraint language. Such that every relation from the constraint language is invariant under the coordinate wise application of this map to any set of M-tapos from the relation. And moreover, we said that a function is symmetric if its result doesn't change if we permute its arguments. And now finally we're ready to state the main results of our work. That is our main theorem that the decision problem for this CSP of gamma is tractable in polynomial time, even only if gamma has symmetric polymorphisms of all RITs. Otherwise, the CSP of gamma cannot be solved in finite time. So here actually we have a dichotomy that is different from the classical CSP in the sense that we don't have empty completeness but actually we have that either problem is tractable in polynomial time or it is not solvable at all. And now these results can easily be extended to the search problem and in fact we have the same dichotomy. The search problem for this CSP of gamma is tractable in polynomial time, even only if gamma contains asymmetric polymorphism of a priority and otherwise we cannot solve it in finite time. Now just to give an example of these results. For instance, if we take two colorability. Now two colorability does not have asymmetric polymorphism of RIT2. And therefore it falls in the set of intractable languages and this can be seen easily for example if we take an instance that is a ring, where we apply the two colorability relation between every pair of variables in the ring. And it's easy to see that the search problem here cannot be solved because if all the processes start in the same state and the algorithm that they run is the same throughout every run, then they will always be in the same state and therefore they will always output the same solution. So no matter how long this other algorithm runs for, and we will never be able to have two processes that output different values for their variables, their respective variables, and therefore two colorability cannot be solved in the search problem. To see why it cannot be solved in a decision problem is a bit more difficult and I will talk about it later. On the other hand, for example, if we consider any binary relation that has bound that way. We know that it can be solved by our consistency and our consistency can easily be implemented in the distributed framework. So, given any instance, we can solve it in the DCSP framework. Now I'm going to start talking about intractable languages and why if we don't have a symmetric polymorphism of some RIT then there are no algorithms that solve the DCSP of gamma. But before that, I have to introduce a new concept that is the concept of iterative decree. Now, this concept comes from graph theory, and it is quite simple. The idea is to calculate a partition of a graph by iteratively dividing the vertices into finer and finer partitions. And this is, these partitions like are given by this algorithm that's called iterative color refinement, or one dimensional by spiraling on algorithm. Basically, it works as follows. The first degree, or sorry, the zero degree is just given by the degree of the vertex in the graph. So for instance here, we have that every node in this graph has degree two, except for these nodes that highlighted in green that have degree three. And now the kth degree, kth degree of a node is just the multi-set of k minus one degrees of the nodes' neighbors. So for instance, in this example graph, we have that every green node has three neighbors, and it has two neighbors that have degree two and one neighbor that has degree three. So it's first degree would be two to three. While, for instance, these red nodes, they have two neighbors and both their neighbors have degree two, so their first degree is now two to. It's easy to see that actually this partition that I give here by dividing them in three colors is a stable partition that is a fixed point. So we cannot divide it further. And in general, it is also easy to see that after almost any iterations where any is the number of vertices in the graph, we will reach a stable stable point. So there will, it will not be more possible to divide the partition further. And now originally this concept of iterated degree was was defined as a heuristic to test for graph isomorphism. That is, if we have two graphs, and we run the iterated color and find the algorithms. We will obtain a degree sequence that is the sequence of fixed point degrees for both graphs. And we know that if they're either a degree sequence is different than the two graphs cannot be isomorphic. However, the opposite is not true. For instance, this is an example where we have two different graphs. This is the one that we were looking at before. This is a graph that has the iterated the same iterated degree sequence. However, it's easy to see that these two graphs are not isomorphic because for example, the left one is too colorable, but the right one is not. So as an extension of the iterated degree concept to CSP, we, we define it as follows, and basically now we're not looking at graphs, but by part of the graphs that have labels. So the first thing that we want to make sure is that any two nodes of the graph that belong to different sets of the partition, get a different degree at all times. So we start by defining the zero degree as just a symbol that differentiates the degree of variables from the degree of constraints. And then, because we have labels and we do not want to lose this information. And the K degree is defined as a multi set of tuples that contain the K minus one degree of the neighbors of this of this note and the label that connects the nodes with its neighbors. Now we say that two nodes are degree equivalent, if they're catered to the degree is the same for okay. And we have the following crucial observation. So, given an instance of this CSP, and given two nodes that have the same integrated degree, we have that any terminated in decision algorithm over these instance will output the same decision at the two processes corresponding to this, to these notes. And moreover, any terminated search algorithm will output the same assignment for the same, these two nodes, if the if the instance is satisfied. And additionally, we also have that if we run a distributed algorithm over two separate instances that have the same degree sequence and the algorithm without the same solution on both instances. And now, again, before I go to the proof of interactability, I'm going to define construction of a gadget. And that's, I call the indicator problem. And so, given a constrained language gamma over a finite domain D, and a positive integer K, I define the indicator problem of order K for gamma to be the instance. Given by basically has the set of variables being the set of K tuples over of the domain. And then for every relation of gamma and every set of K tuples from his relation. There is a constraint in the indicator problem that is given, basically as, as follows the I variable of the scope is the table given by the I coordinate of these K tuples that I took before. And the important observation about indicator problem is that the set of solutions to to this indicator problem corresponds exactly to the set of K area polymorphisms of gamma. And secondly, we also observed that for any two tuples in the in the set of variables of the indicator problems that are permutations of each other. The two tuples will have the same in the ready degree. This can be is, this can be seen easily either by induction, or by just observing that actually these two tuples, there will be an automorphism between them. So, if they're automorphic, then they're also either a degree equivalent. So finally, I'm going to give some intuition on how to prove that the search problem is intractable for the intractable languages. Assume that gamma does not have a symmetric polymorphism of our K and consider the indicator problem of order K. Now, from our observation that I mentioned before, for any two tuples that are permutations of each other, any terminated algorithm will output the same value at them because they have the same integrated degree. And therefore, this algorithm can solve the CSP of gamma, only if there is a solution that assigns the same value to every two tuples that are permutations of each other. But this solution, since it corresponds to a polymorphism. Well, it corresponds exactly to a symmetric polymorphism of our K, which is a contradiction, because we just assume that such a polymorphism doesn't exist. So for research problem, this is quite simple. The decision problem one has to do a little bit more work. And the idea again is to control the gadget that shows that the problem is intractable. However, we could not find one in CSP of gamma, but rather we have to define a new relation. So I'm going to briefly talk about keeping definitions. We said that our relation is pp definable from a template gamma. If there exists a pp formula primitive positive form formula, which uses only relations from gamma and equality to define you by pp formula, of course I mean formula only uses existential quantifiers, conjunctions and equality. We say that you is e f pp definable with by which I mean equality free pp definable if such if you formula doesn't use equality so he only uses relations from them. Now there's a very well known reduction for CSPs that basically says that if some constraint language gamma prime is pp definable from gamma. Then CSP of gamma prime is log spacer is equal to CSP of gamma. And we have a similar reduction here in the DCSP framework, but with e f pp definitions so if a constraint language gamma prime is e f pp definable from gamma. Then the CSP of gamma is, sorry, if if the distributed CSP problem for gamma is solvable in polynomial time. That's always the distributed CSP problem for gamma prime. So assuming the gamma does not have a symmetrical morphism of RTK, we just consider the relation defined as a set of solutions of the indicator problem of RTK. And it is easy to see that this definition actually consists of an e f pp definition for for this relation you. And so, because of this reduction that I just mentioned, it is enough to prove that there is no algorithm that shows DCSP of you in finite time instead of solving of proving that there is no algorithm that solves the CSP of gamma. So if we don't do this as follows, we would find two instances, I wanna night to have in CSP of you. Such that, first of all, they have the same degree sequence. And secondly, that one of them is unsatisfiable, and the other one is satisfiable. And because of our observation that I mentioned before that if I run a distributed algorithm on two instances that have the same degree sequence. In this algorithm will have put the same solution at both the intense instances. And so the same decision as well unsatisfiable. And so because one of them is unsatisfiable, and the other one is not, then there is no algorithm that could possibly solve this problem. Now, down to the tractable case. So assuming that a constraint language gamma has a symmetric polymorphisms of varieties. We will show that there is an algorithm that solves it in polynomial time and in particular it. It runs over n square rounds. The round is not unique times are actually the total running time is, is this and cube and again, where any is the number of variables in a constraint, such as for instance, and is the number of constraints. And the maximum size of a message is in order to prove this theorem. I'm going to need another observation, which I call the structural theorem, this is interesting in its own right especially because it is not specific to the DCSP framework but actually it holds in the CSP context in general. I'm going to, to discuss it more needed later but just to mention, and the structural theorem states that the following are equivalent. First, that gamma has symmetric polymorphisms of varieties. And secondly, that for every satisfied instance of CSP of gamma. There exists a satisfying assignment that assigns the same value to any pair of variables that are degree equivalent. So coming to the structure theorem. There are algorithms subtractable languages consist of two phases, the first phase. In the first phase, every process in the network calculus is either a degree. This is done by a distributed version of the color refinement algorithm is very simple basically at every round, every process. And then the third degree and then calculates the next either a degree and then broadcast is and calculate it and so on. Now the ninth version of this only takes and rounds. However, the maximum size of a message is m log n. And because we're actually going to use this message later and we're going to process this and this is going to take time. It's very inconvenient to improve this algorithm by basically trying to decrease the size, the maximum size of a message, and this is done at the cost of increasing the number of rounds. The, the basic idea is that instead of broadcasting the degree in itself. Every node would just broadcast a number and this number is unique up to the great equivalence. And in order to calculate this number. For every round one is an extra n rounds that's why we get n square. Now, once every process is calculated is already degree and we have reached a stable point. And then the crucial observation is that thanks to the structure theorem, we can tag messages with the degree that has been calculated and use it as its own ID. So now in a way the network is no longer anonymous or better, it is anonymous but we can have no unique IDs up to degree equivalence. And now because of this we can use distributed and adapted version of JPQ consistency which is some recent work of cosmic to decide the decision problem for this is pure comma. And the second phase takes n square rounds, m log n times, sorry m and log n time, so then we get the balance that I mentioned before. And the maximum size of a message is m log n. Just to explain a little bit how distributed JPQ consistency works. So every variable process in the network would maintain a set S of X that is a subset of the domain. So the values are such that for every solution, if this solution assigns the same value to any pair of variables that are degree equivalent, then the value given by by the solution to to X must belong to S of X adult time. So initially, as of X is, is just set to be the domain for every variable X. And at every iteration we calculate the new as I have X by basically taking the previous SI minus one of X and then removing all the elements of the domain that are not consistent with all the other variables in that work that are equivalent to X taking that value. So just to explain a little bit. So for binary relation actually is free colorability we know that this is not solvable but it's just an example. And, for instance, here, suppose that X and Y are degree equivalent, we have a SI of X and SI of Y. And we can see that there is no path from zero here to zero in SI of Y. We can remove zero from both sets. On the other hand, for example, there is a path from one here that we can follow to one here. So one will be maintained in this iteration. And once we have computed these new sets, and which we're going to do for every iteration. And now just to mention that this can be done locally in a way that it will take n rounds. So just by sending messages during n rounds, every process can calculate these new sets locally. So in most n times the iterations and each iteration consists of n rounds, one can obtain a fixed point. And the crucial observation is that since gamma has symmetric polymorphisms of all areas, and hence it also has bounded with from the structures theorem that I mentioned before and from the work of Cosic. It follows that one can decide satisfiability of the instance just by looking at these sets as of X in the fixed point. But if anyone of these sets is empty, then the instance is not satisfiable, and it can be easily propagated around the network so that all the processes are made aware that the instance is not satisfiable. Otherwise, if all of these sets are not empty, then the instance is satisfiable and this can be decided. Now, going back to the structure theorem. I'm going to actually try to prove it for you. I'll state it again, just for convenience. So the structure theorem states that for any finite country language gamma gamma has symmetric polymorphisms of all areas, even only for every satisfiable instance of CSB or gamma. And this is the satisfying assignments me that assigned the same value to every pair of variables that are either that are degree equivalent. Now, in order to prove the structure theorem, I'm going to need to use the basic LP relaxation of CSB. And this is as defined as follow we have a variable for every pair of, well, we have a variable of the LP for every pair of variables from the CSB and elements and we have a variable of the LP for every constraint in the CSB and every couple T in the relation of the constraint. And this set of variables of the LP are constrained by the following equation. First of all, we require that the variables of the LP define a probability distribution for the variables of the CSB over the domain. Secondly, we require first that also the variables of the LP that for the constraint defined probability distribution over the tuples of the relative relation. And secondly, that the marginals of the probability distributions are consistent. Now we say that BLP decides the constraint satisfaction problem for gamma, if for every instance of CSB or gamma. The instance is satisfiable, if and only if the basic LP relaxation of that instance is feasible. And it is one known that if gamma has a metric polymorphisms of all artists, then BLP of gamma decides CSB or gamma. However, the running scheme that gives this this equivalence, which is actually if and only if also determines that the if the solution given by the LP is such that any two variables. Sorry, for two variables, we get the same value basically for every value of the domain. Then there also exists a solution that gives the same value to these two variables. Now the proof of the structure theorem would go like this. First of all, we would rewrite the the BLP in matrix form. So, just by replacing basically every equation with the pair of inequalities. And then we would apply the multiplicative weight update algorithm to this feasibility problem. And wU is quite a widely used technique in machine learning. And basically a weight update technique is quite simple. So suppose that big w is a set of equations in the LP. We define small w to be the vector of weights of these equations. So we basically assign a weight to every one of these equations, initially all the weights are set to one. So for T iterations. We do the following. First of all, we calculate the probability vector. That's just the normalized vector of weights. Secondly, we assume that there is an oracle that gives a solution to these feasibility problem over here. And it's important to notice that this feasibility problem is strictly weaker than the previous one than this. But if we have a solution to the LP, then we definitely also have a solution to this problem over here. The opposite does not hold. So, given the solution by an oracle, we compute the losses. So, basically, there's one loss for every equation. And then calculate the new weights just by multiplying with the losses. The algorithm returns the solution that is just the average of all the solutions given by the oracle over the T iterations. Now, it's quite easy to show that if we're on MWU for an infinite number of iterations, then we actually get an exact solution to the basic LP. In particular, under some technical assumptions on the oracle, that are easy to be met. In order to get an epsilon approximation for the BLP, it's actually enough to run the algorithm for a number of iterations that is quadratic in one over epsilon. And so, clearly, if we let T to infinity, then epsilon goes to zero, so we get an exact solution. And now, again, given the algorithm, the multiplicity weight update algorithm, it's not hard to show that the solution given by MWU is not just exact, but also it assigns the same value for every pair of variables that are degree equivalent in the network. And to show this, okay. Again, it's not difficult, but just to give you an idea, we will define two more equivalence relations and now on the set of variables of the LP V and on the set of equations of the LPW. And we say that the vector V is V preserving if it assigns the same value to any two variables of the LP whenever they are V equivalent. And similarly, a vector W is big W preserving if it assigns the same value to any two equations V and VW that are V equivalent. Now, consider the oracle that maximizes the left hand side of this equation. And that's given basically just by assigning one to V if it's coefficient is positive and zero if it's coefficient is negative. It's easy to see that this maximizes the left hand side and so it must satisfy this feasibility problem. And this oracle also satisfies our technical condition that we needed before from that year. And so, one question by induction that is the solution given by this oracle actually guarantees that the, that the solution given by MWU is be preserving that means it's going to give the same value to any two variables that are V equivalent. Even only if the corresponding variables in the CSP are degree equivalent. And so, once we show that a given the gamma has symmetry polymorphisms of all areas given around the scheme that I mentioned before. You can see that basically the solution given by the IP will be the same for every pair of variables that are degree equivalent. And because of this because of the running scheme then we have a solution of I of the CSP instance that gives the same value to every pair of variables that are degree equivalent. Now that completes the one direction of the proof of the structure theory. The other direction, luckily, is a lot more simple. So, assuming that we have a closer language gamma that satisfies the second condition of the structure theory. So that means that gamma is such that for any satisfiable instance, we have a solution to that instance that gives the same value to every pair of degree equivalent variables. Then we're going to show that gamma actually has a symmetric polymorphism of RTK for every K greater than one. Consider first the indicator problem of order K. And remember that, as we said before, the solutions of the indicator problem of order K define exactly the K area polymorphisms of gamma. Consider then an arbitrary solution, we know that the indicator problem is satisfiable. And so considering an arbitrary solution of the indicator problem that satisfies the this condition to above, which we know must exist. And remember, so for any pair of tappos in indicator problem that are permutations of each other, we know that they are degree equivalent. And because they are degree equivalent, given that our solution satisfies the conditions of the structures here. Then the solution must give the same value to these two tappos. And since this solution defines polymorphism of RTK. It follows that this polymorphism must be symmetric because it gives the same value to any two tappos that are permutations of each other. And so we have a symmetric polymorphism of RTK as required, which completes the proof of the structure here, and also completes my talk I believe. Thank you. Yeah, thanks a lot. Some questions. Comments. Well, where do you go next with this, or it's all done you start the direction and finished it in one paper. No, for sure not. So there's a few, a few ways that this can be taken further. First of all, while we made a couple of assumptions on the network, synchronicity and anonymity and determinism. While the anonymous assumption cannot really be taken away because otherwise it's trivial. You could look into making the network asynchronous. So that would most likely gives rise to a different classification. And you could look into allowing for randomness. And again, I don't know where that would take. Another interesting point is that actually the DCSB framework is quite similar to graph neural networks. So there's, there's actually quite an interesting correspondence there because graph neural networks are also very deeply tied to these vice father layman test and they did already degree and actually their expressive power is seems to be linked to vice father layman. So it's an interesting direction to see in, in what way these three things are linked together. And yeah. There's more. Does it even make sense to apply this framework to optimization problems. So what is this piece of some of that? Possibly. Yeah, one could look into that, that direction. So we haven't looked at value CSP or optimization in the sense. But actually, yes, so DCP distributed concern optimization problem is is also well defined there is quite a few papers on that. But again, nothing on the complexity. So that would also need to be analyzed in a way. Some other questions. Maybe I will have a question then. So, yeah, my question is about the communication model. So I think your algorithms basically work in a way that that the vertices just needs to need to communicate with their neighbors right. Yes, exactly. They can only communicate with the neighbors in the, in the network. So if you if you change this into, you know, global global communication, does it change anything. So you could, you would be able to send messages to anyone you want, or maybe a for sure this is not the only network that would work. Or at least there are cases in which other networks would work. For example, if you have just binary, you could use a different network with global communications. I don't know what could look into that actually it I would imagine it's not very very feasible for applications in that way, because in general if you have a constrained network. It's not super feasible to assume that everyone can communicate with everyone. But surely surely one can look into that. I don't know, Victor, do you have any idea? I don't know exactly what what is global communication. I will say that as long as you can keep anonymity. I mean, global communication only could speed up what is not for those views. But, but I don't know if you can make it global communications without without revealing anonymity. Like, yeah, I guess like if you want to keep anonymity, the only the only global communication that you can get would be broadcast a message to everyone right the same message to everyone. Yeah. So, so then I guess, basically, perhaps you have the same classification right because, because perhaps it's still like you have the same the same barrier like that the notes that have that are, that are, they will go and need, need to still to behave in the same way. And then global global, perhaps it will only make the algorithm faster, but I guess that will get sort of the same, the same frontier. Yeah, yeah, I agree. That I mean that's my feeling as well in the sense that you could, if you receive more messages in a way that wouldn't help you break the symmetry it would only give you more information faster but only information you're going to get, you're going to get it anyway at some point. It just might take longer because the network is complicated and you, you're not a direct neighbor, but all the information that you're ever going to get you're going to get in a finite time. And, and so just to to our communication channels is is not going to have to break the symmetry which is the problem for intractable languages, it will only make algorithms faster. Although, one thing that one might look in this model, perhaps is that you see in the model that we're looking at. We are hoping at the best. I mean, let me see, how can I say that, and by making it distributive we don't get any improvement. Actually, the only thing that we get the obstacles right. But perhaps by looking at global communication, then we can study another kind of questions like which kind of, which kind of CSPs you can solve them faster in this way than like for instance classical CSPs for instance I don't can solve any like in sublinear time, what kind of CSPs that you can solve in sublinear time now that you can communicate like instantly because that was a problem when we look at this initially. So I think it might be interesting to look at in that direction like, like, like, yeah, which, which kind of CSPs you can solve like faster. Right. But your algorithm is actually quite fast isn't it like compared to QB and QB and log N. Yeah, how does this actually compare to the standard algorithm for symmetric polymorphisms that would be LP. Sorry. LP is matrix multiplication time. Matrix multiplication time. So that means this is slightly slower. Good point. I don't know. Okay. You made this assumption that you have as many, so you have one agent for every variable or constraint. Yes. How much of restriction is there? Not at all actually. It's not a restriction in the sense that if you have, for example, say that you have a variable, sorry, an agent controlling two variables. Then the agent can just simulate two agents that control each of them one variable. And then just run the algorithm in the same way. It's no loss of generality. Sorry? It's no loss of generality, you say. Yeah, no, it doesn't lose any generality.