1. MBQC 原理（单向量子计算）¶
1.1 什么是 MBQC？¶
基于测量的量子计算（Measurement-Based Quantum Computation, MBQC），也称为单向量子计算（One-Way Quantum Computation），是一种与传统量子电路模型截然不同的量子计算范式。
核心思想¶
传统量子电路模型 vs MBQC：
| 特性 | 传统电路模型 | MBQC 模型 |
|---|---|---|
| 计算方式 | 按序应用量子门 | 顺序测量纠缠态 |
| 资源准备 | 逐个制备量子态 | 预先制备大簇态 |
| 测量作用 | 读取计算结果 | 驱动计算过程 |
| 纠正方式 | 不需要 | 自适应前馈纠正 |
1.2 MBQC 的关键特征¶
预先制备资源态：在计算开始前，先制备一个高度纠缠的多量子比特态（簇态）
单量子比特测量：通过逐个测量量子比特来执行计算
自适应前馈：根据之前的测量结果自适应调整后续测量的基
单向性：测量过程会破坏量子态，因此计算是"单向"的，不可逆
1.3 为什么叫"单向"？¶
- 测量操作会坍缩量子态，是不可逆的
- 一旦量子比特被测量，它就退出了计算
- 信息流是单向的：从未测量的部分 → 已测量的部分
1.4 MBQC 的优势¶
- 并行性：资源态可以离线制备，计算过程只需测量
- 通用性：任何量子电路都可以转化为 MBQC 模式
- 物理实现友好：某些物理系统（如光量子）更容易实现 MBQC
- 量子网络：适合分布式量子计算和量子通信
2. 簇态（Cluster State）¶
2.1 什么是簇态？¶
簇态（Cluster State）是 MBQC 的核心资源态，是一种高度纠缠的图态。
数学定义¶
对于图 $G = (V, E)$，其中 $V$ 是顶点集（量子比特），$E$ 是边集（纠缠关系），簇态定义为：
$$ |C_G\rangle = \prod_{(a,b) \in E} CZ_{ab} \bigotimes_{i \in V} |+\rangle_i $$
其中：
- $|+\rangle = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)$ 是单量子比特初态
- $CZ$ 是受控-Z 门，用于建立纠缠
2.2 簇态的性质¶
- 最大纠缠：簇态是高度纠缠的图态
- 通用资源：任意量子计算都可以通过在簇态上执行单量子比特测量实现
- 几何结构：簇态的几何结构（图的形状）决定了可实现的计算
2.3 常见簇态类型¶
一维簇态¶
- 量子比特排列成一条线
- 适合实现单量子比特门
二维簇态¶
- 量子比特排列成平面网格
- 适合实现通用量子计算（包括双量子比特门）
2.4 簇态的制备¶
制备步骤：
- 初始化所有量子比特为 $|+\rangle$ 态
- 对每对相邻的量子比特应用 CZ 门
# 伪代码
for each qubit i:
initialize qubit i in |+⟩ state
for each edge (i, j) in graph:
apply CZ gate between qubit i and qubit j
3. 测量模式和计算¶
3.1 测量模式（Measurement Pattern）¶
MBQC 的计算过程由测量模式决定，包括：
- 测量顺序：量子比特的测量次序
- 测量基：每个量子比特的测量基（XY、YZ 或 XZ 平面）
- 测量角度：在选定平面内的测量角度
- 自适应修正：根据前序测量结果调整后续测量
3.2 测量基¶
在 Bloch 球上，测量通常在三个主平面进行：
- XY 平面：测量 $\cos(\phi)X + \sin(\phi)Y$
- YZ 平面：测量 $\cos(\phi)Y + \sin(\phi)Z$
- XZ 平面：测量 $\cos(\phi)X + \sin(\phi)Z$
3.3 测量角度的自适应调整¶
测量角度 $\phi$ 根据前序测量结果自适应调整：
$$ \phi' = (-1)^{s_r}\phi + \pi s_t $$
其中：
- $s_r = \sum_{i \in D_r} m_i$ 是 $r$-域（实部依赖）中测量结果之和
- $s_t = \sum_{j \in D_t} m_j$ 是 $t$-域（虚部依赖）中测量结果之和
- $m_i \in \{0, 1\}$ 是量子比特 $i$ 的测量结果
3.4 计算流程¶
1. 制备簇态
↓
2. 按顺序测量量子比特
↓
3. 根据测量结果调整后续测量基
↓
4. 对输出比特应用修正（Pauli 门）
↓
5. 读取最终结果
4. Pattern 和图表示¶
4.1 NEMC 命令¶
MBQC 使用 NEMC 命令序列来描述测量模式：
| 命令 | 符号 | 描述 | DeepQuantum 函数 |
|---|---|---|---|
| Node | $N_i$ | 制备量子比特 $i$ | n(i) |
| Entanglement | $E_{ij}$ | 对量子比特 $i,j$ 应用 CZ 门 | e(i, j) |
| Measurement | $[M_i^{\lambda, \alpha}]_s^t$ | 测量量子比特 $i$，平面 $\lambda$，角度 $\alpha$ | m(i, \alpha, \lambda, t, s) |
| Correction X | $X_i^s$ | 对量子比特 $i$ 应用 X 修正 | x(i, s) |
| Correction Z | $Z_i^s$ | 对量子比特 $i$ 应用 Z 修正 | z(i, s) |
4.2 依赖域¶
- s-domain（实部域）：影响测量角度的符号
- t-domain（虚部域）：向测量角度添加 $\pi$ 的相位
- domain（修正域）：决定最终的 Pauli 修正
4.3 图表示¶
Pattern 可以用图直观表示：
- 方形节点：输入量子比特
- 圆形节点：辅助量子比特
- 边：CZ 纠缠
- 蓝色节点：待测量子比特
- 灰色节点：输出量子比特
- 绿色虚线：t-domain 依赖
- 红色虚线：s-domain 依赖
4.4 Pattern 的标准形式¶
Pattern 可以通过优化转换为标准形式：
- Standardize：将命令按 N → E → M → C 的顺序排列
- Signal Shifting：消除 t-domain 依赖，降低量子深度
优化优势：
- 减少自适应前馈的复杂度
- 降低量子深度（关键量子资源）
- 提高计算效率
5. 单向量子门的实现¶
5.1 单量子比特旋转¶
任意单量子比特旋转 $R_z(\alpha)R_x(\beta)R_z(\gamma)$ 可以通过测量一维簇态实现。
实现原理¶
使用 3 个量子比特的一维簇态，通过在 XY 平面内以不同角度测量前两个量子比特来实现。
测量角度：
- 第 1 个量子比特：$\phi_1 = -\alpha$
- 第 2 个量子比特：$\phi_2 = -\beta$
- 第 3 个量子比特：输出（不需要测量）
Pauli 修正：
- 根据测量结果应用 $X$ 和 $Z$ 修正
5.2 Hadamard 门¶
Hadamard 门可以通过在 YZ 平面测量实现：
$$ H = HR_z(0) \approx \text{测量角度 } 0 $$
5.3 CNOT 门¶
CNOT 门需要二维簇态（4 个量子比特）：
拓扑结构：
• (控制)
│
•─•─• (目标)
测量模式：
- 测量控制比特和辅助比特
- 根据结果修正输出比特
5.4 通用性¶
定理：单量子比特旋转 + CNOT = 通用量子计算
因此，二维簇态上的 MBQC 是通用的。
6. 纠缠态制备¶
6.1 EPR 态¶
EPR 态（Einstein-Podolsky-Rosen state）是最简单的两体纠缠态：
$$ |\text{EPR}\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle) $$
制备方法¶
- 初始化两个量子比特为 $|+\rangle$ 态
- 应用 CZ 门
$$ CZ_{01} |++\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle) $$
6.2 GHZ 态¶
GHZ 态（Greenberger-Horne-Zeilinger state）是多体纠缠态：
$$ |\text{GHZ}\rangle = \frac{1}{\sqrt{2}}(|00\cdots0\rangle + |11\cdots1\rangle) $$
制备方法¶
- 初始化 $n$ 个量子比特为 $|+\rangle$ 态
- 应用 $n-1$ 个 CZ 门连接相邻量子比特
6.3 时域复用（TDM）¶
时域复用（Time-Domain Multiplexing）是一种高效制备大规模簇态的方法：
核心思想¶
- 使用单个物理模式配合延时线圈
- 通过时间复用模拟多个空间模式
- 周期性调制分束器和移相器
优势¶
- 资源高效：只需要少数物理量子比特
- 可扩展：可制备大规模一维/二维簇态
- 实验友好：已在光量子系统中实现
应用¶
- 大规模簇态制备（10000+ 模式）
- 量子通信网络
- 分布式量子计算
In [ ]:
Copied!
import deepquantum as dq
import numpy as np
import torch
print(f"DeepQuantum version: {dq.__version__}")
import deepquantum as dq
import numpy as np
import torch
print(f"DeepQuantum version: {dq.__version__}")
7.2 通过电路转译构建 Pattern¶
最简单的方法是从传统量子电路转译为 MBQC Pattern。
In [ ]:
Copied!
# 创建一个简单的量子电路
cir = dq.QubitCircuit(2)
cir.h(0)
cir.h(1)
cir.cnot(0, 1)
# 转译为 MBQC Pattern
pattern = cir.pattern()
pattern
# 创建一个简单的量子电路
cir = dq.QubitCircuit(2)
cir.h(0)
cir.h(1)
cir.cnot(0, 1)
# 转译为 MBQC Pattern
pattern = cir.pattern()
pattern
7.3 可视化 Pattern¶
使用 draw() 方法可视化 Pattern 的图结构：
In [ ]:
Copied!
# 可视化 Pattern
# 方形节点：输入
# 蓝色节点：待测
# 灰色节点：输出
# 边：CZ 纠缠
pattern.draw()
# 可视化 Pattern
# 方形节点：输入
# 蓝色节点：待测
# 灰色节点：输出
# 边：CZ 纠缠
pattern.draw()
7.4 手动构建 Pattern¶
除了转译，也可以手动构建 Pattern：
In [ ]:
Copied!
# 初始化 Pattern，指定输入量子比特
pattern = dq.Pattern(nodes_state=[0, 1])
# 添加量子比特
pattern.n(2)
# 添加纠缠（CZ 门）
pattern.e(0, 2)
pattern.e(1, 2)
# 添加测量
pattern.m(node=0, angle=np.pi)
pattern.m(node=1, angle=np.pi, s_domain=[0]) # 依赖于测量结果 0
# 添加修正
pattern.x(node=2, domain=[0, 1])
# 可视化
pattern.draw()
# 初始化 Pattern，指定输入量子比特
pattern = dq.Pattern(nodes_state=[0, 1])
# 添加量子比特
pattern.n(2)
# 添加纠缠（CZ 门）
pattern.e(0, 2)
pattern.e(1, 2)
# 添加测量
pattern.m(node=0, angle=np.pi)
pattern.m(node=1, angle=np.pi, s_domain=[0]) # 依赖于测量结果 0
# 添加修正
pattern.x(node=2, domain=[0, 1])
# 可视化
pattern.draw()
7.5 执行 MBQC 模拟¶
使用前向运算执行 Pattern：
In [ ]:
Copied!
# 执行 Pattern
final_state = pattern()
# 获取最终态
state_vector = final_state.full_state
print("Final state:")
print(state_vector)
# 查看测量结果
print("\nMeasurement results:")
print(pattern.state.measure_dict)
# 执行 Pattern
final_state = pattern()
# 获取最终态
state_vector = final_state.full_state
print("Final state:")
print(state_vector)
# 查看测量结果
print("\nMeasurement results:")
print(pattern.state.measure_dict)
7.6 优化 Pattern¶
通过标准化和信号转移优化 Pattern：
In [ ]:
Copied!
# 创建一个新的 Pattern
pattern = dq.Pattern(nodes_state=[0, 1])
pattern.n(2)
pattern.e(0, 2)
pattern.e(1, 2)
pattern.m(node=0, angle=np.pi)
pattern.m(node=1, angle=np.pi, s_domain=[0], t_domain=[0]) # 有 t-domain 依赖
pattern.x(node=2, domain=[0, 1])
print("Before optimization:")
print(pattern)
# 标准化
pattern.standardize()
print("\nAfter standardization:")
print(pattern)
# 信号转移（消除 t-domain 依赖）
pattern.shift_signals()
print("\nAfter signal shifting:")
print(pattern)
# 创建一个新的 Pattern
pattern = dq.Pattern(nodes_state=[0, 1])
pattern.n(2)
pattern.e(0, 2)
pattern.e(1, 2)
pattern.m(node=0, angle=np.pi)
pattern.m(node=1, angle=np.pi, s_domain=[0], t_domain=[0]) # 有 t-domain 依赖
pattern.x(node=2, domain=[0, 1])
print("Before optimization:")
print(pattern)
# 标准化
pattern.standardize()
print("\nAfter standardization:")
print(pattern)
# 信号转移（消除 t-domain 依赖）
pattern.shift_signals()
print("\nAfter signal shifting:")
print(pattern)
7.7 支持参数化输入¶
Pattern 支持可训练的参数（用于变分算法）：
In [ ]:
Copied!
# 创建带参数的 Pattern
pattern = dq.Pattern(nodes_state=[0, 1])
pattern.n(2)
pattern.e(0, 2)
pattern.e(1, 2)
# encode=True 表示角度可从外部输入
pattern.m(node=0, encode=True)
pattern.m(node=1, encode=True, s_domain=[0])
pattern.x(node=2, domain=[0, 1])
# 输入参数
angles = torch.randn(2, requires_grad=True)
result = pattern(data=angles).full_state
print("Output state:")
print(result)
print("\nRequires gradient:", result.requires_grad)
# 创建带参数的 Pattern
pattern = dq.Pattern(nodes_state=[0, 1])
pattern.n(2)
pattern.e(0, 2)
pattern.e(1, 2)
# encode=True 表示角度可从外部输入
pattern.m(node=0, encode=True)
pattern.m(node=1, encode=True, s_domain=[0])
pattern.x(node=2, domain=[0, 1])
# 输入参数
angles = torch.randn(2, requires_grad=True)
result = pattern(data=angles).full_state
print("Output state:")
print(result)
print("\nRequires gradient:", result.requires_grad)
7.8 Batch 输入¶
支持批量处理多个输入：
In [ ]:
Copied!
# 批量输入
batch_angles = torch.randn(6, 2) # 6 个样本，每个 2 个角度
batch_result = pattern(data=batch_angles).full_state
print(f"Batch output shape: {batch_result.shape}")
print("First sample:")
print(batch_result[0])
# 批量输入
batch_angles = torch.randn(6, 2) # 6 个样本，每个 2 个角度
batch_result = pattern(data=batch_angles).full_state
print(f"Batch output shape: {batch_result.shape}")
print("First sample:")
print(batch_result[0])
In [ ]:
Copied!
# 定义旋转角度
alpha = np.pi / 3
# 创建电路
cir = dq.QubitCircuit(2)
# 制备簇态
cir.h(0)
cir.h(1)
cir.cz(0, 1)
# 测量第一个量子比特（|alpha⟩ 基）
cir.p(0, -alpha)
cir.h(0)
cir.barrier()
# 根据测量结果修正
cir.x(1, controls=0, condition=True)
# 执行
cir()
# 获取结果
state, measure_rst, prob = cir.defer_measure(with_prob=True)
# MBQC 有额外的全局相位：exp(-i*alpha/2)
corrected_state = state * np.exp(1j * alpha / 2)
print("Measurement result:", measure_rst)
print("Probability:", prob)
print("Output state (corrected):")
print(corrected_state)
# 可视化
cir.draw()
# 定义旋转角度
alpha = np.pi / 3
# 创建电路
cir = dq.QubitCircuit(2)
# 制备簇态
cir.h(0)
cir.h(1)
cir.cz(0, 1)
# 测量第一个量子比特（|alpha⟩ 基）
cir.p(0, -alpha)
cir.h(0)
cir.barrier()
# 根据测量结果修正
cir.x(1, controls=0, condition=True)
# 执行
cir()
# 获取结果
state, measure_rst, prob = cir.defer_measure(with_prob=True)
# MBQC 有额外的全局相位：exp(-i*alpha/2)
corrected_state = state * np.exp(1j * alpha / 2)
print("Measurement result:", measure_rst)
print("Probability:", prob)
print("Output state (corrected):")
print(corrected_state)
# 可视化
cir.draw()
验证：与传统电路对比¶
In [ ]:
Copied!
# 使用传统电路实现相同的操作
cir_traditional = dq.QubitCircuit(1)
# 制备 |+⟩ 态
cir_traditional.h(0)
# 应用 Rz(-α) 和 H
cir_traditional.rz(0, -alpha)
cir_traditional.h(0)
# 执行
traditional_state = cir_traditional()
print("Traditional circuit output:")
print(traditional_state)
# 比较（MBQC 的结果需要选择特定的测量结果）
mbqc_state = cir.post_select(measure_rst) * np.exp(1j * alpha / 2)
print("\nMBQC output (selected):")
print(mbqc_state)
print("\nAre they equal?", np.allclose(traditional_state, mbqc_state))
cir_traditional.draw()
# 使用传统电路实现相同的操作
cir_traditional = dq.QubitCircuit(1)
# 制备 |+⟩ 态
cir_traditional.h(0)
# 应用 Rz(-α) 和 H
cir_traditional.rz(0, -alpha)
cir_traditional.h(0)
# 执行
traditional_state = cir_traditional()
print("Traditional circuit output:")
print(traditional_state)
# 比较（MBQC 的结果需要选择特定的测量结果）
mbqc_state = cir.post_select(measure_rst) * np.exp(1j * alpha / 2)
print("\nMBQC output (selected):")
print(mbqc_state)
print("\nAre they equal?", np.allclose(traditional_state, mbqc_state))
cir_traditional.draw()
8.2 任意单量子比特旋转¶
实现 $R_z(\alpha)R_x(\beta)R_z(\gamma)$ 旋转。
In [ ]:
Copied!
# 定义三个旋转角度
alpha = np.pi / 2
beta = np.pi / 3
gamma = np.pi / 4
# 创建 MBQC 电路
cir_mbqc = dq.QubitCircuit(4)
# 制备一维簇态
cir_mbqc.hlayer()
cir_mbqc.cz(0, 1)
cir_mbqc.cz(1, 2)
cir_mbqc.cz(2, 3)
cir_mbqc.barrier()
# 测量（实现三个旋转）
cir_mbqc.p(0, -alpha)
cir_mbqc.h(0)
cir_mbqc.p(1, -beta)
cir_mbqc.h(1)
cir_mbqc.p(2, -gamma)
cir_mbqc.h(2)
# 根据测量结果修正
cir_mbqc.x(3, controls=2, condition=True)
cir_mbqc.z(3, controls=1, condition=True)
cir_mbqc.x(3, controls=0, condition=True)
# 执行
cir_mbqc()
state_mbqc, measure_rst, prob = cir_mbqc.defer_measure(with_prob=True)
corrected_state = state_mbqc * np.exp(1j * (alpha + beta + gamma) / 2)
print("Measurement results:", measure_rst)
print("Probability:", prob)
print("Output state:")
print(corrected_state)
cir_mbqc.draw()
# 定义三个旋转角度
alpha = np.pi / 2
beta = np.pi / 3
gamma = np.pi / 4
# 创建 MBQC 电路
cir_mbqc = dq.QubitCircuit(4)
# 制备一维簇态
cir_mbqc.hlayer()
cir_mbqc.cz(0, 1)
cir_mbqc.cz(1, 2)
cir_mbqc.cz(2, 3)
cir_mbqc.barrier()
# 测量（实现三个旋转）
cir_mbqc.p(0, -alpha)
cir_mbqc.h(0)
cir_mbqc.p(1, -beta)
cir_mbqc.h(1)
cir_mbqc.p(2, -gamma)
cir_mbqc.h(2)
# 根据测量结果修正
cir_mbqc.x(3, controls=2, condition=True)
cir_mbqc.z(3, controls=1, condition=True)
cir_mbqc.x(3, controls=0, condition=True)
# 执行
cir_mbqc()
state_mbqc, measure_rst, prob = cir_mbqc.defer_measure(with_prob=True)
corrected_state = state_mbqc * np.exp(1j * (alpha + beta + gamma) / 2)
print("Measurement results:", measure_rst)
print("Probability:", prob)
print("Output state:")
print(corrected_state)
cir_mbqc.draw()
验证：与传统电路对比¶
In [ ]:
Copied!
# 传统电路实现
cir_traditional = dq.QubitCircuit(1)
cir_traditional.h(0)
# 根据测量结果调整角度符号
cir_traditional.rz(0, -alpha)
cir_traditional.rx(0, beta * (-1) ** (int(measure_rst[0]) + 1))
cir_traditional.rz(0, gamma * (-1) ** (int(measure_rst[1]) + 1))
cir_traditional.h(0)
traditional_state = cir_traditional()
print("Traditional circuit output:")
print(traditional_state)
mbqc_selected = cir_mbqc.post_select(measure_rst) * np.exp(1j * (alpha + beta + gamma) / 2)
print("\nMBQC output (selected):")
print(mbqc_selected)
print("\nAre they equal?", np.allclose(traditional_state, mbqc_selected))
cir_traditional.draw()
# 传统电路实现
cir_traditional = dq.QubitCircuit(1)
cir_traditional.h(0)
# 根据测量结果调整角度符号
cir_traditional.rz(0, -alpha)
cir_traditional.rx(0, beta * (-1) ** (int(measure_rst[0]) + 1))
cir_traditional.rz(0, gamma * (-1) ** (int(measure_rst[1]) + 1))
cir_traditional.h(0)
traditional_state = cir_traditional()
print("Traditional circuit output:")
print(traditional_state)
mbqc_selected = cir_mbqc.post_select(measure_rst) * np.exp(1j * (alpha + beta + gamma) / 2)
print("\nMBQC output (selected):")
print(mbqc_selected)
print("\nAre they equal?", np.allclose(traditional_state, mbqc_selected))
cir_traditional.draw()
8.3 CNOT 门¶
实现 CNOT 门的 MBQC 版本。
In [ ]:
Copied!
# 创建 MBQC CNOT 电路
cir_mbqc_cnot = dq.QubitCircuit(4)
# 制备二维簇态
cir_mbqc_cnot.hlayer()
cir_mbqc_cnot.swap([1, 2]) # 调整拓扑结构
cir_mbqc_cnot.cz(0, 1)
cir_mbqc_cnot.cz(0, 2)
cir_mbqc_cnot.cz(0, 3)
cir_mbqc_cnot.barrier()
# 测量
cir_mbqc_cnot.h(0)
cir_mbqc_cnot.h(1)
cir_mbqc_cnot.barrier()
# 根据测量结果修正
cir_mbqc_cnot.x(3, controls=0, condition=True)
cir_mbqc_cnot.z(2, controls=1, condition=True)
cir_mbqc_cnot.z(3, controls=1, condition=True)
# 执行
cir_mbqc_cnot()
state_cnot_mbqc, measure_rst_cnot, prob_cnot = cir_mbqc_cnot.defer_measure(with_prob=True)
print("Measurement results:", measure_rst_cnot)
print("Probability:", prob_cnot)
print("Output state:")
print(state_cnot_mbqc)
cir_mbqc_cnot.draw()
# 创建 MBQC CNOT 电路
cir_mbqc_cnot = dq.QubitCircuit(4)
# 制备二维簇态
cir_mbqc_cnot.hlayer()
cir_mbqc_cnot.swap([1, 2]) # 调整拓扑结构
cir_mbqc_cnot.cz(0, 1)
cir_mbqc_cnot.cz(0, 2)
cir_mbqc_cnot.cz(0, 3)
cir_mbqc_cnot.barrier()
# 测量
cir_mbqc_cnot.h(0)
cir_mbqc_cnot.h(1)
cir_mbqc_cnot.barrier()
# 根据测量结果修正
cir_mbqc_cnot.x(3, controls=0, condition=True)
cir_mbqc_cnot.z(2, controls=1, condition=True)
cir_mbqc_cnot.z(3, controls=1, condition=True)
# 执行
cir_mbqc_cnot()
state_cnot_mbqc, measure_rst_cnot, prob_cnot = cir_mbqc_cnot.defer_measure(with_prob=True)
print("Measurement results:", measure_rst_cnot)
print("Probability:", prob_cnot)
print("Output state:")
print(state_cnot_mbqc)
cir_mbqc_cnot.draw()
验证：与传统 CNOT 对比¶
In [ ]:
Copied!
# 传统 CNOT 电路
cir_traditional_cnot = dq.QubitCircuit(2)
cir_traditional_cnot.hlayer()
cir_traditional_cnot.cx(0, 1)
traditional_cnot_state = cir_traditional_cnot()
print("Traditional CNOT output:")
print(traditional_cnot_state)
mbqc_cnot_selected = cir_mbqc_cnot.post_select(measure_rst_cnot)
print("\nMBQC CNOT output (selected):")
print(mbqc_cnot_selected)
print("\nAre they equal?", np.allclose(traditional_cnot_state, mbqc_cnot_selected))
cir_traditional_cnot.draw()
# 传统 CNOT 电路
cir_traditional_cnot = dq.QubitCircuit(2)
cir_traditional_cnot.hlayer()
cir_traditional_cnot.cx(0, 1)
traditional_cnot_state = cir_traditional_cnot()
print("Traditional CNOT output:")
print(traditional_cnot_state)
mbqc_cnot_selected = cir_mbqc_cnot.post_select(measure_rst_cnot)
print("\nMBQC CNOT output (selected):")
print(mbqc_cnot_selected)
print("\nAre they equal?", np.allclose(traditional_cnot_state, mbqc_cnot_selected))
cir_traditional_cnot.draw()
8.4 使用 Pattern 实现¶
直接使用 Pattern 类实现上述门操作：
In [ ]:
Copied!
# 使用 Pattern 实现单量子比特旋转
pattern = dq.Pattern(nodes_state=[0])
# 构建一维簇态
pattern.n(1)
pattern.n(2)
pattern.e(0, 1)
pattern.e(1, 2)
# 测量
pattern.m(node=0, angle=alpha, encode=True)
pattern.m(node=1, angle=beta, s_domain=[0], encode=True)
# 修正
pattern.x(node=2, domain=[0, 1])
pattern.z(node=2, domain=[0])
# 执行
angles = torch.tensor([alpha, beta])
result = pattern(data=angles).full_state
print("Pattern-based MBQC output:")
print(result)
# 可视化
pattern.draw()
# 使用 Pattern 实现单量子比特旋转
pattern = dq.Pattern(nodes_state=[0])
# 构建一维簇态
pattern.n(1)
pattern.n(2)
pattern.e(0, 1)
pattern.e(1, 2)
# 测量
pattern.m(node=0, angle=alpha, encode=True)
pattern.m(node=1, angle=beta, s_domain=[0], encode=True)
# 修正
pattern.x(node=2, domain=[0, 1])
pattern.z(node=2, domain=[0])
# 执行
angles = torch.tensor([alpha, beta])
result = pattern(data=angles).full_state
print("Pattern-based MBQC output:")
print(result)
# 可视化
pattern.draw()
8.5 自定义初态¶
Pattern 支持自定义初态：
In [ ]:
Copied!
# 创建自定义初态
# 例如，从 |0⟩ 而不是 |+⟩ 开始
custom_state = torch.tensor([1, 0, 0, 0], dtype=torch.complex128) # |00⟩
pattern_custom = dq.Pattern(
nodes_state=[0, 1],
state=custom_state
)
# 添加操作
pattern_custom.n(2)
pattern_custom.e(0, 2)
pattern_custom.e(1, 2)
pattern_custom.m(node=0, angle=0.5)
pattern_custom.m(node=1, angle=0.3, s_domain=[0])
pattern_custom.x(node=2, domain=[0, 1])
# 执行
result_custom = pattern_custom().full_state
print("Custom initial state result:")
print(result_custom)
print("\nInitial state was:")
print(custom_state)
pattern_custom.draw()
# 创建自定义初态
# 例如，从 |0⟩ 而不是 |+⟩ 开始
custom_state = torch.tensor([1, 0, 0, 0], dtype=torch.complex128) # |00⟩
pattern_custom = dq.Pattern(
nodes_state=[0, 1],
state=custom_state
)
# 添加操作
pattern_custom.n(2)
pattern_custom.e(0, 2)
pattern_custom.e(1, 2)
pattern_custom.m(node=0, angle=0.5)
pattern_custom.m(node=1, angle=0.3, s_domain=[0])
pattern_custom.x(node=2, domain=[0, 1])
# 执行
result_custom = pattern_custom().full_state
print("Custom initial state result:")
print(result_custom)
print("\nInitial state was:")
print(custom_state)
pattern_custom.draw()
总结¶
本教程介绍了基于测量的量子计算（MBQC）的核心概念和实现方法：
关键要点¶
MBQC 原理：通过预先制备簇态，然后逐个测量量子比特来执行计算
簇态：高度纠缠的图态，是 MBQC 的通用资源
测量模式：由 NEMC 命令序列定义，包括节点制备、纠缠、测量和修正
Pattern 优化：通过标准化和信号转移降低量子深度
量子门实现：单量子比特旋转和 CNOT 门都可以通过 MBQC 实现
DeepQuantum 支持：提供了完整的 Pattern 类，支持转译、可视化、优化和执行
MBQC 的优势¶
- 并行性：资源态可离线制备
- 通用性：任何量子电路都可转译
- 物理友好：适合光量子等系统
- 可扩展：结合时域复用可制备大规模簇态
进一步学习¶
- 探索更复杂的量子算法（如量子傅里叶变换）的 MBQC 实现
- 学习变分 MBQC（VMBQC）用于优化问题
- 研究时域复用技术制备大规模簇态
- 了解 MBQC 在量子通信和网络中的应用
参考资源¶
- Raussendorf, R., & Briegel, H. J. (2001). A one-way quantum computer. Physical Review Letters.
- Browne, D. E., & Briegel, H. J. (2006). One-way quantum computation.
- DeepQuantum 文档：
E:\02_Projects\turingQ\deepquantum\docs\mbqc_basics.ipynb - 基本门的 MBQC 实现：
E:\02_Projects\turingQ\deepquantum\examples\basic_gate_MBQC.ipynb