mindquantum.core.operators.QubitOperator

class mindquantum.core.operators.QubitOperator(terms: Union[str, 'QubitOperator'] = None, coefficient: PRConvertible = 1.0, internal: bool = False)

作用于量子比特的项的总和，例如 0.5 * 'X1 X5' + 0.3 * 'Z1 Z2'。 项是一个作用于n个量子比特的运算符，可以表示为：coefficient * local_operator[0] x … x local_operator[n-1]，其中x是张量乘积。 本地运算符是作用于一个量子比特的泡利运算符（'I'，'X'，'Y'或者'Z'）。 在数学符号中，一个QubitOperator是例如0.5 * 'X1 X5'的项，它意味着X运算符作用于量子比特1和5，而恒等运算符作用于其余所有量子比特。

请注意，由QubitOperator算子组成的哈密顿量应该是一个厄米算子，因此要求所有项的系数必须是实数。

QubitOperator的属性设置如下：operators = ('X', 'Y', 'Z')，different_indices_commute = True。

参数：

• term (Union[str, QubitOperator]) - 量子比特运算符的输入项。默认值： None。

• coefficient (Union[numbers.Number, str, Dict[str, numbers.Number], ParameterResolver]) - 此量子比特运算符的系数，可以是由字符串、符号或参数解析器表示的数字或变量。默认值： 1.0。

• internal (bool) - 第一个参数是否为泡利算符对象的内部c++类。默认值： False。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> ham = ((QubitOperator('X0 Y3', 0.5)
...         + 0.6 * QubitOperator('X0 Y3')))
>>> ham2 = QubitOperator('X0 Y3', 0.5)
>>> ham2 += 0.6 * QubitOperator('X0 Y3')
>>> ham2
1.1 [Y3 X0]
>>> ham3 = QubitOperator('')
>>> ham3
1 []
>>> ham_para = QubitOperator('X0 Y3', 'x')
>>> ham_para
x [Y3 X0]
>>> ham_para.subs({'x':1.2})
1.2 [Y3 X0]

astype(dtype)

将QubitOperator转化为不同的数据类型。

说明

将一个复数类型的QubitOperator转化为实数类型将会忽略系数的虚数部分。

参数：

• dtype (mindquantum.dtype) - 玻色子算符的新类型。

返回：

QubitOperator，给定类型的玻色子算符。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> import mindquantum as mq
>>> f = QubitOperator('X0', 2 + 3j)
>>> f.dtype
mindquantum.complex128
>>> f.astype(mq.float64)
2 [X0]

cast_complex()

将一个玻色子算符转化为等价的复数形式。

compress(abs_tol=EQ_TOLERANCE)

将系数很小的玻色子串项移除。

参数：

• abs_tol (float) - 绝对值阈值，必须大于0.0。默认值： EQ_TOLERANCE。

返回：

QubitOperator，经过压缩后的玻色子算符。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> ham_compress = QubitOperator('X0 Y1', 0.5) + QubitOperator('Z1 X3', 1e-7)
>>> ham_compress
1/2 [Y1 X0] +
1/10000000 [X3 Z1]
>>> ham_compress.compress(1e-6)
1/2 [Y1 X0]
>>> ham_para_compress =  QubitOperator('X0 Y1', 0.5) + QubitOperator('Z5', 'X')
>>> ham_para_compress
1/2 [Y1 X0] +
X [Z5]
>>> ham_para_compress.compress(1e-7)
1/2 [Y1 X0] +
X [Z5]

count_gates()

返回单哈密顿量处理时的门数量。

返回：

int，单量子门的数量。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> a = QubitOperator("X0 Y1") + QubitOperator("X2 Z3")
>>> a.count_gates()
4

count_qubits()

统计移除没用比特前所占用的比特数。

返回：

int，移除没用比特前所占用的比特数。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> a = QubitOperator("Z0 Y3")
>>> a.count_qubits()
4

property dtype

玻色子算符系数的数据类型。

dumps(indent: int = 4)

将QubitOperator转储到JSON（JavaScript对象表示法）。

参数：

• indent (int) - JSON数组元素和对象成员打印时的缩进。默认值： 4。

返回：

JSON(strings)，QubitOperator的JSON字符串。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> f = QubitOperator('0', 1 + 2j) + QubitOperator('0^', 'a')
>>> len(f.dumps())
581

static from_openfermion(of_ops)

将openfermion格式的玻色子算符转换为mindquantum格式。

参数：

• of_ops (openfermion.QubitOperator) - openfermion框架中的玻色子算符。

返回：

QubitOperator，mindquantum框架中的玻色子算符。

get_coeff(term)

获取给定项的系数。

参数：

• term (List[Tuple[int, Union[int, str]]]) - 想要获取系数的项。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> q = QubitOperator('X0 Y1', 1.2)
>>> q.get_coeff([(1, 'Y'), (0, 'X')])
ParameterResolver(dtype: float64, const: 1.200000)

hermitian()

返回QubitOperator的厄米共轭。

返回：

QubitOperator，玻色子算符的厄米共轭。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> a = QubitOperator("X0 Y1", {"a": 1 + 2j})
>>> a.hermitian()
(-1 + 2j)*a [1 0^]

property imag

获得系数的虚部。

返回：

QubitOperator，此玻色子算符的虚部。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> f = QubitOperator('X0', 1 + 2j) + QubitOperator('Y0', 'a')
>>> f.imag.compress()
2 [X0]

property is_complex

返回当前玻色子是否使用复数类型的系数。

property is_singlet

检查当前玻色子是否只有一项。

返回：

bool，当前玻色子是否只有一项。

static loads(strs: str)

将JSON（JavaScript对象表示法）加载到QubitOperator中。

参数：

• strs (str) - 转储的玻色子算符字符串。

返回：

QubitOperator，从字符串加载的QubitOperator。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> f = QubitOperator('0', 1 + 2j) + QubitOperator('0^', 'a')
>>> obj = QubitOperator.loads(f.dumps())
>>> obj == f
True

matrix(n_qubits: int = None, pr=None)

将此玻色子算符转换为csr_matrix。

参数：

• n_qubits (int) - 结果矩阵的量子比特数目。如果是None，则该值将是最大局域量子比特数。默认值： None。

• pr (ParameterResolver, dict, numpy.ndarray, list, numbers.Number) - 含参玻色子算符的参数。默认值： None。

property parameterized

检查当前玻色子是否是参数化的。

property params_name

获取玻色子算符的所有参数。

property real

获得系数的实部。

返回：

QubitOperator，这个玻色子算符的实部。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> f = QubitOperator('X0', 1 + 2j) + QubitOperator('Y0', 'a')
>>> f.real.compress()
1 [X0] +
a [Y0]

relabel(logic_qubits: List[int])

根据逻辑比特顺序重新编码量子比特。

参数：

• logic_qubits (List[int]) - 逻辑比特编号。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> o = QubitOperator('Z0 Y1 X2 Z3')
>>> o
1 [Z0 Y1 X2 Z3]
>>> o.relabel([1, 3, 0, 2])
1 [X0 Z1 Z2 Y3]

singlet()

将只有一个费米子串的玻色子算符分裂成只有一个玻色子的玻色子算符。

返回：

List[QubitOperator]，只有一个玻色子的玻色子算符。

异常：

• RuntimeError - 如果该玻色子算符拥有不止一个玻色子串。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> ops = QubitOperator("1^ 2", 1)
>>> print(ops.singlet())
[1 [2], 1 [1^]]

singlet_coeff()

当玻色子算符只有一个玻色子串时，返回该玻色子串的系数。

返回：

ParameterResolver，唯一玻色子串的系数。

异常：

• RuntimeError - 如果该玻色子算符拥有不止一个玻色子串。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> ops = QubitOperator("X0 Y1", "a")
>>> print(ops)
-a [2 1^]
>>> print(ops.singlet_coeff())
-a

property size

返回玻色子算符中玻色子串的数量。

split()

将算符的系数跟算符本身分开。

返回：

List[List[ParameterResolver, QubitOperator]]，分裂后的结果。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> a = QubitOperator('X0', 'a') + QubitOperator('Z1', 1.2)
>>> for i, j in a.split():
...     print(f"{i}, {j}")
a, 1 [X0]
1.2, 1 [Z1]

subs(params_value: PRConvertible)

将玻色子中的变量换成具体的参数值。

参数：

• params_value (Union[Dict[str, numbers.Number], ParameterResolver]) - 系数变量的参数。

样例：

>>> from mindquantum.core.operators import QubitOperator
>>> from mindquantum.core.parameterresolver import ParameterResolver
>>> q = QubitOperator('X0', ParameterResolver({'a': 2.0}, 3.0))
>>> q
2*a + 3 [X0]
>>> q.subs({'a': 1.5})
6 [X0]

property terms

返回玻色子算符中的玻色子串。

to_openfermion()

将玻色子算符转换为openfermion格式。