文档反馈

问题文档片段

问题文档片段包含公式时，显示为空格。

提交类型

issue

有点复杂...

找人问问吧。

请选择提交类型

问题类型

规范和低错类

- 规范和低错类：

- 错别字或拼写错误，标点符号使用错误、公式错误或显示异常。

- 链接错误、空单元格、格式错误。

- 英文中包含中文字符。

- 界面和描述不一致，但不影响操作。

- 表述不通顺，但不影响理解。

- 版本号不匹配：如软件包名称、界面版本号。

易用性

- 易用性：

- 关键步骤错误或缺失，无法指导用户完成任务。

- 缺少主要功能描述、关键词解释、必要前提条件、注意事项等。

- 描述内容存在歧义指代不明、上下文矛盾。

- 逻辑不清晰，该分类、分项、分步骤的没有给出。

正确性

- 正确性：

- 技术原理、功能、支持平台、参数类型、异常报错等描述和软件实现不一致。

- 原理图、架构图等存在错误。

- 命令、命令参数等错误。

- 代码片段错误。

- 命令无法完成对应功能。

- 界面错误，无法指导操作。

- 代码样例运行报错、运行结果不符。

风险提示

- 风险提示：

- 对重要数据或系统存在风险的操作，缺少安全提示。

内容合规

- 内容合规：

- 违反法律法规，涉及政治、领土主权等敏感词。

- 内容侵权。

请选择问题类型

问题描述

点击输入详细问题描述，以帮助我们快速定位问题。

提交

文档反馈

mindquantum.core.gates

量子门模块，提供不同的量子门。

functional

如下量子门是预实例化的量子门，可直接作为对应量子门的实例来使用。

functional	gates
mindquantum.core.gates.CNOT	mindquantum.core.gates.CNOTGate
mindquantum.core.gates.I	mindquantum.core.gates.IGate
mindquantum.core.gates.ISWAP	mindquantum.core.gates.ISWAPGate
mindquantum.core.gates.H	mindquantum.core.gates.HGate
mindquantum.core.gates.S	mindquantum.core.gates.PhaseShift (numpy.pi/2)
mindquantum.core.gates.SWAP	mindquantum.core.gates.SWAPGate
mindquantum.core.gates.T	mindquantum.core.gates.PhaseShift (numpy.pi/4)
mindquantum.core.gates.X	mindquantum.core.gates.XGate
mindquantum.core.gates.Y	mindquantum.core.gates.YGate
mindquantum.core.gates.Z	mindquantum.core.gates.ZGate

Quantum Gates

class mindquantum.core.gates.AmplitudeDampingChannel(gamma: float, **kwargs)

用于表征量子计算中非相干噪声的信道。 振幅衰减信道表示的是量子比特由于能量耗散导致的错误。 振幅衰减信道通常可表示为：

$$\begin{array}{r}\begin{array}{c}ϵ(\rho )=E_0\rho E_0^{†}+E_1\rho E_1^{†}\\ \begin{array}{c}where{E}_0=\left[\begin{array}{cc}1& 0\\ 0& \sqrt{1-\gamma }\end{array}\right],E_1=\left[\begin{array}{cc}0& \sqrt{\gamma }\\ 0& 0\end{array}\right]\end{array}\end{array}\end{array}$$

这里 $\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)──

define_projectq_gate()

定义对应的projectq门。

get_cpp_obj()

返回底层c++对象。

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

检查此门是否已经作用在量子比特上。

define_projectq_gate()

定义对应的 projectq 中的量子门。

get_cpp_obj()

获取底层c++对象。

hermitian()

返回该量子门的厄米共轭形式。

matrix(*args)

门的矩阵。

no_grad()

设置该量子门在梯度计算相关算法中不计算梯度。

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

检查此门是否为参数化门。

requires_grad()

设置该量子门在梯度计算相关算法中要计算梯度。在默认情况下，参数化量子门在构造时就是需要计算梯度。

class mindquantum.core.gates.BitFlipChannel(p: float, **kwargs)

量子信道可以描述量子计算中的非相干噪声。

比特翻转信道描述的噪声体现为：以 $P$ 的概率翻转量子比特（作用 $X$ 门），或以 $1-P$ 的概率保持不变（作用 $I$ 门）。

比特翻转信道的数学表示如下：

$$ϵ(\rho )=(1-P)\rho +PX\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$ 门）。

比特相位翻转通道的数学表示如下：

$$ϵ(\rho )=(1-P)\rho +PY\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 。

on(obj_qubits, ctrl_qubits=None)

定义量子门作用在哪些量子别上，并受哪些量子比特控制。

说明

在本框架中，接口中的第一个参数是量子门作用在哪些比特上，第二个参数是控制比特，即使对于控制门也是如此，例如CNOT门。

参数：

• obj_qubits (int, list[int]) - 指明量子门作用在哪些量子比特上。

• ctrl_qubits (int, list[int]) - 指明量子门受哪些量子比特控制。默认值：None。

返回：

量子门，返回一个新的量子门。

class mindquantum.core.gates.DepolarizingChannel(p: float, **kwargs)

量子信道可以描述量子计算中的非相干噪声。

去极化通道描述的噪声体现为：以 $P$ 的概率将量子态转变为最大混态（随机作用泡利门（X,Y,Z）的其中一个，每个泡利门的概率都是 $P/3$ ），或以 $1-P$ 的概率保持不变（作用I门）。

去极化信道的数学表示如下：

$$ϵ(\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{array}{r}\mathrm{F}\mathrm{S}\mathrm{i}\mathrm{m}(\theta ,\varphi )=\left(\begin{array}{cccc}1& 0& 0& 0\\ 0& \cos (\theta )& -i\sin (\theta )& 0\\ 0& -i\sin (\theta )& \cos (\theta )& 0\\ 0& 0& 0& e^{i\varphi }\end{array}\right)\end{array}$$

参数：

• 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)

get_cpp_obj()

返回量子门的c++对象。

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{array}{r}\mathrm{G}\mathrm{l}\mathrm{o}\mathrm{b}\mathrm{a}\mathrm{l}\mathrm{P}\mathrm{h}\mathrm{a}\mathrm{s}\mathrm{e}=\left(\begin{array}{cc}\exp (-i\theta )& 0\\ 0& \exp (-i\theta )\end{array}\right)\end{array}$$

参数：

• pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。

diff_matrix(pr=None, about_what=None, **kwargs)

参数门的倒数矩阵形式。

参数：

• pr (Union[ParameterResolver, dict]) - 参数门的参数。默认值：None。

• about_what (str) - 相对于哪个参数来求导数。默认值：None。

• kwargs (dict) - 其他参数。

返回：

numpy.ndarray，量子门的导数形式的矩阵。

matrix(pr=None, **kwargs)

参数门的矩阵形式。

参数：

• pr (Union[ParameterResolver, dict]) - 参数门的参数。默认值：None。

• kwargs (dict) - 其他的参数。

返回：

numpy.ndarray，量子门的矩阵形式。

class mindquantum.core.gates.HGate

Hadamard门，矩阵为：

$$\begin{array}{r}\mathrm{H}=\frac{1}{\sqrt{2}}\left(\begin{array}{cc}1& 1\\ 1& -1\end{array}\right)\end{array}$$

更多用法，请参见 mindquantum.core.gates.XGate。

class mindquantum.core.gates.IGate

Identity门，矩阵为：

$$\begin{array}{r}\mathrm{I}=\left(\begin{array}{cc}1& 0\\ 0& 1\end{array}\right)\end{array}$$

更多用法，请参见 mindquantum.core.gates.XGate。

class mindquantum.core.gates.ISWAPGate

ISWAP门会交换两个不同的量子比特并且为 $|01⟩$ 和 $|10⟩$ 的振幅增加相位 $i$。

更多用法，请参见 mindquantum.core.gates.XGate。

class mindquantum.core.gates.KrausChannel(name: str, kraus_op, **kwargs)

用于表征量子计算中非相干噪声的量子信道。

Kraus 信道接受两个或多个 2x2 矩阵作为 Kraus 算子，以在量子电路中构造自定义（单量子比特）噪声。

Kraus 信道以如下形式作用噪声：

$$ϵ(\rho )=\sum _{k=0}^{m-1}{E}_k\rho E_k^{†}$$

其中 $\rho$ 是密度矩阵形式的量子态；$E_k$ 是Kraus算符， 并且它需要满足完备性条件：$\sum _k{E}_k^{†}{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──

define_projectq_gate()

定义对应的projectq门。

get_cpp_obj()

获取底层c++对象。

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])

get_cpp_obj()

获取测量门的底层c++对象。

hermitian()

测量门的厄米形式，返回其自身。

on(obj_qubits, ctrl_qubits=None)

定义测量门作用在什么量子比特上。

参数：

• obj_qubits (Union[int, list[int]]) - 对哪个比特进行测量。

• ctrl_qubits (Union[int, list[int]]) - 测量门不允许设置控制位。

返回：

Measure，以及定义好作用在哪个比特上的测量门。

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}

svg(style=None)

将当前测量结果显示为jupyter notebook中的SVG图片。

参数：

• style (dict, str) - 设置svg样式的样式。目前，我们支持’official’。默认值：None。

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) - 量子门的其他参数。

get_cpp_obj()

返回量子门的c++对象。

get_parameters()

返回参数化门的参数列表。

no_grad()

设置量子门中的所有参数都不需要求导数。

no_grad_part(names)

设置某些不需要求梯度的参数。此操作将会原位改变线路参数梯度属性。

参数：

• names (tuple[str]) - 不需要求梯度的参数。

返回：

BasicGate，其中有些参数不需要更新梯度。

requires_grad()

设置量子门中的所有参数都需要求导数。

requires_grad_part(names)

设置哪部分参数需要求导。原地操作。

参数：

• names (tuple[str]) - 需要求梯度的参数。

返回：

BasicGate，其中有些参数需要更新梯度。

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$ 门）。

泡利信道的数学表示如下：

$$ϵ(\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}

define_projectq_gate()

定义对应的projectq门。

get_cpp_obj()

返回量子门的c++对象。

class mindquantum.core.gates.PhaseDampingChannel(gamma: float, **kwargs)

用于表征量子计算中非相干噪声的信道。 相位衰减信道表示的是量子比特在不跟外界产生能量交换时量子信息的损失。 相位衰减信道通常可表示为：

$$\begin{array}{r}\begin{array}{c}ϵ(\rho )=E_0\rho E_0^{†}+E_1\rho E_1^{†}\\ \begin{array}{c}where{E}_0=\left[\begin{array}{cc}1& 0\\ 0& \sqrt{1-\gamma }\end{array}\right],E_1=\left[\begin{array}{cc}0& 0\\ 0& \sqrt{\gamma }\end{array}\right]\end{array}\end{array}\end{array}$$

这里 $\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)──

define_projectq_gate()

定义对应的projectq门。

get_cpp_obj()

获取底层c++对象。

class mindquantum.core.gates.PhaseFlipChannel(p: float, **kwargs)

量子信道可以描述量子计算中的非相干噪声。

相位翻转信道描述的噪声体现为：以 $P$ 的概率翻转量子比特的相位（应用Z门），或以 $1-P$ 的概率保持不变（作用I门）。

相位翻转信道的数学表示如下：

$$ϵ(\rho )=(1-P)\rho +PZ\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{array}{r}\mathrm{P}\mathrm{h}\mathrm{a}\mathrm{s}\mathrm{e}\mathrm{S}\mathrm{h}\mathrm{i}\mathrm{f}\mathrm{t}=\left(\begin{array}{cc}1& 0\\ 0& \exp (i\theta )\end{array}\right)\end{array}$$

参数：

• pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。

diff_matrix(pr=None, about_what=None)

参数门的倒数矩阵形式。

参数：

• pr (Union[ParameterResolver, dict]) - 量子门的参数。默认值：None。

• about_what (str) - 相对于哪个参数来求导数。默认值：None。

返回：

numpy.ndarray, 量子门的导数形式的矩阵。

matrix(pr=None)

参数门的矩阵形式。

参数：

• pr (Union[ParameterResolver, dict]) - 参数门的矩阵形式。默认值：None。

返回：

numpy.ndarray，量子门的矩阵形式。

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()))

get_cpp_obj()

返回量子门的c++对象。

class mindquantum.core.gates.RX(pr)

围绕x轴的旋转门。

$$\begin{array}{r}\mathrm{R}\mathrm{X}=\left(\begin{array}{cc}\cos (\theta /2)& -i\sin (\theta /2)\\ -i\sin (\theta /2)& \cos (\theta /2)\end{array}\right)\end{array}$$

该旋转门可以用三种不同的方式初始化。

1. 如果用单个数字初始化它，那么它将是一个具有一定旋转角度的非参数化门。

2. 如果使用单个str初始化它，那么它将是只有一个参数的参数化门，默认系数为1。

3. 如果使用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{array}{r}\mathrm{R}\mathrm{Y}=\left(\begin{array}{cc}\cos (\theta /2)& -\sin (\theta /2)\\ \sin (\theta /2)& \cos (\theta /2)\end{array}\right)\end{array}$$

参数：

• pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。

class mindquantum.core.gates.RZ(pr)

围绕z轴的旋转门。更多用法，请参见 mindquantum.core.gates.RX。

$$\begin{array}{r}\mathrm{R}\mathrm{Z}=\left(\begin{array}{cc}\exp (-i\theta /2)& 0\\ 0& \exp (i\theta /2)\end{array}\right)\end{array}$$

参数：

• pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。

class mindquantum.core.gates.SGate

S门，矩阵为：

$$\begin{array}{r}\mathrm{S}=\left(\begin{array}{cc}1& 0\\ 0& i\end{array}\right)\end{array}$$

更多用法，请参见 mindquantum.core.gates.XGate。

class mindquantum.core.gates.SWAPGate

SWAP门可以交换两个不同的量子比特。

更多用法，请参见 mindquantum.core.gates.XGate。

class mindquantum.core.gates.TGate

T门，矩阵为：

$$\begin{array}{r}\mathrm{T}=\left(\begin{array}{cc}1& 0\\ 0& (1+i)/\sqrt{(}2)\end{array}\right)\end{array}$$

更多用法，请参见 mindquantum.core.gates.XGate。

class mindquantum.core.gates.U3(theta: ParameterResolver, phi: ParameterResolver, lamda: ParameterResolver)

U3 门表示单比特的任意幺正门。U3 门的矩阵形式为：

$$\begin{array}{r}\mathrm{U}3(\theta ,\varphi ,\lambda )=\left(\begin{array}{cc}\cos (\theta /2)& -e^{i\lambda }\sin (\theta /2)\\ e^{i\varphi }\sin (\theta /2)& e^{i(\varphi +\lambda )}\cos (\theta /2)\end{array}\right)\end{array}$$

它可以被分解为：

$$\mathrm{U}3(\theta ,\varphi ,\lambda )=RZ(\varphi )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)

get_cpp_obj()

返回量子门的c++对象。

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)

get_cpp_obj()

返回该门的c++对象。

class mindquantum.core.gates.XGate

泡利X门，矩阵为：

$$\begin{array}{r}\mathrm{X}=\left(\begin{array}{cc}0& 1\\ 1& 0\end{array}\right)\end{array}$$

为了简单起见，我们将 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。

$$\mathrm{X}{\mathrm{X}}_{\theta }=\cos (\theta )I\otimes I-i\sin (\theta ){\sigma }_x\otimes {\sigma }_x$$

参数：

• pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。

diff_matrix(pr=None, about_what=None, frac=1)

返回该参数化量子门的导数矩阵。

参数：

• pr (Union[ParameterResolver, dict]) - 该参数化量子门的参数值。默认值：None。

• about_what (str) - 关于哪个参数求导数。

• frac (numbers.Number) - 系数的倍数。默认值：1。

返回：

numpy.ndarray，该量子门的导数矩阵形式。

matrix(pr=None, frac=1)

返回该参数化量子门的矩阵。

参数：

• pr (Union[ParameterResolver, dict]) - 该参数化量子门的参数值。默认值：None。

• frac (numbers.Number) - 系数的倍数。默认值：1。

返回：

numpy.ndarray，该量子门的矩阵形式。

class mindquantum.core.gates.YGate

泡利Y门，矩阵为：

$$\begin{array}{r}\mathrm{Y}=\left(\begin{array}{cc}0& -i\\ i& 0\end{array}\right)\end{array}$$

更多用法，请参见 mindquantum.core.gates.XGate。

class mindquantum.core.gates.YY(pr)

伊辛YY门。更多用法，请参见 mindquantum.core.gates.RX。

$$\mathrm{Y}{\mathrm{Y}}_{\theta }=\cos (\theta )I\otimes I-i\sin (\theta ){\sigma }_y\otimes {\sigma }_y$$

参数：

• pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。

diff_matrix(pr=None, about_what=None, frac=1)

返回该参数化量子门的导数矩阵。

参数：

• pr (Union[ParameterResolver, dict]) - 该参数化量子门的参数值。默认值：None。

• about_what (str) - 关于哪个参数求导数。

• frac (numbers.Number) - 系数的倍数。默认值：1。

返回：

numpy.ndarray，该量子门的导数矩阵形式。

matrix(pr=None, frac=1)

返回该参数化量子门的矩阵。

参数：

• pr (Union[ParameterResolver, dict]) - 该参数化量子门的参数值。默认值：None。

• frac (numbers.Number) - 系数的倍数。默认值：1。

返回：

numpy.ndarray，该量子门的矩阵形式。

class mindquantum.core.gates.ZGate

泡利Z门，矩阵为：

$$\begin{array}{r}\mathrm{Z}=\left(\begin{array}{cc}1& 0\\ 0& -1\end{array}\right)\end{array}$$

更多用法，请参见 mindquantum.core.gates.XGate。

class mindquantum.core.gates.ZZ(pr)

伊辛ZZ门。更多用法，请参见 mindquantum.core.gates.RX。

$$\mathrm{Z}{\mathrm{Z}}_{\theta }=\cos (\theta )I\otimes I-i\sin (\theta ){\sigma }_Z\otimes {\sigma }_Z$$

参数：

• pr (Union[int, float, str, dict, ParameterResolver]) - 参数化门的参数，详细解释请参见上文。

diff_matrix(pr=None, about_what=None, frac=1)

返回该参数化量子门的导数矩阵。

参数：

• pr (Union[ParameterResolver, dict]) - 该参数化量子门的参数值。默认值：None。

• about_what (str) - 关于哪个参数求导数。

• frac (numbers.Number) - 系数的倍数。默认值：1。

返回：

numpy.ndarray，该量子门的导数矩阵形式。

matrix(pr=None, frac=1)

返回该参数化量子门的矩阵。

参数：

• pr (Union[ParameterResolver, dict]) - 该参数化量子门的参数值。默认值：None。

• frac (numbers.Number) - 系数的倍数。默认值：1。

返回：

numpy.ndarray，该量子门的矩阵形式。

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])

class mindquantum.core.gates.BarrierGate(show=True)

栅栏门会将两个量子门分开在不同的层级上。

参数：

• show (bool) - 是否展示栅栏门。默认值：True.

on(obj_qubits, ctrl_qubits=None)

定义该门作用在哪些量子比特上。受控位必须为 None，应为栅栏门不能被其他比特控制。

参数：

• obj_qubits (int, list[int]) - 指明量子门作用在哪些量子比特上，可以是单个比特，也可以是一连串的连续比特。

• ctrl_qubits (int, list[int]) - 指明量子门受哪些量子比特控制。默认值：None。

返回：

量子门，返回一个新的量子门。

class mindquantum.core.gates.NoneParameterGate(name, n_qubits, obj_qubits=None, ctrl_qubits=None)

非参数化的门。

参数：

• name (str) - 此门的名称。

• n_qubits (int) - 这个门有多少个量子比特。

• obj_qubits (int, list[int]) - 具体门作用在哪个量子比特上。

• ctrl_qubits (int, list[int]) - 指定控制量子比特。默认：None。