>> Krysta Svore: Today we are welcoming Byung-Soo Choi to our group. He got his
PhD in South Korea. He's currently a post doc at Duke University and has been working
with the Quantum Computer Science IARPA program on a team at Duke University. His
interests are in the areas of quantum computer architecture and previously in
microprocessor architecture. So Byung-Soo today is going to today present work on
quantum computer system components for quantum-augmented cloud systems. So
please welcome Byung-Soo. Thank you.
>> Byung-Soo Choi: Thanks so much. It is my great pleasure to be here, and this is the
first time for visiting [inaudible]. It's a very nice place. And I'm very proud of Microsoft
because Bill Gates is one of the respectable persons in the [inaudible], so this is very
good and this is an honor for me.
Okay, today I'd like to discuss -- or not discuss, I'd like to talk about my previous work
and my current work related to quantum applications and quantum systems. So
ultimately I want to -- If I work in this world more then ten years, for the rest of my life,
then I want to look at some quantum system in the cloud systems, and then I'll be very
happy because everybody can use quantum computers.
So let me start. So my consists of three parts: one is my bird view of the quantum cloud
systems, and the second one is my previous work, and the last one is my current work
and my plan. So when I started quantum research from the time I considered how can I
design quantum cloud systems from the device [inaudible] to the algorithm [inaudible].
This slide, I actually made it around five years ago. From that time I've revised it and
revised it again and again based on my knowledge about quantum systems. So please
tell me if I am incorrect or if I have invalidators; please just tell me.
So I the quantum computer system consists of these hierarchies. So at the low-level we
can make a quantum device, like a qubit gate operation based on the physical device
like ion trap, optical, superconductor, NMR or solid-state or whatever. Although, we have
quantum devices like this one, if we don't have any quantum computation model then we
cannot do that; we cannot make a quantum computer system. So we usually have three
-- These are my classifications. So we have three models like a circuit-based model and
measurement-based model. And now, we have another one: anyon-based model.
The circuit-based model is very similar to conventional classical quantum models. So we
just make a circuit and we just run the circuit. The next one is a measurement-based
model. So if we prepare a large number of [inaudible] pairs, we can do measurements
among them and we can do the computation. So this is what we call a measurementbased model. Now another one is recently based on anyons we can make a quantum
computation model. I think these three things are measured computation models in a
quantum computer but there's another one like automatic. And maybe we can propose
another one based on cellular model. So I believe there are many models but typically
we have three models like circuit-based model, measurement-based model and anyon
models.
Now we have a device and we have computation models, but this is not enough
because this quantum device is very sensitive to errors. So we have to error correction
code or fault tolerance schemes. So we have to use have fault tolerance previous to this
like concatenation code or topological code or surface code. This layer is technically for
the error correction part and fault tolerance part.
So these three, device, model and error corrections, makes [inaudible] and fault
toleration computation models but that's not enough to make a quantum computer
because we still need some components like adder, [inaudible] or multiplier. These kind
of things in computational terminology we call these database elements. So we have to
make those kinds of things.
And also we have to make memory systems or CPU or bus systems, or maybe we have
to add another one like communication components. So based on this we can make
distributed [inaudible] systems. Up to now I do not believe that we can make one holistic
big system, one big quantum system; we have to make an Internet communication
system within the nodes. I think that's a practical way of making a big quantum computer
system right now. So we have to consider this distributed way.
Up to this level we can make one working quantum computer system but that's not
enough [inaudible]. So we have to make another layers like system software primitives
like a compiler, scheduler or optimizer and other things. So I call this one quantum cloud
systems. So this hierarchy is web-based quantum computer system where we can make
a connection between the computer. We can put some components in here for the
communication part. So based on this hierarchy and the structures, we can make a
quantum system.
Now the next one is applications. I'm considering this architecture; this is cloud systems.
Currently right now in the classical domain they also do a lot of work on cloud computing
systems, but at the same time we have to consider how to use that, how to use quantum
system for the cloud system. So I made this level of components. The lower level is
application primitives, like high performance computing algorithms. And the second one
is high security application, and the last one in high speed communication primitives. So
these kind of primitives can be used for making applications.
In the conventional cloud systems they call these applications [inaudible]. So based on
these primitives, we can build up some applications like computational science and
engineer applications or healthcare or transportation and whatever. But for that we have
to have one middle layer like an application framework layers. So this framework has to
map these application primitives to the applications. So in this case we have to combine
the classical cloud systems and the quantum cloud systems.
And the last one, that's the device or the user interfaces like me, individual cases, and
companies like Microsoft or other companies, the business sector, and the one other
one is the national sector. Usually when we have to use quantum computer systems, we
have to consider the national application first, like national security or national energy
factors. But sometimes we will use this one for the business sectors, like a bank or
Microsoft or Google or [inaudible]. But finally we, like me, I also want to use quantum
computer systems through my telephone.
So this might be a picture of the quantum-augmented cloud system. So [inaudible], this
is cloud system [inaudible] and this is end user terminal or embedded systems. So as
you can see this is not a small job; these are very big jobs. We have to consider vertical
integrations of all areas from the device layer to the application layers. So the property of
this physical device will affect all things. Also the application will affect the device as
well. Yes?
>>: If you spread quantum components, distributing...
>> Byung-Soo Choi: Okay.
>>: ...then you new security problems arise.
>> Byung-Soo Choi: Yes, that's true. That's true.
>>: How are you going to address that?
>> Byung-Soo Choi: Somebody has to do that.
[laughing]
>> Byung-Soo Choi: Maybe I cannot do that but somebody has to do that. So we also
recognize that kind of problem. If you have to make [inaudible] quantum [inaudible]
systems, how can you manage the security [inaudible] from like North Korea or from
other countries? Security issues are very important. Also in the conventional cloud
system, the biggest problem is security. So we have to consider the same thing in the
quantum case as well.
But luckily we have some high security systems like [inaudible] systems so maybe we
can support much more higher security classical systems. So in...
>>: But I'm surprised that I don't see quantum information [inaudible]. You know,
quantum [inaudible] contribute to security, a secure way to exchange bits, quantum is
more secure than anybody else.
>> Byung-Soo Choi: Yeah.
>>: I think what's missing from Yuri's comment -- if I may rephrase -- is there's no
quantum information backbone here in the cloud where you can take advantage of the
fact that you can send [inaudible], you can send superpositions and you can send
cryptographically secure messaging throughout the data center, even across data
centers.
>> Byung-Soo Choi: Yeah.
>>: And that also needs to be on your bus besides conventional distributed processing,
quantum distributed processing as far as the hybrid.
>> Byung-Soo Choi: So this area has to consider that. It's [inaudible].
>>: Exactly.
>> Byung-Soo Choi: Okay. So this is my dream to make this whole system in my life. So
related to this before I came here, I have worked on some parts, especially the
application part and the system part. Related to application part, I did some work like
cryptanalysis and machine learning. And the system, I did some work on architecture
and arithmetic and the code parts. So today I'll try to tell you about this previous work
and also my future work.
So for applications, this is my previous work. Why I joined this work myself was because
I wanted to know if this was really useful, is this really helpful for information processing.
So for that I did some work to analyze the quantum search algorithms. So at the time I
worked on the partial algorithms, partial search problems. Partial search is defined as
searching problems but not to find the target element but to find the block orders of the
target element. This is [inaudible] partial problem, this is [inaudible] problem compared to
the original group of such problems.
But in this case because we put some [inaudible] on the problems, so we have to ask
some high [inaudible] property compared to Grover's problems. With other papers we
found one way how to do that. The idea is very simple: we can define the three bases.
One is target state and the second one is other states in the target block and the other
basis is for other states in the non-target blocks. So based on these three bases, we can
find some phase conditions to achieve successful [inaudible] very high.
The next one is we tried to extend this problem to more general cases. Like Grover's
algorithm, we also considered multiple target cases, multiple target block cases. But this
is trickier. But we found some way how to do that. I don't want to tell all the details but I
just want to say what I did.
After that I tried to move to find some real, more practical problems, but still it is a little bit
artificial. We are given one Boolean function and we're also given two weights, but we
don't know which weight is the real weight for the given Boolean function. So the
problem is we have to decide which one is the correct one. So for that we propose one
algorithm, but the idea is also simple. From step 1 to k minus 2 steps we apply the
conventional Grover algorithm. From k minus 1 to k steps, we apply modified Grover
operators based on some conditions. So this is algorithms.
So as you can see from 1 step to k minus 2 steps, we apply the convention Grover
operator, but for the k minus 1 step and the k steps, we apply slightly different Grover
operators based on the phase conditions, set 1 or set 2. These are the phase conditions.
But the idea is like this one: because we given two weights for one Boolean function, we
can put these two weights at the initial state on the Bloch sphere, like that way. So in this
case we [inaudible] a condition. The Boolean function is symmetric, so the summation of
two weights, Weight 1 and Weight 2, should be 1 so that their location in the Bloch
sphere should be symmetric. Symmetric means if this one is going down then this one
should be going high, so like [inaudible] should be symmetric like that.
This is Project 3 on the Bloch sphere for the last two steps, how we can do that. So in
the algorithms this is k minus 1 steps, Grover operator. These are k steps operators. As
you can see we apply the conventional inversion to the target state like pi angles. But
the next inversion has to be changed based on these set triangles. So as you know the
Grover operator consists of two inversions, inversion over the solution state and the
inversion over the initial state. So we just need to change the angle for the inversion over
the initial state.
This target shows that. If this is some state, after k minus 2 steps, we apply the inversion
of the solution state so that this state has to be here. But the next inversion, inversion
over the initial state, has to be changed based a set angle. In the previous slide, these
values. So we found that the angle based on this condition. In the trajectory, based on
this [inaudible] we have to rotate this state into some area here. Yes?
>>: What is the weight? How do you assign weights to Boolean functions?
>> Byung-Soo Choi: A weight is defined as a ratio of the number of solutions over the
number of [inaudible]. If there is only one solution -- Solution means just some input
[inaudible] is one.
>>: Satisfying [inaudible].
>> Byung-Soo Choi: Yeah. Number of satisfied...
>>: So the fraction of [inaudible].
>> Byung-Soo Choi: Yeah, that's correct.
>>: So you don't know ahead of time the weights.
>> Byung-Soo Choi: We are given just the two weights but we don't know which one is
the correct one. That's a promise. We are given one Boolean function and we are given
two weights.
>>: Oh, it's a promise problem.
>> Byung-Soo Choi: Yeah, promise problems.
>>: Oh, okay.
>> Byung-Soo Choi: But we don't know which one is the correct one so this algorithm is
for that case. So during this work we found one way how to do that, how to decide which
is the right one. And the next one is [inaudible]. In the previous case we assumed that
the weight of these two are symmetric, that means the summation of these two weights
is one. But now we make some [inaudible]. So in this case we do not have such
conditions. So the summation of the two weights can be from zero to two. This is the
asymmetric case. But the idea is tricky and the idea is very simple.
We just make a larger input space by adding some qubits so that we can reduce this
problem to the symmetric case. This is the way. We can make other functions based on
the initial functions. For the initial input space from zero to N, we use the same function.
But from N to 2N we use similar function -- actually this the same function. But from 2N
to 2N plus x we assume that the output should be 1. And for the input space, from 2N
plus x to 4N, we assume that the output is zero.
So this f of prime function is derived from function f but the weight is different. Because
of this solution space, we can make w1 prime and w2 prime. And their summation can
be one. And the condition for L is derived that way. So this is very trivial and this is a
very simple idea.
The one thing I want to emphasize is the necessary qubits. Usually two qubits is enough
even though the problem seems to be very general compared to previous cases. But,
two qubits are sufficient. And next essentially is to do the case for multiple weights. In
this case we have m weights, and we want to decide which one is the correct one. So
the idea is to apply the sequential -- repetition in applying the asymmetric case
algorithms like that one. So if we are given these m number of weights, wm, we want to
know which one is the correct one. So we choose two candidates from S, one is the
minimum and one is the maximum. And then, we apply the asymmetric weight decision
algorithm, the previous one.
>>: But now it's not promised to one of them. You need the promise that one of them is
correct.
>> Byung-Soo Choi: Yeah.
>>: But maybe neither the minimum nor the maximum is correct.
>> Byung-Soo Choi: That's right. In this case we have a promise: one of them is the
right weight. But in this case, we just choose that. Sometimes we choose w1 or wm but
unfortunately w1 and wm are not the correct ones. Then, this algorithm shows that or
gives us some candidate that in all likelihood is the correct weight. Based on that we can
choose that. But even in that case we can say that if the weight is not chosen it is not a
candidate. So we can even know that. So this is a knock out system, so every repetition
we just knock out one by one.
If one of them is the right one, then that weight can be chosen and that weight can
survive the remaining iterations. So we can choose the right one. This is one way how to
do that. Actually we did not consider any more generations of this problem, so our last
job is to prove whether this is optimal or not. So we try to prove that: whether this is
optimal or not. So for that we apply the quantum query complexity method, quantum
query [inaudible] method.
We explored the Ambainis' Quantum Adversary Method. So he proposed one way how
to do that. If we can find some relation, r, and we can find some input space, x and y,
and if we can find these kinds of conditions then we know [inaudible] this number of
queries are required to do the computation. So we apply the same idea for our case...
>>: What do you query? Where is the overflow?
>> Byung-Soo Choi: Sorry?
>>: You count queries. Queries to what?
>> Byung-Soo Choi: Ah, query means [inaudible].
>>: And what does [inaudible] do?
>>: [inaudible] f.
>> Byung-Soo Choi: Yeah. In quantum algorithms usually...
>>: Oh, f is a [inaudible].
>> Byung-Soo Choi: Yeah, f [inaudible]. So I mean this is just a query [inaudible]
complexities. So how many queries? How many [inaudible] functions are required for
doing these algorithms? So based on this information we can infer whether these
algorithms are optimal or not. So we just apply the same ideas in our case. So for our
problem we found that these values, from m to f prime, we just apply the same
algorithms so we can prove that our algorithm is optimal.
This whole thing is -- Yeah?
>>: [inaudible] requires [inaudible] -- Where k is what?
>> Byung-Soo Choi: K is the number of steps, and number of steps means number of
Grover operators, how many Grover operators have to be used to do these algorithms.
>>: So coming back is your [inaudible] optimal or [inaudible]?
>> Byung-Soo Choi: Sorry, [inaudible]?
>>: You posed a question whether your algorithm is optimal.
>> Byung-Soo Choi: Yeah, our algorithm requires k steps for the problem. And based
on this [inaudible] we found that k steps are required.
>>: In that [inaudible]. Okay, yeah.
>> Byung-Soo Choi: So this whole thing is, actually from my understanding of the
quantum computation power for some algorithms. But luckily these kinds of problems
can be used for machine learning right now, so I'm extending this idea from machine
learning cases. But for now I'll try to explain my previous work on the quantum system
part.
So build up the quantum system we have to consider many things, but in that case we
cannot do anything. So I just consider some simple cases, like [inaudible] first. Based on
this I can get many insights about the depth lower bound and the scheduling and the
[inaudible] and the lower bound as well. So I chose adder for my primitive for
researching things.
So my first question on the system part is, what is the depth lower bound for the addition
on the 2D architectures? The question is -- This architecture is very important in these
cases because this one, 2D NTC SWAP channel means we allow just the nearest
neighbor interactions between the qubit. And we allow just two-qubit gate operations as
a maximum. And we allow concurrent gate operations on [inaudible] qubit and we allow
just the SWAP channels for moving the qubit between the neighbors.
>>: What's NTC?
>> Byung-Soo Choi: Oh, N means nearest neighbor. And T means two-qubit gate
operations. We allow [inaudible] gate operation and the two-qubit gate operations. And C
means concurrent operations.
So my question is in this architecture, 2D NTC, we do SWAP channels, what is the
depth lower bound of the additions? So for that I explored the graph theory of
operations. In the graph theory we know that there are some graph embedding issues,
like these cases. This is a guest graph and this is a host graph, and our job is to map
this guest graph into the host graph. If the host graph has some limitations, like this one,
then the guest graph has to be changed. "It has to be changed" means some edge like
this one has to be -- the distance of this edge has to be changed like this one. So this is
one case of the graph embedding. So this guest graph is a tree and this one is a line
graph. So this edge from node 1 to 5 has to be changed like this one. So in this case
there is no direct edge from node 1 to 5. If they want to communicate they have to use
node 2. That means this interaction distance has to be increased in these graphs. So we
just use this idea in our case.
We found that there is some vector-like dilations. So dilation is defined as the ratio of the
diameter of the host graph and the diameter of the guest graph. Diameter is maximum
distance between any two nodes in G. That means, in this case, diameter is from this
node to this node, the maximum distance of any two nodes. Okay? Yeah?
>>: [inaudible] So what you call embedding is not really embedding, it's...
>> Byung-Soo Choi: It's just mapping actually.
>>: Mapping.
>> Byung-Soo Choi: Yeah, mapping. Mapping [inaudible].
>>: And your theory is about two embeddings, right? [inaudible] This theory is about two
embeddings, right, [inaudible]?
>> Byung-Soo Choi: Yeah.
>>: Okay.
>> Byung-Soo Choi: Okay. This dilation value implies the increase or the overhead of
the edge, the increase of distance for the guest graph. Based on this dilation effect, we
can infer how much overhead has to be added for the distance of every edge.
>>: How much you have dilate the host graph in order to embed...
>> Byung-Soo Choi: Yeah, that's correct. That's correct. So luckily in the addition circuit,
in the graph theory addition can be done, can be implemented by the tree graph. Okay?
And this 2D NTC can be represented as just a grid structure. So in graph theory terms
the problem is like this one: if we want to embed complete graph structures into 2D
graph structures, how many dilations? That's the key. Based on that we found that this is
the lower bound of the depth. In this case depths means from this leaf node to the top
node because addition is just from this leaf node to the top node. So based on this
property we can find that there is a lower bound [inaudible]. So if we are given kD NTC
architecture then the lower bound is this one. For the 2D cases the depth low bound is
square root of N. We found that.
The next case is then what about depth optimal adder in 2D architecture. So we propose
one adder based on the partitioning of the input qubit like that way. So we put the adder
this way. So the number of columns is root N and every column contains root N
elements. So there's N qubits. And we map the quantum addition circuit on this
architecture like that way.
So this is the first phase. In the first phase, the first column has to do the conventional
ripple carry additions. But the other columns they do not do that because their input
carry is not defined yet. So they just do carry [inaudible] operations. And the next step -Because we found the carry output for the first column, we can propagate this carry into
every column. So every column can know the input carry for each column.
And the next step is to do just [inaudible] carry additions for all the columns. So three
steps, like that one. So this is the first phase in the circuit. So this is the first column for
the first phase and these are the other columns from 2 to root to N columns. They are
doing just the carry [inaudible] operations. And this is [inaudible] for the k propagation
between the columns. And this one is for addition from column 2 to root to N columns.
They doing just replicate additions based the input carries. So this is one example for the
[inaudible] cases.
So as you can see the depth is just root N because the time for this addition is root N,
and this carry propagation requires root N times. And this addition also requires root N
times. So depth is root N.
So this is our one design which is optimal. And we compared and this is really good
compared to 1DC NTC adders architecture. And we analyzed that, whether this 2D NTC
shows better performance in terms of KQ. K and Q means number of qubits and number
of gate operations. This is the value when this 2D NTC adders shows that better
performance compared to the 1D NTC adders because this is [inaudible]. So from n is 3
this adder shows better performance, but this one is [inaudible], the CDKM is very good.
When n is 51 this adder shows a better performance compared to our one, but larger
than 51 and our adder is better.
So now -- By the way right now in these days we consider KQ very important. Based on
the KQ values we decided the error correction [inaudible] and the [inaudible] error
requirement. So nowadays the KQ factor is very important.
So this is...
>>: [inaudible] your other rows? AC?
>> Byung-Soo Choi: Oh, this is -- AC means Arbitrary -- Actually this is abstract
concurrent architecture. Abstract means they do not care about the distance so they
allow any combination of the qubit operations regardless of the distance. So this is kind
of theoretical bounds of the additions.
Those kinds work [inaudible] on the system part. But for now I'll try and tell you about my
current work on the system part. So recently the quantum computer research work is
heavily focused on the research part because we already know how to make a
[inaudible] quantum system. But the problem is the research is too big [inaudible] if you
want to do [inaudible] algorithms for the 2,000-bit then maybe we need 10 to the 20
qubits with 10 to the 30 gate operations. But technically this is impossible.
Actually I'm working on some experiment papers. When I say, "I need 10 to the 20
qubits," then they say, "Oh you are just an idiot." Because they say, "Our best is to make
just a 3-qubit." So there is a very big [inaudible]. So our job right now is to reduce. We
have to reduce resource overhead as soon as possible. And also we have some
[inaudible] metric like ADCR. This is for the algorithm levels. So how much area and how
much delay and how much repetition of the algorithms are required for doing [inaudible].
So our job is to reduce ADCR [inaudible] resource overhead. We have to reduce the
resource overhead and also we have to reduce this ADCR.
So this is my understanding of the overhead breakdown from the algorithm level to the
device level. The algorithm designers they just make several lines, we can program
using the C or using F sharp or using [inaudible] languages, whatever. So this is a
resource overhead in that case, several lines or a hundred lines, that's enough. But by
offline compilings we have to decompose this source code in terms of reversible circuit
so that we have to add additional overhead. This comes from this synthesizer method.
But that's not all; we have to do it again for the single qubit gate operations, especially
like arbitrary angle rotation gates. So we have decompose again. This is additional
overhead for these single qubit gate operations.
But that's not all [inaudible]. We have to add another layer for the error correction part
and fault tolerance part. And also we have to consider architecture constraint. So these
kinds of things increase the resource overhead as well.
But that's all, is it? We have to do it again [inaudible] part. So like that, actually we have
to add resource overhead step by step until it generates [inaudible] code. So our job is to
reduce this whole overhead by optimizing every level. My focus right now is on two
levels. [Inaudible]. My approach is optimize some components like the arithmetic part
and also improve the architecture part and the necessary system [inaudible], and also try
to exploit some code conversion method.
The first one is the arithmetic part. Even though we have a lot of papers, we have a lot of
work on the arithmetic part, it is still not sufficient because most of the previous work
focuses on depth or size the gate is. They do not consider usually area delay,
components of the area delay or they do not consider error correction parts. So right
now we have to consider these factors. So maybe the immediate goal is to find AD or
KQ optimal adders on the 2D [inaudible].
Probably we just need to revise the previous designs in those ways. So I'm considering
right now this way. So if you can put some bus [inaudible] channels then maybe we can
reduce the delay for the computation part because this bus is not a free one so we have
to increase the resource overhead like area. But if we can put this bus [inaudible] then
we can make a smaller KQ, a very good adder which has very small KQ values. So this
is one way.
The next one -- These are just working diagrams. The next one is, I think, much more
practically important. Conventionally we assume that [inaudible] gate operations we
have to apply error corrections, right? But if you consider just the CR or error [inaudible]
of the algorithms then maybe we don't need to do that. Maybe we just need to put
[inaudible] error corrections for one part. If the [inaudible] over ADCR is very small
compared to applying error corrections for every case then we have to choose that way
because our main performance [inaudible] is not just for error property but ADCR. So we
may find some vast number of error corrections and their locations in the circuit so that
maybe we have to increase the area and delay but we may decrease error rate. So we
find some tradeoff between the number of error corrections and ADCR values.
For example we can put error corrections only for this part or only for this part, not all of
them. But we don't know yet how many error corrections are required and what is the
location for them. And also we can consider other arithmetic components like a multiplier
or even more we can make another arithmetic component like floating-point
representation arithmetic or CORDIC. CORDIC is very useful for the classical [inaudible]
devices, so we can make a quantum CORDIC arithmetic circuit.
The next one is the architectural part and it isn't my main area right now. So [inaudible] I
say that we have to optimize ADCR. But how can you evaluate ADCR? Technically we
have to have some toolset to evaluate this A and D and CR, but these two sets also
have to focus on the architectural part, architectural constraint and/or the error correction
part.
So this architectural research or architectural consideration is very important to show
which error correction, what kind of parameter has to be considered. So in our team with
other team members we are focused on how to build up good architecture and the
necessary layout and scheduling algorithms and how to evaluate their whole inputs. So
our target architecture right now is 2D NTC architecture but the communication channel
is a little bit different. Previously we considered SWAP channels but right now we're
considering constant-time communication channels by using simultaneous entanglement
swapping. Actually this is based on [inaudible] papers and also based on the [inaudible]
models. So we can apply the simultaneous entanglement swapping; that means we can
prepare an EPR pair at any distance qubit at a single time. So we can implement
constant-time communication channels by using this way.
By using this one we can do remote CNOT between any component, and we can do
teleportation in a single time. Based on these architectures, our job starts. So our job is
to make one architecture which exploits these kind of communication channels and
consider these kinds of architecture constraints. So to make an architecture from the
empty space, it is quite hard. So we checked out assembly code because this assembly
code is an input for the architectural part. So this is one sample code from one of the
team members in our project. They give us one assembly code and this assembly code
consists of some modules like -- We call this Level 0 gate. This component represents
one gate operation for the component, like just preparation Z state -- zero state actually.
And this one is for measurement at the Z bases. These are primitives and also we can
define the CNOT operations. So these things are elementary components for building
the whole algorithm. This is the next step module, Toffoli 1 consists of calling the lowlevel modules. In this case low-level module means this level [inaudible].
This is a block diagram of the hierarchies. This Toffoli 1 calls some CNOTs several times
because of this code. Like this way, we can make a hierarchy of the modules of top
levels. So this is the top level. The top level main module. The main module consists of
several sub-modules, like this one, and each sub-module calls on other sub-modules. So
we found there is a hierarchy that way and we found the modular way. Based on this
insight we propose one way how to make architecture.
Our idea is very simple: we have to use the modular approach and we have to follow the
hierarchical approach. This is our idea. If we can make a schedule and if we can make a
layout for Module, and if Module B tries to call this Module 1 then we just map these
input parameters to this Module 1 by using some way, and actually some way means
shared bus. So we can layout all modules that way and then, we can schedule these
mappings by using some additional resources. And then, we can make all input
algorithms like this way. So for this architecture we defined some primitive components
like a bus. So this bus implements simultaneous entanglement swapping. These
components can support entanglement swapping between these two neighbors. So we
can implement entanglement swapping from this port to this port at the same time.
That means by using this bus we can make some information channels from this part to
this part. Yeah?
>>: [inaudible]. Previous slide, please? So this is acyclic. So you have a hierarchy of
modules.
>> Byung-Soo Choi: Yeah. Yeah.
>>: Which means you cannot do recursion. Did you consider allowing cyclicity?
>> Byung-Soo Choi: In the quantum algorithms we do not allow acyclic flow because
quantum algorithms usually are just one flow from the beginning to end and that's all.
>>: That's logical.
>> Byung-Soo Choi: That's logical.
>>: Physically. You're now trying to compile it the physical. And so if I have a module
that's reused a hundred times, I'm really looping on that module passing a state vector
on one end, getting it out and passing it back in. So you really are looping.
>> Byung-Soo Choi: Yeah.
>>: So you do get recursion.
>> Byung-Soo Choi: From like this one.
>>: Right. So...
>> Byung-Soo Choi: Sometimes here. Sometimes here. Sometimes here. And then, you
have to use the same modules not because [inaudible].
>>: So the way I read -- If you can go back to your furthest slide -- the approach is you
take an algorithm, you figure out the common modules.
>> Byung-Soo Choi: Yeah.
>>: Up to a certain level of abstraction.
>> Byung-Soo Choi: Yeah.
>>: So you have the very bottom here. You may do Toffoli's, you may go higher than
that. You may say, "I have QFT. I have an adder. I have whatever."
>> Byung-Soo Choi: Yeah.
>>: You implement some number of those in the hardware.
>> Byung-Soo Choi: Yeah.
>>: Then you have a scheduler that decides, "Oh, in parallel I can run these versus
these have to go sequentially because I only have so many QFTs."
>> Byung-Soo Choi: Yeah.
>>: For example. So, "I can only run this one and then this one has to wait."
>> Byung-Soo Choi: Yeah, yeah.
>>: And so what you're doing is doing a layout not of the algorithm but the modules the
algorithm needs and then, you're scheduling the algorithm on top of that.
>> Byung-Soo Choi: That's true.
>>: Is that correct?
>> Byung-Soo Choi: That's correct.
>>: Okay.
>> Byung-Soo Choi: Actually that is [inaudible] scheduling. Maybe I can skip some
slides. So by using this one and by using this one we can make parameter passing. So
this is one. This is what you are saying. So this Module 1 tried to call this Module 3. And
this Module 2 also tried to call this Module 3. Maybe sometimes they try access the
same modules, but the architecture and the high-level scheduler have to control these
kinds of conflicts. So that is the job of the high-level scheduler. And also like the previous
question, if Module 1 tried to call this Module 3 several times then the high-level
schedule has to do that.
They just need to map the input qubit to somewhere here because we already found
their scheduling and layer [inaudible] so we don't need to worry about this part. We just
pass the parameters to some pre-defined place here then we just use the same
schedules. This is the advantage of this kind of approach. If we have a schedule of the
low modules and if the high-level scheduler can schedule for the mapping of the input,
mapping the parameters then we don't need to worry about the low-level part during the
high-level schedulings.
>>: But a module could be as small as a single gate. For instance, if I have to do a
phase estimation with a reset, I need a CNOT in one place....
>> Byung-Soo Choi: That's correct. That's correct.
>>: And have to be able to do it. Okay.
>> Byung-Soo Choi: That's the job of the [inaudible] compiler. I call those low-level
scheduling. This is just for high-level parts. I just assume that this is encapsulated in the
modules. But as mentioned, we have to decompose again. So this is a very big view, top
view of the architectures. So we can put this bus somewhere here -- Oh by the way, we
don't which way is the best way to locate this bus, but we have an idea [inaudible]. So
we can put a bus like that way. These blue ones are modules. And one advantage is this
is magic state factory. So this magic state factory can distribute magic state any place in
[inaudible] if there are no conflicts.
I think this is very -- I mean this can support a very cost effective way. This is a highlevel view. And the next one is a low-level architecture and low-level scheduling. So we
have to decompose these modules in a very similar way. Maybe the very naïve idea is to
put one to one, all channels for all combinations but I think this is superior. So we have
to use some [inaudible]. So we have to put a bus like that one. And then, the key
problem is we have to partition this circuit or we have to partition the group of the qubit
into four terms. So this shared bus has to be used for all four combinations. If this
module won't communicate with the other modules, submodules then this bus has to use
and also this one has to communicate with the other two modules.
So this partitioning has to consider the connectivity or sensitivity of the circuits. So this
shared bus has to be located on the very sparse or very low connected parts, not the
highly connected part. Technically this part has very high connectivity compared to these
connections. So we have to partition the input circuit based on these conditions and
then, we have to put the bus. This single bus can support all combinations of
communication.
>>: One other question: the bus is a lot more sophisticated I would assume than what
people think of as a bus because it's constantly generating EPR pair and shipping them
everywhere for the teleportation for the CNOTs?
>>: [inaudible] same thing.
>> Byung-Soo Choi: Also we have a strong argument over that issue. At the physical
level we have to do that like repetition, generation and [inaudible] and other things. But
after Level 0, after the physical level, we can assume that we can apply the logical level
plus schemes.
>>: But it implies a bandwidth then because if you guess wrong and put the wrong
pairs...
>> Byung-Soo Choi: That's true.
>>: ...in the wrong places...
>> Byung-Soo Choi: That's true.
>>: ...you're going to cause a latency that you wouldn't have had if you didn't have to do
that.
>> Byung-Soo Choi: Yeah, yeah.
>>: Okay.
>> Byung-Soo Choi: That's true. That's the reason why I put it like that way. [inaudible]
on the bandwidth we have increase even though there's a vertical one. Sometimes we
have to make very thick [inaudible] but we don't know yet which way this is good.
Up to now we just devised the conceptual way. So this is one example: we consider
module this way. This is just handwritings but you can see there is the location of the
bus [inaudible]. But I think we also have to consider the ADCR model. So even though in
this case the number of buses is I think very large, we have to reduce the number of
buses based on the ADCR model criteria. But, we don't know yet. And "I don't know yet"
means we do not have any tools right now, but we are considering those kind of issues.
This is a whole view of the architecture part. This is the high-level view so we can map
the algorithms into these columns based on the modules and based on the hierarchy.
And each component in the architecture part can be decomposed like that, and also this
one can be decomposed like that.
This is one concerns your questions. We have to build up some physical or Level 0
components like core, router, repeaters. We have to use these elementary tiles to make
a bus for a communication channel. But luckily in our project this is not our job actually.
[inaudible] our people, they do that. They implement this low-level, Level 1 scheduling
for implementing Level 1 components. So they are implementing the physical level
circuits and physical level components, and they generate Level 1 components like
Level 1 core, router or repeaters. From that we can build up.
Yeah, I have to say that at the physical level we have to consider this [inaudible]
protocol, we have to consider repeater protocol, many things. But on this level, we don't
need to do that.
>>: Well, there's also the problem of lifetimes.
>> Byung-Soo Choi: Yeah.
>>: So sending the pair doesn't mean you have it for more than a certain period of time
before you have to send it again even if you didn't use it.
>> Byung-Soo Choi: Yeah. So I didn't show this slide yet but we have very important
questions. The location of the repeaters -- Even though we assume that we needed
these [inaudible] bus, we don't know the good location of the repeater or how many in
the locations. That question is also one of our questions.
Based on that -- This is just simple because we know how to layout, how to schedule.
[inaudible] suggested to make some programs.
That's for the architecture part. From now I want to talk about code conversion. So we
can imagine this case: computer system A uses one code, like a Steane code. Computer
System B uses another code like Bacon-Shor code. And for some reason, they have to
communicate. I mean this is natural in the cloud system.
>>: What were the code [inaudible]?
>> Byung-Soo Choi: Oh, error correction code.
>>: Error correction.
>> Byung-Soo Choi: Yeah, sorry. Error correction code.
>>: Very different code spaces.
>> Byung-Soo Choi: So to make a connection between the computers we have to
consider these problems.
>>: I'm sorry, why would you have two different codes in the first place?
>> Byung-Soo Choi: I don't know. Why?
>>: How can you rule it out?
>>: What if somebody wrote a library using specific code, and you're off in another
library using a different code and you wanted to use their [inaudible] to convert between
your code and [inaudible] their code. In the classical sense. On a quantum machine it's a
whole question of whether we actually [inaudible].
>>: And I guess that's what I mean.
>>: Right. Right. But it's an interesting question. How practical is a different question.
>> Byung-Soo Choi: That's correct. So up to know we have two methods: one is code
teleportation method and another one is the stabilizer sequence method. Code
teleportation means if we prepare in quantity EPR pairs between error correction code A
and error correction code B then we can do just teleportation. This is called code
teleportation. Sorry?
>>: You can do what?
>> Byung-Soo Choi: Teleportation.
>>: Teleportation.
>> Byung-Soo Choi: And the stabilizer sequence method means we can find some
sequence of stabilized gate operations from one [inaudible] state to the target state. But
in this case we have to find a sequence. So actually [inaudible] made some software
programs, how to find it. So technically we have two methods, like the teleportation
method and the stabilizer sequence method.
This work is a little bit related to state conversion research work. But this one is just
based on the [inaudible] like teleportation. Maybe we can propose another method. I
don't know. I tried several times but I cannot find any way. Maybe we can find other
ones.
Related to this, I'm considered some technical cases like this case. This one is Steane
code and this one is Bacon-Shor code. How can we make one specific [inaudible] circuit
for doing code teleportation? This slide shows how to prepare EPR state, encode in EPR
state for Code A -- in this case it's Steane code -- and for Code B -- in this case BaconShor code.
I found that this circuit works correctly, so we need to prepare the CAT state and we
apply each gates, transpose away and we apply the [inaudible]. This part and that part.
This whole thing is a transposer. And we just measure some part of the CAT state and
the part of the CAT state. And then, we just check the parities. Based on these parities,
we just apply the encoded X gate operations. This is just like compensations to make an
EPR pair between this one and that one.
This is one circuit.
>>: [inaudible] re-encoded. How did you send one code to another?
>> Byung-Soo Choi: No this is just for preparing the EPR pair for Code A and Code B.
And then, we can do teleportation by using this EPR pair.
>>: But the pairs are in different code spaces.
>> Byung-Soo Choi: Yes. This one is from Code A. This one is Code B. And this one,
CAT state.
>>: No, no. I understand the CAT state. What I’m trying to understand is Code A may
have a different number of qubits than Code B.
>> Byung-Soo Choi: Yeah.
>>: For example. So how does this teleport from one to other?
>>: No, no.
>> Byung-Soo Choi: No, no.
>>: So he's preparing...
>> Byung-Soo Choi: Just an EPR.
>>: ...an EPR pair.
>>: I know this is just the -- Okay, let's see how you're going to use it. Let's stop. This
give you now a fully entitled between the two and they have some sort of base they
agree on basically at this point?
>> Byung-Soo Choi: Yeah.
>>: Okay, you're at that point? Fine.
>> Byung-Soo Choi: Yeah.
>>: Okay.
>> Byung-Soo Choi: And this is one way how to make a [inaudible] scheme for this
circuit. So we can prepare logical [inaudible] state for Code A and logical [inaudible]
state for Code B. And we can prepare this CAT state [inaudible]. And this is the
transporter. So we don't need to worry about that. And because this one makes some
errors -- In some pair here there is errors, so we have to do it three times [inaudible].
Every job we have to do quantum error corrections for the error corrections so that at the
end we have to apply X gates. So this is one way how to do that. But this is just one
case. Now we consider some application of this case, this idea for reduction of resource
overhead for some gates, especially T gates.
In our [inaudible] the T gate on the Bacon-Shor requires a lot of gates, a lot of qubits
because Bacon-Shor T gate is basically based on the magic state distillation protocols.
So we did some preliminary work. If you can change or if you can convert Bacon-Shor
encoded state into Reed-Muller encoded state and if you apply the Reed-Muller encoded
T gate then we can recover again into the Bacon-Shor encoded state.
But the issue is, the T gate on the Reed-Muller code is transversal. So some T gates can
be replaced by the transversal T gates on the different code. So Steane code T gate and
the Bacon-Shor T gate is non-transversal but the Reed-Muller code T gate is
transversal. So if the cost of the code conversion is similar then we can replace a BaconShor T gate into Reed-Muller T gate operations.
That's the main idea. So this is our preliminary data, but this is not precise. So our
calculations show that for the Steane code case, if we implement a T gate on the Steane
code we need this amount of resources. But if we apply code conversion and if we
replace string T into Reed-Muller T gate then we need this amount of resources. In this
case, this is not good.
But in the Bacon-Shor code -- As I told you Bacon-Shor code requires a lot of distillation
overhead so that we can replace this amount of resource overhead into a smaller one.
So if we use a Reed-Muller T gate then we just need this amount of resource overhead.
This is reasonable for conventional case resource overhead. Even if we assume that
figuratively the [inaudible] state is very high, like 1, in that case the resource overhead is
very big. But if we can use the Reed-Muller T gate, we can reduce this resource
overhead into these values.
But we can go further because Steane code T gate is much more simpler, so we can
replace again into Steane T gates. So the conclusion of this slide is if the cost code
conversion from one code to another one is smaller than some gate like a T gate then
we can replace it, we can replace the complex T gate into...
>>: [inaudible].
>> Byung-Soo Choi: Yeah.
>>: Okay.
>>: And where's the threshold -- I mean on these codes isn't the threshold for these
codes somewhere 10 to the minus 5 on the top one? Some of these error rate numbers
don't make sense because you're above the threshold you can't correct.
>> Byung-Soo Choi: Oh, yeah.
>>: So the only numbers that would make sense are the ones that are below...
>>: 10 to the minus...
>>: ...the threshold significantly...
>> Byung-Soo Choi: Probably this...
>>: ...you know, an order of magnitude below.
>> Byung-Soo Choi: Yeah.
>>: And then it looks like even using these code conversion things, the top one is still
better, right?
>> Byung-Soo Choi: Yeah.
>>: If you look at the single-code model, the resources are always smaller at the below
threshold.
>>: The 932 that you see up on top is never beat by anybody else.
>>: I mean you'd never use the Bacon-Shore code in that scenario.
>>: Right. Because even down at the bottom it's 2800 or 2600 gates.
>> Byung-Soo Choi: Yeah. Yeah. So technically we have to consider these areas, these
boundaries and these boundaries. We don't [inaudible] part.
>>: Right.
>>: And there's no benefit [inaudible].
>>: And then it seems like it's too expensive.
>>: Yeah, and that's before the cost of the code conversion.
>> Byung-Soo Choi: Yeah, so this one -- this error rate is [inaudible] either case. And
this one's [inaudible] is 1. So this is either case's cost. Even in that case, the code
[inaudible] show that [inaudible].
>>: I'm curious, do you have the same numbers for the single code model for
[inaudible]?
>> Byung-Soo Choi: Yeah.
>>: Do you know what they look like? So it looks like 932 is the best that you have here
for the Steane code. Do you know what the same number would be for Reed-Muller
code? I mean you can do T transversely in Reed-Muller and you can do -- Basically your
universal computation transversely [inaudible]...?
>> Byung-Soo Choi: No, Reed-Muller code does not allow gate H as a transposer.
>>: Well, if you're careful you actually can do it.
>> Byung-Soo Choi: Yeah. So I just combined the advantage over the codes. This
Steane code and Bacon-Shor code has advantage on the H gate and [inaudible] as a
transposer. But the Reed-Muller code shows advantage on the T gate only. The other
gates like the H gate does not allow transposing. So I just combined the advantage of
both of these.
>>: We can talk about that later. But, yeah, it would be interesting to see the numbers
[inaudible].
>> Byung-Soo Choi: And also I think these are more practical reasons. We have to
consider code conversion on the repeater part. The repeater is usually used for the
communication part and the repeater has to consider the error correction as well. So the
repeater has to consider code conversions in the near future.
So that's all my current consideration on the system part. And also I am considering
some issues on the application part. So just one extension of my previous work: I want
to know if there are quantum algorithms for resiliency and nonlinearity checking of the
Boolean functions. These two primitives are very important on the security part because
Boolean functions are used for symmetric key systems. So they want to check this
resiliency and nonlinearity as quickly as possible, but up until now there is classically
efficient way to check resiliency and nonlinearity.
Now the idea is whether the quantum computer can have them to check resiliency and
nonlinearity efficiently. But I am working with another fellow but we still found that it's not
good. "Not good" means it's not like [inaudible]. It's [inaudible].
And also I want to know [inaudible] for these problems. That means that I want to know,
what are the limitations of the quantum computations on those problems? And also we
can expand this problem into post-quantum cryptography domains. And the second one
is machine learning. So because a Boolean function can be used for cryptography and
also for machine learning, I'm considering using this algorithm for machine learning. But
I'm just starting; I don't have any idea. Ultimately, maybe, we can make a quantum Bing,
much more useful quantum Bing such algorithms.
But that's all. So currently I'm working on these issues. In the architecture I'm refining the
low-level and the high-level architecture and their scheduling and layout algorithms and
the error analysis methods. In the arithmetic part we are trying to find the best way to put
the error correction and their locations. And in the code conversation case, we tried to
check the fault tolerance level of the output circuit and also it's used on the architecture
part. And cryptanalysis and machine learning.
So this one shows my current research target; architecture level resource reduction is
my main goal by using the arithmetic and code level optimizations and also compiler
level resource optimizations. [inaudible] here so I'm considering using high-level
optimization methods in the architectural part so like vertical optimizations.
That's it. Thanks so much.
[applause]
>> KS: Do we have question for Byung-Soo?
>>: So I have a question. So you mentioned -- Okay, so you have some concatenated
code scheme. Basically what you normally do is error correction followed by the coded
gate [inaudible] error corrections. And you mentioned that you could optimize,
potentially, by eliminating some error correction steps...
>> Byung-Soo Choi: That's right.
>>: ...in specific places.
>> Byung-Soo Choi: That's right.
>>: I mean do you have a strategy for how you might go about figuring out how to do
that?
>> Byung-Soo Choi: One approach is to consider the graph theory as well. So in the
graph theory you can find that the weakest one is the congestion node. Congestion node
means this node affects all other edges or nodes. So this is a very important node.
>: So the error of that node could spread.
>> Byung-Soo Choi: Yeah. So maybe we can use that approach for that scheme.
>>: Graph centrality algorithms are extremely expensive. So depending on the size of
the unit you want to look at classical processing. It's very hard to figure that out. And in
the general case you can't solve it; you have to do it for each graph that you generate.
>> Byung-Soo Choi: Maybe we can use it, even though that case, because we just
need to optimize some component. So we just need once.
>>: For the standard block, yeah, you're going to do some specific adder or multiplier
QFT. Yes, that's the scaling...
>> Byung-Soo Choi: At the high-level maybe we don't.
>>: Do you have any intuition for how much you might save by doing such a thing? And
what kind of multiplicative factor you would get [inaudible]? I mean I suppose that would
depend on what module you're trying to optimize, right?
>> Byung-Soo Choi: Yeah. So recently there are papers already showing [inaudible].
They consider [inaudible] -- How we have two error corrections every time, those kinds
of things.
>>: Okay.
>> Byung-Soo Choi: That's [inaudible]. So they also consider these problems.
>>: [inaudible]
>>: [inaudible]
>>: What they find there is they just look at the sequence actually because of
decomposition they look at each TH or HT or our favorite sequences. And they just
basically show analytically that the maximum you can go typically is 2 or 3.
>>: [inaudible] the sequence...
>>: Yeah because...
>>: So that's for single...
>>: ...that's the lowest level sequence.
>>: Right.
>>: They just consider that sequence.
>>: Okay, so this is just...
>>: And you just consider...
>>: ...single logical qubit.
>>: Steane 713 code.
>>: Yeah.
>>: And they just say that, "Okay if I don't error correct after the H." So they look at TH,
HT, you know, different permutations of this and say, "If I don't error correct after the H
and I just error correct after HT, what happens to my [inaudible]?" And they give a table
of it. Essentially they say -- I mean to me it means maybe you save a factor of 2.
>>: Okay. And so they're not...
>>: Was my conclusion for this paper.
>>: ...And so that's for only single logical qubit. So it's even worse...
>>: And if they only [inaudible]...
>>: ...for 2 qubits...
>>: ...a single qubit....
>>: ...I would imagine --.
>>: And the other work that I know of that looked at that was out of [inaudible] group.
And they look at it in a slightly different fashion. They just consider that the error
correction tiling, kind of how often they apply error correction to the Shor code, they try
to optimize that. And I think the factor was much larger than just a factor of 2. And they
actually simulate it, I mean parts of the [inaudible]. I think it was higher, like -- I don't
want to say exactly. It was like...
>>: It wasn't that big....
>>: Okay, but it wasn't that big, though.
[simultaneous commenting]
>>: ...rather than say like a factor of like, I don't know, a hundred or something.
>>: No, this was an order of magnitude plus.
>>: Oh, really.
>>: Really?
>>: If I remember correctly in the [inaudible] paper. But they make a lot of assumptions
on the architecture. I mean it's not...
>>: Like you're not going to gage the same error or the same place...
>>: Yeah.
>>: ...with a certain delta and on and on and on.
>>: I can point you to --.
>>: That's all right. I remember that now. Yeah, if all the world is working for you while
your faults are going on then the order...
>>: Yeah.
>>: It all depends on...
>>: ...of magnitude [inaudible].
>>: ...the assumptions.
>>: Last question on that related topic, I mean do you think that that kind of same thing
could be applied to topological codes, surface code in particular?
>> Byung-Soo Choi: Honestly speaking, topological surface code is not our part. In our
project we did not consider it. But probably -- I think in the surface code we can make a
graph based on the rotation or based on the [inaudible] operations, so maybe we can
make a graph [inaudible]. So in this case the distance -- Because I think if we can put
defect as a node on the graph...
>>: What are the defect?
>> Byung-Soo Choi: Defect on the surface code. And then, the distance of the
[inaudible] operations we can make long distance edges. So maybe we can consider
that kind of information as like a weight of the edges. So in this case we do not consider
the weight of the edges or what kind of implement [inaudible] as a weight. But maybe in
that case we can put the distance as a weight for the graph then maybe we can use the
same algorithms. I mean the key idea...
>>: [inaudible] results as some point, right...?
>>: Yeah, but I think part of the problem in here is that we're only in these experiments
or simulations. People are just looking at [inaudible] and noise. And that paper from
Austin and John this morning basically shows that these [inaudible] are a huge problem
in the super-connecting qubits. And the way they propose -- I didn't read the whole paper
yet but I did read the abstraction and conclusion. And basically it seems that you have to
measure these qubits...
>>: More often.
>>: They actually want to move to maybe a full measurement [inaudible] scheme
instead because...
>>: But given the earlier assumptions before that paper.
>>: Right.
>>: I mean Austin did a bunch of work in terms of given the length between the defects,
right, how long you could wait before fixing things before you're matching with that.
Right? I mean there was a time...
>>: That's not [inaudible].
>>: Yeah, but there was a time delay depending on the depth...
>>: Yeah, it's like...
>>: ...that you could wait.
>>: ...optimally like [inaudible]...
>>: But he's assuming error correction at every...
[simultaneous commenting]
>>: No, no, you don't decode every time stamp. You error correct every time stamp.
>>: Oh, even without the decoding?
>>: Different function.
>>: Oh, that then doesn't help. Okay.
>>: But this new paper says that basically the leakage is the...
>>: Is so bad...
>>: ...problem and...
>>: Is the big thing, yeah.
>>: ...you actually need to maintain...
>>: Well, people are starting to do non-unitary noise. They're realizing, "Oh my god,
that's what's going to kill us," more than anything else.
>>: Yeah.
>>: So I don't know.
>>: So sorry for the extended question.
>> Byung-Soo Choi: No, no. That's fine. Any more questions?
>>: I guess I have one more question. On the adder circuit work when you did the
square root of N, you assume there's not change in the width for that embedding?
Because if you add more qubits, you can do it in constant time. So [inaudible]. So you
must make an assumption...
>>: Well, he had the same number of qubits that he was adding, right?
>>: Yeah, that's what I was asking just to...
>>: Right. Right.
>>: ...verify...
>>: He never went further.
>>: ...that when you do the proof, you actually add no additional qubits.
>> Byung-Soo Choi: Yes. That adder is not optimal.
>>: Yeah, it's a long way back.
>> Byung-Soo Choi: Yeah.
>>: It's okay.
>> Byung-Soo Choi: That's just like I tried to show the conceptual way how to change
the previous adders by using bus scheme. The bus scheme can reduce the delay from
[inaudible] to one. But as you know the one column requires K flow, so this requires over
ten times. So this is not the optimal one. But I just wanted to show that this is just one
way how to put the bus on the adder circuit. It's not for showing the optimal one. But
maybe we can use -- I mean if we have in the architecture a scheduler and [inaudible]
then we just need to use these tools for adder circuit. The adder circuit can be the input
for this scheduler. And we can look at the layout of the adders.
>>: Are there any other questions. Let's Byung-Soo again.
>> Byung-Soo Choi: Thanks so much.
[applause]