>> Krysta Svore: Okay, so today we have Vadym Kliuchnikov visiting the Quark Group. He’s a candidate for our group. Vadym actually spent this last summer working with us. So many of us know him very well, his research interests mainly focus around quantum compiling, quantum circuit synthesis, looking at exact and approximate synthesis of single and multi-qubit gates into different basis’s of gates. That’s what he’s going to talk about today. He’s getting his Ph.D. with Michele Mosca at Institute for Quantum
Computing at the University of Waterloo in Canada. He’ll be finishing up in the spring, probably March.
So today Vadym’s going to talk to us about his Number Theoretic Methods in Quantum Compiling and work he’s done on a variety of different basis’s for single qubit circuit decomposition, so, Vadym.
>> Vadym Kliuchnikov: Yeah, thank you for introduction. So, yeah first I start actually with just some broad statement of the problems. So what is compiling for quantum computers and why actually do we need it? So on one side we have a quantum algorithm that promises us to solve certain problem much more efficient than in the classical computer, and examples of this is Abelian hidden subgroup problem or chemistry simulation, or very famous factoring, right. On the other hand we have quantum hardware. So this is actually where we’re going to execute our algorithm.
It turns out that this inner path it’s not that short from going, from high level description of quantum algorithm to a quantum hardware. If one day somebody comes and asks okay I do this, some other model of quantum computer, I have this many qubits and it can execute this long sequences. So can I do something interesting on it? Basically it turns out to answer this question to help experimentalists to execute, to use his actual computer for something interesting also work needs to be done.
I’m going to talk about some problems appearing in this direction today. Here’s also just example of that actually this moment can be not that far of future, this is a slide from David DIVIncenzo talk on the
QIP two thousand thirteen. Basically showing that there is some kind of Moore law for coherence time of superconducting qubits, and basically shows that it’s advances over the last year is pretty impressive.
Right, so I start using some examples of architectures of quantum computers. So it always starts with a physical system that is somehow controlled, right. After control level there are several possibilities depending on what physical system they have. So the most kind of conventional situation use after quantum control we get physical or layer gate set. We use this gate set to execute some fault tolerant and protocol to improve the quality of the gate set, so it can handle precision required for the algorithm.
The most common example for tolerant gate set is Clifford plus T. I’ll explain what it is on the next slide.
After that we basically execute circuits in those gate set. The quantum algorithms must be decomposed into the circuits precisely in these gate sets.
So this is, was actually my [indiscernible] not trivial right, because we start with quantum algorithm and we need to go like through many layers to actually, to control in some physical system. That two architectures is related to topological quantum computers. So this architecture related to [indiscernible] model. So here we get some physically protected gates, Clifford Group is just not enough to get universal computations. That’s why we need some extra procedures to get a T gate to get to nearest
[indiscernible]; this is done through state distillation. This picture shows architecture where all gate,

where as the gate sets available is actually universal and topological protected. This corresponds to
Fibonacci anyons model.
I’ll talk today about this gate set and Fibonacci anyon model and Clifford and T. So more now just some example, right, so the very common building block on many quantum algorithms is Quantum Fourier
Transform. It uses R [indiscernible] which is this diagonal unitary matrices, right. Here is example; here is a specific matrices of Clifford and T gates as in single qubit. You see this is a T gate which has
[indiscernible] root of unity in it, and Hadamard gate and I also include other Clifford gates like phase gate, and fault gates, ZX and integrate set. For the Fibonacci model single qubit gates set looks like up to global phase its tens root of unity to the seventh power and this is a [indiscernible] gate set and as a generator is the first one conjugated by F metrics, which is made of invasive golden ratio and its square roots.
So and I am, in my talk today I’m actually going to focus on this problem. So how you take single qubit R
[indiscernible] and decompose this into these gate sets. What’s important to mention that this cannot like, nearly always this cannot be done exactly. Therefore you need to approximate, right. The main parameter of interest is the precision of approximation and the efficiency of how you efficiently solve the problem is actually how many gates you need to approximate this rotation depending on the precision you require.
Okay, so now I am, give some brief overview, which it was known before in this problem. It’s a, sorry, this problem now was, the question was asked in the beginning of like, nearly in the beginning of research in quantum computing. First in a really satisfactory answer was the Solovay-Kitaev theorem and corresponding algorithm. So this algorithm itself and appeared like in like, so there was like actually it was discovered in parallel by Solovay and Kitaev in nineteen ninety-five and nineteen ninety-seven. In two thousand five points out to Dawson’s paper which makes it kind of, it’s kind of a review with, which is more easy to actually program on the computer. Because that work is you know more theoretical and not so straightforward to implement.
So and this question basically solved doing some high level problems saying that okay if you have some gate sets we can do this efficiently. So this algorithm says that because we want to include any speedups. If you even a polynomial speedup in our quantum algorithm like Grover search or some other examples. Right we still will have the speedup because this is just logarithmic overhead, right.
Of course it was like always was a solution like brute force solution. Here I point out just two papers at first time I actually did it for Clifford and T gates set. So Austin Fowler, so and you see it number of gates you can kind of do this brute force scales like log one over epsilon, while in Solovay-Kitaev it’s like log three point ninety-seven. So conceptually you know when you talk about complexity of algorithms it’s not a big deal. But once you really helping your experimentalists to do something interesting, it becomes a big deal, because this give like big constant factors or just big factors of overhead.

So there was some other works related to this which actually has pretty interesting scaling, but has drawbacks. For example phase kickback described in Kitaev’s book, it uses like adder as a building block and if, has, gives you log one or epsilon approximation but it’s use some number of ancillae to scale over time, and will scale like depending on the precision. So there is like program ancillae orientations by
[indiscernible] Jones that also includes some other you know kind of hierarchical construction of his measurements.
So it heavily depends as a last one on resource state. Actually and if complexity hides in the resource state this is not regal to implement. It also work by Krysta Svore and Duclos-Cianci on some kind of very interesting approach how you make a ladder of state, ladders with measurements and feedback to get something like one point twelve or a little bit more, right.
So but still think you know like classical solution is like Solovay-Kitaev algorithm and it’s you know interesting thing about it is you know it doesn’t require measurements and achieves this result and you get a resource state.
>>: A question, the classical run time in case of the phase kickback method and the PAR. Is that for the preparation of the resource state? Because once you have that is no compilation really to…
>> Vadym Kliuchnikov: Yeah, so actually, I mean it’s why I’m saying log one over epsilon, there’s always run time, classical just to write down a circuit rate. So it’s kind of, I mean if you need to write down circuit rate you have at least this, at least a number of gates in the circuit, right. For part of, actually this is some kind of you know ladder of this classical feedback. So those they like some expectation, so this expectation does not include resource state, right, so on average you can kind of finish this ladder in constant number of sets. But of course to kind of do compilation on some classical processing and runs is you know classical feedback and taking into account which actually states you need you still have, need classical run time, I think you can do it a little more…
>>: I think you’re right. The elements are really just errors in that case, right. [indiscernible] errors?
>> Vadym Kliuchnikov: Yeah, with phase kickback it’s errors. With PAR it’s like the differencing.
>>: Right.
>> Vadym Kliuchnikov: Yeah, okay, well and I think what is actually interesting about this problem, there is like some other side of this problem, which was, has also interesting history. So we can ask a question, okay, is there like how many is this universal gate sets that will actually saturate these bounds.
So we saw like we’ve seen like from brute force that Clifford and T can do it, right. But there’s actually no proof that, there was no proof that you know Clifford and T saturates lower bound, right. In nineteen eighty-six and nineteen eighty-seven there was paper by Lubotzke, Phillips, and Sarnak actually showing that there is a gate set, just example of gate set which saturates this lower bound.

Right, later there was a paper by Aram Harrow, Recht, and Chuang generalizing this result on SU d basically. So SU 2 corresponds to one qubit, right, and SU d can corresponds to [indiscernible] qubits, right. Just you know very recently there was two results by mathematicians, actually sayings that if you have any universal gate set with unitaries that has entries as an algebraic numbers you can, you will always saturate this lower bound. This is non-trivial result. So at first do it in two thousand eight for SU d it was in two thousand eleven.
The first author actually is Field medalist. So and for example second paper is like around like sixty pages proof. Right so this kind of shows, that actually questions them answering not trivial, because even like existential like results about existence are difficult. I am talking here about constructive proofs for some interest in special cases of this problem. So and this just you know some kind of additional motivation to see okay how it works, right. So this are results for Fibonacci anyons, right, for example this is what we need to achieve precision turn to minus ten with Solovay-Kitaev algorithm, this for number theoretic methods.
So like one hundred sixty or over like four thousand, and if you go like up to higher precisions like ten to minus thirty which also pretty considerable with what might be required for quantum algorithm. Its four hundred fifty-eight gates versus like five to ten to the five. So this is why I’m saying that once you actually experimentalists come to you and ask for help, then using methods like Solovay-Kitaev is not the way to go. You actually need something much better.
Okay, so now I’m, yeah maybe one common table one to make also as in talking about Fibonacci anyons.
So this is actually as I saying you see here is, I mentioned this is all for Clifford and T, right. It turns out they show the phase kickback is based on the adder, right, which is easy to do in case of Clifford and T gate set, but totally not easy to do in Fibonacci case. Actually, basically to do an adder; to be able to an adder you need the methods like this.
So I think like Fibonacci case, actually number theoretic methods are kind of much more important and much more special because to go like, to be able to do most of these methods you actually need to do them first. You need to do, to get for example CNOT, right, and toefl gate. To get these gates in
Fibonacci model you need a number theoretic approximations.
Okay, so with this now first I will talk about how this works for Clifford and T gate set. It’s kind of all the results and a little bit more you know, there is more things known and you can be here like really, really precise. So this is how it’s done before, right, so you start with some unitary and as a result of your approximation you get circuit for example from Solovay-Kitaev algorithm. There’s a way how it’s done with number theoretic methods. You take a unitary, you do a unitary round-off and you come up with exact unitary which is close to your original unitary. By exact unitary I mean the unitary that can be done exactly with the gate sets of your choice, in this case Clifford and T. Later it will be gate sets for
Fibonacci anyons.

Then you apply exact synthesis algorithm to get a Clifford plus T circuit or circuit [indiscernible] gate set.
So what’s important here right is actually not just to be able to do this round-off procedure and exact synthesis. You also want to control the inequality of your approximation. Because as we’ve seen from this bound, right, so the more gates, so the better quality you want more gates you need, right. There is a question how you take this into account of this.
Right, so actually as the important part of this exact synthesis story is that your able to say okay so how is this unitary must look like if you want more gates, and how it must look like if you want less gates.
You make the shortest journey round-off procedure. So doing round-off procedure it can actually make a choice how much freedom you get, right. So this corresponds how long circuit you will end, in the end.
Based on this you get better round-off or slightly worse depending on the choice.
>>: Let me, so your error tolerance is set in that first step so is that right?
>> Vadym Kliuchnikov: Yeah, it’s stepped here.
>> Wait, but you need to be able to somehow propagate it into the synthesized circuit at the right.
>> Vadym Kliuchnikov: So this is how this happens right. So basically there’s an, you say okay I have circuits of certain lens, right. This says that this exact unitaries must have a certain form, right. Once you have the certain form that can, so this form kind of fixes the lens of the circuit. So you want to get more than something, right. Once you fix this lens you get some freedom, right. More lens kind of more lens the circuit you get, more freedom you propagate in the step, and more freedom you have you get better approximations. So this how it works.
Well and for this particular case in this actual case story about how exact synthesis, exact unitary looks like is pretty simple. Alright, so all unitaries that can be done exactly with single qubit must have entries of this form. Right, so its sum of different powers of A square root of unity with integer co-efficients divided by a power of square root of two. So if each answer of your single qubit unitary looks like this then you can come off as a circuit.
I will show in a few slides actually the intuition how this power here is related to the complexity of the circuit; this is what I’m going to talk. Here is a reminder how the gates it looks like, right. So you see that in this case entries are of the desired form. Right, so you have this power of square root of two ones and this is H root of unity so they have desired form. This set it’s a ring so it closed on the addition and multiplication so when we multiply these matrices together we get again unitaries on the same ring.
This gives this theorem that I announced already.
So a single qubit unitary can be implemented exactly if and only if its entries has this form, right. As a part of the theorem its interest is an efficient algorithm how to actually get a circuit out of it. It’s both efficient and it’s also guarantees optimality in the number of Hadamard and T gates. Right so
[indiscernible] gates that you can have freedom is some small amount of Pauli’s, so all other things are

optimal except like we don’t make statements about optimality of Pauli gates which are like really, really cheap in fault tolerance setting.
Okay, here is some examples just to show intuition behind how this power of the denominator related to the circuit size. So I take just HT to zen which is, has infinite order, right and I write it to different powers. I see, I look actually instead of entries I look at absolute value square of entries. We see that after each step basically and if you pull out this denominator power increases by one, right. So this much awaits the definition was called like smaller denominator exponent, which is the smallest exponent you can get here. Because, why is this like what is smallest here? Right because there’s some kind of freedom, we can multiply this for example by square root two and this square root two, by square root to and right five.
So basically the smallest means that we minimize this by keeping this in still integers, or integer, like well keeping them in this form, right, with integer coefficients. Right and now I’m going to make precise the intuition. So this is basically main kind of main important result. Right, so we want to know if you want to simplify circuit right, we kind of want to chop some like, it’s complexity of by small steps, right. For this we use generators of the form HT to the K. Right, so you kind of use them to reduce kind of un
[indiscernible] the whole circuit for the unitary. Right and the important question what happens to this denominator when we do this? Right and this statement basically shows that by adjusting K here, right, we can adjust this power of denominator. Either it increases by one, either decrease by one, either it leaves it the same.
Right and this is kind of basic theme for efficiency of all the algorithms. So we can always, this means we can always decrease this SD, right. Basically you can greatly reduce SD for the circuit and get some very simple unitary in the end. Right, so this is more precise statement of the algorithm. So on each we take input unitary, we calculate smallest denominator exponent, then we calculate new unitary with different powers of K here, right, and PK such a way as that we can represent it in this form. So you see, and minus one is crucial here, we have N and here we can always reduce it by one. Right and then we replace or we can reminder unitary with this new one. Also kind of keep in memory what K we use for the choice to reconstruct the circuit. We can do this up to like, so I’ll discuss later there was some progress on this part. This is earliest way, so in the first version just was kind of reduce it below four and for below four this is very small amount of different unitaries that you can look up in your database.
Right here is some ideas why it’s actually H optimal and why is T optimal. So I started with H optimality and it turns that one can show that to increase or decrease this small denominator exponent by one you need precisely one [indiscernible] key, right. Then you check that the set of unitaries with small denominator exponent four is the same as a set of unitaries with that needs three Hadamard gates.
Right and basically this is then shown using the results that I’ve shown you before. So this is a crucial step to show H optimality.
Right and for T optimality it’s actually follows from H optimality. It turns out if you have circuits of this form, ones like have IH in the end and the beginning. Then this circuit must be also a T optimal. Right

and this is the first step and the second step you actually have [indiscernible] outside two things, right, and [indiscernible] K and J in such a way, kind of in a number of, so basically make sure the number of
Hadamard is optimal by,for the circuit by picking K and J and then you can understand what’s what kind of on the ends. Right and out of this you get a precise expression for calculating a number of T gates for the unit of, for the given unitary. So and it’s actually and it’s kind of very precise, very efficient expression, right. Because you don’t need to know much you just need to know this one over square root two, right and some reduce of the entries?
>>: So I have a small question here, so when, since you’re reduced the circuit using HT to the power of
K, right.
>> Vadym Kliuchnikov: Yes.
>>: So do you, how will it be in the occurrences of phase gate. So T to the power of K could have…
>> Vadym Kliuchnikov: It all, it turns out…
>>: [inaudible] zero.
>> Vadym Kliuchnikov: It turns out is that you can, so just, so not all, so first as you get like H optimal circuit you cannot have HB, H phase gate H because this is not H optimal.
>>: Right.
>> Vadym Kliuchnikov: Because you can do the same circuit with [indiscernible] Hadamard gate. Then it’s going to eliminate some possibilities and you get just two possibilities with T gate and one of them is the just T gate and the other one can be expressed as T dagger multiplied by poly zar, poly Z metrics.
Right, so you actually, for it you don’t need phase gate on these steps. You just need poly Z, that’s why I said that I don’t…
>>: Oh I see.
>> Vadym Kliuchnikov: And I count, yeah I count the T dagger at the same cost as a T gate, which is much a gradient by fault tolerance in partial. Right, because in fault tolerance it’s as absolute is the same cost to do like T and T dagger.
>>: [inaudible]
>> Vadym Kliuchnikov: Okay, but thanks, yeah. So and this is just some kind of, a little bit more details on how this proved, right. So they’re actually like one analytic part of the proof to show this inequality.
So this is done just through like tedious series of exercises about the properties of this small denominator exponent. So you try to understand how it behaves on the addition and multiplication.

The second part is actually when you need to show that you can always pick the K, such it can be increased and reduced by one. Right and this computer assisted part that just need to check some finite number of cases.
Here is kind of just one idea is crucial right. So once you have numbers like this, right, you don’t need to know the whole number to understand if the SD can be reduced or not. You just need to know basically three lost bits. Computer assist part just take different combination of lost bits and checks exhaustively for the different combinations that this can be done.
So, yeah, this is how, yeah I will discuss later that there’s some kind of, maybe easier way to look at this.
But I think there’s still benefits of this way because you’ll see that there’s some similarities and differences for Fibonacci case, which still look in some sense similar, right. So and actually exact synthesis algorithm give you like a tool to efficiently approximate circuits. It can be used in different ways. Here I want to highlight just one of this, one ways. This is kind of some smart search methods, right. So this is actually about if you want to really guarantee the quality. So how you find optimal circuits, so it’s not done in polynomial time but you can do it to the precisions like ten to minus fifteen, ten to minus seventeen, which is maybe, which is quite sufficient for many applications and especially for earlier ones.
Then I will also like later mention why it’s, actually [indiscernible] efficient for anything at all. Right, so my aim to approximate is R [indiscernible] right and I’m approximated with unitaries like this when all entries is from the [indiscernible] that I’ve been talking about. The distances I’m interested in is a trace, global phase and variant trace distance. Right and it can be simplified to expression like this. Important point here is that this expression depends on only one entry of the unitary. Right and this gives enough way, this dictates the ways of how approximation works. Just, first I pick X in such a way that I achieve certain approximation and then I reconstruct the full unitary. To reconstruct the full unitary the question like this must be solved.
The main kind of challenge of this method is that this equation does not always have a solution. Finding solution to this equation is also a challenge. So this is just actually just kind of flawed. This is a complex plane, right. This is different choices of X and its red if solution exists and blue if it doesn’t, right. So this is of course if you consider all possible numbers of this form they will like just you know, you’ll play and you’ll be just colored completely. But this is a drawing that limits the denominator exponent. So and this is what we do in the algorithm, right. This is the way how we adjust the quality.
The first pick based on precisions we want, we choose maximal denominator exponents that we will use.
Once it is chosen we look on possible entries with this denominator exponent and solve our algorithm.
So and this basically, solving this equation leads to the problems that is called relative norm equation.
>>: [inaudible] which denominators [indiscernible]?
>> Vadym Kliuchnikov: Think four and this is just a partial of complex play and you see it zoomed.

>>: [inaudible] plot [indiscernible] one?
>> Vadym Kliuchnikov: It’s real and imaginary part.
>>: Oh real and imaginary part of what?
>>: X, of X.
>> Vadym Kliuchnikov: Of X, yeah and just to give a brief feeling basically of how to solve this equation you actually need to, one of the sub problems is the factoring. It’s known to be a hard problem but it turns out that actually in this case it’s, in that regime you know there was a lot of work on factoring, right. Actually here we can harness all this nice number theory results on factoring, on Heuristics for factoring. Actually you need to roughly to factor numbers up to two hundred fifty-six bits. This can be done very easily on modern computers. Because of that you know…
>>: [inaudible] quantum computer person.
>> Vadym Kliuchnikov: Well, so it’s actually like on a usual computer, right, so. Yeah and, so and how the algorithm works, it actually kind of, I phrase the problem of find approximations like a different way.
It’s a problem with a promise. So I say okay I promise there is a exist approximation with some precision, epsilon, I want to find something better with given complexity. Why it’s kind of, why it’s okay to consider this problem as a promise because you know if you do your search iterate of the right for example you find like best circuit for fifty gates, right. Then you know what’s the best circuit for fifty gates and what’s the precision in use.
Right, so if you want to find the next one that uses like fifty-one or fifty-two, you don’t, you’re not more interested in some qualities that lower that you have already achieved, right. So this is the way how, where you can take this promise from, right and this basically limits that’s kind of the possibilities that you need to consider to very small region, right. It’s also the problems is placed to, like real part and imaginary part. Basically you choose possible approximations for real and imaginary part. Then check is there a solution or not. So basically you do this factoring and check necessary conditions for existence of solution.
Right and here is just maybe to point out to the other like subtlety. In this problem we should call, it’s related to what I call minimal unitaries. So the quality of approximation depends on the X entry, right.
But the T count is actually depends on the whole unitary. You interested in, was, so as Y, as a choice of Y is a [indiscernible], right. So you actually interested in the, what’s kind of minimal to count you can get for X and for this you need to consider all solutions to norm equation. So basically two guarantee the minimally of algorithm is you need to go like through all solutions to this equation and minimize this T count over all solutions. I’ll skip example because I’m a little bit short on time.

So this is just basically shows that work that was done on this, right, so this paper on exact synthesis.
This is generalization of exact synthesis by Giles and Selinger, it’s a multi-qubit case. So the next work is a first published result with saturated lower bounds using a fixed number of ancillaes and our resource states. Then it was improved by Selinger’s but eliminated ancillaes [indiscernible], right. This was in probabilistic polynomial time, right. This is an improvement by around thirty percent over this by kind of investing more computational resources. This is kind of preliminary work of what I was just talking now, because now actually I can prove optimality, which wasn’t done in this work.
Okay, now I’m more into Fibonacci anyons and topological quantum computation, just to remind actually why it’s so exciting to work in topological models. It’s kind of, this way you get hardware level fault tolerance. So your compute, you get a gate set that is universal and protected just by design of your physical system. This is, so you don’t need some like extra things like fault tolerant protocols, or magic state distillation protocols to achieve a new result. All there is, once you know once there is a hole that you don’t need extra things that the hole, there is a hole that okay you can do more computation, right. But it turns out that actually like the whole possibility of this model depends on how well you compile, right.
This is why, so this is gate sets that you get in this model, right. So it includes you know tens root of unitary inverse of golden fraction. What’s important, like what’s kind of you know the way you pay for this universality right so you cannot implement exactly when a bit flip. So which is you know pretty set and if you use Solovay-Kitaev algorithm for that so it will just eliminate all those advantages of using the small [indiscernible] like state distillation all running extra full tolerant protocols.
So and here some, as I told before also you need the single qubits into this method not just for bit flips but to actually come off with good multi-qubit gates. Right, for example, this examples that, of coming, how you can come up with CNOTs and this, you see this how computation like visualized in this model, right. This precision that you still can achieve, it’s pretty small. If you go to larger precisions with
Solovay-Kitaev, you won’t be able to draw it.
Right, so this is generic scheme how in this case this method work. This is a work that I’d done like during my internship in the summer with Alex Bocharov and Krysta Svore. Right and this is high level you see it’s again, we start from unitary, we do a round-off, do exact unitaries, right. Then apply exact synthesis to get F, T-circuit, I will explain in a minute what it is. Here is some extra step which is optimization to actually bring it to sigma one, sigma two-circuit, which is, so sigma one, sigma two circuits corresponds to actually the things that you are actually doing. So in Fibonacci model you’re moving particles around, right, and sigma one and sigma two corresponds to the particle moves. Right, while this gate set is just convenient for my theoretical purposes and is not so directly related to how complex your, you know computation will be.
Okay, so this is definition of this F, T gate set. So it somehow looks similar to T gates that we had before, but with tens root of unitary instead of eight root of unitary and this is F gate, which is, looks the same

like as F metrics for Fibonacci model but it’s actually a gate. This can be executed using some sequence of sigma one, sigma two. You can just search, so this can be found and it’s in our paper, right.
So and here is the story that’s more interesting about exact synthesis in the sense that how exactly synthesisable unitaries looks like. Right, so it actually has some like additional things it’s the square root of ToE that, so U, V, and V dagger, E dagger are from, have this form, right. So this is integers extended by tens root of unitary. Right and the square root of ToE is just kind of sits around and just plays the role when we calculate things, but it’s kind of just symbol and all kind of variations that all of our freedoms are related to this U, V with rings of integers. So this is also like there’s one feature interesting that you have the square root of ToE and the other feature that is interesting that you have actually work with ring of integers, instead of ring of integers divided by some square roots to some power.
Right, so this is, and actually this is, changes the structure of exact synthesis proof a lot. Because you don’t have any more that’s like square roots powers that you that was used before to kind of understand the circuit complexity. So here you really need something different to understand complexity.
>>: I wish you had made it the same as that [indiscernible]. Your kind of using in a changing way.
>> Vadym Kliuchnikov: Oh, okay.
>>: For example.
>> Vadym Kliuchnikov: Yeah, okay, yeah sorry.
[laughter]
Yeah, you know it’s a typo, right. So yeah omega here is tens root of unitary. Yeah, so yeah a little bit confusing in this example. Now, so and you know, well actually you know as an important objects can become considerably real sub-ring is Zetilli. For example absolute value squared, you remember like in
Clifford T also to [indiscernible] squared. This belongs to this ring of integers. The next important object is Galois automorphism of this ring of integers. It moves its Zetilli which is inverse of golden fracture to minus five, which is golden ratio.
Right and, so there are different choices actually of complexity imagine just , in our papers there is a different one but here just kind of to explain it more quickly. So kind of, just you, I think it a bit easier to explain with this one. So this is a Galois conjugation of absolute value squares of the entry. Right and again some slide to show the intuition behind it. Right, so we look at unitaries of this form and if you rise it to power N and see what happens to complexity measure and we see that it’s going to become larger and larger.

Right and we’re going to use this intuition for exact synthesis. So here’s exact synthesis algorithm you take as input exactly sythesisable unitary. So the unitary of this form, right and while you have complexity measures greater than one, V use F multiplied by T to the M to reduce the complexity. Right and basically we pick M so that complexity measures the result is minimal possible. The crucial here is that it can always be done and then we can achieve new equals to one. Once we achieve this it’s just very simple situation, just some power of root of unity, which we can handle.
Right and so this is small, just very briefly showing you this idea of the proof. Right, so this is what you get after you multiple, so this is the entry after multiplication entry of the unitary after you multiplied by
F, T, to the K. Right and this is before, and we are interested in this ratio how it changes, right. So and basically what’s important is that we can always make this ratio roughly less than one cert on each step.
This means that the number of steps is algorithmic in the value of complexity measure.
Right, and how this is achieved, this is roughly, basically can define two vectors, two unit vectors on a complex plane. By choosing K you just angle between these two vectors. The rotation, basically rotations that you have rotations by five over five, and by adjusting this rotation you can kind of move it as orthogonal as possible. Because of this you can go below this number.
Right, okay, yeah maybe. So I mentioned before the complexities is also, so we need to have a good you know take of what is complexity, right, of how it limits the complexity of our unitaries. So in this case we actually limit complexity by the value of, by the logarithm of the complexity measure, so how complex our unitary is proportional to the logarithm of complexity measure. It’s kind of similar but to what we have in Clifford and T case. Right, in that case we have the square root in the sum power right.
The power, which is related to logarithm, power of the square root two was complexity measure.
Okay and to handle general single-qubit synthesis problem, zero two sub-problems. Right, first one is R
[indiscernible] and the second one R Z followed by X. So important case when five zero is X gate, right, so includes actually how to synthesize X gate. There is a lemm in our paper proved by Alex showing that
[indiscernible] represents unitary and as product of three R [indiscernible] case.
Right and now I am going to concentrate on R [indiscernible]. In this part actually I’m talking about polynomial time algorithm of, instead of, as opposed to the last for Clifford T case where I was talking about something that is guarantees of optimality. Here is actually reason for that because complexity measure in this case is, so it allows you to synthesize unitaries but it doesn’t allow you to reduce the complexity lower, just straight, right. So in that case we just looking by unitaries say oh, this many
Hadamard gates is needed and a number of T gates is plus, minus one from the number of Hadamard.
In this case we cannot do this things yet, maybe we’ll be able to do them in the future. So and here I’m talking about if polynomial time algorithm, but concentrate will be pretty good as I’ll show later. So this is again the distance that we are aiming for, this is the same distance, right. It is again simplifies to this expression, right, and constraint in this case looks slightly different, before we had just the same thing result ToE and here we got extra ToE.

Now this just integers are like integers extended by a tens root of unitary, right and again we kind of start with actually since that gives us required precision, so we identify, so this gray region here corresponds to, since this helps, gives us precision of approximation epsilon, right. Then we sample U from here, its actual simpler to sample from this green region. So the sample U from here states that we have some pretty fine complexity measure, like bounded complexity measure. This M here is basically how we bounded. So we compute M which is around like log ToE one over epsilon, with some constants and where a scale, also where a scale accesses, right. Since your scaling is done actually to improve constant factors because once you do round-off you actually kind of, this way you kind of utilize the bits for efficiently. Because you have a choice, you might not rescale this but then you want to utilize as kind of all your degrees as freedom as efficiently as you could, right.
So for polynomial time synergy actually concentrate on a special case of constraints that are easy to handle and easy to solve, because I mention that we have as a sub-problem we have a factoring, right.
Everybody knows this is a harsh problem, right, so how we come off this polynomial time algorithm when the sub-problem is factoring. It turns out that we can aim for easy cases, right. So I give just one example of easy case. You can, there is, you can come up with other examples of easy cases, right, but this is just one with this right hand side of the norm equation looks like five to some integer multiplied by prime number of this form. Right and this basically prime number of this form which is form of prime numbers that must be here is related to a number theoretic structure of the problem. It’s related to each prime, which primes are completely split in the tenth degree, in the cyclotomic field, tens degree cyclotomic field.
Right and this condition is also necessary. It basically says kind of follows directly from positivity of absolute value squared. The second one follows from the fact that ultimate reason that we were using for Galois automorphism for complexity measure it can be actually defined also on the ring of the, for the tenth root of unity, and you can propagate it inside, right, so if you have A plus B ToE here then and insolvable, the second thing when you can apply this Galois automorphism on top also must be solvable.
Right, so it turns out there is a simple, oh well not simple but efficient algorithm for solving norm equations in this case.
Right and this is example of how the sampling is going, right. Is, oh that picture is going to, a little bit not realistic, it’s not how it happens because epsilons so small. One kind of interesting cases is always kind of more close to reality. Alright and basically divides it great, green region into these cells, right, and a number of cells scales like one over epsilon. Right, so basically smaller, yeah smaller epsilon that it get, more cells we get. We randomly sample from them and sometimes we get unsolvable cases, and sometimes we get solvable, but not easily solvable, and sometimes we get solvable cases.
So this, what’s actually, this is somehow analogist to prime number theorem, right. In prime number theorems says that if you sample from numbers from zero to M you’ll, the density of primes will be M over log M. So basically number of efforts because you need to do before you successful to find a prime in this random process is log M. So this ways and similar thing happens here, basically actually some kind of conjecture because this happens here it’s, that [indiscernible] proof.

This means that we can efficiently find easy, so we can find easy case like this logarithmic number of efforts. That guarantees efficiency of algorithm. The other thing that guarantees efficiency of the algorithm is that actually primes can be recognized in like polynomial time. So there is a famous result as recent that you know is like deterministic algorithm for checking if the prime is not or it is, right, or some earlier results like primality tests like Miller-Rabin primality tests that we use here.
>>: So when I run primality test has a certain false positive, right.
>> Vadym Kliuchnikov: Yeah.
>>: It’s small but it’s…
>> Vadym Kliuchnikov: Yeah, yeah, but I think…
>>: So the deterministic one does it still have a false positive?
>> Vadym Kliuchnikov: No, that’s, so this was like you were, I mean I think isn’t, was the case, right it was break through sort of nailing down the problem of prime testing. Right, so that you can, in polynomial time decide the, if the number is prime is not result in your false positive. It’s like AKS algorithm.
>>: False positives [inaudible].
>> Vadym Kliuchnikov: What?
>>: Well for Miller-Rabin you just testing [inaudible].
>> Vadym Kliuchnikov: Yeah I mean, so Miller-Rabin is better for practice, yes, because that one has pretty but constant and pretty but actually powers in the logarithm. So yeah that’s, okay. Yeah, and this is just one out of the small detail how, basically how you pick points inside the cells, right, to actually pick the point we use continued fractions, right. So we, first which, so take a center of the cell, then we find imaginary coordinate just by finding the best possible approximation with a continued fraction, right. Then we do the same thing for ex-coordinate.
So this is kind of technically how the results look like. So this is what you can achieve, so basically with roughly like ToE to the M, right precision by allowing B to be less than five to zen. Here you can see actually where is it B balancing zen comes from, right, because if you don’t re-scale the whole thing, right, then basically X will be round one. Right and B, V fixed and A will be kind of too, for A, too small degree of freedom, right. So by re-scaling actually you kind of take into account degrees of freedom for
A that we have. This is very high level, so if it’s confusing don’t worry.

Okay in this experimental results of how this algorithm for Fibonacci anyons works. Right, so it was implemented in C++ using PARI/GP sub-routine to solve norm equation. This is comparison to brute force search. So this is actually more like about you know how good, so I’ve been talking you know about that algorithm efficient and it’s efficient in asymptotic sense, right, but okay what’s the constant factors? Yeah, this shows was the constant factors. So this is what our algorithm does and this is what results of brute force. Right, so you see that it’s around basically twenty percent overhead in comparison to brute force, which is I think very good for polynomial time algorithm. Right, so this is a case of R Z rotations and for R Z X is slightly larger overhead.
Okay this is this shows how it scales, right. These are very different parts, right so synthesis part. This is exact synthesis algorithm, norm equations. This is part, this is inside part GPU, just you know, because it’s not very well documented, so we actually need to check if it’s actually really does solve things in polynomial time. This is as a part of approximation algorithm. Right and the last thing is re-synthesis.
So I didn’t talk before much about it, right, so this is, the thing, this is how you translate your FT circuit into a sigma one, sigma two circuit, which is needed to really execute the things on the hardware. Here
I use people optimization. So I made a database of optimal sigma one, sigma two circuit up to some size. Right and then I take a circuit, FT circuit, rewrite it using simple, so you can express F gate using sigma one, sigma two, and you can express that my T gate for this model, right, precisely using small number of generators gives a sequence a then you optimize it, using people optimization so you take sub-circuit and find the unitary database, replaced with optimal one, and do it until it’s possible to do.
And…
>>: Do you know what percent of what the compression rate is [inaudible]?
>> Vadym Kliuchnikov: I would say it’s like around twice, something like that. Yeah, I think maybe, yeah,
I think it was around twice. Yeah probably should kind of do this experiment to show how it, because I just did some, on the way of my development looked at this.
Yeah, it’s important to know that this scaling is actually in all these algorithms this is kind of typical to present scaling as a number of arithmetic corporation as opposed to number of bit size, as a bit size.
Right, so this is the scaling is the number of arithmetic corporation. Because I am using fixed bit size not types. So I use large ones but it’s a fixed size. So therefore example five hundred twelve bits integers, one thousand twenty-four bit integers, and two thousand forty-eight size integers. This shows scaling of algorithm run-time depending on the choice of how many bits you use.
Alright and the last point I think to make about this that you see the scaling is like all below like two right. Solovay-Kitaev is like two seventy something, right, so and this algorithm not just gives much better results it’s because Solovay-Kitaev it’s actually run-time scales better. So you know it’s basically against on the all, in all directions.

Right and this is just the part of the conclusion I just want to highlight a few other things that I’ve done related to compiling. So this work is called Synthesis of unitaries with Clifford and T circuits. It’s improvement of exact synthesis algorithm from multi-qubit unitaries in, for multi-qubit Clifford and T integers. So the result that I mentioned before by Selinger it had actually with a number of qubits the circuit size scale doubled exponentially. Right and here it just scales exponentially and of course you can come with qubits, with circuits that actually has exponential number of gates, with a number of qubits.
So it’s kind of you know basically it cannot, I think cannot do much better in asymptotic sense for generic situation, right. Because sure you can do, for special cases you can do better than exponent and, but this kind of small papers it causes kind of theoretical question about exact synthesis. Right, so in this paper it’s algorithm for T-count. This is more you know like in a practical paper like about, for maybe two and three qubits for Clifford T, can you actually, how you improve your exhaustive search.
What was done here basically we kind of split Clifford group from T-count and we come up with this canonical form that kind of removes this you know make it invariant with respect to Clifford group. This allows you kind of to go, once you using some like exhaustive methods this allows you significantly compressed search space. As a consequence we were able for example to prove that if you’re not using measurements and ancillaes you need seventy gates to make a TOEFL gate. So this was a paper that first readdressed the proof to this result.
Of course, I mean this is, you know it’s kind of a little bit, this particular result is you know I mean it’s a little bit of theoretical interest more than like practical. Because there is no like circuits that use measurement and classical feedback that can TOEFL like this four T gates, but still the technique and ideas I think will be useful for optimization of circuits. Because in people optimization for example if you, the larger database you get the better results you have. Right so it’s, actually I did this kind of experiment for this paper and I’ve seen like serious difference between for example when I’m using three qubit database optimized Clifford circuits and when I’m using four qubit database, right.
Also this paper kind of nicely matches this one because now it kind of will remove this problem from here right. It started separately in this paper, so how you can actually optimize Clifford circuits and for a small number of qubits there is a way using binary [indiscernible] interpretation. You can build pretty large databases up to like, handling up to like four qubits. Also this, looks what happens when you use them for people optimization of larger things.
The last one is kind of, paper is Nathan Wiebe, right, well it’s right say to say it’s paper by Nathan Wiebe and me that kind of asking the question about single qubit synthesis in a slightly different way, which is very neat. Because in many cases you’re not really, so all the way around here I was asking about absolute precision. Right and sometimes you, absolute precision is not the, probably those things that, I mean it can be high, right. In my cases you can, especially like in simulation, chemistry simulation you might want to rotate by very small angle but your precision, like relative precision is small but absolute precision is still big. So on this paper it’s actually addresses how to benefit in this, from this situation.
So what you can actually do, you can do measurements in classical feedback, kind of split your rotation in two parts like mantissa and exponent and do exponent part with some tree structure. Because of this

basically we can bit that log one over, like bit lower bounds up to constant factor. Right, because you can come up with numeric lower bounds how good you can do in Clifford and T case, right. You can actually bit it by kind of stating problem differently in this paper.
Okay and here’s my conclusion. So basically today discussed how ideas from computational number theory can be applied to circuit synthesis of single qubit unitaries. Right, so I showed efficient asymptotic lower optimal algorithm for compiling to Fibonacci anyons braid patterns. I showed and kind of sketched how you can get optimal ancillae-free Clifford plus T circuits solving the same problem. All above was implemented in C++ so it’s not, just not theoretical work it’s actually now practical it works.
This for Clifford and T is its open source project. So this was, I am developing here at, I was developing in the summer and contributing, right.
Like I want to finish actually with a question what is next? Right and I think the next kind of questions that are interesting to look at includes measurements in this number-theoretic frameworks. This is one interesting direction. The other interesting direction actually kind of uses methods to come off as good to multi-qubit Fibonacci circuits and also I still think that something interesting can be done for multiqubit Clifford and T circuits, once you use for example two or three qubits. That’s paper by David
Gossett and me and others I think it’s kind of start point, can be a starting point. Last question is what’s the generic mathematical structure behind exact synthesis? Because answering it is also important.
Because I think once you include this measurements right you can get access to some other number fields.
Alex asked me this question like long time ago how you combine things, right. How combine for example result from their work, which is view basis, right with for example Clifford and T, actually I should mention that view basis is precisely the thing that was in Sarnak paper when they prove existential result and then Alex and Krysta and [indiscernible] showed that you know there’s a constructive way actually for that gate set, right, so that’s also kind of interesting.
So, thanks everybody for attention. That’s it.
[applause]
>> Krysta Svore: Any questions for Vadym?
>> Vadym Kliuchnikov: Questions?
>>: Yeah, I’m curious, with your work with Demetre involving Clifford synthesis.
>> Vadym Kliuchnikov: Yeah.
>>: Have you noticed any side effects that are, any improvements that might be relevant for say randomized benchmarking or other applications?

>> Vadym Kliuchnikov: Well, I think, so that, yeah I did, you know I kind of do mention this here is one of our application we mentioned randomized benchmarking, right, which is, so randomized benchmarking is a way how you can check the quality. It’s the modern way of checking quality of your quantum computer. Right, before there was like this tomography. Right but it’s difficult to do and not efficient and randomized benchmarking protocols allow you kind of to construct some rough quality, rough information about the quality of how your computer works. Basically this, one of the other applications for this work of Clifford optimization actually performs these benchmarking protocols better. So you can basically have shorter sequences to perform these experiments faster and you know.
For example if you compare to what you get using some, there’s like algorithm for the composing
Clifford unitary synthesis circuits by this kind of canonical that works in polynomial time, but it gives you some long circuit. Our circuits probably like around, for small number of qubits can be like maybe two, three, four times shorter. So this just gives you, you know like reduces your waiting time in physics experiment.
I think that might be interesting seeing about relating this to this benchmark application is that it kind of puts together implementation at people optimization. So first you use opt, your circuits to benchmark things, right and then you, once you get your Clifford circuits you replace precise, you optimize it using the same database. So this ensures that your circuit in your algorithm has the same circuits that you use for benchmarking.
So, I think, yeah, and yeah I think in that direction there’s also some freedom to explore because you know there are tradeoffs you can play depending on what gates in your physical system are more difficult to do and easier to do. Because in such paper we just looked at some basic cases and there are like ways how you can maybe do it a little bit further, this brute force part depending on your architecture.
Yeah, thanks.
>>: I have a mathematical question? For this FT basis, so you had certain things like since you had ten
[indiscernible] I guess the tenth power of one of these states is, was the identity.
>> Vadym Kliuchnikov: Yes.
>>: I guess this F gate squared perhaps is the identity?
>> Vadym Kliuchnikov: Yes.
>>: Are there any other non-trivial relations or is it [inaudible]?

>> Vadym Kliuchnikov: So, we’ve been looking at, you know so this not published and so we’ve been looking at canonical form for the circuits. Right and basically there are, so the un-trivial relation is like as, non-trivial relation is like, includes like such powers of T and it’s like F, T cube, F, T cube, F, T cube, I think equals to identity if I’m not mistaken, right. There is, actually they come off as canonical form for that. I’m pretty sure that it’s kind of how it must be, but I don’t have a proof for it. So you basically cannot have [indiscernible] seven powers. So you can have a canonical form like F T, F T, right, and you cannot have such powers of T and seventh power. You cannot have bits strings like ones and a bunch of fours and one. So because, that’s because of that identity actually, because of that identity it can kind of a little bit exchange it ones in fours and move them together and bring it to three, which becomes nonoptimal.
>>: [inaudible]
>>: So there’s [indiscernible] right? So it’s a need for a theoretical problem. The proof is clearly finitely representable, but what is the finite unitary presentation in terms of generators which are the two generators. What are the minimum set of relations? It’s not known.
>>: How do those three continue…
>> Vadym Kliuchnikov: No, I mean, so my point is that the last one that F T cube is the last, it’s not untrivial. It’s the only non-trivial one. Yeah, so…
>>: [inaudible]
>> Vadym Kliuchnikov: Because I, what I actually did like, I go this canonical form, I kind of, so you can solve recurrent, system of recurrent relations to get how many optimal circuits that you have this specific number of these F gates, right. I did computer search and I compared the numbers and they’re the same.
>>: [inaudible] or is it non-trivial one or it’s not…
>>: Actually F T cubed, right.
>> Vadym Kliuchnikov: Yeah, so
>>: [inaudible]
>>: [inaudible]
>>: It’s a [indiscernible] sequence of the [indiscernible]. It’s not something…
>>: I’m just asking are, is a theorem that there are no other non-trivial relations?

>>: Oh, it is not proved yet.
>>: [inaudible]
>> Vadym Kliuchnikov: But I think it’s you know I can’t believe it. I believe it but it’s not yet proved yet.
>>: Thanks.
>> Krysta Svore: Have you thought about other, so in the beginning you showed these long constructive papers.
>> Vadym Kliuchnikov: Yeah.
>>: They talk about other basis’ of these algebraic entries that’s per SU and SUD. Have you thought about other basis’ that might be of interest to look at here?
>> Vadym Kliuchnikov: Yeah I think…
>>: Because you know now we, well we have three.
[laughter]
>> Vadym Kliuchnikov: Yeah, I think so…
>>: [inaudible]
>> Vadym Kliuchnikov: I don’t think of any specific ones but I kind of thought about the sources, like where they can come from, right. So they can come from actually Fibonacci they come from including measurements in the model, right. Because each time you include measurement you will normalize, right so they might do some other variations of like you know in Fibonacci case. The same thing like, so in your paper and Alex is like, so view basis is one example, right. You have like other possible denominators, right. So this also comes from you know can, I think basically the way to get these other basis’ is to do some this measurements and see what you get in the, once you apply measurements.
>>: Do you know that for a fact [indiscernible] circuits on [inaudible]?
>> Vadym Kliuchnikov: Yeah, yeah, so this is…
>>: So I’ve been sort of musing for quite awhile as some of you know that finally it’s about quantum
Fourier transform the gradients other than two or a power of two. It’s pretty easy to generate rotations of higher of ten, higher of five, or something like that. But this sort of idea, what is left then at least is

generating a state which superposes equal amplitudes by zero, one, two, three, and four. Sorry, zero, two, three, and four by five. If you could superpose those and then use those to control application and rotation you would have a gradient five to the K before you transform them. So how could we do that?
How could we generate a state that has equal distributions of amplitude across that space?
>>: [inaudible]
>> Vadym Kliuchnikov: I think, so I think…
>>: Yeah.
>> Vadym Kliuchnikov: Well I mean the first we can answer like the question it cannot be done exactly, right, because one over square root of five is not…
>>: [inaudible] can’t generate rotations of you know…
>> Vadym Kliuchnikov: I then I think so there actually, there is literature on state preparation like decomposing for example, like how you do state preparation using single qubits and CNOT and slightly different methods than for example how you unitaries with single qubit and CNOT. Then there is like you know that, for example in this paper right. The main [indiscernible] block is a state preparation, right. So this works, so basically sometimes it’s actually common to answer the question how to exactly prepare states with a certain model, right. After that, so I think, so this is kind of included in what next.
Right so like, but to multi-qubit for Fibonacci, right so actually how you exactly, what are exactly synthesisable states with Fibonacci model. Then you can just like round-off the whole state, right. It’s actually, now state round-off is easier problem than unitary round-off because you just, for example even if you have multi-qubits state you just have one constraint, it must be normalized to one. Right so that’s, and that’s basically leads to one norm equation that we already kind of, it’s already well studied by us for this case.
>>: Yeah, on the other hand in [indiscernible] there are five of those I suppose?
>> Vadym Kliuchnikov: No, so in this case you just take entries and round-off and show them. You give yourself some small freedom. Then you just could move on small entry. Right, it defines basically how good you approximate and actually for [indiscernible], well I mean for [indiscernible] field it’s not actually, so we use like fifth root of unitary, right. So it’s like tenths asymptotic field. But it’s actually like fourth degree extension, right.
>>: Right.
>> Vadym Kliuchnikov: So an integral basis that I’m using here, right. You can see it’s here it’s, yeah so it’s just four numbers, right. So basically entries of integers is just four degree of freedom, actually other

things that kind of need in Clifford T and in Fibonacci is both like fourth degree extension. There are only like four, there are only two different fourth degree groups, right. Actually like this is a cyclic fourth degree group. Right, so it’s like in Fibonacci case its Z four and in Clifford, like, okay, sorry, I jumped. So you can look at Galois group of this extension, right. Galois group of this extension is Z four and for
Clifford and T it’s [indiscernible] group. Yep?
>>: So many?
>> Vadym Kliuchnikov: Yeah, I think it’s considerable in the future, right.
>>: [inaudible]
>>: I’m curious about the round-off procedures.
>> Vadym Kliuchnikov: Yeah.
>>: That you explained you do it in two step fashion. First you round-off the exact synthesis.
>> Vadym Kliuchnikov: Yes.
>>: Somehow it seems that the round-off algorithm itself there’s kind of a trade space. It could be very efficient but in the [indiscernible] the precisions not so high or you seem to suggest the norm equation solver to do the round-off. I wonder how that compares to like methods that Selinger proposed. He proposed a very efficient method for round-off.
>> Vadym Kliuchnikov: No it’s [indiscernible] equation.
>>: [inaudible]
>> Vadym Kliuchnikov: Just, so what Selinger does it just solves special case of norm equation, right.
>>: Right, right.
>> Vadym Kliuchnikov: So this is, I mean this is kind of…
>>: But not quite, right. He has according to…
>> Vadym Kliuchnikov: Ah, you mean the second…
>>: [inaudible]

>> Vadym Kliuchnikov: You mean like, so okay, if you’re searching [indiscernible] Selinger paper now, right. So there are two steps, still two steps, first step in round-off.
>>: Right.
>> Vadym Kliuchnikov: The second one is to solve, no check if this instance was a norm, like in that paper there’s no like word norm equation, right. The first time when it appeared like it’s related to norm equation is like practical approximation, but in that paper there is, no this word. But if you’re talking about in this language, right, first step you do round-off and the second step you solve norm equation and basically check if it’s an easy instance with a norm equation and solve it.
>>: Right.
>>: You hope for the best.
>> Vadym Kliuchnikov: Yeah.
>>: I think that is very fast.
>> Vadym Kliuchnikov: Yeah, check and actually I mean you can, you know I said before that I, here present as very kind of simple case of what is an easy instance, right. But you can say okay I have for example this, I can have an easy instance of the other type. I can have a smooth number, right, with just one big prime factor, right. This is also an easy instance for factoring problem. It will handle like more situations than just hoping for having one prime number, right. Going back to this round-off, right, it’s actually, so this is an interesting difference between the Clifford and T case and for example Fibonacci case. That…
>>: You might want to bring up a slide where there is, where it says greater than zero of the two greater than zero conditions.
>> Vadym Kliuchnikov: Yes, so…
>>: Way back.
>>: [inaudible]
>> Vadym Kliuchnikov: Oh, this one.
>>: Yeah.
>> Vadym Kliuchnikov: So here, right, I get them from round, so they actually I don’t need to any work to satisfy [indiscernible], because first ones it is satisfied just by choice the number of this that it’s inside

here. The second one is that I can prove that it will be also satisfied. Right, so in Clifford and T gate, case it’s actually non-automatically satisfied, right. You need to do extra work and if you remember there’s like, in Selinger paper he has this like volume, right, has the small cells and there’s a bound on the volume. It’s actually I think interesting this might be related to the famous Makowski theorem on, about you know convex bodies and lattice. So if there is a, like if you have convex body great, with volume greater than determine unto the lattice then you can find your point inside it.
So and actually it’s, to me it looks pretty similar to what he is doing to the constructive proof of the
Makowski theorem. But, I mean it’s kind of tweaked a little bit and I’ve been looking recently on some literature and it might be actually you know related.
>>: [inaudible] you are absolutely right. But as a [indiscernible] in H T case it’s very hard work to actually get a green point in a convex domain of interest.
>> Vadym Kliuchnikov: Right.
>>: That’s…
>>: Here it’s almost a…
>>: Yes.
>> Vadym Kliuchnikov: Yeah, here is that you don’t have to care about the extra condition.
>>: The same as in the case in the B basis case?
>> Vadym Kliuchnikov: Yeah, well…
>>: [inaudible] even simpler. I mean we basis three [indiscernible] squared.
[laughter]
>>: Wait, wait, mathematically you’re…
>>: He’s making a joke.
>>: I know, I’m just giving him a hard time.
>>: Okay we’ve got to go.
>> Krysta Svore: Let’s thank Vadym again.

>> Vadym Kliuchnikov: Thanks.
[applause]