mindquantum.core.operators
MindQuantum算子库。算子由一个或多个基本门的组合而成。
包含以下类的表示： - Qubit算子 - Fermion算子 - 时间演化算子
- class mindquantum.core.operators.FermionOperator(term=None, coefficient=1.0)[源代码]
费米子算子，如FermionOperator(‘4^ 3 9 3^’)表示 \(a_4^\dagger a_3 a_9 a_3^\dagger\)。 这些是描述费米子系统的基本运算符，如分子系统。 FermionOperator遵循反交换关系。
- 参数：
terms (str) - 费米子算符的输入项。默认值：None。
coefficient (Union[numbers.Number, str, ParameterResolver]) - 单费米子算符的系数。默认值：1.0。
样例：
>>> from mindquantum.core.operators import FermionOperator >>> a_p_dagger = FermionOperator('1^') >>> a_p_dagger 1.0 [1^] >>> a_q = FermionOperator('0') >>> a_q 1.0 [0] >>> zero = FermionOperator() >>> zero 0 >>> identity= FermionOperator('') >>> identity 1.0 [] >>> para_op = FermionOperator('0 1^', 'x') >>> para_op x [0 1^] >>> para_dt = {'x':2} >>> op = para_op.subs(para_dt) >>> op 2 [0 1^]
- dumps(indent: int = 4)[源代码]
将FermionOperator转储到JSON（JavaScript对象表示法）。
- 参数：
indent (int) - JSON数组元素和对象成员打印时的缩进大小。默认值：4。
- 返回：
JSON(str)，FermionOperator的JSON字符串。
样例：
>>> from mindquantum.core.operators import FermionOperator >>> f = FermionOperator('0', 1 + 2j) + FermionOperator('0^', 'a') >>> len(f.dumps()) 443
- static from_openfermion(of_ops, dtype=None)[源代码]
将openfermion格式的费米子运算符转换为mindquantum格式。
- 参数：
of_ops (openfermion.FermionOperator) - openfermion中的费米子算符。
dtype (type) - 要生成的TermsOperator的类型（即实数“float”或复数“complex”）。 注意：此参数在 Python 版本的 QubitOperator 中被忽略。
- 返回：
FermionOperator，mindquantum中的费米子算符。
- property imag
获得系数的虚部。
- 返回：
FermionOperator，这个FermionOperator的虚部。
样例：
>>> from mindquantum.core.operators import FermionOperator >>> f = FermionOperator('0', 1 + 2j) + FermionOperator('0^', 'a') >>> f.imag.compress() 2.0 [0]
- static loads(strs: str, dtype: type)[源代码]
将JSON（JavaScript对象表示法）加载到FermionOperator中。
- 参数：
strs (str) - 转储的费米子运算符字符串。
dtype (type) - 生成的TermsOperator的类型.
- 返回：
FermionOperator，从字符串加载的FermionOperator。
样例：
>>> from mindquantum.core.operators import FermionOperator >>> f = FermionOperator('0', 1 + 2j) + FermionOperator('0^', 'a') >>> obj = FermionOperator.loads(f.dumps()) >>> obj == f True
- matrix(n_qubits: int = None)[源代码]
将此费米子运算符转换为jordan_wigner映射下的csr_matrix。
- 参数：
n_qubits (int) - 结果矩阵的总量子比特数。如果是None，则该值将是最大局域量子比特数。默认值：None。
- normal_ordered()[源代码]
返回FermionOperator的规范有序形式。
- 返回：
FermionOperator，规范有序的FermionOperator。
样例：
>>> from mindquantum.core.operators import FermionOperator >>> origin = FermionOperator('0 1^') >>> origin 1.0 [0 1^] >>> origin.normal_ordered() -1.0 [1^ 0]
- property real
获得系数的实部。
- 返回：
FermionOperator，这个FermionOperator的实部。
样例：
>>> from mindquantum.core.operators import FermionOperator >>> f = FermionOperator('0', 1 + 2j) + FermionOperator('0^', 'a') >>> f.real.compress() 1.0 [0] + a [0^]
- class mindquantum.core.operators.Hamiltonian(hamiltonian)[源代码]
QubitOperator哈密顿量的包装器。
- 参数：
hamiltonian (QubitOperator) - 泡利量子比特算子。
样例：
>>> from mindquantum.core.operators import QubitOperator, Hamiltonian >>> ham = Hamiltonian(QubitOperator('Z0 Y1', 0.3)) >>> ham 3/10 [Z0 Y1]
- class mindquantum.core.operators.InteractionOperator(constant, one_body_tensor, two_body_tensor)[源代码]
存储用于配置费米子分子哈密顿量的“交互算子”的类。哈密顿量包括存储了自旋和奇偶性的单体项和双体项。在这个模块中，存储的系数可以通过费米子算子表示为分子的哈密顿量。
说明
此类中存储的运算符具有以下形式：
\[C + \sum_{p, q} h_{[p, q]} a^\dagger_p a_q + \sum_{p, q, r, s} h_{[p, q, r, s]} a^\dagger_p a^\dagger_q a_r a_s.\]其中 \(C\) 是一个常数。
- 参数：
constant (numbers.Number) - 算子中的常量项，以浮点数形式给出。例如，核排斥能量。
one_body_tensor (numpy.ndarray) - 单体项的系数（h[p,q]）。这是一个 \(n_\text{qubits}\times n_\text{qubits}\) 的NumPy浮点数组。默认情况下，存储带有键值的NumPy数组 \(a^\dagger_p a_q\) (1,0)。
two_body_tensor (numpy.ndarray) - 双体项的系数 (h[p, q, r, s]) 。这是一个 \(n_\text{qubits}\times n_\text{qubits}\times n_\text{qubits}\times n_\text{qubits}\) 的NumPy浮点数组。默认情况下，存储带有键值的NumPy数组 \(a^\dagger_p a^\dagger_q a_r a_s\) (1, 1, 0, 0)。
- class mindquantum.core.operators.PolynomialTensor(n_body_tensors=None)[源代码]
以张量形式存储费米梯算子系数的类。 例如，在粒子数守恒的分子哈密顿量（4级多项式）中，只有三种项，即常数项、 单激励 \(a^\dagger_p a_q\) 和双激励项 \(a^\dagger_p a^\dagger_q a_r a_s\)，它们对应的系数可以存储在标量、 \(n_\text{qubits}\times n_\text{qubits}\) 矩阵和 \(n_\text{qubits}\times n_\text{qubits}\times n_\text{qubits}\times n_\text{qubits}\) 矩阵中。 请注意，由于奇偶性守恒，每个张量必须具有偶数维数。 这个类的大部分功能与FermionOperator的功能相似。
- 参数：
n_body_tensors (dict) - 存储描述n-body作用的张量的字典。 键是指示张量类型的元组。 例如，
n_body_tensors[()]将返回一个常量， 而n_body_tensors[(1, 0)]将是一个 \(n_\text{qubits}\times n_\text{qubits}\) 的numpy数组， 和n_body_tensors[(1,1,0,0)]将返回一个 \(n_\text{qubits}\times n_\text{qubits}\times n_\text{qubits}\times n_\text{qubits}\) 的numpy数组。 这些常数和数组分别表示identity、 \(a^\dagger_p a_q\) 和 \(a^\dagger_p a^\dagger_q a_r a_s\) 的系数。默认值：None。
说明
这里的’1’代表 \(a^\dagger\)，而’0’代表 \(a\)。
样例：
>>> import numpy as np >>> from mindquantum.core.operators import PolynomialTensor >>> constant = 1 >>> one_body_term = np.array([[1,0],[0,1]]) >>> two_body_term = two_body_term = np.array([[[[1,0],[0,1]],[[1,0],[0,1]]],[[[1,0],[0,1]],[[1,0],[0,1]]]]) >>> n_body_tensors = {(): 1, (1,0): one_body_term,(1,1,0,0):two_body_term} >>> poly_op = PolynomialTensor(n_body_tensors) >>> poly_op () 1 ((0, 1), (0, 0)) 1 ((1, 1), (1, 0)) 1 ((0, 1), (0, 1), (0, 0), (0, 0)) 1 ((0, 1), (0, 1), (1, 0), (1, 0)) 1 ((0, 1), (1, 1), (0, 0), (0, 0)) 1 ((0, 1), (1, 1), (1, 0), (1, 0)) 1 ((1, 1), (0, 1), (0, 0), (0, 0)) 1 ((1, 1), (0, 1), (1, 0), (1, 0)) 1 ((1, 1), (1, 1), (0, 0), (0, 0)) 1 ((1, 1), (1, 1), (1, 0), (1, 0)) 1 >>> # get the constant >>> poly_op.constant 1 >>> # set the constant >>> poly_op.constant = 2 >>> poly_op.constant 2 >>> poly_op.n_qubits 2 >>> poly_op.one_body_tensor array([[1, 0], [0, 1]]) >>> poly_op.two_body_tensor array([[[[1, 0], [0, 1]], [[1, 0], [0, 1]]], [[[1, 0], [0, 1]], [[1, 0], [0, 1]]]])
- property constant
获取常数项的值。
- property one_body_tensor
获得单体项。
- property two_body_tensor
获得双体项。
- class mindquantum.core.operators.Projector(proj)[源代码]
投影算子。
对于一个如下所示的投影算子：
\[\left|01\right>\left<01\right|\otimes I^2\]字符串格式为’01II’。
说明
索引小的量子比特位于bra和ket字符串格式的右端。
- 参数：
proj (str) - 投影算子的字符串格式。
样例：
>>> from mindquantum.core.operators import Projector >>> p = Projector('II010') >>> p I2 ⊗ ¦010⟩⟨010¦
- class mindquantum.core.operators.QubitExcitationOperator(term=None, coefficient=1.0)[源代码]
量子比特激发算子定义为： \(Q^{\dagger}_{n} = \frac{1}{2} (X_{n} - iY_{n})\) 和 \(Q_{n} = \frac{1}{2} (X_{n} + iY_{n})\) 。 与费米子激发算子相比，量子比特激发算子是某种“局部化”的，即费米子激发算子 \(a^{\dagger}_{7} a_{0}\) 涉及到JW变换下从0到7的量子比特， 而量子比特激发 \(Q^{\dagger}_{7} Q_{0}\) 只会影响第0和第7个量子比特。 此外，用量子比特激发算子描述双激发所使用的CNOT门比相应的费米子激发算子少得多。
- 参数：
terms (Union[str, tuple]) - 量子比特激发算子的输入项。默认值：None。
coefficient (Union[numbers.Number, str, ParameterResolver]) - 相应单个运算符的系数。默认值：1.0。
样例：
>>> from mindquantum.algorithm.nisq import Transform >>> from mindquantum.core.operators import QubitExcitationOperator >>> op = QubitExcitationOperator(((4, 1), (1, 0), (0, 0)), 2.5) >>> op 5/2 [Q4^ Q1 Q0] >>> op.fermion_operator 5/2 [4^ 1 0] >>> op.to_qubit_operator() 5/16 [X0 X1 X4] + (-0.3125j) [X0 X1 Y4] + (5/16j) [X0 Y1 X4] + 5/16 [X0 Y1 Y4] + (5/16j) [Y0 X1 X4] + 5/16 [Y0 X1 Y4] + -0.3125 [Y0 Y1 X4] + (5/16j) [Y0 Y1 Y4] >>> Transform(op.fermion_operator).jordan_wigner() 5/16 [X0 X1 Z2 Z3 X4] + (-0.3125j) [X0 X1 Z2 Z3 Y4] + (5/16j) [X0 Y1 Z2 Z3 X4] + 5/16 [X0 Y1 Z2 Z3 Y4] + (5/16j) [Y0 X1 Z2 Z3 X4] + 5/16 [Y0 X1 Z2 Z3 Y4] + -0.3125 [Y0 Y1 Z2 Z3 X4] + (5/16j) [Y0 Y1 Z2 Z3 Y4]
- property imag
该算符的虚部。
- 返回：
QubitExcitationOperator，保留原始算符虚部的量子比特激发算符。
样例：
>>> from mindquantum.core.operators import QubitExcitationOperator >>> f = QubitExcitationOperator(((1, 0),), 1 + 2j) >>> f += QubitExcitationOperator(((1, 1),), 'a') >>> f.imag.compress() 2 [Q1]
- normal_ordered()[源代码]
按照比特序号由小到大排列量子比特激发算符。
说明
与费米子不同，玻色子交换不需要乘系数-1。
- 返回：
QubitExcitationOperator，正规排序后的量子比特激发算符。
样例：
>>> from mindquantum.core.operators import QubitExcitationOperator >>> op = QubitExcitationOperator("7 1^") >>> op 1 [Q7 Q1^] >>> op.normal_ordered() 1 [Q1^ Q7]
- property real
该算符的实部。
- 返回：
QubitExcitationOperator，保留原始算符实部的量子比特激发算符。
样例：
>>> from mindquantum.core.operators import QubitExcitationOperator >>> f = QubitExcitationOperator(((1, 0),), 1 + 2j) >>> f += QubitExcitationOperator(((1, 1),), 'a') >>> f.real.compress() 1 [Q1] + a [Q1^]
- class mindquantum.core.operators.QubitOperator(term=None, coefficient=1.0)[源代码]
作用于量子比特的项的总和，例如 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 (str) - 量子比特运算符的输入项。默认值：None。
coefficient (Union[numbers.Number, str, ParameterResolver]) - 此量子比特运算符的系数，可以是由字符串、符号或参数解析器表示的数字或变量。默认值：1.0。
样例：
>>> 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 [X0 Y3] >>> ham3 = QubitOperator('') >>> ham3 1 [] >>> ham_para = QubitOperator('X0 Y3', 'x') >>> ham_para x [X0 Y3] >>> ham_para.subs({'x':1.2}) 6/5 [X0 Y3]
- count_gates()[源代码]
返回单哈密顿量处理时的门数量。
- 返回：
int，单量子门的数量。
样例：
>>> from mindquantum.core.operators import QubitOperator >>> a = QubitOperator("X0 Y1") + QubitOperator("X2 Z3") >>> a.count_gates() 4
- dumps(indent: int = 4)[源代码]
将QubitOperator转储到JSON（JavaScript对象表示法）。
- 参数：
indent (int) - JSON数组元素和对象成员打印时的缩进。默认值：4。
- 返回：
JSON(strings)，QubitOperator的JSON字符串。
样例：
>>> from mindquantum.core.operators import QubitOperator >>> ops = QubitOperator('X0 Y1', 1.2) + QubitOperator('Z0 X1', {'a': 2.1}) >>> len(ops.dumps()) 448
- static from_openfermion(of_ops, dtype=None)[源代码]
将openfermion格式的量子比特算符转换为mindquantum格式。
- 参数：
of_ops (openfermion.QubitOperator) - openfermion框架中的量子比特算符。
dtype (type) - 要生成的TermsOperator的类型（即实数“float”或复数“complex”）。 注意：此参数在 Python 版本的 QubitOperator 中被忽略。
- 返回：
QubitOperator，mindquantum框架中的量子比特算符。
- property imag
获得系数的虚部。
- 返回：
QubitOperator，此量子算符的虚部。
样例：
>>> from mindquantum.core.operators import QubitOperator >>> f = QubitOperator('X0', 1 + 2j) + QubitOperator('Y0', 'a') >>> f.imag.compress() 2 [X0]
- static loads(strs: str, dtype: type)[源代码]
将JSON（JavaScript对象表示法）加载到QubitOperator中。
- 参数：
strs (str) - 转储的量子比特算符字符串。
dtype (type) - （被此类忽略）要创建的 QubitOperator 的类型（即real，complex，real_pr，complex_pr）。
- 返回：
FermionOperator，从字符串加载的QubitOperator。
样例：
>>> from mindquantum.core.operators import QubitOperator >>> ops = QubitOperator('X0 Y1', 1.2) + QubitOperator('Z0 X1', {'a': 2.1}) >>> obj = QubitOperator.loads(ops.dumps()) >>> obj == ops True
- matrix(n_qubits: int = None)[源代码]
将此量子比特算符转换为csr_matrix。
- 参数：
n_qubits (int) - 结果矩阵的量子比特数目。如果是None，则该值将是最大局域量子比特数。默认值：None。
- property real
获得系数的实部。
- 返回：
QubitOperator，这个量子比特算符的实部。
样例：
>>> from mindquantum.core.operators import QubitOperator >>> f = QubitOperator('X0', 1 + 2j) + QubitOperator('Y0', 'a') >>> f.real.compress() 1 [X0] + a [Y0]
- class mindquantum.core.operators.TimeEvolution(ops: QubitOperator, time=None)[源代码]
可以生成对应线路的时间演化算子。
时间演化算子将执行以下演化：
\[\left|\varphi(t)\right> = e^{-iHt}\left|\varphi(0)\right>\]说明
哈密顿量应该是参数化或非参数化 QubitOperator。 如果 QubitOperator 有多项，则将使用一阶Trotter分解。
- 参数：
ops (QubitOperator) - 量子算子哈密顿量，可以参数化，也可以非参数化。
time (Union[numbers.Number, dict, ParameterResolver]) - 演化时间，可以是数字或参数解析器。如果是None，时间将设置为1。默认值：None。
样例：
>>> from mindquantum.core.operators import TimeEvolution, QubitOperator >>> q1 = QubitOperator('Z0 Y1', 'a') >>> q2 = QubitOperator('X0 Z1', 'b') >>> ops1 = q1 + q2 >>> ops2 = q2 + q1 >>> TimeEvolution(ops1).circuit q0: ─────────────●───────────────●───────H────────●───────────────●────H── │ │ │ │ q1: ──RX(π/2)────X────RZ(2*a)────X────RX(7π/2)────X────RZ(2*b)────X─────── >>> TimeEvolution(ops2).circuit q0: ──H────●───────────────●───────H───────●───────────────●────────────── │ │ │ │ q1: ───────X────RZ(2*b)────X────RX(π/2)────X────RZ(2*a)────X────RX(7π/2)──
- property circuit
返回时间演化算符的一阶Trotter分解线路。
- mindquantum.core.operators.commutator(left_operator, right_operator)[源代码]
计算两个算子的对易。
- 参数：
left_operator (Union[FermionOperator, QubitOperator, QubitExcitationOperator]) - 第一个算子，类型是 FermionOperator 或者 QubitOperator。
right_operator (Union[FermionOperator, QubitOperator, QubitExcitationOperator]) - 第二个算子，类型是 FermionOperator 或者 QubitOperator。
- 异常：
TypeError - left_operator 和 right_operator 不是相同的类型。
样例：
>>> from mindquantum.core.operators import QubitOperator, FermionOperator, commutator >>> qub_op1 = QubitOperator("X1 Y2") >>> qub_op2 = QubitOperator("X1 Z2") >>> commutator(qub_op1, qub_op1) 0 >>> commutator(qub_op1, qub_op2) (2j) [X2]
- mindquantum.core.operators.count_qubits(operator)[源代码]
计算未使用的量子比特被删除之前的量子比特数目。
说明
在某些情况下，我们需要删除未使用的索引。
- 参数：
operator (Union[FermionOperator, QubitOperator, QubitExcitationOperator]) - operator 算子类型为FermionOperator、QubitOperator或QubitExcitationOperator。
- 返回：
int，运算符作用的最小量子比特数。
- 异常：
TypeError - 类型无效的运算符。
样例：
>>> from mindquantum.core.operators import QubitOperator,FermionOperator, count_qubits >>> qubit_op = QubitOperator("X1 Y2") >>> count_qubits(qubit_op) 3 >>> fer_op = FermionOperator("1^") >>> count_qubits(fer_op) 2
- mindquantum.core.operators.down_index(index)[源代码]
索引顺序，默认情况下，我们将无自旋轨道设置为偶数-奇数-偶数-奇数（0,1,2,3,…）。自旋向下的轨道（β轨道）索引是奇数。
- 参数：
index (int) - 空间轨道索引。
- 返回：
int，关联的自旋向下的轨道索引序号。
样例：
>>> from mindquantum.core.operators import down_index >>> down_index(1) 3
- mindquantum.core.operators.hermitian_conjugated(operator)[源代码]
返回FermionOperator或QubitOperator的厄米共轭。
- 参数：
operator (Union[FermionOperator, QubitOperator, QubitExcitationOperator]) - 输入的算子。
- 返回：
operator(Union[FermionOperator, QubitOperator, QubitExcitationOperator])， 输入算子的厄米共轭。
样例：
>>> from mindquantum.core.operators import QubitOperator, hermitian_conjugated >>> q = QubitOperator('X0', {'a' : 2j}) >>> hermitian_conjugated(q) (-2j)*a [X0]
- mindquantum.core.operators.normal_ordered(fermion_operator)[源代码]
计算并返回FermionOperator的规范顺序。 根据惯例，规范顺序意味着项从最高模式索引（左侧）到最低（右侧）排序。 此外，创建运算符首先出现，然后跟随湮灭运算符。 例如 ‘3 4^’ \(\rightarrow\) ‘- 4^ 3’ 。
- 参数：
fermion_operator (FermionOperator) - 此参数只能为费米子类型运算符。
- 返回：
FermionOperator, 规范有序的FermionOperator。
样例：
>>> from mindquantum.core.operators import FermionOperator, normal_ordered >>> op = FermionOperator("3 4^", 'a') >>> normal_ordered(op) -a [4^ 3]
- mindquantum.core.operators.number_operator(n_modes=None, mode=None, coefficient=1.0)[源代码]
返回 reverse_jordan_wigner 变换的费米数运算符。
- 参数：
n_modes (int) - 系统中模式的数量。默认值：None。
mode (int, optional) - 返回数运算符的模式。如果是None，则返回所有点上的总数运算符。默认值：None。
coefficient (float) - 项的系数。默认值：1.0。
- 返回：
FermionOperator，reverse_jordan_wigner变换的费米数运算符。
样例：
>>> from mindquantum.core.operators import FermionOperator, number_operator >>> n_mode = 3 >>> number_operator(n_mode) 1 [0^ 0] + 1 [1^ 1] + 1 [2^ 2] >>> mode = 3 >>> number_operator(None, mode) 1 [3^ 3]
- mindquantum.core.operators.sz_operator(n_spatial_orbitals)[源代码]
返回sz运算符。
说明
默认索引顺序自旋向上（α）对应于偶数索引，而自旋向下（β）对应于奇数索引。
- 参数：
n_spatial_orbitals (int) - 空间轨道数（ n_qubits // 2 ）。
- 返回：
FermionOperator ，对应于 n_spatial_orbitals 轨道上的sz运算符。
样例：
>>> from mindquantum.core.operators import sz_operator >>> sz_operator(3) 1/2 [0^ 0] + -1/2 [1^ 1] + 1/2 [2^ 2] + -1/2 [3^ 3] + 1/2 [4^ 4] + -1/2 [5^ 5]