fellow USC alumnus. He's going to talk about fault-tolerant quantum computation via adiabatic holonomies. Please thank him in advance. Thank you, Kaveh. It's really a pleasure to be back at USC. About four years ago, I talked here

about a preliminary version of some of this work. But since then, our understanding has evolved significantly. And there have been some new results. And this is what I'm going to talk about today. So here is an outline of my talk. I will give you a brief introduction

about geometric phases and holonomic quantum computation. And then I will describe a slight expansion of the original model for holonomic quantum computation, which performs computation in subsystems as opposed to a subspace, which would be helpful for understanding

how it is possible to combine these geometric ideas with the methods for fault-tolerant computation on stabilizer codes. And then I will describe two approaches to fault-tolerant holonomic quantum computation. One of them is the original that we proposed. It works on a stabilizer code, as you know it.

It uses no extra qubits, but requires Hamiltonians that depends on the codes that you use. And the other one uses extra gauge qubits, but it uses Hamiltonians which are independent of the code and also allows for reducing the locality of the Hamiltonian to two using a weak guardians.

I will discuss some potential advantages or disadvantages of this approach and also some related schemes. And then I will conclude with a few remarks. So holonomic quantum computation is based on geometric phases. Geometric phase is a phenomenon that occurs under parallel transport in a curved space.

For instance, consider a sphere and a vector which lives in the tangent plane at the given point. And if it is parallel transport, which means in a way that it remains parallel to itself during the transport along the dotted curve,

it is going to follow this evolution such that when you bring it back to the initial point, it's going to be rotated by some angle phi, which is a holonomy. And this idea is not restricted to transport of vectors on a tangent space, but you can imagine any curve,

any manifold with where at each point you have an associated vector space or an even more general space. And the parallel transport is some rule which tells you how to transport the information in this space as you move along the manifold. It is described by a gauge potential. And this idea is actually ubiquitous in physics

where the fundamental interactions are described by gauge fields. Interestingly, it is the same idea that appears in adiabatic dynamics on which the holonomic approach to quantum computation is based. The holonomy that you acquire in this or in other cases

is actually proportional to the flux of the curvature through the area that you enclose. So to review the adiabatic theorem, here I'm going to use a version which is non-controversial. It works for degenerates, eigenspaces of the Hamiltonian and is due to Kato back in the 1950s.

So basically consider a time-dependent Hamiltonian which changes along a curve of Hamiltonians which is parameterized by a parameter s from 0 to 1. But the dependence of time is given by that. So s is actually the current time

divided by the total time of evolution. And let's assume that this family of Hamiltonians has a dependent eigenspace which is separated from the rest of the spectrum by a gap. And assume that the projection on this eigenspace is twice differentiable. Then the statement is that if we slow down the evolution, if we slow down the change of the Hamiltonian

along the curve in the limit when the slowdown goes to infinity, the evolution generated by this Hamiltonian will be such that any state that begins in the eigenspace is going to remain in the eigenspace during the evolution for all time. But furthermore, this theorem also

tells us how the eigenspace is going to change within the eigenspace. And in order to express this, we need to introduce an s-dependent basis for the subspace. And considering an initial state psi of 0, it is going to evolve. Its transformation will be described

by the following expression, where you have a geometric phase, which is simply the integral of the energy. And there is this geometric quantity, which is a continuous sequence of projectors along the subspace, along this curve. And the transformation that it corresponds to

can be described in this form. These are J of 0 is the basis frame in the initial space, and J of s is the basis frame at time s. And this Uij is actually a unitary transformation given by the following expression. It's a path-ordered exponent of a quantity, which

is given by this expression. This is actually the Weil-Jekz connection, which describes how, in a most parallel fashion, the states that are in the subspace are going to evolve along the curve. But this unitary, actually, as you can see,

depends on the choice of basis. So in our case, the choice of basis is a gauge freedom, which is not physical. But if there is a method to, if there is some natural rule that fixes the final frame, we actually can get rid of this gauge freedom and obtain a gauge invariant quantity. And this is the case when we take the subspace along a loop

such that it comes back to itself. The requirement that the basis at the final time is identical with the one that we started from removes the gauge freedom, and we obtain this gauge invariant quantity called the holonomy associated with the path that we take the space in. So in this picture, I'm considering

a path in what is called the Grassmannian. The Grassmannian is the space of all subspaces of a given dimension. So on what paths of the Grassmannian we can take a given subspace depends on the Hamiltonians that we can engineer, of course. But it was shown by Zanardi and Rossetti

that, in the generic case, given some reasonable assumptions about your control abilities, we can actually obtain holonomies in a given subspace, which can generate the entire unitary group. And they propose this as a method for quantum computation, which is what holonomic quantum computation is.

And this idea, besides being very fascinating from a conceptual point of view, has attracted significant attention due to the robustness that it promises. So on one hand, this is adiabatic dynamics, which gives you some robustness against timing errors.

So as long as you're in the adiabatic limit, and for instance, you're interpolating between some Hamiltonians, it doesn't matter precisely at what time you'll be able to switch on your interaction and or turn it off. As long as you're in the adiabatic limit for satisfactory precision, you can take your time and traverse the loop with timing that you like.

And also, of course, since this is adiabatic, the idea is that the Hamiltonian itself, the gap can protect you from some kind of errors. In addition, the geometric nature of the gates supplies you with some additional robustness

against those classes of errors which change the path in such a way that it preserves the flux. Because remember that the holonomy that you generate is equal to the flux of the curvature area that you enclose. But these statements should be taken with care,

because there are also various errors against which this approach would not be robust. For instance, the splitting of the ground space is going to result in very bad errors. And especially since you are doing this evolution slowly, splitting is going to cause transformation in your code space, which is going to accumulate

and can be detrimental to your computation. So even if robust, even if we are able to engineer very well such a system, I mean, every system interacts with the environment, so we need to find ways to combat errors if we would like to use this approach to quantum computation

as a really reliable approach. And one possible solution has been considered by Zunard and Lidar, which is to encode in a decoherence-free subspace. And they have shown that for some natural system, it is possible to do holonomic computation in a decoherence-free subspace. But of course, this requires certain symmetries.

And no symmetry is ideal. So inevitably, there will be errors due to interaction with the environment. And similarly, there are errors due to control imperfections. In addition, I mean, scalability of any method requires the ability to do it fault-tolerantly.

So it is also desirable that we should somehow be able to, if we conceive this method as a universal method for computation, to combine it somehow with fault-tolerant methods for computation. And all this is telling us that we need to somehow unify this approach with active error correction. And one attractive prospect is that assuming

that the holonomic approach provides us indeed with some control robustness, this control robustness could aid the protection provided by quantum error correction.

So in order to understand how this works, I would like to introduce a slight modification of what was already introduced as an approach to holonomic computation, which is in a subspace. So the idea is to develop it so that it can capture the most general form of encoding, which is a faithful encoding, which is encoding in subsystems. This is known as the so-called subsystem principle.

And this is particularly relevant in the context of information protection. A subsystem is a tensor factor of a subspace, such as, for instance, H with subscript i and superscript a in this decomposition.

So here in this decomposition, we have a sum of different orthogonal subspaces labeled by i. And each of them factors into two. And the two factors are a and b. The reason why I'm showing this particular decomposition is that it is known to be associated with the structure of preserved information on the open quantum systems, as shown by these people.

In fact, this can be viewed as a hybrid quantum classical code, where the protected quantum information resides in the subsystem a. And the classical information is associated with the different subspaces in which we have

such subsystem codes. Here is one example that we should all be familiar with, a standard quantum error correcting code. Let's assume there is a code which explores the full Hubert space. The statement that the information, if it has remained protected, can be found in a subsystem,

actually, corresponds to the fact, in this case, that there is a decomposition of the full Hubert space of the following form, where the logical information, even if a netable error has occurred, can be retrieved. It is contained in this factor. And this other co-factor contains the error syndromes

and possibly gauge degrees of freedom. The code space itself, the one in which we prepare our information, is HA tensor to the span of some fixed vector, which we write as 0 here. This corresponds to the error syndromes

being initialized to 0, meaning that we're in the original code space. Actually, from this point of view, error correction can be seen like this. We prepare the logical information in the subsystem A. And keep in mind that this is a virtual subsystem, meaning

that the observables that describe it are actually non-local. And the syndromes are in the state 0. And when a correctable error occurs, what it does is that it simply excites the cosine. It sends it to some generally mixed state in HB. And then the correction is simply

to reinitialize that state. This concerns correctable errors. Now, it is desirable now to develop a formulation, as I said, more general formulation of holonomic computation, which is compatible with this general notion of encoding, which

is encoding in subsystems. And this can be captured in the following theorem. So consider any decomposition of the Hilbert space of that form, where we'll be interested in the information contained in the subsystems HAI. The statement is that if we choose a starting Hamiltonian of this form,

basically it acts trivially on the subsystems that contain the logical information, and non-trivially on the cosine subsystem. And here, for different I's, there's a difference of space. We require donions have different spectrum. The statement is that if we start with this Hamiltonian and change it adiabatically, so that there

are no crossings of energy levels, given sufficient control abilities, it is possible to take these subsystems around loops in such a way that we are going to generate a unitary, where the transformation of this form, where the transformations in the logical subsystems

are purely geometric, and any set that we desire. And all unwanted dynamical phases can be absorbed in the cosub systems, B, labeled by D. And one interesting consequence of this statement is that when you have the situation where the Hilbert

space factors into two, we can actually implement an arbitrarily purely geometric transformation on the subsystem A without having to initialize the system in any subspace. You might, specifically, if you're given a system, you can append to it some qubit in an unknown state.

You just turn on a Hamiltonian which acts non-trivially on that qubit, on that gauge qubit. You adiabatically change it in such a way that you end up, again, with a Hamiltonian acting on that qubit. And you leave your original system with a purely geometric transformation.

The way this is done, I am not showing the proof here, but it is based on the idea that you perform different computations in the different eigen spaces of your Hamiltonian. And you do it in such a way that the desired transformation factors out, and it remains on the subsystem A that you are interested in.

And this approach can be useful in that it saves on initialization procedures. So in the case of when we do fault-tolerant quantum computation, and not necessarily polynomically,

even in the dynamical case, we are also moving the logical subsystem around. So I think it is useful to get the idea of how polynomial computation works, to also consider fault-tolerant quantum computation in that picture of a logical subsystem being moved around.

So consider a stabilizer code where the logical information will be contained in one subsystem A, and those syndrome-engaged degrees of freedom are here. I mean, ideally, we would like to do just correction, which means initializing the state of this subsystem B back to the code space.

And we would like to perform computation, so we would like to perform some non-trivial evolution inside HA. But the thing is that for this quantum error correction works because the logical observables are highly non-local. So this means that you would need to have a highly non-local Hamiltonian to achieve this.

But in reality, we have to implement computation as a sequence of using local Hamiltonian. This means that inevitably, you have to take the information outside of this code. And during the evolution, you are

going to have a time-dependent decomposition of this type, which is related to the initial one by some unitary. And this unitary is generated by the local interactions that you are applying. But the question is, can this be done in a way that keeps the information protected? Because this code might correct errors. But during the evolution, it might

be that this subsystem gets exposed to errors for which the code was not designed. And fault-tolerant computation tells you exactly how to do it. So already, a lot was said about fault-tolerant computations. I'm not going to go into details. But just to refresh, we say that a quantum error correcting

circuit is fault-tolerant if an error occurring during its implementation renders the result correctable. And if we're able to do this, there is the powerful threshold theorem, which tells us that if the error is below some threshold for information carrier per gate, then we could achieve an arbitrary long computation

with polylogarithmic overhead. So that has been a lot of literature on how to do that. I'm going here to reduce simply the building blocks for dynamical fault-tolerant schemes. And I'm referring specifically to the formalism

for the theory developed by Garzman, which applies for an arbitrary stabilizer code. And since these basic operations will be needed in our construction. And so you do this by being able to perform transversal unitary operations, which

includes a single qubit unitary, transversal C0, maybe transversal Toffoli. And in addition, we require preparation and use of a cat state of this type, which requires the ability to somehow create it, verify that it is well-prepared. And also, we need the ability

to do transversal C0 gates from the logical states to the cat state. In addition, of course, like any method of computation, we require the ability to perform projective measurements in the computational basis. Actually, the fault-tolerant procedures, they are smart constructions which tell us how, in terms of these basic operations,

really to move the subsystem around so that it remains protected. So coming back to the question of fault-tolerant for the monoclonal computation, let's consider stabilizer code, which encodes one qubit into n, possibly has r-gauge qubits.

So these are the stabilizer generators, and these are the logical operators on the gauge qubits. So again, we have this decomposition. The idea is that we would like to move the subsystem along the exactly same paths that are prescribed by the standard fault-tolerant procedure such that we are going to keep it protected.

But if we would like to move the logical subsystem around in an adiabatic manner, we have to use a Hamiltonian which acts non-trivially on HB only. This should be our starting Hamiltonian. And this means that it must be a linear combination of elements of the gauge group.

And the same holds during the evolution. If we perform any evolution starting with this Hamiltonian, the corresponding time dependent decomposition during the evolution will be such that the Hamiltonian expressed with respect to it will have that form.

And this means that it is, again, a linear combination of the elements of the transformed gauge group, because all operators of the gauge group get transformed during the evolution in the Heisenberg picture. So the thing is that operators in the gauge group couple qubits in the same block.

This is a non-trivial code, which means that transversality is impossible. I mean, we cannot just perform operations that address one qubit in a code or the corresponding qubits for two different code words. So fortunately, there is a way around this.

Actually, transversal operations are not the most general ones that do not cause errors to propagate, but a transversal unitary followed by formation, which is generated by a Hamiltonian from the gauge group, is also fault tolerant. So it is exactly through this kind of transformations that we are going to drag the subsystem code around

in order to generate encoded gates inside it. So here is the main idea in very abstract terms, but this is what I want to convey to you. This is the main idea of this approach. Basically, we are going to idea about how we drag the logical subsystem along some sequence of paths

in such a way that during each segment, so this path is divided by segments, and during each segment, the transformations in the full Hilbert space that we generate, including dynamical and geometric parts, are of the type that I just outlined. They are transversal unitaries followed

by a gauge transformation. Now, we're going to follow exactly the prescription of some dynamical fault tolerance unit. If we complete a sequence of these transformations, at the end of the day, we're going to get the desired encoded operation followed by a gauge transformation. And by construction, when we complete such an operation,

we have taken our logical subsystem around such a loop that we have exactly a tentaholonomy in it, which is the desired encoded gate. So the first two by construction will imply fault tolerance,

whereas the third of these conditions ensures that the computation we perform is purely geometric. So how do we do it? The way we do it is based on one observation. So we're going to use Hamiltonians.

For simplicity, we're actually going to use, at each time, only one element analyzer or the gauge group. So without loss of generality, we can choose a Hamiltonian of that type if we would like to follow this step in a fault-tolerant procedure, which implements a gate on, say,

the first qubit in a code work. So we choose a Hamiltonian of that type. And if we vary it adiabatically in such a way that only the factor on the first qubit changes, then the result on unitary is of that type up to a gauge transformation. And all the dynamical effects are

contained in the gauge transformation. So you see that in this way, we can actually implement a single qubit gate in the code. And in a similar way, so let me give you an example. For instance, let's say that we want to implement an X

gate on the first qubit. This G tilde, I forgot to say, is just the rest of the description of this Hamiltonian. Since it's an element of the gauge group, this thing corresponds, belongs to the Pauli group. So it is some tensor product of Pauli matrices.

But you can think, for instance, for some nice code, such as the bacon short code, you can think that this is just another Z on a nearest neighbor qubit. So you can think of this as just yet another Z on the qubit. So here is the example. For a single qubit gate X, what we do

is we start with this Hamiltonian. We gradually turn it off and turn on another Hamiltonian of that type. And then we go to the initial Hamiltonian with a minus sign. So in a similar way, we can actually mimic all the necessary operations

which are building blocks for a fault-tolerant scheme. So given the three conditions that I showed, being able to do this, as well as the preparation and verification of the ket state, we are able to, in purely geometric terms, to perform fault-tolerant quantum computation. But now there are some characteristics of this scheme.

And the first one is that the threshold, which is defined as an error per qubit per gate, is the same as that for a dynamical scheme that we made, because we simply have the same set of operations, the same number of qubits. So the threshold would be the same

if we follow a particular fault-tolerant scheme. However, since adiabatic gates are slow, this means that the relative weight of different errors that we allow is going to change. For instance, if we compare a dynamical implementation

of a gate and a holonomic implementation, to get a failure of 10 to the minus 4, something typical for a threshold, we would need holonomic gates which are from 10 to 100 times slower than the dynamical gates. This depends on how smooth the interpolation is.

This means that you are slowing down the evolution significantly. And during this time, there are errors from your interaction with the environment. So this means that if this method is to be somehow useful, it must provide such a precision. It must help you in the control precision

much more than you lose by slowing down the evolution and exposing your information to possible errors from the environment such that you would remain within the threshold. Another feature of this approach is that it requires at least three local Hamiltonians.

But this lower bound is actually achievable with nice codes such as Dorko. And a natural question is, is it possible to do universal fault-tolerant holonomic computation in terms of two local Hamiltonians, for instance, using the perturbative techniques

to reduce the locality of the Hamiltonian? And actually, for this particular scheme, as I just described it, I think that this is not possible simply because it relies heavily on the fact that the Hamiltonians are elements of the gauge group. And when you simulate using perturbative gadgets, when you simulate a Hamiltonian, you introduce extra energy levels which split.

And this is no longer going to preserve this feature. And now this brings me to the next method that I wanted to describe, which actually allows combining, which allows using the gadgets while preserving

fault-tolerance. And this is a conceptually much simpler method. Basically, the idea is, in the previous approach, we did holonomic computation in the logical subsystem. Here, the idea is to do holonomic computation in the full system that describes the original code. To do this, we need to introduce some external system.

These are gauge qubits, so we're going to essentially enlarge the code by a little bit. And we are going to perform transversal gates like this. We are simply going to make some interaction which leaves the desired geometric transformation right there. And this scheme has the feature that the qubits

in the same block never interact by construction. And now we have to use additional qubits, which lowers the threshold because, for instance, if we implement a two-qubit gate, we'll need three qubits. But this is a relatively small drawback.

And one nice feature is that, as I explained, you don't need to initialize the gauge qubit. And the Hamiltonians are independent of the code, unlike the previous one, where you have to keep track of the stabilizer elements or the gauge group elements as they evolve.

And again, this one requires three local interactions, but it allows us to reduce the locality. So how much time do we have? OK. So the way one can do this is using so-called perturbative gadgets, which were developed by these people in a different context,

but a very useful and widely applicable tool. I'm not going to explain how they work in general, but rather I will give an example. And here I will consider the time-dependent Hamiltonian, which appears in our construction, which looks something like that.

You are interpolating between a starting Hamiltonian, which acts on qubits 1, 2, and 3. So it has this form. It acts on qubits 2 and 3. And then you're going to turn this off. This is described by this function f of t. And you are going to turn on another interaction, which

involves all the three qubits. The way you do it is that for each of these terms, here we have two terms, each of which we can consider three local, although the first one is two local. For each of these terms, we introduce three gadget qubits,

s1, this set of three for the first one, and s2 for the second term. And they are prepared in the cat state, each of them. And so what we do is that we use a Hamiltonian of the following type. It consists of a sum of ancilla Hamiltonian. These are the gadget ancillas.

And a perturbation. This perturbation is going to split the base of this Hamiltonian and create effectively the Hamiltonian that we would like to obtain. The ancilla Hamiltonian has this form. It is this z, but it is two local

and has z form on the neighboring qubits. So here I have described by a single line the pairwise interactions that appear in this construction. We label the ancilla qubits with lower indices by s and i. s corresponds to this s here, which corresponds to the term

that you're simulating, whereas i corresponds to the qubit with 1, 2, or 3. And the perturbation that you would use in this case would have a form of this type. It consists of pairwise interactions,

here described by the red lines, with x ancillas for each of these terms. And the corresponding identity y or z acting on the system qubit. And similarly for v2.

There might be, I'm not sure about the square root here. It might be a third root. But the idea is that by doing so, you effectively obtain the following Hamiltonian in the ground space. You obtain the original Hamiltonian that you would like to simulate multiplied by a factor lambda to the third, where lambda is the perturbation parameter.

It appears here. And the error that you obtain by doing so is lambda to the fourth. You can see that since these ancillas do not interact with any other qubits, any error that appears on any of the nine qubits is not going to propagate.

However, you can also see that this is highly inefficient. Just to implement the two-qubit gate, we have to introduce, we have to use nine qubits. This means that the threshold is going to be 9 divided by 2 times smaller. That's not such a big deal.

The biggest problem is actually that this perturbative approaches reduce the gap of your Hamiltonian by a significant amount, which will require a very, very significant slowdown of the evolution. So let's say that you would like to achieve precision or error delta.

So precision 1 minus delta with the original Hamiltonian. Some simple calculations show that in order to achieve this precision with the perturbative gadgets, you would need to increase the time of the evolution by this factor of the order, the original time

to the power 3 divided by the delta to the power. So if this delta is something like 10 to the minus 4, this is a huge, huge slowdown. So this rather should be regarded as a proof of principle that it is possible with two local Hamiltonians to do flow-tolerant who only computation. However, it doesn't seem very, very useful.

So I would like to also comment on a few other schemes related. A very interesting paper by Bacon and Flamia proposed a method of doing computation by a sequence of operations.

Again, dragging a subsystem, a logical subsystem, by different Hamiltonians, very similar to our type. But what is really cool about this scheme is that it achieves a gate just by a single interpolation between two Hamiltonians. The trick is that you actually leave your subsystem on another physical system, and you keep on doing this

by moving your system forward as you do the computation. This scheme also can be understood as some form of holonomic computation, but it is an open-loop holonomy, which is the basis for the construction. I mean, open-loop holonomy can be defined when you have the final space overlaps with the initial one.

So there is a natural fixing of the final frame, which comes from the requirement that it is most parallel to the initial frame. This approach is also compatible with flow-tolerant techniques and perturbative gadgets. And these guys further proposed another scheme

inspired by this and one-way quantum computing, which is one-way computing without measurements. Again, adiabatically dragging the subsystem such that we implement certain transformations inside it. Another paper that has appeared recently is a two-local Hamiltonian without gadgets. During holonomic computation, a ground state

of spin chains protected by topological order, which actually uses two local Hamiltonians without gadgets. Although, I don't know of this scheme being fault-tolerant. And I would also like to mention another approach, which is based on holonomic computation

by dissipation. In a paper with John Cozzamiglia, we have developed a theory of adiabatic Markovian dynamics, which allows you to move a subsystem around and implement holonomists in it. It is compatible with fault-tolerant approach, too. And it also is associated with a new type of geometric phase,

which generalizes the Wilczyk-Z holonomy or Ullman's holonomy for mixed states or any other holonomy for mixed states, as a matter of fact. And just to conclude, we have seen that there exists an approach to holonomic

computation, which is done in subsystems, which help us devise schemes that combine the purely geometric adiabatic approach with fault-tolerant contractions on error-correcting codes, which shows that holonomic quantum computation is, in principle, scalable. And it could also aid somehow the software protection provided by quantum error correction.

We have seen that two-qubit Hamiltonians are universal for fault-tolerant computation. But the gadgets are very inefficient. So here are a few open problems. Is it possible to find a null-perturbative and fault-tolerant realization with two-qubit Hamiltonians? What physical systems will be favorable for implementing

some of these ideas? And finally, can some of these ideas be useful for finding a fault-tolerant realization of adiabatic quantum computing? And with this, I will stop. Thank you for your attention. Are there any questions for Armin? Yes, there is.

It's an apology and a question. The apology is because I was a little bit late. And the question is, if you could expand a little bit more on the last of the dissipative adiabatic scheme, if possible. In particular, I'd like to know, what can you say about the locality

property of the dissipators that would be required in such a scheme? And how should I think of this in connection with the earlier scheme of, like, Chirac and Frustrated, where they had a dissipative scheme for doing encoded quantum computation?

Right, yeah. So basically, the idea of this is that, let me go back. I mean, the idea of this, the very notion of adiabatic Markovian dynamics that we have introduced in this paper is concerned with quasi-static evolution of the stationary states, which we know are organized in a noiseless subsystem

and a profile tool, which is a fixed point. So the idea of this holonomic computation in terms of dissipation is simply, if it is possible to somehow engineer a Linbladion, which will drag the subsystem around, to move it in a way that you would

obtain non-trivial holonomies once you take it around the loop. And I should say that it also allows more general possibilities than the standard holonomic approach based on Hamiltonians, because it allows you to move the subsystem along paths that sometimes are not

possible to achieve with a Hamiltonian. And also, depending on the noisy subsystem, on the fixed state that it is in it, you obtain different gauge potential that describes the transformation in the noiseless path. So here, I have said that we're currently developing this idea. But in that paper with Giancarlo Samilia,

we have given some artificial example, just for the sake of proof, how it is possible to achieve universal computation. For this, you would need one gauge qubit, on which, for that particular example, we imagine that you start with the Linbladion, which

acts as the depolarizing channel on that qubit. And then you change this Linbladion. Basically, you rotate it by some unit area until you come back, so that you will obtain this non-trivial transformation. And in this respect, I would say that the Linbladion is three local, to achieve two local.

And how this relates to the Verstrate and Sirak and Wolf, I think it is actually quite different, in the sense that their approach is closely related to adiabatic quantum computing and the clock Hamiltonian. Basically, the solution there is

obtained if you simulate a circuit, you design a Linbladion, which attracts you to a solution of the problem, somehow. Whereas here, there is no solution to a problem where implementing gates, similarly in the spirit of standard holonomic approach.

So if you're worried about the noise that splits degeneracy, since your holonomies are gauge operators, could you use the stabilizer of the code

to suppress correlated noise as DD? Can I repeat, I'm sorry? So when you're doing the holonomy, right? Yes. You're worried about noise that splits the degeneracy. Yes, of course, yes. So if you assume the noise is correlated, could you use the stabilizers of the code, like the bake and short code, as DD pulses

to suppress the degeneracy splitting noise? Suppress? I haven't thought about that. It's an interesting idea. In those theorems that you showed where you were able to produce any target unitary

on subsystem A and errors in subsystem B, is there any condition on relation between sizes of subsystems? No, actually, the gauge subsystem must be with dimension larger than one so that it is non-trivial. But actually, a qubit is sufficient.

A qubit is, the gauge qubit can be sufficient for any system in which you contain the logical information. Let us thank again again.