
English: 
- Okay. Hi, my name's Alwin Zulehner.
And I'm from Johannes Kepler
University in Linz. Austria.
And now we're getting a bit
more technically I would say,
because now we're diving into the topic
of Compiling Quantum
Circuits to NISQ Devices.
So just a brief recap,
we already heard it,
and I probably can assume that
everyone is aware of that.
NISQ stands for Noisy
Intermediate-Scale Quantum.
And for example, IBM has
some architecture for them.
And here I took IBM QX5
which is of course,
available for cloud access,
has 16 qubits,
and have there seems to be
some issues on this PowerPoint.
So you can see the error rates here,
but single-qubit gate error rate
is about 10 to the minus two.
And a multi-qubit gate
tend also, no, sorry,
same cubic gate should 10 to minus three,

Spanish: 
Hola, me llamo Alwin Zulehner y soy de la
Universidad Johannes
Kepler de Linz, Austria.
Ahora vamos a ponernos
un poco más técnicos
porque vamos a hablar de cómo
compilar circuitos cuánticos
a dispositivos NISQ.
Vamos a repasar un poco todo,
doy por hecho que todos lo sabéis.
NISQ es escala cuántica
intermedia ruidosa.
Por ejemplo, IBM tiene
arquitectura para ellos.
Y aquí tengo IBM QX5 que,
por supuesto, tiene acceso desde la nube,
tiene 16 cúbits
y parece que da problemas
en este PowerPoint.
Aquí veis los índices de error,
pero el índice de error
por cúbit individual
está entre 10 y -2.
Y una puerta multi cúbit, no, perdón,
la misma puerta cúbit debería ser 10 a- 3.

Japanese: 
「NISQデバイスへの量子回路コンパイル」
アルウィン・ズレナー
- よし。こんにちは、私はアルウィン・ズレナーです。
私はオーストリア、リンツのヨハネス・ケプラー大学から来ました。
技術的にもう少し進歩していると言えるでしょう。
現在量子回路をNISQデバイスに
組み込む話をしているのですから。
簡単に要約しますと、私たちはすでにそれを聞いてたことがあります。
おそらく誰もが知っているでしょう。
NISQはノイズあり中規模量子デバイスの略称です。
例えば、IBMにはそのためのアーキテクチャーがいくつかあります。
こちらはIBMのQX5です。
もちろんクラウドアクセス対応です。
16キュービットです。
このパワーポイントには問題があるようです。
ここに誤り率がありますが
シングル量子ビットのゲートの誤り率は
約10からマイナス2です。
マルチ量子ビットゲートは
同一の量子ビットゲートで10からマイナス3、

Japanese: 
マルチ量子ビットゲートは10からマイナス2になります。
よし。このデバイス上で回路として書かれた
アルゴリズムを実際に
実行するには
いくつかの作業が必要です。
実際には、量子コンピュータがサポートする
基本的な演算に分解しなければなりません。
これはシングル量子ビットゲートで
3つのパラメータによるアパートメントトライで
C、X、Z軸を中心とした
回転を記述しています。
もちろん2つの量子ビットゲートがありますが、
これらは基本的に制御されたNotゲートまたは
CNOTゲートとも呼ばれます。
つまり私が基本的に話している問題は、
式はまだいくつか欠けていますが、
それは以前いくつかのゲートでの
設定どおりに記述されました。
シングル量子ビットゲートがあります。
それらのボックスで視覚化されます。
そしてある種のCNOTがあり、
それらは同時に2つの量子ビットと

English: 
and multi-qubit gate to 10 to minus two.
Okay. So if we want actually to run
any sort of algorithm described
as a circuit on this devices,
then we have to do some things.
Actually we have to
decompose our operations
into elementary operations
supported by a quantum computer.
And those are single qubit gates,
which are apartment tries
by three parameters,
they are describing a rotation
about the C, X and Z axis.
And of course we have
some two qubit gates,
which are basically controlled Not gates
or also called CNOT gates.
So the problem, what I'm
basically talking about,
I mean, some formulas are still missing,
but it's spelled them before,
as set we have some sort of gates.
We have single qubit gates.
Those are visualized by those boxes.
And we have some sort of CNOTs
and those are allowed to interact

Spanish: 
Y la puerta multi cúbit, 10 a -2.
Vale. Si queremos ejecutar algún
algoritmo descrito como
circuito en estos dispositivos,
tenemos que hacer dos cosas.
Descomponer nuestras
operaciones en operaciones
elementales apoyadas por
un ordenador cuántico.
Y esas son las puertas de un cúbit,
que tienen tres parámetros:
describen una rotación sobre
los ejes C, X y Z.
Y claro, tenemos dos puertas cúbit,
que básicamente son puertas de control no
o puertas CNOT.
El problema del que hablo es que
nos siguen faltando fórmulas,
pero ya se dijeron,
y tenemos unas puertas.
Puertas de un cúbit.
Se visualizan con esos recuadros.
Y tenemos una especie de CNOTs
que pueden interactuar

English: 
with two qubits at the same time.
And as set when we want
to run anything on a device,
we have, for example, to decompose,
you can see here at toughly gate,
into a sequence of single
qubit gates and CNOTs.
And as you can see here,
this can be quite costly.
So a lot of one or two
qubit gates are needed,
but what's even more
important is that we have,
some constraints that are
given by our architectures.
And you can see there
on the right hand side,
a picture of QX5.
And basically, since
it's a physical device,
we have some restrictions
because not all qubits
are coupled with each other.
And this physical layout easily translates
to a directed graph.
And here we have visualize
qubits the physical ones,
with vertices and the
arrows indicate whether
we can apply a CNOT or not.

Spanish: 
con dos cúbits al mismo tiempo.
Y se hace cuando queremos
ejecutar algo en un dispositivo,
tenemos, por ejemplo, que descomponer,
aquí veis las puertas,
en una secuencia de puertas
de un cúbit y CNOTs.
Y como veis aquí, puede ser muy costoso.
Se necesitan muchas puertas
de uno o dos cúbits,
pero lo más importante es que tenemos
algunos límites que nos
imponen nuestras arquitecturas.
A la derecha podéis ver
una imagen del QX5.
Y como es un dispositivo físico,
tenemos restricciones
porque no todos los cúbits
están emparejados entre sí.
Este diseño físico se traduce fácilmente
a un gráfico directo.
Aquí visualizamos los cúbits, los físicos,
con vértices y flechas que indican
si podemos aplicar una CNOT o no.

Japanese: 
相互作用できます。
デバイス上で何かを実行したい時に
設定されるように、
例えば分解するため
シングル量子ビットゲートと
CNOTのシーケンスが見えるでしょう。
ご覧のようにかなりの費用がかかります。
そのため、1つまたは2つの多くの量子ビットゲートが必要になりますが、
さらに重要なのは、アーキテクチャによって
与えられる制約があるということです。
右側にQX5の
画像があります。
基本的に物理デバイスであるため、
すべての量子ビットが互いに結合されているわけではないため、
制約がいくつかあります。
この物理的な配置は有向グラフに
簡単に変換できます。
ここでは、物理的な量子ビットを頂点で視覚化しています。
矢印はCNOTを適用できるかどうかを
示しています。

English: 
So for example, this
arrow down here means,
that we can't apply a CNOT
where we have Q1 target source
and Q0 as target qubit.
And if there's no arrow
in between two qubits,
we can not interact those two.
So I call this now CNOT-constraints,
for the rest of my talk
and assume that we have given,
such a quantum circuit as shown there,
where we have some
logical qubits Q0 to Q5.
And what we want to do
is we want to map them,
onto the physical ones of the device.
So we can do it like this quite easy,
map Q0 to the physical bond to Q14,
Q1 to Q15 so on and so forth,
so we can choose whatever we want.
And if you check then
our gates, we can see,
here I highlight the control of the CNOT
with in gray and the target in blue.

Japanese: 
たとえば、この下の矢印は、
Q1の終点始点とQ0は終点量子ビットとして
CNOTを適用できないことを意味します。
2つの量子ビットの間に矢印がなければ
それらを相互作用させることはできません。
ここではこれをCNOT制約と呼びます。
これ以降の説明では、
ここに示すような
量子回路を与えたと仮定します。
ここでは、Q0からQ5までの論理量子ビットがあります。
私たちがやりたいのはそれらをデバイスの
物理的なものにマッピングすることです。
物理的結合Q0とQ14、Q1と
Q15などのようにマッピングして
簡単にできます。
そのため何でも好きなものを選べます。
ゲートを確認すると、
ここではCNOTの制御をグレー、
終点を青でハイライトしています。

Spanish: 
Por ejemplo, esta flecha
hacia abajo indica
que no podemos aplicar una
CNOT si no hay un origen Q1
y un Q0 como cúbit objetivo.
Y si no hay flecha entre dos cúbits
no podemos interactuar con estos dos.
Llamaré a esto límites CNOT
durante el resto de la charla
y daré por hecho que tenemos
un circuito cuántico como este, con
cúbits lógicos de Q0 a Q5.
Y queremos mapearlos
a los físicos del dispositivo.
Podemos hacerlo de forma bastante fácil,
mapear Q0 al vínculo físico a Q14,
Q1 a Q15, etc,
podemos elegir lo que queramos.
Y si veis nuestras puertas, veréis
que aquí resalto el control de la CNOT
en gris, y el objetivo en azul.

Spanish: 
Y si hay una flecha entre estos
dos cúbits físicos
podremos aplicar la puerta.
No hay problema con el primero,
ni con el segundo.
Pero en el tercero
tenemos un problema.
No hay conexión de Q3 a Q0
y pasa algo parecido con la cuarta puerta.
La quinta vuelve a estar bien, y vuelve
a haber un problema con la última.
Y pensaréis,
qué mala suerte,
deberíamos elegir mejor para el mapeado.
Pero el problema es que
no suele ser posible
encontrar un mapeado así.
Os podéis imaginar por qué.
Damos por hecho que todos los cúbits
tienen una CNOT con otros seis cúbits.
Así que nunca encontraréis
un punto en el gráfico
donde los podáis mapear.
Y la idea es que tenemos que cambiar,
mapear dinámicamente
durante la compilación.
Y con este fin,

English: 
And whenever there's an arrow in between
those two physical qubits,
then we can apply the gate.
So no problem for the first one,
same for the second one.
But here at the third one,
we have some sort of issue.
So there's no connection from Q3 to Q0
and similar to the fourth gate.
The fifth gate is okay
again and also again,
an issue for the last one.
So what you might think,
which has for unlucky,
we should do a better choice for mapping,
but the problem is
usually it's not possible
to find such a mapping.
You can easily imagine
why this is not possible.
So assume we have any qubit that is,
has a CNOT with assume six other qubits.
Then you will never find a spot
here on the coupling graph,
where you can map them.
And the idea now is
that we have to change,
that mapping dynamically
during our compilation process.
And to this end,

Japanese: 
この2つの物理量子ビットの間に矢印があれば
いつでもゲートを適用できます。
ですから最初のものは問題なく、
2番目も同様です。
しかし3番目は
問題があります。
Q3からQ0への接続はなく、
第4ゲートと同様です。
5番目のゲートも問題なく、
最後のゲートはまた問題です。
運が悪いと
思われるかもしれませんが、
マッピングにはより良い選択をすべきですが、
問題は通常、そのようなマッピングを
見つけられないことです。
なぜこれが不可能なのか容易に想像できるでしょう。
したがって、他6つの量子ビットを想定した
CNOTを持つ量子ビットがあると仮定します。
そうすれば結合グラフ上には、
それらをマップできる場所はまったく見つかりません。
ここでの考え方は、コンパイルプロセス中に
マッピングを動的に変更する必要があるということです。
この目的のために私たちはいわゆる

Spanish: 
buscamos operaciones SWAP o puertas SWAP.
Y esto cambia el estado
de los cúbits físicos.
Si damos por hecho que Q0
y Q1 son vínculos lógicos
que están mapeados y aplicamos SWAP,
insertamos valores.
Así que el mapeado también cambia.
Así que podemos usar
estas operaciones SWAP
para movernos por los físicos,
los cúbits lógicos sobre los físicos.
Y claro, como esta
descomposición de una puerta SWAP
también tiene que satisfacer
el mapeado de pares,
tenemos que cambiar la
dirección de la CNOT central,
y esto se hace fácilmente
insertando la operación Hadamard.
Esto es un poco más barato que usarlo.
Y esto es solo un boceto,
una forma de presentar
una solución inocente.
Pero solo miramos las
puertas de una en una,
y claro, configurar las 2
primeras no es un problema.
El problema está en
conducir una CNOT cuyo control

Japanese: 
SWAP演算やSWAPゲートを探しています。
これは基本的に2つの物理的な量子ビットの状態を変化させます。
Q0とQ1の論理結合がマッピングされ、
SWAPを適用すると仮定すると、
実際に値を挿入します。
基本的にマッピングも変更されます。
つまり、これらのSWAP演算を利用して、
物理的な量子ビットを簡単に
物理的論理量子ビットに移動できます。
もちろん、SWAPゲートのこの分解は
結合マッピングを満たすと言われているので、
中間CNOTの方向を変える必要があり、
これはHadamard演算を挿入すると
簡単です。
そのためこちらも使うより少し安いです。
ここで素朴な解決策を提示することで、
この問題がどう解決されるのかを説明します。
その時点では1つのゲートを見ているだけです。
もちろん最初の2つは問題ありません。
ここで問題となるのは、
コントロールが現在Q3にマッピングされている

English: 
we in search so-called SWAP
operations or SWAP gates.
And this basically changes the
state of two physical qubits.
And if you assume that Q0
and Q1 the logical bonds,
are mapped to them and we apply SWAP,
we actually insert values.
So basically the mapping also changes.
This means we can easily
amuse those SWAP operations
to move around the physical,
the logical qubits on the physical ones.
And of course, since this
decomposition of a SWAP gate
has also said to satisfy the coupling map,
we have to change the
direction of the middle CNOT,
and this can be easily done
by inserting Hadamard operation.
So this is a bit cheaper
than using as well.
And now I just to give you a feeling,
how this could work out by
presenting a naive solution.
So we're just looking
at one gate at the time,
and of course, a set for the
first two it's not a problem.
And now we have the problem here,
that you want to conduct
a CNOT where the control

Spanish: 
está mapeado a Q3,
pero el objetivo esté mapeado a Q1 o Q0.
Así que podemos aplicar un SWAP.
Y así movemos el control
hacia el objetivo.
Y así podemos aplicar la puerta.
Y repetimos lo mismo
en la siguiente puerta.
De nuevo, uno y dos SWAP
y podemos aplicar la puerta
y para las posibles puertas
necesitamos otro SWAP y ya está.
Es bastante fácil, pero si
recordáis cómo descomponer
una puerta SWAP,
veréis que esto es bastante costoso.
Así que en principio tenemos 6 CNOT
y después 6 CNOT más para cada SWAP,
tres CNOT más,
una sobrecarga muy grande.
La pregunta es:
¿podemos hacerlo en
una versión más barata?
Por supuesto que sí,
pero el problema es que si
queremos hacerlo muy bien,

Japanese: 
CNOTを実行したいけれど
終点がQ1またはQ0にマッピングされていることです。
ここでできるのは、SWAPを適用することです。
これにより、制御を終点に向けて移動できます。
それではゲートを適用します。
次のゲートでも同じことを繰り返します。
ここでも、1つおよび2つのSWAPに
ゲートを適用します。
次に可能なゲートを適用します。
ここでは、別のSWAPが必要です。これで完了です。
これは非常に簡単ですが、
SWAPゲートの分解方法を覚えておくと、
かなりコストがかかることがわかります。
最初は6つのCNOTしかありませんでしたが、
その後各SWAPに対する6つのCNOTに加え、
さらに3つのCNOTがあるので、
これはかなり大きなオーバーヘッドになります。
問題はこれを低価格版で
実現できるかということです。
もちろん可能ですが
問題はそれを最適に行いたければ

English: 
is currently mapped to Q3,
but the target is mapped to Q1 or to Q0.
So what we can do here is applies a SWAP,
And by this, we can move the
control towards the target.
Then we can apply the gate.
And then we just repeat the
same thing for the next gate.
Again, one and two SWAPs,
we can apply the gate
and then the gates possible,
here we need another
SWAP and then we're done.
So this is quite easy,
but if you remember how
to decompose a SWAP gates,
then you can imagine this is quite costly.
So originally we have just 6 CNOTs
and afterwards we have 6 CNOTs
plus for each of the SWAPs,
we have three more CNOTs,
So this is quite a huge overhead.
And the question is,
can we do that in cheaper version?
And of course we can,
but the problem is if we
want to do it optimally,

Japanese: 
それはNP完全問題であると言うことです。
したがってこのようなコンパイラとオーバーヘッド
削減方法のさらなる研究を活用し、
このNPを解決します。
IBMは開発者チャレンジを立ち上げ、開発しました。
ここでの目標は、特定のコスト関数に関係なく、
コンパイルの結果が最適化される回路を
最適化することです。
そしてここでCNOTに10のペナルティを与え、
シングル量子ビットゲートに対してVonのペナルティを与えます。
その理由は、 CNOTの忠実度が
単一量子ビットゲートの
忠実度より10倍悪いためです。
そのため、コンパイル回路忠実度の
最適化を目指します。
次に、右側に示すのは、
IBMが提供している6量子ビット
円形アーキテクチャなどの例です。
最後にいくつかのランダム回路はここにある

Spanish: 
hay un problema NP-completo.
Así que para apoyar más
investigaciones de los
compiladores, reducir los excesos
y resolver este problema NP-completo,
IBM ha lanzado el
desafío de desarrollador.
El objetivo es optimizar el circuito
que surge al optimizar la compilación
sin importar la función de coste.
Aquí tenemos una penalización
de 10 en las CNOT
y la de Von por puertas de un cúbit.
Y el motivo es que la fidelidad
de las CNOT es 10 veces
peor que la fidelidad
de las puertas de un cúbit.
Así que vamos a optimizar la fidelidad
del circuito de compilación.
Y por ejemplo, las arquitecturas de IBM,
como la circular de 6 cúbits
se muestran en el lado derecho.
Y por último una entrada
superficial de circuitos al azar,

English: 
then we run to issue that
it's an NP-complete problem.
So to leverage further
research on such compilers
and how to reduce the overheads,
to solve this NP-complete a problem.
IBM has launched and developed
the developer challenge.
And here the goal is that we
want to optimize the circuit
that's results from the
compilation is optimized,
regardless certain cost function.
And here we give the
penalty of 10 to the CNOTs
and the penalty of Von
for single qubit gates.
And the reason for that
is that the fidelity
of CNOT is 10 times worse than fidelity
for single qubit gates.
So we're aiming for
optimizing the fidelity
of the compile circuit.
Then some example,
architectures are given by IBM,
such as six qubit circular architecture,
is shown on the right hand side.
And finally some random
circuits surface input,

Japanese: 
入力を浮上させます。
6つの量子ビットのある円が見えるでしょう。
各層にゲートがあります。
これらのゲートはSU からのランダムサンプルです。
つまりこれはランダムな4x4のユニタリ行列で
表されるということです。
もちろん負債の分解もあります。
IBMは幸運にもそれを提供しました。
したがって、SU からの任意のゲートがあれば、
いつでもそれを3つのCNOTと7つの
シングル量子ビットゲートのシーケンスに分解できます。
ここでの課題は
右側に置かれた回路をがあり
特定のアーキテクチャにマッピングすることです。
そして今、私が考えていた解決策を提示できます。
まず回路から始めます。
私がすることは、
同じ量子ビットに適用されたゲートをグループ化し、

Spanish: 
y en cada uno podéis ver
un círculo con seis cúbits,
y en cada capa tenemos puertas
que se generan al azar desde SU ,
es decir, que se describen por 4 x 4
aleatorios, una matriz unitaria.
Y luego está la descomposición
por deuda, claro.
IBM por suerte contaba con esto.
Así que si tienes una
puerta arbitraria de SU ,
siempre podrás descomponerla
en una secuencia
de tres CNOT y siete puertas de un cúbit.
Y ahora tenemos
el circuito del lado derecho y
queremos mapearlo a esta arquitectura.
Os doy la solución que tengo en mente.
Primero empiezo con el circuito.
Lo que hago es
agrupar las que se aplican
a los mismos cúbits,

English: 
where each of those had here,
you can see a circle with six qubits
and in each layer we have and have gates
and those gates are
randomly sample from SU(4),
which means that they are
described by a random four
by four, a unitary matrix.
And of course there's again,
that decomposition for debt.
IBM has fortunately given that.
So if you have an
arbitrary gate from SU(4),
then you can always
decompose it into sequence
of three CNOTs and seven
single qubit gates.
And what the task is now,
is we have that circuit
given on the right hand side,
and we want to map it to
the given architecture.
And now I can present you the
solution that I had in mind.
So first I start with the circuit.
And what I do is,
I group gates that are
applied to the same qubits,

Japanese: 
基本的にこれまで見てきた分解を元に戻します。
これでコンパイル時間を大幅に短縮できるのです。
そこで私はこれらのグループを作り
回路を相互作用グラフや
従属グラフのようなものに変えました。
G0から1、2のグループは、
第1層の3つのゲートを表します。
そしてもちろんその後で
同じ量子ビットを演算しているなら
次の層のゲートを適用して
最終層のゲートを適用できます。
ここで考えられていたのは、
任意のマッピングから始めるということです。
特にランダムな回路を考えると、
最初のマッピングはそれほど重要ではありません。
なぜなら、SWAPの演算をたくさん必要とするからです。

English: 
basically this undoes the
decomposition seen before,
but this allows to reduce the
compile time significantly.
So what I did is I formed those groups,
and I just then transformed the circuit
into some sort of interaction
graph or dependency graph.
So the groups G0 to one to two stands for,
the three gates of the first layer.
And of course after those,
if they're depend
operating the same qubits,
we can apply the gates of the next layer
and then the gates of the final layer.
And what the idea was now is,
that we start with an arbitrary mapping,
because especially if we
consider random circuits,
then the initial mapping
doesn't matter too much,
because you need a lot of
SWAP operations anyways.

Spanish: 
y así se deshace la
descomposición anterior
pero podemos reducir mucho
el tiempo de compilación.
Así que creé estos grupos
y transformé el circuito en una especie de
gráfico de interacción o dependencia.
Así que los grupos G0 de uno a dos son
las tres puertas de la primera capa.
Y claro, después,
si dependen de operar los mismos cúbits,
podemos aplicar las puertas
de la siguiente capa,
y después las puertas de la capa final.
Y la idea es
empezar con un mapeado arbitrario,
sobre todo si consideramos
los circuitos aleatorios,
el mapeado inicial no importa mucho,
porque necesitas muchas
SWAP de todas formas.

English: 
And so then our own or my algorithm
was basically separated into three steps.
We had to pre-processing,
Then we have the compilation algorithm,
where we first search for
groups that can be applied next.
So for our initial mapping,
we can immediately map those gate groups.
Then, as a next step,
we look for groups that
could be applied, next.
Those are now highlighted in blue.
And the problem here is that,
we cannot directly apply them,
because the conditions of the coupling map
are not satisfied.
So we call our A* based search algorithm
that finds a permutation,
so SWAP gates that allows to
map at least one of the groups.
In this case, it finds a solution
where both groups can be mapped.

Japanese: 
私たちのアルゴリズムは
基本的に3つの段階に分けられました。
前処理が必要でした。
次にコンパイルアルゴリズムがあります。
次に適用できるグループを最初に検索するのです。
最初のマッピングでは、
これらのゲートグループをすぐにマッピングできます。
次に次のステップとして、
適用可能なグループを探します。
これらは青色でハイライトされます。
ここでの問題は、
結合画像の条件が
満たされていないので、
それらを直接適用できないことです。
そこで、私たちは順列を見つける
A*ベースの検索アルゴリズムを呼びだします。
従って、SWAPゲートはグループの少なくとも1つのマッピングを可能にします。
この場合両方のグループを
マッピングできるソリューションが見つかります。

Spanish: 
Así que mi algoritmo se
separa en tres pasos.
Hemos tenido que preprocesar.
Después tenemos el
algoritmo de compilación,
cuando buscamos los
siguientes grupos a aplicar.
Para nuestro mapeado inicial
podemos mapear inmediatamente
estos grupos de puertas.
Y el siguiente paso es
buscar grupos que podamos aplicar.
Están resaltados en azul.
Y el problema es que
no podemos aplicarlas directamente
porque las condiciones
del mapeado por pares
no se cumplen.
Usamos nuestro algoritmo de búsqueda A*
que encuentra una permutación,
y las puertas SWAP permiten
mapear al menos un grupo.
En este caso, encuentra una solución
en la que se mapean los dos grupos.

English: 
And then we just repeat our algorithm
until we map all the groups.
So again, we determined
which operations could be,
or which groups could be applied next,
highlighted in blue.
We call the mapper,
which just finds a solution with one SWAP,
and then we can apply group G6.
So we have to call our mapper again,
those are the potential
groups to be mapped next.
And after applying bond word SWAP gate,
we can compile all those
groups and sobers on.
So this basically generates a circuit
where all the set is
constraints are satisfied.
However, we can do it even better.
And for that, we do some
post-mapping optimization
where we Re-group again.
So we consider gates actionably
same qubits as a group,
and we Re-compile those groups.
So for example, if you consider
the box highlighted in red,

Japanese: 
すべてのグループをマッピングするまで
アルゴリズムを繰り返します。
そこでどの演算を次に適用するか、
またはどのグループを次に適用するかを
青色でハイライトして決定しました。
マッパーを呼びだし、1つのSWAPで
ソリューションを見つけ、
グループG6を適用します。
このため、再度マッパーを呼び出す必要があります。
これらは次にマッピングされる可能性のあるグループです。
本当のSWAPゲートを適用すると、
これらのグループと地道なものをすべてまとめられます。
これは基本的に全ての集合が
制約を満たす回路を生成します。
しかし、私たちはもっとうまくできます。
そのためにマッピング後の最適化を行い
再度グループ化します。
そこでゲートをグループと同じ量子ビットとみなし、
それらのグループを再コンパイルします。
たとえば、赤でハイライトされているボックスは

Spanish: 
Y después repetimos el algoritmo
hasta mapear todos los grupos.
Así que volvemos a determinar
qué operaciones se harán
o qué grupos se aplicarán a continuación,
resaltados en azul.
Lo llamamos el mapeador,
que encuentra una solución con una SWAP
y así podemos aplicar el grupo G6.
Así que usamos otra vez el mapeador,
estos son los grupos posibles para mapear.
Y después de aplicar la
puerta SWAP de vínculo,
compilamos todos esos grupos.
Así se genera un circuito
donde se cumplen todos los límites.
Pero podemos hacerlo incluso mejor.
Y para ello hacemos una
optimización post-mapeo
y volvemos a reagrupar.
Así que consideramos los
mismos cúbits como un grupo
y volvemos a recompilar esos grupos.
Por ejemplo, si pensamos
en el recuadro rojo,

Spanish: 
es un grupo de puerta SU de SU ,
seguido de una operación SWAP.
Si lo dibujas, esta parte de aquí,
la versión descompuesta de esta parte,
verás que está compuesto de seis CNOT
y siete puertas de un cúbit.
Pero sabemos que cualquier
matriz unitaria de
dimensión 4x4 se puede descomponer en
tres CNOT y siete puertas cúbit CNOT.
Así que si recompilamos,
solo tenemos que ajustar los parámetros,
queremos usar siete,
y después asegurar nuestra puerta SWAT.
Así que algunas puertas SWAP
son gratis, si haces esta recompilación.
Y lo bueno es que
ya sabemos eso durante la compilación.
Así que si sabemos que
hacemos un post-mapeado,

English: 
this is a group from
SU(4) a gate from SU(4),
followed by a SWAP operation.
And if you draw it, this part here,
the decomposed version of this part,
then you can see this is
actually composed of six CNOTs
and seven single cubic gates.
However, as we know any unitary matrix
of dimension four by four
can be decomposed into,
three CNOTs and seven CNOT cubic gates.
So what we do, if we Re-compile,
we just have to adjust the parameters for,
you want to use seven,
and then safe our SWAP gate.
So this means that some of the SWAP gates,
are basically for free, if
you do this Re-compiling.
And the nice thing about it,
is actually that we already
know that during compilation.
So if we are aware that
we perform a post-map,

Japanese: 
SU からのグループ、SU からのゲート、
続いてSWAP演算です。
この部分を分解して描いてみると
これが6つのCNOTと
7つのキュービックゲートで
構成されていることがわかります。
しかし4x4次元のユニタリ行列は
3つのCNOTと7つのCNOT立方ゲートに
分解できることがわかっています。
つまり再コンパイルした場合、
パラメータを調整するだけで、
7を使用して、
SWAPゲートを安全にできます。
つまり、この再コンパイルを行えば、
SWAPゲートのいくつかは基本的に無料です。
これの良いところは
コンパイル時に既にわかっていることです。
したがって、マッピング後の最適化である

Japanese: 
ポストマップを実行することがわかっていれば、
すぐにコンパイラに組み込むことができ、
その結果、既知のSWAPゲートのいくつかが
優先され
それらは後でキャンセルされます。
次に、QISKitコンパイラーとの
比較を少し紹介します。
これはバージョン4.0.4ポンド15のコンパイラです。
繰り返しますが、
私はIBMが提供する回路とアーキテクチャを使いました。
たとえば、ここでは、5量子ビットアーキテクチャの結果が
少し不明瞭です。
ここではQISKitコンパイラのコストを
X軸に、コンパイラのコストを
Y軸にプロットしました。
これは、主対角線の下にデータポイントがあれば
いつでも私のコンパイラーの方が
IBMよりも優れているということを意味します。
さらに、コンパイル前の回路のコストを示す
水平線と垂直線も

Spanish: 
una optimización post-mapeo posterior,
podemos incorporarlo de
inmediato a nuestro compilador
y esto prefiere algunas
de las puertas SWAP
que sabemos que
pueden volver a cancelarse más tarde.
Ahora quiero enseñaros
una pequeña comparación
con el compilador QISKit.
Este es el compilador de
la versión 4.0.4. libra 15.
Y de nuevo,
usé circuitos y arquitecturas de IBM.
Y aquí podéis ver los resultados.
Es un poco borroso,
arquitecturas de 5 cúbits.
Lo que hice fue planear los costes
del compilador QISKit en el eje X
y el coste de mi compilador en el eje Y.
Así que siempre que haya un punto de datos
debajo de la diagonal principal,
mi compilador funciona mejor que IBM.
Y además,
también tracé líneas
horizontales y verticales

English: 
a post-mapping optimization afterwards,
we can immediately incorporate
that into our compiler
and by that this prefer
some of the SWAP gates,
for which we know that,
they will be canceled out later again.
So then I want to show you,
a small comparison to the QISKit compiler.
And this is the compiler
of version 4.0.4 pound 15.
And again,
I used circuits and
architectures provided by IBM.
And for example, here,
you can see results for,
this is a bit blurry, for
5 qubit architectures.
So what I did here is I plot the cost
for the QISKit compiler on the X axis
and the cost for my
compiler on the Y axis.
This means whenever there's a data point,
underneath the main diagonal,
that my compiler performed
better than IBMs.
And in addition to that,
I also plotted horizontal
and vertical lines,

Spanish: 
que indican los costes del
circuito antes de la compilación.
Y es bastante interesante ver
que con la optimización post-mapeado
es incluso posible generar
o compilar circuitos,
más baratos que los originales.
No contaba con esto.
Después hicimos lo mismo con
arquitecturas de 16 cúbits.
Y volvió a pasar algo parecido,
siempre nos va mejor que
con un compilador QISKit.
Pero lo más interesante es que
en función de la arquitectura,
los circuitos tienden a agruparse.
Por ejemplo, aquí a la derecha,
los puntos rojos indican
una arquitectura lineal.
Y claro, si solo tienes
unas pocas conexiones
permitidas entre los cúbits,
el coste de compilación se disparará.
Y por último también tenemos resultados
de arquitecturas de 20 cúbits.
Se parecen mucho a las de 16 cúbits.
Y para esta compilación no solo

English: 
which indicate the cost of the
circuit before compilation.
And this is quite interesting to see here,
that with the post-mapping optimization,
it's even possible to
generate or compile circuits,
that are cheaper than the original ones.
So this was actually quite unexpected.
Then we did the same for
16 qubit architectures.
And again, similar thing here,
we are always better
than a QISKit compiler.
However, what's also very
interesting to see here,
is that dependent on the architecture,
the circuits tend to group.
So for example, on the
right hand side here,
the red dots indicate
a linear architecture.
And of course, if you just
have very few connections
between the qubits that are allowed,
then we have a very huge
overhead cost by compilation.
And finally also have some results
for a 20 cubit architectures.
And those look pretty
similar to the 16 qubit ones.
And for compilation,

Japanese: 
プロットしました。
興味深いことに
マッピング後の最適化によって
回路の生成やコンパイルが可能になりました。
元の回路よりも安価です。
これは全く予想外でした。
次に、16量子ビットアーキテクチャについても同じことを行いました。
ここでも同様に、
QISKitコンパイラよりも常に優れています。
しかし、ここで非常に興味深いのは、
アーキテクチャに依存して、
回路がグループ化する傾向にあることです。
例えば右側の赤い点は
直線的な構造を表しています。
そしてもちろん、許可されているキュービット間の
接続が非常に少ない場合には、
コンパイルによるオーバーヘッドが非常に大きくなります。
そして最後に、 20量子ビットアーキテクチャに対する
いくつかの結果も得られています。
これは16量子ビットのものとよく似ています。
コンパイル時には、

English: 
not only the quantity of
the compile circuit matters,
but also a compilation speed.
And for example, compared for
the 20 qubit architectures,
we also achieved a speed up
of, up to a factor of 35.
So also quite a good improvement here.
And if you're interested in
more details of this method,
there I've written a paper about that,
and it has been accepted and presented
to this year at the ASP-DAC in Tokyo.
And if you want to talk
more about my methods,
you can of course ask questions in,
for example, the unconference sessions.
So this is about my solution
for the developer challenge,
and just to give you a brief outline,
what we're also doing at the university
is that we have some other directions,
where we have for example,
synthesis of pooling components
for quantum computing,

Japanese: 
コンパイル回路の量だけでなく、
コンパイル速度も重要です。
たとえば、20量子ビットアーキテクチャと比較すると、
速度は35まで向上しています。
ここでもかなり改善されています。
この方法の詳細に興味がある方は
こちらで論文を書いたのですが
今年東京のASP-DACで
発表されました。
私の方法についてもっと話したい場合は、
例えば非カンファレンスのセッションで
質問することもできます。
これは開発者の課題に対する私の解決策です。
簡単に概要を説明するため
私たちが大学で行っていることは
他の方向性も持っているということです。
例えば
量子コンピューティングのためのプーリング部品の合成や

Spanish: 
importa la cantidad de los circuitos,
también la velocidad de compilación.
Por ejemplo, en comparación
con las arquitecturas de 20
cúbits, también logramos
una velocidad de hasta un
factor 35. Una gran mejora.
Si queréis saber más sobre este método,
he escrito una tesis sobre ello
que ha sido aceptada y presentada
al ASP-DAC de Tokio de este año.
Y si queréis, podéis hacerme más
preguntas sobre mis métodos,
por ejemplo, en conferencias.
Y esta es mi solución para
el desafío de desarrollador,
y sin extenderme mucho,
os digo que en la
universidad también hacemos
cosas en otras direcciones,
donde por ejemplo, tenemos
síntesis de almacén de
componentes para computación

English: 
where we have some sort
of a new of design flow.
And also we do some simulation.
So we have here a new method
where we basically try,
to decrease the memory overhead
by using some clever data-structures,
which in some case turns
out to be really efficient.
And what's nice about this is that,
it's currently been integrated
into QISKit as well as an add on.
And I also want to thank the guys from IBM
for helping with that integration.
So that's all from my
site and I'll hand over.

Spanish: 
cuántica, y un nuevo flujo de diseño.
Y algunas simulaciones.
Estamos probando un nuevo método para
reducir el exceso de memoria
por medio de estructuras
de datos inteligentes,
y algunas han resultado muy eficaces.
Y lo bueno es que
se están integrando en
QISKit como un complemento.
También quiero dar las
gracias a la gente de IBM
por ayudarnos con esa integración.
Y con esto termino.

Japanese: 
新しい設計フローなどです。
シミュレーションも行います。
そこで、ここでは新しい方法を使用して、
賢いデータ構造で
メモリのオーバーヘッドを削減します。
これは場合によっては非常に効率的であることがわかります。
これの良いところは、
現在QISKitとアドオンに
統合されていることです。
また、この統合を支援してくれた
IBMの皆さんにも感謝したいと思います。
以上が私の拠点からの情報です。お渡ししましょう。
