量子隨機數生成與超密集編碼技術

– 9 分鐘閱讀

量子隨機數生成器是量子計算的重要應用之一，它利用量子力學的特性產生真正的隨機數，不同於傳統電腦的偽隨機數。本文將介紹如何使用 Qiskit 框架建構量子電路，並透過 Hadamard 閘和測量操作生成隨機數。同時，我們也會探討超密集編碼技術，這是一種利用量子糾纏態在單一量子位元上編碼兩個經典位元的量子通訊協定。文章將詳細說明 Bell Pair 的生成、傳送端與接收端的編碼和解碼過程，並提供使用 IBM Q Experience Composer 和 Python 程式碼的實作範例，最後會簡述超密集編碼與量子隱形傳態之間的關聯性，並討論如何在量子計算領域中應用這些技術。

量子隨機數生成與超密集編碼技術解析

量子隨機數生成原理與實作

在量子運算領域中，隨機數的生成是一項重要的應用。傳統的電腦使用偽隨機數生成器，而量子電腦則能夠利用量子力學的原理生成真正的隨機數。

實作範例：使用 Qiskit 生成隨機數

以下是一個使用 Qiskit 框架生成隨機數的 Python 程式範例：

import sys
import time
import qiskit
from qiskit import QuantumProgram

# 載入 Q Experience 組態
sys.path.append('../Config/')
import Qconfig

def qrng(n):
    # 建立量子程式
    qp = QuantumProgram()
    # 建立 n 個量子位元
    quantum_r = qp.create_quantum_register("qr", n)
    # 建立 n 個經典暫存器
    classical_r = qp.create_classical_register("cr", n)
    # 建立電路
    circuit = qp.create_circuit("QRNG", [quantum_r], [classical_r])
    
    # 對所有量子位元套用 Hadamard 閘
    for i in range(n):
        circuit.h(quantum_r[i])
    
    # 測量量子位元並儲存結果到經典暫存器
    for i in range(n):
        circuit.measure(quantum_r[i], classical_r[i])
    
    # 設定後端模擬器
    backend = 'ibmq_qasm_simulator'
    circuits = ['QRNG']
    
    # 編譯程式並設定 API Token 和 Q Experience API URL
    qp.set_api(Qconfig.APItoken, Qconfig.config['url'])
    shots = 1024
    result = qp.execute(circuits, backend, shots=shots, max_credits=3, timeout=240)
    
    # 取得測量結果
    counts = result.get_counts('QRNG')
    bits = ""
    for v in counts.values():
        if v > shots / (2 ** n):
            bits += "1"
        else:
            bits += "0"
    
    # 將二進位制字串轉換為整數
    return int(bits, 2)

if __name__ == '__main__':
    start_time = time.time()
    numbers = []
    size = 10
    qubits = 3  # bits = 2**qubits
    
    # 生成 10 個 8 位元隨機數
    for i in range(size):
        n = qrng(qubits)
        numbers.append(n)
    
    print("生成的隨機數列表：" + str(numbers))
    print("執行時間：%s 秒" % (time.time() - start_time))

內容解密：

  1. 建立量子程式和電路：首先，建立一個量子程式 qp，並在其中建立 n 個量子位元和 n 個經典暫存器。然後，建立一個名為 “QRNG” 的量子電路。
  2. 套用 Hadamard 閘：對所有量子位元套用 Hadamard 閘，使它們處於疊加態。
  3. 測量量子位元：測量每個量子位元，並將結果儲存到對應的經典暫存器中。
  4. 執行電路：使用 ibmq_qasm_simulator 後端模擬器執行電路，並設定執行次數 shots 為 1024。
  5. 處理測量結果：根據測量結果的計數，生成一個二進位制字串。如果某個結果的計數大於平均機率（shots / (2 ** n)），則對應的位元為 1，否則為 0。
  6. 轉換為整數：將生成的二進位制字串轉換為整數，並傳回。

超密集編碼技術簡介

超密集編碼（Super Dense Coding, SDC）是一種利用量子糾纏特性來傳輸經典資訊的協定。它允許傳送者透過傳輸一個量子位元來傳送兩個經典位元的資訊。

超密集編碼原理

超密集編碼協定涉及兩個參與者：傳送者和接收者。他們分享一對糾纏的量子位元。傳送者透過對自己的量子位元進行特定的操作，可以將兩個經典位元的資訊編碼到這個量子位元上。然後，傳送者將這個量子位元傳輸給接收者。接收者透過測量這個量子位元和他自己的糾纏量子位元，可以解碼出傳送者傳輸的兩個經典位元資訊。

量子超密集編碼技術解析

超密集編碼協定的基礎

超密集編碼是一種量子通訊協定，允許Alice使用一個量子位元（qubit）向Bob傳送兩個經典位元（bit）的資訊。該協定的基礎是建立在量子糾纏態的基礎上，第三者Eve首先生成一對Bell Pair，即兩個量子位元的糾纏態。

Bell Pair的生成過程

  1. Eve首先將兩個量子位元初始化為基態|0⟩。
  2. 對第一個量子位元施加Hadamard門（H門），使其進入疊加態：$\frac{|0\rangle + |1\rangle}{\sqrt{2}}$。
  3. 對第一個量子位元（控制位元）和第二個量子位元（目標位元）施加CNOT門，生成糾纏態：$\frac{|00\rangle + |11\rangle}{\sqrt{2}}$。

編碼規則

Alice根據要傳送的兩個經典位元，對她的量子位元施加不同的量子門：

  • 傳送00：不施加任何門（即施加單位門I）。
  • 傳送01：施加X門（位元翻轉）。
  • 傳送10：施加Z門（相位翻轉）。
  • 傳送11：先施加X門，再施加Z門。

解碼過程

Bob接收到Alice的量子位元後，使用他的量子位元進行解碼：

  1. 對Alice的量子位元和他的量子位元施加CNOT門。
  2. 對Alice的量子位元施加Hadamard門（H門）。
  3. 對兩個量子位元進行測量，得到兩個經典位元。

實作超密集編碼的量子電路

使用IBM Q Experience Composer實作

在IBM Q Experience Composer中，可以構建超密集編碼的量子電路：

  1. 首先生成Bell Pair。
  2. Alice根據要傳送的資訊對她的量子位元施加相應的量子門。
  3. Bob對接收到的量子位元進行解碼操作。

使用Python指令碼實作

from qiskit import QuantumCircuit, execute, Aer
from qiskit.tools.visualization import plot_histogram

# 建立量子電路
qc = QuantumCircuit(2, 2)

# 生成Bell Pair
qc.h(0)
qc.cx(0, 1)

# Alice的編碼操作（例如傳送11）
qc.x(0)
qc.z(0)

# Bob的解碼操作
qc.cx(0, 1)
qc.h(0)

# 測量
qc.measure([0, 1], [0, 1])

# 執行電路
simulator = Aer.get_backend('qasm_simulator')
job = execute(qc, simulator)
result = job.result()

# 繪製測量結果
counts = result.get_counts(qc)
plot_histogram(counts)

內容解密：

  1. 生成Bell Pair：透過Hadamard門和CNOT門生成兩個量子位元的糾纏態，為超密集編碼奠定基礎。
  2. Alice的編碼：根據要傳送的兩個經典位元，對她的量子位元施加相應的量子門，以編碼資訊。
  3. Bob的解碼：透過CNOT門和Hadamard門對接收到的量子位元進行解碼，最終測量得到兩個經典位元。

超密集編碼的結果分析與量子隱形傳態原理

超密集編碼結果解讀

在執行超密集編碼的程式碼（Listing 5-2）後，我們可以觀察到以下標準輸出結果：

OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0],q[1];
z q[0];
x q[0];
barrier q[0],q[1];
cx q[0],q[1];
h q[0];
measure q[0] -> c[0];
measure q[1] -> c[1];
Counts:{'11': 1024}
---
 167.52969431877136 seconds 
---

結果分析

指令碼輸出了電路的組合語言程式碼以及結果的計數：{'11': 1024}，並顯示了執行時間。結果計數用於透過將實驗次數（1024）除以結果計數（1024）來計算結果的機率。因此，對於結果 11 的機率為 1，如 Listing 5-2 最後一步執行的圖表（Figure 5-7）所示。

模擬器與真實量子裝置的差異

值得注意的是，當在模擬器中執行時，機率始終為 1，即計數等於實驗次數。然而，如果在真實的量子裝置上執行，由於噪聲和環境誤差，計數應該小於 1024，從而導致機率小於 1。

超密集編碼的原理與應用

超密集編碼提供了一種將 2 個經典位元編碼到單個量子位元中的方法。乍看之下，這似乎與量子計算中每個量子位元只能儲存一個經典位元的原則相矛盾。然而，這裡並沒有真正的矛盾。該協定之所以有效，是因為 Alice 和 Bob 的量子位元透過 Bell 對（Bell Pair）糾纏在一起。這使得 Alice 能夠透過她的糾纏量子位元傳送 2 個經典位元。

模組化抽象

總的來說，這個協定可以被解釋為一組模組化的抽象：

  1. Bell 對生成模組：建立 2 個糾纏的量子位元。
  2. 資訊編碼模組：應用 Alice 的規則來編碼 2 個經典位元的資訊。
  3. 解碼模組：從 Bell 對提供的量子位元以及編碼模組中提取經典位元。

超密集編碼的重要性

超密集編碼為量子資訊處理提供了一個高層次的圖景，並將有助於理解本章下一個主題：量子隱形傳態。

量子隱形傳態原理

量子隱形傳態是一種與超密集編碼密切相關的過程。它的正式定義是，透過經典通訊和一個 Bell 對的幫助，將一個量子位元（ψ）的狀態從一個位置傳輸到另一個位置。

量子隱形傳態的工作流程

  1. Alice 和 Bob 首先分享一個 Bell 對，其中一個量子位元歸 Alice 所有，另一個歸 Bob 所有。
  2. Alice 將她要傳輸的量子位元準備在狀態 |ψ⟩ = α|0⟩ + β|1⟩，然後對她的量子位元和來自 Bell 對的糾纏量子位元進行 Bell 基測量。Alice 將測量結果透過經典通訊傳送給 Bob。
  3. Bob 根據 Alice 的測量結果，應用適當的量子門來還原原始狀態 ψ。

後驗狀態分析

在 Alice 測量之後，Bob 的量子位元會處於某個後驗狀態。透過分析三個量子位元的聯合狀態，可以得出 Bob 如何還原 Alice 的原始狀態 ψ。

測量結果與還原操作

透過 Bell 基測量，Alice 的測量結果會影響 Bob 的量子位元狀態。根據測量結果的不同，Bob 可以透過應用相應的量子門來還原原始狀態，如 Table 5-5 所示。

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultTextAlignment center
skinparam rectangleBackgroundColor #F5F5F5
skinparam rectangleBorderColor #333333
skinparam arrowColor #333333

title 測量結果與還原操作

rectangle "Bell Pair" as node1
rectangle "Measurement Result" as node2
rectangle "Recovery Operation" as node3

node1 --> node2
node2 --> node3

@enduml

此圖示展示了量子隱形傳態的工作流程，其中 Alice 和 Bob 分享一個 Bell 對，Alice 將測量結果傳送給 Bob，Bob 根據測量結果執行還原操作。

量子隱形傳態協定的電路實作與驗證

量子隱形傳態協定概述

量子隱形傳態協定是一種利用量子糾纏的特性，將一個量子位元（qubit）的狀態傳輸到另一個遠端量子位元上的技術，而無需直接傳輸該量子位元本身。這個過程涉及三個主要角色：Alice（傳送者）、Bob（接收者）和Eve（第三方，提供糾纏的Bell Pair）。

Composer中的量子隱形傳態電路

圖5-9展示了在Composer中實作量子隱形傳態協定的電路，以及在模擬器上的執行結果。該電路的關鍵部分包括：

  • Bell Pair的準備：Eve透過在量子位元1和2上施加Hadamard門和CNOT門來準備Bell Pair。
  • Alice的操作：Alice準備她的量子位元（0）到某個狀態ψ，並將其與從Eve獲得的量子位元（1）進行糾纏，然後對這兩個量子位元進行測量。
  • Bob的操作：根據Alice的測量結果，Bob對他的量子位元（2）施加相應的還原操作（X門或Z門），然後測量該量子位元以還原原始狀態ψ。

使用Python指令碼進行遠端執行與驗證

由於目前真實的量子裝置不支援所需的旋轉門，Listing 5-3中的Python指令碼用於在遠端模擬器上執行量子隱形傳態協定。該指令碼的關鍵步驟包括：

  1. 建立量子暫存器和經典暫存器：建立3個量子位元和3個經典暫存器，分別用於Alice和Bob的操作。
  2. 準備Bell Pair：Eve透過在量子位元1和2上施加Hadamard門和CNOT門來準備Bell Pair。
  3. Alice準備狀態ψ並進行測量：Alice透過旋轉門在量子位元0上準備狀態ψ，然後將其與量子位元1進行糾纏，並對這兩個量子位元進行測量，將結果儲存在經典暫存器0和1中。
  4. Bob根據Alice的結果進行還原操作：Bob根據儲存在經典暫存器0和1中的結果，對他的量子位元（2）施加Z門或X門，然後測量該量子位元，將結果儲存在經典暫存器2中。

程式碼範例

import sys, time, math
import numpy as np
from qiskit import QuantumCircuit, QuantumProgram

# Q Experience組態
sys.path.append('../Config/')
import Qconfig

def main():
    # 建立QuantumProgram
    Q_program = QuantumProgram()
    Q_program.register(Qconfig.APItoken, Qconfig.config["url"])

    # 建立暫存器
    q = Q_program.create_quantum_register('q', 3)
    c0 = Q_program.create_classical_register('c0', 1)
    c1 = Q_program.create_classical_register('c1', 1)
    c2 = Q_program.create_classical_register('c2', 1)

    # 建立電路
    teleport = Q_program.create_circuit('teleport', [q], [c0, c1, c2])
    teleport.h(q[1])
    teleport.cx(q[1], q[2])
    teleport.ry(np.pi/4, q[0])
    teleport.cx(q[0], q[1])
    teleport.h(q[0])
    teleport.barrier()
    teleport.measure(q[0], c0[0])
    teleport.measure(q[1], c1[0])

    # Bob的操作
    teleport.z(q[2]).c_if(c0, 1)
    teleport.x(q[2]).c_if(c1, 1)
    teleport.measure(q[2], c2[0])

    # 在模擬器上執行
    backend = "ibmq_qasm_simulator"
    shots = 1024
    result = Q_program.execute(['teleport'], backend=backend, shots=shots)

    # 分析結果
    data = result.get_counts('teleport')
    alice = {}
    alice['00'] = data['0 0 0'] + data['1 0 0']
    alice['10'] = data['0 1 0'] + data['1 1 0']
    alice['01'] = data['0 0 1'] + data['1 0 1']
    alice['11'] = data['0 1 1'] + data['1 1 1']

#### 程式碼解密：
此段程式碼展示瞭如何使用Qiskit在IBM Q Experience上實作量子隱形傳態協定。主要步驟包括建立量子暫存器和經典暫存器、準備Bell Pair、Alice進行狀態準備和測量、以及Bob根據Alice的測量結果進行還原操作。程式碼中使用了Qiskit的QuantumCircuit和QuantumProgram類別來定義和執行量子電路。最終，程式碼在模擬器上執行並分析結果，以驗證協定的有效性。

### 結果驗證與分析
透過執行Python指令碼並分析結果，可以驗證Bob是否成功還原了Alice原始準備的狀態ψ。這涉及到比較Alice的測量結果與Bob的測量結果，以確認狀態是否正確傳輸。
玄貓 BlackCat

玄貓 BlackCat

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。