量子计算系统知识库 - 层间映射规则¶

文档版本: 1.0 创建日期: 2026-01-12 维护者: 系统架构组状态: 活跃

文档目的¶

本文档定义量子计算系统**L1-L7七层架构之间的映射规则**，说明如何在层与层之间转换、映射和传递信息。

核心内容： - 向下映射：从抽象到具体（如算法→电路→脉冲） - 向上抽象：从具体到抽象（如物理限制→算法约束） - 横向映射：同层级不同实现之间的转换（如Qiskit→Cirq） - 约束传播：下层约束如何影响上层设计

1. 层间映射类型¶

1.1 映射方向分类¶

┌─────────────────────────────────────────┐
│          向下映射 (Downward)             │
│    L7 → L6 → L5 → L4 → L3 → L2 → L1     │
│   抽象 → 具体   Algorithm → Hardware    │
└─────────────────────────────────────────┘

┌─────────────────────────────────────────┐
│          向上抽象 (Upward)               │
│    L1 → L2 → L3 → L4 → L5 → L6 → L7     │
│   具体 → 抽象   Constraint → Capability  │
└─────────────────────────────────────────┘

┌─────────────────────────────────────────┐
│          横向映射 (Lateral)              │
│   Qiskit ⟷ Cirq ⟷ Qibo ⟷ PennyLane     │
│         同一层级不同实现                  │
└─────────────────────────────────────────┘

1.2 映射操作分类¶

映射类型	操作	典型转换	不可逆性
分解 (Decomposition)	一分为多	算法→电路	❌ 不可逆
映射 (Mapping)	保持结构	逻辑比特→物理比特	✅ 可逆 (已知映射)
优化 (Optimization)	简化/改进	电路优化	❌ 不可逆
抽象 (Abstraction)	忽略细节	脉冲→门	❌ 不可逆
综合 (Synthesis)	从规格构建	算法→电路	❌ 不可逆

2. L7 → L6 算法到程序的映射¶

2.1 映射规则¶

映射方向: L7 算法应用层 → L6 编程环境层

映射类型: 分解 + 参数化

规则:

L7: 算法描述 (数学形式)
  ↓
L6: 量子程序 (代码实现)

映射规则:
1. 算法步骤 → 量子门序列
2. 算法参数 → 可调参数
3. 数学运算 → 量子子程序
4. 经典控制 → 混合量子-经典代码

2.2 典型示例¶

示例1: VQE 算法映射

L7: VQE 算法 (数学描述)
  目标: min⟨ψ(θ)|H|ψ(θ)⟩
  方法: 变分优化

L6: Qiskit 实现
  from qiskit import QuantumCircuit
  from qiskit.algorithms import VQE

  # 算法参数化
  ansatz = TwoLocal(num_qubits, ['ry', 'cz'])
  optimizer = COBYLA()

  # 映射关系:
  L7 哈密顿量 H → L6 SparsePauliOp
  L7 波函数 |ψ(θ)⟩ → L6 ParameterVector(θ)
  L7 变分优化 → L6 VQE + Minimizer

示例2: Shor 算法映射

L7: Shor 算法 (分解 N = p×q)
  步骤:
    1. 选择随机 a
    2. 计算 order r (mod N)
    3. 因数分解

L6: Q# 实现
    operation ShorAlgorithm(N : Int) : Int[] {
        // 映射关系:
        // L7 模幂运算 → L6 ModularExponentiation operation
        // L7 量子傅里叶变换 → L6 QPE operation
        // L7 连续分数 → L6 Classical post-processing

        use qubits = Qubit[Log2(N) * 2];
        // ... 量子操作
    }

2.3 映射约束¶

约束1: 可实现性

L7 算法必须在 L6 可实现:
  ✓ 门序列可在框架中表达
  ✓ 参数可调
  ✗ 非量子操作需经典后处理

约束2: 资源需求

L7 算法 → L6 资源估计:
  - 量子比特数 (逻辑/物理)
  - 电路深度
  - 门数量 (单门/两门)
  - 运行时间估计

3. L6 → L5 程序到编译的映射¶

3.1 映射规则¶

映射方向: L6 编程环境层 → L5 系统软件层

映射类型: 转译 (Transpilation) + 优化

规则:

L6: 量子程序 (高级代码)
  ↓
L5: 可执行电路 (硬件适配)

映射规则:
1. 高级门 → 原生门分解
2. 逻辑比特 → 物理比特映射
3. 电路优化 (门取消、合并)
4. 脉冲级编译 (可选)

3.2 关键子映射¶

3.2.1 门分解 (Gate Decomposition)¶

规则: 高级门 → 原生门集合

L6: 高级门 (如 H, S, T)
  ↓
L5: 原生门 (U1, U2, U3 或 RX, RY, RZ)

示例:
  H = RY(π/2)  (某些框架)
    = (U3(π/2, 0, π))  (Qiskit)
    = U2(0, π)  (OpenQASM)

  T = U1(π/4)  (Qiskit)
    = RZ(π/4)  (Qiskit >= 0.16)

3.2.2 比特映射 (Qubit Mapping)¶

规则: 逻辑比特 → 物理比特

L6: 逻辑比特 (抽象索引 0, 1, ..., n-1)
  ↓
L5: 物理比特 (实际硬件位置)

映射算法:
  1. 初始映射 (Initial Mapping)
     - 优化连通性
     - 减少后续 SWAP

  2. 路由 (Routing)
     - 插入 SWAP 门
     - 满足拓扑约束

示例:
  L6: qc.cx(0, 1); qc.cx(1, 2);

  L5 (重六边形拓扑):
    逻辑: [0, 1, 2]
    物理: [5, 6, 7]  (映射)

    如果物理不连通:
      插入 SWAP:
      qc.cx(0, 1);
      qc.swap(1, 3);  // SWAP 插入
      qc.cx(3, 2);

3.2.3 电路优化 (Circuit Optimization)¶

规则: 简化电路，减少门数和深度

优化类型:
1. 门取消 (Gate Cancellation)
   H·H = I
   RX(θ)·RX(-θ) = I

2. 门合并 (Gate Merging)
   RX(θ1)·RX(θ2) = RX(θ1 + θ2)
   RZ(θ1)·RZ(θ2) = RZ(θ1 + θ2)

3. 门重排序 (Gate Reordering)
   交换 commuting 门以优化并行执行

示例:
  L6: H(0); X(0); H(0);
  ↓
  L5: (H·X·H) = Z
  ↓
  L5: Z(0)  (1个门, 而非3个)

3.3 框架差异处理¶

横向映射: Qiskit ⟷ Cirq ⟷ Qibo

参数顺序差异:
  Qiskit: gate(angle, qubit)
  Qibo:   gate(qubit, angle)

映射函数:
  def qiskit_to_qibo(qiskit_circuit):
      for gate, params, qubits in qiskit_circuit:
          if gate == 'rx':
              qibo_circuit.add(RZ(qubits[0], params[0]))

4. L5 → L3 编译到控制的映射¶

4.1 映射规则¶

映射方向: L5 系统软件层 → L3 控制互连层

映射类型: 脉冲级编译 (Pulse-Level Compilation)

规则:

L5: 量子门 (离散操作)
  ↓
L3: 控制脉冲 (连续波形)

映射规则:
1. 门 → 微观哈密顿量
2. 哈密顿量 → 时间演化
3. 时间演化 → 控制波形

4.2 门到脉冲的映射¶

示例: 超导 RX(θ) 门

L5: RX(θ) 门
  目标: 绕 X 轴旋转 θ 角度

L3: 微波脉冲
  步骤:
    1. 哈密顿量: H = Ω(t)·σ_x/2
    2. 时间演化: U = exp(-i∫H(t)dt)
    3. 条件: ∫Ω(t)dt = θ

  波形参数:
    - 频率: ω_d = ω_qubit + Δ (失谐)
    - 幅度: Ω(t) = Ω_max·envelope(t)
    - 包络: Gaussian / DRAG / Square
    - 持续时间: τ = θ/Ω_max

4.3 编码层次¶

L5: 量子门层 (Gate Level)
  ↓ 门分解
L4: 逻辑门层 (Logical Gate Level)
  ↓ 纠错编码
L3: 物理门层 (Physical Gate Level)
  ↓ 脉冲编译
L3: 脉冲层 (Pulse Level)
  ↓ AWG 输出
L3: 模拟信号层 (Analog Signal)

5. L4 → L2 纠错到物理的映射¶

5.1 映射规则¶

映射方向: L4 量子纠错层 → L2 物理量子比特层

映射类型: 编码映射 (Encoding Map)

规则:

L4: 逻辑量子比特 (抽象, 纠错后)
  ↓
L2: 物理量子比特 (实际硬件)

映射规则:
1. 逻辑空间 → 物理子空间
2. 逻辑门 → 物理门序列 (编码操作)
3. 逻辑测量 → 物理测量 (解码操作)

5.2 典型编码映射¶

示例1: 表面码编码

L4: 1 个逻辑量子比特 (d=3)
  ↓
L2: 7 个物理量子比特 (编码距离 d=3)

映射:
  |0⟩_L = ⊗⁷ |0⟩ (全零态)
  |1⟩_L = ⊗⁷ |+⟩ (全加态)

逻辑门映射:
  L_X = ⊗⁷ X (所有物理比特同时翻转)
  L_Z = ⊗⁷ Z (所有物理比特同时相位翻转)

  实际实现:
    通过 lattice surgery 或
    通过 transversal 门

示例2: Steane 码编码

L4: 1 个逻辑量子比特
  ↓
L2: 7 个物理量子比特

映射:
  |0⟩_L = (|000⟩ + |111⟩)⊗3 / √8
  |1⟩_L = (|+++⟩ + |---⟩)⊗3 / √8

逻辑门:
  L_H = H₁·H₂·...·H₇ (所有物理比特 H 门)
  L_X = X₁·X₂·...·X₇
  L_Z = Z₁·Z₂·...·Z₇

5.3 资源开销映射¶

规则: 逻辑资源 → 物理资源

L4: 逻辑资源需求
  ↓
L2: 物理资源需求

映射公式:
  物理比特数 = 编码距离² × f(码类型)
  门时间 = 编码后的门序列时间
  错误率 = (物理错误率)^((d-1)/2)

示例 (表面码, d=3):
  物理比特 = 2d² - 1 = 17 (或 ≈ d² = 9 某些布局)
  逻辑 X 门 = ~100 物理门
  逻辑错误率 = (0.01)^((3-1)/2) = 0.01

6. 向上抽象：约束传播¶

6.1 L2 → L4 约束传播¶

规则: 物理约束 → 纠错码选择

L2: 物理约束
  ↓
L4: 纠错码选择

约束 → 码类型映射:
  连接拓扑 = 全连接
    → 可用: LDPC码, 色码, 表面码

  连接拓扑 = 近邻
    → 可用: 表面码, Bacon-Shor 码
    → 不可用: 需要长程连接的码

  测量能力 = 支持中间测量
    → 可用: 表面码, LDPC码
  测量能力 = 不支持中间测量
    → 可用: 测量free 码 (FBQC, 拓扑码)

6.2 L3 → L5 约束传播¶

规则: 控制约束 → 编译器策略

L3: 控制约束
  ↓
L5: 编译器策略

约束 → 编译选项:
  并行控制 = 有限 (不能同时控制所有比特)
    → 编译器: 串行化部分门
    → 影响: 电路深度增加

  门保真度 = 不均匀 (某些比特门保真度低)
    → 编译器: 避免使用低保真度比特
    → 影响: 有效比特数减少

  相干时间 = 不均匀
    → 编译器: 优先使用长相干时间比特
    → 影响: 路由策略调整

6.3 L2 → L7 约束传播¶

规则: 物理限制 → 算法选择

L2: 物理限制
  ↓
L7: 算法可行性

限制 → 算法映射:
  门保真度 F₂q < 0.99
    → 不可用: 深电路算法 (Shor, HHL)
    → 可用: 浅电路算法 (VQE, QAOA)

  量子比特数 < 100
    → 不可用: 大规模算法
    → 可用: 小规模演示

  相干时间短
    → 不可用: 深度电路
    → 可用: 变分算法 (浅电路)

7. 横向映射：框架转换¶

7.1 Qiskit → Cirq 映射¶

规则: 同一逻辑，不同语法

# Qiskit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.rz(np.pi/2, 0)

# 映射到 Cirq
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit()
circuit.append(cirq.H.on(q0))
circuit.append(cirq.CNOT.on(q0, q1))
circuit.append(cirq.rz(np.pi/2).on(q0))

映射规则:
1. qiskit.QuantumCircuit → cirq.Circuit
2. qc.h(i) → cirq.H.on(q_i)
3. qc.cx(i, j) → cirq.CNOT.on(q_i, q_j)
4. qc.rz(angle, i) → cirq.rz(rads=angle).on(q_i)

7.2 参数顺序调整¶

规则: 调整参数顺序

# Qiskit: (angle, qubit)
qc.rz(theta, 0)

# Qibo: (qubit, angle)
circuit.add(gates.RZ(0, theta))

# 映射函数
def qiskit_angle_to_qibo(qiskit_op):
    if qiskit_op.name == 'rz':
        return gates.RZ(qiskit_op.qubits[0], qiskit_op.params[0])

8. 映射验证¶

8.1 正确性验证¶

方法1: 模拟对比

1. L6: 创建量子电路
2. L5: 编译到不同后端
3. 模拟器运行: 对比结果态保真度
4. 判定: F > 0.999 → 映射正确

方法2: 单元测试

def test_mapping():
    # 原始电路
    qc_original = create_circuit()

    # 映射
    qc_mapped = map_to_backend(qc_original)

    # 验证
    assert are_equivalent(qc_original, qc_mapped)

8.2 性能验证¶

指标:

1. 电路深度变化: ΔDepth = Depth_after - Depth_before
2. 门数量变化: ΔGates = Gates_after - Gates_before
3. 保真度损失: ΔF = F_before - F_after
4. 编译时间: T_compile

9. 映射最佳实践¶

9.1 映射设计原则¶

保真度优先: 映射不应显著降低保真度
资源最小化: 减少额外资源开销
可逆性 (如可能): 保持映射可逆,便于调试
文档化: 明确记录映射规则
自动化: 使用工具减少人工错误

9.2 映射检查清单¶

映射设计:
□ 明确源层级和目标层级
□ 定义映射规则
□ 处理特殊情况
□ 提供逆向映射 (如可能)

映射实现:
□ 实现映射函数
□ 编写单元测试
□ 验证正确性
□ 评估性能

映射文档:
□ 记录映射规则
□ 提供示例
□ 说明约束和限制
□ 版本控制

10. 快速参考¶

10.1 层间映射表¶

源层	目标层	映射类型	关键操作	可逆性
L7	L6	分解+参数化	算法→代码	❌
L6	L5	转译+优化	代码→电路	❌
L5	L4	编码	门→纠错码	❌
L4	L3	纠错→控制	逻辑门→物理门	❌
L5	L3	脉冲编译	门→脉冲	❌
L3	L2	控制→物理	脉冲→比特操作	❌
L2	L1	物理→设施	比特→环境	✅ (限制)

10.2 框架转换表¶

源框架	目标框架	主要差异	转换工具
Qiskit	Cirq	参数顺序, 门表示	qiskit-cirq-converter
Qiskit	Qibo	参数顺序, 符号约定	qiskit-qibo-bridge
Qiskit	PennyLane	后端接口	qiskit-pennylane plugin
Cirq	Qiskit	状态向量表示	cirq-to-qiskit

版本历史¶

版本	日期	修改内容
1.0	2026-01-12	初始版本，建立层间映射规则