注釈

当ページは tutorials/circuits/3_summary_of_quantum_operations.ipynb から生成されました。

量子操作の概要

このセクションでは、Qiskit Terraで使用可能なさまざまな操作について説明します。 これらは、次のようなものです。 - 単一量子ビット量子ゲート - 複数量子ビット量子ゲート - 測定 - リセット - 条件 - 状態初期化

また、次の 3 つの異なるシミュレーターを使用する方法も示します。: - unitary_simulator - qasm_simulator - statevector_simulator

[1]:
# Useful additional packages
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from math import pi
[2]:
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.tools.visualization import circuit_drawer
from qiskit.quantum_info import state_fidelity
from qiskit import BasicAer

backend = BasicAer.get_backend('unitary_simulator')

単一量子ビット量子状態

単一量子ビット量子状態は次のように記述できます。

\[\left|\psi\right\rangle = \alpha\left|0\right\rangle + \beta \left|1\right\rangle\]

ここでの \(\alpha\)\(\beta\) は複素数です。測定において、ビットが \(\left|0\right\rangle\) になる確率は \(|\alpha|^2\)\(\left|1\right\rangle\) になる確率は \(|\beta|^2\) です。ベクトルとしては、次のように記述できます。

\[\begin{split}\left|\psi\right\rangle = \begin{pmatrix} \alpha \\ \beta \end{pmatrix}.\end{split}\]

注記、確率の保存の \(|\alpha|^2+ |\beta|^2 = 1\) と、 \(\left|\psi\right\rangle := e^{i\delta} \left|\psi\right\rangle\) により絶対的な位相は検出できないことから、単一量子ビットの量子状態を記述するためには2つの実数のみを必要とします。

便利な表現として、

\[\left|\psi\right\rangle = \cos(\theta/2)\left|0\right\rangle + \sin(\theta/2)e^{i\phi}\left|1\right\rangle\]

ただし、\(0\leq \phi < 2\pi\) 、および \(0\leq \theta \leq \pi\) とします。これより、量子ビット状態( \(\mathbb{C}^2\) )と、単位球面上の点( \(\mathbb{R}^3\) )との間に 1 対 1 の対応があることが明らかとなっています。 これは量子ビット状態のブロッホ球表現と呼ばれます。

通常、量子ゲート/操作は行列として表されます。1量子ビットに作用するゲートは、 \(2\times 2\) ユニタリ行列 \(U\) によって表されます。 量子ゲートの作用は、ゲートを表す行列を量子状態を表すベクトルにかけることによって分かります。

\[\left|\psi'\right\rangle = U\left|\psi\right\rangle\]

一般的なユニタリは、\(\left|0\right\rangle\) を上記の状態にできなければなりません。 これは、

\[\begin{split}U = \begin{pmatrix} \cos(\theta/2) & a \\ e^{i\phi}\sin(\theta/2) & b \end{pmatrix}\end{split}\]

ここでの \(a\) および \(b\) は、すべての \(0\leq\theta\leq\pi\) および \(0\leq \phi<2\pi\) に対して \(U^\dagger U = I\) となるような制約を持つ複素数です。これにより3つの制約が与えられ、\(0\leq \lambda<2\pi\) において \(a\rightarrow -e^{i\lambda}\sin(\theta/2)\) および \(b\rightarrow e^{i\lambda+i\phi}\cos(\theta/2)\) となり、次式が得られます。

\[\begin{split}U = \begin{pmatrix} \cos(\theta/2) & -e^{i\lambda}\sin(\theta/2) \\ e^{i\phi}\sin(\theta/2) & e^{i\lambda+i\phi}\cos(\theta/2) \end{pmatrix}.\end{split}\]

これは単一量子ビットユニタリの最も一般的な形式です。

単一量子ビットゲート

利用可能な単一量子ビットゲートは次のとおりです。: - uゲート - Identityゲート - パウリゲート - クリフォードゲート - :math:`C3`ゲート - 標準的な回転ゲート

ユニタリ行列を計算するためのバックエンドである unitary_simulator が用意されています。

[3]:
q = QuantumRegister(1)

u ゲート

Qiskit では、 \(u3\) ゲートを使用して一般のユニタリにアクセスできます。

\[u3(\theta, \phi, \lambda) = U(\theta, \phi, \lambda)\]
[4]:
qc = QuantumCircuit(q)
qc.u3(pi/2,pi/2,pi/2,q)
qc.draw()
[4]:
      ┌────────────────────┐
q0_0: ┤ U3(pi/2,pi/2,pi/2) ├
      └────────────────────┘
[5]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[5]:
array([[ 0.707+0.j   , -0.   -0.707j],
       [ 0.   +0.707j, -0.707+0.j   ]])

\(u2(\phi, \lambda) =u3(\pi/2, \phi, \lambda)\) は次の行列形式を持ちます。

\[\begin{split}u2(\phi, \lambda) = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & -e^{i\lambda} \\ e^{i\phi} & e^{i(\phi + \lambda)} \end{pmatrix}.\end{split}\]

これは、重ね合わせ状態を作り出せる便利なゲートです。

[6]:
qc = QuantumCircuit(q)
qc.u2(pi/2,pi/2,q)
qc.draw()
[6]:
      ┌───────────────┐
q0_0: ┤ U2(pi/2,pi/2) ├
      └───────────────┘
[7]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[7]:
array([[ 0.707+0.j   , -0.   -0.707j],
       [ 0.   +0.707j, -0.707+0.j   ]])

\(u1(\lambda)= u3(0, 0, \lambda)\) は次の行列形式を持ちます。

\[\begin{split}u1(\lambda) = \begin{pmatrix} 1 & 0 \\ 0 & e^{i \lambda} \end{pmatrix},\end{split}\]

これは、量子位相の適用に役立ちます。

[8]:
qc = QuantumCircuit(q)
qc.u1(pi/2,q)
qc.draw()
[8]:
      ┌──────────┐
q0_0: ┤ U1(pi/2) ├
      └──────────┘
[9]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[9]:
array([[1.+0.j, 0.+0.j],
       [0.+0.j, 0.+1.j]])

恒等ゲート

恒等ゲートは、 :math:`Id = u0(1)`です。

[13]:
qc = QuantumCircuit(q)
qc.id(q)
qc.draw()
[13]:
      ┌───┐
q0_0: ┤ I ├
      └───┘
[14]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[14]:
array([[1.+0.j, 0.+0.j],
       [0.+0.j, 1.+0.j]])

パウリゲート

\(X\): ビット・フリップ・ゲート

ビット・フリップ・ゲート \(X\) は次のように定義されています。

\[\begin{split}X = \begin{pmatrix} 0 & 1\\ 1 & 0 \end{pmatrix}= u3(\pi,0,\pi)\end{split}\]
[15]:
qc = QuantumCircuit(q)
qc.x(q)
qc.draw()
[15]:
      ┌───┐
q0_0: ┤ X ├
      └───┘
[16]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[16]:
array([[0.+0.j, 1.-0.j],
       [1.+0.j, 0.+0.j]])

\(Y\) : ビット・アンド・フェーズ・フリップ・ゲート

\(Y\) ゲートは次のように定義されています。

\[\begin{split}Y = \begin{pmatrix} 0 & -i\\ i & 0 \end{pmatrix}=u3(\pi,\pi/2,\pi/2)\end{split}\]
[17]:
qc = QuantumCircuit(q)
qc.y(q)
qc.draw()
[17]:
      ┌───┐
q0_0: ┤ Y ├
      └───┘
[18]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[18]:
array([[ 0.+0.j, -0.-1.j],
       [ 0.+1.j,  0.+0.j]])

\(Z\): 位相フリップ・ゲート

位相フリップゲート \(Z\) は、次のように定義されます。

\[\begin{split}Z = \begin{pmatrix} 1 & 0\\ 0 & -1 \end{pmatrix}=u1(\pi)\end{split}\]
[19]:
qc = QuantumCircuit(q)
qc.z(q)
qc.draw()
[19]:
      ┌───┐
q0_0: ┤ Z ├
      └───┘
[20]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[20]:
array([[ 1.+0.j,  0.+0.j],
       [ 0.+0.j, -1.+0.j]])

クリフォードゲート

アダマールゲート

\[\begin{split}H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1\\ 1 & -1 \end{pmatrix}= u2(0,\pi)\end{split}\]
[21]:
qc = QuantumCircuit(q)
qc.h(q)
qc.draw()
[21]:
      ┌───┐
q0_0: ┤ H ├
      └───┘
[22]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[22]:
array([[ 0.707+0.j,  0.707-0.j],
       [ 0.707+0.j, -0.707+0.j]])

\(S\) (または、 \(\sqrt{Z}\) フェーズ) ゲート

\[\begin{split}S = \begin{pmatrix} 1 & 0\\ 0 & i \end{pmatrix}= u1(\pi/2)\end{split}\]
[23]:
qc = QuantumCircuit(q)
qc.s(q)
qc.draw()
[23]:
      ┌───┐
q0_0: ┤ S ├
      └───┘
[24]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[24]:
array([[1.+0.j, 0.+0.j],
       [0.+0.j, 0.+1.j]])

\(S^{\dagger}\) (または :math:`sqrt{Z}`フェーズの共役 ) ゲート

\[\begin{split}S^{\dagger} = \begin{pmatrix} 1 & 0\\ 0 & -i \end{pmatrix}= u1(-\pi/2)\end{split}\]
[25]:
qc = QuantumCircuit(q)
qc.sdg(q)
qc.draw()
[25]:
      ┌─────┐
q0_0: ┤ SDG ├
      └─────┘
[26]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[26]:
array([[1.+0.j, 0.+0.j],
       [0.+0.j, 0.-1.j]])

\(C3\) ゲート

\(T\) (または、 \(\sqrt{S}\) フェーズ) ゲート

\[\begin{split}T = \begin{pmatrix} 1 & 0\\ 0 & e^{i \pi/4} \end{pmatrix}= u1(\pi/4)\end{split}\]
[27]:
qc = QuantumCircuit(q)
qc.t(q)
qc.draw()
[27]:
      ┌───┐
q0_0: ┤ T ├
      └───┘
[28]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[28]:
array([[1.   +0.j   , 0.   +0.j   ],
       [0.   +0.j   , 0.707+0.707j]])

\(T^{\dagger}\) (または \(\sqrt{S}\) フェーズの共役 ) ゲート

\[\begin{split}T^{\dagger} = \begin{pmatrix} 1 & 0\\ 0 & e^{-i \pi/4} \end{pmatrix}= u1(-\pi/4)\end{split}\]
[29]:
qc = QuantumCircuit(q)
qc.tdg(q)
qc.draw()
[29]:
      ┌─────┐
q0_0: ┤ TDG ├
      └─────┘
[30]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[30]:
array([[1.   +0.j   , 0.   +0.j   ],
       [0.   +0.j   , 0.707-0.707j]])

標準回転

標準回転ゲートは、パウリ \(P=\{X,Y,Z\}\) の周囲で回転を定義するゲートが定義されているものです。

\[R_P(\theta) = \exp(-i \theta P/2) = \cos(\theta/2)I -i \sin(\theta/2)P\]

X 軸まわりの回転

\[\begin{split}R_x(\theta) = \begin{pmatrix} \cos(\theta/2) & -i\sin(\theta/2)\\ -i\sin(\theta/2) & \cos(\theta/2) \end{pmatrix} = u3(\theta, -\pi/2,\pi/2)\end{split}\]
[31]:
qc = QuantumCircuit(q)
qc.rx(pi/2,q)
qc.draw()
[31]:
      ┌──────────┐
q0_0: ┤ RX(pi/2) ├
      └──────────┘
[32]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[32]:
array([[ 0.707+0.j   , -0.   -0.707j],
       [ 0.   -0.707j,  0.707+0.j   ]])

Y 軸まわりの回転

\[\begin{split}R_y(\theta) = \begin{pmatrix} \cos(\theta/2) & - \sin(\theta/2)\\ \sin(\theta/2) & \cos(\theta/2). \end{pmatrix} =u3(\theta,0,0)\end{split}\]
[33]:
qc = QuantumCircuit(q)
qc.ry(pi/2,q)
qc.draw()
[33]:
      ┌──────────┐
q0_0: ┤ RY(pi/2) ├
      └──────────┘
[34]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[34]:
array([[ 0.707+0.j, -0.707+0.j],
       [ 0.707+0.j,  0.707+0.j]])

Z 軸まわりの回転

\[\begin{split}R_z(\phi) = \begin{pmatrix} e^{-i \phi/2} & 0 \\ 0 & e^{i \phi/2} \end{pmatrix}\equiv u1(\phi)\end{split}\]

ここでは、グローバル・フェーズ \(e^{-i \phi/2}\) だけ u1 と異なるので、同じとみなしています。

[35]:
qc = QuantumCircuit(q)
qc.rz(pi/2,q)
qc.draw()
[35]:
      ┌──────────┐
q0_0: ┤ RZ(pi/2) ├
      └──────────┘
[36]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[36]:
array([[1.+0.j, 0.+0.j],
       [0.+0.j, 0.+1.j]])

これは、グローバル・フェーズのみ異なることに注意してください。

複数量子ビットゲート

数学的準備

量子コンピューターの次元は、量子ビットの数に対して指数関数的に大きくなります。 \(n\) 量子ビットの場合、複素ベクトル空間は \(d=2^n\) 次元になります。複数量子ビット系の状態を表すためには、テンソル積が演算子と基底ベクトルの ”結合” として使われます。

2量子ビットシステムを考える所から始めてみましょう。それぞれ片方の量子ビットに作用する \(A\)\(B\) という2つの演算子を用意し、2つの量子ビットに作用する結合演算子 \(A \otimes B\) は、

\[\begin{split}\begin{equation} A\otimes B = \begin{pmatrix} A_{00} \begin{pmatrix} B_{00} & B_{01} \\ B_{10} & B_{11} \end{pmatrix} & A_{01} \begin{pmatrix} B_{00} & B_{01} \\ B_{10} & B_{11} \end{pmatrix} \\ A_{10} \begin{pmatrix} B_{00} & B_{01} \\ B_{10} & B_{11} \end{pmatrix} & A_{11} \begin{pmatrix} B_{00} & B_{01} \\ B_{10} & B_{11} \end{pmatrix} \end{pmatrix}, \end{equation}\end{split}\]

ここでは、 \(A_{jk}\)\(B_{lm}\)\(A\)\(B\) それぞれの行列成分になります。

類似的に、2量子ビット系の基底ベクトルは、単一量子ビットでの基底ベクトルのテンソル積を使って形成されます。

\[\begin{split}\begin{equation}\begin{split} \left|{00}\right\rangle &= \begin{pmatrix} 1 \begin{pmatrix} 1 \\ 0 \end{pmatrix} \\ 0 \begin{pmatrix} 1 \\ 0 \end{pmatrix} \end{pmatrix} = \begin{pmatrix} 1 \\ 0 \\ 0 \\0 \end{pmatrix}~~~\left|{01}\right\rangle = \begin{pmatrix} 1 \begin{pmatrix} 0 \\ 1 \end{pmatrix} \\ 0 \begin{pmatrix} 0 \\ 1 \end{pmatrix} \end{pmatrix} = \begin{pmatrix}0 \\ 1 \\ 0 \\ 0 \end{pmatrix}\end{split} \end{equation}\end{split}\]
\[\begin{split}\begin{equation}\begin{split}\left|{10}\right\rangle = \begin{pmatrix} 0\begin{pmatrix} 1 \\ 0 \end{pmatrix} \\ 1\begin{pmatrix} 1 \\ 0 \end{pmatrix} \end{pmatrix} = \begin{pmatrix} 0 \\ 0 \\ 1 \\ 0 \end{pmatrix}~~~ \left|{11}\right\rangle = \begin{pmatrix} 0 \begin{pmatrix} 0 \\ 1 \end{pmatrix} \\ 1\begin{pmatrix} 0 \\ 1 \end{pmatrix} \end{pmatrix} = \begin{pmatrix} 0 \\ 0 \\ 0 \\1 \end{pmatrix}\end{split} \end{equation}.\end{split}\]

ここでは、基底ベクトルの略記を導入します。\(\left|0\right\rangle \otimes \left|0\right\rangle\) は :math:`left|00rightrangle`と表現されます。:math:`n`キュービット系の状態は、単一キュービットベクトルの:math:`n`階のテンソル積を使って書き下すことができます。2キュービット系の基底ベクトルは、4次元になります。前に述べたように、一般に、:math:`n`キュービット系の基底ベクトルは、:math:`2^{n}`次元になります。

Qiskitにおける基底ベクトル表記の順番

物理コミュニティーでは、マルチ qubit システムの qubit の取り扱いを典型的にはテンソル積の一番左端を最初の qubit とし、一番右端のものを最後の qubit としています。例えば、最初の qubit が \(\left|0\right\rangle\) 状態で、2番目のものが \(\left|1\right\rangle\) 状態の場合、その結合状態は \(\left|01\right\rangle\) です。Qiskit では qubits の順番に少し異なる方法をとります。qubit は最上位ビット (Most Significant Bit - MSB) を左にとり、最下位ビット (Least Significant Bit - LSB) を右にとります(ビッグエンディアン - big-endian)。これにより、古典コンピューター上でのビット列表現と同じようになり、測定が実行された後のビット文字列から整数への変換が容易になります。例えば、先の例は :math:`left|10rightrangle`という結合状態で表現されます。以下で説明するように重要なこととして、* マルチ量子ビット状態に対するこの変更により、Qiskit でのマルチ量子ビットゲートの表現に影響があるということです*。

Qiskitで使用される表現は、基底ベクトルをそれらが表す整数の昇順で列挙します。たとえば、2量子ビット系の基底ベクトルは、\(\left|00\right\rangle\)\(\left|01\right\rangle\)\(\left|10\right\rangle\)、および \(\left|11\right\rangle\) の順序になります。基底ベクトルをビット文字列と見なし、それぞれを整数の 0、1、2、3 にエンコードします。

量子ビットに対する制御操作

複数 qubit ゲートに共通なものとして、一つの qubit にゲートを適用し、別の qubit の状態に応じて制御するというものがあります。例えば、最初の qubit が :math:`left|0rightrangle`の時に、2つ目の qubit の状態をフリップしたい場合があります。このようなゲートは*制御ゲート*と知られています。標準的な複数 qubit ゲートは 2 qubit ゲートと 3 qubit ゲートから構成されています。2 qubit ゲートは: - 制御パウリゲート -制御アダマールゲート - 制御回転ゲート - 制御位相ゲート - 制御 u3 ゲート -スワップゲート です。

3量子ビットゲートは: - トフォリゲート -フレドキンゲートです。

2量子ビット(two-qubit) ゲート

多くの2ゲート(two-gates) は制御タイプのものです(SWAP ゲートは例外になります)。一般的に、制御 2量子ビット(two-qubit) ゲート \(C_{U}\) は 最初の qubit が \(\left|1\right\rangle\) の時に、2つ目の量子ビットに対して単独量子ビット (single-qubit) \(U\) を適用します。 \(U\) が以下の行列表示であるとします。

\[\begin{split}U = \begin{pmatrix} u_{00} & u_{01} \\ u_{10} & u_{11}\end{pmatrix}.\end{split}\]

\(C_{U}\) の動作は次のように計算できます。2量子ビット系の基底ベクトルは \(\left|00\right\rangle、\left|01\right\rangle、\left|10\right\rangle、\left|11\right\rangle\) の順序で並べられることを思い出してください。**制御量子ビット**は**0量子ビット(qubit 0)**であると仮定します(Qiskitの慣例によれば、これはテンソル積の**右側**のひとつです)。もし制御量子ビットが \(\left|1\right\rangle\) であれば、\(U\) を**ターゲット**に適用する必要があります(テンソル積の左側の1量子ビット(qubit 1)です)。したがって、:math:`C_{U}`のもとにおける基底ベクトルは

\[\begin{split}\begin{align*} C_{U}: \underset{\text{qubit}~1}{\left|0\right\rangle}\otimes \underset{\text{qubit}~0}{\left|0\right\rangle} &\rightarrow \underset{\text{qubit}~1}{\left|0\right\rangle}\otimes \underset{\text{qubit}~0}{\left|0\right\rangle}\\ C_{U}: \underset{\text{qubit}~1}{\left|0\right\rangle}\otimes \underset{\text{qubit}~0}{\left|1\right\rangle} &\rightarrow \underset{\text{qubit}~1}{U\left|0\right\rangle}\otimes \underset{\text{qubit}~0}{\left|1\right\rangle}\\ C_{U}: \underset{\text{qubit}~1}{\left|1\right\rangle}\otimes \underset{\text{qubit}~0}{\left|0\right\rangle} &\rightarrow \underset{\text{qubit}~1}{\left|1\right\rangle}\otimes \underset{\text{qubit}~0}{\left|0\right\rangle}\\ C_{U}: \underset{\text{qubit}~1}{\left|1\right\rangle}\otimes \underset{\text{qubit}~0}{\left|1\right\rangle} &\rightarrow \underset{\text{qubit}~1}{U\left|1\right\rangle}\otimes \underset{\text{qubit}~0}{\left|1\right\rangle}\\ \end{align*}.\end{split}\]

行列形式では、 \(C_{U}\) の作用は

\[\begin{split}\begin{equation} C_U = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & u_{00} & 0 & u_{01} \\ 0 & 0 & 1 & 0 \\ 0 & u_{10} &0 & u_{11} \end{pmatrix}. \end{equation}\end{split}\]

これらのマトリックス要素を処理するには、

\[C_{(jk), (lm)} = \left(\underset{\text{qubit}~1}{\left\langle j \right|} \otimes \underset{\text{qubit}~0}{\left\langle k \right|}\right) C_{U} \left(\underset{\text{qubit}~1}{\left| l \right\rangle} \otimes \underset{\text{qubit}~0}{\left| k \right\rangle}\right),\]

として、 \(C_{U}\) (上記のもの)を作用させ、内積を計算することで導出されます。

以下の例に示すように、この操作は Qiskit では cU(q[0],q[1]) として実装されています。

もし **量子ビット1 が制御で、量子ビット 0 が ターゲット**の場合には、基底ベクトルは次のもので変換されます。

\[\begin{split}\begin{align*} C_{U}: \underset{\text{qubit}~1}{\left|0\right\rangle}\otimes \underset{\text{qubit}~0}{\left|0\right\rangle} &\rightarrow \underset{\text{qubit}~1}{\left|0\right\rangle}\otimes \underset{\text{qubit}~0}{\left|0\right\rangle}\\ C_{U}: \underset{\text{qubit}~1}{\left|0\right\rangle}\otimes \underset{\text{qubit}~0}{\left|1\right\rangle} &\rightarrow \underset{\text{qubit}~1}{\left|0\right\rangle}\otimes \underset{\text{qubit}~0}{\left|1\right\rangle}\\ C_{U}: \underset{\text{qubit}~1}{\left|1\right\rangle}\otimes \underset{\text{qubit}~0}{\left|0\right\rangle} &\rightarrow \underset{\text{qubit}~1}{\left|1\right\rangle}\otimes \underset{\text{qubit}~0}{U\left|0\right\rangle}\\ C_{U}: \underset{\text{qubit}~1}{\left|1\right\rangle}\otimes \underset{\text{qubit}~0}{\left|1\right\rangle} &\rightarrow \underset{\text{qubit}~1}{\left|1\right\rangle}\otimes \underset{\text{qubit}~0}{U\left|1\right\rangle}\\ \end{align*},\end{split}\]

この場合の \(C_{U}\) の行列表示は次のようになります。

\[\begin{split}\begin{equation} C_U = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & u_{00} & u_{01} \\ 0 & 0 & u_{10} & u_{11} \end{pmatrix}. \end{equation}\end{split}\]
[37]:
q = QuantumRegister(2)

制御パウリゲート

制御 X (制御NOT) ゲート

制御NOTゲートは、制御量子ビットが:math:left|1rightrangle`状態のとき、``ターゲット``量子ビットを反転します。もしMSBを制御ビットとした時(例: ``cx(q[1],q[0])`)、行列は以下の通りになります。

\[\begin{split}C_X = \begin{pmatrix} 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 0 & 1\\ 0 & 0 & 1 & 0 \end{pmatrix}.\end{split}\]

しかし、LSBが制御キュービットの場合 (例えば、cx(q[0],q[1]))、このゲートは次の行列と同等です。

\[\begin{split}C_X = \begin{pmatrix} 1 & 0 & 0 & 0\\ 0 & 0 & 0 & 1\\ 0 & 0 & 1 & 0\\ 0 & 1 & 0 & 0 \end{pmatrix}.\end{split}\]
[38]:
qc = QuantumCircuit(q)
qc.cx(q[0],q[1])
qc.draw()
[38]:
q1_0: ──■──
      ┌─┴─┐
q1_1: ┤ X ├
      └───┘
[39]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[39]:
array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j],
       [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
       [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]])

制御:math:`Y`ゲート

制御量子ビットが MSB の場合、ターゲット量子ビットに \(Y\) ゲートを適用します。

\[\begin{split}C_Y = \begin{pmatrix} 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 0 & -i\\ 0 & 0 & i & 0 \end{pmatrix},\end{split}\]

あるいはLSBを制御にした場合

\[\begin{split}C_Y = \begin{pmatrix} 1 & 0 & 0 & 0\\ 0 & 0 & 0 & -i\\ 0 & 0 & 1 & 0\\ 0 & i & 0 & 0 \end{pmatrix}.\end{split}\]
[40]:
qc = QuantumCircuit(q)
qc.cy(q[0],q[1])
qc.draw()
[40]:
q1_0: ──■──
      ┌─┴─┐
q1_1: ┤ Y ├
      └───┘
[41]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[41]:
array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 0.-1.j],
       [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
       [0.+0.j, 0.+1.j, 0.+0.j, 0.+0.j]])

制御 \(Z\) (または制御フェーズ) ゲート

同様に、制御クビットが :math:`left|1r/r角である場合には、制御された Z ゲートがターゲット量子ビットの位相を反転させる。 このマトリックスは、 MSB または LSB が制御クビットかどうかに関係なく、同じになります。

\[\begin{split}C_Z = \begin{pmatrix} 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 1 & 0\\ 0 & 0 & 0 & -1 \end{pmatrix}\end{split}\]
[42]:
qc = QuantumCircuit(q)
qc.cz(q[0],q[1])
qc.draw()
[42]:
q1_0: ─■─
       │
q1_1: ─■─
         
[43]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[43]:
array([[ 1.-0.j,  0.+0.j,  0.+0.j,  0.+0.j],
       [ 0.+0.j,  1.-0.j,  0.+0.j,  0.+0.j],
       [ 0.+0.j,  0.+0.j,  1.-0.j,  0.+0.j],
       [ 0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j]])

制御アダマールゲート

制御量子ビットが:math:left|1rightrangle`のとき、ターゲット量子ビットに:math:`H ゲートを適用します。制御がLSB量子ビットの時、以下の通りになります。

\[\begin{split}C_H = \begin{pmatrix} 1 & 0 & 0 & 0\\ 0 & \frac{1}{\sqrt{2}} & 0 & \frac{1}{\sqrt{2}}\\ 0 & 0 & 1 & 0\\ 0 & \frac{1}{\sqrt{2}} & 0& -\frac{1}{\sqrt{2}} \end{pmatrix}\end{split}\]
[44]:
qc = QuantumCircuit(q)
qc.ch(q[0],q[1])
qc.draw()
[44]:
q1_0: ──■──
      ┌─┴─┐
q1_1: ┤ H ├
      └───┘
[45]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[45]:
array([[ 1.   -0.j,  0.   +0.j,  0.   +0.j,  0.   +0.j],
       [ 0.   +0.j,  0.707-0.j,  0.   +0.j,  0.707-0.j],
       [ 0.   +0.j,  0.   +0.j,  1.   -0.j,  0.   +0.j],
       [ 0.   +0.j,  0.707+0.j,  0.   +0.j, -0.707+0.j]])

制御回転ゲート

Z軸周りの制御された回転

制御量子ビット(ここではLSB)が :math:`left|1rightrangle`の場合、ターゲット量子ビットでZ軸周りの回転を実行します。

\[\begin{split}C_{Rz}(\lambda) = \begin{pmatrix} 1 & 0 & 0 & 0\\ 0 & e^{-i\lambda/2} & 0 & 0\\ 0 & 0 & 1 & 0\\ 0 & 0 & 0 & e^{i\lambda/2} \end{pmatrix}\end{split}\]
[46]:
qc = QuantumCircuit(q)
qc.crz(pi/2,q[0],q[1])
qc.draw()
[46]:
q1_0: ─────■──────
      ┌────┴─────┐
q1_1: ┤ RZ(pi/2) ├
      └──────────┘
[47]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[47]:
array([[1.   +0.j   , 0.   +0.j   , 0.   +0.j   , 0.   +0.j   ],
       [0.   +0.j   , 0.707-0.707j, 0.   +0.j   , 0.   +0.j   ],
       [0.   +0.j   , 0.   +0.j   , 1.   +0.j   , 0.   +0.j   ],
       [0.   +0.j   , 0.   +0.j   , 0.   +0.j   , 0.707+0.707j]])

制御位相回転

両方の量子ビットが \(\left|11\right\rangle\) の状態の場合、位相の回転を実行します。 行列は、MSBまたはLSBが制御量子ビットであるかどうかに関係なく同じに見えます。

\[\begin{split}C_{u1}(\lambda) = \begin{pmatrix} 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 1 & 0\\ 0 & 0 & 0 & e^{i\lambda} \end{pmatrix}\end{split}\]
[48]:
qc = QuantumCircuit(q)
qc.cu1(pi/2,q[0], q[1])
qc.draw()
[48]:
q1_0: ─■─────
       │pi/2
q1_1: ─■─────
             
[49]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[49]:
array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 0.+1.j]])

制御 \(u3\) 回転

もし制御量子ビット(ここではLSB)が:math:left|1rightrangle`のとき、ターゲット量子ビットを制御-:math:`u3 回転させます。

\[\begin{split}C_{u3}(\theta, \phi, \lambda) \equiv \begin{pmatrix} 1 & 0 & 0 & 0\\ 0 & e^{-i(\phi+\lambda)/2}\cos(\theta/2) & 0 & -e^{-i(\phi-\lambda)/2}\sin(\theta/2)\\ 0 & 0 & 1 & 0\\ 0 & e^{i(\phi-\lambda)/2}\sin(\theta/2) & 0 & e^{i(\phi+\lambda)/2}\cos(\theta/2) \end{pmatrix}.\end{split}\]
[50]:
qc = QuantumCircuit(q)
qc.cu3(pi/2, pi/2, pi/2, q[0], q[1])
qc.draw()
[50]:
q1_0: ──────────■───────────
      ┌─────────┴──────────┐
q1_1: ┤ U3(pi/2,pi/2,pi/2) ├
      └────────────────────┘
[51]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[51]:
array([[ 1.   +0.j   ,  0.   +0.j   ,  0.   +0.j   ,  0.   +0.j   ],
       [ 0.   +0.j   ,  0.707+0.j   ,  0.   +0.j   , -0.   -0.707j],
       [ 0.   +0.j   ,  0.   +0.j   ,  1.   +0.j   ,  0.   +0.j   ],
       [ 0.   +0.j   ,  0.   +0.707j,  0.   +0.j   , -0.707+0.j   ]])

SWAP ゲート

SWAPゲートは2つの量子ビットを交換します。それは次のように基底ベクトルを変換します。

\[\left|00\right\rangle \rightarrow \left|00\right\rangle~,~\left|01\right\rangle \rightarrow \left|10\right\rangle~,~\left|10\right\rangle \rightarrow \left|01\right\rangle~,~\left|11\right\rangle \rightarrow \left|11\right\rangle,\]

行列表現は以下の通りです。

\[\begin{split}\mathrm{SWAP} = \begin{pmatrix} 1 & 0 & 0 & 0\\ 0 & 0 & 1 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 0 & 1 \end{pmatrix}.\end{split}\]
[52]:
qc = QuantumCircuit(q)
qc.swap(q[0], q[1])
qc.draw()
[52]:
q1_0: ─X─
       │
q1_1: ─X─
         
[53]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[53]:
array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],
       [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])

3量子ビット・ゲート

一般に使用されている2つの3量子ビット・ゲートがあります。3量子ビットにおいて、基底ベクトルは以下の順番になります。

\[\left|000\right\rangle, \left|001\right\rangle, \left|010\right\rangle, \left|011\right\rangle, \left|100\right\rangle, \left|101\right\rangle, \left|110\right\rangle, \left|111\right\rangle,\]

ビット・ストリングは、整数 :math:`0,1,2,cdots, 7`を表します。繰り返しになりますが、Qiskitは最初の量子ビットがテンソル積の右端にあり、3番目の量子ビットが左端にあるという表現を使用します:

\[\left|abc\right\rangle : \underset{\text{qubit 2}}{\left|a\right\rangle}\otimes \underset{\text{qubit 1}}{\left|b\right\rangle}\otimes \underset{\text{qubit 0}}{\left|c\right\rangle}.\]

Toffoliゲート(:math:`ccx`ゲート)

Toffoliゲート は、最初の2つの量子ビット(LSB)がどちらも:math:`left|1rightrangle`のとき、3番目の量子ビットを反転します:

\[\left|abc\right\rangle \rightarrow \left|bc\oplus a\right\rangle \otimes \left|b\right\rangle \otimes \left|c\right\rangle.\]

行列形式では、トフォリゲートは

\[\begin{split}C_{CX} = \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \end{pmatrix}.\end{split}\]
[54]:
q = QuantumRegister(3)
[55]:
qc = QuantumCircuit(q)
qc.ccx(q[0], q[1], q[2])
qc.draw()
[55]:
q2_0: ──■──
        │
q2_1: ──■──
      ┌─┴─┐
q2_2: ┤ X ├
      └───┘
[56]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[56]:
array([[1.-0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j]])

制御SWAPゲート (Fredkinゲート)

Fredkinゲート、または *制御SWAPゲート*は、最初の量子ビット(LSB)が \(\left|1\right\rangle\) のとき、2番目と3番目の量子ビットを交換します:

\[\left|abc\right\rangle \rightarrow \begin{cases} \left|bac\right\rangle~~\text{if}~c=1 \cr \left|abc\right\rangle~~\text{if}~c=0 \end{cases}.\]

行列形式では、Fredkinゲートは以下の通りになります。

\[\begin{split}C_{\mathrm{SWAP}} = \begin{pmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0\\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \end{pmatrix}.\end{split}\]
[57]:
qc = QuantumCircuit(q)
qc.cswap(q[0], q[1], q[2])
qc.draw()
[57]:
q2_0: ─■─
       │
q2_1: ─X─
       │
q2_2: ─X─
         
[58]:
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
[58]:
array([[1.-0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j, 0.+0.j],
       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 1.-0.j]])

非ユニタリ操作

ここまで、量子回路におけるすべてのユニタリ操作について見てきましたが、非ユニタリ操作についても見ていきましょう。ここでは、測定、キュービットのリセット、そして古典的条件付き操作が含まれます。

[59]:
q = QuantumRegister(1)
c = ClassicalRegister(1)

測定

我々は測定が行われるまで量子コンピューターにおける全ての情報を知ることはできません。量子状態は、標準基底に射影されます。下の2つの例は基底状態に準備した回路と量子コンピューターが重ね合わせ状態に準備した回路になります。

[60]:
qc = QuantumCircuit(q, c)
qc.measure(q, c)
qc.draw()
[60]:
      ┌─┐
q3_0: ┤M├
      └╥┘
c0_0: ═╩═
         
[61]:
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1024)
job.result().get_counts(qc)
[61]:
{'0': 1024}

シミュレーターは古典レジスタが0を返す確率が100%であることを予測しています。

[62]:
qc = QuantumCircuit(q, c)
qc.h(q)
qc.measure(q, c)
qc.draw()
[62]:
      ┌───┐┌─┐
q3_0: ┤ H ├┤M├
      └───┘└╥┘
c0_0: ══════╩═
              
[63]:
job = execute(qc, backend, shots=1024)
job.result().get_counts(qc)
[63]:
{'0': 532, '1': 492}

シミュレーターは古典レジスタが0もしくは1を返す確率が50%であることを予測しています。

リセット

リセット演算子はキュービットを計算の途中で \(\left|0\right\rangle\) 状態に``リセット``することができます。ここでの``リセット``は、不可逆なのでゲート操作ではないことに注意してください。

[64]:
qc = QuantumCircuit(q, c)
qc.reset(q[0])
qc.measure(q, c)
qc.draw()
[64]:
           ┌─┐
q3_0: ─|0>─┤M├
           └╥┘
c0_0: ══════╩═
              
[65]:
job = execute(qc, backend, shots=1024)
job.result().get_counts(qc)
[65]:
{'0': 1024}
[66]:
qc = QuantumCircuit(q, c)
qc.h(q)
qc.reset(q[0])
qc.measure(q, c)
qc.draw()
[66]:
      ┌───┐     ┌─┐
q3_0: ┤ H ├─|0>─┤M├
      └───┘     └╥┘
c0_0: ═══════════╩═
                   
[67]:
job = execute(qc, backend, shots=1024)
job.result().get_counts(qc)
[67]:
{'0': 1024}

ここで、両方の回路においてシミュレーターは出力が100%の確率で0状態であることを常に予測することが確認できます。

条件付き操作

古典レジスタの状態に応じて操作を行うことも可能です。

[68]:
qc = QuantumCircuit(q, c)
qc.x(q[0]).c_if(c, 0)
qc.measure(q,c)
qc.draw()
[68]:
       ┌───┐ ┌─┐
q3_0: ─┤ X ├─┤M├
       └─┬─┘ └╥┘
      ┌──┴──┐ ║
c0_0: ╡ = 0 ╞═╩═
      └─────┘   

ここでは古典ビットは常に値0をとるので、量子ビットの状態は常に反転されます。

[69]:
job = execute(qc, backend, shots=1024)
job.result().get_counts(qc)
[69]:
{'1': 1024}
[70]:
qc = QuantumCircuit(q, c)
qc.h(q)
qc.measure(q,c)
qc.x(q[0]).c_if(c, 0)
qc.measure(q,c)
qc.draw()
[70]:
      ┌───┐┌─┐ ┌───┐ ┌─┐
q3_0: ┤ H ├┤M├─┤ X ├─┤M├
      └───┘└╥┘ └─┬─┘ └╥┘
            ║ ┌──┴──┐ ║
c0_0: ══════╩═╡ = 0 ╞═╩═
              └─────┘   
[71]:
job = execute(qc, backend, shots=1024)
job.result().get_counts(qc)
[71]:
{'1': 1024}

ここで、最初の測定による古典ビットはランダムですが、条件付きの演算の結果は、量子ビットは決定論的に \(\left|1\right\rangle\) になります。

任意の初期化

量子ビットのレジスターを任意の状態に初期化したい場合はどうなりますか? \(n\) 量子ビットの任意の状態は、\(2^n\) の振幅のベクトルで指定できます。ここで、振幅 - ノルム - 平方の合計は1です。例えば、次の3量子ビットの状態を用意するには以下のようにします:

\[\left|\psi\right\rangle = \frac{i}{4}\left|000\right\rangle + \frac{1}{\sqrt{8}}\left|001\right\rangle + \frac{1+i}{4}\left|010\right\rangle + \frac{1+2i}{\sqrt{8}}\left|101\right\rangle + \frac{1}{4}\left|110\right\rangle\]
[77]:
# Initializing a three-qubit quantum state
import math
desired_vector = [
    1 / math.sqrt(16) * complex(0, 1),
    1 / math.sqrt(8) * complex(1, 0),
    1 / math.sqrt(16) * complex(1, 1),
    0,
    0,
    1 / math.sqrt(8) * complex(1, 2),
    1 / math.sqrt(16) * complex(1, 0),
    0]


q = QuantumRegister(3)

qc = QuantumCircuit(q)

qc.initialize(desired_vector, [q[0],q[1],q[2]])
qc.draw()
[77]:
       ┌───────────────────────────────────────────────────────────────────┐
q28_0: ┤0                                                                  ├
       │                                                                   │
q28_1: ┤1 initialize(0.25j,0.35355,0.25+0.25j,0,0,0.35355+0.70711j,0.25,0) ├
       │                                                                   │
q28_2: ┤2                                                                  ├
       └───────────────────────────────────────────────────────────────────┘
[74]:
backend = BasicAer.get_backend('statevector_simulator')
job = execute(qc, backend)
qc_state = job.result().get_statevector(qc)
qc_state
[74]:
array([2.50000000e-01+0.j        , 5.55111512e-17-0.35355339j,
       2.50000000e-01-0.25j      , 0.00000000e+00+0.j        ,
       0.00000000e+00+0.j        , 7.07106781e-01-0.35355339j,
       8.67361738e-17-0.25j      , 0.00000000e+00+0.j        ])

Fidelity(忠実度) <https://en.wikipedia.org/wiki/Fidelity_of_quantum_states> は、2つの状態が同じかどうかを確認するのに役立ちます。 (純粋な)量子状態 \(\left|\psi_1\right\rangle\)\(\left|\psi_2\right\rangle\),の場合、Fidelity (忠実度) 度は

\[F\left(\left|\psi_1\right\rangle,\left|\psi_2\right\rangle\right) = \left|\left\langle\psi_1\middle|\psi_2\right\rangle\right|^2.\]

2つの状態が同じ場合に限り、忠実度は :math:`1`に等しくなります。

[75]:
state_fidelity(desired_vector,qc_state)
[75]:
1.0

更に詳細な説明:

裏では、どのようにして目的の状態が生成されるのでしょうか。 複数の方法がありますが、 Qiskitは Shendeらによって提案された方法 <https://arxiv.org/abs/quant-ph/0406176> を使っています。 これは、量子レジスタが我々の望む状態から始まったと仮定し、それを \(\left|00..0\right\rangle\) の状態にする回路を構築するアイデイアです。 初期化回路はこの回路の逆になります。

任意の量子状態を計算基底のゼロ状態にするために、1つずつレジスターから量子ビットのもつれをほどく反復的な手順を行ないます。任意の1量子ビット状態 \(\left|\rho\right\rangle\) は次のようにZ軸まわりの \(\phi\) 度回転とY軸まわりの \(\theta\) 度回転を用いることで \(\left|0\right\rangle\) 状態にすることができます。

\[R_y(-\theta)R_z(-\phi)\left|\rho\right\rangle = re^{it}\left|0\right\rangle\]

ここからは、1量子ビットの代わりに \(n\) 量子ビットを扱うと、状態ベクトルを分解して最下位ビット(LSB)方式で分離する必要があります。

\[\begin{split}\begin{align*} \left|\psi\right\rangle =& \alpha_{0_0}\left|00..00\right\rangle + \alpha_{0_1}\left|00..01\right\rangle + \alpha_{1_0}\left|00..10\right\rangle + \alpha_{1_1}\left|00..11\right\rangle + ... \\&+ \alpha_{(2^{n-1}-1)_0}\left|11..10\right\rangle + \alpha_{(2^{n-1}-1)_1}\left|11..11\right\rangle \\ =& \left|00..0\right\rangle (\alpha_{0_0}\left|0\right\rangle + \alpha_{0_1}\left|1\right\rangle) + \left|00..1\right\rangle (\alpha_{1_0}\left|0\right\rangle + \alpha_{1_1}\left|1\right\rangle) + ... \\&+ \left|11..1\right\rangle (\alpha_{(2^{n-1}-1)_0}(\left|0\right\rangle + \alpha_{(2^{n-1}-1)_1}\left|1\right\rangle) \\ =& \left|00..0\right\rangle\left|\rho_0\right\rangle + \left|00..1\right\rangle\left|\rho_1\right\rangle + ... + \left|11..1\right\rangle\left|\rho_{2^{n-1}-1}\right\rangle \end{align*}\end{split}\]

ここで、それぞれの1量子ビット状態 \(\left|\rho_0\right\rangle, ..., \left|\rho_{2^{n-1}-1}\right\rangle\) は、 上の式に従って適切な角度 \(\phi\)\(\theta\) を見つけることで \(\left|0\right\rangle\) に取れます。 すべての状態でこれを同時に行うことは、最下位ビットの量子もつれをほどくユニタリ行列は次のようになります:

\[\begin{split}U = \begin{pmatrix} R_{y}(-\theta_0)R_{z}(-\phi_0) & & & &\\ & R_{y}(-\theta_1)R_{z}(-\phi_1) & & &\\ & . & & &\\ & & . & &\\ & & & & R_y(-\theta_{2^{n-1}-1})R_z(-\phi_{2^{n-1}-1}) \end{pmatrix}\end{split}\]

よって

\[\begin{split}U\left|\psi\right\rangle = \begin{pmatrix} r_0e^{it_0}\\ r_1e^{it_1}\\ . \\ . \\ r_{2^{n-1}-1}e^{it_{2^{n-1}-1}} \end{pmatrix}\otimes\left|0\right\rangle\end{split}\]

これはブロック対角行列なので、Uは「量子マルチプレクサー」ゲートとして実装できます。量子マルチプレクサーのフォーマリズムでは \(2^s\) 個のブロックから成る \(2^n \times 2^n\) のブロック対角行列は、\(s\) 個の選択制御量子ビットと \(n-s\) 個のデータ量子ビットをもつマルチプレクサーと等価です。選択制御量子ビットの状態に依って、対応するブロックがデータ量子ビットに適用されます。この種のマルチプレクサーはcx、rz、ryといった基本ゲートへ再帰的に分解することで実装することができます。

[76]:
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit SoftwareVersion
QiskitNone
Terra0.14.0
Aer0.6.0
Ignis0.3.0
AquaNone
IBM Q Provider0.6.1
System information
Python3.7.7 (default, Mar 26 2020, 10:32:53) [Clang 4.0.1 (tags/RELEASE_401/final)]
OSDarwin
CPUs4
Memory (Gb)16.0
Tue Apr 28 22:09:33 2020 EDT

This code is a part of Qiskit

© Copyright IBM 2017, 2020.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

[ ]: