mindquantum.simulator

模拟量子系统演化的量子模拟器。

class mindquantum.simulator.GradOpsWrapper(grad_ops, hams, circ_right, circ_left, encoder_params_name, ansatz_params_name, parallel_worker)[源代码]

用生成梯度算子的信息包装梯度算子。

参数：

grad_ops (Union[FunctionType, MethodType]) - 返回前向值和线路参数梯度的函数或方法。
hams (Hamiltonian) - 生成这个梯度算子的hamiltonian。
circ_right (Circuit) - 生成这个梯度算子的右电路。
circ_left (Circuit) - 生成这个梯度算子的左电路。
encoder_params_name (list[str]) - encoder参数名称。
ansatz_params_name (list[str]) - ansatz参数名称。
parallel_worker (int) - 运行批处理的并行工作器数量。

set_str(grad_str)[源代码]

设置梯度算子的表达式。

参数：

grad_str (str) - QNN运算符的字符串。

class mindquantum.simulator.Simulator(backend, n_qubits, seed=None)[源代码]

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

参数：

backend (str) - 想要的后端。通过调用 get_supported_simulator() 可以返回支持的后端。
n_qubits (int) - 量子模拟器的量子比特数量。
seed (int) - 模拟器的随机种子，如果为None，种子将由 numpy.random.randint 生成。默认值：None。

异常：

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('projectq', 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('projectq', 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
projectq 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('projectq', 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应用到模拟器上，这个hamiltonian可以是hermitian或non hermitian。

Note

应用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('projectq', 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])

copy()[源代码]

复制模拟器。

返回：

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

样例：

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

flush()[源代码]

适用于projectq模拟器的flush门。 projectq模拟器将缓存一些门并将这些门融合到一个更大的门中，然后作用在量子态上。 flush命令使模拟器刷新当前存储的门并作用在量子态上。

样例：

>>> from mindquantum.core.gates import H
>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('projectq', 1)
>>> sim.apply_gate(H.on(0))
>>> sim.flush()

get_expectation(hamiltonian)[源代码]

得到给定hamiltonian的期望。hamiltonian可能是非厄米共轭的。

\[E = \left<\psi\right|H\left|\psi\right>\]

参数：

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

返回：

numbers.Number，期望值。

样例：

>>> from mindquantum.core.circuit import Circuit
>>> from mindquantum.core.operators import QubitOperator, Hamiltonian
>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('projectq', 1)
>>> sim.apply_circuit(Circuit().ry(1.2, 0))
>>> ham = Hamiltonian(QubitOperator('Z0'))
>>> sim.get_expectation(ham)
(0.36235775447667357+0j)

get_expectation_with_grad(hams, circ_right, circ_left=None, simulator_left=None, encoder_params_name=None, ansatz_params_name=None, parallel_worker=None)[源代码]

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

\[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 (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。
encoder_params_name (list[str]) - 指定哪些参数属于encoder，被编码成量子态。encoder数据可以是一个batch。默认值：None。
ansatz_params_name (list[str]) - 指定哪些参数属于ansatz，在训练期间被训练。默认值：None。
parallel_worker (int) - 并行器数目。并行器可以在并行线程中处理batch。默认值：None。

返回：

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('projectq', 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('projectq', 1)
>>> prep_circ = Circuit().h(0)
>>> ansatz = Circuit().ry('a', 0).rz('b', 0).ry('c', 0)
>>> sim1.apply_circuit(prep_circ)
>>> sim2 = Simulator('projectq', 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_qs(ket=False)[源代码]

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

参数：

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

返回：

numpy.ndarray，当前量子态。

样例：

>>> from mindquantum.algorithm.library import qft
>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('projectq', 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])

reset()[源代码]

将模拟器重置为0态。

样例：

>>> from mindquantum.algorithm.library import qft
>>> from mindquantum.simulator import Simulator
>>> sim = Simulator('projectq', 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)[源代码]

在线路中对测量比特进行采样。采样不会改变模拟器的量子态。

参数：

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('projectq', 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('projectq', 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])

mindquantum.simulator.get_supported_simulator()[源代码]

获取MindQuantum支持的模拟器名称。

返回：

list，支持的模拟器列表。

mindquantum.simulator.inner_product(bra_simulator: Simulator, ket_simulator: Simulator)[源代码]

计算给定模拟器中两种状态的内积。

参数：

bra_simulator (Simulator) - 提供bra态的模拟器。
ket_simulator (Simulator) - 提供ket态的模拟器。

返回：

numbers.Number，两个量子态的内积。

样例：

>>> from mindquantum.core.gates import RX, RY
>>> from mindquantum.simulator import inner_product, Simulator
>>> bra_simulator = Simulator('projectq', 1)
>>> bra_simulator.apply_gate(RY(1.2).on(0))
>>> ket_simulator = Simulator('projectq', 1)
>>> ket_simulator.apply_gate(RX(2.3).on(0))
>>> inner_product(bra_simulator, ket_simulator)
(0.33713923320500694-0.5153852888544989j)