 Welcome everyone to today's TCS plus talk. I go by G. I'm the moderator for today's talk as operator We have Oded Rigev and also on the team. We have Clemence Henan, Anindya Day, Ilya Razenstein, and Thomas Vidic. To start we're going to have Oded take us around the table and introduce the groups Okay, thank you G. Let me try. So we have first Ben Miller with the group from UW-Venison everyone and We have Budimba from EPFL group from UW-Venison. Hello everyone And we're great to see some groups from Europe. We have Ilya Razenstein from Colombia, not far from here. Hi everyone We have K. Gopalakrishnan from East Carolina University We have Michael, Michael Linens. Hello Michael from Johns Hopkins and We have Samson Samson from Purdue and we have some kid from UCSD. We can't see you. It's very dark supposed to be morning there we have the Sayed from the group from Shahid B.H.D. in Tehran, and Also, we can actually see you everyone. It's the first time I think we have a group from Iran. So welcome I hope you join again We have Shavas with the group here in NYU a few floors above me. It looks very empty, but I'm sure there's some of there We have Femmitt from MIT Everyone and finally we have My fellow organizer Thomas, we did for the group from Catech. Okay, so back to you G. Great. Thank you Ed. So again, I want to remind you that you should ask questions. Did you have any? And I want to let you know about a couple of the upcoming talks two weeks from now We'll have Ola Svensson telling us about some exciting results on ATSP and then one week after that to avoid a conflict with American Thanksgiving. We have been owed by Kuntanathan Now let me tell you about today's speaker today. We're very lucky to have a Sets Petty speaking to us Sets Petty is a professor at University of Michigan. He did his PhD at University of Texas Austin He spent a few years at a Max Planck Institute at a postdoc He's a what best known perhaps for his work on graph algorithms Including work on matchings and an optimal algorithm for MST, which one best paper at iCalp He's also known for his work on other algorithmic problems Including for example work on threesome and today he's going to tell us about a time hierarchy theorem in the Local model without further ado sets Petty. Oh First I want to thank the TCS plus organizers for inviting me to give this talk. Thank you very much Can you hear me? Okay So this is joint work with my student Yiran Chang And this paper is sort of the the the middle Edition of a trilogy of papers that looks at sort of a complexity theory in the local model Okay So The title says time hierarchy. So what is that the time hierarchy theorem is one of the classics of? Complexity theory it says basically and formally if you give a touring machine more time it can solve more problems So formally it says for any time complexity t of n not really any time complexity. It has to be I'm satisfied a couple of constraints like time construct ability But there's going to be at least one problem that you can solve in this time, but you can't solve in less time asymptotically and I think We don't often dwell on you know what this theorem what the takeaway messages are from the fear I mean syntactically it it says something But it does you know give us a few takeaway messages the time hierarchy hierarchy is infinite. There are not a finite number of Possible complexities And the time hierarchy is very dense. There are problems that take linear time there's problems that take into the 1.01 time etc etc and And these these problems that have those these characteristics That you can solve an end to the 1.02 time, but not less time are a little ridiculous I mean the time hierarchy is populated with problems that were designed To prove the theorem and they're not the sort of problems that you encounter in everyday life So whenever you see a model of computation a Natural question to ask is basically what is what is the analog of the time hierarchy in this? Model of computation. What what are the complexities that you can achieve? Is it infinite? Is it dense and so forth and so on? Okay, so the problem or the the model that I'm looking at is the is the sort of the simplest Model of distributed computation that takes locality into account. It's called the local model So we imagine that the there's some underlying graph of nodes which we identify with computers in this case Macintosh's circa 1984 Each vertex is a computer each edge allows for bi-directed communication between them We imagine there's some drumbeat of time Marking off synchronized rounds and each round every computer gets to send a message to their neighbors so to simplify things we're only going to count rounds time is rounds and In between rounds the computers can do as much computation as they want given the information they have and When it's time to send a message the the size of the message is completely undoubted. So there's variants of the local model where Message size has to be some reasonable Number let's say log n bits or something Okay, so one thing that comes up I mean one of the you know types of problems that you end up solving in the in the local model are symmetry breaking problems and randomization comes in Very handy when you're solving symmetry breaking problems. So in the deterministic local model we're assuming that the that the each Computer is running a single deterministic algorithm and in the randomized model. They can locally generate any number random bits They want but there's no global shared randomness Okay, so what does a vertex know in this model? It doesn't initially know very much It has to learn everything through these rounds of communication Initially, we assume that every vertex Has a common knowledge Bound on and the number of vertices and Delta the maximum degree We assume vertices know some sort of unique identifier a lot of problems are just provably impossible to solve deterministically unless you have some Identification or broken some kind of symmetry initially. So these IDs are rather weak assumption and Just so that each node can talk about its its edges Is you know distinct entities and and and give them names and send messages along one edge But not another we assume that the nodes have some port numbering of their edges so they can distinguish them Okay, so what is a natural problem? so if you're looking for a time hierarchy theorem you have to Basically rule out some dumb answers to this question. So for example Let's say I want to say approve that there is a problem that can be solved and only logarithmic time and no less well, that's sort of trivial You could just say the problem is for every vertex to decide whether The number of vertices that are within distance log n is odd or even And obviously you need to actually look at your entire neighborhood to figure out the answer of that question so we want to find a definition of a natural problem that basically Includes everything that we're interested in and excludes ridiculous problems so now in stock Meyer came up with a definition that I especially like and It's basically all problems that can be expressed in the following way The output is going to be some labeling of the graph like with vertex labels let's say colors or something and You should be able to check that a labeling is Correct in constant time Okay, so this is sort of the the the analog of non-deterministic Constant time and foreign machines or something So more formally what what are we talking about here? There's going to be some sort of input alphabet. So each node is going to be initially labeled with some Label from Sigma in and It will eventually be labeled with an element of Sigma out at the end of the computation and there's some integer Radius are so that a vertex can tell whether it's labeled correctly Just by looking at its are a neighborhood So an important thing to note here is that the the the sigmas here these these alphabet sizes Have to do with the local graph parameters. So you They can depend on Delta for example, but they are some of the independent of and Okay, so an LCL problem is basically defined by a set of labelings that is Acceptable, okay, so we're just going to enumerate all of them essentially So conceptually C is just a list of acceptable radius are labeled centered subgraphs centered out of particular vertex So I'll give an example in a second. So the problem is we're given an input labeling computer output labeling so that everybody's Our neighborhood looks good and looks good means is isomorphic to an element of C so for example this is a vertex and this is what it would see if it looked out to radius one and This is without any labels If the problem that we're solving is three coloring then these would be two acceptable one neighborhoods and This one would be an unacceptable one neighborhood for the the three coloring problem and in this problem Sigma out has Is a set of size three and Sigma in is a set of size one because there are no input labels Everything is is initially white. I guess Are there any questions so far? So one question said yeah, so in what sense is the problem you mentioned before not natural Well, I mean if you look at the time hierarchy theorem it makes perfect sense, right? I mean every problem that is used in the time hierarchy theorem specifically refers to a Specific running time inside the definition of the problem. So in that sense, I mean there's precedent but it's unnatural in the sense that these These problems don't seem to show up in nature. I mean, we don't really care about You know over Texas log-in neighborhood in a graph of indeterminate size because you know And we might just be guessing on the size of an anyway I guess my question was not so much in the philosophical level, but why does it not fit under the definition of LCL ah? because R has to be a constant independent of everything else and Sigma in and Sigma. Oh, yeah, so that's it our R has to be a constant. That's why I would rule out that problem So for I mean typical problems are is going to be one maybe maybe two You know for all let's say the proper coloring problem R needs to be one for You know edge coloring depending on how you do the labeling's to is a sufficient radius to check that an edge coloring is locally consistent and so Okay, so I think last semester Mohsen gave a talk in the local model. It was very nice and he surveyed a lot of things that That people study in the local model which are Greedy problems. So greedy problems I'm going to just define a greedy problem to be one where basically you can extend any partial solution to a total solution and Maximal independent set maximal matching Delta plus one vertex coloring to Delta minus one edge coloring. These are all the Classics, okay, and for reasons that will become clear in a second. We're not gonna find these greedy problems very Interesting and also why in a couple of slides. So we're mostly going to be thinking about Locally checkable problems that do not have greedy solutions. So these are let's say finding a decent approximation to a maximum matching orienting the edges of an undirected graph so that there's no sinks Assuming that the graph can be Delta vertex colored then finding one To Delta minus two edge coloring. This is just slightly less than is allowed by the greedy algorithm and various other notions of coloring Okay, so I'm gonna start plotting all these time hierarchy type results on basically an asymptotic complexity line where on the left end of the line you have basically trivial problems that you can solve in constant time or maybe even zero time and Problems that require the diameter of the network time. So this is the in in the local model This is as bad as it can possibly get, you know in Turing machines. There's an infinite number of complexities There is no maximum complexity But here we really know that there is a maximum you you can solve any problem you want in the diameter of the network time Okay, so every problem can be solved at this point and all greedy problems on on on Constant-degree graphs and for the rest of this talk. I'm gonna more or less focus on just constant-degree graphs all greedy problems basically end up at the exact same complexity class and the reason is that when Delta is constant what you can do is apply Lineal's classic algorithm and Delta squared color the graph and then march through the color classes one at a time and when Vertex is deciding its output label It it looks in its neighborhood and then and then chooses one according to the greedy algorithm So basically any greedy greedily solvable problem on constant-degree graphs is gonna have one complexity Okay, so there's a lot of gaps here. Obviously. There's a big gap between log star and diameter and there's gaps between Constant log star and we'd like to know what what's in those gaps Okay, so before and concurrent with this work people basically settled the landscape of What complexities you can get on pretty simple network topologies? So this what I'm about to show applies equally well to paths cycles Grids and torus's so the main distinction between like a grid and the torus is grids have corners and torus is You know every protection is precisely the same neighborhood equation. Yeah So basically this log star and bomb does it randomize the deterministic? It's deterministic. I see. Okay. Thanks Okay, yeah, the the the algorithm to Delta squared color Graph is deterministic Okay, so what we have here is a nice situation Which is basically everything you see in the picture is about all that you can possibly get in these particular network topologies So now we're in stock Meyer back in the 90s showed that if your um If your algorithm solves an lcl problem in constant time Then it can be put in a certain canonical form where it basically ignores the values of the vertex ids these log n bit identifiers And it just functions based on the total order of the vertex ids that it sees So in this sense, it doesn't really care what the space of the ids is just the fact that they come from a totally ordered set Is all that it needs to run in constant time And they didn't really phrase this result as a as a speed-up theorem But it can be phrased that way and the details are in These two papers here. So on paths and cycles Basically any problem that you can solve in asymptotically less than log star and time can be automatically sped up To be constant and the reason is basically once you make an algorithm order invariant Uh, you it has no experience of what n is it can't see the graph So it doesn't know what n is in terms of number of nodes It uh, it no longer cares about how many bits are in the in the id so you can lie about what n is okay, and interestingly On paths and cycles there are no complexities in the other part of the spectrum either So anything that runs in more than log star and time But asymptotically less than the the diameter time So like less than square root of n for a grid or a torus Can be automatically sped up to run in log star time and again The main technique here is lying If you if you imagine that you're a node in the middle of of a very large grid or torus Uh, and you look out to some radius that's less than the diameter You're going to see some subgraph you already knew the topology of the subgraph that you'd see and And if someone told you that that's you know, and is different than what it is You'd have no way to uh to contradict them So it's very easy to lie to uh an algorithm And create the circumstances Where it thinks it's living in a much much smaller graph and it actually is And uh, and therefore you can you can speed it up by by tricking it So, um Okay, so that says uh and the the pass and cycles are basically the same So here's one way where they're completely different. Uh, everything basically is decidable on a path Uh, all the all these three complexities are uh decidable on a path whereas on a grid or a torus Um, you can't distinguish between constant time and diameter time Uh, basically so if you're given a description of the lcl You know in terms of explicitly acceptable our neighborhoods then, um You can encode in this lcl the functioning of a towing machine that that uh, you know Is given an empty tape and you just want to you know, tell if it halts or not Okay, so if it doesn't halt then there's no way to solve this lcl in less than diameter time And if it does halt you can solve it in constant time um, so uh This proof on a grid is basically trivial and on a torus because there's no corners You have to do a lot of work and that's in the the branched out paper Okay, so why is lying so easy? uh This is one of the reasons that the local model doesn't has a sort of a funny time hierarchy, which is um, there's this there's this parameter n that the algorithms You know use to determine the running time the running times are a function of n uh when delta is constant and n Refers to actually three distinct things. So n is uh the size of the graph log n is the number of bits in a vertex id And when you're running a randomized algorithm and you tell it, you know, it's okay to fail But just fail with this a certain probability um, you can think of the probability as being a separate parameter But we always fix it to be one over poly amp. Okay, so you can think of n as being You know just influencing the the error probability and uh All of these statistics here are a little bit unreliable right unless you see the entire graph you don't exactly know what n is And if someone changed the vertex IDs in your neighborhood, uh, then You know to be let's say come from a smaller set then you're none the wiser so the number of bits in your vertex id can be uh can be manipulated and um And uh, you can always just run an algorithm with a different error probability So the even number three is sort of a fungible uh number So I think this is basically the slide that says explains why Lying works in this model and it probably doesn't work in most computational models. You can't lie about the size of the input Okay, so, uh, this paper addresses, uh more expressive graph topology. So we have general graphs bounded degree graphs and Bounded degree trees So everything I'm going to talk about applies equally well to both except for one thing which only applies to uh trees so um, the now or stockmeyer argument, uh, is, uh is, uh, based on his uh, uh, hyper graph, uh Ramsey numbers and uh, it basically says you can speed up any algorithm if it runs sufficiently fast So in in general graphs and trees sufficiently fast is less than log log star Time so we get a a gap there in the lower end of the spectrum Um, so a line of work that showed up in 2016 Uh, actually separated randomized and deterministic complexity in a narrow range between Basically constant time and log n time Okay, so we actually have two branches here in the on the complexity Spectrum here depending on whether you're talking about deterministic bounds or randomized bounds so, um at the fox 2016 Uh, we proved this automatic speed up theorem that says if you ever if you have an algorithm that runs in less than log n Time sub logarithmic time, then you can automatically speed it up to run in log star time. So this is sort of a um Showing that there's there's there are no natural complexities between these uh two extremes for lcl problems and moreover you get a similar, um uh Gap and the randomized spectrum, but it's not the same so in general Uh, we showed that the randomized complexity of any problem Is at least it's deterministic complexity on instances that are logarithmic in that size so, uh one, um Implication of this is that there's no natural complexities between log star n and log log n in the randomized universe Okay, so here we have the possibility of an exponential separation Leaves open the possibility that you could have a problem that requires log n time deterministically but log log n time, uh randomized and we now actually have I think three and maybe only three Um three or four depending on how you count examples of problems where we know that this exponential separation actually shows up So the first problem uh to be shown with the the next initial separation is a problem of um, if you're given a A tree with maximum degree delta to find any delta vertex coloring of the tree Okay, so trees are too colorable, but even finding a delta coloring of a tree turns out to be kind of tricky And uh, it takes log log n time randomized and log n time deterministically the same is true of sinclest orientation on a graph with a a sufficiently large minimum degree And uh two delta minus two edge coloring so this was shown These results are followed from a series of papers that came out in the last two two years and the future Okay, so our first um result and the one that i'm going to show pretty much the entirety of the proof Uh in this talk is that uh, there's a gap in the randomized hierarchy Uh between log n and the complexity of the lavash local emma the distributed complexity of the lavash local emma So we can think of this as a as a completeness result It says if you have an algorithm and it runs in sub logarithmic time Then uh, its running time is actually at most the lavash local emma So the lll is is sort of complete for this uh complexity class And the next result uh that i'm going to talk about is that this uh up until now It was consistent with everything we knew that there were just a finite number of complexities and all lcl problems fit in that Finite set and it turns out that there's a a a class of somewhat contrived coloring problems Uh that we invented exactly for the the purpose of proving this theorem. They don't really um, you know show up in other places and um It's sort of a k level version of the two coloring problem with a little bit of you know extra flexibility So it's sort of two and a half color But anyway, so what we do is we show that uh, this particular problem, which is sort of uh parameterized by a constant k Uh has complexity exactly into the one over k and that this is uh optimal for You know randomized or deterministic algorithms. It doesn't really matter Randomness probably doesn't help with this uh with this class of problems Okay, and then on trees, uh, we get one extra result So if if your graph class is the class of boundary degree trees Then uh, we have a an exponent. I know a gap theorem that says that there are no natural complexities between log n and end of the little o of one and uh philosophically this is sort of um Interesting because if you read the literature on local algorithms people come up with local algorithms all the time That actually do have complexities that lie in this range. They're poly log n or they're Two to the square root of log n or something like that. It's very common to see complexities that are actually in this range So on trees, we can we can show through this mechanical process You're given an lcl and an algorithm that solves this lcl in unless they end of the little o of one time that it can be automatically sped up and be randomized and run in and run in log n time and um, this gap theorem Uh, I won't have time to uh to talk about it But it's qualitatively completely different than the other gap theorems in that it doesn't involve lying about n It doesn't involve tricking an algorithm into thinking the graph is much much smaller. Uh, it's based on completely different principles Okay, so, um Yeah, so I'm going to look at the first result now this uh, this idea that the lavash local Emma is complete for sub logarithmic time So, uh, you may be familiar with the lll, but I'm going to just describe the uh differences that you see in the distributed Version of the constructive lavash lemma local Emma, so you can define an asymmetric version of this Problem just like the asymmetric lll, uh, but for simplicity. Well, we're going to look at the symmetric version Okay, so the main difference is as follows. Um, the lll creates a dependency graph, which I'll get to And uh, the the basic assumption is that the communications network and the dependency graph are identical Okay, so how do you get this dependency graph? Um, the set of vertices are, uh, you can think of them as bad events That you do not want to happen And each, uh, vertex Uh, depends on a set of Variables, so each variable is let's say discreet and we know it's distribution and uh We're not going to get into specifying that but each very uh each uh vertex v Or you in this case depends on a set of discrete random variables, which we'll call the variable set So, um, if the variable sets of two vertices are disjoint then whether these bad events happen are obviously independent um, and we're defined the dependency graph to be you connect, uh A vertices u and v if their variable sets, uh intersect So the symmetric version of this lemma, uh says, uh, there's only two parameters of interest here when we're when we're judging whether, uh whether, uh We can find a good variable assignment. Uh, it's going to be the maximum degree in the dependency graph And the maximum probability that any event, uh occurs when the variables are selected according to their distribution So a typical, uh, lll criterion says that there always exists such a good assignment if, uh, let's say e times p times d plus one is less than one this is a standard form of the lemma and We're going to be looking at lll criteria that are much much much weaker than this And uh, most of them that we'll look at are polynomial criteria. So basically the probability that an event occurs Is inversely proportional to some polynomial in in the degree Okay, so the problem is compute a variable assignment such that no, uh bad event occurs And for the time being, uh, and in the subsequent slides, I'm going to fix this constant c to be whatever the c is in the lll criterion Uh, that's that we're using okay So we're going to have a black box algorithm that solves this uh lll problem And it says it works if it uh, if this inequality is satisfied for some specific constant c So it doesn't really matter what c is. It could be, you know, 50 or something I'm still a little bit confused about the definition. Can you say again what exactly the input is and the output? Oh the input. Okay. So, um, you are a vertex. You know the variables that are in your set You know their distributions And you know who your neighbors are You don't have any knowledge of the set of all variables Uh, but you do know your own variables and their distributions And those variables, how did they get assignments? Well, they come from some demand. They could be uh bits. They could be uh colors They could I mean any any discrete finite distributions find you say I know the variables You mean I know the assignment to my variables You know, there is no assignment. You know their distribution So, you know, if each variable is selected according to its distribution The probability that you are your bad event occurs is at most p And are we supposed to choose from that distribution? What was that? Am I am I required to choose from the correct distributions somehow? No, no the the algorithm does not have to choose anything randomly the algorithm can be deterministic But the guarantee is if these variables are selected according to a certain distribution That the probability that they occurs p you don't actually have to select them randomly, but it has to be banded It has the what it has to be a satisfying assignment at the end Yeah, it has to be a satisfying assignment and obviously consistent, you know Two two events that share the same variable have to agree on what the assignment is to that variable and What where does where is specified what it means for? Something to be satisfied. Is it part of the input? Um each vertex cares about the variables that are in its variable set And it cares about those assignments and it does not care about anything else So as long as it picks an assignment that is consistent with its neighbors and makes its own event Not bad not not occur Then it's happy Okay, so when you say v column bad event, it's not it's not that you mean to say that It's not as v is the set of bad events, right? I think I'm too confused by the Second bullet there Well, I mean they're identified with bad events But there are also computers because the dependency graph and the communications network are identical So the events themselves are communicating in a way. Okay Okay, so the speed up Goes like this. We're going to get his input an algorithm a And the claim is that it solves some lcl problem Some specific lcl problem in sub logarithmic time With a certain failure probability, which we'll just fix that one over end Some polynomially small error probability Okay, so The first thing I'm going to do is say that this the the way that this is expressed is is a little wrong Because when you say sub logarithmic time, what you mean is, you know, if n goes to infinity As n goes to infinity the running time tends to You know something a little over log n. Okay, but we're not going to make n get large We're going to make n get very very very small So these these asymptotic expressions of the running time are not precise enough So we're going to think of n is becoming very very small. So We're going to say that the what what this means sub logarithmic time is that For any constant epsilon that we choose We can express the running time in such a way so that it's upper bounded by something that depends only on delta And something that can be made arbitrarily Small Compared to log based delta of m Okay, so this c might depend on on epsilon for example But once we fix a specific c like one over a hundred we can express it in exactly this form Okay, and most of the algorithms that we we see that actually do run in sub logarithmic time can easily be expressed in this In this form Okay, so the next thing that we do is we figure out A small value of n. Let's call it n star such that if you Told the algorithm that n is n star The size of the size of the graph is n star Then it would run in t star time and t star is sufficiently small relative to log based delta n star so There always is such a t such an n star And it's fairly easy to show that the the t star here is going to be something on the order of whatever this term is that depends on delta Okay, so now we're going to lie to the the algorithm. We're going to say the graph is size n star Uh, that means that you get to run for t star time Um, and what is the algorithm going to do the algorithm is let's say the algorithm that uh that is running at the vertex v It's going to gather up Let's say all the information in its t star neighborhood And then decide on its output label Okay So if v decides on its output label, but it also wants to let's say check whether it's it's uh It's uh neighborhood is consistent, you know, whether it it satisfies the uh the the rules of the lcl Then it also needs to generate the labels of its immediate, uh neighbors So uh to get its own label it needs to gather up its t star neighborhood, but to gather up its uh To generate its own label And its neighbors labels so it can check consistency It needs to look up to some t star plus little of one radius to uh generate all that information okay so The important thing about this sub logarithmic running time is that uh v is none the wiser So in other words, we told v that the size of the graph is n star And based on what it sees it sees a sub graph that is consistent with it living in an n star vertex graph It does not see anything to contradict that fact And if we change the the running time to be, you know logarithmic or more then we would not be able to guarantee this type of indistinguishability Okay, so one or two, uh Vertices dependent they're dependent if basically they depend on any common information whatsoever, which just means that their Their t star plus o of one balls intersect Okay, okay, so we're now uh about ready to actually build the Uh lll instance and the dependency graph And we do it as follows Um Yeah Sorry keep it trapped in you but just So first it would help if you could say once more what is what it is exactly that you're proving and also Did you ever mention what complexity l l is what what do we know? I will it's it's it's complicated So it's secret. Okay. There's some number Yeah, I will so yeah Right. I'm sorry. I should restate. Yeah. What are we're doing? We're trying to take an algorithm a it's a black box algorithm We don't know how it works We're guaranteed that it runs in sub logarithmic time and by sub logarithmic. I mean this running time here um And the idea is we're going to automatically speed it up so that The resulting algorithm runs in something on the order of the complexity of the lovash local emma Which might be log n or Of course, what okay as far as we know it might be log n in which case this is it might be log n Yeah, but hopefully it'll be a lot faster. Okay. Okay. Thanks. Okay So, uh, we now need to build this, uh instance to hand to the lovash local emma algorithm and it needs to know what the what the events are what the variables are what the Uh dependency graph looks like and everything so the variables are basically everything that Uh Was generated all the random bits that were generated locally at v form We'll call it one random variable xv and this encapsulates everything that that Was controlled by v in the algorithm Okay, so, uh a vertex v is influenced by you The the let's say the random bits generated by you if they are uh sufficiently close after too far away Just they can't influence each other. So there's you know as no bearing on it so if you and v uh Are a distance t star plus, uh Uh o of one um Should be two t star that's a typo should be two's t star plus of one then. Um, I'm sorry. Sorry. Sorry. Yeah, this is correct So yeah, the variables of v are everything that influence the behavior of v and that's everything and it's t star plus o of one neighborhood And the dependency graph is uh, we have an event for each uh for each vertex So the event ev is the event that V's neighborhood is inconsistently labeled according to the rules of the lcl So by the definition of the algorithm a The probability that this uh event happens is the most one over n But we're lying to the algorithm. So it's not one over n. It's one over uh n star in this case The probability that ev happens is is one over n star And the dependency graph h is we have a vertex for each uh of these bad events And we connect up two bad events if they uh share variables which in this case means that their distance is roughly two t star Okay, so the lll parameters here are uh, the probability of error is one over n star and because uh the under the the degree in the underlying graph, let's say is delta The degree in the dependency graph d is delta to the roughly two t star Okay, so this satisfies the lll criterion Uh, basically by design we we chose t star specifically So that the exponent here would be less than log based delta of n star So at this point we have our dependency graph. We have the random variables and their distributions. We have the uh bad events Each bad event knows which variables it depends on so we have an instance that we can hand To a distributed lll algorithm and say find me a variable assignment that satisfies everything. And of course what that means is find me uh The outcomes of these coin flips at every vertex so that nobody Makes a mistake. No one no one has a a neighborhood that is inconsistent with the lcl so um the real underlying communications network is g And we're running this algorithm on h and because vertices and h are connected by a path of Uh length c of delta and g we can just simulate this algorithm with a certain Slowdown that that depends on that factor. Okay, so if delta is constant this is a constant slowdown and we get uh something that's linear in the complexity of The lavash local Emma okay, um so that's the end of the proof And if there's any questions, I should I ask them now and in the next slide I'm going to go over basically what is the complexity of the lavash local Emma and what do we know about it. So Okay, I'll go on Trying my luck once more. So, um, where is that they actually use the fact that the sub logarithmic When effects log in the remix. Okay, so here's it. Here's an example. Um, so We're using the fact that a sub logarithmic When we're saying, uh The algorithm has to perform as advertised because what this vertex vcs is consistent with A sub graph inside an n star vertex graph Now as soon as an algorithm runs in logarithmic time, you can't claim this type of thing. For example, I can say, um You know the algorithm Needs to see a degree two vertex Or a degree one vertex or a cycle And you can always see one of those three things if it runs in log n time Because if you look out to log n radius, you're going to see a degree one vertex a degree two vertex or a cycle Okay, but anything that runs in sub logarithmic time. It can never it can never depend on seeing one of those types of, uh, graph features Okay, so we're allowed to lie to it in this sense because it can't distinguish lying from truth But where does it show up in the proof? Um, we just can't even proceed There I mean there's no way to get past this step if v can tell the difference between you lying to it and you not lying to it Then you can't proceed So the claim is that v sees a sub graph that has fewer than n star vertices in it And there's no way it can uh, it end up sees a sub graph that's consistent with a ver living inside an n star vertex graph And that's because t star is basically much much less than log base delta of n star Does that make sense Yeah, okay. So yeah, and then So in the next slide, how do you get c of delta? How do you make sure get capital c of delta without the extra log? when you said it Slowdown is only by the factor of c of delta Yeah, this is uh, I mean c of delta could be the dominant term until n gets to be some size and then And then eventually this epsilon log delta n will be the dominant term Right, so we're just waiting for this second thing to be the dominant term And when it is uh, when it dominates the c delta, uh, we'll stop when it's uh when the leading constant here is 1 over 2c So so epsilon I mean the epsilon that we pick is going to depend on c. It's going to be Something on the order of 1 over c How can I think of this n star and the t star those are our constants? Yes, these are constants that depend on Um, everything that you see in the running time here the epsilon the capital c Yeah, these are all constants that depend on those things Cut you and the running time actually comes from the l l l once you have the l l l everything is That's right. Yeah, so yeah n star and t star constants. I should have emphasized that. Yeah So what's the special about philip probability 1 over n? How robust is this? Um, that's how we measure error probabilities probabilities typically in uh in algorithms. So um I mean, I I could choose one over a square root of n one. I mean So it's robust where all the same there's nothing special about 1 over n Not too special now any inverse polynomials fine Um, okay, so what do we know about the l l l? Uh, the l l l has of course a very deep history I'm just going to start in 2010 with mojo and tardos Uh, because well, it's a nice algorithm and it's the first algorithm that was um, I think specifically Uh mentioned that it can solve it in a in a distributed network So, uh, their algorithm uh runs in log squared n uh time and satisfies the a pretty strict l l l criterion Uh, we showed uh several years later that uh, when they're a weaker criterion you can run it in log n time And it's still using the mojo tardo's framework. I'll resampling basically it's a natural randomized algorithm Uh, the lower bounds are nice Uh, so brant et al showed a new lower bound technique Uh, and uh proved that a specific problem whose existence Uh is proved using the l l l Needs log log n time and therefore the l l l itself also needs log log n time And this is uh, this holds with just about any reasonable criterion even something that's exponential like this was This lower bound holds even in this case Um, so this is for randomized algorithms. Uh, we showed that it can be de randomized and And made exponentially larger. So deterministic l l l algorithms require uh log n time And uh in the paper which we originally posted on the archive we We conjectured that log log n should be the right answer for some polynomial criterion Or you get to pick the c you can make it as big as you want as long as it's constant log log n should be Should be the right answer for some c and um uh Emmanuella fischer and mosin gaffari got to work immediately and uh started trying to prove this conjecture And they came up with some pretty spiffy algorithms. So their first algorithm is randomized And it runs in slightly sub logarithmic time Uh, where the sub logarithmic part here is sort of uh, measured according to The you know strength or weakness of the l l l criterion. So it's you know, the exponent here is inversely proportional to c so if c is You know 10, let's say you get something uh sub logarithmic here And you uh, you pay for the the degree in the dependency graph So one thing that we didn't immediately anticipate when we proved our uh this gap theorem is that uh the um Is that it could be used on the l l l algorithm itself I mean the input algorithm might be solving the l l and the output algorithm might be a sped up version of that uh algorithm So this is exactly what fischer and gaffari did they use this algorithm as the as the sub logarithmic algorithm fed it into the Reduction and it turns out that when d is sufficiently small you can get a very strongly sub logarithmic, uh Running time with a polynomial l l l criterion Okay, so that's the state of the art for general graphs And uh in a soda paper coming up soon. We we proved uh this conjecture in the special case of tree structured Uh dependency graphs, so if your underlying graph is a tree Then the dependency graph that pops out of that is tree structured in a sense and on that class of dependency graphs We can we can actually achieve log log n time So uh set to have a question uh in the picture that you showed way back Uh this if you your conjecture was true, this would basically imply that there is no intermediaries things. That's basically uh log n log log n and log star n. Is that true? Yeah, that's exactly right. So so for trees there is no intermediate stuff log log n is where the l l l is And there's nothing in between that and log n Okay, so uh, that's all i'm going to say about the l l l. So let's get to the real um the title of the paper At least it's the the time hierarchy. How do you get these infinite number of complexities? so uh the problem Uh is two and a half coloring and it's going to look a lot like two coloring but with a lot of extra rules so The first thing that we're going to do Uh the even to explain what the rules are depends on this uh graph partition Okay, so k is an input is a is a parameter of the problem and it's uh, it's fixed It's some constant like two or three In the example i'm going to give k will be three So we partition the graph into uh vertices as follows V one is all vertices with degree one or two And when you peel those out of the graph, uh any Vertex that now has degree one or two is part of v two and when you peel those out of the graph Any vertex that has degree one or two is now part of v three and so forth and so on So here's an example of a graph We would assign all of these things here Uh to be level one vertices v one The green ones And then when you remove those green vertices, then you get a bunch of new degree one and degree two vertices and all of these would be called level two And then when you remove those you get a bunch more degree two vertices or degree one vertices and all of those are called Level three. So obviously by design when you look at the connected components of vertices that are induced at a particular level Um, they're always going to be um paths or cycles Okay, so the problem is to color this graph according to the following rules So the two colors are black and white. Those are the first two symbols Um, but you don't have to color every vertex black or white. You're allowed two other options Some vertices are exempt. They don't need to be colored and that's a good thing And some vertices can choose not to color themselves and they can abstain So we have exempt abstain or color yourself black or white and the exemption rule, uh says that uh If you are a vertex, let's say at level i And you have a neighbor at a lower level and that neighbor did color themselves black or white Then you don't need to be colored. You can color yourself exempt Okay, so everybody who's colored exempt, uh is let's say part of the set x Okay, the tool coloring rule, uh says that if you look at the path or cycle induced by vertices at a particular level and you Ignore the exempt vertices you take those out. So you have um, uh This is only this rule only applies to vertices that were not colored by the exemption rule Then whatever remains is you have two different options about what to do Uh, you're allowed to two color the path with black and white Or you're allowed to make everybody on the path simultaneously abstain. You can't have any middle ground here Either everyone does participates in the valid two coloring or everyone simultaneously abstains Okay, so up until now a pretty obvious, uh Way to satisfy these rules is just everybody abstain. So we need a rule that says that's not going to happen and the level k rule says that, uh Any degree one vertex in the graph at the highest level Um cannot abstain and therefore must be two colored or uh the exempt Okay, so this is the set of rules and um, I'll describe an algorithm and then once you see the the shape of the algorithm It'll be pretty clear You know why it's plausibly optimal Okay, so the theorem is is that uh, this version of the problem, uh, the k level hierarchical Two and a half coloring takes n to the one over k time. So I'm going to show you the algorithm and it's deterministic and the Uh and the lower bound says that even randomized algorithms can't uh do better than this with more than uh negligible probability of success Okay, so the algorithm of the ideas you uh, you color the vertices in exactly the order that these uh sets were Were peeled off. So you color all of v one then you color all of v two v three up to v k Okay, so we're coloring a vertex u at the ith level, let's say And uh, the first thing we do is just see if it's if it's under the exemption rule So it looks at its neighbors if it sees any lower level neighbor that got colored black or white already Then it just says i'm exempt And it joins the set x And then if it doesn't satisfy that rule, uh, this vertex u Identifies the path or cycle in its level that contains it Okay Um, and it does one of two things. So it uh determines that either P is a cycle or p is a path and p is too long Too long in this case is on the order of n to the one over k Okay, so if you're a cycle or the path is too long Then everybody simultaneously on p uh abstains And they can figure out which case they're in in roughly n to the one over k time So if p is less than um n to the one over k two times n to the one over k And a path then it too colors itself and that also takes n to the one over k time okay, so Um, that's the entire algorithm. Um, so it obviously runs in the right time. The only thing that you have to check is that uh It doesn't cause any vertex on the top level to abstain and the reason roughly goes like this Uh, the only way you could possibly abstain on the top level is if you had uh, let's say Uh a path of length greater than two to the Two times n to the one over k And the only way you could possibly have a path Of that length on the top level is if there were n to the two over k Vertices on the top two levels and the only way that could happen is if there were n to the three over k vertices on the top three levels and so forth and so on And the only way that all of these things can simultaneously be true Is if you had more than n vertices in the graph on all the levels combined and that can't happen So therefore the top level can never have a path of length longer than n to the one over k Okay, and the lower down basically yeah, I have a quick question. So you um, is it you haven't said this maybe It's obvious. So the nodes can figure out what which set v1 v2, etc. They're they're in Yeah, they can figure out what set they're in in in on the order of k time Yeah, right every vertex just looks at its neighbors counts them says i'm either degree one or two If you are you alert all your neighbors and say i'm in the set v1 So they know the know to subtract you from their degree count If their degree becomes one or two then they alert their neighbors that they're in set v2 and so forth and so on Yeah, thanks Yeah, so uh, yeah, so we have this sort of um Behavior where you you simply cannot have a very long path at the top level Otherwise you would have more than n vertices In the graph total, okay, and proving that this randomness doesn't help and that the the the complexity of this problem Is uh is also into the one over k is uh, I guess left for the paper Okay, so the result that i'm not going to talk about is actually the most uh technically involved Involved lying about the size of the graph it uh, it uses sort of a a combination of a pumping lemma tailored to trees and Uh a simulation argument so rather than convince all the vertices that they live in a very small graph We actually tell the vertices that they live in a really enormous graph And have them simulate the behavior of algorithms on that enormous graph um, it's a completely different uh argument than most of the other gap theorems on on this slide Okay, so that only applies to trees and uh, and it's a sort of an interesting open question whether you can get a similar gap on on general graphs Okay, so here's some interesting open questions I think the foremost one is to really uh figure out the the complexity of the lavash local lemma under a polynomial criterion of your choice And uh, one of the funny things about this question is that you know, we don't know what the answer is but we do know that you have to Simultaneously get the randomized and deterministic complexities settled in the same paper You can't solve these problems independently. They're basically one in the same so Uh, the randomized, uh, I mean you could solve the deterministic complexity in one paper and then the randomized one next But you can't do it in the in the opposite order the randomized complexity depends on the deterministic ones Okay, so another one problem that I am interested in is um, basically I want to know how far this this Hypergraph ram's the argument can go and whether you can actually Show that nothing exists in the range between constant time and less than log start time Uh, or whether we need some new arguments to actually understand this this, uh this territory of the complexity spectrum and uh, lastly, I mean everything I talked about, um I mean it applies to graphs in one way or the other with the unbounded degree I mean some of the results hold as is some results hold when you parameterized by delta and some of them kind of go Out the window as soon as delta is not constant um, so to really understand the complexity hierarchy for unbounded degree graphs is a is a is a challenging problem and um It's all I mean it's already unclear what the answer You know in terms of what the answer should look like in terms of its format for example Delta plus one coloring You know has algorithms that have running times that are largely expressed in terms of delta And then it has running times that are expressed, uh in terms of n that are independent of delta Even you know, even when out delta is unbounded Um, so it's it's unclear what part you want. Maybe you want a hierarchy That's just in terms of delta running times or a hierarchy that's independent of delta You have to rephrase the the question a little maybe Okay All right, that's all I have Thank you set. Uh, now i'm going to ask are there any questions from any of the audience Yeah, I guess I have a question though It's not maybe probably relevant because you talked mostly about this bounded degree model So for example, if we allow large degrees other known gaps between Like the model when we talk to like one neighbor per round versus like all possible neighbors At the same time um I don't know um Yeah, so most of the literature i'm familiar with considers models where you get to talk to all your neighbors, but maybe the constraints are on the size of the messages um, I don't know many good, uh Results on models where you can only talk to one at a time um, I guess In some sense, I mean you might have to assume they you're in some sort of asynchronous model and then The notion of time is a little flexible, right? Thanks Is it supposed to be obvious that randomness does not help for the two and a half coloring problem? uh, no, it it's not really obvious, but um, it should feel natural because um, the thing that you're asking these algorithms to do is to color a path And the only way to two color a path is to know your distance from one end point to the path or another Because you have to correlate your your answer with the an endpoint of the path So I mean to make sense that randomness can't help just because you know, you can't guess what the How long your path is unless you've seen the length? Okay, thank you I have a question. Um, I was wondering uh You you talked about lcls. Are there any other perhaps natural problems that you consider could consider in the local model? Uh that fall outside of lcls. Yeah. Yeah Um, yeah, there's there's several problems that makes sense. Um, for example, I mean if you just wanted to Uh compute your distances from a specific source in the graph Um, I mean the complexity of that problem is pretty obvious But the resulting labeling would be a distance and a distance does does not come from an alphabet size That's independent of n it comes from an alphabet size that depends on n So that doesn't quite fit in the framework of an lcl. Um, other problems are approximation algorithms where um Let's say you you want to guarantee a global um approximation of some quantity Uh, but that a global approximation of some quantity is not necessarily witnessed by locally Local neighborhoods that look a certain way Does that make sense? Yeah. Yeah, that makes sense. Do you think there's any hope for a time hierarchy theorems for these types of problems? um, no idea Haven't thought about Any more questions? I have another another question, which I think is a little bit more philosophical. So basically, uh In all these models and all these papers you are solving some graph problem But on the graph which exactly corresponds to your network topology I always was thinking that it sounds like a little bit of Of an arbitrary restriction Has people looked at the cases when like the graph we care about and the network graph are actually different? Maybe they're closed, but they're nevertheless different um, I don't I don't know any work that looks at the case where they're two completely independent graphs Uh, but the congested clique model does look at a nice situation where the communications network is a complete graph Yeah, and the input graph is arbitrary and the the data about which edges are present or missing is stored at all the nodes So you can talk to anybody you want at any round. You don't have to be connected to them by an edge but um But there the communications graph is fixed. I mean, it's it's not an arbitrary graph So potentially you can imagine that there is some notion of like distance between graphs Such that the smaller the distance is the the easier it becomes to solve, but yeah It's If there is a are there any further questions If not, we're going to take this offline. Uh, you can still hang around and talk to set a bit more if you have time to stick around Um, besides that I want to remind you that Two weeks from now we have all a sense in and then one week after that we have the node Thanks all for coming