量子门

pyqpanda3 中所有量子门函数的 API 参考。每个门函数返回一个 QGate 对象，可组合到 QCircuit 和 QProg 结构中。

QGate 类

QGate 是所有门工厂函数返回的基础类型。

签名

class QGate

方法

方法	签名	说明
qubits_num	qubits_num() -> int	门作用的量子比特数
qubits	qubits() -> list[int]	门作用的所有量子比特索引
control_qubits	control_qubits() -> list[int]	控制量子比特索引
target_qubits	target_qubits() -> list[int]	目标量子比特索引
dagger	dagger() -> QGate	返回门的 dagger（共轭转置）
is_dagger	is_dagger() -> bool	门是否处于 dagger 形式
power	power(k: float) -> QGate	将门提升到幂次
clear_control	clear_control() -> None	移除所有控制量子比特
control	control(qubit: int) -> QGate	添加单个控制量子比特，返回受控门
control	control(qubits: list[int]) -> QGate	添加多个控制量子比特，返回受控门
matrix	matrix(expanded: bool = False) -> numpy.ndarray	幺正矩阵表示；若 expanded 为 True，扩展至完整系统大小
gate_type	gate_type() -> GateType	标识门类型的枚举值
remap	remap(qubit_map: dict[int, int]) -> QGate	使用映射字典重索引量子比特
remap	remap(qubit_list: list[int]) -> QGate	使用有序列表重索引量子比特
parameters	parameters() -> list[float]	门参数
set_parameters	set_parameters(params: list[float]) -> None	设置门参数
name	name() -> str	门名称字符串

单量子比特门

H — Hadamard 门

H(qubit: int) -> QGate

应用 Hadamard 门，创建等概率叠加态。

$$H=\frac{1}{\sqrt{2}}\left[\begin{array}{cc}1& 1\\ 1& -1\end{array}\right]$$

from pyqpanda3.core import H, CPUQVM, QProg, measure

qvm = CPUQVM()
prog = QProg()
prog << H(0)
prog << measure(0, 0)
qvm.run(prog, 1000)
result = qvm.result()
print(result.get_counts())

运行结果：

{'0': 543, '1': 457}

X — 泡利-X（NOT）

X(qubit: int) -> QGate

比特翻转（NOT）门。

$$X=\left[\begin{array}{cc}0& 1\\ 1& 0\end{array}\right]$$

Y — 泡利-Y

Y(qubit: int) -> QGate

$$Y=\left[\begin{array}{cc}0& -i\\ i& 0\end{array}\right]$$

Z — 泡利-Z

Z(qubit: int) -> QGate

相位翻转门。

$$Z=\left[\begin{array}{cc}1& 0\\ 0& -1\end{array}\right]$$

I — 恒等门

I(qubit: int) -> QGate

恒等门（无操作）。

$$I=\left[\begin{array}{cc}1& 0\\ 0& 1\end{array}\right]$$

S — 相位门

S(qubit: int) -> QGate

$$S=\left[\begin{array}{cc}1& 0\\ 0& i\end{array}\right]$$

T — T 门（π/8 门）

T(qubit: int) -> QGate

$$T=\left[\begin{array}{cc}1& 0\\ 0& e^{i\pi /4}\end{array}\right]$$

X1 — SX 门

X1(qubit: int) -> QGate

$$X1=\frac{1}{\sqrt{2}}\left[\begin{array}{cc}1& -i\\ -i& 1\end{array}\right]$$

Y1

Y1(qubit: int) -> QGate

$$Y1=\frac{1}{\sqrt{2}}\left[\begin{array}{cc}1& -1\\ 1& 1\end{array}\right]$$

Z1

Z1(qubit: int) -> QGate

$$Z1=\frac{1}{\sqrt{2}}\left[\begin{array}{cc}1-i& 0\\ 0& 1+i\end{array}\right]$$

P — 相位门（参数化）

P(qubit: int, theta: float) -> QGate

参数	类型	说明
qubit	int	目标量子比特索引
theta	float	旋转角度（弧度）

$$P(\theta )=\left[\begin{array}{cc}1& 0\\ 0& e^{i\theta }\end{array}\right]$$

RX — 绕 X 轴旋转

RX(qubit: int, theta: float) -> QGate

参数	类型	说明
qubit	int	目标量子比特索引
theta	float	旋转角度（弧度）

$$R_X(\theta )=e^{-i\theta X/2}=\left[\begin{array}{cc}\cos (\theta /2)& -i\sin (\theta /2)\\ -i\sin (\theta /2)& \cos (\theta /2)\end{array}\right]$$

RY — 绕 Y 轴旋转

RY(qubit: int, theta: float) -> QGate

$$R_Y(\theta )=e^{-i\theta Y/2}=\left[\begin{array}{cc}\cos (\theta /2)& -\sin (\theta /2)\\ \sin (\theta /2)& \cos (\theta /2)\end{array}\right]$$

RZ — 绕 Z 轴旋转

RZ(qubit: int, theta: float) -> QGate

$$R_Z(\theta )=e^{-i\theta Z/2}=\left[\begin{array}{cc}{e}^{-i\theta /2}& 0\\ 0& e^{i\theta /2}\end{array}\right]$$

RPHI — R-Phi 门

RPHI(control: int, theta: float, phi: float) -> QGate

注意: RPhi 是一种变分门（VQGate），具有不同的签名。它并非 RPHI 的别名。详见变分门。

参数	类型	说明
control	int	目标量子比特索引
theta	float	旋转角度
phi	float	相位角度

$$R_{\text{PHI}}(\theta ,\varphi )=\left[\begin{array}{cc}\cos (\theta /2)& -i{e}^{-i\varphi }\sin (\theta /2)\\ -i{e}^{i\varphi }\sin (\theta /2)& \cos (\theta /2)\end{array}\right]$$

U1

U1(qubit: int, theta: float) -> QGate

单参数门，等价于 $P(\theta )$。

U2

U2(qubit: int, theta: float, phi: float) -> QGate

参数	类型	说明
qubit	int	目标量子比特索引
theta	float	第一个角度参数
phi	float	第二个角度参数

$$U2(\theta ,\varphi )=\frac{1}{\sqrt{2}}\left[\begin{array}{cc}1& -e^{i\varphi }\\ e^{i\theta }& e^{i(\theta +\varphi )}\end{array}\right]$$

U3

U3(qubit: int, theta: float, phi: float, lambda: float) -> QGate

参数	类型	说明
qubit	int	目标量子比特索引
theta	float	旋转角度
phi	float	第一个相位
lambda	float	第二个相位

$$U3(\theta ,\varphi ,\lambda )=\left[\begin{array}{cc}\cos (\theta /2)& -e^{i\lambda }\sin (\theta /2)\\ e^{i\varphi }\sin (\theta /2)& e^{i(\varphi +\lambda )}\cos (\theta /2)\end{array}\right]$$

U4

U4(qubit: int, theta: float, phi: float, lambda: float, gamma: float) -> QGate

参数	类型	说明
qubit	int	目标量子比特索引
theta	float	第一个角度
phi	float	第二个角度
lambda	float	第三个角度
gamma	float	第四个角度

$$U4(\theta ,\varphi ,\lambda ,\gamma )=\left[\begin{array}{cc}{e}^{i(\theta -\varphi /2-\gamma /2)}\cos (\lambda /2)& -e^{i(\theta -\varphi /2+\gamma /2)}\sin (\lambda /2)\\ e^{i(\theta +\varphi /2-\gamma /2)}\sin (\lambda /2)& e^{i(\theta +\varphi /2+\gamma /2)}\cos (\lambda /2)\end{array}\right]$$

IDLE

IDLE(qubit: int, nanoseconds: float) -> QGate

参数	类型	说明
qubit	int	目标量子比特索引
nanoseconds	float	延迟持续时间（纳秒）

双量子比特门

CNOT — 受控非门

CNOT(qubit1: int, qubit2: int) -> QGate

参数	类型	说明
qubit1	int	控制量子比特索引
qubit2	int	目标量子比特索引

$$\text{CNOT}=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\\ 0& 0& 1& 0\end{array}\right]$$

from pyqpanda3.core import H, CNOT, CPUQVM, QProg, measure

qvm = CPUQVM()
prog = QProg()
# 创建 Bell 态
prog << H(0) << CNOT(0, 1)
prog << measure(0, 0) << measure(1, 1)
qvm.run(prog, 1000)
print(qvm.result().get_counts())

运行结果：

{'00': 524, '11': 476}

CZ — 受控-Z 门

CZ(qubit1: int, qubit2: int) -> QGate

$$\text{CZ}=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& -1\end{array}\right]$$

CP — 受控相位门

CP(control: int, target: int, theta: float) -> QGate

参数	类型	说明
control	int	控制量子比特索引
target	int	目标量子比特索引
theta	float	相位角度（弧度）

$$\text{CP}(\theta )=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& e^{i\theta }\end{array}\right]$$

CR — 受控旋转（CP 的别名）

CR(control: int, target: int, theta: float) -> QGate

等价于 CP。

CRX — 受控 RX 门

CRX(control: int, target: int, theta: float) -> QGate

CRY — 受控 RY 门

CRY(control: int, target: int, theta: float) -> QGate

CRZ — 受控 RZ 门

CRZ(control: int, target: int, theta: float) -> QGate

SWAP

SWAP(qubit1: int, qubit2: int) -> QGate

$$\text{SWAP}=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& 1& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 1\end{array}\right]$$

ISWAP

ISWAP(qubit1: int, qubit2: int) -> QGate

$$\text{iSWAP}=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 0& i& 0\\ 0& i& 0& 0\\ 0& 0& 0& 1\end{array}\right]$$

SQISWAP — 平方根 iSWAP 门

SQISWAP(qubit1: int, qubit2: int) -> QGate

$$\text{SQISWAP}=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& \frac{1}{\sqrt{2}}& \frac{i}{\sqrt{2}}& 0\\ 0& \frac{i}{\sqrt{2}}& \frac{1}{\sqrt{2}}& 0\\ 0& 0& 0& 1\end{array}\right]$$

ECHO

ECHO(qubit: int, param: float = 0.0) -> QGate

参数	类型	说明
qubit	int	目标量子比特索引
param	float	回波参数（默认 0.0）

CU — 受控 U 门

CU(control: int, target: int, theta: float, phi: float, lambda: float, gamma: float) -> QGate

参数	类型	说明
control	int	控制量子比特索引
target	int	目标量子比特索引
theta	float	旋转角度
phi	float	第一个相位
lambda	float	第二个相位
gamma	float	第三个相位

RXX — 绕 XX 旋转

RXX(control: int, target: int, theta: float) -> QGate

$$R_{XX}(\theta )=e^{-i\theta X\otimes X/2}=\left[\begin{array}{cccc}\cos (\theta /2)& 0& 0& -i\sin (\theta /2)\\ 0& \cos (\theta /2)& -i\sin (\theta /2)& 0\\ 0& -i\sin (\theta /2)& \cos (\theta /2)& 0\\ -i\sin (\theta /2)& 0& 0& \cos (\theta /2)\end{array}\right]$$

RYY — 绕 YY 旋转

RYY(control: int, target: int, theta: float) -> QGate

$$R_{YY}(\theta )=e^{-i\theta Y\otimes Y/2}=\left[\begin{array}{cccc}\cos (\theta /2)& 0& 0& i\sin (\theta /2)\\ 0& \cos (\theta /2)& -i\sin (\theta /2)& 0\\ 0& -i\sin (\theta /2)& \cos (\theta /2)& 0\\ i\sin (\theta /2)& 0& 0& \cos (\theta /2)\end{array}\right]$$

RZZ — 绕 ZZ 旋转

RZZ(control: int, target: int, theta: float) -> QGate

$$R_{ZZ}(\theta )=e^{-i\theta Z\otimes Z/2}=\left[\begin{array}{cccc}{e}^{-i\theta /2}& 0& 0& 0\\ 0& e^{i\theta /2}& 0& 0\\ 0& 0& e^{i\theta /2}& 0\\ 0& 0& 0& e^{-i\theta /2}\end{array}\right]$$

RZX — 绕 ZX 旋转

RZX(control: int, target: int, theta: float) -> QGate

$$R_{ZX}(\theta )=e^{-i\theta Z\otimes X/2}=\left[\begin{array}{cccc}\cos (\theta /2)& 0& -i\sin (\theta /2)& 0\\ 0& \cos (\theta /2)& 0& i\sin (\theta /2)\\ -i\sin (\theta /2)& 0& \cos (\theta /2)& 0\\ 0& i\sin (\theta /2)& 0& \cos (\theta /2)\end{array}\right]$$

多量子比特门

TOFFOLI — CCX（受控-受控-非门）

TOFFOLI(qubit1: int, qubit2: int, qubit3: int) -> QGate

参数	类型	说明
qubit1	int	第一个控制量子比特
qubit2	int	第二个控制量子比特
qubit3	int	目标量子比特

当且仅当两个控制量子比特都为 $|1⟩$ 时翻转目标量子比特。

特殊门

BARRIER

BARRIER(qubits: list[int]) -> QGate

参数	类型	说明
qubits	list[int]	要施加屏障的量子比特索引

在转译期间阻止跨屏障的优化。

RESET

RESET(qubit: int) -> QGate

参数	类型	说明
qubit	int	要重置到 `

0.5.0 新增。施加原生非幺正 RESET 信道：该量子比特被测量并按需翻转，确定性地坍缩到 |0>，且不影响经典寄存器。在 CPU 态矢量与密度矩阵模拟器上受支持；其他后端在执行时报错，受控 RESET 无物理定义。该操作可经 OriginIR 双向往返，并可从 OpenQASM 2.0 的 reset q[i]; 语句解析；将其导出回 OpenQASM 会抛出 RuntimeError（请改用 OriginIR）。

from pyqpanda3.core import CPUQVM, QProg, RESET, X, measure

prog = QProg() << X(0) << RESET(0) << measure(0, 0)
qvm = CPUQVM()
qvm.run(prog, 100)
print(qvm.result().get_counts())

运行结果：

{'0': 100}

MS — Molmer-Sorensen 门

MS(qubit1: int, qubit2: int) -> QGate

用于囚禁离子量子计算的双量子比特纠缠门。

$$\text{MS}=\frac{1}{\sqrt{2}}\left[\begin{array}{cccc}1& 0& 0& -i\\ 0& 1& -i& 0\\ 0& -i& 1& 0\\ -i& 0& 0& 1\end{array}\right]$$

Oracle

Oracle(qubits: list[int], matrix: numpy.ndarray, check_unitary: bool = True) -> QGate

参数	类型	说明
qubits	list[int]	Oracle 作用的量子比特索引
matrix	numpy.ndarray	复数幺正矩阵
check_unitary	bool	构造门之前校验 matrix 是否为幺正矩阵（0.5.0 新增）。默认 True。

从给定的幺正矩阵创建自定义门。

矩阵按所给量子比特的顺序作用：qubits[0] 对应矩阵的最高位因子，即克罗内克积最左侧的一项。因此在量子比特 [0, 1] 上，X ⊗ I 翻转量子比特 0，而 I ⊗ X 翻转量子比特 1；把列表写成 [1, 0] 则会交换各因子作用的量子比特。

import numpy as np
from pyqpanda3.core import Oracle, CPUQVM, QProg

x = np.array([[0, 1], [1, 0]], dtype=complex)
i = np.eye(2, dtype=complex)

# qubits[0] 是最左因子，因此 X 作用于量子比特 0
qvm = CPUQVM()
qvm.run(QProg() << Oracle([0, 1], np.kron(x, i)), 1)
print({format(k, '02b'): round(abs(v), 3)
       for k, v in enumerate(qvm.result().get_state_vector()) if abs(v) > 1e-9})

运行结果：

{'10': 1.0}

check_unitary 用于拒绝非幺正矩阵——那会定义一个非物理的门。除非矩阵来自可信来源且该次校验确有可测量的开销，否则请保持启用：

import numpy as np
from pyqpanda3.core import Oracle

not_unitary = np.array([[1, 1], [0, 1]], dtype=complex)

try:
    Oracle([0], not_unitary)
except ValueError as e:
    print(type(e).__name__, "-", e)

gate = Oracle([0], not_unitary, check_unitary=False)
print("built without validation:", type(gate).__name__)

运行结果：

ValueError - Non-unitary matrix for QOracle-gate.
built without validation: QGate

import numpy as np
from pyqpanda3.core import Oracle

# 从幺正矩阵创建 2 量子比特 oracle
mat = np.eye(4, dtype=complex)
gate = Oracle([0, 1], mat)

门操作

所有 QGate 对象支持以下操作：

Dagger（共轭转置）

from pyqpanda3.core import H

gate = H(0)
dg = gate.dagger()  # Hermitian conjugate

Control（控制）

from pyqpanda3.core import X

gate = X(1)
cgate = gate.control([0])  # CNOT with qubit 0 as control

Power（幂）

from pyqpanda3.core import S

gate = S(0)
t_gate = gate.power(2)  # S^2 = Z

另见

• 线路 — QCircuit 和 QProg 用于组合门
• 枚举 — GateType 枚举
• 变分门 — 参数化门变体

---

create_gate

通过指定名称、目标量子比特和参数来创建量子门。这是一个通用工厂函数，可以动态构造任何支持的门类型。

签名

create_gate(gate_name: str, qubits: list[int], params: list[float]) -> QGate

参数

参数	类型	说明
gate_name	str	要创建的门名称（如 "H"、"RX"、"CNOT"）
qubits	list[int]	目标量子比特索引列表
params	list[float]	参数值列表（非参数化门传空列表）

示例

from pyqpanda3.core import create_gate

# 在量子比特 0 上创建 Hadamard 门
h = create_gate("H", [0], [])

# 在量子比特 1 上创建角度为 1.57 的 RX 旋转门
rx = create_gate("RX", [1], [1.57])

# 创建 CNOT 门，控制=0，目标=1
cnot = create_gate("CNOT", [0, 1], [])