Python on kenji.blog

使用 Qiskit 的量子程式設計超入門

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

1. 簡介

現代的電腦（古典電腦）戲劇性地改變了我們的生活，並以高度的運算能力支撐著社會的各個層面。然而，對於某些特定的問題（例如：巨大數字的質因數分解、複雜分子結構的模擬、最佳化問題等），已知即使是目前最先進的超級電腦，也需要比宇宙年齡更長的時間才能解決。

有望突破這種「古典電腦的極限」的就是量子電腦（Quantum Computer）。藉由將量子力學的奇妙特性（疊加與量子糾纏）作為運算資源來運用，被認為能夠將特定問題的處理速度戲劇性地加快。

在本文中，我們將使用 IBM 開源提供的量子運算框架 Qiskit，邁出進入量子程式設計世界的第一步。這是一份非常詳細的入門指南，從物理與數學的基礎開始仔細解說，涵蓋了實際使用 Python 撰寫程式碼，直到在模擬器上運行量子線路的整個過程。

2. 支撐量子運算的物理與數學基礎

為了理解量子程式設計，首先必須了解量子力學的基本概念。在此，我們將解說量子位元、疊加與量子糾纏這三個重要的支柱。

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）。

例如，當一個量子位元處於完全均等的疊加狀態時，$\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）。愛因斯坦稱這個現象為「鬼魅般的超距作用」，其性質是兩個以上的量子位元彼此強烈連結，當其中一個量子位元的狀態被決定時，無論物理距離有多遠，另一個量子位元的狀態也會瞬間被決定。

最著名的量子糾纏態「貝爾態（Bell State）」之一，$\Phi^+$ 狀態表示如下：

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

3. 量子邏輯閘（Quantum Logic Gates）

就像古典電腦使用 AND、OR、NOT 等邏輯閘進行運算一樣，量子電腦也使用量子閘來操作量子位元的狀態。由於量子狀態是向量，因此量子閘表示為作用於該向量的「酉矩陣（Unitary matrix）」。

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 閘（Hadamard Gate）

Hadamard 閘（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 閘）是在兩個量子位元之間進行操作的邏輯閘，是生成量子糾纏所不可或缺的。由「控制（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 個量子位元應用 Hadamard 閘（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) 應用 Hadamard 閘
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())

執行這段程式碼後，主控台上會顯示如下由 ASCII 藝術構成的量子線路圖。

1
2
3
4
5
6
7


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

H 代表 Hadamard 閘，■ 和 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 次 shots）
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}}$ 的理論預測完全一致。第一個量子位元如果是 0，第二個也必定是 0；如果是 1，則必定是 1。這種「量子糾纏」已被準確地模擬出來了。

此外，如果在實際的量子電腦硬體（IBM Quantum Hardware）上執行，受到雜訊（量子去相干或邏輯閘錯誤）的影響，可能偶爾會觀測到 01 或 10。如何減少這種雜訊（量子錯誤更正），是目前量子電腦開發中最大的課題之一。

6. 擴展至更高階的演算法

建立貝爾態可以說是量子程式設計的「Hello World」。從這裡進一步發展，就能建構出超越古典電腦的強大演算法。

6.1 Deutsch-Jozsa 演算法（Deutsch-Jozsa Algorithm）

這是判定給定的函數 $f(x)$ 是「常數函數（無論輸入為何，總是輸出 0 或總是輸出 1）」還是「平衡函數（對一半的輸入輸出 0，另一半輸出 1）」的問題。在古典電腦上，最壞的情況下需要對函數進行 $2^{n-1} + 1$ 次評估；但若使用 Deutsch-Jozsa 演算法，利用量子的平行性，僅需 1 次評估即可判定。這展示了輸入疊加狀態，並利用干涉（Interference）抵消不需要的狀態，放大所需答案的量子演算法基本模式。

6.2 Grover 演算法（Grover’s Algorithm）

在未排序的 $N$ 個資料庫中找出特定資料的搜尋問題中，古典演算法平均需要進行 $N/2$ 次運算，而 Grover 演算法僅需 $\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或超級電腦）來說是極度困難的」。然而，彼得·秀爾（Peter Shor）在1994年發表的「秀爾演算法（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["選擇一個小於 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：量子暫存器的初始化與疊加

首先準備兩個量子暫存器。第一個暫存器用來輸入狀態，第二個暫存器用來儲存函數的計算結果。初始狀態全部為 $|0\rangle$。

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

對第一個暫存器的所有量子位元套用阿達馬閘（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$，並將結果儲存於第二個暫存器中。

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

此時，第一暫存器與第二暫存器處於**量子糾纏（Entanglement）**狀態。如果（假設）我們觀測第二暫存器並得到特定的值 $k = a^{x_0} \bmod N$，那麼第一暫存器的狀態就會塌縮為所有能給出該值 $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）進行相位干涉

對第一個暫存器套用量子傅立葉轉換（Quantum Fourier Transform, QFT）。QFT是古典離散傅立葉轉換的量子版，能夠轉換狀態向量的振幅。QFT對基底狀態 $|x\rangle$ 的作用定義如下：

$$ 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時，只有在 $y$ 極為接近 $Q/r$ 的整數倍時，波才會產生建設性干涉（Constructive Interference）。除此之外的其他狀態，會因為**破壞性干涉（Destructive Interference）**使機率振幅互相抵消並趨近於零。

步驟4：測量與連分數展開

最後測量第一個暫存器。測量所得的值 $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，來模擬看看秀爾演算法。

在這裡，我們將實作最經典且著名的例子：「使用 $a=7$ 將 $N=15$ 進行質因數分解」。

執行環境準備

請事先安裝好Qiskit。

1

pip install qiskit qiskit-aer numpy

Python實作程式碼全貌

以下程式碼是專門針對 $N=15, a=7$ 的秀爾演算法實作範例。由於建立通用的模指數運算電路對現在的模擬器來說計算成本太高，因此我們將針對 $a=7$ 情況下的閘道動作進行寫死（hardcoding）。

 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)

 # 第一暫存器（控制暫存器）的初始化（產生疊加態）
 for q in range(n_count):
 qc.h(q)

 # 將第二暫存器（目標暫存器）初始化為 |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)])

 # 對第一暫存器套用反量子傅立葉轉換
 qc.append(qft_dagger(n_count), range(n_count))

 # 測量第一暫存器
 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:
 # 將位元字串轉換為十進位
 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位數的十進位數），目前還存在著許多難以跨越的障礙。

我們現在所處的時代，被稱為 NISQ（Noisy Intermediate-Scale Quantum：含雜訊中等規模量子）時代。量子位元對外部環境的雜訊極度敏感，計算途中容易發生「退相干（Decoherence）」導致狀態崩壞。

為了能準確執行像秀爾演算法這種具有深度（閘數量多）的電路，能修正雜訊的**量子錯誤更正（Quantum Error Correction）**是不可或缺的。為了創造出一個沒有雜訊的「邏輯量子位元」，需要透過表面碼（Surface Code）等方式將數千個「實體量子位元」進行編碼。

據估計，要破解2048位元的RSA加密，需要數千個完美的邏輯量子位元，這意味著必須要有搭載數百萬至數千萬個實體量子位元的容錯（Fault-tolerant）量子電腦才能實現。而目前最先進的量子處理器也只有幾百到幾千個實體量子位元左右，因此全世界的密碼並不會立刻被破解。

[!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 的「密碼敏捷性（Crypto-Agility：能快速切換密碼系統的設計）」，將會是未來的一大任務。

8. 結語

本文從秀爾演算法的理論數學背景開始，介紹了使用量子傅立葉轉換萃取週期的機制，並深入到使用Python與Qiskit的具體模擬程式碼，以約一萬字的篇幅進行了徹底的解說。

量子力學這種微觀世界的物理法則，竟然能從根本推翻作為宏觀資訊科學基礎的計算複雜度理論與密碼理論，這是科學史上最令人興奮的典範轉移之一。未來我們也絕對不能將目光從持續發展的量子運算技術，以及與之抗衡的新型密碼技術的攻防戰中移開。

請務必在您自己的環境中執行本次介紹的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/