PauliOperator

PauliOperator 表示作用于量子比特的泡利字符串的加权和。它是 pyqpanda3 中定义量子可观测量和问题哈密顿量的主要类。算符中的每一项是特定量子比特上泡利矩阵（$I$、$X$、$Y$、$Z$）的张量积，乘以一个复系数：

$$O=\sum _i{c}_i\underset{j}{⨂}{\sigma }_{ij}$$

其中 ${\sigma }_{ij}\in \{I,X,Y,Z\}$ 且 $c_i\in \mathbb{C}$。

四个泡利矩阵为：

$$I=\left(\begin{array}{cc}1& 0\\ 0& 1\end{array}\right),X=\left(\begin{array}{cc}0& 1\\ 1& 0\end{array}\right),Y=\left(\begin{array}{cc}0& -i\\ i& 0\end{array}\right),Z=\left(\begin{array}{cc}1& 0\\ 0& -1\end{array}\right)$$

构造

默认构造函数

PauliOperator() -> PauliOperator

构造一个空的（零）PauliOperator，没有项。

拷贝构造函数

PauliOperator(pauli_operator: PauliOperator) -> PauliOperator

参数	类型	说明
pauli_operator	PauliOperator	要深拷贝的现有 PauliOperator。

从字符串构造

PauliOperator(pauli: str) -> PauliOperator

从单个泡利字符串的字符串表示构造 PauliOperator。

参数	类型	说明
pauli	str	类似 "X0 Z1" 或 "Z0 X1 Y2" 的字符串。每个标记是一个泡利字符后跟量子比特索引。

从字典构造

PauliOperator(pauli_with_coef_s: dict[str, complex]) -> PauliOperator

从将泡利字符串映射到复系数的字典构造 PauliOperator。

参数	类型	说明
pauli_with_coef_s	dict[str, complex]	例如 {"X0 Z1": 1.1, "Y2 I1": 2.1+0j} 的字典。

从并行列表构造（稀疏表示法）

PauliOperator(paulis: list[str], coefs: list[complex]) -> PauliOperator

从两个并行列表——泡利字符串及其系数——构造。

参数	类型	说明
paulis	list[str]	泡利字符串列表，例如 ["X0 Z1", "Y2 I1"]。
coefs	list[complex]	系数列表，例如 [1.1+0j, 2.1+0j]。必须与 paulis 长度相同。

从并行列表构造（紧凑表示法）

PauliOperator(paulis: list[str], coefs: list[complex], AB_is_A1_B0: bool) -> PauliOperator

使用紧凑泡利表示法从并行列表构造，其中每个字符串字符按位置映射到量子比特索引。

参数	类型	说明
paulis	list[str]	紧凑泡利字符串列表，例如 ["XZI", "IZX"]。字符位置映射到量子比特索引。
coefs	list[complex]	系数列表，例如 [1.1+0j, 2.1+0j]。必须与 paulis 长度相同。
AB_is_A1_B0	bool	如果为 True，字符串中字符索引 0 对应量子比特 0。如果为 False，字符索引 0 对应最高量子比特索引。

从元组列表构造

PauliOperator(paulis_qbits_coef__s: list[tuple[str, list[int], complex]]) -> PauliOperator

从元组列表构造，每个元组指定泡利字符串、量子比特索引和系数。

参数	类型	说明
paulis_qbits_coef__s	list[tuple[str, list[int], complex]]	例如 [("XZ", [0, 4], 1.1+0j), ("YX", [1, 2], 2.1+0j)]。每个元组为 (泡利字符串, 量子比特索引, 系数)。

从矩阵构造

PauliOperator(mat: numpy.ndarray) -> PauliOperator

通过将实值矩阵分解为泡利字符串之和来构造 PauliOperator。

参数	类型	说明
mat	numpy.ndarray	实值方阵（二维，双精度）。矩阵维度必须是 2 的幂。

运算符

加法

PauliOperator.__add__(other: PauliOperator) -> PauliOperator
PauliOperator.__add__(num: complex) -> PauliOperator
PauliOperator.__radd__(num: complex) -> PauliOperator
PauliOperator.__iadd__(other: PauliOperator) -> PauliOperator
PauliOperator.__iadd__(num: complex) -> PauliOperator

将两个 PauliOperator 相加或加上标量（视为恒等算子上的系数）。当两个项具有相同的泡利字符串时，它们的系数被求和。返回新的 PauliOperator。

减法

PauliOperator.__sub__(other: PauliOperator) -> PauliOperator
PauliOperator.__sub__(num: complex) -> PauliOperator
PauliOperator.__rsub__(num: complex) -> PauliOperator
PauliOperator.__isub__(other: PauliOperator) -> PauliOperator
PauliOperator.__isub__(num: complex) -> PauliOperator

从一个 PauliOperator 减去另一个，或减去标量。对于 num - self，结果等价于 PauliOperator("I") * num - self。

一元取负

PauliOperator.__neg__() -> PauliOperator

返回算符的取负，等价于 self * (-1)。

乘法

PauliOperator.__mul__(other: PauliOperator) -> PauliOperator
PauliOperator.__mul__(scalar: complex) -> PauliOperator
PauliOperator.__rmul__(scalar: complex) -> PauliOperator

将两个 PauliOperator 相乘（遵循泡利代数规则：$X^2=I$、$XY=iZ$ 等）或将所有系数乘以标量。返回新的 PauliOperator。

原地乘法

PauliOperator.__imul__(other: PauliOperator) -> PauliOperator

将当前 PauliOperator 与另一个 PauliOperator 原地相乘，遵循泡利代数规则。当前对象被更新为乘积。

矩阵乘法（@）

PauliOperator.__matmul__(other: PauliOperator) -> PauliOperator

等价于 __mul__。使用泡利代数计算两个 PauliOperator 的乘积。

张量积

PauliOperator.tensor(other: PauliOperator) -> PauliOperator
PauliOperator.tensor(n: int) -> PauliOperator

计算此算符与另一个算符的张量积（Kronecker 积），或与其自身 n-1 次的张量积。在结果中，左操作数的量子比特索引保持不变，而右操作数的索引偏移左操作数的量子比特数。

相等

PauliOperator.__eq__(other: PauliOperator) -> bool

如果两个 PauliOperator 具有相同的项和相同的系数，则它们相等。

方法

str_with_I

PauliOperator.str_with_I(AB_is_A1_B0: bool = True) -> str

返回包含恒等（I）字符的字符串表示。如果 AB_is_A1_B0 为 True，字符串中的第一个字符对应最高量子比特索引。

参数	类型	说明
AB_is_A1_B0	bool	控制量子比特到字符索引的顺序。默认 True。

返回： 类似 "IXZ" 的字符串，表示所有量子比特上的算符。

str_no_I / str_without_I

PauliOperator.str_no_I() -> str
PauliOperator.str_without_I() -> str

返回不包含恒等项的字符串表示。格式使用 "X0"、"Y1"、"Z2" 表示法。

返回： 类似 "X0 Z1" 的字符串。

matrix

PauliOperator.matrix() -> numpy.ndarray

将 PauliOperator 转换为其稠密矩阵表示。

返回： 形状为 (2^n, 2^n) 的复值 NumPy 数组，其中 n 是量子比特数。

group_commuting

PauliOperator.group_commuting(qubit_wise: bool = False) -> list[list[PauliOperator]]

将项分组为可交换子集。

参数	类型	说明
qubit_wise	bool	如果为 True，使用逐量子比特对易（同一量子比特上的泡利必须对易）。如果为 False，使用完全对易（对易子为零）。默认 False。

返回： PauliOperator 列表的列表，每个内部列表包含互相可交换的项。

terms

PauliOperator.terms() -> list[PauliTerm]

返回组成此算符的各个泡利项。

返回： PauliTerm 对象列表。

to_qcircuits

PauliOperator.to_qcircuits() -> list[tuple[QCircuit, complex]]

将每一项转换为与其系数配对的量子线路。

返回： (QCircuit, complex) 元组列表。

qubits

PauliOperator.qubits() -> tuple[list[int], list[int]]

返回算符中涉及的量子比特，分为仅受恒等作用和受非恒等泡利作用的两组。

返回： 元组 (仅受恒等作用的量子比特, 受非恒等泡利作用的量子比特)。

max_qbit_idx

PauliOperator.max_qbit_idx() -> int

返回算符中任何项引用的最大量子比特索引。

返回： 整数量子比特索引。

data_3tuple_list_complex_coeff

PauliOperator.data_3tuple_list_complex_coeff() -> list[tuple[str, list[int], complex]]

以 (泡利字符串, 量子比特索引, 复系数) 元组列表的形式返回内部数据。

返回： 例如 [("XXZ", [0, 1, 4], 1+2j), ("ZZ", [1, 2], -1+1j)]。

data_3tuple_list_float_coeff

PauliOperator.data_3tuple_list_float_coeff() -> list[tuple[str, list[int], float]]

以 (泡利字符串, 量子比特索引, 浮点系数) 元组列表的形式返回内部数据。如果任何系数有非零虚部则抛出错误。

返回： 例如 [("XXZ", [0, 1, 4], 1.0), ("ZZ", [1, 2], -1.0)]。

data_dict_float_coeff

PauliOperator.data_dict_float_coeff() -> dict[str, float]

以将泡利字符串映射到浮点系数的字典形式返回算符数据。

返回： 例如 {"Z0": 0.395, "Z1": -0.395}。

data_dict_complex_coeff

PauliOperator.data_dict_complex_coeff() -> dict[str, complex]

以将泡利字符串映射到复系数的字典形式返回算符数据。

返回： 例如 {"Z0": 0.395+0j, "Z1": -0.395+0j}。

data_dict_str

PauliOperator.data_dict_str(is_coeff_complex: bool = True, double_quote: bool = True) -> str

将算符序列化为适合后续反序列化的字符串格式。

参数	类型	说明
is_coeff_complex	bool	是否将系数序列化为复数。默认 True。
double_quote	bool	是否对键使用双引号。默认 True。

返回： 类似 '"Z0": 0.395, "Z1": -0.395' 的序列化字符串。

from_dict_str（静态）

PauliOperator.from_dict_str(dict_str: str) -> PauliOperator

将 data_dict_str() 生成的字符串反序列化为 PauliOperator。

参数	类型	说明
dict_str	str	类似 '"Z0": 0.395, "Z1": -0.395' 的序列化字符串。

返回： 一个新的 PauliOperator。

示例

从字典构造

定义哈密顿量的常用模式是传递泡利字符串和系数的字典。

from pyqpanda3.hamiltonian import PauliOperator

# 定义 2 量子比特哈密顿量：
# H = 0.5 * Z0 Z1 + 0.3 * X0 + 0.1 * X1
h = PauliOperator({"Z0 Z1": 0.5, "X0": 0.3, "X1": 0.1})
print(h)

使用标志从紧凑表示法构造

from pyqpanda3.hamiltonian import PauliOperator

# 紧凑字符串：字符位置映射到量子比特索引
# "XZ" 对应量子比特索引 [0, 1] 表示量子比特 0 上的 X，量子比特 1 上的 Z
h = PauliOperator(["XZ", "ZX"], [1.0+0j, -1.0+0j], True)
print(h)

算术运算

from pyqpanda3.hamiltonian import PauliOperator

a = PauliOperator({"X0": 1.0})
b = PauliOperator({"Z0": 1.0})

# 加法
s = a + b
print("a + b =", s)

# 乘法（泡利代数：X * Z = -iY）
p = a * b
print("a * b =", p)

# 标量乘法
scaled = 2.0 * a
print("2 * a =", scaled)

# 取负
neg = -a
print("-a =", neg)

张量积

from pyqpanda3.hamiltonian import PauliOperator

a = PauliOperator({"X0": 1.0})
b = PauliOperator({"Z0": 1.0})

# 张量积：b 的量子比特被偏移
t = a.tensor(b)
print("a tensor b =", t)
# 结果：X0 Z1 系数为 1.0

矩阵表示

from pyqpanda3.hamiltonian import PauliOperator

h = PauliOperator({"Z0": 1.0, "X0": 0.5})
mat = h.matrix()
print(mat)

分组可交换项

from pyqpanda3.hamiltonian import PauliOperator

h = PauliOperator({"X0": 1.0, "Z0": 1.0, "X1": 0.5})
groups = h.group_commuting(qubit_wise=True)
for i, group in enumerate(groups):
    print(f"Group {i}:")
    for op in group:
        print(f"  {op}")

序列化与反序列化

from pyqpanda3.hamiltonian import PauliOperator

h = PauliOperator({"Z0": 0.5, "X1": -0.3})
s = h.data_dict_str()
print("Serialized:", s)

h2 = PauliOperator.from_dict_str(s)
print("Deserialized:", h2)
print("Equal:", h == h2)

另见

• PauliTerm -- PauliOperator 中的单个项
• PauliWithQbit -- 单个量子比特上的泡利矩阵
• Hamiltonian -- 高级哈密顿量封装