Tech記事

Cirqでベル状態を作って学ぶ量子コンピューティング

Cirqは、NISQ(Noisy Intermediate-Scale Quantum Computer)向けの量子回路を作成、編集、実行するためのPythonフレームワークです。NISQは直訳すると「ノイズあり中間スケール量子コンピュータ」です。

この記事では、量子ゲートの基本的な計算を理解するために、Cirqでベル状態をシミュレーションすることを目指します。なるべく難しい話は避けて、数式は途中式を省かず、量子ゲートの働きを理解しやすいように説明していきたいと思います。

Cirqとは

量子コンピュータが古典的コンピュータではシミュレーション不可能な性能を発揮することをQuantum Supremacy(量子超越性)といいます。数年内に、「特定のアルゴリズムに関する量子超越性が実証される」のではないか、という関心が高まっています。

古典的コンピュータや通信と同様に、量子コンピュータでもノイズエラーが発生します。現在の量子コンピュータはノイズによるエラーを訂正するには量子ビット数が少なすぎるため、十分にスケールしません。

しかし近年、ノイズエラーの訂正が完全でなくとも、量子ビット数がある程度あれば、「特定のアルゴリズムにおいて」は量子超越性を実証できる可能性が指摘されています。このような弱い量子コンピュータをNISQ(Noisy Intermediate-Scale Quantum Computer)といいます。以前は49量子ビットあれば量子超越性を示せるという見解をGoogleの研究チームは示していましたが、古典的スーパーコンピュータが49量子ビットをシミュレーションできたとする実験結果もあり、まだ決着はついていません。

Googleは、(少なくとも発表されているものとしては、)FluxmonGmonXmonの三種類の量子コンピュータチップを開発しています。物理的なアーキテクチャが異なりそれぞれに特徴がありますが、特にXmonはゲートコンピューティングに適したエラー訂正を必要とするタイプのアーキテクチャで、以前には22量子ビットのXmonチップであるFoxtailを開発しています。さらに、2018年の3月にはBristlecone1と名付けられた72量子ビットを持つチップを発表しています。これは、昨年トップのIBMの50量子ビットを大きく上回る量子ビットの数です。もちろん、量子ビットの数が全てではないのですが、とても大きなインパクトのあるニュースでしたね。

そして、2018年7月に、Cirqのパブリックアルファ版が公開されました。

Cirqは抽象化された量子回路を作成し、実際のアーキテクチャやそのシミュレータで実行可能なオペレーションにコンパイルし、最適化します。すでにXmonアーキテクチャのシミュレータを実装しており、将来的な実機での利用を想定していることが見て取れるAPI設計になっています。いずれ他のアーキテクチャや、実機やクラウド提供での実行もサポートしていくと考えられます。

Cirqの使い方

CirqはPython環境があればすぐに始められます。pipコマンドでインストールしましょう。プラットフォームによっては追加の作業が必要になりますが、詳細はドキュメントを参照してください。

$ pip install -Uq cirq

PythonでCirqを使うときは、cirqモジュールをインポートします。

import cirq

ここからは、実際のコードを見ながらCirqの使い方を確認していきましょう。

量子回路

Cirqで回路を作るためには、以下の要素を理解する必要があります:

  • Qubit: 量子ビット
  • Operation: 量子ビットの操作
  • Moment: オペレーションのタイムスライス
  • Circuit: モーメントのシーケンスで構成される量子回路

量子回路は、1つ以上の量子ビットに対する量子ゲートのシーケンスです。しばしば以下のような図で表されます:

これは例であり回路に意味はありません。この場合は2つの量子ビット(Qubit)$Q_0$,$Q_1$があります。この図は、2本の線がそれぞれの量子ビットの時間的発展の時間軸を示しています。

この図では量子ビットに対する作用が4種類使われています。$H$,$Z$,$X$と、2つの量子ビットを結ぶ$CNOT$です。量子ビットに対する作用をオペレーションと呼びます。オペレーションは、単一または複数の量子ビットに対する作用であり、その中でも量子ゲートは最も一般的なオペレーションです。

回路図を時間軸で見たときのタイムスライスを、モーメントといいます。この場合、モーメントは$H \otimes I$と、$CNOT$と、$X \otimes Z$の、3つとなります。モーメントは量子ゲートによる量子ビットの時間的発展の「抽象的な」タイムスライスであり、ハードウェアまたはシミュレータ上のスケジューリングに直接引き継がるものではありません。ゆえに同一のモーメント内のオペレーションが実際のデバイスで同時発生するようにスケジュールされる保証はありませんが、回路上のモーメントが示すトポロジカルな順序は守られます。

Cirqでの実装

まず量子ビットを作成します。量子ビットは一意なIDを持ちます。作り方は様々です。

cirq.LineQubit(3) # 整数ID
cirq.GridQubit(2, 1) # 2つの整数のID
cirq.NamedQubit('somename') # 文字列ID

どれで作っても構いませんが、重要なのは量子ビットがどういう順序で回路に与えられるかです。Cirqでは、cirq.QubitOrderか量子ビットのリストで順序を制御します。実際の量子コンピュータでは、ハードウェア上の制約や実行パフォーマンスなどのためにその配置が重要になるケースがあります。シミュレータしかないので現時点ではあまり意識する必要はありません。

なお、以下のコードでは、LineQubitで定義し、IDの順番のリスト(インデックス=IDとなるようにします)で順序を制御します。

まずはN個の量子ビットのリストQを作成してみましょう:

N = 2
Q = [cirq.LineQubit(i) for i in range(N)]

次に、先程の例の図の回路を作ります。作り方はfrom_opsを使う方法と、appendで追加する方法があります。回路は、print関数などにより、テキストダイアグラムで表示することができます。

C = cirq.Circuit.from_ops(
  cirq.H(Q[0]),
  cirq.CNOT(Q[0], Q[1]),
  cirq.X(Q[0]),
  cirq.Z(Q[1]),
)

# または
C = cirq.Circuit() # 空の回路の作成
C.append([
  cirq.H(Q[0]),
  cirq.CNOT(Q[0], Q[1]),
  cirq.X(Q[0]),
  cirq.Z(Q[1]),
])

print(C) # 回路をテキストで表示

回路図が以下のように出力されるはずです:

0: ───H───@───X───
          │
1: ───────X───Z───

Google Xmonシミュレータで実行

シミュレータには、simulaterunの2つの実行方法があります。もちろん、シミュレータで実行する以上はどちらもシミュレーションですが、前者は任意の量子状態を与えたり、本来なら観測で壊れてしまう量子状態の値を取得することができたりと、デバッグ用途に向いています。

ただし、量子コンピュータデバイスによってサポートされる演算は限られるため、回路は実行前にプリセットの量子ゲートの組合せに変換、最適化されます。当然ながら観測結果が変わるようなことはありませんが、デバイスの慣例による絶対位相差によって、simulateで取得できる内部状態の値は変わる可能性があります。simulateはあくまでも小さな回路のデバッグ用途であって、実際にはrunによる検証が推奨されます。

以後、頻繁にシミュレータで回路を実行するので、Xmonシミュレータを作成し、simulaterunを実行し、結果をテキストとグラフで出力する関数を定義しておきます。

まず実行に必要な設定をします(ここはCirqとは関係ありません):

import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['figure.figsize'] = (6, 4)
plt.rcParams['figure.dpi'] = 200
repr_bin = lambda N, x: ('{:0%d}'%N).format(int(bin(x)[2:]))

# シミュレーション結果を表示する関数
def plot_results(circuit, N, simulated, ran, repetitions, name):
  title = 'Results of "{}"'.format(name)
  bins = np.arange(2**N)
  labels = [repr_bin(N, i) for i in bins]
  probs = np.asarray([np.power(np.abs(s),2) for s in simulated.final_state])
  hist = ran.histogram(key='m')
  for i in bins:
    hist.setdefault(i, 0)
  print('----- {} -----'.format(title))
  print('Circuit:')
  print(circuit)
  print('')
  print('Simulation:')
  for i, p in enumerate(probs):
    print(' {} : {:>7.2%}'.format(labels[i], p))
  print('')
  print('Run(repetitions={})'.format(repetitions))
  for i in bins:
    print(' {} : {:>4}'.format(labels[i], hist[i]))
  plt.title(title)
  plt.yticks(bins, labels)
  plt.barh(bins - 0.2, hist.values(), height=0.2, align='edge', label='measure')
  plt.barh(bins, probs * repetitions, height=0.2, align='edge', label='expect')
  plt.legend(loc='best')
  plt.ylim(ymax=-0.4, ymin=2**N-0.6)
  plt.show()

次に、Cirqを使ってシミュレーションを実行するrun関数を定義しておきます:

def run(circuit, qubits, repetitions=1000, enable_plot=True, name=None):
  """ 回路の実行

  与えられた回路の最後にすべてのQubitの観測を追加し、
  Xmonシミュレータで反復実行した結果を返します

  Args:
    circuit: 実行する回路
    qubits: 最後に観測するQubitのリスト
    repetitions: 反復回数(デフォルト: 1000)
    enable_plot: グラフをプロットする(デフォルト: True)
    name: 表示する文字列
  """
  def _simulate():
    simulator = cirq.google.XmonSimulator()
    return simulator.simulate(circuit.copy(), qubit_order=qubits)
  def _run():
    # すべてのQubitの観測を回路のコピーに追加します
    # measureの引数keyに与えた名前であとから参照できます
    C = circuit.copy()
    C.append(cirq.measure(*qubits, key='m'))
    simulator = cirq.google.XmonSimulator()
    return simulator.run(C, repetitions=repetitions, qubit_order=qubits)

  s, r = _simulate(), _run()
  if enable_plot:
    # 結果を表示する
    plot_results(circuit, len(qubits), s, r, repetitions, name)
  return s, r

では、1量子ビットを観測する空の回路を実行してみましょう!

N = 1
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit()
_ = run(C, Q, name='Empty Circuit')

出力は以下のようなものを得るでしょう:

----- Results of "Empty Circuit" -----
Circuit:


Simulation:
 |0> : 100.00%
 |1> :   0.00%

Run(repetitions=1000)
 |0> : 1000
 |1> :    0

シミュレーション結果は、$\ket{0}$の観測確率が100%となり、実際に1000回の反復実行の結果は100%の割合で$\ket{0}$を得ました。現在、Xmonシミュレータはノイズを想定していないので、多くの場合はシミュレーションの期待値通りの結果を得ますが、実際のデバイスでは、多くの場合はノイズエラーにより、この通りの観測結果が得られるわけではありません(例えば、数%の確率で$\ket{1}$が観測されたりします)。

上記の結果より、天下り的にもわかることですが、量子ビットの初期状態は$\ket{0}$です。

$N$ビットの量子状態ベクトル$\ket{\psi}$は、直交正規性を満たす$\ket{0},\ket{1},\cdots,\ket{2^N-1}$を基底とする$2^N$次元複素数ベクトルでした。

$$ \begin{eqnarray}
\ket{\psi} &=& c_0 \ket{0} + c_1 \ket{1} + \cdots + c_{N-1} \ket{2^N-1}
&=& \begin{pmatrix} c_0 \\ c_1 \\ \vdots \\ c_{2^N-1} \end{pmatrix} \
\quad c_k \in \mathbb{C}
\end{eqnarray} $$

ただし、$\sum_{k=0}^{2^N-1}{|c_k|^2} = 1$です。

回路の初期状態は$\ket{0}$です。1量子ビットの回路の初期状態$\ket{0}$の初期状態は以下のようになります:

$$ \ket{0} = \begin{pmatrix} 1+0i \\ 0+0i \end{pmatrix} $$

$\ket{0}$が観測される確率は$|1+0i|^2 = 1$、$\ket{1}$が観測される確率は$|0+0i|^2 = 0$ですから、実行結果と一致しました。

1-qubitに作用する基本的な量子ゲート

基礎的な単一量子ビットに対する量子ゲートを式とCirqの実行結果で確認してみましょう。

$X$ゲート

量子ゲートの中でも最も基本のゲートの1つに、$X$ゲートがあります。NOTゲートBit FlipperPauli-$X$ゲートなどとも呼ばれます。

$X$ゲートのユニタリ行列は以下のようなものです:

$$ X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} $$

$\begin{pmatrix} \alpha \\ \beta \end{pmatrix}$を入力とすると、

$$ \begin{eqnarray}
X \begin{pmatrix} \alpha \\ \beta \end{pmatrix}
&=& \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}
\begin{pmatrix} \alpha \\ \beta \end{pmatrix} \\
&=& \begin{pmatrix} \beta \\ \alpha \end{pmatrix}
\end{eqnarray}$$

となります。よって、$X\ket{0} = \ket{1}$、$X\ket{1} = \ket{0}$となります。

初期状態$\ket{0}$で、$X$ゲートを適用する回路を実行してみましょう。

N = 1
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.X(Q[0]) # Xゲートを、0番目のqubitに作用します
)
_ = run(C, Q, name='X|0>')
----- Results of "X|0>" -----
Circuit:
0: ───X───

Simulation:
 |0> :   0.00%
 |1> : 100.00%

Run(repetitions=1000)
 |0> :    0
 |1> : 1000

実際に、$X\ket{0} = \ket{1}$となることが確認できました。

$Z$ゲート

$Z$ゲートは、しばしば位相反転ゲートPauli-$Z$ゲート$R_1$ゲートとも呼ばれます。

$Z$ゲートのユニタリ行列は以下のようなものです:

$$ Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} $$

$\begin{pmatrix} \alpha \\ \beta \end{pmatrix}$を入力とすると、

$$ \begin{eqnarray}
Z \begin{pmatrix} \alpha \\ \beta \end{pmatrix}
&=& \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}
\begin{pmatrix} \alpha \\ \beta \end{pmatrix} \\
&=& \begin{pmatrix} \alpha \\ -\beta \end{pmatrix}
\end{eqnarray}$$

となります。よって、$Z\ket{0} = \ket{0}$、$Z\ket{1} = -\ket{1}$となります。実行してみましょう。

$Z \ket{0}$の結果

N = 1
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.Z(Q[0]),
)
_ = run(C, Q, name='Z|0>')
----- Results of "Z|0>" -----
Circuit:
0: ───Z───

Simulation:
 |0> : 100.00%
 |1> :   0.00%

Run(repetitions=1000)
 |0> : 1000
 |1> :    0

$Z \ket{1}$の結果

N = 1
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.X(Q[0]),
  cirq.Z(Q[0]),
)
_ = run(C, Q, name='Z|1>')
----- Results of "Z|1>" -----
Circuit:
0: ───X───Z───

Simulation:
 |0> :   0.00%
 |1> : 100.00%

Run(repetitions=1000)
 |0> :    0
 |1> : 1000

位相は観測不可能なので、測定結果からは違いがわかりません。

Hadamardゲート

Hadamard(アダマール)ゲートは、量子のSuperposition(重ね合わせ)状態を作る基本的なゲートです。$H$ゲートとも呼びます。

$H$ゲートのユニタリ行列は以下のようなものです:

$$ H = {1 \over \sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} $$

$\begin{pmatrix} \alpha \\ \beta \end{pmatrix}$を入力とすると、

$$ \begin{eqnarray}
H \begin{pmatrix} \alpha \\ \beta \end{pmatrix}
&=& {1 \over \sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}
\begin{pmatrix} \alpha \\ \beta \end{pmatrix} \\
&=& {1 \over \sqrt{2}} \begin{pmatrix} \alpha + \beta \\ \alpha – \beta \end{pmatrix} \\
&=& {1 \over \sqrt{2}} \Bigl\{
\alpha \begin{pmatrix} 1 \\ 1 \end{pmatrix}
+ \beta \begin{pmatrix} 1 \\ -1 \end{pmatrix}
\Bigr\} \\
&=& {1 \over \sqrt{2}} \Bigl\{
\alpha (\ket{0} + \ket{1}) + \beta (\ket{0} – \ket{1})
\Bigr\} \\
&=& \alpha \Bigl\{
{1 \over \sqrt{2}} (\ket{0} + \ket{1})
\Bigr\} + \beta \Bigl\{
{1 \over \sqrt{2}} (\ket{0} – \ket{1})
\Bigr\}
\end{eqnarray} $$

となります。${1 \over \sqrt{2}} (\ket{0} \pm \ket{1})$は、$\ket{0}$と$\ket{1}$の状態が、等しく$\bigl|{1 \over \sqrt{2}}\bigr|^2 = {1 \over 2}$の確率で重ね合わさった状態です。これをSuperposition(重ね合わせ)状態といいます。計算基底から$\ket{\pm}$基底への変換とみなすこともできます。

${1 \over \sqrt{2}} (\ket{0} \pm \ket{1})$は頻繁に用いられるため、しばしば以下のように$\ket{\pm}$で表記されることもあります。

$$ \begin{eqnarray}
\ket{+} = {1 \over \sqrt{2}} (\ket{0} + \ket{1}) \\
\ket{-} = {1 \over \sqrt{2}} (\ket{0} – \ket{1}) \\
\end{eqnarray} $$

これを用いると、$H \begin{pmatrix} \alpha \\ \beta \end{pmatrix} = \alpha \ket{+} + \beta \ket{-}$と書けます。

$\ket{0}$または$\ket{1}$が入力の場合は以下のとおりです。

$$ \begin{eqnarray}
H \ket{0} &=& \ket{+} \\
H \ket{1} &=& \ket{-}
\end{eqnarray}$$

$H\ket{0}$と$H\ket{1}$はいずれも$\ket{0}$と$\ket{1}$が50%の確率で観測されることが期待されます。ためしに$H\ket{0}$を実行してみましょう。

N = 1
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.H(Q[0]),
)
_ = run(C, Q, 1000, name='H|0>')
----- Results of "H|0>" -----
Circuit:
0: ───H───

Simulation:
 |0> :  50.00%
 |1> :  50.00%

Run(repetitions=1000)
 |0> :  504
 |1> :  496

たしかに約50%の割合で観測されました。コイントスをすると(おそらく)表と裏が50/50で出るのと同じように、観測をすると50/50で$\ket{0}$か$\ket{1}$が出る様子から、これを「量子コイン」と呼ぶこともあります。

2-qubitsに作用する基本的な量子ゲート

次は、2-qubitsに作用する基本的な量子ゲートを確認しましょう。

$CNOT$ゲート

$CNOT$ゲートは、Control-NOT(制御NOT)ゲートのことです。Control-X(制御X)ゲートともいいます。

$CNOT$のユニタリ行列は以下のように定義されます:

$$ CNOT = \begin{pmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 0 & 1 \\
0 & 0 & 1 & 0
\end{pmatrix} $$

2qubitsに作用するため、$4 \times 4$のユニタリ行列です。入力は、$\ket{\psi} = \ket{\psi_C} \otimes \ket{\psi_T}$としたとき、$\ket{\psi_C}$をControl(制御)ビット、$\ket{\psi_T}$をターゲットビットと呼びます。入力の各量子ビットが$\ket{0}$か$\ket{1}$のいずれかであった場合、出力は以下のようになります。

$\ket{\psi}$ $CNOT \ket{\psi}$
$\ket{0} \otimes \ket{0}$ $\ket{0} \otimes \ket{0}$
$\ket{0} \otimes \ket{1}$ $\ket{0} \otimes \ket{1}$
$\ket{1} \otimes \ket{0}$ $\ket{1} \otimes \ket{1}$
$\ket{1} \otimes \ket{1}$ $\ket{1} \otimes \ket{0}$

この表の通り、$CNOT$ゲートは、制御ビットが$\ket{0}$のときのみ、ターゲットビットに$X$ゲートを適用するように作用します。

# Control = 0
# Target  = 0
# 期待される出力: 00

N = 2
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.CNOT(Q[0], Q[1]),
)
_ = run(C, Q, name='CNOT|00>')

実際に、$\ket{00}$、$\ket{01}$、$\ket{10}$、$\ket{11}$のそれぞれの場合で試してみましょう。

$CNOT\ket{00}$の結果

----- Results of "CNOT|00>" -----
Circuit:
0: ───@───
      │
1: ───X───

Simulation:
 |00> : 100.00%
 |01> :   0.00%
 |10> :   0.00%
 |11> :   0.00%

Run(repetitions=1000)
 |00> : 1000
 |01> :    0
 |10> :    0
 |11> :    0

$CNOT\ket{01}$の結果

# Control = 0
# Target  = 1
# 期待される出力: 01

N = 2
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.X(Q[1]),
  cirq.CNOT(Q[0], Q[1]),
)
_ = run(C, Q, name='CNOT|01>')
----- Results of "CNOT|01>" -----
Circuit:
0: ───────@───
          │
1: ───X───X───

Simulation:
 |00> :   0.00%
 |01> : 100.00%
 |10> :   0.00%
 |11> :   0.00%

Run(repetitions=1000)
 |00> :    0
 |01> : 1000
 |10> :    0
 |11> :    0

$CNOT\ket{10}$の結果

# Control = 1
# Target  = 0
# 期待される出力: 11

N = 2
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.X(Q[0]),
  cirq.CNOT(Q[0], Q[1]),
)
_ = run(C, Q, name='CNOT|10>')
----- Results of "CNOT|10>" -----
Circuit:
0: ───X───@───
          │
1: ───────X───

Simulation:
 |00> :   0.00%
 |01> :   0.00%
 |10> :   0.00%
 |11> : 100.00%

Run(repetitions=1000)
 |00> :    0
 |01> :    0
 |10> :    0
 |11> : 1000

$CNOT\ket{11}$の結果

# Control = 1
# Target  = 1
# 期待される出力: 10

N = 2
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.X.on_each(Q),
  cirq.CNOT(Q[0], Q[1]),
)
_ = run(C, Q, name='CNOT|11>')
----- Results of "CNOT|11>" -----
Circuit:
0: ───X───@───
          │
1: ───X───X───

Simulation:
 |00> :   0.00%
 |01> :   0.00%
 |10> : 100.00%
 |11> :   0.00%

Run(repetitions=1000)
 |00> :    0
 |01> :    0
 |10> : 1000
 |11> :    0

量子ゲートの組合せ

ここまでいくつかの量子ビットに作用する量子ゲートを見てきました。1-qubitの量子ゲートは、$2 \times 2$のユニタリ行列でした。$N$-qubitsの量子状態ベクトルは$2^N$次元複素数ベクトルですから、それに作用する量子ゲートののユニタリ行列は$2^N \times 2^N$です。

このとき、複数の量子ゲートに作用するゲートを、これまで見てきた単一または複数の量子ビットに作用する量子ゲートの組合せで表現することを考えます。

例として、2つの量子ビットからなるシステムを考えます。この量子ビットに、それぞれ$Z$ゲートと$X$ゲートを作用させることを考えます。

このとき、$ \ket{\psi} = \ket{\psi_0} \otimes \ket{\psi_1} $であり、2つのゲートからなるユニタリ行列$は$Z \otimes X$で求められます。$\otimes$は、クロネッカー積(テンソル積)です。

$\ket{\psi} = \ket{00}$のとき、$(Z \otimes X) \ket{\psi}$を求めます。

$$ \begin{eqnarray}
\ket{\psi} &=& \ket{00} = \ket{0} \otimes \ket{0}
= \begin{pmatrix} 1 \\ 0 \end{pmatrix} \otimes \begin{pmatrix} 1 \\ 0 \end{pmatrix}
= \begin{pmatrix}
\begin{pmatrix} 1 \\ 0 \end{pmatrix} \\
\begin{pmatrix} 0 \\ 0 \end{pmatrix}
\end{pmatrix}
= \begin{pmatrix}
1 \\ 0 \\ 0 \\ 0
\end{pmatrix}
\end{eqnarray}
$$

$$ \begin{eqnarray}
Z \otimes X
&=& \begin{pmatrix}
1 & 0 \\ 0 & -1
\end{pmatrix} \otimes \begin{pmatrix}
0 & 1 \\ 1 & 0
\end{pmatrix} \\
&=& \begin{pmatrix}
\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} &
\begin{pmatrix} 0 & 0 \\ 0 & 0 \end{pmatrix} \\
\begin{pmatrix} 0 & 0 \\ 0 & 0 \end{pmatrix} &
\begin{pmatrix} 0 & -1 \\ -1 & 0 \end{pmatrix}
\end{pmatrix} \\
&=& \begin{pmatrix}
0 & 1 & 0 & 0 \\
1 & 0 & 0 & 0 \\
0 & 0 & 0 & -1 \\
0 & 0 & -1 & 0
\end{pmatrix}
\end{eqnarray} $$

$$ \begin{eqnarray}
(Z \otimes X) \ket{00}
&=& \begin{pmatrix}
0 & 1 & 0 & 0 \\
1 & 0 & 0 & 0 \\
0 & 0 & 0 & -1 \\
0 & 0 & -1 & 0
\end{pmatrix}
\begin{pmatrix}
1 \\ 0 \\ 0 \\ 0
\end{pmatrix}
= \begin{pmatrix}
0 \\ 1 \\ 0 \\ 0
\end{pmatrix}
= \ket{01}
\end{eqnarray} $$

Cirqで実行して、$U \ket{00} = \ket{01}$となることを確認しましょう。

N = 2
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.Z(Q[0]),
  cirq.X(Q[1]),
)
_ = run(C, Q, name='(Z⊗X)|00>')
----- Results of "(Z⊗X)|00>" -----
Circuit:
0: ───Z───

1: ───X───

Simulation:
 |00> :   0.00%
 |01> : 100.00%
 |10> :   0.00%
 |11> :   0.00%

Run(repetitions=1000)
 |00> :    0
 |01> : 1000
 |10> :    0
 |11> :    0

Bell State

ここまで出てきたゲートを使って、Bell State(ベル状態)を作るゲートを作ります。

ベル状態を作るゲート$B$は、$CNOT(H \otimes I)$で表されます($I$は単位行列)。

ユニタリ行列を計算すると、以下になります。

$$ \begin{eqnarray}
CNOT(H \otimes I)
&=& \begin{pmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 0 & 1 \\
0 & 0 & 1 & 0
\end{pmatrix}
\Bigl(
{1 \over \sqrt{2}} \begin{pmatrix}
1 & 1 \\
1 & -1
\end{pmatrix}
\otimes
\begin{pmatrix}
1 & 0 \\
0 & 1
\end{pmatrix}
\Bigr) \\
&=& {1 \over \sqrt{2}}
\begin{pmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 0 & 1 \\
0 & 0 & 1 & 0
\end{pmatrix}
\begin{pmatrix}
1 & 0 & 1 & 0 \\
0 & 1 & 0 & 1 \\
1 & 0 & -1 & 0 \\
0 & 1 & 0 & -1
\end{pmatrix} \\
&=& {1 \over \sqrt{2}}
\begin{pmatrix}
1 & 0 & 1 & 0 \\
0 & 1 & 0 & 1 \\
0 & 1 & 0 & -1 \\
1 & 0 & -1 & 0
\end{pmatrix}
\end{eqnarray} $$

入力を$\ket{00},\ket{01},\ket{10},\ket{11}$とすると、以下の結果が得られます。

$$ \begin{eqnarray}
CNOT(H \otimes I) \ket{00} &=& {1 \over \sqrt{2}} (\ket{00} + \ket{11}) \\
CNOT(H \otimes I) \ket{01} &=& {1 \over \sqrt{2}} (\ket{01} + \ket{10}) \\
CNOT(H \otimes I) \ket{10} &=& {1 \over \sqrt{2}} (\ket{00} – \ket{11}) \\
CNOT(H \otimes I) \ket{11} &=& {1 \over \sqrt{2}} (\ket{01} – \ket{10}) \\
\end{eqnarray} $$

これらをBell State(ベル状態)といます。

ベル状態は2量子ビットが取りうる4通りの基底のうち2つのいずれかである確率が$1 \over 2$であるような重ね合わせ状態ですが、さらに重要な特徴があります。

量子状態を$\ket{\psi} \otimes \ket{\phi}$のように積の形に分離可能(セパラブル)であるものを積状態といい、分離不可能なものをエンタングルしている(もつれている)といいます。ベル状態はいずれの場合も2つの量子ビットがエンタングルしています。

例えば、${1 \over \sqrt{2}} (\ket{00} + \ket{11})$が、2つの量子状態ベクトルに分離できるかを考えてみます。もし分離できる場合、量子状態ベクトルは$(a\ket{0} + b\ket{1}) \otimes (c\ket{0} + d\ket{1}) = ac\ket{00} + ad\ket{01} + bc\ket{10} + bd\ket{11}$の形で表せるはずです。係数に着目すると、$ad = bc = 0$かつ$ac = bd = {1 \over \sqrt{2}}$となるはずですが、そのような係数の組合せは存在しません。

$CNOT(H \otimes I)$は量子情報理論における代表的なQuantum Entanglement(量子エンタングルメント、量子もつれ)の生成方法の1つです。

それぞれ、観測結果には2通りの可能性が等しい確率で存在する重ね合わせ状態でした。まずは実行結果が一致するか確認してみましょう。

$CNOT(H \otimes I)\ket{00}$の結果

# 初期状態 |00>
# 期待される最終状態 |00>+|11> / sqrt(2)

N = 2
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.H(Q[0]),
  cirq.CNOT(Q[0], Q[1]),
)
_ = run(C, Q, name='BELL|00>')
----- Results of "BELL|00>" -----
Circuit:
0: ───H───@───
          │
1: ───────X───

Simulation:
 |00> :  50.00%
 |01> :   0.00%
 |10> :   0.00%
 |11> :  50.00%

Run(repetitions=1000)
 |00> :  488
 |01> :    0
 |10> :    0
 |11> :  512

$CNOT(H \otimes I)\ket{01}$の結果

# 初期状態 |01>
# 期待される最終状態 |01>+|10> / sqrt(2)

N = 2
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.X(Q[1]),
  cirq.H(Q[0]),
  cirq.CNOT(Q[0], Q[1]),
)
_ = run(C, Q, name='BELL|01>')
----- Results of "BELL|01>" -----
Circuit:
0: ───H───@───
          │
1: ───X───X───

Simulation:
 |00> :   0.00%
 |01> :  50.00%
 |10> :  50.00%
 |11> :   0.00%

Run(repetitions=1000)
 |00> :    0
 |01> :  499
 |10> :  501
 |11> :    0

$CNOT(H \otimes I)\ket{10}$の結果

# 初期状態 |10>
# 期待される最終状態 |00>-|11> / sqrt(2)

N = 2
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.X(Q[0]),
  cirq.H(Q[0]),
  cirq.CNOT(Q[0], Q[1]),
)
_ = run(C, Q, name='BELL|10>')
----- Results of "BELL|10>" -----
Circuit:
0: ───X───H───@───
              │
1: ───────────X───

Simulation:
 |00> :  50.00%
 |01> :   0.00%
 |10> :   0.00%
 |11> :  50.00%

Run(repetitions=1000)
 |00> :  518
 |01> :    0
 |10> :    0
 |11> :  482

$CNOT(H \otimes I)\ket{11}$の結果

# 初期状態 |11>
# 期待される最終状態 |01>-|10> / sqrt(2)

N = 2
Q = [cirq.LineQubit(i) for i in range(N)]
C = cirq.Circuit.from_ops(
  cirq.X.on_each(Q),
  cirq.H(Q[0]),
  cirq.CNOT(Q[0], Q[1]),
)
_ = run(C, Q, name='BELL|11>')
----- Results of "BELL|11>" -----
Circuit:
0: ───X───H───@───
              │
1: ───X───────X───

Simulation:
 |00> :   0.00%
 |01> :  50.00%
 |10> :  50.00%
 |11> :   0.00%

Run(repetitions=1000)
 |00> :    0
 |01> :  502
 |10> :  498
 |11> :    0

量子エンタングルメント

確かにいずれも重ね合わせ状態の通り$1 \over 2$の確率で2通りの結果が観測されました。しかし、エンタングルメントとは何だったのでしょうか。これだけだといまいちわかりませんね。

先ほどは$CNOT(H \otimes I)$のユニタリ行列をいきなり求めましたが、もう少し理解するために、少し条件を絞った上で、時間的発展を順番に確認してみましょう。

初期状態が$\ket{00}$の場合を考えます。まず、1つ目の量子ビットは$H$ゲートの作用を受け、$H\ket{0} = \ket{+}$となります。2つ目の量子ビットは何も変化せず、$\ket{0}$です。

次に、$CNOT$に$\ket{+} \otimes \ket{0}$が入力されます。さきほどの節では制御ビットが基底状態の場合の入力しか考えませんでしたが、今回の入力は$\ket{+}$の重ね合わせ状態です。実際に行列を計算してみましょう。

$$ \begin{eqnarray}
CNOT(\ket{+} \otimes \ket{0})
&=& CNOT \Bigl\{
{1 \over \sqrt{2}} (\ket{0} + \ket{1}) \otimes \ket{0}
\Bigr\} \\
&=& CNOT \Bigl\{
{1 \over \sqrt{2}} (\ket{00} + \ket{10})
\Bigr\} \\
&=& {1 \over \sqrt{2}} CNOT \Bigl\{ \ket{00} + \ket{10} \Bigr\} \\
&=& {1 \over \sqrt{2}} \begin{pmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 0 & 1 \\
0 & 0 & 1 & 0
\end{pmatrix} \Bigl\{ \begin{pmatrix}
1 \\ 0 \\ 0 \\ 0
\end{pmatrix} + \begin{pmatrix}
0 \\ 0 \\ 1 \\ 0
\end{pmatrix} \Bigr\} \\
&=& {1 \over \sqrt{2}} \begin{pmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 0 & 1 \\
0 & 0 & 1 & 0
\end{pmatrix} \begin{pmatrix}
1 \\ 0 \\ 1 \\ 0
\end{pmatrix} \\
&=& {1 \over \sqrt{2}} \begin{pmatrix}
1 \\ 0 \\ 0 \\ 1
\end{pmatrix} \\
&=& {1 \over \sqrt{2}} \Bigl\{ \begin{pmatrix}
1 \\ 0 \\ 0 \\ 0
\end{pmatrix} + \begin{pmatrix}
0 \\ 0 \\ 0 \\ 1
\end{pmatrix} \Bigr\} \\
&=& {1 \over \sqrt{2}} (\ket{00} + \ket{11})
\end{eqnarray} $$

確かに、$CNOT(\ket{+} \otimes \ket{0}) = {1 \over \sqrt{2}} (\ket{00} + \ket{11})$となり、最初の結果と同じものが得られました。

この${1 \over \sqrt{2}} (\ket{00} + \ket{11})$のうち、1つ目の量子ビットのみを観測したとき、$\ket{1}$だったとします。この場合、2つ目の量子ビットを同じ基底で観測すると、$\ket{0}$と$\ket{1}$のどちらが得られるでしょうか?この例では、量子状態は$\ket{00}$か$\ket{11}$の可能性しかないのですから、1つ目が$\ket{1}$ならば、2つ目は理論的には$\ket{1}$しか考えられません。つまり、片方のみ観測すると、観測していない方の状態も決定するのです。よく知られているように、これは2つの量子ビットが地理的にどれだけ離れていても、片方が観測で基底状態に変わると、もう片方の量子状態も決定します。

まとめ

Cirqを使うことで、量子コンピューティングの基礎となるゲート計算をとても簡単にシミュレートすることができました。今回はせいぜい二つの量子ビットしか扱わなかったですから、この程度であれば式を手で計算するほうが早いかもしれません。ここで学んだのはとても簡単な一部のゲートの働きだけで、ここから量子テレポーテーション、量子フーリエ変換、GroverのQuantum Amplitude Amplification、Shorの素因数分解…といった基礎的な量子アルゴリズムの話が始まります。

現在は肝心の量子コンピュータの実機が私達の手元にはないので、実際に試せないことが残念ではありますが、GoogleやIBMを始めとした企業や様々な研究機関が実用化を進めて目覚ましい成果を出しています。実際に量子コンピュータが量子超越性を示したとき、どのフレームワークがデファクトスタンダードになっていくのかも注目ですね。Cirqはその候補となる十分なポテンシャルを持っていると思います。今後に期待を込めつつ、今のうちから勉強して備えておきましょう。

参考文献

  • 古澤明. (2004). 量子テレポーテーションとマルチパータイトエンタングルメント. 光学, 33(5), 278-283.
  • 鄭琳琳, 松枝秀明. (2005). 量子エンタングルメントによる量子情報処理. Kochi University (Information Science), Vol.26, No.6, pdf (閲覧日: 2018年9月22日).
  • 丸山不二夫. (2018). 量子情報理論基礎演習 I. pdf

  1. 和訳すると「イガゴヨウ」。調べてみたら、マツ科の植物で、世界最古の樹齢を持つ木の種でもあるらしいです。 ↩︎
ABOUT ME
Arata Furukawa
DMM.com LLCでAIエンジニアをしてます。 このブログでは、ITに関する記事や、セミナーの開催、執筆、登壇の告知などをまとめています。アイコンは自作。