Qiskit on kenji.blog

Qiskitを使った量子プログラミング超入門

Fri, 11 Sep 2026 20:00:00 +0900

1. はじめに

現代のコンピュータ（古典コンピュータ）は、私たちの生活を劇的に変化させ、高度な計算能力によって社会のあらゆる側面を支えています。しかし、一部の特定の問題（例えば、巨大な数の素因数分解、複雑な分子構造のシミュレーション、最適化問題など）においては、現在の最先端のスーパーコンピュータであっても、宇宙の年齢より長い時間が必要になることが知られています。

こうした「古典コンピュータの限界」を打ち破る可能性を秘めているのが**量子コンピュータ（Quantum Computer）**です。量子力学の不思議な性質（重ね合わせや量子もつれ）を計算資源として活用することで、特定の問題を劇的に高速化できると考えられています。

本記事では、IBMがオープンソースで提供している量子コンピューティングのフレームワークである**Qiskit（キスキット）**を用いて、量子プログラミングの世界へ第一歩を踏み出します。物理や数学の基礎から丁寧に解説し、実際にPythonでコードを書き、シミュレータ上で量子回路を動かすまでのプロセスを網羅した、非常に詳細な入門ガイドです。

2. 量子計算を支える物理と数学の基礎

量子プログラミングを理解するためには、まず量子力学の基本的な概念を理解する必要があります。ここでは、量子ビット、重ね合わせ、量子もつれという3つの重要な柱について解説します。

2.1 古典ビットと量子ビット（Qubit）

古典コンピュータの情報単位は「ビット（Bit）」です。ビットは常に 0 か 1 のどちらか一つの状態をとります。

一方、量子コンピュータの情報の最小単位は**量子ビット（Qubit: Quantum bit）**と呼ばれます。量子ビットは、0 と 1 の状態をとることができるだけでなく、その両方の状態を同時に保持することが可能です。

数学的には、量子ビットの状態 $|\psi\rangle$ は、基底状態 $|0\rangle$ と $|1\rangle$ の線形結合（重ね合わせ）として表現されます。

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

ここで、$\alpha$ と $\beta$ は複素数であり、それぞれ状態 $|0\rangle$ と $|1\rangle$ を観測する確率振幅を表します。量子力学の基本原理に基づき、確率の合計は1にならなければならないため、以下の規格化条件を満たします。

$$ |\alpha|^2 + |\beta|^2 = 1 $$

graph LR A["古典ビット (Classical Bit)"] --> B["確定した状態: 0 または 1"] C["量子ビット (Qubit)"] --> D["重ね合わせ: 0 と 1 の両方"] D --> E["測定によって確率的に状態が確定"]

2.2 重ね合わせ（Superposition）

先ほど述べたように、$|0\rangle$ と $|1\rangle$ の状態が混ざり合っている状態を**重ね合わせ（Superposition）**と呼びます。

例えば、1つの量子ビットが完全に均等な重ね合わせ状態にある場合、$\alpha = \frac{1}{\sqrt{2}}$、$\beta = \frac{1}{\sqrt{2}}$ となります。

$$ |\psi\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle $$

2.3 量子もつれ（Entanglement）

量子計算において最も強力かつ不思議な性質が**量子もつれ（Entanglement）**です。アインシュタインが「不気味な遠隔作用」と呼んだこの現象は、2つ以上の量子ビットが互いに強く結びつき、一方の量子ビットの状態が決定されると、物理的にどれだけ離れていても、もう一方の量子ビットの状態が瞬時に決定されるという性質です。

最も有名な量子もつれ状態である「ベル状態（Bell State）」の一つ、$\Phi^+$ 状態は次のように表されます。

$$ |\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}} $$

3. 量子論理ゲート（Quantum Logic Gates）

古典コンピュータがAND、OR、NOTなどの論理ゲートを用いて計算を行うように、量子コンピュータも量子ゲートを用いて量子ビットの状態を操作します。量子状態はベクトルであるため、量子ゲートはそのベクトルに作用する「ユニタリ行列」として表現されます。

3.1 パウリゲート（Pauli-X, Y, Z）

パウリゲートは、1量子ビットに対する基本的な操作です。

・Pauli-X ゲート (NOTゲート) 古典のNOTゲートに相当します。$|0\rangle$ を $|1\rangle$ に、$|1\rangle$ を $|0\rangle$ に反転させます。（ブロッホ球においてX軸周りの180度回転）

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

・Pauli-Y ゲート Y軸周りの180度回転を行います。位相とビットの両方を反転させる効果があります。

$$ Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} $$

・Pauli-Z ゲート (位相反転ゲート) $|0\rangle$ の状態はそのままに、$|1\rangle$ の状態の位相を反転（$-1$ を掛ける）させます。（Z軸周りの180度回転）

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

3.2 アダマールゲート（Hadamard Gate）

アダマールゲート（Hゲート）は、確定した状態（$|0\rangle$ や $|1\rangle$）を重ね合わせ状態に変換する、非常に重要なゲートです。

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

$|0\rangle$ にHゲートを適用すると、均等な重ね合わせ状態である $|+\rangle$ になります。

$$ H|0\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle = |+\rangle $$

3.3 位相ゲート（Phase Gates）

位相ゲートは、Zゲートを一般化したもので、$|1\rangle$ 状態の位相を指定した角度 $\theta$ だけ回転させます。

$$ P(\theta) = \begin{pmatrix} 1 & 0 \\ 0 & e^{i\theta} \end{pmatrix} $$

代表的なものとして、Sゲート（$\theta = \pi/2$）や Tゲート（$\theta = \pi/4$）があります。

3.4 CNOTゲート（Controlled-NOT Gate）

CNOTゲート（CXゲート）は、2つの量子ビット間で操作を行うゲートで、量子もつれを生成するために不可欠です。「制御（Control）ビット」と「標的（Target）ビット」から構成されます。

制御ビットが $|1\rangle$ の場合のみ、標的ビットにXゲート（NOT操作）を適用し、制御ビットが $|0\rangle$ の場合は何もしません。

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

4. Qiskitの基本と環境構築

ここからは、実際にPythonとQiskitを使用して量子プログラムを書いていきます。

4.1 Qiskitとは？

Qiskitは、IBM Quantumが開発したオープンソースの量子コンピューティング向けソフトウェア開発キット（SDK）です。Pythonを用いて直感的に量子回路を構築し、ローカルのシミュレータや、クラウド経由で実際のIBMの量子コンピュータ実機で実行することができます。

4.2 インストール方法

Qiskitを利用するためには、Python環境が必要です。以下のコマンドでQiskitと関連パッケージ（シミュレータや描画用ライブラリ）をインストールします。

1

pip install qiskit qiskit-aer qiskit-ibm-runtime matplotlib pylatexenc

4.3 プログラミングの基本フロー

Qiskitを使った量子プログラミングは、主に以下のステップで進行します。

graph TD A["1. 回路の構築 (Build)"] --> B["2. コンパイル/トランスパイル (Compile)"] B --> C["3. 実行 (Execute)"] C --> D["4. 結果の解析と可視化 (Analyze)"]

回路の構築: QuantumCircuit オブジェクトを作成し、ゲートを追加していく。
コンパイル: 実行するバックエンド（実機やシミュレータ）に合わせて回路を最適化。
実行: バックエンドにジョブを送信し、結果を取得。
解析: 測定結果のヒストグラムなどをプロット。

5. 実践：ベル状態（量子もつれ）を作る回路の構築

理論で学んだ「量子もつれ（ベル状態）」を、実際にQiskitで作成してみましょう。目標とする状態は $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$ です。

5.1 回路の設計

ベル状態を作るには、以下の手順を踏みます。

2つの量子ビットを用意する（初期状態はどちらも $|0\rangle$）。
1つ目の量子ビットにアダマールゲート（H）を適用し、重ね合わせ状態にする。
1つ目の量子ビットを「制御ビット」、2つ目の量子ビットを「標的ビット」として、CNOTゲートを適用する。
結果を読み取るために測定（Measure）を行う。

5.2 Python/Qiskit コード実装

それでは、実際のコードを見てみましょう。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

# 1. 回路の初期化
# 2つの量子ビットと、2つの古典ビットを持つ量子回路を作成
qc = QuantumCircuit(2, 2)

# 2. Hゲートの適用
# 量子ビット 0 (q0) にアダマールゲートを適用
qc.h(0)

# 3. CNOTゲートの適用
# q0 を制御ビット、q1 を標的ビットとして CNOT を適用
qc.cx(0, 1)

# 4. 測定
# 量子ビット 0 と 1 を測定し、古典ビット 0 と 1 にそれぞれ書き込む
qc.measure([0, 1], [0, 1])

# 回路図を描画 (matplotlibを使用)
# qc.draw('mpl')
print(qc.draw())

このコードを実行すると、コンソール上にアスキーアートで以下のような量子回路図が表示されます。

1
2
3
4
5
6
7


 ┌───┐ ┌─┐
q_0: ┤ H ├──■──┤M├───
 └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
 └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
 0 1

H がアダマールゲート、■ と X の組み合わせがCNOTゲート、M が測定を表しています。

5.3 シミュレータでの実行と結果の解釈

次に、この回路をIBMの高性能シミュレータ Aer で実行し、結果を確認します。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# Aerシミュレータのバックエンドを取得
simulator = Aer.get_backend('qasm_simulator')

# シミュレータ向けに回路をトランスパイル（最適化）
compiled_circuit = transpile(qc, simulator)

# 回路を実行（ここでは1000回ショットを実行）
job = simulator.run(compiled_circuit, shots=1000)

# 結果を取得
result = job.result()

# 状態の観測回数（カウント）を取得
counts = result.get_counts(compiled_circuit)
print("\n測定結果:", counts)

# ヒストグラムのプロット
# plot_histogram(counts)
# plt.show()

結果の解釈

コンソールの出力は以下のようになるはずです。 測定結果: {'00': 495, '11': 505} （※確率はランダムなため、実行ごとに数値はわずかに変動します）

理想的なシミュレーション環境では、測定結果は 00 と 11 がおよそ50%ずつ観測され、01 や 10 は一切観測されません。これはまさに、私たちが作成したベル状態 $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$ の理論的予測と完全に一致しています。1つ目の量子ビットが0であれば2つ目も必ず0、1であれば必ず1になるという「量子もつれ」が正確にシミュレートされています。

なお、実機の量子コンピュータ（IBM Quantum Hardware）で実行した場合、ノイズ（量子デコヒーレンスやゲートエラー）の影響により、わずかに 01 や 10 が観測されることがあります。このノイズをいかに減らすか（量子誤り訂正）が、現在の量子コンピュータ開発における最大の課題の一つです。

6. より高度なアルゴリズムへのスケールアップ

ベル状態の作成は量子プログラミングの「Hello World」とも言えます。ここからさらに発展させることで、古典コンピュータを凌駕する強力なアルゴリズムを構築できます。

6.1 ドイチェ・ジョサのアルゴリズム（Deutsch-Jozsa Algorithm）

与えられた関数 $f(x)$ が「定数関数（入力に関わらず常に0または常に1を出力する）」か「均衡関数（半分の入力に対して0、残りの半分に対して1を出力する）」のどちらであるかを判定する問題です。古典コンピュータでは最悪の場合 $2^{n-1} + 1$ 回の関数の評価が必要ですが、ドイチェ・ジョサのアルゴリズムを使えば、量子の並列性を利用してたった1回の評価で判定することができます。これは、重ね合わせ状態を入力し、干渉（Interference）を利用して不要な状態を打ち消し、欲しい答えを増幅させるという量子アルゴリズムの基本パターンを示しています。

6.2 グローバーのアルゴリズム（Grover’s Algorithm）

ソートされていない $N$ 個のデータベースから特定のデータを探し出す検索問題において、古典アルゴリズムが平均 $N/2$ 回の計算を要するのに対し、グローバーのアルゴリズムは $\sqrt{N}$ 回で目的のデータを見つけ出すことができます。このアルゴリズムは、「オラクル（Oracle）」と呼ばれるブラックボックスを用いて目的の解の位相を反転させ、さらに「振幅増幅（Amplitude Amplification）」を行うことで、目的の解が観測される確率を劇的に高めます。

graph TD A["初期化 (すべての状態の重ね合わせ)"] --> B["オラクル (正解の位相を反転)"] B --> C["拡散演算子 (平均値周りの反転による振幅増幅)"] C --> D{"十分な確率に達したか？"} D -- "No" --> B D -- "Yes" --> E["測定"]

7. まとめとこれからの学習

この記事では、量子コンピューティングの根本的な概念である重ね合わせや量子もつれから始まり、Qiskitを用いた量子論理ゲートの操作、そして実際にベル状態を構築・シミュレーションして結果を解釈するまでを詳細に解説しました。

QiskitはPythonという親しみやすい言語で記述できるため、数学的・物理的な壁を越えて、アルゴリズムの構築に集中させてくれる強力なツールです。量子コンピュータは現在、ノイズを伴う中規模量子デバイス（NISQ: Noisy Intermediate-Scale Quantum）の時代にありますが、機械学習（Quantum Machine Learning）、化学シミュレーション（Quantum Chemistry）、暗号解読など、数多くの分野での応用研究が世界中で急速に進められています。

ぜひ、この機会にQiskitを使って様々な量子回路を自作し、実機のIBM Quantumプロセッサで動かしてみてください。未来のコンピューティング・パラダイムをその手で体験できるはずです。

参考資料

Qiskit公式ドキュメント
Qiskit Textbook - より深く数学的背景やアルゴリズムを学びたい方におすすめの公式テキスト
IBM Quantum Learning

量子の世界へようこそ！

ショアのアルゴリズムをPythonでシミュレーションしてみた

Fri, 11 Sep 2026 08:00:00 +0900

1. はじめに：量子コンピュータがもたらす暗号の危機

現代のインターネット社会におけるセキュリティの大部分は、公開鍵暗号方式（特にRSA暗号）に依存しています。私たちがオンラインショッピングでクレジットカード情報を送信する際や、機密性の高いデータをやり取りする際、その通信内容はRSA暗号によって強固に守られています。

RSA暗号の安全性の根拠は、「巨大な整数の素因数分解は、古典コンピュータ（私たちが普段使っているPCやスーパーコンピュータ）では極めて困難である」という数学的な事実に依存しています。しかし、1994年にピーター・ショア（Peter Shor）が発表した「ショアのアルゴリズム（Shor’s Algorithm）」は、この前提を根底から覆すものでした。ショアのアルゴリズムを大規模な量子コンピュータ上で実行すれば、古典コンピュータでは宇宙の年齢以上の時間を要する素因数分解を、わずか数分から数時間で解くことができると数学的に証明されたのです。

本記事では、このショアのアルゴリズムがいかにして素因数分解を高速に行うのか、その数学的な仕組みから、Pythonと量子計算フレームワークであるQiskitを用いた具体的なシミュレーション実装までを、徹底的に詳細に解説していきます。

2. 計算量の劇的な変化：指数関数から多項式時間へ

なぜ素因数分解が難しいのでしょうか？古典コンピュータにおける最良の素因数分解アルゴリズムとして知られる「一般数体ふるい法（General Number Field Sieve, GNFS）」を用いたとしても、その計算量は準指数関数的になります。

桁数 $N$ の合成数を素因数分解するのにかかる時間計算量は、古典的な手法では以下のようになります。

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

このため、鍵長を長くする（例えば2048ビットや4096ビットにする）だけで、古典コンピュータでの解読には数千年、数万年といった現実的ではない時間がかかるようになります。

しかし、量子コンピュータ上でショアのアルゴリズムを用いると、計算量は入力のビット数 $\log N$ に対して多項式時間へと劇的に削減されます。

$$ O((\log N)^3) $$

これは、ビット数を2倍にした場合、古典コンピュータでは計算時間が天文学的に増大するのに対し、量子コンピュータでは計算時間がせいぜい8倍程度にしか増えないことを意味します。この**指数関数時間から多項式時間への計算量クラスの削減（BQPクラスへの包含）**こそが、ショアのアルゴリズムの真の凄みです。

graph TD A["入力サイズ(ビット数) Nの増加"] --> B{"アルゴリズムの選択"} B -->|古典: 一般数体ふるい法| C["準指数関数的増加 O(exp(...))"] B -->|量子: ショアのアルゴリズム| D["多項式時間 O((log N)^3)"] C --> E["数千年〜数十億年 (解読不能)"] D --> F["数分〜数時間 (現実的な時間で解読)"]

3. アルゴリズムの全体像と数学的背景

ショアのアルゴリズムは、実はすべてを量子コンピュータで行うわけではありません。古典コンピュータによる前処理・後処理と、量子コンピュータによる核心部分（周期発見アルゴリズム）の連携によって成り立っています。

アルゴリズムの全体的な流れは以下のようになります。

graph TD A["入力: 素因数分解したい合成数 N"] --> B["a < N なる乱数 a を選ぶ"] B --> C{"gcd(a, N) > 1 ?"} C -- "Yes" --> D["自明な因数 gcd(a, N) を出力して終了"] C -- "No" --> E["量子アルゴリズムで f(x) = a^x mod N の周期 r を見つける"] E --> F{"r が偶数かつ a^(r/2) ≢ -1 mod N ?"} F -- "No" --> B F -- "Yes" --> G["因数 p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N) を計算"] G --> H["出力: p, q"]

素因数分解から周期発見問題への帰着

ショアの天才的なひらめきは、「素因数分解問題」を「周期発見問題（Order Finding Problem）」に変換したことにあります。

整数 $N$（素因数分解したい数）と、互いに素な整数 $a$（$1 < a < N$）を考えます。次のようなモジュラー指数関数を定義します。

$$ f(x) = a^x \bmod N $$

この関数は、ある周期 $r$ を持ちます。つまり、任意の $x$ に対して $f(x+r) = f(x)$ が成り立ちます。特に $x=0$ のとき、

$$ a^r \equiv 1 \pmod N $$

となる最小の正の整数 $r$ を「$a$ の $N$ を法とする位数（Order）」と呼びます。この周期 $r$ を見つけることができれば、次のようにして素因数を導き出すことができます。

式を変形すると、

$$ a^r - 1 \equiv 0 \pmod N $$

もし $r$ が偶数であれば、平方差の公式を用いて因数分解できます。

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

これは、$N$ が $(a^{r/2} - 1)$ または $(a^{r/2} + 1)$ のいずれかと公約数を持つことを意味します（ただし $a^{r/2} \not\equiv -1 \pmod N$ という条件を満たす必要があります）。したがって、ユークリッドの互除法を用いて、

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

を計算すれば、$N$ の非自明な素因数 $p, q$ を見つけることができるのです。この計算（最大公約数の計算や乱数の生成）は、古典コンピュータで非常に高速に行えます。問題は、周期 $r$ をどのようにして高速に見つけるかという点に絞られます。古典コンピュータでは、この周期 $r$ を見つけること自体が指数関数的な時間を要してしまいます。ここで量子コンピュータの出番となります。

4. 量子アルゴリズム部分：周期発見の仕組み

量子コンピュータを用いて周期 $r$ を見つけるためのサブルーチンは、以下の4つのステップで構成されます。

graph LR subgraph "量子状態の推移" S1["|0⟩|0⟩ (初期化)"] --> S2["Hゲート: 重ね合わせ Σ|x⟩|0⟩"] S2 --> S3["オラクル U: Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT: 干渉による周期抽出"] S4 --> S5["測定: 近似値 y の取得"] end

ステップ1：量子レジスタの初期化と重ね合わせ

まず、2つの量子レジスタを用意します。第1レジスタは状態を入力するためのもので、第2レジスタは関数の計算結果を格納するためのものです。初期状態は全て $|0\rangle$ です。

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

第1レジスタのすべての量子ビットにアダマールゲート（Hadamard Gate）を適用し、考え得るすべての入力 $x$ （$0$ から $Q-1$ まで、$Q=2^n$）の等確率な重ね合わせ状態を作り出します。

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |0\rangle_2 $$

これにより、量子コンピュータは一度の演算で $Q$ 個すべての入力に対する状態を同時に保持することになります。これが量子並列性の強力な源泉です。

ステップ2：オラクル関数（モジュラーべき乗）の適用

次に、量子演算回路 $U_f$ を用いて、関数 $f(x) = a^x \bmod N$ を計算し、その結果を第2レジスタに格納します。

$$ |\psi_2\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |a^x \bmod N\rangle_2 $$

この時点で、第1レジスタと第2レジスタは**量子もつれ（エンタングルメント）**の状態にあります。もし（仮に）第2レジスタを観測して特定の値 $k = a^{x_0} \bmod N$ を得たとすると、第1レジスタの状態は、その値 $k$ を与えるような $x$ の重ね合わせ状態に崩壊します。関数の周期が $r$ であるため、残る状態は $x_0, x_0+r, x_0+2r, \dots$ という $r$ 飛ばしの値になります。

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

しかし、私たちは $x_0$ を知りたいわけではなく、周期 $r$ 自体を知りたいのです。この状態から $r$ を直接観測することは不可能です。そこで、量子フーリエ変換を用います。

ステップ3：量子フーリエ変換（QFT）による位相干渉

第1レジスタに対して**量子フーリエ変換（Quantum Fourier Transform, QFT）**を適用します。QFTは古典的な離散フーリエ変換の量子版であり、状態ベクトルの振幅を変換します。基底状態 $|x\rangle$ に対するQFTの作用は以下のように定義されます。

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

ここで、$\omega = e^{2\pi i / Q}$ です。

QFTを適用すると、状態の振幅が干渉を起こします。数学的な詳細は省きますが、周期 $r$ を持つ状態に対してQFTを適用すると、波が**建設的干渉（Constructive Interference）を起こすのは、$y$ が $Q/r$ の整数倍に極めて近い値のときだけになります。それ以外の状態は破壊的干渉（Destructive Interference）**により確率振幅が相殺され、ゼロに近づきます。

ステップ4：測定と連分数展開

最後に第1レジスタを測定します。測定によって得られる値 $y$ は、高い確率で以下の条件を満たします。

$$ y \approx c \frac{Q}{r} \implies \frac{y}{Q} \approx \frac{c}{r} $$

（$c$ は $0 \le c < r$ の未知の整数です）

得られた有理数 $y/Q$ に対して古典アルゴリズムである**連分数展開（Continued Fraction Expansion）**を適用することで、近似分数 $c/r$ を計算し、分母から周期 $r$ を抽出します。

5. PythonとQiskitを用いたシミュレーション実装

理論だけでは実感が湧かないため、実際にPythonとIBMの量子計算フレームワークであるQiskitを用いて、ショアのアルゴリズムをシミュレーションしてみましょう。

ここでは、最も古典的で有名な例である 「$N=15$ を $a=7$ を用いて素因数分解する」 というシナリオを実装します。

実行環境の準備

あらかじめQiskitをインストールしておいてください。

1

pip install qiskit qiskit-aer numpy

Python実装コードの全体像

以下のコードは、$N=15, a=7$ に特化したショアのアルゴリズムの実装例です。汎用的なモジュラーべき乗回路を組むのは現在のシミュレータでは計算コストが高すぎるため、特定の $a=7$ の場合のゲート動作をハードコーディングしています。

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. 逆量子フーリエ変換 (QFT†) を構築する関数
def qft_dagger(n):
 """n量子ビットの逆量子フーリエ変換回路を生成する"""
 qc = QuantumCircuit(n)
 # 順序を反転するためのSWAPゲート
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # 制御位相ゲートとHゲートの適用
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. 7^x mod 15 の制御モジュラーべき乗演算を構築する関数
def c_amod15(a, power):
 """特定のaとべき乗に対する制御Uゲートを生成する(N=15専用)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # a=7の場合の 7^x mod 15 のハードコーディング論理
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. メインの量子回路構成
def shor_circuit(a, n_count):
 # n_count: 制御レジスタのビット数
 # ターゲットレジスタは 0〜15 を表現するため 4ビット
 qc = QuantumCircuit(n_count + 4, n_count)

 # 第1レジスタ（制御レジスタ）の初期化（重ね合わせの生成）
 for q in range(n_count):
 qc.h(q)

 # 第2レジスタ（ターゲットレジスタ）を |1> (0001) に初期化
 qc.x(3 + n_count)

 # 制御モジュラーべき乗演算（オラクル）の適用
 for q in range(n_count):
 # 2^q 乗の演算を適用
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # 第1レジスタに逆量子フーリエ変換を適用
 qc.append(qft_dagger(n_count), range(n_count))

 # 第1レジスタを測定
 qc.measure(range(n_count), range(n_count))
 return qc

# --- 実行セクション ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # 制御レジスタに8量子ビットを使用 (Q=256)

 print(f"探索設定: N={N}, a={a}, 制御量子ビット数={n_count}")

 # 回路の生成
 qc = shor_circuit(a, n_count)

 # シミュレータでの実行
 sim = AerSimulator()
 # 最新のQiskitではtranspileを推奨
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\n測定結果(ビット列: 観測回数):")
 for bitstring, count in counts.items():
 print(f" {bitstring}: {count}回")

 # 古典的後処理: 連分数展開による周期rの特定
 print("\n--- 周期の計算と素因数分解 ---")
 phases = []
 for output in counts:
 # ビット列を10進数に変換
 decimal = int(output, 2)
 # 位相 = 測定値 / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # 連分数展開によって近似分数を取得。分母の上限は N=15
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"観測値: {decimal:3d} | 位相: {phase:.4f} | 連分数: {frac} | 推定周期 r = {r}")

 # 周期 r が偶数かつ有効な結果をもたらすか確認
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => 成功！ {N} の素因数は {guess1} と {guess2} です。")
 else:
 print(f" => 自明な因数のみ。やり直し。")
 else:
 print(f" => 周期が奇数のため失敗。")

コードの解説と実行結果の解析

上記のコードを実行すると、制御レジスタの測定結果として、高い確率で特定のピーク（観測値）が得られます。n_count=8（$Q=256$）の場合、理想的な量子コンピュータ（またはシミュレータ）であれば、観測値として 0, 64, 128, 192 のような数値が圧倒的な確率で出現します。

これらを $Q=256$ で割ると、位相 $y/Q$ はそれぞれ $0.0$, $0.25$, $0.5$, $0.75$ となります。この位相を連分数展開すると：

$0.25 \to 1/4$ （推定周期 $r=4$）
$0.50 \to 1/2$ （推定周期 $r=2$）
$0.75 \to 3/4$ （推定周期 $r=4$）

ここで得られた周期 $r=4$ を用いて、素因数を計算します。 $a=7, r=4$ なので、 $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

見事に、$15 = 3 \times 5$ の素因数分解に成功しました。

[!TIP] 測定値として $y=128$（位相 $0.5$）が得られた場合、分母は $2$ となり、真の周期 $r=4$ ではなくその約数を得てしまいます。このような場合は、アルゴリズムを複数回実行するか、得られた $r$ の倍数を調べることで真の周期にたどり着くことができます。

6. 実用化に向けた課題と NISQ 時代の限界

シミュレータ上で $N=15$ を素因数分解することは簡単にできましたが、実社会で使われているRSA-2048（617桁の10進数）を素因数分解するには、現実の量子コンピュータにはまだ数多くの壁が存在します。

現在私たちが生きている時代は、NISQ（Noisy Intermediate-Scale Quantum：ノイズあり中規模量子）時代と呼ばれています。量子ビットは外部環境のノイズに対して極めて脆弱であり、計算途中で「デコヒーレンス」を起こして状態が壊れてしまいます。

ショアのアルゴリズムのような深い（ゲート数が多い）回路を正確に実行するためには、ノイズを訂正する**量子誤り訂正（Quantum Error Correction）**が不可欠です。一つのノイズのない「論理量子ビット」を作り出すために、数千個の「物理量子ビット」を表面符号（Surface Code）などでエンコードする必要があります。

2048ビットのRSA暗号を破るためには、数千個の完璧な論理量子ビットが必要であり、それを実現するには数百万から数千万個の物理量子ビットを搭載したフォールトトレラント（誤り耐性）量子コンピュータが必要になると見積もられています。現在の最先端の量子プロセッサでも数百〜数千物理量子ビット程度であるため、直ちに世界中の暗号が破られるわけではありません。

[!WARNING] しかし、「Store Now, Decrypt Later（今保存して、後で解読する）」という脅威モデルが存在します。攻撃者は現在暗号化されている機密通信を暗号データのまま大量に保存しておき、10〜20年後に強力な量子コンピュータが完成した瞬間に全てを解読するという戦略をとる可能性があります。

7. 耐量子計算機暗号（PQC）への移行

このような「Q-Day（量子コンピュータが暗号を破る日）」の到来に備え、アメリカ国立標準技術研究所（NIST）を筆頭に、世界中の暗号学者が**耐量子計算機暗号（Post-Quantum Cryptography, PQC）**の策定を進めています。

PQCは、ショアのアルゴリズムを用いても（あるいはグローバーのアルゴリズムを用いても）効率的に解くことができないと数学的に考えられている新しい数学的問題（格子問題、多変数多項式問題、ハッシュ関数ベースなど）を基盤としています。すでに「CRYSTALS-Kyber」や「CRYSTALS-Dilithium」といったアルゴリズムが標準規格として選定され、AppleのiMessageや各種ウェブブラウザの通信プロトコルへの導入が徐々に始まっています。

ITインフラを管理するエンジニアにとって、既存のRSAや楕円曲線暗号からPQCへの「クリプト・アジリティ（暗号の俊敏性：素早く暗号方式を切り替えられる設計）」をシステムに組み込むことが、今後の大きなミッションとなるでしょう。

8. おわりに

本記事では、ショアのアルゴリズムの理論的な数学的背景から始まり、量子フーリエ変換を用いた周期抽出のメカニズム、そしてPythonとQiskitを用いた具体的なシミュレーションコードまで、1万文字規模のボリュームで徹底的に解説を行いました。

量子力学というミクロな世界の物理法則が、マクロな情報科学の根幹である計算量理論や暗号理論を根本から覆してしまうという事実は、科学の歴史において最もエキサイティングなパラダイムシフトの一つです。現在進行形で発展し続ける量子コンピューティング技術と、それに立ち向かう新しい暗号技術の攻防戦から、今後も目が離せません。

ぜひ、今回紹介したPythonコードをご自身の環境で実行し、量子状態の重ね合わせと干渉が生み出す「計算の魔法」を体感してみてください。

参考文献

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Qiskit Documentation: https://qiskit.org/documentation/