泡利算符类

泡利算符是一组三个2×2的幺正厄米复矩阵，又称酉矩阵。我们一般都以希腊字母 \(\sigma\) （西格玛）来表示，记作 \(\sigma_x\) ，\(\sigma_y\) ，\(\sigma_Z\) 。在 QPanda 中我们称它们为 \(X\) 门，\(Y\) 门，\(Z\) 门。它们对应的矩阵形式如下表所示。

	\(\sigma_x\)	\(\begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix}\quad\)
	\(\sigma_y\)	\(\begin{bmatrix} 0 & -i \\ i & 0 \end{bmatrix}\quad\)
	\(\sigma_z\)	\(\begin{bmatrix} 1 & 0 \\ 0 & -1 \end{bmatrix}\quad\)

泡利算符的运算规则如下：

1. 泡利算符与自身相乘得到是单位矩阵

\[\sigma_x\sigma_x = I\]

\[\sigma_y\sigma_y = I\]

\[\sigma_z\sigma_z = I\]

2. 泡利算符与单位矩阵相乘，无论是左乘还是右乘，其值不变

\[\sigma_xI = I\sigma_x = \sigma_x\]

\[\sigma_yI = I\sigma_y = \sigma_y\]

\[\sigma_zI = I\sigma_z = \sigma_z\]

3. 顺序相乘的两个泡利算符跟未参与计算的泡利算符是 \(i\) 倍的关系

\[\sigma_x\sigma_y = i\sigma_z\]

\[\sigma_y\sigma_z = i\sigma_x\]

\[\sigma_z\sigma_x = i\sigma_y\]

4. 逆序相乘的两个泡利算符跟未参与计算的泡利算符是 \(-i\) 倍的关系

\[\sigma_y\sigma_x = -i\sigma_z\]

\[\sigma_z\sigma_y = -i\sigma_x\]

\[\sigma_x\sigma_z = -i\sigma_y\]

模块介绍

class PauliOperator

Pauli 算符类

该类实现了生成和操作 Pauli 算符集合的功能，用于表示量子哈密顿量或量子操作。Pauli 算符是由 Pauli 矩阵组成的线性组合，常用于描述量子系统的演化和能级。

__init__(): 初始化 PauliOperator 类实例。

__init__(value: complex)

初始化 PauliOperator 类实例，给定复数值。

参数:: value (complex) -- 复数值。

__init__(matrix: numpy.ndarray, is_reduce_duplicates: bool = False)

初始化 PauliOperator 类实例，给定矩阵表示。

参数:

matrix (numpy.ndarray) -- 表示 Pauli 算符的矩阵，要求为 numpy.ndarray[numpy.float64[m, n]] 类型。
is_reduce_duplicates (bool, optional) -- 是否进行重复项削减。默认为 False。

__init__(key: str, value: complex, is_reduce_duplicates: bool = False)

初始化 PauliOperator 类实例，给定键值对。

参数:

key (str) -- 代表 Pauli 算符的字符串键。
value (complex) -- 复数值。
is_reduce_duplicates (bool, optional) -- 是否进行重复项削减。默认为 False。

__init__(pauli_map: Dict[str, complex], is_reduce_duplicates: bool = False)

初始化 PauliOperator 类实例，给定 Pauli 算符字典。

参数:

pauli_map (Dict[str, complex]) -- 包含 Pauli 算符键值对的字典。
is_reduce_duplicates (bool, optional) -- 是否进行重复项削减。默认为 False。

dagger() → PauliOperator

返回 Pauli 算符的共轭转置。

返回:: Pauli 算符的共轭转置。
返回类型:: PauliOperator

data() → List[Tuple[Tuple[Dict[int, str], str], complex]]

返回 Pauli 算符数据的列表形式。

返回:: 包含 Pauli 算符数据的列表，每个元组包含表示和复数值。
返回类型:: List[Tuple[Tuple[Dict[int, str], str], complex]]

error_threshold() → float

返回 Pauli 算符的错误阈值。

返回:: Pauli 算符的错误阈值。
返回类型:: float

getMaxIndex() → int

返回 Pauli 算符最大索引，下标从0开始

返回:: Pauli 算符最大索引。
返回类型:: int

get_max_index() → int

返回 Pauli 算符最大索引，下标从0开始

返回:: Pauli 算符最大索引。
返回类型:: int

isAllPauliZorI() → bool

检查是否所有 Pauli 算符都是 Pauli-Z 或单位算符。

返回:: 若所有算符均为 Pauli-Z 或单位算符则返回 True，否则返回 False。
返回类型:: bool

isEmpty() → bool

检查 Pauli 算符是否为空。

返回:: 若 Pauli 算符为空则返回 True，否则返回 False。
返回类型:: bool

is_all_pauli_z_or_i() → bool

检查是否所有 Pauli 算符都是 Pauli-Z 或单位算符。

返回:: 若所有算符均为 Pauli-Z 或单位算符则返回 True，否则返回 False。
返回类型:: bool

is_empty() → bool

检查 Pauli 算符是否为空。

返回:: 若 Pauli 算符为空则返回 True，否则返回 False。
返回类型:: bool

reduce_duplicates() → None: 削减重复的 Pauli 算符项。

remapQubitIndex(remap_dict: Dict[int, int]) → PauliOperator

重新映射量子比特索引。

参数:: remap_dict (Dict[int, int]) -- 指定索引映射关系的字典。
返回:: 重新映射后的 Pauli 算符。
返回类型:: PauliOperator

remap_qubit_index(remap_dict: Dict[int, int]) → PauliOperator

重新映射量子比特索引。

参数:: remap_dict (Dict[int, int]) -- 指定索引映射关系的字典。
返回:: 重新映射后的 Pauli 算符。
返回类型:: PauliOperator

setErrorThreshold(threshold: float) → None

设置 Pauli 算符的错误阈值。

参数:: threshold (float) -- 错误阈值。

set_error_threshold(threshold: float) → None

设置 Pauli 算符的错误阈值。

参数:: threshold (float) -- 错误阈值。

toHamiltonian(sparse: bool) → List[Tuple[Dict[int, str], float]]

将 Pauli 算符转换为哈密顿量。

参数:: sparse (bool) -- 是否以稀疏矩阵形式表示哈密顿量。
返回:: 哈密顿量数据列表，每个元组包含表示和复数值。
返回类型:: List[Tuple[Dict[int, str], float]]

toString() → str

返回 Pauli 算符的字符串表示。

返回:: Pauli 算符的字符串表示。
返回类型:: str

to_hamiltonian(sparse: bool) → List[Tuple[Dict[int, str], float]]

将 Pauli 算符转换为哈密顿量。

参数:: sparse (bool) -- 是否以稀疏矩阵形式表示哈密顿量。
返回:: 哈密顿量数据列表，每个元组包含表示和复数值。
返回类型:: List[Tuple[Dict[int, str], float]]

to_matrix() → numpy.ndarray

返回 Pauli 算符的矩阵表示。

返回:: Pauli 算符的矩阵表示。
返回类型:: numpy.ndarray

to_string() → str

返回 Pauli 算符的字符串表示。

返回:: Pauli 算符的字符串表示。
返回类型:: str

我们可以很容易的通过各种方式构造泡利算符类，例如

from pyqpanda import *

if __name__=="__main__":
    # 构造一个空的泡利算符类
    p1 = PauliOperator()

    # 2倍的"泡利Z0"张乘"泡利Z1"
    p2 = PauliOperator("Z0 Z1", 2)

    # 2倍的"泡利Z0"张乘"泡利Z1" + 3倍的"泡利X1"张乘"泡利Y2"
    p3 = PauliOperator({"Z0 Z1": 2, "X1 Y2": 3})

    # 构造一个单位矩阵，其系数为2，等价于p4 = PauliOperator("", 2)
    p4 = PauliOperator(2)

其中PauliOperator p2("Z0 Z1", 2)表示的是 \(2\sigma_{0}^{z}\otimes\sigma_{1}^{z}\)。

备注

构造泡利算符类的时候，字符串里面包含的字符只能是空格、 \(X\)、 \(Y\) 和 \(Z\)中的一个或多个，包含其它字符将会抛出异常。另外，同一个字符串里面同一泡利算符的比特索引不能相同，例如：PauliOperator("Z0 Z0", 2)将会抛出异常。

泡利算符类之间可以做加、减、乘等操作，计算返回结果还是一个泡利算符类。

a = PauliOperator("Z0 Z1", 2)
b = PauliOperator("X5 Y6", 3)

plus = a + b
minus = a - b
muliply = a * b

泡利算符类支持打印功能，我们可以将泡利算符类打印输出到屏幕上，方便查看其值。

a = PauliOperator("Z0 Z1", 2)

print(a)

我们在实际使用的时候，常常需要知道该泡利算符类操作了多少个量子比特，这时候我们通过调用泡利算符类getMaxIndex接口即可得到。如果是空的泡利算符类调用getMaxIndex接口则返回0，否则返回其最大下标索引值加1的结果。

a = PauliOperator("Z0 Z1", 2)
b = PauliOperator("X5 Y6", 3)

# 输出的值为1
print(a.getMaxIndex())
# 输出的值为6
print(b.getMaxIndex())

如果我们构造的的泡利算符类，其中泡利算符的下标索引不是从0开始分配的，例如PauliOperator("X5 Y6", 3)调用getMaxIndex接口返回的使用的比特数是7，其实只使用了2个比特。我们如何才能返回其真实用到的比特数呢。我们可以调用泡利算符类里面remapQubitIndex接口，它的功能是对泡利算符类中的索引从0比特开始分配映射，并返回新的泡利算符类，该接口需要传入一个map来保存前后下标的映射关系。

b = PauliOperator("X5 Y6", 3)

index_map = {}
a = b.remapQubitIndex(index_map)

# 输出的值为 6
print(b.getMaxIndex())
# 输出的值为 1
print(a.getMaxIndex())

实例

以下实例主要是展示 PauliOperator 接口的使用方式。

from pyqpanda import *

if __name__=="__main__":

    a = PauliOperator("Z0 Z1", 2)
    b = PauliOperator("X5 Y6", 3)

    plus = a + b
    minus = a - b
    muliply = a * b

    print("a + b = ", plus)
    print("a - b = ", minus)
    print("a * b = ", muliply)

    print("Index : ", muliply.getMaxIndex())

    index_map = {}
    remap_pauli = muliply.remapQubitIndex(index_map)

    print("remap_pauli : ", remap_pauli)
    print("Index : ", remap_pauli.getMaxIndex())

输出结果如下：

a + b =  {
"Z0 Z1" : 2.000000,
"X5 Y6" : 3.000000
}

a - b =  {
"Z0 Z1" : 2.000000,
"X5 Y6" : -3.000000
}

a * b =  {
"Z0 Z1 X5 Y6" : 6.000000
}

Index :  6
remap_pauli :  {
"Z0 Z1 X2 Y3" : 6.000000
}

Index :  3

费米子算符类

我们用如下的记号标识来表示费米子的两个形态，湮没: \(X\) 表示 \(a_x\) ，创建: \(X +\) 表示 \(a_x^\dagger\) ，例如: "1 + 3 5 + 1"则代表 \(a_1^\dagger \ a_3 \ a_5^\dagger \ a_1\)

整理规则如下

1. 不同数字

\[''1\quad 2'' = -1 * ''2\quad 1''\]

\[''1 + 2 +'' = -1 * ''2 + 1 +''\]

\[''1 + 2'' = -1 * ''2\quad 1 +''\]

2. 相同数字

\[''1\quad 1 + '' = 1 + ''1 + 1''\]

\[''1 + 1 + '' = 0\]

\[''1\quad 1'' = 0\]

跟 PauliOperator 类似，FermionOperator 类也提供了费米子算符之间加、减和乘的基础的运算操作。通过整理功能可以得到一份有序排列的结果。

class FermionOperator

费米子算符类，用于生成和操作费米子算符集合，主要用于量子化学等领域的模拟和计算。

__init__(): 初始化 FermionOperator 类的实例。

__init__(scalar: float)

初始化 FermionOperator 类的实例。

参数:: scalar (float) -- 标量值。

__init__(scalar: complex)

初始化 FermionOperator 类的实例。

参数:: scalar (complex) -- 复数标量值。

__init__(term: str, scalar: complex)

初始化 FermionOperator 类的实例。

参数:

term (str) -- 项的标识字符串，表示费米子项。
scalar (complex) -- 复数标量值。

__init__(terms: Dict[str, complex])

初始化 FermionOperator 类的实例。

参数:: terms (Dict[str, complex]) -- 复数标量值和项的字典，键为项的标识字符串。

data() → List[Tuple[Tuple[List[Tuple[int, bool]], str], complex]]

获取费米子算符数据。

返回:: 包含费米子项的列表，每个元组为一项，包含项的信息和复数标量值。
返回类型:: List[Tuple[Tuple[List[Tuple[int, bool]], str], complex]]

error_threshold() → float

获取误差阈值。

返回:: 误差阈值。
返回类型:: float

isEmpty() → bool

判断费米子算符是否为空。

返回:: 如果费米子算符为空，则为 True，否则为 False。
返回类型:: bool

normal_ordered() → FermionOperator

对费米子算符进行正则排序。

返回:: 经过正则排序后的费米子算符。
返回类型:: FermionOperator

setErrorThreshold(threshold: float) → None

设置误差阈值。

参数:: threshold (float) -- 误差阈值。

toString() → str

获取费米子算符的字符串表示。

返回:: 费米子算符的字符串表示。
返回类型:: str

to_string() → str

获取费米子算符的字符串表示。

返回:: 费米子算符的字符串表示。
返回类型:: str

实例

from pyqpanda import *

if __name__=="__main__":

    a = FermionOperator("0 1+", 2)
    b = FermionOperator("2+ 3", 3)

    plus = a + b
    minus = a - b
    muliply = a * b

    print("a + b = ", plus)
    print("a - b = ", minus)
    print("a * b = ", muliply)

    print("normal_ordered(a + b) = ", plus.normal_ordered())
    print("normal_ordered(a - b) = ", minus.normal_ordered())
    print("normal_ordered(a * b) = ", muliply.normal_ordered())

a + b =  {
0 1+ : 2.000000
2+ 3 : 3.000000
}

a - b =  {
0 1+ : 2.000000
2+ 3  : -3.000000
}

a * b =  {
0 1+ 2+ 3 : 6.000000
}

normal_ordered(a + b) =  {
1+ 0 : -2.000000
2+ 3 : 3.000000
}

normal_ordered(a - b) =  {
1+ 0 : -2.000000
2+ 3  : -3.000000
}

normal_ordered(a * b) =  {
2+ 1+ 3 0 : 6.000000
}