mindquantum.core.gates
量子门模块，提供不同的量子门。
functional
如下量子门是预实例化的量子门，可直接作为对应量子门的实例来使用。
functional |
gates |
|---|---|
mindquantum.core.gates.CNOT |
|
mindquantum.core.gates.I |
|
mindquantum.core.gates.ISWAP |
|
mindquantum.core.gates.H |
|
mindquantum.core.gates.S |
|
mindquantum.core.gates.SWAP |
|
mindquantum.core.gates.T |
|
mindquantum.core.gates.X |
|
mindquantum.core.gates.Y |
|
mindquantum.core.gates.Z |
Quantum Gates
- class mindquantum.core.gates.AmplitudeDampingChannel(gamma: float, **kwargs)[源代码]
用于表征量子计算中非相干噪声的信道。 振幅衰减信道表示的是量子比特由于能量耗散导致的错误。 振幅衰减信道通常可表示为：
\[ \begin{align}\begin{aligned}\epsilon(\rho) = E_0 \rho E_0^\dagger + E_1 \rho E_1^\dagger\\\begin{split}where\ {E_0}=\begin{bmatrix}1&0\\ 0&\sqrt{1-\gamma}\end{bmatrix}, \ {E_1}=\begin{bmatrix}0&\sqrt{\gamma}\\ 0&0\end{bmatrix}\end{split}\end{aligned}\end{align} \]这里 \(\rho\) 是密度矩阵形式的量子态； \(\gamma\) 是能量损耗系数。
- 参数：
gamma (int, float) - 振幅衰减系数。
样例：
>>> from mindquantum.core.gates import AmplitudeDampingChannel >>> from mindquantum.core.circuit import Circuit >>> circ = Circuit() >>> circ += AmplitudeDampingChannel(0.02).on(0) >>> circ += AmplitudeDampingChannel(0.01).on(1, 0) >>> print(circ) q0: ──AD(0.02)───────●────── │ q1: ──────────────AD(0.01)──
- class mindquantum.core.gates.BasicGate(name, n_qubits, obj_qubits=None, ctrl_qubits=None)[源代码]
BasicGate是所有门的基类。
- 参数：
name (str) - 此门的名称。
n_qubits (int) - 这个门有多少个量子比特。
obj_qubits (int, list[int]) - 具体门作用在哪个量子比特上。
ctrl_qubits (int, list[int]) - 指定控制量子比特。默认：None。
- property acted
检查此门是否已经作用在量子比特上。
- on(obj_qubits, ctrl_qubits=None)[源代码]
定义门作用于哪个量子比特和控制量子比特。
说明
在此框架中，首先指定门作用的量子比特，即使对于控制门，例如CNOT，第二个参数是控制量子比特。
- 参数：
obj_qubits (int, list[int]) - 指定门作用在哪个量子比特上。
ctrl_qubits (int, list[int]) - 指定控制量子比特。默认：None。
- 返回：
返回一个新的门。
样例：
>>> from mindquantum.core.gates import X >>> x = X.on(1) >>> x.obj_qubits [1] >>> x.ctrl_qubits [] >>> x = X.on(2, [0, 1]) >>> x.ctrl_qubits [0, 1]
- property parameterized
检查此门是否为参数化门。
- class mindquantum.core.gates.BitFlipChannel(p: float, **kwargs)[源代码]
量子信道可以描述量子计算中的非相干噪声。
比特翻转信道描述的噪声体现为：以 \(P\) 的概率翻转量子比特（作用 \(X\) 门），或以 \(1-P\) 的概率保持不变（作用 \(I\) 门）。
比特翻转信道的数学表示如下：
\[\epsilon(\rho) = (1 - P)\rho + P X \rho X\]其中 \(\rho\) 是密度矩阵形式的量子态； \(P\) 是作用额外 \(X\) 门的概率。
- 参数：
p (int, float) - 发生错误的概率。
样例：
>>> from mindquantum.core.gates import BitFlipChannel >>> from mindquantum.core.circuit import Circuit >>> circ = Circuit() >>> circ += BitFlipChannel(0.02).on(0) >>> circ += BitFlipChannel(0.01).on(1, 0) >>> print(circ) q0: ──BF(0.02)───────●────── │ q1: ──────────────BF(0.01)──
- class mindquantum.core.gates.BitPhaseFlipChannel(p: float, **kwargs)[源代码]
量子信道可以描述量子计算中的非相干噪声。
比特相位翻转信道描述的噪声体现为：以 \(P\) 的概率翻转比特的量子态和相位（作用 \(Y\) 门），或以 \(1-P\) 的概率保持不变（作用 \(I\) 门）。
比特相位翻转通道的数学表示如下：
\[\epsilon(\rho) = (1 - P)\rho + P Y \rho Y\]其中， \(\rho\) 是密度矩阵形式的量子态； \(P\) 是作用额外 \(Y\) 门的概率。
- 参数：
p (int, float) - 发生错误的概率。
样例：
>>> from mindquantum.core.gates import BitPhaseFlipChannel >>> from mindquantum.core.circuit import Circuit >>> circ = Circuit() >>> circ += BitPhaseFlipChannel(0.02).on(0) >>> circ += BitPhaseFlipChannel(0.01).on(1, 0) >>> print(circ) q0: ──BPF(0.02)────────●────── │ q1: ───────────────BPF(0.01)──
- class mindquantum.core.gates.CNOTGate[源代码]
控制X门。
更多用法，请参见
mindquantum.core.gates.XGate。
- class mindquantum.core.gates.DepolarizingChannel(p: float, **kwargs)[源代码]
量子信道可以描述量子计算中的非相干噪声。
去极化通道描述的噪声体现为：以 \(P\) 的概率将量子态转变为最大混态（随机作用泡利门（X,Y,Z）的其中一个，每个泡利门的概率都是 \(P/3\) ），或以 \(1-P\) 的概率保持不变（作用I门）。
去极化信道的数学表示如下：
\[\epsilon(\rho) = (1 - P)\rho + P/3( X \rho X + Y \rho Y + Z \rho Z)\]其中，\(\rho\) 是密度矩阵形式的量子态；\(P\) 是发生去极化错误的概率。
- 参数：
p (int, float) - 发生错误的概率。
样例：
>>> from mindquantum.core.gates import DepolarizingChannel >>> from mindquantum.core.circuit import Circuit >>> circ = Circuit() >>> circ += DepolarizingChannel(0.02).on(0) >>> circ += DepolarizingChannel(0.01).on(1, 0) >>> print(circ) q0: ──Dep(0.02)────────●────── │ q1: ───────────────Dep(0.01)──
- class mindquantum.core.gates.FSim(theta: ParameterResolver, phi: ParameterResolver)[源代码]
FSim 门表示费米子模拟门。FSim 门的矩阵形式为：
\[\begin{split}{\rm FSim}(\theta, \phi)=\begin{pmatrix}1&0&0&0\\0&\cos(\theta)&-i\sin(\theta)&0\\ 0&-i\sin(\theta)&\cos(\theta)&0\\0&0&0&e^{i\phi}\end{pmatrix}\end{split}\]- 参数：
theta (Union[numbers.Number, dict, ParameterResolver]) - FSim 门的第一个参数。
phi (Union[numbers.Number, dict, ParameterResolver]) - FSim 门的第二个参数。
样例：
>>> from mindquantum.core.gates import FSim >>> fsim = FSim('a', 'b').on([0, 1]) >>> fsim FSim(𝜃=a, 𝜑=b|0 1)
- hermitian()[源代码]
获取 FSim 门的厄米共轭形式。
样例：
>>> from mindquantum.core.gates import FSim >>> fsim = FSim('a', 'b').on([0, 1]) >>> fsim.hermitian() FSim(𝜃=-a, 𝜑=-b|0 1)
- matrix(pr: ParameterResolver = None)[源代码]
获取 FSim 门的矩阵形式。
- 参数：
pr (Union[ParameterResolver, dict]) - FSim 门的参数。默认值：None。
- phi()
获取 FSim 门的参数 phi。
- 返回：
ParameterResolver，参数 phi。
- theta()
获取 FSim 门的参数 theta。
- 返回：
ParameterResolver，参数 theta。
- class mindquantum.core.gates.GlobalPhase(pr)[源代码]
全局相位门。更多用法，请参见
mindquantum.core.gates.RX.\[\begin{split}{\rm GlobalPhase}=\begin{pmatrix}\exp(-i\theta)&0\\ 0&\exp(-i\theta)\end{pmatrix}\end{split}\]- 参数：
pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。
- class mindquantum.core.gates.HGate[源代码]
Hadamard门，矩阵为：
\[\begin{split}{\rm H}=\frac{1}{\sqrt{2}}\begin{pmatrix}1&1\\1&-1\end{pmatrix}\end{split}\]更多用法，请参见
mindquantum.core.gates.XGate。
- class mindquantum.core.gates.IGate[源代码]
Identity门，矩阵为：
\[\begin{split}{\rm I}=\begin{pmatrix}1&0\\0&1\end{pmatrix}\end{split}\]更多用法，请参见
mindquantum.core.gates.XGate。
- class mindquantum.core.gates.ISWAPGate[源代码]
ISWAP门会交换两个不同的量子比特并且为 \(\left|01\right>\) 和 \(\left|10\right>\) 的振幅增加相位 \(i\)。
更多用法，请参见
mindquantum.core.gates.XGate。
- class mindquantum.core.gates.KrausChannel(name: str, kraus_op, **kwargs)[源代码]
用于表征量子计算中非相干噪声的量子信道。
Kraus 信道接受两个或多个 2x2 矩阵作为 Kraus 算子，以在量子电路中构造自定义（单量子比特）噪声。
Kraus 信道以如下形式作用噪声：
\[\epsilon(\rho) = \sum_{k=0}^{m-1} E_k \rho E_k^\dagger\]其中 \(\rho\) 是密度矩阵形式的量子态；\(E_k\) 是Kraus算符， 并且它需要满足完备性条件：\(\sum_k E_k^\dagger E_k = I\)。
- 参数：
name (str) - 该自定义噪声信道的名称。
kraus_op (list, np.ndarray) - Kraus 算符，由两个或多个 2x2 矩阵打包成的列表构成。
样例：
>>> from mindquantum.core.gates import KrausChannel >>> from mindquantum.core.circuit import Circuit >>> from cmath import sqrt >>> gamma = 0.5 >>> kmat0 = [[1, 0], [0, sqrt(1 - gamma)]] >>> kmat1 = [[0, sqrt(gamma)], [0, 0]] >>> amplitude_damping = KrausChannel('damping', [kmat0, kmat1]) >>> circ = Circuit() >>> circ += amplitude_damping.on(0) >>> circ += amplitude_damping.on(1, 0) >>> print(circ) q0: ──damping───────●───── │ q1: ─────────────damping──
- class mindquantum.core.gates.Measure(name='')[源代码]
测量量子比特的测量门。
- 参数：
name (str) - 此测量门的键。在量子线路中，不同测量门的键应该是唯一的。默认值：
''。
样例：
>>> import numpy as np >>> from mindquantum.algorithm.library import qft >>> from mindquantum.core.circuit import Circuit >>> from mindquantum.core.gates import Measure >>> from mindquantum.simulator import Simulator >>> circ = qft(range(2)) >>> circ += Measure('q0').on(0) >>> circ += Measure().on(1) >>> circ q0: ──H────PS(π/2)─────────@────M(q0)── │ │ q1: ──────────●───────H────@────M(q1)── >>> sim = Simulator('mqvector', circ.n_qubits) >>> sim.apply_circuit(Circuit().h(0).x(1, 0)) >>> sim mqvector simulator with 2 qubits (little endian). Current quantum state: √2/2¦00⟩ √2/2¦11⟩ >>> res = sim.sampling(circ, shots=2000, seed=42) >>> res shots: 2000 Keys: q1 q0│0.00 0.124 0.248 0.372 0.496 0.621 ───────────┼───────────┴───────────┴───────────┴───────────┴───────────┴ 00│▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ │ 10│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ │ 11│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ │ {'00': 993, '10': 506, '11': 501} >>> sim mqvector simulator with 2 qubits (little endian). Current quantum state: √2/2¦00⟩ √2/2¦11⟩ >>> sim.apply_circuit(circ[:-2]) >>> sim mqvector simulator with 2 qubits (little endian). Current quantum state: √2/2¦00⟩ (√2/4-√2/4j)¦10⟩ (√2/4+√2/4j)¦11⟩ >>> np.abs(sim.get_qs())**2 array([0.5 , 0. , 0.25, 0.25])
- class mindquantum.core.gates.MeasureResult[源代码]
测量结果容器。
样例：
>>> from mindquantum.algorithm.library import qft >>> from mindquantum.simulator import Simulator >>> sim = Simulator('mqvector', 2) >>> res = sim.sampling(qft(range(2)).measure_all(), shots=1000, seed=42) >>> res shots: 1000 Keys: q1 q0│0.00 0.065 0.13 0.194 0.259 0.324 ───────────┼───────────┴───────────┴───────────┴───────────┴───────────┴ 00│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ │ 01│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ │ 10│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ │ 11│▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ │ {'00': 230, '01': 254, '10': 257, '11': 259} >>> res.data {'00': 230, '01': 254, '10': 257, '11': 259}
- add_measure(measure)[源代码]
在此测量结果容器中添加测量门。测量键在此测量结果容器中应是唯一的。
- 参数：
measure (Union[Iterable, Measure]) - 一个或多个测量门。
- collect_data(samples)[源代码]
收集所有测量门测量出的比特串。
- 参数：
samples (numpy.ndarray) - 一个二维(N x M) numpy数组，以0或1存储采样位字符串，其中N表示拍摄次数，M表示此测量容器中的键数。
- property data
获取采样数据。
- 返回：
dict，采样数据。
- property keys_map
返回测量门名词与出现顺序的关系的字典。
- select_keys(*keys)[源代码]
从该测量容器中选择某些测量键。
- 参数：
keys (tuple[str]) - 要选择的键。
样例：
>>> from mindquantum.algorithm.library import qft >>> from mindquantum.core.gates import H >>> from mindquantum.simulator import Simulator >>> circ = qft(range(2)).measure('q0_0', 0).measure('q1_0', 1) >>> circ.h(0).measure('q0_1', 0) >>> circ q0: ──H────PS(π/2)─────────@────M(q0_0)────H────M(q0_1)── │ │ q1: ──────────●───────H────@────M(q1_0)────────────────── >>> sim = Simulator('mqvector', circ.n_qubits) >>> res = sim.sampling(circ, shots=500, seed=42) >>> new_res = res.select_keys('q0_1', 'q1_0') >>> new_res shots: 500 Keys: q1_0 q0_1│0.00 0.068 0.136 0.204 0.272 0.34 ───────────────┼───────────┴───────────┴───────────┴───────────┴───────────┴ 00│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ │ 01│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ │ 10│▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ │ 11│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ │ {'00': 127, '01': 107, '10': 136, '11': 130}
![[源代码]](_modules/mindquantum/core/gates/measurement.html#MeasureResult.svg){kind=link}
- class mindquantum.core.gates.ParameterGate(pr: ParameterResolver, name, n_qubits, *args, obj_qubits=None, ctrl_qubits=None, **kwargs)[源代码]
参数化的门。
- 参数：
pr (ParameterResolver) - 参数化量子门的参数。
name (str) - 参数化量子门的名字。
n_qubits (int) - 参数化量子门的比特数。
args (list) - 量子门的其他参数。
obj_qubits (Union[int, List[int]]) - 量子门作用在哪些比特上。默认值： None 。
ctrl_qubits (Union[int, List[int]]) - 量子门受哪些量子比特控制。默认值： None 。
kwargs (dict) - 量子门的其他参数。
- class mindquantum.core.gates.PauliChannel(px: float, py: float, pz: float, **kwargs)[源代码]
量子信道可以描述量子计算中的非相干噪声。
泡利信道描述的噪声体现为：在量子比特上随机作用一个额外的泡利门，作用 \(X\) 、 \(Y\) 和 \(Z\) 门对应概率分别为 \(P_x\) 、 \(P_y\) 和 \(P_z\) ，或以概率 \(1-P_x-P_y-P_z\) 的概率保持不变（作用 \(I\) 门）。
泡利信道的数学表示如下：
\[\epsilon(\rho) = (1 - P_x - P_y - P_z)\rho + P_x X \rho X + P_y Y \rho Y + P_z Z \rho Z\]其中， \(\rho\) 是密度矩阵形式的量子态； \(P_x\) 、 \(P_y\) 和 \(P_z\) 是作用的泡利门为 \(X\) 、 \(Y\) 和 \(Z\) 门的概率。
- 参数：
px (int, float) - 作用的泡利门是X门的概率。
py (int, float) - 作用的泡利门是Y门的概率。
pz (int, float) - 作用的泡利门是Z门的概率。
样例：
>>> from mindquantum.core.gates import PauliChannel >>> from mindquantum.core.circuit import Circuit >>> circ = Circuit() >>> circ += PauliChannel(0.8, 0.1, 0.1).on(0) >>> circ += PauliChannel(0, 0.05, 0.9).on(1, 0) >>> circ.measure_all() >>> print(circ) q0: ──PC────●─────M(q0)── │ q1: ────────PC────M(q1)── >>> from mindquantum.simulator import Simulator >>> sim = Simulator('mqvector', 2) >>> sim.sampling(circ, shots=1000, seed=42) shots: 1000 Keys: q1 q0│0.00 0.2 0.4 0.6 0.8 1.0 ───────────┼───────────┴───────────┴───────────┴───────────┴───────────┴ 00│▒▒▒▒▒▒▒ │ 01│▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ │ 11│▒▒▒ │ {'00': 101, '01': 862, '11': 37}
- class mindquantum.core.gates.PhaseDampingChannel(gamma: float, **kwargs)[源代码]
用于表征量子计算中非相干噪声的信道。 相位衰减信道表示的是量子比特在不跟外界产生能量交换时量子信息的损失。 相位衰减信道通常可表示为：
\[ \begin{align}\begin{aligned}\epsilon(\rho) = E_0 \rho E_0^\dagger + E_1 \rho E_1^\dagger\\\begin{split}where\ {E_0}=\begin{bmatrix}1&0\\ 0&\sqrt{1-\gamma}\end{bmatrix}, \ {E_1}=\begin{bmatrix}0&0\\ 0&\sqrt{\gamma}\end{bmatrix}\end{split}\end{aligned}\end{align} \]这里 \(\rho\) 是密度矩阵形式的量子态； \(\gamma\) 是信息损失系数。
- 参数：
gamma (int, float) - 信息损失系数。
样例：
>>> from mindquantum.core.gates import PhaseDampingChannel >>> from mindquantum.core.circuit import Circuit >>> circ = Circuit() >>> circ += PhaseDampingChannel(0.02).on(0) >>> circ += PhaseDampingChannel(0.01).on(1, 0) >>> print(circ) q0: ──PD(0.02)───────●────── │ q1: ──────────────PD(0.01)──
- class mindquantum.core.gates.PhaseFlipChannel(p: float, **kwargs)[源代码]
量子信道可以描述量子计算中的非相干噪声。
相位翻转信道描述的噪声体现为：以 \(P\) 的概率翻转量子比特的相位（应用Z门），或以 \(1-P\) 的概率保持不变（作用I门）。
相位翻转信道的数学表示如下：
\[\epsilon(\rho) = (1 - P)\rho + P Z \rho Z\]其中，\(\rho\) 是密度矩阵形式的量子态； \(P\) 是作用额外Z门的概率。
- 参数：
p (int, float) - 发生错误的概率。
样例：
>>> from mindquantum.core.gates import PhaseFlipChannel >>> from mindquantum.core.circuit import Circuit >>> circ = Circuit() >>> circ += PhaseFlipChannel(0.02).on(0) >>> circ += PhaseFlipChannel(0.01).on(1, 0) >>> print(circ) q0: ──PF(0.02)───────●────── │ q1: ──────────────PF(0.01)──
- class mindquantum.core.gates.PhaseShift(pr)[源代码]
相移门。更多用法，请参见
mindquantum.core.gates.RX。\[\begin{split}{\rm PhaseShift}=\begin{pmatrix}1&0\\ 0&\exp(i\theta)\end{pmatrix}\end{split}\]- 参数：
pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。
- class mindquantum.core.gates.Power(gate, exponent=0.5)[源代码]
作用在非参数化门上的指数运算符。
- 参数：
gates (
mindquantum.core.gates.NoneParameterGate) - 要作用指数运算符的基本门。exponent (int, float) - 指数。默认值：0.5。
样例：
>>> from mindquantum.core.gates import Power >>> import numpy as np >>> rx1 = RX(0.5) >>> rx2 = RX(1) >>> assert np.all(np.isclose(Power(rx2,0.5).matrix(), rx1.matrix()))
- class mindquantum.core.gates.RX(pr)[源代码]
围绕x轴的旋转门。
\[\begin{split}{\rm RX}=\begin{pmatrix}\cos(\theta/2)&-i\sin(\theta/2)\\ -i\sin(\theta/2)&\cos(\theta/2)\end{pmatrix}\end{split}\]该旋转门可以用三种不同的方式初始化。
如果用单个数字初始化它，那么它将是一个具有一定旋转角度的非参数化门。
如果使用单个str初始化它，那么它将是只有一个参数的参数化门，默认系数为1。
如果使用dict初始化它，例如 {‘a’：1，’b’：2} ，则此门可以包含多个具有特定系数的参数。在这种情况下，它可以表示为：
\[RX(a+2b)\]- 参数：
pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。
样例：
>>> from mindquantum.core.gates import RX >>> import numpy as np >>> rx1 = RX(0.5) >>> np.round(rx1.matrix(), 2) array([[0.97+0.j , 0. -0.25j], [0. -0.25j, 0.97+0.j ]]) >>> rx2 = RX('a') >>> np.round(rx2.matrix({'a':0.1}), 3) array([[0.999+0.j , 0. -0.05j], [0. -0.05j, 0.999+0.j ]]) >>> rx3 = RX({'a' : 0.2, 'b': 0.5}).on(0, 2) >>> print(rx3) RX(0.2*a + 0.5*b|0 <-: 2) >>> np.round(rx3.matrix({'a' : 1, 'b' : 2}), 2) array([[0.83+0.j , 0. -0.56j], [0. -0.56j, 0.83+0.j ]]) >>> np.round(rx3.diff_matrix({'a' : 1, 'b' : 2}, about_what = 'a'), 2) array([[-0.06+0.j , 0. -0.08j], [ 0. -0.08j, -0.06+0.j ]]) >>> rx3.coeff {'a': 0.2, 'b': 0.5}
- class mindquantum.core.gates.RY(pr)[源代码]
围绕y轴的旋转门。更多用法，请参见
mindquantum.core.gates.RX。\[\begin{split}{\rm RY}=\begin{pmatrix}\cos(\theta/2)&-\sin(\theta/2)\\ \sin(\theta/2)&\cos(\theta/2)\end{pmatrix}\end{split}\]- 参数：
pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。
- class mindquantum.core.gates.RZ(pr)[源代码]
围绕z轴的旋转门。更多用法，请参见
mindquantum.core.gates.RX。\[\begin{split}{\rm RZ}=\begin{pmatrix}\exp(-i\theta/2)&0\\ 0&\exp(i\theta/2)\end{pmatrix}\end{split}\]- 参数：
pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。
- class mindquantum.core.gates.SGate[源代码]
S门，矩阵为：
\[\begin{split}{\rm S}=\begin{pmatrix}1&0\\0&i\end{pmatrix}\end{split}\]更多用法，请参见
mindquantum.core.gates.XGate。
- class mindquantum.core.gates.SWAPGate[源代码]
SWAP门可以交换两个不同的量子比特。
更多用法，请参见
mindquantum.core.gates.XGate。
- class mindquantum.core.gates.TGate[源代码]
T门，矩阵为：
\[\begin{split}{\rm T}=\begin{pmatrix}1&0\\0&(1+i)/\sqrt(2)\end{pmatrix}\end{split}\]更多用法，请参见
mindquantum.core.gates.XGate。
- class mindquantum.core.gates.U3(theta: ParameterResolver, phi: ParameterResolver, lamda: ParameterResolver)[源代码]
U3 门表示单比特的任意幺正门。U3 门的矩阵形式为：
\[\begin{split}{\rm U3}(\theta, \phi, \lambda) =\begin{pmatrix}\cos(\theta/2)&-e^{i\lambda}\sin(\theta/2)\\ e^{i\phi}\sin(\theta/2)&e^{i(\phi+\lambda)}\cos(\theta/2)\end{pmatrix}\end{split}\]它可以被分解为：
\[{\rm U3}(\theta, \phi, \lambda) = RZ(\phi) RX(-\pi/2) RZ(\theta) RX(\pi/2) RZ(\lambda)\]- 参数：
theta (Union[numbers.Number, dict, ParameterResolver]) - U3 门的第一个参数。
phi (Union[numbers.Number, dict, ParameterResolver]) - U3 门的第二个参数。
lamda (Union[numbers.Number, dict, ParameterResolver]) - U3 门的第三个参数。
样例：
>>> from mindquantum.core.gates import U3 >>> U3('theta','phi','lambda').on(0, 1) U3(𝜃=theta, 𝜑=phi, 𝜆=lambda|0 <-: 1)
- hermitian()[源代码]
获取 U3 门的厄米共轭形式。
样例：
>>> from mindquantum.core.gates import U3 >>> u3 = U3('a', 'b', 0.5).on(0) >>> u3.hermitian() U3(𝜃=-a, 𝜑=-1/2, 𝜆=-b|0)
- lamda()
获取 U3 门的参数 lamda。
- 返回：
ParameterResolver，参数 lamda。
- matrix(pr: ParameterResolver = None)[源代码]
获取 U3 门的矩阵形式。
- 参数：
pr (Union[ParameterResolver, dict]) - U3 门的参数。默认值：None。
- phi()
获取 U3 门的参数 phi。
- 返回：
ParameterResolver，参数 phi。
- theta()
获取 U3 门的参数 theta。
- 返回：
ParameterResolver，参数 theta。
- class mindquantum.core.gates.UnivMathGate(name, matrix_value)[源代码]
通用数学门。
更多用法，请参见
mindquantum.core.gates.XGate.- 参数：
name (str) - 此门的名称。
mat (np.ndarray) - 此门的矩阵值。
样例：
>>> from mindquantum.core.gates import UnivMathGate >>> x_mat=np.array([[0,1],[1,0]]) >>> X_gate=UnivMathGate('X',x_mat) >>> x1=X_gate.on(0,1) >>> print(x1) X(0 <-: 1)
- class mindquantum.core.gates.XGate[源代码]
泡利X门，矩阵为：
\[\begin{split}{\rm X}=\begin{pmatrix}0&1\\1&0\end{pmatrix}\end{split}\]为了简单起见，我们将
X定义为XGate()的实例。有关更多重新定义，请参考下面的功能表。说明
为了简单起见，您可以在泡利门上执行指数运算（目前仅适用于泡利门）。规则如下：
\[X^\theta = RX(\theta\pi)\]样例：
>>> from mindquantum.core.gates import X >>> x1 = X.on(0) >>> cnot = X.on(0, 1) >>> print(x1) X(0) >>> print(cnot) X(0 <-: 1) >>> x1.matrix() array([[0, 1], [1, 0]]) >>> x1**2 RX(2π) >>> (x1**'a').coeff {'a': 3.141592653589793}, const: 0.0 >>> (x1**{'a' : 2}).coeff {'a': 6.283185307179586}, const: 0.0
- class mindquantum.core.gates.XX(pr)[源代码]
伊辛XX门。更多用法，请参见
mindquantum.core.gates.RX。\[{\rm XX_\theta}=\cos(\theta)I\otimes I-i\sin(\theta)\sigma_x\otimes\sigma_x\]- 参数：
pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。
- class mindquantum.core.gates.YGate[源代码]
泡利Y门，矩阵为：
\[\begin{split}{\rm Y}=\begin{pmatrix}0&-i\\i&0\end{pmatrix}\end{split}\]更多用法，请参见
mindquantum.core.gates.XGate。
- class mindquantum.core.gates.YY(pr)[源代码]
伊辛YY门。更多用法，请参见
mindquantum.core.gates.RX。\[{\rm YY_\theta}=\cos(\theta)I\otimes I-i\sin(\theta)\sigma_y\otimes\sigma_y\]- 参数：
pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。
- class mindquantum.core.gates.ZGate[源代码]
泡利Z门，矩阵为：
\[\begin{split}{\rm Z}=\begin{pmatrix}1&0\\0&-1\end{pmatrix}\end{split}\]更多用法，请参见
mindquantum.core.gates.XGate。
- class mindquantum.core.gates.ZZ(pr)[源代码]
伊辛ZZ门。更多用法，请参见
mindquantum.core.gates.RX。\[{\rm ZZ_\theta}=\cos(\theta)I\otimes I-i\sin(\theta)\sigma_Z\otimes\sigma_Z\]- 参数：
pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。
- mindquantum.core.gates.gene_univ_parameterized_gate(name, matrix_generator, diff_matrix_generator)[源代码]
基于单参数幺正矩阵生成自定义参数化门。
- 参数：
name (str) - 此门的名称。
matrix_generator (Union[FunctionType, MethodType]) - 只采用一个参数生成幺正矩阵的函数或方法。
diff_matrix_generator (Union[FunctionType, MethodType]) - 只采用一个参数生成幺正矩阵导数的函数或方法。
- 返回：
_ParamNonHerm，自定义的参数化门。
样例：
>>> import numpy as np >>> from mindquantum.core.circuit import Circuit >>> from mindquantum.core.gates import gene_univ_parameterized_gate >>> from mindquantum.simulator import Simulator >>> def matrix(theta): ... return np.array([[np.exp(1j * theta), 0], ... [0, np.exp(-1j * theta)]]) >>> def diff_matrix(theta): ... return 1j*np.array([[np.exp(1j * theta), 0], ... [0, -np.exp(-1j * theta)]]) >>> TestGate = gene_univ_parameterized_gate('Test', matrix, diff_matrix) >>> circ = Circuit().h(0) >>> circ += TestGate('a').on(0) >>> circ q0: ──H────Test(a)── >>> circ.get_qs(pr={'a': 1.2}) array([0.25622563+0.65905116j, 0.25622563-0.65905116j])