mindquantum.simulator.Simulator

查看源文件
class mindquantum.simulator.Simulator(backend, n_qubits=None, seed=None, dtype=None, *args, **kwargs)[源代码]

模拟量子线路的量子模拟器。

参数：

  • backend (str) - 想要的后端。通过调用 get_supported_simulator() 可以返回支持的后端。

  • n_qubits (int) - 量子模拟器的量子比特数量。默认值： None。

  • seed (int) - 模拟器的随机种子，如果为 None，种子将由 numpy.random.randint 生成。默认值： None。

  • dtype (mindquantum.dtype) - 模拟器的数据类型。

异常：

  • TypeError - 如果 backend 不是str。

  • TypeError - 如果 n_qubits 不是int。

  • TypeError - 如果 seed 不是int。

  • ValueError - 如果不支持 backend 。

  • ValueError - 如果 n_qubits 为负数。

  • ValueError - 如果 seed 小于0或大于 \(2^23 - 1\) 。

样例：

>>> from mindquantum.algorithm.library import qft
>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqvector', 2)
>>> sim.apply_circuit(qft(range(2)))
>>> sim.get_qs()
array([0.5+0.j, 0.5+0.j, 0.5+0.j, 0.5+0.j])
apply_circuit(circuit, pr=None)[源代码]

在模拟器上应用量子线路。

参数：

  • circuit (Circuit) - 要应用在模拟器上的量子线路。

  • pr (Union[ParameterResolver, dict, numpy.ndarray, list, numbers.Number]) - 线路的ParameterResolver。如果线路不含参数，则此参数应为None。默认值： None。

返回：

MeasureResult或None，如果线路具有测量门，则返回MeasureResult，否则返回None。

样例：

>>> import numpy as np
>>> from mindquantum.core.circuit import Circuit
>>> from mindquantum.core.gates import H
>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqvector', 2)
>>> sim.apply_circuit(Circuit().un(H, 2))
>>> sim.apply_circuit(Circuit().ry('a', 0).ry('b', 1), np.array([1.1, 2.2]))
>>> sim
mqvector simulator with 2 qubits  (little endian).
Current quantum state:
-0.0721702531972066¦00⟩
-0.30090405886869676¦01⟩
0.22178317006196263¦10⟩
0.9246947752567126¦11⟩
>>> sim.apply_circuit(Circuit().measure(0).measure(1))
shots: 1
Keys: q1 q0│0.00     0.2         0.4         0.6         0.8         1.0
───────────┼───────────┴───────────┴───────────┴───────────┴───────────┴
         11│▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
           │
{'11': 1}
apply_gate(gate, pr=None, diff=False)[源代码]

在此模拟器上应用门，可以是量子门或测量算子。

参数：

  • gate (BasicGate) - 要应用的门。

  • pr (Union[numbers.Number, numpy.ndarray, ParameterResolver, list]) - 含参门的参数。默认值： None。

  • diff (bool) - 是否在模拟器上应用导数门。默认值： False。

返回：

int或None，如果是该门是测量门，则返回坍缩态，否则返回None。

异常：

  • TypeError - 如果 gate 不是BasicGate。

  • ValueError - 如果 gate 的某个量子比特大于模拟器本身的量子比特。

  • ValueError - 如果 gate 是含参的，但没有提供参数。

  • TypeError - 如果 gate 是含参的，但 pr 不是ParameterResolver。

样例：

>>> import numpy as np
>>> from mindquantum.core.gates import RY, Measure
>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqvector', 1)
>>> sim.apply_gate(RY('a').on(0), np.pi/2)
>>> sim.get_qs()
array([0.70710678+0.j, 0.70710678+0.j])
>>> sim.apply_gate(Measure().on(0))
1
>>> sim.get_qs()
array([0.+0.j, 1.+0.j])
apply_hamiltonian(hamiltonian)[源代码]

将hamiltonian应用到模拟器上，这个hamiltonian可以是hermitian或non hermitian。

说明

应用hamiltonian后，量子态可能不是归一化量子态。

参数：

  • hamiltonian (Hamiltonian) - 想应用的hamiltonian。

样例：

>>> from mindquantum.core.circuit import Circuit
>>> from mindquantum.core.operators import QubitOperator, Hamiltonian
>>> from mindquantum.simulator import Simulator
>>> import scipy.sparse as sp
>>> sim = Simulator('mqvector', 1)
>>> sim.apply_circuit(Circuit().h(0))
>>> sim.get_qs()
array([0.70710678+0.j, 0.70710678+0.j])
>>> ham1 = Hamiltonian(QubitOperator('Z0'))
>>> sim.apply_hamiltonian(ham1)
>>> sim.get_qs()
array([ 0.70710678+0.j, -0.70710678+0.j])
>>> sim.reset()
>>> ham2 = Hamiltonian(sp.csr_matrix([[1, 2], [3, 4]]))
>>> sim.apply_hamiltonian(ham2)
>>> sim.get_qs()
array([1.+0.j, 3.+0.j])
astype(dtype, seed=None)[源代码]

将模拟器转化给定的数据类型。

说明

量子模拟器中的状态将从原始模拟器中复制。

参数：

  • dtype (mindquantum.dtype) - 新模拟器的数据类型。

  • seed (int) - 新模拟器的随机数种子。默认值： None。

copy()[源代码]

复制模拟器。

返回：

模拟器，当前模拟器的副本。

样例：

>>> from mindquantum.core.gates import RX
>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqvector', 1)
>>> sim.apply_gate(RX(1).on(0))
>>> sim2 = sim.copy()
>>> sim2.apply_gate(RX(-1).on(0))
>>> sim2
mqvector simulator with 1 qubit (little endian).
Current quantum state:
1¦0⟩
property dtype

返回模拟器的数据类型。

entropy()[源代码]

计算当前量子态的冯诺伊曼熵。

冯诺伊曼熵 \(S\) 的定义如下。

\[S(\rho) = -\text{tr}(\rho \ln \rho)\]

其中 \(\rho\) 是密度矩阵。

返回：

numbers.Number，当前量子态的冯诺伊曼熵。

样例：

>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqmatrix', 1)
>>> sim.set_qs([[0.5, 0], [0, 0.5]])
>>> sim.entropy()
0.6931471805599453
get_expectation(hamiltonian, circ_right=None, circ_left=None, simulator_left=None, pr=None)[源代码]

得到给定hamiltonian的期望。hamiltonian可能是非厄米共轭的。该方法旨在计算期望值，如下所示：

\[E = \left<\varphi\right|U_l^\dagger H U_r \left|\psi\right>\]

其中 \(U_l\) 是circ_left，\(U_r\) 是circ_right，\(H\) 是hams，\(\left|\psi\right>\) 是模拟器当前的量子态，\(\left|\varphi\right>\) 是 simulator_left 的量子态。

说明

传入的线路仅参与期望值计算，不会改变模拟器当前的量子态。

参数：

  • hamiltonian (Hamiltonian) - 想得到期望的hamiltonian。

  • circ_right (Circuit) - 表示 \(U_r\) 的线路。如果为 None，则选择空线路。默认值： None。

  • circ_left (Circuit) - 表示 \(U_l\) 的线路。如果为 None，则将设置成 circ_right 一样的线路。默认值： None。

  • simulator_left (Simulator) - 包含 \(\left|\varphi\right>\) 的模拟器。如果无，则 \(\left|\varphi\right>\) 被假定等于 \(\left|\psi\right>\)。默认值： None。

  • pr (Union[Dict[str, numbers.Number], ParameterResolver]) - 线路中的参数。默认值： None.

返回：

numbers.Number，期望值。

样例：

>>> from mindquantum.core.circuit import Circuit
>>> from mindquantum.core.operators import QubitOperator, Hamiltonian
>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqvector', 1)
>>> sim.apply_circuit(Circuit().ry(1.2, 0))
>>> ham = Hamiltonian(QubitOperator('Z0'))
>>> sim.get_expectation(ham)
(0.36235775447667357+0j)
>>> sim.get_expectation(ham, Circuit().rx('a', 0), Circuit().ry(2.3, 0), pr={'a': 2.4})
(-0.25463350745693886+0.8507316752782879j)
>>> sim1, sim2 = Simulator('mqvector', 1), Simulator('mqvector', 1)
>>> sim1.apply_circuit(Circuit().ry(1.2, 0).rx(2.4, 0))
>>> sim2.apply_circuit(Circuit().ry(1.2, 0).ry(2.3, 0))
>>> sim1.apply_hamiltonian(ham)
>>> from mindquantum.simulator import inner_product
>>> inner_product(sim2, sim1)
(-0.25463350745693886+0.8507316752782879j)
get_expectation_with_grad(hams, circ_right, circ_left=None, simulator_left=None, parallel_worker=None, pr_shift=False)[源代码]

获取一个返回前向值和关于线路参数梯度的函数。该方法旨在计算期望值及其梯度，如下所示：

\[E = \left<\varphi\right|U_l^\dagger H U_r \left|\psi\right>\]

其中 \(U_l\) 是circ_left，\(U_r\) 是circ_right，\(H\) 是hams，\(\left|\psi\right>\) 是模拟器当前的量子态，\(\left|\varphi\right>\) 是 simulator_left 的量子态。

说明

传入的线路仅参与期望值和梯度的计算，不会改变模拟器当前的量子态。

参数：

  • hams (Union[Hamiltonian, List[Hamiltonian]]) - 需要计算期望的 Hamiltonian 或者一组 Hamiltonian。

  • circ_right (Circuit) - 上述 \(U_r\) 电路。

  • circ_left (Circuit) - 上述 \(U_l\) 电路，默认情况下，这个线路将为 None，在这种情况下， \(U_l\) 将等于 \(U_r\) 。默认值： None。

  • simulator_left (Simulator) - 包含 \(\left|\varphi\right>\) 的模拟器。如果无，则 \(\left|\varphi\right>\) 被假定等于 \(\left|\psi\right>\)。默认值： None。

  • parallel_worker (int) - 并行器数目。并行器可以在并行线程中处理batch。默认值： None。

  • pr_shift (bool) - 是否使用 parameter-shift rule。仅在mqvector模拟器中可用，当电路包含噪声信道时该参数将自动启用。请注意，并非所有门都适用于相同移位值 π/2，因此 FSim 门和自定义参数化门的梯度将通过有限差分法计算，差分值为 0.001。默认值： False。

返回：

GradOpsWrapper，一个包含生成梯度算子信息的梯度算子包装器。

样例：

>>> import numpy as np
>>> from mindquantum.core.circuit import Circuit
>>> from mindquantum.core.operators import QubitOperator, Hamiltonian
>>> from mindquantum.simulator import Simulator
>>> circ = Circuit().ry('a', 0)
>>> ham = Hamiltonian(QubitOperator('Z0'))
>>> sim = Simulator('mqvector', 1)
>>> grad_ops = sim.get_expectation_with_grad(ham, circ)
>>> grad_ops(np.array([1.0]))
(array([[0.54030231+0.j]]), array([[[-0.84147098+0.j]]]))
>>> sim1 = Simulator('mqvector', 1)
>>> prep_circ = Circuit().h(0)
>>> ansatz = Circuit().ry('a', 0).rz('b', 0).ry('c', 0)
>>> sim1.apply_circuit(prep_circ)
>>> sim2 = Simulator('mqvector', 1)
>>> ham = Hamiltonian(QubitOperator(""))
>>> grad_ops = sim2.get_expectation_with_grad(ham, ansatz, Circuit(), simulator_left=sim1)
>>> f, g = grad_ops(np.array([7.902762e-01, 2.139225e-04, 7.795934e-01]))
>>> f
array([[0.99999989-7.52279618e-05j]])
get_partial_trace(qubits_to_trace)[源代码]

计算当前密度矩阵的偏迹。

参数：

  • qubits_to_trace (Union[int, list[int]]) - 对哪些量子比特（子系统）求偏迹。

返回：

numpy.ndarray，密度矩阵的偏迹。

样例：

>>> from mindquantum.core.circuit import Circuit
>>> from mindquantum.simulator import Simulator
>>> circ = Circuit().h(0).x(1, 0)
>>> sim = Simulator('mqmatrix', 2)
>>> sim.apply_circuit(circ)
>>> mat = sim.get_partial_trace(0)
>>> mat
array([[0.5-0.j, 0. -0.j],
       [0. +0.j, 0.5-0.j]])
get_pure_state_vector()[源代码]

若当前密度矩阵是纯态，则获得相应的态矢量。

密度矩阵 \(\rho\) 和态矢量 \(\left| \psi \right>\) 的关系如下。

\[\rho = \left| \psi \right>\!\left< \psi \right|\]

注意：态矢量 \(\left| \psi \right>\) 可能包含一个任意的全局相位 \(e^{i\phi}\)。

返回：

numpy.ndarray，由当前纯态密度矩阵计算出的态矢量。

样例：

>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqmatrix', 1)
>>> sim.set_qs([[0.5, 0.5], [0.5, 0.5]])
>>> sim.get_pure_state_vector()
array([0.70710678+0.j, 0.70710678+0.j])
get_qs(ket=False)[源代码]

获取模拟器的当前量子态。

对于态矢量模拟器，返回态矢量的量子态表示。对于密度矩阵模拟器，返回密度矩阵的量子态表示。

可选择返回以ket（狄拉克符号）形式表示的量子态。 对于密度矩阵模拟器，如果是混态，则会通过各个纯态的概率加权和来表示。

参数：

  • ket (bool) - 是否以ket格式返回量子态。默认值： False。

返回：

Union[numpy.ndarray, str]，当前量子态。 如果ket为True，返回ket格式的字符串表示。 对于态矢量模拟器，返回一维数组或态矢量的ket字符串。 对于密度矩阵模拟器，返回二维数组或密度矩阵的ket字符串。

样例：

>>> from mindquantum.algorithm.library import qft
>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqvector', 2)
>>> sim.apply_circuit(qft(range(2)))
>>> sim.get_qs()
array([0.5+0.j, 0.5+0.j, 0.5+0.j, 0.5+0.j])
get_qs_of_qubits(qubits, ket=False)[源代码]

获取当前模拟器中指定量子比特的约化量子态。

约化量子态是通过对其他量子比特进行偏迹运算得到的。如果得到的是纯态，返回态矢量，混态则返回密度矩阵。

可选择返回以ket（狄拉克符号）形式表示的约化量子态，如果是混态，则会通过各个纯态的概率加权和来表示。

说明

  • 输入量子比特的顺序不会影响返回结果。

  • 返回的量子态采用小端序（例如：在ket表示中，¦01⟩表示q1=0，q0=1）。

参数：

  • qubits (Union[int, List[int]]) - 想要观察的量子比特。可以是单个整数或整数列表。

  • ket (bool) - 是否以 ket 字符串格式返回量子态。默认值： False。

返回：

Union[numpy.ndarray, str]，如果 ket 为 True，返回量子态的字符串表示。如果 ket 为 False 且状态为纯态，返回态矢量的 numpy 数组。如果状态为混态，返回密度矩阵。

样例：

>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqvector', 2)
>>> sim.apply_circuit(Circuit().h(0).x(1,0))
>>> # Get state vector of qubit 0
>>> state_0 = sim.get_qs_of_qubits(0)
>>> state_0
array([[0.5+0.j, 0. +0.j],
      [0. +0.j, 0.5+0.j]])
>>> # Get ket string representation of qubit 1
>>> state_1 = sim.get_qs_of_qubits(1, ket=True)
>>> state_1
'1/2¦1⟩ + 1/2¦0⟩ (mixed state)'
get_reduced_density_matrix(kept_qubits)[源代码]

通过对其余量子比特执行偏迹运算，得到指定量子比特的约化密度矩阵。

说明

  • 输入量子比特的顺序不会影响返回结果。

  • 返回的密度矩阵采用小端序（例如：对于2量子比特系统，基态的顺序为 ¦00⟩, ¦01⟩, ¦10⟩, ¦11⟩，其中 ¦01⟩ 表示 q1=0, q0=1）。

参数：

  • kept_qubits (Union[int, List[int]]) - 想要获取约化密度矩阵的目标量子比特，可以指定单个量子比特或多个量子比特的列表。

返回：

numpy.ndarray，目标量子比特的约化密度矩阵。

样例：

>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqvector', 2)
>>> sim.apply_circuit(Circuit().h(0).x(1,0))
>>> # Get reduced density matrix of qubit 1
>>> rho_1 = sim.get_reduced_density_matrix([1])
>>> print(rho_1)
[[0.5+0.j 0.0+0.j]
 [0.0+0.j 0.5+0.j]]
property n_qubits

获取模拟器的量子比特数。

返回：

int，当前模拟器的量子比特数。

purity()[源代码]

计算当前量子态的纯度。

纯度 \(\gamma\) 的定义如下所示。

\[\gamma \equiv \text{tr}(\rho^2)\]

其中 \(\rho\) 是密度矩阵。

返回：

numbers.Number，当前量子态的纯度。

样例：

>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqmatrix', 1)
>>> sim.set_qs([[0.5, 0], [0, 0.5]])
>>> sim.purity()
0.5
reset()[源代码]

将模拟器重置为0态。

样例：

>>> from mindquantum.algorithm.library import qft
>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqvector', 2)
>>> sim.apply_circuit(qft(range(2)))
>>> sim.reset()
>>> sim.get_qs()
array([1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j])
sampling(circuit, pr=None, shots=1, seed=None)[源代码]

在线路中对测量比特进行采样。

说明

  • 传入的线路仅参与采样过程，不会改变模拟器当前的量子态。

  • 采样结果默认使用小端序表示（例如：'01'表示q1=0, q0=1）。如果需要大端序表示，可以使用 MeasureResult.reverse_endian() 方法。

参数：

  • circuit (Circuit) - 要进行演化和采样的电路。

  • pr (Union[None, dict, ParameterResolver]) - 线路的parameter resolver，如果线路是含参线路则需要提供pr。默认值： None。

  • shots (int) - 采样线路的次数。默认值： 1。

  • seed (int) - 采样的随机种子。如果为None，则种子将是随机的整数。默认值： None。

返回：

MeasureResult，采样的统计结果，结果中的比特串采用小端序表示。

样例：

>>> from mindquantum.core.circuit import Circuit
>>> from mindquantum.core.gates import Measure
>>> from mindquantum.simulator import Simulator
>>> circ = Circuit().ry('a', 0).ry('b', 1)
>>> circ += Measure('q0_0').on(0)
>>> circ += Measure('q0_1').on(0)
>>> circ += Measure('q1').on(1)
>>> sim = Simulator('mqvector', circ.n_qubits)
>>> res = sim.sampling(circ, {'a': 1.1, 'b': 2.2}, shots=100, seed=42)
>>> res
shots: 100
Keys: q1 q0_1 q0_0│0.00   0.122       0.245       0.367        0.49       0.612
──────────────────┼───────────┴───────────┴───────────┴───────────┴───────────┴
               000│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
                  │
               011│▒▒▒▒▒▒▒▒▒
                  │
               100│▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
                  │
               111│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
                  │
{'000': 18, '011': 9, '100': 49, '111': 24}
set_qs(quantum_state)[源代码]

设置模拟器的量子态。

参数：

  • quantum_state (numpy.ndarray) - 想设置的量子态。

样例：

>>> import numpy as np
>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('mqvector', 1)
>>> sim.get_qs()
array([1.+0.j, 0.+0.j])
>>> sim.set_qs(np.array([1, 1]))
>>> sim.get_qs()
array([0.70710678+0.j, 0.70710678+0.j])
set_threads_number(number)[源代码]

设置最大线程数。

参数：

  • number (int) - 设置模拟器中线程池所使用的线程数。