量子门

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())

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

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 是 RPHI 的别名，两者功能完全相同。

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

U1

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

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

U2

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

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

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	第四个角度

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())

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

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}$$

RYY — 绕 YY 旋转

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

$$R_{YY}(\theta )=e^{-i\theta Y\otimes Y/2}$$

RZZ — 绕 ZZ 旋转

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

$$R_{ZZ}(\theta )=e^{-i\theta Z\otimes Z/2}$$

RZX — 绕 ZX 旋转

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

$$R_{ZX}(\theta )=e^{-i\theta Z\otimes X/2}$$

多量子比特门

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]	要施加屏障的量子比特索引

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

MS — Molmer-Sorensen 门

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

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

Oracle

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

参数	类型	说明
qubits	list[int]	Oracle 作用的量子比特索引
matrix	numpy.ndarray	复数幺正矩阵

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

import numpy as np
from pyqpanda3.core import Oracle

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

门操作

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

Dagger（共轭转置）

gate = H(0)
dg = gate.dagger()  # 厄米共轭

Control（控制）

gate = X(1)
cgate = gate.control([0])  # 以量子比特 0 为控制的 CNOT

Power（幂）

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], [])