Long range failure-tolerant entanglement distribution
Benjamin, Simon
We introduce a protocol to distribute entanglement between remote parties. Our protocol is based on a chain of repeater stations, and exploits topological encoding to tolerate very high levels of defect and error. The repeater stations may employ probabilistic entanglement operations which usually faill; ours is the first protocol to explicitly allow for technologies of this kind. Given a error rate between stations in excess of 10%, arbitrarily long range high fidelity entanglement distribution is possible even if the heralded failure rate within the stations is as high as 99%, providing that unheralded errors are low (order 0.01%).
 about long range entanglement distribution. Hello, hello, hello. Good, that's working. Up a bit. All right. Okay, cool. Yeah. So just winning it back and forth. Okay. So thank you very much to, thank you very much to the organizers for letting me contribute this talk. It's a little bit different from what's as advertised. I will get to the stuff that's advertised in due course, but talking to people, I guess an advantage of coming at the end of the conference is I get to see what everyone else is talking about. And I also get to talk to other people and see what they'd be interested in hearing about. So I've kind of made some modifications and I'm telling the story in a little bit more detail, I guess. Okay. So the basic question that I'd like to interest you in is how are we going to do quantum computing, preferably fault tolerant quantum computing. If we have entanglement operations that are very prone to fail. Now, what I mean by fail is not generating error. I mean just outright failed and you know that it failed. So what we call a heralded failure. So our entanglement operations are very prone and when I say very prone, we'll talk about those actual probabilities, but think 70%, something like that, you know, more than 50% chance. But when you try and entangle two qubits, your apparatus will say, no, I tried, I failed, I'm sorry, it's all gone wrong. And those two qubits, in that case, you should also consider are now corrupt. So if they previously had some kind of entanglement invested in them with partners, that's all been lost and spoiled. So if that's your model, you've, of course, on top of that, you've also got the usual kind of errors, single qubit errors, measurement errors, which you don't know about and presumably are at a much lower rate than 70%. We've got no hope. But the, you know, the new factor, I mean, many people have thought about this, of course, but the factor that is perhaps not usually considered is that we have a very high known failure rate. And so let's see, let's go on. Yeah, so I always find it helpful to have some kind of physical example in mind when I'm thinking about these things. This is by no means the only kind of scenario that would give rise to this picture. So what I'm thinking of here is you've got some kind of physical system, let's call it an atom. It's sitting in a cavity. So there on the right, we see a cute little sort of cavity image there. And light can come out of our physical structure perhaps due to some conditional transition in the level structure that it has. So obviously it will have a complex level structure, but it may contain something like this L structure that would be convenient. So we have some low-lying levels that are qubit and we have some optically excited state that can only be reached from state one. And so we can interrogate our qubit and ask it what state it's in by shining on light that would excite it to the optically excited state if it is in state one and then watch to see if the photon comes out. We can even repeat that. That's how we might measure it. So that structure then, an atom in a box, is like a module of our hardware. That's basically the unit of our quantum computer. And how are we going to entangle different modules with each other? Well, I'm sure pretty much everyone in the room is familiar with these kind of path erasure type tricks that we could use to do measurements, joint measurements on two such modules simultaneously in order to entangle them. And in fact, the most common kind of operation you end up with, if you do that kind of thing, is you end up with a parity projection on your qubits. And that's what I'm going to be assuming later on. But just generally, that is one example of why we might be thinking this, because if we lose foaming that process, the entanglement operation will go wrong. And we should know that that's happened because we'll fail to see photons in our measuring device. So then the kind of architecture that we might end up with is something like this. Very, very schematically, of course, you have a bunch of modules, which you could just plug more in if you wanted to. Each module contains one atom, or one qubit. You have some kind of switching device that allows you to choose which two guys to entangle with one another. And in fact, I'm going to assume parallelism so that I assume that because it's optical, light passes through light, and so I can try and entangle one of these guys with another while simultaneously attempting a different pairing. And in fact, I can pair everybody up and have a go at entangling them. This is the kind of picture we're talking about. What we have there in the inset is just, I don't know which of the particular, I think this might have been a device that was made by Bell Labs or something. It's a tiny little mirror that's sort of reorientatable, and that's the kind of thing that you might use to have this whole switching device. Obviously, you want the light to pass through this device without being measured. Okay. So just very briefly, if we did have, for this talk, I'm not going to assume this, but if we did have more structure within each module, like two qubits within each module, then it would be at least fairly easy to see how we might do quantum computing. Even though the entanglement operation is very likely to fail, the kind of thing we might do is we'd nominate one guy within each location to be in charge of getting entangled with other people, and another guy in each location to be not involved in that process. So then we would get it, so here the green guys, the brokers, the chaps who get entangled, you entangle that eventually after perhaps many attempts with the other module that you're shooting for. When you finally got entanglement, you can move it down, transfer it down, swap it down onto the clients, the quiet guys. So that at least, you know, who knows, we might come back to what the error rates and things structure, but at least you can see that that approach would work in principle. But we haven't got that, we've only got one qubit in each location. So I'm going to probably skip through this, even though it's a pretty diagram, because I realized that I started a little bit late, and let me go on to talk about the scenario I'm interested in is when the probability of successfully creating entanglement is significantly less than 50%. So the failure rate is higher than a half. How high might it be in reality? Unfortunately at the moment in experiments that have been achieved, the failure rate is enormous. This is kind of one of the earliest papers that got me excited. This was a paper by Chris Munn-Rosegroop, this 2007 paper, there because they need to see two photons in order to have their entanglement operation held it as a success, what they have to do is look at the success rate for retaining a single photon through the apparatus and square it in order to see two, and they end up with something like excesses per billion attempts. So that's obviously an appalling success rate, and it will be impossible to do QIP with such rates, but it does at least show us that we shouldn't be thinking for the foreseeable future that we're going to have lovely high success rates like 80%. We need to sort of look into the area of low success rates and see how things might work. NV centers, another very interesting approach, have similar problems which I won't go into if anything worse. So, alright, let's imagine we've got something like a 90% failure rate. How are we going to even approach the problem of quantum computing in a way that the errors, the genuine unheralded errors don't build up horrifically? So the kind of thing we might do is this. Let's say I want to make an entangled state of many of my qubits that's a useful state such as a two-dimensional cluster state like that. Then I'm going to make it by having building blocks, which I will obtain work through brute force if necessary. I'm going to build building block structures, each of which contains a great many qubits in, I'm sorry, when I put up these diagrams, this is a graph state notation, as I imagine pretty much everyone has assumed, if I have a blob then that's a line, that's a phase gate between those two qubits. So the kind of thing I might do is make these building block structures which have a huge number of qubits in them, and then arrange them so that there's one such blob for each eventual qubit that I want to have in my cluster state. And then I will try and fuse them up. And the way that I'll fuse them up is that I will, let's see if I can, no, that's not working for me really. What would that do? It's also not working. I can't really see anything. So if we look at these four guys, which are the highlighted block of four from the center there, what we can see is that we have many, as it were, dangling bonds on the end of our graph structures here. We can attempt to, each one of those leaves with a partner leaf in the next structure along. We can attempt that in parallel, and we have so many leaves that even though we have a high failure rate, we can then expect that we will probably succeed and make at least one bridge between these two structures. Okay, so that's the kind of approach we might take. Oh, okay, I see. Thank you. Okay, so the first question to ask would be what kind of building block structure should we employ? Various ones have been looked at in the literature by, well, for example, I think Nielsen looked at the star, Jens Eissert looked at a linear structure, Robert Rausendorf used these cross shapes. What I'm going to advocate is these binary tree structures, which we refer to in our paper as snowflakes, just because we like to draw and sort of picture them that way. And in a minute, I think I'll just be able to show you why the snowflake is actually the most natural and sensible building block object to use. Okay, snowflake. First off, how do we make them? If we do a parity projection on two qubits, let me try out that, yep, if we do a parity projection on two qubits, then up to local operations we get this graph state. If we then try and connect two of those guys, we get this three-pointed star. If we connect two stars, we start to get this tree. If we connect the core node of two trees, we get a larger tree. So they grow very efficiently. That's the first nice property of these star structures, these snowflakes. What's really important is that they give us a very large number of dangling bonds, these dangling bonds are going to be used for fusing up snowflakes with one another. They give us the largest possible number of these, considering the path length through the structure. So in a minute, we'll see that if we were able to successfully connect this particular qubit to another snowflake and this particular qubit to another snowflake, we would then want to just prune out all this extra structure. Because it's a binary tree, it means that a lot of the structure errors in this patch here, errors in this patch here and in this patch here, will not find their way onto the path that we're actually keeping. And the path itself is only of logarithmic length. So that's going to be very important in getting sensible performance for our structure at the end of the process. So let's remember this is very generally the kind of machine we might imagine. The other things that I will need from it, from my analysis, are that it should be able to do operations in parallel and that's the, let's say, that I'm arbitrarily allowed to connect any qubit with any other. That's going to be more than I need, but let's imagine that. Okay, so the kind of thing that will go on inside my machine is this. In a particular time step, S, I will have a whole bunch of qubits which are not entangled with any others, a whole bunch of qubits that are in pairs, a whole bunch of qubits that are in groups of four, and so on. What I will do is I will schedule, at time step S, I will schedule to pair up every one of the unentangled guys. I will schedule to pair up every one of the guys of size two to pair up and so forth. And I will then attempt all those operations in parallel in one time step. I will get some successes which will allow me to promote entities up one rank. And I will get, of course, some failures, more commonly failures than successes. I will take the very aggressive strategy that if I fail, even if I've managed to make a lovely, quite big thing like this, which has got a lot of investment in it in a sense, I then try and entangle this with this. If I fail, I've actually still got quite a lot of entangled structure there. But what I'm going to do is nevertheless bin it. I'll just break the whole thing down, reset all the qubits, and dump them back into stage zero. And the reason I'm going to do that is to crack down as aggressively as I can on the rate that errors build up. And I'll be able to show you what difference it makes if we don't do that presently. So we have this painful process of promoting ourselves to a larger and larger snowflake. But what I'm going to assume is that eventually we can get to snowflakes sufficiently large. Then if I try and pair two of these snowflakes up and connect, say this guy to this guy, while simultaneously trying to connect this guy to this guy, this guy to this guy, for the particular failure rate that I have, I will expect a greater than 50% probability, whatever probability I decide I need, that I will successfully create a bridge between these two structures, like this. That's the basic trick. I'll skip over this. This is just sort of a trick for making the last stage more efficient. So then we have our structures. Here are our snowflakes drawn slightly differently. We then try and connect them up in whatever topology that we're interested in. It's okay for some of these connections to fail, even though we've got multiple chances, sometimes all our chances will fail. That's all right, because we can use results like percolation to show that if we are able to have a pretty well connected 2D cluster state, then we can actually do quantum computing with it. And then here again is this point that when we come to clean the structure up, get to the cluster state that we really want, we are going to have paths that are only logarithmically long in the size of the snowflake. All right, so now let me show you what kind of performance we see. The first point here is that we see that it doesn't really make much difference if we have recycling. Recycling is the process of not chucking things away when we get our first failure. So in fact, we won't recycle, we will just bin things. Let me skip through this and show you this. This is quite interesting. I won't take too long on it. Basically, in order for our machine to operate efficiently and keep all its errors bounded as a logarithmic function of essentially one over the success rate, so logarithmically related to the probability, our fundamental probability that we can successfully make entanglement, in order to achieve that we need a big machine because we need to be making lots of these snowflakes at the same time so that we're never waiting for a partner to emerge for a snowflake of a given size. We're always straightforward and as soon as we have a guy of a certain size, in the very next step we'll try and partner him up. In order to do that, we need our computer to be of a particular size. So we had a rather interesting relationship between the probability of successfully making entanglement, that's presumably a very low level experimental parameter, and the size of the machine that this whole idea works for. So the lower the success rate, the bigger the machine needs to be. I can say a bit more about that if people are interested. Sorry? Oh, three minutes. Let me just get to the point which is, I think, going to be of most interest to you guys. So all of that, this idea of making snowflakes and joining snowflakes up and so forth, is basically a route to showing that I can create a useful structure with only logarithmic number of errors. But what I haven't obtained for you yet is any kind of threshold to see whether this is going to be a useful approach, how horrible things will be. So let's get a threshold now. Instead of having a target object which is a simple cluster state, let's try and get one of these topologically protected states, one of these Roussendorff-style states instead. In principle, that seems pretty straightforward. After all, it's a similar sort of challenge of connecting each building block object to four other objects. But the trick here that allowed us to complete the analysis was that we had this percolation result. Let me just skip through. So here we know that if we have a certain number of missing edges in our two-dimensional cluster state, then we nevertheless have a resource that's good for quantum computing. We need a result that's equivalent here if we're going to use all the ideas that I've developed so far in order to obtain an actual threshold-based result. So what can we do? We need to be able to say how many missing edges we can tolerate within a structure like that. Now, that result was just obtained last year by Sean and Tom, who are both in the audience here. Or rather, they were able to obtain the result. And you heard, if you are around, I think, yesterday, you heard Sean talk about this. You have a result that says, if you have a certain... Excuse me, I'm going the wrong way. That's unfortunate. So the result was that if you remove certain nodes from certain qubits from the structure, then it will still operate. You can remove up to 25% of them and it will still operate. What I require is missing edges, but that, in fact, is straightforward because what we need to do... Let's see if I can actually go backwards. What we need to do is identify a missing edge. Remember, these are known. I know where these edges are missing. And I will basically delete both the qubits from either end of this missing edge in order to then translate it into a question of missing qubits. So this is the equivalent of the percolation result from my purposes, which will allow me to then get a threshold. How will I do that? I will take, again, my snowflake concept, build these snowflakes, identify each one with a node of the target structure, and then try in parallel to connect them up, as shown here. And I know that some of those will fail, but as long as the rate of failure is below the essentially the translated 25% rate, then the eventual entity will still offer me fault tolerance. So I can simply inherit the results that those previous authors worked out in order to do some numerics and generate for you a threshold. So this is essentially the key figure for the talks, and let me tell you what it means. Here we have the rate at which I fail when I attempt an entanglement. So this is I always fail. This, of course, is a fairly trivial case with only 25% failures. This is setting all the kind of low-level errors in the device equal to one another, the single qubit errors, the two qubit errors, the measurements. Setting those equal to each other and calling them PG, this is what we then obtain. So here's using the snowflake, which as you can see is very superior to using the star or the cross because of this logarithmically beneficial path length that it has. And what we do here is we see that we can operate out to sort of 90%, even perhaps 95% failure rates, and in that regime the kind of actual error rates we can tolerate are 2 or 3 times 10 to the minus 4. Not a great number, but also not an insane number considering that we are tolerating an enormously high failure rate. So I need to mention to you that it doesn't make much difference if you put in reasonable memory errors, that those things are becoming corrupt all the time. That also doesn't spoil the situation for you. And finally, resources, of course, very important. The real problem that stops you getting to sort of the very high 90s is that the resource overhead explodes. So I think that if you're looking here in the sort of 80% regime, you can see that your overhead is like 100 qubits. That's a lot, but perhaps in solid state type scenarios where your qubits are not too expensive, that isn't completely crazy. So this, as far as we're aware, was the first result that basically related failure rate to actual error rate and obtained a threshold for this style. Now at the same time, I should mention really that these authors, who are also present at the conference, obtained almost exactly the same threshold by exactly the same techniques. We weren't aware that they were working on this. It's one of these strange situations where two papers emerged almost simultaneously. Okay, and I'm going to stop there because I can also tell you about communication thresholds. Actually, I'm going to just leave it on that slide. So you can also obtain, of course, higher numbers, 15% if you use the same tricks for... Okay, thank you. Time for maybe one or two questions. I'm trying to put together some of your numbers. So you've got overheads at about 80% or 90% of 10 to the 3, 10 to the 4. So this is for the general quantum computing rather than the communication, which I just mentioned. Yes, general quantum computing. I have to go back to this. Is this the one that you would like to see, or...? Yes, and then earlier on there was one way you were saying these types of codes would work at 80 or 90% for something like a computer of size 10 to the 11 qubits. I'm wondering what the size of the eventual, well, the number of qubits in the eventual lattice that you've got. Yeah, okay. So the trick is that when you're building these... Let me go all the way back if I can... Back, back, back, back, back, back... To show you how we're building these snowflakes. Can I hold it? Oh, yeah, I can. Okay. That's the one I want. So what we see here is how we're actually going to build these structures. It's very important if we're going to crack down on errors that we shouldn't let anything sneakily become non-logarithmic because the basic result, the nice result, is that all the errors are bounded by a logarithmic function of our failure probability. In order to stop memory errors from becoming a problem, I need this, basically, the situation that's shown in this schematic mustn't be allowed to happen. What I've got here, as you can see, as it happens, is one of these guys, and he has no partner with which to try and become entangled. So he will now have to wait until another partner emerges in order to try and create the next generation of object. If I allow that to happen, then I will spoil my logarithmic scaling. Therefore, my overall computer size must be such that I have a large number of snowflakes of every size, including the final size, emerging all the time. And that's where you saw that large number from. Basically, the larger my computer, the more snowflakes I'm going to need because I'm trying to create this large, either 2D cluster state or other geometry in order to do my computation. So provided that I'm attempt, it's perverse, provided I'm attempting a large enough scale computation, then I can know that I will actually have plenty of snowflakes of a given size as a function of the failure probability. We can talk about that a bit more at the end, if you like. But it's a rather strange relationship between how bad your hardware is and basically how large a computation you attempt to undertake. Let's thank Simon again. So we're approximately 10 minutes behind. I'll leave that to Daniel. 20 minute break. Your back's 11.
 about long range entanglement distribution.  Hello, hello, hello.  Good, that's working.  Up a bit.  All right.  Okay, cool.  Yeah. So just winning it back and forth.  Okay. So thank you very much to, thank you very much to the organizers for letting me contribute this talk.  It's a little bit different from what's as advertised.  I will get to the stuff that's advertised in due course, but talking to people,  I guess an advantage of coming at the end of the conference is I get to see what everyone else is talking about.  And I also get to talk to other people and see what they'd be interested in hearing about.  So I've kind of made some modifications and I'm telling the story in a little bit more detail, I guess.  Okay. So the basic question that I'd like to interest you in is how are we going to do quantum computing,  preferably fault tolerant quantum computing.  If we have entanglement operations that are very prone to fail.  Now, what I mean by fail is not generating error.  I mean just outright failed and you know that it failed.  So what we call a heralded failure.  So our entanglement operations are very prone and when I say very prone,  we'll talk about those actual probabilities, but think 70%, something like that, you know, more than 50% chance.  But when you try and entangle two qubits, your apparatus will say, no, I tried, I failed, I'm sorry, it's all gone wrong.  And those two qubits, in that case, you should also consider are now corrupt.  So if they previously had some kind of entanglement invested in them with partners, that's all been lost and spoiled.  So if that's your model, you've, of course, on top of that, you've also got the usual kind of errors,  single qubit errors, measurement errors, which you don't know about and presumably are at a much lower rate than 70%.  We've got no hope. But the, you know, the new factor, I mean, many people have thought about this, of course,  but the factor that is perhaps not usually considered is that we have a very high known failure rate.  And so let's see, let's go on.  Yeah, so I always find it helpful to have some kind of physical example in mind when I'm thinking about these things.  This is by no means the only kind of scenario that would give rise to this picture.  So what I'm thinking of here is you've got some kind of physical system, let's call it an atom.  It's sitting in a cavity. So there on the right, we see a cute little sort of cavity image there.  And light can come out of our physical structure perhaps due to some conditional transition in the level structure that it has.  So obviously it will have a complex level structure, but it may contain something like this L structure that would be convenient.  So we have some low-lying levels that are qubit and we have some optically excited state that can only be reached from state one.  And so we can interrogate our qubit and ask it what state it's in by shining on light that would excite it to the optically excited state  if it is in state one and then watch to see if the photon comes out. We can even repeat that. That's how we might measure it.  So that structure then, an atom in a box, is like a module of our hardware.  That's basically the unit of our quantum computer. And how are we going to entangle different modules with each other?  Well, I'm sure pretty much everyone in the room is familiar with these kind of path erasure type tricks that we could use to do measurements,  joint measurements on two such modules simultaneously in order to entangle them.  And in fact, the most common kind of operation you end up with, if you do that kind of thing, is you end up with a parity projection on your qubits.  And that's what I'm going to be assuming later on. But just generally, that is one example of why we might be thinking this,  because if we lose foaming that process, the entanglement operation will go wrong.  And we should know that that's happened because we'll fail to see photons in our measuring device.  So then the kind of architecture that we might end up with is something like this.  Very, very schematically, of course, you have a bunch of modules, which you could just plug more in if you wanted to.  Each module contains one atom, or one qubit.  You have some kind of switching device that allows you to choose which two guys to entangle with one another.  And in fact, I'm going to assume parallelism so that I assume that because it's optical, light passes through light,  and so I can try and entangle one of these guys with another while simultaneously attempting a different pairing.  And in fact, I can pair everybody up and have a go at entangling them.  This is the kind of picture we're talking about. What we have there in the inset is just, I don't know which of the particular,  I think this might have been a device that was made by Bell Labs or something.  It's a tiny little mirror that's sort of reorientatable, and that's the kind of thing that you might use to have this whole switching device.  Obviously, you want the light to pass through this device without being measured.  Okay. So just very briefly, if we did have, for this talk, I'm not going to assume this,  but if we did have more structure within each module, like two qubits within each module,  then it would be at least fairly easy to see how we might do quantum computing.  Even though the entanglement operation is very likely to fail,  the kind of thing we might do is we'd nominate one guy within each location to be in charge of getting entangled with other people,  and another guy in each location to be not involved in that process.  So then we would get it, so here the green guys, the brokers, the chaps who get entangled,  you entangle that eventually after perhaps many attempts with the other module that you're shooting for.  When you finally got entanglement, you can move it down, transfer it down, swap it down onto the clients, the quiet guys.  So that at least, you know, who knows, we might come back to what the error rates and things structure,  but at least you can see that that approach would work in principle.  But we haven't got that, we've only got one qubit in each location.  So I'm going to probably skip through this, even though it's a pretty diagram,  because I realized that I started a little bit late, and let me go on to talk about the scenario I'm interested in  is when the probability of successfully creating entanglement is significantly less than 50%.  So the failure rate is higher than a half.  How high might it be in reality?  Unfortunately at the moment in experiments that have been achieved, the failure rate is enormous.  This is kind of one of the earliest papers that got me excited.  This was a paper by Chris Munn-Rosegroop, this 2007 paper,  there because they need to see two photons in order to have their entanglement operation held it as a success,  what they have to do is look at the success rate for retaining a single photon through the apparatus and square it in order to see two,  and they end up with something like excesses per billion attempts.  So that's obviously an appalling success rate, and it will be impossible to do QIP with such rates,  but it does at least show us that we shouldn't be thinking for the foreseeable future  that we're going to have lovely high success rates like 80%.  We need to sort of look into the area of low success rates and see how things might work.  NV centers, another very interesting approach, have similar problems which I won't go into if anything worse.  So, alright, let's imagine we've got something like a 90% failure rate.  How are we going to even approach the problem of quantum computing in a way that the errors,  the genuine unheralded errors don't build up horrifically?  So the kind of thing we might do is this.  Let's say I want to make an entangled state of many of my qubits that's a useful state such as a two-dimensional cluster state like that.  Then I'm going to make it by having building blocks, which I will obtain work through brute force if necessary.  I'm going to build building block structures, each of which contains a great many qubits in, I'm sorry,  when I put up these diagrams, this is a graph state notation, as I imagine pretty much everyone has assumed,  if I have a blob then that's a line, that's a phase gate between those two qubits.  So the kind of thing I might do is make these building block structures which have a huge number of qubits in them,  and then arrange them so that there's one such blob for each eventual qubit that I want to have in my cluster state.  And then I will try and fuse them up.  And the way that I'll fuse them up is that I will, let's see if I can, no, that's not working for me really.  What would that do? It's also not working.  I can't really see anything.  So if we look at these four guys, which are the highlighted block of four from the center there,  what we can see is that we have many, as it were, dangling bonds on the end of our graph structures here.  We can attempt to, each one of those leaves with a partner leaf in the next structure along.  We can attempt that in parallel, and we have so many leaves that even though we have a high failure rate,  we can then expect that we will probably succeed and make at least one bridge between these two structures.  Okay, so that's the kind of approach we might take.  Oh, okay, I see. Thank you.  Okay, so the first question to ask would be what kind of building block structure should we employ?  Various ones have been looked at in the literature by, well, for example, I think Nielsen looked at the star,  Jens Eissert looked at a linear structure, Robert Rausendorf used these cross shapes.  What I'm going to advocate is these binary tree structures, which we refer to in our paper as snowflakes,  just because we like to draw and sort of picture them that way.  And in a minute, I think I'll just be able to show you why the snowflake is actually the most natural and sensible building block object to use.  Okay, snowflake.  First off, how do we make them?  If we do a parity projection on two qubits, let me try out that, yep,  if we do a parity projection on two qubits, then up to local operations we get this graph state.  If we then try and connect two of those guys, we get this three-pointed star.  If we connect two stars, we start to get this tree.  If we connect the core node of two trees, we get a larger tree.  So they grow very efficiently.  That's the first nice property of these star structures, these snowflakes.  What's really important is that they give us a very large number of dangling bonds, these dangling bonds are going to be used for fusing up snowflakes with one another.  They give us the largest possible number of these, considering the path length through the structure.  So in a minute, we'll see that if we were able to successfully connect this particular qubit to another snowflake and this particular qubit to another snowflake,  we would then want to just prune out all this extra structure.  Because it's a binary tree, it means that a lot of the structure errors in this patch here,  errors in this patch here and in this patch here, will not find their way onto the path that we're actually keeping.  And the path itself is only of logarithmic length.  So that's going to be very important in getting sensible performance for our structure at the end of the process.  So let's remember this is very generally the kind of machine we might imagine.  The other things that I will need from it, from my analysis, are that it should be able to do operations in parallel and that's the,  let's say, that I'm arbitrarily allowed to connect any qubit with any other.  That's going to be more than I need, but let's imagine that.  Okay, so the kind of thing that will go on inside my machine is this.  In a particular time step, S, I will have a whole bunch of qubits which are not entangled with any others,  a whole bunch of qubits that are in pairs, a whole bunch of qubits that are in groups of four, and so on.  What I will do is I will schedule, at time step S, I will schedule to pair up every one of the unentangled guys.  I will schedule to pair up every one of the guys of size two to pair up and so forth.  And I will then attempt all those operations in parallel in one time step.  I will get some successes which will allow me to promote entities up one rank.  And I will get, of course, some failures, more commonly failures than successes.  I will take the very aggressive strategy that if I fail, even if I've managed to make a lovely, quite big thing like this,  which has got a lot of investment in it in a sense, I then try and entangle this with this.  If I fail, I've actually still got quite a lot of entangled structure there.  But what I'm going to do is nevertheless bin it.  I'll just break the whole thing down, reset all the qubits, and dump them back into stage zero.  And the reason I'm going to do that is to crack down as aggressively as I can on the rate that errors build up.  And I'll be able to show you what difference it makes if we don't do that presently.  So we have this painful process of promoting ourselves to a larger and larger snowflake.  But what I'm going to assume is that eventually we can get to snowflakes sufficiently large.  Then if I try and pair two of these snowflakes up and connect, say this guy to this guy,  while simultaneously trying to connect this guy to this guy, this guy to this guy,  for the particular failure rate that I have, I will expect a greater than 50% probability,  whatever probability I decide I need, that I will successfully create a bridge between these two structures, like this.  That's the basic trick.  I'll skip over this. This is just sort of a trick for making the last stage more efficient.  So then we have our structures. Here are our snowflakes drawn slightly differently.  We then try and connect them up in whatever topology that we're interested in.  It's okay for some of these connections to fail, even though we've got multiple chances,  sometimes all our chances will fail.  That's all right, because we can use results like percolation to show that if we are able to have a pretty well connected 2D cluster state,  then we can actually do quantum computing with it.  And then here again is this point that when we come to clean the structure up,  get to the cluster state that we really want,  we are going to have paths that are only logarithmically long in the size of the snowflake.  All right, so now let me show you what kind of performance we see.  The first point here is that we see that it doesn't really make much difference if we have recycling.  Recycling is the process of not chucking things away when we get our first failure.  So in fact, we won't recycle, we will just bin things.  Let me skip through this and show you this.  This is quite interesting. I won't take too long on it.  Basically, in order for our machine to operate efficiently and keep all its errors bounded as a logarithmic function of essentially one over the success rate,  so logarithmically related to the probability, our fundamental probability that we can successfully make entanglement,  in order to achieve that we need a big machine because we need to be making lots of these snowflakes at the same time  so that we're never waiting for a partner to emerge for a snowflake of a given size.  We're always straightforward and as soon as we have a guy of a certain size, in the very next step we'll try and partner him up.  In order to do that, we need our computer to be of a particular size.  So we had a rather interesting relationship between the probability of successfully making entanglement,  that's presumably a very low level experimental parameter, and the size of the machine that this whole idea works for.  So the lower the success rate, the bigger the machine needs to be. I can say a bit more about that if people are interested.  Sorry? Oh, three minutes. Let me just get to the point which is, I think, going to be of most interest to you guys.  So all of that, this idea of making snowflakes and joining snowflakes up and so forth,  is basically a route to showing that I can create a useful structure with only logarithmic number of errors.  But what I haven't obtained for you yet is any kind of threshold to see whether this is going to be a useful approach,  how horrible things will be. So let's get a threshold now.  Instead of having a target object which is a simple cluster state,  let's try and get one of these topologically protected states, one of these Roussendorff-style states instead.  In principle, that seems pretty straightforward. After all, it's a similar sort of challenge of connecting each building block object to four other objects.  But the trick here that allowed us to complete the analysis was that we had this percolation result. Let me just skip through.  So here we know that if we have a certain number of missing edges in our two-dimensional cluster state,  then we nevertheless have a resource that's good for quantum computing.  We need a result that's equivalent here if we're going to use all the ideas that I've developed so far in order to obtain an actual threshold-based result.  So what can we do? We need to be able to say how many missing edges we can tolerate within a structure like that.  Now, that result was just obtained last year by Sean and Tom, who are both in the audience here.  Or rather, they were able to obtain the result. And you heard, if you are around, I think, yesterday, you heard Sean talk about this.  You have a result that says, if you have a certain... Excuse me, I'm going the wrong way. That's unfortunate.  So the result was that if you remove certain nodes from certain qubits from the structure, then it will still operate.  You can remove up to 25% of them and it will still operate.  What I require is missing edges, but that, in fact, is straightforward because what we need to do...  Let's see if I can actually go backwards.  What we need to do is identify a missing edge. Remember, these are known. I know where these edges are missing.  And I will basically delete both the qubits from either end of this missing edge in order to then translate it into a question of missing qubits.  So this is the equivalent of the percolation result from my purposes, which will allow me to then get a threshold.  How will I do that? I will take, again, my snowflake concept, build these snowflakes, identify each one with a node of the target structure,  and then try in parallel to connect them up, as shown here.  And I know that some of those will fail, but as long as the rate of failure is below the essentially the translated 25% rate,  then the eventual entity will still offer me fault tolerance.  So I can simply inherit the results that those previous authors worked out in order to do some numerics and generate for you a threshold.  So this is essentially the key figure for the talks, and let me tell you what it means.  Here we have the rate at which I fail when I attempt an entanglement.  So this is I always fail. This, of course, is a fairly trivial case with only 25% failures.  This is setting all the kind of low-level errors in the device equal to one another, the single qubit errors, the two qubit errors, the measurements.  Setting those equal to each other and calling them PG, this is what we then obtain.  So here's using the snowflake, which as you can see is very superior to using the star or the cross because of this logarithmically beneficial path length that it has.  And what we do here is we see that we can operate out to sort of 90%, even perhaps 95% failure rates, and in that regime the kind of actual error rates we can tolerate are 2 or 3 times 10 to the minus 4.  Not a great number, but also not an insane number considering that we are tolerating an enormously high failure rate.  So I need to mention to you that it doesn't make much difference if you put in reasonable memory errors, that those things are becoming corrupt all the time.  That also doesn't spoil the situation for you.  And finally, resources, of course, very important.  The real problem that stops you getting to sort of the very high 90s is that the resource overhead explodes.  So I think that if you're looking here in the sort of 80% regime, you can see that your overhead is like 100 qubits.  That's a lot, but perhaps in solid state type scenarios where your qubits are not too expensive, that isn't completely crazy.  So this, as far as we're aware, was the first result that basically related failure rate to actual error rate and obtained a threshold for this style.  Now at the same time, I should mention really that these authors, who are also present at the conference, obtained almost exactly the same threshold by exactly the same techniques.  We weren't aware that they were working on this.  It's one of these strange situations where two papers emerged almost simultaneously.  Okay, and I'm going to stop there because I can also tell you about communication thresholds.  Actually, I'm going to just leave it on that slide.  So you can also obtain, of course, higher numbers, 15% if you use the same tricks for...  Okay, thank you.  Time for maybe one or two questions.  I'm trying to put together some of your numbers.  So you've got overheads at about 80% or 90% of 10 to the 3, 10 to the 4.  So this is for the general quantum computing rather than the communication, which I just mentioned.  Yes, general quantum computing.  I have to go back to this.  Is this the one that you would like to see, or...?  Yes, and then earlier on there was one way you were saying these types of codes would work at 80 or 90% for something like a computer of size 10 to the 11 qubits.  I'm wondering what the size of the eventual, well, the number of qubits in the eventual lattice that you've got.  Yeah, okay.  So the trick is that when you're building these...  Let me go all the way back if I can...  Back, back, back, back, back, back...  To show you how we're building these snowflakes.  Can I hold it?  Oh, yeah, I can.  Okay.  That's the one I want.  So what we see here is how we're actually going to build these structures.  It's very important if we're going to crack down on errors  that we shouldn't let anything sneakily become non-logarithmic  because the basic result, the nice result,  is that all the errors are bounded by a logarithmic function  of our failure probability.  In order to stop memory errors from becoming a problem,  I need this, basically, the situation that's shown in this schematic  mustn't be allowed to happen.  What I've got here, as you can see, as it happens,  is one of these guys, and he has no partner with which to try and become entangled.  So he will now have to wait until another partner emerges  in order to try and create the next generation of object.  If I allow that to happen, then I will spoil my logarithmic scaling.  Therefore, my overall computer size must be such  that I have a large number of snowflakes of every size,  including the final size, emerging all the time.  And that's where you saw that large number from.  Basically, the larger my computer, the more snowflakes I'm going to need  because I'm trying to create this large, either 2D cluster state  or other geometry in order to do my computation.  So provided that I'm attempt, it's perverse,  provided I'm attempting a large enough scale computation,  then I can know that I will actually have plenty of snowflakes  of a given size as a function of the failure probability.  We can talk about that a bit more at the end, if you like.  But it's a rather strange relationship between how bad your hardware is  and basically how large a computation you attempt to undertake.  Let's thank Simon again.  So we're approximately 10 minutes behind.  I'll leave that to Daniel.  20 minute break. Your back's 11.
Long_range_0_275.png Long_range_276_395.png Long_range_396_443.png Long_range_444_755.png Long_range_756_911.png Long_range_912_1163.png Long_range_1164_1295.png Long_range_1296_1343.png Long_range_1344_1439.png Long_range_1440_3671.png Long_range_3672_3755.png Long_range_3756_9311.png Long_range_9312_31487.png Long_range_31488_31607.png Long_range_31608_31727.png Long_range_31728_32063.png Long_range_32064_32111.png Long_range_32112_32387.png Long_range_32388_32795.png Long_range_32796_32927.png Long_range_32928_33059.png Long_range_33060_33131.png Long_range_33132_35339.png Long_range_35340_35963.png Long_range_35964_36095.png Long_range_36096_36167.png Long_range_36168_36251.png Long_range_36252_36561.png
about long range entanglement distribution. Hello, hello, hello. Good, that's working. Up a bit. All right. Okay, cool. Yeah. So just winning it back and forth. Okay. So thank you very much to, thank you very much to the organizers for letting me contribute this talk. It's a little bit different from what's as advertised. I will get to the stuff that's advertised in due course, but talking to people, I guess an advantage of coming at the end of the conference is I get to see what everyone else is talking about. And I also get to talk to other people and see what they'd be interested in hearing about. So I've kind of made some modifications and I'm telling the story in a little bit more detail, I guess. Okay. So the basic question that I'd like to interest you in is how are we going to do quantum computing, preferably fault tolerant quantum computing. If we have entanglement operations that are very prone to fail. Now, what I mean by fail is not generating error. I mean just outright failed and you know that it failed. So what we call a heralded failure. So our entanglement operations are very prone and when I say very prone, we'll talk about those actual probabilities, but think 70%, something like that, you know, more than 50% chance. But when you try and entangle two qubits, your apparatus will say, no, I tried, I failed, I'm sorry, it's all gone wrong. And those two qubits, in that case, you should also consider are now corrupt. So if they previously had some kind of entanglement invested in them with partners, that's all been lost and spoiled. So if that's your model, you've, of course, on top of that, you've also got the usual kind of errors, single qubit errors, measurement errors, which you don't know about and presumably are at a much lower rate than 70%. We've got no hope. But the, you know, the new factor, I mean, many people have thought about this, of course, but the factor that is perhaps not usually considered is that we have a very high known failure rate. And so let's see, let's go on. Yeah, so I always find it helpful to have some kind of physical example in mind when I'm thinking about these things. This is by no means the only kind of scenario that would give rise to this picture. So what I'm thinking of here is you've got some kind of physical system, let's call it an atom. It's sitting in a cavity. So there on the right, we see a cute little sort of cavity image there. And light can come out of our physical structure perhaps due to some conditional transition in the level structure that it has. So obviously it will have a complex level structure, but it may contain something like this L structure that would be convenient. So we have some low-lying levels that are qubit and we have some optically excited state that can only be reached from state one. And so we can interrogate our qubit and ask it what state it's in by shining on light that would excite it to the optically excited state if it is in state one and then watch to see if the photon comes out. We can even repeat that. That's how we might measure it. So that structure then, an atom in a box, is like a module of our hardware. That's basically the unit of our quantum computer. And how are we going to entangle different modules with each other? Well, I'm sure pretty much everyone in the room is familiar with these kind of path erasure type tricks that we could use to do measurements, joint measurements on two such modules simultaneously in order to entangle them. And in fact, the most common kind of operation you end up with, if you do that kind of thing, is you end up with a parity projection on your qubits. And that's what I'm going to be assuming later on. But just generally, that is one example of why we might be thinking this, because if we lose foaming that process, the entanglement operation will go wrong. And we should know that that's happened because we'll fail to see photons in our measuring device. So then the kind of architecture that we might end up with is something like this. Very, very schematically, of course, you have a bunch of modules, which you could just plug more in if you wanted to. Each module contains one atom, or one qubit. You have some kind of switching device that allows you to choose which two guys to entangle with one another. And in fact, I'm going to assume parallelism so that I assume that because it's optical, light passes through light, and so I can try and entangle one of these guys with another while simultaneously attempting a different pairing. And in fact, I can pair everybody up and have a go at entangling them. This is the kind of picture we're talking about. What we have there in the inset is just, I don't know which of the particular, I think this might have been a device that was made by Bell Labs or something. It's a tiny little mirror that's sort of reorientatable, and that's the kind of thing that you might use to have this whole switching device. Obviously, you want the light to pass through this device without being measured. Okay. So just very briefly, if we did have, for this talk, I'm not going to assume this, but if we did have more structure within each module, like two qubits within each module, then it would be at least fairly easy to see how we might do quantum computing. Even though the entanglement operation is very likely to fail, the kind of thing we might do is we'd nominate one guy within each location to be in charge of getting entangled with other people, and another guy in each location to be not involved in that process. So then we would get it, so here the green guys, the brokers, the chaps who get entangled, you entangle that eventually after perhaps many attempts with the other module that you're shooting for. When you finally got entanglement, you can move it down, transfer it down, swap it down onto the clients, the quiet guys. So that at least, you know, who knows, we might come back to what the error rates and things structure, but at least you can see that that approach would work in principle. But we haven't got that, we've only got one qubit in each location. So I'm going to probably skip through this, even though it's a pretty diagram, because I realized that I started a little bit late, and let me go on to talk about the scenario I'm interested in is when the probability of successfully creating entanglement is significantly less than 50%. So the failure rate is higher than a half. How high might it be in reality? Unfortunately at the moment in experiments that have been achieved, the failure rate is enormous. This is kind of one of the earliest papers that got me excited. This was a paper by Chris Munn-Rosegroop, this 2007 paper, there because they need to see two photons in order to have their entanglement operation held it as a success, what they have to do is look at the success rate for retaining a single photon through the apparatus and square it in order to see two, and they end up with something like excesses per billion attempts. So that's obviously an appalling success rate, and it will be impossible to do QIP with such rates, but it does at least show us that we shouldn't be thinking for the foreseeable future that we're going to have lovely high success rates like 80%. We need to sort of look into the area of low success rates and see how things might work. NV centers, another very interesting approach, have similar problems which I won't go into if anything worse. So, alright, let's imagine we've got something like a 90% failure rate. How are we going to even approach the problem of quantum computing in a way that the errors, the genuine unheralded errors don't build up horrifically? So the kind of thing we might do is this. Let's say I want to make an entangled state of many of my qubits that's a useful state such as a two-dimensional cluster state like that. Then I'm going to make it by having building blocks, which I will obtain work through brute force if necessary. I'm going to build building block structures, each of which contains a great many qubits in, I'm sorry, when I put up these diagrams, this is a graph state notation, as I imagine pretty much everyone has assumed, if I have a blob then that's a line, that's a phase gate between those two qubits. So the kind of thing I might do is make these building block structures which have a huge number of qubits in them, and then arrange them so that there's one such blob for each eventual qubit that I want to have in my cluster state. And then I will try and fuse them up. And the way that I'll fuse them up is that I will, let's see if I can, no, that's not working for me really. What would that do? It's also not working. I can't really see anything. So if we look at these four guys, which are the highlighted block of four from the center there, what we can see is that we have many, as it were, dangling bonds on the end of our graph structures here. We can attempt to, each one of those leaves with a partner leaf in the next structure along. We can attempt that in parallel, and we have so many leaves that even though we have a high failure rate, we can then expect that we will probably succeed and make at least one bridge between these two structures. Okay, so that's the kind of approach we might take. Oh, okay, I see. Thank you. Okay, so the first question to ask would be what kind of building block structure should we employ? Various ones have been looked at in the literature by, well, for example, I think Nielsen looked at the star, Jens Eissert looked at a linear structure, Robert Rausendorf used these cross shapes. What I'm going to advocate is these binary tree structures, which we refer to in our paper as snowflakes, just because we like to draw and sort of picture them that way. And in a minute, I think I'll just be able to show you why the snowflake is actually the most natural and sensible building block object to use. Okay, snowflake. First off, how do we make them? If we do a parity projection on two qubits, let me try out that, yep, if we do a parity projection on two qubits, then up to local operations we get this graph state. If we then try and connect two of those guys, we get this three-pointed star. If we connect two stars, we start to get this tree. If we connect the core node of two trees, we get a larger tree. So they grow very efficiently. That's the first nice property of these star structures, these snowflakes. What's really important is that they give us a very large number of dangling bonds, these dangling bonds are going to be used for fusing up snowflakes with one another. They give us the largest possible number of these, considering the path length through the structure. So in a minute, we'll see that if we were able to successfully connect this particular qubit to another snowflake and this particular qubit to another snowflake, we would then want to just prune out all this extra structure. Because it's a binary tree, it means that a lot of the structure errors in this patch here, errors in this patch here and in this patch here, will not find their way onto the path that we're actually keeping. And the path itself is only of logarithmic length. So that's going to be very important in getting sensible performance for our structure at the end of the process. So let's remember this is very generally the kind of machine we might imagine. The other things that I will need from it, from my analysis, are that it should be able to do operations in parallel and that's the, let's say, that I'm arbitrarily allowed to connect any qubit with any other. That's going to be more than I need, but let's imagine that. Okay, so the kind of thing that will go on inside my machine is this. In a particular time step, S, I will have a whole bunch of qubits which are not entangled with any others, a whole bunch of qubits that are in pairs, a whole bunch of qubits that are in groups of four, and so on. What I will do is I will schedule, at time step S, I will schedule to pair up every one of the unentangled guys. I will schedule to pair up every one of the guys of size two to pair up and so forth. And I will then attempt all those operations in parallel in one time step. I will get some successes which will allow me to promote entities up one rank. And I will get, of course, some failures, more commonly failures than successes. I will take the very aggressive strategy that if I fail, even if I've managed to make a lovely, quite big thing like this, which has got a lot of investment in it in a sense, I then try and entangle this with this. If I fail, I've actually still got quite a lot of entangled structure there. But what I'm going to do is nevertheless bin it. I'll just break the whole thing down, reset all the qubits, and dump them back into stage zero. And the reason I'm going to do that is to crack down as aggressively as I can on the rate that errors build up. And I'll be able to show you what difference it makes if we don't do that presently. So we have this painful process of promoting ourselves to a larger and larger snowflake. But what I'm going to assume is that eventually we can get to snowflakes sufficiently large. Then if I try and pair two of these snowflakes up and connect, say this guy to this guy, while simultaneously trying to connect this guy to this guy, this guy to this guy, for the particular failure rate that I have, I will expect a greater than 50% probability, whatever probability I decide I need, that I will successfully create a bridge between these two structures, like this. That's the basic trick. I'll skip over this. This is just sort of a trick for making the last stage more efficient. So then we have our structures. Here are our snowflakes drawn slightly differently. We then try and connect them up in whatever topology that we're interested in. It's okay for some of these connections to fail, even though we've got multiple chances, sometimes all our chances will fail. That's all right, because we can use results like percolation to show that if we are able to have a pretty well connected 2D cluster state, then we can actually do quantum computing with it. And then here again is this point that when we come to clean the structure up, get to the cluster state that we really want, we are going to have paths that are only logarithmically long in the size of the snowflake. All right, so now let me show you what kind of performance we see. The first point here is that we see that it doesn't really make much difference if we have recycling. Recycling is the process of not chucking things away when we get our first failure. So in fact, we won't recycle, we will just bin things. Let me skip through this and show you this. This is quite interesting. I won't take too long on it. Basically, in order for our machine to operate efficiently and keep all its errors bounded as a logarithmic function of essentially one over the success rate, so logarithmically related to the probability, our fundamental probability that we can successfully make entanglement, in order to achieve that we need a big machine because we need to be making lots of these snowflakes at the same time so that we're never waiting for a partner to emerge for a snowflake of a given size. We're always straightforward and as soon as we have a guy of a certain size, in the very next step we'll try and partner him up. In order to do that, we need our computer to be of a particular size. So we had a rather interesting relationship between the probability of successfully making entanglement, that's presumably a very low level experimental parameter, and the size of the machine that this whole idea works for. So the lower the success rate, the bigger the machine needs to be. I can say a bit more about that if people are interested. Sorry? Oh, three minutes. Let me just get to the point which is, I think, going to be of most interest to you guys. So all of that, this idea of making snowflakes and joining snowflakes up and so forth, is basically a route to showing that I can create a useful structure with only logarithmic number of errors. But what I haven't obtained for you yet is any kind of threshold to see whether this is going to be a useful approach, how horrible things will be. So let's get a threshold now. Instead of having a target object which is a simple cluster state, let's try and get one of these topologically protected states, one of these Roussendorff-style states instead. In principle, that seems pretty straightforward. After all, it's a similar sort of challenge of connecting each building block object to four other objects. But the trick here that allowed us to complete the analysis was that we had this percolation result. Let me just skip through. So here we know that if we have a certain number of missing edges in our two-dimensional cluster state, then we nevertheless have a resource that's good for quantum computing. We need a result that's equivalent here if we're going to use all the ideas that I've developed so far in order to obtain an actual threshold-based result. So what can we do? We need to be able to say how many missing edges we can tolerate within a structure like that. Now, that result was just obtained last year by Sean and Tom, who are both in the audience here. Or rather, they were able to obtain the result. And you heard, if you are around, I think, yesterday, you heard Sean talk about this. You have a result that says, if you have a certain... Excuse me, I'm going the wrong way. That's unfortunate. So the result was that if you remove certain nodes from certain qubits from the structure, then it will still operate. You can remove up to 25% of them and it will still operate. What I require is missing edges, but that, in fact, is straightforward because what we need to do... Let's see if I can actually go backwards. What we need to do is identify a missing edge. Remember, these are known. I know where these edges are missing. And I will basically delete both the qubits from either end of this missing edge in order to then translate it into a question of missing qubits. So this is the equivalent of the percolation result from my purposes, which will allow me to then get a threshold. How will I do that? I will take, again, my snowflake concept, build these snowflakes, identify each one with a node of the target structure, and then try in parallel to connect them up, as shown here. And I know that some of those will fail, but as long as the rate of failure is below the essentially the translated 25% rate, then the eventual entity will still offer me fault tolerance. So I can simply inherit the results that those previous authors worked out in order to do some numerics and generate for you a threshold. So this is essentially the key figure for the talks, and let me tell you what it means. Here we have the rate at which I fail when I attempt an entanglement. So this is I always fail. This, of course, is a fairly trivial case with only 25% failures. This is setting all the kind of low-level errors in the device equal to one another, the single qubit errors, the two qubit errors, the measurements. Setting those equal to each other and calling them PG, this is what we then obtain. So here's using the snowflake, which as you can see is very superior to using the star or the cross because of this logarithmically beneficial path length that it has. And what we do here is we see that we can operate out to sort of 90%, even perhaps 95% failure rates, and in that regime the kind of actual error rates we can tolerate are 2 or 3 times 10 to the minus 4. Not a great number, but also not an insane number considering that we are tolerating an enormously high failure rate. So I need to mention to you that it doesn't make much difference if you put in reasonable memory errors, that those things are becoming corrupt all the time. That also doesn't spoil the situation for you. And finally, resources, of course, very important. The real problem that stops you getting to sort of the very high 90s is that the resource overhead explodes. So I think that if you're looking here in the sort of 80% regime, you can see that your overhead is like 100 qubits. That's a lot, but perhaps in solid state type scenarios where your qubits are not too expensive, that isn't completely crazy. So this, as far as we're aware, was the first result that basically related failure rate to actual error rate and obtained a threshold for this style. Now at the same time, I should mention really that these authors, who are also present at the conference, obtained almost exactly the same threshold by exactly the same techniques. We weren't aware that they were working on this. It's one of these strange situations where two papers emerged almost simultaneously. Okay, and I'm going to stop there because I can also tell you about communication thresholds. Actually, I'm going to just leave it on that slide. So you can also obtain, of course, higher numbers, 15% if you use the same tricks for... Okay, thank you. Time for maybe one or two questions. I'm trying to put together some of your numbers. So you've got overheads at about 80% or 90% of 10 to the 3, 10 to the 4. So this is for the general quantum computing rather than the communication, which I just mentioned. Yes, general quantum computing. I have to go back to this. Is this the one that you would like to see, or...? Yes, and then earlier on there was one way you were saying these types of codes would work at 80 or 90% for something like a computer of size 10 to the 11 qubits. I'm wondering what the size of the eventual, well, the number of qubits in the eventual lattice that you've got. Yeah, okay. So the trick is that when you're building these... Let me go all the way back if I can... Back, back, back, back, back, back... To show you how we're building these snowflakes. Can I hold it? Oh, yeah, I can. Okay. That's the one I want. So what we see here is how we're actually going to build these structures. It's very important if we're going to crack down on errors that we shouldn't let anything sneakily become non-logarithmic because the basic result, the nice result, is that all the errors are bounded by a logarithmic function of our failure probability. In order to stop memory errors from becoming a problem, I need this, basically, the situation that's shown in this schematic mustn't be allowed to happen. What I've got here, as you can see, as it happens, is one of these guys, and he has no partner with which to try and become entangled. So he will now have to wait until another partner emerges in order to try and create the next generation of object. If I allow that to happen, then I will spoil my logarithmic scaling. Therefore, my overall computer size must be such that I have a large number of snowflakes of every size, including the final size, emerging all the time. And that's where you saw that large number from. Basically, the larger my computer, the more snowflakes I'm going to need because I'm trying to create this large, either 2D cluster state or other geometry in order to do my computation. So provided that I'm attempt, it's perverse, provided I'm attempting a large enough scale computation, then I can know that I will actually have plenty of snowflakes of a given size as a function of the failure probability. We can talk about that a bit more at the end, if you like. But it's a rather strange relationship between how bad your hardware is and basically how large a computation you attempt to undertake. Let's thank Simon again. So we're approximately 10 minutes behind. I'll leave that to Daniel. 20 minute break. Your back's 11.
about long range entanglement distribution. computing. If we have entanglement operations what we call a heralded failure. So our have a very high known failure rate. And so let's unheralded errors don't build up horrifically? So gate between those two qubits. So the kind of That's the first nice property of these star aggressive strategy that if I fail, even if I've as I can on the rate that errors build up. And missing edges we can tolerate within a structure of this missing edge in order to then translate purposes, which will allow me to then get a error rate and obtained a threshold for this the nice result, is that all the errors are