量子对象

Qobj

class Qobj( arg: ArrayLike | Any = None, dims: DimensionLike = None, copy: bool = True, superrep: str = None, isherm: bool = None, isunitary: bool = None, )[source]

一个用于表示量子对象的类，例如量子算符和状态。

Qobj 类是 QuTiP 中量子算符和状态向量的表示。该类还实现了 Qobj 实例之间的数学运算 +、-、*（以及除以一个复数），以及一系列常见的算符/状态操作。Qobj 构造函数可以选择性地接受维度 list 和/或形状 list 作为参数。

Parameters:

arg: array_like, data object or :obj:`.Qobj`: 量子对象的向量/矩阵表示的数据。
dims: list: 用于张量积的对象的维度。
copy: bool: 指定Qobj是否应获取输入数据的副本，或使用原始数据的标志。

Attributes:

dataobject: 存储Qobj的向量/矩阵表示的数据对象。
dtypetype: 用于存储数据的数据层类型。可能的类型在Qobj.to中描述。
dimslist: 跟踪张量结构的维度列表。
shapelist: 返回Qobj数据的形状。
typestr: 量子对象的类型：'bra'、'ket'、'oper'、'operator-ket'、'operator-bra' 或 'super'。
superrepstr: 如果type是‘super’时使用的表示形式。其中之一是‘super’（Liouville形式）、‘choi’（迹等于维度的Choi矩阵）或‘chi’（chi矩阵表示）。
ishermbool: 指示量子对象是否表示厄米算子。
isunitarybool: 指示量子对象是否表示酉算子。
iscpbool: 指示量子对象是否表示一个映射，以及该映射是否完全正定（CP）。
ishpbool: 指示量子对象是否表示一个映射，以及该映射是否保持厄米性（HP）。
istpbool: 指示量子对象是否表示一个映射，以及该映射是否是保迹的（TP）。
iscptpbool: 指示量子对象是否表示一个完全正且保迹（CPTP）的映射。
isketbool: 指示 Qobj 是否表示一个 ket 状态。
isbrabool: 指示 Qobj 是否表示一个 bra 状态。
isoperbool: 指示Qobj是否表示一个操作符。
issuperbool: 指示Qobj是否表示一个超算子。
isoperketbool: 指示 Qobj 是否表示一个 operator-ket 状态。
isoperbrabool: 指示 Qobj 是否表示一个 operator-bra 状态。

方法

copy()	创建 Qobj 的副本
conj()	量子对象的共轭。
contract()	收缩张量结构中的一维子空间。
cosm()	量子对象的余弦。
dag()	量子对象的伴随（dagger）。
data_as(format, copy)	量子对象的向量/矩阵表示。
diag()	量子对象的对角线元素。
dnorm()	量子算子的钻石范数。
dual_chan()	表示CP映射的量子对象的双通道。
eigenenergies(sparse=False, sort=’low’, eigvals=0, tol=0, maxiter=100000)	返回量子对象的特征能量（特征值）。
eigenstates(sparse=False, sort=’low’, eigvals=0, tol=0, maxiter=100000)	返回量子对象的特征能量和特征态。
expm()	量子对象的矩阵指数。
full(order=’C’)	返回量子对象data属性的密集数组。
groundstate(sparse=False, tol=0, maxiter=100000)	返回量子对象的基态的特征值和特征向量。
inv()	返回一个对应于操作符矩阵逆的Qobj。
logm()	量子算符的矩阵对数。
matrix_element(bra, ket)	返回操作符在bra和ket向量之间的矩阵元素。
norm(norm=’tr’, sparse=False, tol=0, maxiter=100000)	返回一个ket或算子的范数。
overlap(other)	两个状态向量或两个算子之间的重叠。
permute(order)	返回索引重新排序的复合qobj。
proj()	计算一个ket或bra向量的投影器。
ptrace(sel)	在执行部分迹操作后返回选定维度的量子对象。
purity()	计算量子对象的纯度。
sinm()	量子对象的正弦值。
sqrtm()	量子对象的矩阵平方根。
tidyup(atol=1e-12)	从量子对象中移除小元素。
tr()	量子对象的迹。
trans()	量子对象的转置。
transform(inpt, inverse=False)	执行由inpt矩阵定义的基础变换。
trunc_neg(method=’clip’)	移除负特征值并返回一个新的Qobj，该Qobj是一个有效的密度算子。
unit(norm=’tr’, sparse=False, tol=0, maxiter=100000)	返回归一化的量子对象。

__call__(other: Qobj) → Qobj[source]: 通过左乘或向量化和反向量化，将此Qobj作用于另一个Qobj，视情况而定。

check_herm() → bool[source]

检查量子对象是否为厄米特。

Returns:

ishermbool: 返回isherm属性的新值。

conj() → Qobj[source]: 获取量子对象的逐元素共轭。

contract(inplace: bool = False) → Qobj[source]

张量结构的一维子空间。未在超算符上定义。如果所有维度都是标量，则返回维度为[[1], [1]]的Qobj，即_多个_标量维度被收缩，但保留一个。

Parameters:

inplace: bool, optional: 如果 True，则就地修改尺寸。如果 False，则返回一个复制的对象。

Returns:

out: Qobj: 维度收缩的量子对象。如果inplace为True，则返回self。

copy() → Qobj[source]: 创建相同的副本

cosm() → Qobj[source]

量子算符的余弦。

操作符必须是方形的。

Returns:

operQobj: 操作符的矩阵余弦。

Raises:

TypeError: 量子对象不是方形的。

注释

使用 Q.expm() 方法。

dag() → Qobj[source]: 获取量子对象的埃尔米特伴随。

data_as(format: str = None, copy: bool = True) → Any[source]

从量子对象生成的矩阵。

Parameters:

formatstr, default: None: 输出的类型，Dense 为“ndarray”，CSR 为“csr_matrix”。如果格式不支持，将引发 ValueError。
copybool {False, True}: 是否返回一个副本

Returns:

datanumpy.ndarray, scipy.sparse.matrix_csr, etc.: 底层库类型的矩阵。

diag() → ndarray[source]

量子对象的对角元素。

Returns:

diagsarray: 如果操作符是厄米特（Hermitian），则返回real值的数组，否则返回complex值的数组。

dnorm(B: Qobj = None) → float[source]

计算钻石范数，或到另一个操作员的钻石距离。

Parameters:

BQobj or None: 如果 B 不是 None，则返回此操作符与 B 之间的钻石距离 d(A, B) = dnorm(A - B)，而不是钻石范数。

Returns:

dfloat: 这个算子的钻石范数，或者这个算子到B的钻石距离。

dual_chan() → Qobj[source]: 表示完全正映射的量子对象的双通道。

eigenenergies( sparse: bool = False, sort: Literal['low', 'high'] = 'low', eigvals: int = 0, tol: float = 0, maxiter: int = 100000, ) → ndarray[源代码]

量子物体的本征能量。

特征能量（特征值）仅针对算子或超算子定义。

Parameters:

sparsebool: 使用稀疏特征求解器
sortstr: 将特征值从‘低’到‘高’排序，或从‘高’到‘低’排序。
eigvalsint: 请求的特征值数量。默认值为所有特征值。
tolfloat: 稀疏特征求解器使用的容差（0=机器精度）。如果容差设置得太低，稀疏求解器可能无法收敛。
maxiterint: 稀疏求解器执行的最大迭代次数（如果使用）。

Returns:

eigvalsarray: 算子的特征值数组。

注释

稀疏特征求解器比密集版本慢得多。只有在内存需求要求时才使用稀疏版本。

eigenstates( sparse: bool = False, sort: Literal['low', 'high'] = 'low', eigvals: int = 0, tol: float = 0, maxiter: int = 100000, phase_fix: int = None, ) → tuple[ndarray, list[Qobj]][source]

本征态和本征能量。

本征态和本征能量仅针对算符和超算符定义。

Parameters:

sparsebool: 使用稀疏特征求解器
sortstr: 将特征值（和向量）从‘低’到‘高’排序，或从‘高’到‘低’排序。
eigvalsint: 请求的特征值数量。默认值为所有特征值。
tolfloat: 稀疏特征求解器使用的容差（0 = 机器精度）。如果容差设置得太低，稀疏求解器可能无法收敛。
maxiterint: 稀疏求解器执行的最大迭代次数（如果使用）。
phase_fixint, None: 如果不为None，设置每个ket的相位，使得ket[phase_fix,0]为实正数。

Returns:

eigvalsarray: 算子的特征值数组。
eigvecsarray: 表示算子本征态的量子算子数组。本征态的顺序由本征值的顺序决定。

注释

稀疏特征求解器比密集版本慢得多。只有在内存需求要求时才使用稀疏版本。

expm(dtype: LayerType = None) → Qobj[source]

量子算符的矩阵指数。

输入运算符必须是方形的。

Parameters:

dtypetype: 应该输出的数据层类型。

Returns:

operQobj: 指数化量子算子。

Raises:

TypeError: 量子算子不是方形的。

full( order: Literal['C', 'F'] = 'C', squeeze: bool = False, ) → ndarray[source]

从量子对象生成的密集数组。

Parameters:

orderstr {‘C’, ‘F’}: 返回C（默认）或Fortran顺序的数组。
squeezebool {False, True}: 压缩输出数组。

Returns:

dataarray: 来自量子对象data属性的复杂数据数组。

groundstate( sparse: bool = False, tol: float = 0, maxiter: int = 100000, safe: bool = True, ) → tuple[float, Qobj][source]

基态特征值和特征向量。

仅针对量子算子或超算子定义。

Parameters:

sparsebool: 使用稀疏特征求解器
tolfloat: 稀疏特征求解器使用的容差（0 = 机器精度）。如果容差设置得太低，稀疏求解器可能无法收敛。
maxiterint: 稀疏求解器执行的最大迭代次数（如果使用）。
safebool (default=True): 检查简并基态

Returns:

eigvalfloat: 量子算符基态的特征值。
eigvecQobj: 量子算符基态的Eigenket。

注释

稀疏特征求解器比密集版本慢得多。只有在内存需求要求时才使用稀疏版本。

inv(sparse: bool = False) → Qobj[source]

量子算子的矩阵逆

操作符必须是方形的。

Returns:

operQobj: 操作符的矩阵逆。

Raises:

TypeError: 量子对象不是方形的。

property isbra: bool: 指示 Qobj 是否表示一个 bra 状态。

property isket: bool: 指示 Qobj 是否表示一个 ket 状态。

property isoper: bool: 指示Qobj是否表示一个操作符。

property isoperbra: bool: 指示 Qobj 是否表示一个 operator-bra 状态。

property isoperket: bool: 指示 Qobj 是否表示一个 operator-ket 状态。

property issuper: bool: 指示Qobj是否表示一个超算子。

logm() → Qobj[source]

量子算子的矩阵对数。

输入运算符必须是方形的。

Returns:

operQobj: 量子算符的对数。

Raises:

TypeError: 量子算子不是方形的。

matrix_element( bra: Qobj, ket: Qobj, ) → Qobj[source]

计算矩阵元素。

给出量子对象在bra和ket向量之间的矩阵元素。

Parameters:

braQobj: 类型为‘bra’或‘ket’的量子对象
ketQobj: 类型为‘ket’的量子对象。

Returns:

elemcomplex: 复数值矩阵元素。

注释

使用ket向量作为‘bra’输入在计算上稍微更高效。

norm( norm: Literal['l2', 'max', 'fro', 'tr', 'one'] = None, kwargs: dict[str, Any] = None, ) → float[source]

量子对象的范数。

默认的范数是kets的L2范数和算子的迹范数。可以使用norm参数指定其他kets和算子范数。

Parameters:

normstr: 使用哪种类型的范数。向量的允许值为‘l2’和‘max’。矩阵的允许值为‘tr’表示迹范数，‘fro’表示Frobenius范数，‘one’和‘max’。
kwargsdict: 额外的关键字参数传递给相关的范数求解器。有关每个范数函数的详细信息，请参见data.norm。

Returns:

normfloat: 请求的算子或状态量子对象的范数。

overlap(other: Qobj) → complex[source]

两个状态向量或两个算子之间的重叠。

给出当前bra或ket Qobj与另一个bra或ket Qobj之间的重叠（内积）。当其中一个Qobj是算子/密度矩阵时，它给出Hilbert-Schmidt重叠。

Parameters:

otherQobj: 量子对象，用于表示类型为‘ket’、‘bra’或密度矩阵的状态向量。

Returns:

overlapcomplex: 复数值重叠。

Raises:

TypeError: 只能计算bra、ket和密度矩阵量子对象之间的重叠。

permute(order: list) → Qobj[source]

置换量子对象的张量结构。例如，

qutip.tensor(x, y).permute([1, 0])

将给出与

相同的结果

qutip.tensor(y, x)

和

qutip.tensor(a, b, c).permute([1, 2, 0])

将相同于

qutip.tensor(b, c, a)

对于常规对象（bras、kets 和运算符），我们期望 order 是一个整数平面列表，它指定了张量积的新顺序。

对于超级操作符，我们期望order类似于

[[0, 2], [1, 3]]

这告诉我们要根据 [0, 2, 1, 3] 进行排列，然后根据每个子列表的长度对索引进行分组。再举一个例子，排列一个维度为

[[[1, 2, 3], [1, 2, 3]], [[1, 2, 3], [1, 2, 3]]]

通过一个 order

[[0, 3], [1, 4], [2, 5]]

应该给出一个具有尺寸的新对象

[[[1, 1], [2, 2], [3, 3]], [[1, 1], [2, 2], [3, 3]]].

Parameters:

orderlist: 指定新张量顺序的索引列表。

Returns:

PQobj: 置换的量子对象。

proj() → Qobj[source]

从给定的ket或bra向量形成投影器。

Parameters:

QQobj: 输入bra或ket向量

Returns:

PQobj: 投影操作符。

ptrace( sel: int | list[int], dtype: LayerType = None, ) → Qobj[source]

对量子对象进行部分迹运算，保留选定的子空间。换句话说，迹掉所有未传递的子空间。

这通常是一个作用于算符的函数；在操作发生之前，bras和kets将被提升为密度矩阵，因为部分迹在纯态上本质上是未定义的。

对于当前在超算子形式中被表示为状态的运算符（即对象类型为operator-ket或operator-bra），部分迹的应用方式与运算符处于传统形式时相同。这意味着对于任何运算符x，operator_to_vector(x).ptrace(0) == operator_to_vector(x.ptrace(0))，对于operator-bra也是如此。

对于完整的超算子来说，情况有所不同。在QuTiP使用的形式中，如果一个算子的维度（dims）为[[2, 3], [2, 3]]，那么它可以表示为一个维度为[2, 3, 2, 3]的希尔伯特空间上的状态，而超算子则是作用在这个联合空间上的算子。这个函数通过在超算子上执行部分迹，让选定的组件引用联合空间的元素，然后返回一个常规算子（类型为oper）。

Parameters:

selint or iterable of int: 一个 int 或 list 用于在部分追踪后保留的组件。无论它们以何种顺序提供给 ptrace，所选的子空间都不会被重新排序。

Returns:

operQobj: 表示保留选定组件的部分迹的量子对象。

purity() → complex[source]

计算量子对象的纯度。

Returns:

state_purityfloat: 返回量子对象的纯度。对于纯态，纯度为1。对于维度为d的混合态，1/d<=纯度<1。

property shape: tuple[int, int]: 返回Qobj数据的形状。

sinm() → Qobj[source]

量子算子的正弦值。

操作符必须是方形的。

Returns:

operQobj: 操作符的矩阵正弦。

Raises:

TypeError: 量子对象不是方形的。

注释

使用 Q.expm() 方法。

sqrtm( sparse: bool = False, tol: float = 0, maxiter: int = 100000, ) → Qobj[source]

量子运算符的平方根。运算符必须是方阵。

Parameters:

sparsebool: 使用稀疏特征值/特征向量求解器。
tolfloat: 稀疏求解器使用的容差（0 = 机器精度）。
maxiterint: 稀疏求解器使用的最大迭代次数。

Returns:

operQobj: 操作符的矩阵平方根。

Raises:

TypeError: 量子对象不是方形的。

注释

稀疏特征求解器比密集版本慢得多。只有在内存需求要求时才使用稀疏版本。

tidyup(atol: float = None) → Qobj[source]

从量子对象中移除小元素。

Parameters:

atolfloat: tidyup使用的绝对容差。默认值通过qutip全局设置参数设置。

Returns:

operQobj: 移除了小元素的量子对象。

to(data_type: LayerType, copy: bool = False) → Qobj[source]

将此Qobj的基础数据存储转换为不同的存储表示形式。

可用的不同存储表示是“数据层类型”，这些类型对qutip.core.data.to是已知的。默认情况下，这些类型是CSR、Dense和Dia，它们分别构建压缩稀疏行矩阵、对角矩阵和密集矩阵。使用更合适的数据存储时，某些算法和操作可能会更快或更准确。

Parameters:

data_typetype, str: 数据层类型或其字符串别名，该数据应转换为Qobj。
copyBool: 如果数据存储已经是请求的格式，函数是否应该返回self或一个副本。

Returns:

Qobj: 一个Qobj，其数据以请求的格式存储。

tr() → complex[source]

量子对象的轨迹。

Returns:

tracefloat: 返回量子对象的迹。

trans() → Qobj[source]

获取量子算符的矩阵转置。

Returns:

operQobj: 输入运算符的转置。

transform(inpt: list[Qobj] | ArrayLike, inverse: bool = False) → Qobj[source]

由输入数组定义的基变换。

输入数组可以是一个定义变换的matrix，或者是一个定义新基的list的kets。

Parameters:

inptarray_like: 定义变换的matrix或list的kets。
inversebool: 是否返回逆变换。

Returns:

operQobj: 新基中的运算符。

注释

此功能仍在开发中。

trunc_neg( method: Literal['clip', 'sgs'] = 'clip', ) → Qobj[source]

截断负特征值并重新归一化。

通过移除该实例的负特征值，然后重新归一化以获得有效的密度算子，返回一个新的Qobj。

Parameters:

methodstr: 用于去除负特征值的算法。“clip”简单地丢弃负特征值，然后重新归一化。“sgs”使用SGS算法（doi:10/bb76）来找到在Shatten 2-范数中最接近的正算子。

Returns:

operQobj: 一个有效的密度算子。

unit( inplace: bool = False, norm: Literal['l2', 'max', 'fro', 'tr', 'one'] = None, kwargs: dict[str, Any] = None, ) → Qobj[source]

操作符或状态归一化为单位。使用来自 Qobj.norm() 的范数。

Parameters:

inplacebool: 进行就地归一化
normstr: 请求的状态/操作符的范数。
kwargsdict: 额外的关键字参数将被传递给相关的范数函数（详见 norm 以获取更多信息）。

Returns:

objQobj: 归一化的量子对象。如果是在原地操作，将会是self对象。

核心选项

class CoreOptions(**options)[source]

qutip核心使用的选项，例如Qobj比较的容差或系数的格式。

值可以在 qutip.settings.core 中更改，或者通过使用上下文来更改：

with CoreOptions(atol=1e-6): ...

选项:

auto_tidyupbool

是否在稀疏操作期间进行整理。

auto_tidyup_dimsbool [False]

在乘法、张量等操作上使用自动整理维度。没有 auto_tidyup_dims 时：

basis([2, 2]).dims == [[2, 2], [1, 1]]

使用 auto_tidyup_dims：

basis([2, 2]).dims == [[2, 2], [1]]

atolfloat {1e-12}

通用绝对容差。用于各种函数中以舍入小值。

rtolfloat {1e-12}

一般相对容差。

auto_tidyup_atolfloat {1e-14}

自动整理中使用的绝对容差（参见上面的auto_tidyup参数）以及Qobj.tidyup中使用的atol的默认值。

function_coefficient_stylestr {“auto”}

函数系数期望的签名。选项有：

“pythonic”：签名应该是 f(t, ...)，其中 t 是时间，... 是直接传递给函数的其余参数。例如 f(t, w, b=5)。
“dict”：签名应为 f(t, args)，其中 t 是时间，args 是一个包含剩余参数的字典。例如 f(t, {"w": w, "b": 5})。
“auto”：根据提供的函数签名自动在上述两个选项之间选择。如果函数签名恰好是f(t, args)，则使用dict。否则使用pythonic。

default_dtypeNonetype, str, type {None}

当设置时，创建Qobj的函数，例如 :func:”qeye” 或 :func:”rand_herm”，将使用指定的数据类型。qutip.data.to 已知的任何数据层都被接受。当 None 时，这些函数将默认使用合理的数据类型。

创建状态和操作符

量子态

basis( dimensions: SpaceLike, n: int | list[int] = None, offset: int | list[int] = None, *, dtype: LayerType = None, ) → Qobj[源代码]

生成Fock态的向量表示。

Parameters:

dimensionsint or list of ints, Space: 希尔伯特空间中的基态数量。如果是一个列表，那么结果对象将是这些维度空间上的张量积。
nint or list of ints, optional (default 0 for all dimensions): 对应于所需数字状态的整数，如果省略，则默认为所有维度为0。形状必须与dimensions匹配，例如，如果dimensions是一个列表，那么n必须被省略或是一个等长的列表。
offsetint or list of ints, optional (default 0 for all dimensions): 在相关维度的有限状态表示中包含的最低数字状态。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

stateQobj: 表示请求的数字状态的Qobj |n>。

注释

与量子光学工具箱的微妙不兼容性：在QuTiP中：

basis(N, 0) = ground state

但在qotoolbox中：

basis(N, 1) = ground state

示例

>>> basis(5,2) 
Quantum object: dims = [[5], [1]], shape = (5, 1), type = ket
Qobj data =
[[ 0.+0.j]
 [ 0.+0.j]
 [ 1.+0.j]
 [ 0.+0.j]
 [ 0.+0.j]]
>>> basis([2,2,2], [0,1,0]) 
Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = (8, 1), type = ket
Qobj data =
[[0.]
 [0.]
 [1.]
 [0.]
 [0.]
 [0.]
 [0.]
 [0.]]

bell_state( state: Literal['00', '01', '10', '11'] = '00', *, dtype: LayerType = None, ) → Qobj[source]

返回选定的贝尔状态：

\[\begin{split}\begin{aligned} \lvert B_{00}\rangle &= \frac1{\sqrt2}(\lvert00\rangle+\lvert11\rangle)\\ \lvert B_{01}\rangle &= \frac1{\sqrt2}(\lvert00\rangle-\lvert11\rangle)\\ \lvert B_{10}\rangle &= \frac1{\sqrt2}(\lvert01\rangle+\lvert10\rangle)\\ \lvert B_{11}\rangle &= \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)\\ \end{aligned}\end{split}\]

Parameters:

statestr [‘00’, ‘01’, ‘10’, ‘11’]: 返回哪个贝尔状态
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

Bell_stateqobj: 贝尔态

bra( seq: list[int | str] | str, dim: int | list[int] = 2, *, dtype: LayerType = None, ) → Qobj[source]

为列表或字符串生成一个多粒子bra状态，其中每个元素代表相应粒子的状态。

Parameters:

seqstr / list of ints or characters

每个元素定义了相应粒子的状态。（例如 [1,1,0,1] 或字符串“1101”）。对于量子比特，也可以使用以下约定：

‘g’/’e’（基态和激发态）
‘u’/’d’（自旋向上和向下）
‘H’/‘V’（水平和垂直极化）

注意：对于维度大于9的情况，您需要使用列表。

dimint (default: 2) / list of ints

每个粒子的空间维度：如果相同则为int，如果不同则为list。

dtypetype or str, optional

存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

braqobj

示例

>>> bra("10") 
Quantum object: dims = [[1, 1], [2, 2]], shape = [1, 4], type = bra
Qobj data =
[[ 0.  0.  1.  0.]]

>>> bra("Hue") 
Quantum object: dims = [[1, 1, 1], [2, 2, 2]], shape = [1, 8], type = bra
Qobj data =
[[ 0.  1.  0.  0.  0.  0.  0.  0.]]

>>> bra("12", 3) 
Quantum object: dims = [[1, 1], [3, 3]], shape = [1, 9], type = bra
Qobj data =
[[ 0.  0.  0.  0.  0.  1.  0.  0.  0.]]

>>> bra("31", [5, 2]) 
Quantum object: dims = [[1, 1], [5, 2]], shape = [1, 10], type = bra
Qobj data =
[[ 0.  0.  0.  0.  0.  0.  0.  1.  0.  0.]]

coherent( N: int, alpha: float, offset: int = 0, method: str = None, *, dtype: LayerType = None, ) → Qobj[source]

生成一个具有特征值alpha的相干态。

在真空态上使用位移算子构造。

Parameters:

Nint: 希尔伯特空间中的福克态数量。
alphafloat/complex: 相干态的特征值。
offsetint, default: 0: 包含在状态有限数状态表示中的最低数状态。使用非零偏移将使默认方法为‘analytic’。
methodstring {‘operator’, ‘analytic’}, optional: 生成相干态的方法。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

stateqobj: 用于相干态的Qobj量子对象

注释

选择方法‘operator’（默认）或‘analytic’。使用‘operator’方法时，相干态是通过在大小为‘N’的截断希尔伯特空间中使用位移算子位移真空态生成的。此方法保证生成的状态是归一化的。使用‘analytic’方法时，相干态是通过在Fock基中使用相干态系数的解析公式生成的。如果截断到少量的Fock态，此方法不保证状态是归一化的，但在这种情况下会给出更准确的系数。

示例

>>> coherent(5,0.25j) 
Quantum object: dims = [[5], [1]], shape = [5, 1], type = ket
Qobj data =
[[  9.69233235e-01+0.j        ]
 [  0.00000000e+00+0.24230831j]
 [ -4.28344935e-02+0.j        ]
 [  0.00000000e+00-0.00618204j]
 [  7.80904967e-04+0.j        ]]

coherent_dm( N: int, alpha: float, offset: int = 0, method: str = None, *, dtype: LayerType = None, ) → Qobj[source]

相干态的密度矩阵表示。

通过coherent的外积构建

Parameters:

Nint: 希尔伯特空间中的基态数量。
alphafloat/complex: 相干态的特征值。
offsetint, default: 0: 包含在状态的有限数量状态表示中的最低数字状态。
methodstring {‘operator’, ‘analytic’}, optional: 生成相干密度矩阵的方法。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

dmqobj: 相干态的密度矩阵表示。

注释

选择方法‘operator’（默认）或‘analytic’。使用‘operator’方法时，相干密度矩阵通过在大小为‘N’的截断希尔伯特空间中使用位移算子位移真空态生成。此方法保证生成的密度矩阵是归一化的。使用‘analytic’方法时，相干密度矩阵使用Fock基中相干态系数的解析公式生成。如果截断到少量Fock态，此方法不保证状态是归一化的，但在这种情况下会给出更准确的系数。

示例

>>> coherent_dm(3,0.25j) 
Quantum object: dims = [[3], [3]], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 0.93941695+0.j          0.00000000-0.23480733j -0.04216943+0.j        ]
 [ 0.00000000+0.23480733j  0.05869011+0.j          0.00000000-0.01054025j]
 [-0.04216943+0.j          0.00000000+0.01054025j  0.00189294+0.j        ]]

fock( dimensions: SpaceLike, n: int | list[int] = None, offset: int | list[int] = None, *, dtype: LayerType = None, ) → Qobj[source]

玻色福克（数）态。

与 basis 相同。

Parameters:

dimensionsint or list of ints, Space: 希尔伯特空间中的基态数量。如果是一个列表，那么结果对象将是这些维度空间上的张量积。
nint or list of ints, default: 0 for all dimensions: 对应于所需数字状态的整数，如果省略，则默认为所有维度为0。形状必须与dimensions匹配，例如，如果dimensions是一个列表，那么n必须被省略或是一个等长的列表。
offsetint or list of ints, default: 0 for all dimensions: 在相关维度的有限状态表示中包含的最低数字状态。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

Requested number state \(\left|n\right>\).

示例

>>> fock(4,3) 
Quantum object: dims = [[4], [1]], shape = [4, 1], type = ket
Qobj data =
[[ 0.+0.j]
 [ 0.+0.j]
 [ 0.+0.j]
 [ 1.+0.j]]

fock_dm( dimensions: int | list[int] | Space, n: int | list[int] = None, offset: int | list[int] = None, *, dtype: LayerType = None, ) → Qobj[source]

Fock态的密度矩阵表示

通过basis的外积构造。

Parameters:

dimensionsint or list of ints, Space: 希尔伯特空间中的基态数量。如果是一个列表，那么结果对象将是这些维度空间上的张量积。
nint or list of ints, default: 0 for all dimensions: 对应于所需数字状态的整数，如果省略，则默认为所有维度为0。形状必须与dimensions匹配，例如，如果dimensions是一个列表，那么n必须被省略或是一个等长的列表。
offsetint or list of ints, default: 0 for all dimensions: 在相关维度的有限状态表示中包含的最低数字状态。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

dmqobj: Fock态的密度矩阵表示。

示例

>>> fock_dm(3,1) 
Quantum object: dims = [[3], [3]], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 0.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j  1.+0.j  0.+0.j]
 [ 0.+0.j  0.+0.j  0.+0.j]]

ghz_state(N_qubit: int, *, dtype: LayerType = None) → Qobj[source]

Returns the N-qubit GHZ-state:: [ |00...00> + |11...11> ] / sqrt(2)

Parameters:

N_qubitint: 状态中的量子比特数
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

Gqobj: N量子比特GHZ态

ket( seq: list[int | str] | str, dim: int | list[int] = 2, *, dtype: LayerType = None, ) → Qobj[source]

为列表或字符串生成多粒子ket状态，其中每个元素代表相应粒子的状态。

Parameters:

seqstr / list of ints or characters: 每个元素定义了相应粒子的状态。（例如 [1,1,0,1] 或字符串“1101”）。对于量子比特，也可以使用以下约定： - ‘g’/’e’（基态和激发态） - ‘u’/’d’（自旋向上和向下） - ‘H’/’V’（水平和垂直极化）注意：对于维度大于9的情况，您需要使用列表。
dimint or list of ints, default: 2: 每个粒子的空间维度：如果相同则为int，如果不同则为list。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

ketqobj

示例

>>> ket("10") 
Quantum object: dims = [[2, 2], [1, 1]], shape = [4, 1], type = ket
Qobj data =
[[ 0.]
 [ 0.]
 [ 1.]
 [ 0.]]

>>> ket("Hue") 
Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
Qobj data =
[[ 0.]
 [ 1.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 0.]]

>>> ket("12", 3) 
Quantum object: dims = [[3, 3], [1, 1]], shape = [9, 1], type = ket
Qobj data =
[[ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 1.]
 [ 0.]
 [ 0.]
 [ 0.]]

>>> ket("31", [5, 2]) 
Quantum object: dims = [[5, 2], [1, 1]], shape = [10, 1], type = ket
Qobj data =
[[ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 1.]
 [ 0.]
 [ 0.]]

ket2dm(Q: Qobj) → Qobj[source]

接受输入的ket或bra向量并返回由外积形成的密度矩阵。这与调用Q.proj()完全相同。

Parameters:

QQobj: Ket 或 bra 类型的量子对象。

Returns:

dmQobj: 由Q的外积形成的密度矩阵。

示例

>>> x=basis(3,2)
>>> ket2dm(x) 
Quantum object: dims = [[3], [3]], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 0.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j  0.+0.j  1.+0.j]]

maximally_mixed_dm( dimensions: SpaceLike, *, dtype: LayerType = None, ) → Qobj[source]

返回维度为N的希尔伯特空间的最大混合密度矩阵。

Parameters:

dimensionsint or list of ints, Space: 希尔伯特空间中的基态数量。如果是一个列表，那么结果对象将是这些维度空间上的张量积。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

dmQobj: 热态密度矩阵。

phase_basis( N: int, m: int, phi0: float = 0, *, dtype: LayerType = None, ) → Qobj[source]

Pegg-Barnett 相位算符的第 m 个相位的基础向量。

Parameters:

Nint: 希尔伯特空间中的基态数量。
mint: 对应于第m个离散相位的整数 phi_m = phi0 + 2 * pi * m / N
phi0float, default: 0: 参考相位角。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

stateqobj: 第m个Pegg-Barnett相位算子基态的Ket向量。

注释

Pegg-Barnett基态在截断的希尔伯特空间上形成一个完整的集合。

projection( dimensions: int | list[int], n: int | list[int], m: int | list[int], offset: int | list[int] = None, *, dtype: LayerType = None, ) → Qobj[source]

投影操作符将状态 \(\lvert m\rangle\) 投影到状态 \(\lvert n\rangle\)。

Parameters:

dimensionsint or list of ints, Space: 希尔伯特空间中的基态数量。如果是一个列表，那么结果对象将是这些维度空间上的张量积。
n, mint: 投影中的状态数量。
offsetint, default: 0: 投影仪有限数量状态表示中包含的最低数字状态。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 请求的投影操作符。

qutrit_basis(*, dtype: LayerType = None) → list[Qobj][source]

三能级系统（qutrit）的基础状态

dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

qstatesarray: qutrit基向量的数组

singlet_state(*, dtype: LayerType = None) → Qobj[source]

返回两个粒子的单态：

\[\lvert S\rangle = \frac1{\sqrt2}(\lvert01\rangle-\lvert10\rangle)\]

这与第四个贝尔态相同。

Parameters:

dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

Bell_stateqobj: \(\lvert B_{11}\rangle\) 贝尔态

spin_coherent( j: float, theta: float, phi: float, type: Literal['ket', 'bra', 'dm'] = 'ket', *, dtype: LayerType = None, ) → Qobj[source]

生成相干自旋态 \(\lvert \theta, \phi\rangle\)。

Parameters:

jfloat: 状态的自旋。
thetafloat: 从z轴的角度。
phifloat: 从x轴的角度。
typestring {‘ket’, ‘bra’, ‘dm’}, default: ‘ket’: 生成的状态类型。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

stateqobj: 用于自旋相干态的Qobj量子对象

spin_state( j: float, m: float, type: Literal['ket', 'bra', 'dm'] = 'ket', *, dtype: LayerType = None, ) → Qobj[source]

生成自旋状态 \(\lvert j, m\rangle\)，即自旋-j Sz 算符的特征值为 m 的特征态。

Parameters:

jfloat: 状态的自旋 ()。
mfloat: 自旋-j Sz算符的特征值。
typestring {‘ket’, ‘bra’, ‘dm’}, default: ‘ket’: 生成的状态类型。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

stateqobj: 用于自旋状态的Qobj量子对象

state_index_number(dims: list[int], index: int) → tuple[source]

返回给定状态索引的量子数表示，适用于由dims定义的复合结构系统。

示例

>>> state_index_number([2, 2, 2], 6)
[1, 1, 0]

Parameters:

dimslist or array: 量子状态维度数组，如其在Qobj中的显示。
indexinteger: 状态在标准枚举排序中的索引。

Returns:

statetuple: 标准枚举顺序中对应于索引index的状态编号元组。

state_number_enumerate( dims: list[int], excitations: int = None, ) → Iterator[tuple][source]

一个迭代器，用于枚举由dims给出的系统维度的所有状态数元组（形式为(n1, n2, n3, …)的量子数）。

示例

>>> for state in state_number_enumerate([2,2]): 
>>>     print(state) 
( 0  0 )
( 0  1 )
( 1  0 )
( 1  1 )

Parameters:

dimslist: 量子状态维度数组，如其在Qobj中的显示。
excitationsinteger, optional: 将状态空间限制为激发数低于或等于此值的状态。

Returns:

state_numbertuple: 可以在循环和其他迭代中使用的连续状态编号元组，使用根据定义的标准状态枚举。

state_number_index(dims: list[int], state: list[int]) → int[source]

返回与状态对应的量子态的索引，给定一个由dims指定维度的系统。

示例

>>> state_number_index([2, 2, 2], [1, 1, 0])
6

Parameters:

dimslist: 量子状态维度数组，如其在Qobj中的显示。
statelist: 状态编号数组。

Returns:

idxint: 由state给出的状态在标准枚举顺序中的索引。

state_number_qobj( dims: SpaceLike, state: int | list[int] = None, *, dtype: LayerType = None, ) → Qobj[source]

返回由状态数组 state 指定的量子状态的 Qobj 表示。

注意

在 QuTiP 5.0 中已弃用，请改用 basis。

示例

>>> state_number_qobj([2, 2, 2], [1, 0, 1]) 
Quantum object: dims = [[2, 2, 2], [1, 1, 1]], shape = [8, 1], type = ket
Qobj data =
[[ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 0.]
 [ 1.]
 [ 0.]
 [ 0.]]

Parameters:

dimslist or array: 量子状态维度数组，如其在Qobj中的显示。
statelist: 状态编号数组。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

stateQobj: 状态作为一个 Qobj 实例。

thermal_dm( N: int, n: float, method: Literal['operator', 'analytic'] = 'operator', *, dtype: LayerType = None, ) → Qobj[source]

n粒子热态的密度矩阵

Parameters:

Nint: 希尔伯特空间中的基态数量。
nfloat: 热态粒子数的期望值。
methodstring {‘operator’, ‘analytic’}, default: ‘operator’: string 用于设置生成热态概率的方法
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

dmqobj: 热态密度矩阵。

注释

'operator' 方法（默认）使用截断的数字运算符 num(N) 生成热态。这是在计算中应使用的方法。'analytic' 方法使用在无限希尔伯特空间中导出的解析系数。如果截断过于激进，解析形式不一定归一化。

示例

>>> thermal_dm(5, 1) 
Quantum object: dims = [[5], [5]], shape = [5, 5], type = oper, isHerm = True
Qobj data =
[[ 0.51612903  0.          0.          0.          0.        ]
 [ 0.          0.25806452  0.          0.          0.        ]
 [ 0.          0.          0.12903226  0.          0.        ]
 [ 0.          0.          0.          0.06451613  0.        ]
 [ 0.          0.          0.          0.          0.03225806]]

>>> thermal_dm(5, 1, 'analytic') 
Quantum object: dims = [[5], [5]], shape = [5, 5], type = oper, isHerm = True
Qobj data =
[[ 0.5      0.       0.       0.       0.     ]
 [ 0.       0.25     0.       0.       0.     ]
 [ 0.       0.       0.125    0.       0.     ]
 [ 0.       0.       0.       0.0625   0.     ]
 [ 0.       0.       0.       0.       0.03125]]

triplet_states(*, dtype: LayerType = None) → list[Qobj][source]

返回两个粒子的三重态列表：

\[\lvert T_1\rangle = \lvert11\rangle \lvert T_2\rangle = \frac1{\sqrt2}(\lvert01\rangle + \lvert10\rangle) \lvert T_3\rangle = \lvert00\rangle\]

Parameters:

dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

trip_stateslist: 2粒子三重态

w_state(N_qubit: int, *, dtype: LayerType = None) → Qobj[source]

Returns the N-qubit W-state:: [ |100..0> + |010..0> + |001..0> + ... |000..1> ] / sqrt(n)

Parameters:

N_qubitint: 状态中的量子比特数
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

WQobj: N量子比特W态

zero_ket( dimensions: SpaceLike, *, dtype: LayerType = None, ) → Qobj[source]

创建形状为Nx1且维度为dims的零ket向量。

Parameters:

dimensionsint or list of ints, Space: 希尔伯特空间中的基态数量。如果是一个列表，那么结果对象将是这些维度空间上的张量积。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

zero_ketqobj: 在给定的希尔伯特空间上的零态。

量子运算符

该模块包含用于生成各种常见量子算符的Qobj表示的函数。

charge( Nmax: int, Nmin: int = None, frac: float = 1, *, dtype: LayerType = None, ) → Qobj[source]

生成从Nmin到Nmax的电荷状态上的对角电荷算子。

Parameters:

Nmaxint: 要考虑的最大充电状态。
Nminint, default: -Nmax: 考虑的最低电荷状态。
fracfloat, default: 1: 如果需要，请指定分数电荷。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

CQobj: 在 [Nmin, Nmax] 上操作收费。

注释

在版本3.2中添加。

commutator( A: Qobj, B: Qobj, kind: Literal['normal', 'anti'] = 'normal', ) → Qobj[source]

返回两个运算符 A 和 B 的 kind 类型（正常、反对）的对易子。

Parameters:

A, BQobj, QobjEvo: 用于计算对易子的运算符。
kind: str {“normal”, “anti”}, default: “anti”: 计算哪种类型的交换器。

create( N: int, offset: int = 0, *, dtype: LayerType = None, ) → Qobj[source]

创建（提升）操作符。

Parameters:

Nint: 希尔伯特空间中的基态数量。
offsetint, default: 0: 操作符的有限数状态表示中包含的最低数状态。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 用于提升运算符的Qobj。

示例

>>> create(4) 
Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
Qobj data =
[[ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
 [ 1.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
 [ 0.00000000+0.j  1.41421356+0.j  0.00000000+0.j  0.00000000+0.j]
 [ 0.00000000+0.j  0.00000000+0.j  1.73205081+0.j  0.00000000+0.j]]

destroy( N: int, offset: int = 0, *, dtype: LayerType = None, ) → Qobj[source]

破坏（降低）操作符。

Parameters:

Nint: 希尔伯特空间中的基态数量。
offsetint, default: 0: 操作符的有限数状态表示中包含的最低数状态。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 用于降低运算符的Qobj。

示例

>>> destroy(4) 
Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=False
Qobj data =
[[ 0.00000000+0.j  1.00000000+0.j  0.00000000+0.j  0.00000000+0.j]
 [ 0.00000000+0.j  0.00000000+0.j  1.41421356+0.j  0.00000000+0.j]
 [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  1.73205081+0.j]
 [ 0.00000000+0.j  0.00000000+0.j  0.00000000+0.j  0.00000000+0.j]]

displace( N: int, alpha: float, offset: int = 0, *, dtype: LayerType = None, ) → Qobj[source]

单模位移算子。

Parameters:

Nint: 希尔伯特空间中的基态数量。
alphafloat/complex: 位移幅度。
offsetint, default: 0: 操作符的有限数状态表示中包含的最低数状态。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 位移操作符。

示例

>>> displace(4,0.25) 
Quantum object: dims = [[4], [4]], shape = [4, 4], type = oper, isHerm = False
Qobj data =
[[ 0.96923323+0.j -0.24230859+0.j  0.04282883+0.j -0.00626025+0.j]
 [ 0.24230859+0.j  0.90866411+0.j -0.33183303+0.j  0.07418172+0.j]
 [ 0.04282883+0.j  0.33183303+0.j  0.84809499+0.j -0.41083747+0.j]
 [ 0.00626025+0.j  0.07418172+0.j  0.41083747+0.j  0.90866411+0.j]]

fcreate(n_sites: int, site, dtype: LayerType = None) → Qobj[source]

费米子产生算符。我们使用Jordan-Wigner变换，利用Jordan-Wigner ZZ..Z字符串，按如下方式构造：

\[a_j = \sigma_z^{\otimes j} \otimes (\frac{\sigma_x - i \sigma_y}{2}) \otimes I^{\otimes N-j-1}\]

Parameters:

n_sitesint: Fock空间中的站点数量。
siteint: 在Fock空间中添加一个费米子的位置。对应于上述JW变换中的j。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 用于提升运算符的Qobj。

示例

>>> fcreate(2) 
Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4),     type = oper, isherm = False
Qobj data =
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[1. 0. 0. 0.]
[0. 1. 0. 0.]]

fdestroy(n_sites: int, site, dtype: LayerType = None) → Qobj[source]

费米子湮灭算符。我们使用Jordan-Wigner变换，利用Jordan-Wigner ZZ..Z字符串，按如下方式构造：

\[a_j = \sigma_z^{\otimes j} \otimes (\frac{\sigma_x + i \sigma_y}{2}) \otimes I^{\otimes N-j-1}\]

Parameters:

n_sitesint: Fock空间中的站点数量。
siteint: 在Fock空间中添加一个费米子的位置。对应于上述JW变换中的j。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 用于销毁运算符的Qobj。

示例

>>> fdestroy(2) 
Quantum object: dims=[[2 2], [2 2]], shape=(4, 4),     type='oper', isherm=False
Qobj data =
[[0. 0. 1. 0.]
[0. 0. 0. 1.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]

identity( dimensions: SpaceLike, *, dtype: LayerType = None, ) → Qobj

身份运算符。

Parameters:

dimensions(int) or (list of int) or (list of list of int), Space: 希尔伯特空间中的基态数量。如果提供为整数列表，则维度是该列表的乘积，但新Qobj的dims属性将设置为该列表。根据传递的dimensions，可以生成oper或super。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 身份运算符 Qobj。

示例

>>> qeye(3) 
Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, isherm = True
Qobj data =
[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]
>>> qeye([2,2]) 
Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, isherm = True
Qobj data =
[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]

jmat( j: float, which: Literal[None], *, dtype: LayerType = None, ) → tuple[Qobj][source]

jmat( j: float, which: Literal['x', 'y', 'z', '+', '-'], *, dtype: LayerType = None, ) → Qobj

高阶自旋算子：

Parameters:

jfloat: 操作符的自旋
whichstr, optional: 返回哪个操作符‘x’,’y’,’z’,’+’,’-‘。如果未给出，则输出为[‘x’,’y’,’z’]
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

jmatQobj or tuple of Qobj: qobj 用于请求的自旋运算符。

示例

>>> jmat(1) 
[ Quantum object: dims = [[3], [3]], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 0.          0.70710678  0.        ]
 [ 0.70710678  0.          0.70710678]
 [ 0.          0.70710678  0.        ]]
 Quantum object: dims = [[3], [3]], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 0.+0.j          0.-0.70710678j  0.+0.j        ]
 [ 0.+0.70710678j  0.+0.j          0.-0.70710678j]
 [ 0.+0.j          0.+0.70710678j  0.+0.j        ]]
 Quantum object: dims = [[3], [3]], shape = [3, 3], type = oper, isHerm = True
Qobj data =
[[ 1.  0.  0.]
 [ 0.  0.  0.]
 [ 0.  0. -1.]]]

momentum( N: int, offset: int = 0, *, dtype: LayerType = None, ) → Qobj[source]

动量算子 p=-1j/sqrt(2)*(a-a.dag())

Parameters:

Nint: 希尔伯特空间中的基态数量。
offsetint, default: 0: 操作符的有限数状态表示中包含的最低数状态。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 动量算子作为Qobj。

num( N: int, offset: int = 0, *, dtype: LayerType = None, ) → Qobj[source]

量子对象的数量运算符。

Parameters:

Nint: 希尔伯特空间中的基态数量。
offsetint, default: 0: 操作符的有限数状态表示中包含的最低数状态。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

oper: qobj: 用于数字运算符的Qobj。

示例

>>> num(4) 
Quantum object: dims=[[4], [4]], shape=(4, 4), type='oper', isherm=True
Qobj data =
[[0 0 0 0]
 [0 1 0 0]
 [0 0 2 0]
 [0 0 0 3]]

phase( N: int, phi0: float = 0, *, dtype: LayerType = None, ) → Qobj[source]

单模Pegg-Barnett相位算子。

Parameters:

Nint: 希尔伯特空间中的基态数量。
phi0float, default: 0: 参考阶段。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 相对于参考相位的相位运算符。

注释

Pegg-Barnett 相位算子在截断的希尔伯特空间上是厄米的。

position( N: int, offset: int = 0, *, dtype: LayerType = None, ) → Qobj[source]

位置运算符 \(x = 1 / sqrt(2) * (a + a.dag())\)

Parameters:

Nint: 希尔伯特空间中的基态数量。
offsetint, default: 0: 操作符的有限数状态表示中包含的最低数状态。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 位置运算符作为 Qobj。

从对角线的数组构造一个操作符。

Parameters:

diagonalsarray_like or sequence of array_like

要沿选定对角线放置的元素数组。

offsetsint or sequence of ints, optional

Sequence for diagonals to be set:

k=0 主对角线
k>0 第k个上对角线
k<0 第k条下对角线

dimslist, optional

操作符的维度

shapelist, tuple, optional

操作符的形状。如果省略，将生成一个足够大的正方形操作符以包含对角线。

dtypetype or str, optional

存储表示。任何qutip.data.to已知的数据层都被接受。

示例

>>> qdiags(sqrt(range(1, 4)), 1) 
Quantum object: dims = [[4], [4]], shape = [4, 4], type = oper, isherm = False
Qobj data =
[[ 0.          1.          0.          0.        ]
 [ 0.          0.          1.41421356  0.        ]
 [ 0.          0.          0.          1.73205081]
 [ 0.          0.          0.          0.        ]]

qeye(dimensions: SpaceLike, *, dtype: LayerType = None) → Qobj[source]

身份运算符。

Parameters:

dimensions(int) or (list of int) or (list of list of int), Space: 希尔伯特空间中的基态数量。如果提供为整数列表，则维度是该列表的乘积，但新Qobj的dims属性将设置为该列表。根据传递的dimensions，可以生成oper或super。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 身份运算符 Qobj。

示例

>>> qeye(3) 
Quantum object: dims = [[3], [3]], shape = (3, 3), type = oper, isherm = True
Qobj data =
[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]
>>> qeye([2,2]) 
Quantum object: dims = [[2, 2], [2, 2]], shape = (4, 4), type = oper, isherm = True
Qobj data =
[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]

qeye_like(qobj: Qobj) → Qobj[源代码]

与参考量子对象具有相同维度和类型的恒等运算符。

Parameters:

qobjQobj, QobjEvo: 参考量子对象以复制维度。

Returns:

operqobj: 身份运算符 Qobj。

qutrit_ops(*, dtype: LayerType = None) → list[Qobj][source]

三能级系统（qutrit）的运算符。

Parameters:

dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

opers: array: array 的 qutrit 操作符。

qzero( dimensions: SpaceLike, dims_right: SpaceLike = None, *, dtype: LayerType = None, ) → Qobj[source]

零操作符。

Parameters:

dimensionsint, list of int, list of list of int, Space: 希尔伯特空间中的基态数量。如果提供为整数列表，则维度是该列表的乘积，但新Qobj的dims属性将设置为该列表。根据传递的dimensions，可以生成oper或super。
dims_rightint, list of int, list of list of int, Space, optional: 当操作符为矩形时，右侧希尔伯特空间中的基态数量。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

qzeroqobj: 零操作符 Qobj。

qzero_like(qobj: Qobj) → Qobj[source]

与参考相同维度和类型的零操作符。

Parameters:

qobjQobj, QobjEvo: 参考量子对象以复制维度。

Returns:

qzeroqobj: 零操作符 Qobj。

sigmam(*, dtype: LayerType = None) → Qobj[源代码]

Pauli自旋的湮灭算子。

Parameters:

dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

示例

>>> sigmam() 
Quantum object: dims = [[2], [2]], shape = [2, 2], type = oper, isHerm = False
Qobj data =
[[ 0.  0.]
 [ 1.  0.]]

sigmap(*, dtype: LayerType = None) → Qobj[source]

泡利自旋的创建操作符。

Parameters:

dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

示例

>>> sigmap() 
Quantum object: dims = [[2], [2]], shape = [2, 2], type = oper, isHerm = False
Qobj data =
[[ 0.  1.]
 [ 0.  0.]]

sigmax(*, dtype: LayerType = None) → Qobj[source]

泡利自旋1/2 sigma-x 算子

Parameters:

dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

示例

>>> sigmax() 
Quantum object: dims = [[2], [2]], shape = [2, 2], type = oper, isHerm = False
Qobj data =
[[ 0.  1.]
 [ 1.  0.]]

sigmay(*, dtype: LayerType = None) → Qobj[source]

泡利自旋1/2 sigma-y算子。

Parameters:

dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

示例

>>> sigmay() 
Quantum object: dims = [[2], [2]], shape = [2, 2], type = oper, isHerm = True
Qobj data =
[[ 0.+0.j  0.-1.j]
 [ 0.+1.j  0.+0.j]]

sigmaz(*, dtype: LayerType = None) → Qobj[源代码]

泡利自旋1/2 sigma-z 算子。

Parameters:

dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

示例

>>> sigmaz() 
Quantum object: dims = [[2], [2]], shape = [2, 2], type = oper, isHerm = True
Qobj data =
[[ 1.  0.]
 [ 0. -1.]]

spin_Jm(j: float, *, dtype: LayerType = None) → Qobj[source]

自旋-j 湮灭算符

Parameters:

jfloat: 操作符的自旋
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

opQobj: qobj 操作符的表示。

spin_Jp(j: float, *, dtype: LayerType = None) → Qobj[source]

自旋-j 创建算子

Parameters:

jfloat: 操作符的自旋
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

opQobj: qobj 操作符的表示。

spin_Jx(j: float, *, dtype: LayerType = None) → Qobj[source]

自旋-j x 算子

Parameters:

jfloat: 操作符的自旋
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

opQobj: qobj 表示的操作符。

spin_Jy(j: float, *, dtype: LayerType = None) → Qobj[source]

自旋-j y 算子

Parameters:

jfloat: 操作符的自旋
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

opQobj: qobj 表示的操作符。

spin_Jz(j: float, *, dtype: LayerType = None) → Qobj[source]

自旋-j z 算子

Parameters:

jfloat: 操作符的自旋
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

opQobj: qobj 操作符的表示。

squeeze( N: int, z: float, offset: int = 0, *, dtype: LayerType = None, ) → Qobj[source]

单模压缩算子。

Parameters:

Nint: 希尔伯特空间的维度。
zfloat/complex: 压缩参数。
offsetint, default: 0: 操作符的有限数状态表示中包含的最低数状态。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operQobj: 压缩操作符。

示例

>>> squeeze(4, 0.25) 
Quantum object: dims = [[4], [4]], shape = [4, 4], type = oper, isHerm = False
Qobj data =
[[ 0.98441565+0.j  0.00000000+0.j  0.17585742+0.j  0.00000000+0.j]
 [ 0.00000000+0.j  0.95349007+0.j  0.00000000+0.j  0.30142443+0.j]
 [-0.17585742+0.j  0.00000000+0.j  0.98441565+0.j  0.00000000+0.j]
 [ 0.00000000+0.j -0.30142443+0.j  0.00000000+0.j  0.95349007+0.j]]

squeezing( a1: Qobj, a2: Qobj, z: float, ) → Qobj[source]

广义压缩算子。

\[S(z) = \exp\left(\frac{1}{2}\left(z^*a_1a_2 - za_1^\dagger a_2^\dagger\right)\right)\]

Parameters:

a1Qobj: 操作符 1.
a2Qobj: 操作符 2。
zfloat/complex: 压缩参数。

Returns:

operQobj: 压缩操作符。

tunneling( N: int, m: int = 1, *, dtype: LayerType = None, ) → Qobj[source]

隧道操作符，其元素形式为 \(\\sum |N>。

Parameters:

Nint: 希尔伯特空间中的基态数量。
mint, default: 1: 隧道事件中的激发数量。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

TQobj: 隧道操作符。

量子门

berkeley(*, dtype: LayerType = None) → Qobj[source]

表示伯克利门的量子对象。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

berkeley_gateqobj: 伯克利门的量子对象表示

cnot(*, dtype: LayerType = None) → Qobj[source]

表示CNOT门的量子对象。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

cnot_gateqobj: CNOT门的量子对象表示

cphase(theta: float, *, dtype: LayerType = None) → Qobj[source]

返回表示受控相位位移门的量子对象。

Parameters:

thetafloat: 相位旋转角度。
dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

Uqobj: 受控相位门的量子对象表示。

cs_gate(*, dtype: LayerType = None) → Qobj[源代码]

受控S门。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

resultQobj: 描述旋转的算子的量子对象。

csign(*, dtype: LayerType = None) → Qobj[source]

表示CSIGN门的量子对象。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

csign_gateqobj: CSIGN门的量子对象表示

ct_gate(*, dtype: LayerType = None) → Qobj[source]

受控T门。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

resultQobj: 描述旋转的算子的量子对象。

cy_gate(*, dtype: LayerType = None) → Qobj[source]

受控Y门。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

resultQobj: 描述旋转的算子的量子对象。

cz_gate(*, dtype: LayerType = None) → Qobj[source]

受控Z门。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

resultQobj: 描述旋转的算子的量子对象。

fredkin(*, dtype: LayerType = None) → Qobj[source]

表示Fredkin门的量子对象。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

fredkin_gateqobj: Fredkin门的量子对象表示。

globalphase( theta: float, N: int = 1, *, dtype: LayerType = None, ) → Qobj[source]

返回表示全局相移门的量子对象。

Parameters:

thetafloat: 相位旋转角度。
Nint:: 量子比特数量
dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

phase_gateqobj: 全局相移门的量子对象表示。

hadamard_transform( N: int = 1, *, dtype: LayerType = None, ) → Qobj[source]

表示N量子比特Hadamard门的量子对象。

Parameters:

Nint:: 量子比特数量
dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

qqobj: N量子比特Hadamard门的量子对象表示。

iswap(*, dtype: LayerType = None) → Qobj[源代码]

表示iSWAP门的量子对象。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

iswap_gateqobj: iSWAP门的量子对象表示

molmer_sorensen( theta: float, *, dtype: LayerType = None, ) → Qobj[源代码]

Mølmer–Sørensen门的量子对象。

Parameters:

theta: float: 交互脉冲的持续时间。
target: int: 目标量子位的索引。
dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

molmer_sorensen_gate: Qobj: Mølmer–Sørensen门的量子对象表示。

phasegate(theta: float, *, dtype: LayerType = None) → Qobj[source]

返回表示相移门的量子对象。

Parameters:

thetafloat: 相位旋转角度。
dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

phase_gateqobj: 相移门的量子对象表示。

qrot( theta: float, phi: float, *, dtype: LayerType = None, ) → Qobj[source]

由拉比振荡驱动的单量子比特旋转，无失谐。

Parameters:

phifloat: 拉比脉冲的初始阶段。
thetafloat: 拉比脉冲的持续时间。
dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

qrot_gateQobj: 物理量子比特在拉比脉冲下的旋转的量子对象表示。

qubit_clifford_group(*, dtype: LayerType = None) → list[Qobj][源代码]

生成单量子比特上的Clifford群，使用Ross和Selinger给出的群表示法 (http://www.mathstat.dal.ca/~selinger/newsynth/)。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

oplist of Qobj: Clifford 操作符，表示为 Qobj 实例。

rx(phi: float, *, dtype: LayerType = None) → Qobj[source]

对操作符 sigmax 进行角度为 phi 的单量子比特旋转。

Parameters:

phifloat: 旋转角度
dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

resultqobj: 描述旋转的算子的量子对象。

ry(phi: float, *, dtype: LayerType = None) → Qobj[源代码]

对操作符 sigmay 进行角度为 phi 的单量子比特旋转。

Parameters:

phifloat: 旋转角度
dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

resultqobj: 描述旋转的算子的量子对象。

rz(phi: float, *, dtype: LayerType = None) → Qobj[source]

对操作符sigmaz进行角度为phi的单量子比特旋转。

Parameters:

phifloat: 旋转角度
dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

resultqobj: 描述旋转的算子的量子对象。

s_gate(*, dtype: LayerType = None) → Qobj[source]

单量子比特旋转，也称为相位门或Z90门。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

resultQobj: 描述围绕z轴90度旋转的算子的量子对象。

snot(*, dtype: LayerType = None) → Qobj[source]

表示SNOT（Hadamard）门的量子对象。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

snot_gateqobj: SNOT门的量子对象表示。

sqrtiswap(*, dtype: LayerType = None) → Qobj[source]

表示平方根iSWAP门的量子对象。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

sqrtiswap_gateqobj: 平方根iSWAP门的量子对象表示

sqrtnot(*, dtype: LayerType = None) → Qobj[source]

单量子比特平方根非门。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

resultqobj: 描述平方根NOT门的量子对象。

sqrtswap(*, dtype: LayerType = None) → Qobj[source]

表示平方根SWAP门的量子对象。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

sqrtswap_gateqobj: 平方根SWAP门的量子对象表示

swap(*, dtype: LayerType = None) → Qobj[source]

表示SWAP门的量子对象。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

swap_gateqobj: SWAP门的量子对象表示

swapalpha(alpha: float, *, dtype: LayerType = None) → Qobj[source]

表示SWAPalpha门的量子对象。

Parameters:

alphafloat: SWAPalpha 门的角度。
dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

swapalpha_gateqobj: SWAPalpha门的量子对象表示

t_gate(*, dtype: LayerType = None) → Qobj[source]

与S门相关的单量子比特旋转，关系为S=T*T。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

resultQobj: 描述π/4相位偏移的算子的量子对象。

toffoli(*, dtype: LayerType = None) → Qobj[source]

表示托佛利门的量子对象。

Parameters:

dtypestr or type, [keyword only] [optional]: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

toff_gateqobj: Toffoli门的量子对象表示。

能量受限操作符

enr_destroy(dims, excitations, *, dtype=None)[源代码]

为激发数受限的状态空间中的模式生成湮灭算子。例如，考虑一个由4个模式组成的系统，每个模式有5个状态。总的希尔伯特空间大小为5**4 = 625。如果我们只对包含最多2个激发的状态感兴趣，我们只需要包括如下状态：

(0, 0, 0, 0) (0, 0, 0, 1) (0, 0, 0, 2) (0, 0, 1, 0) (0, 0, 1, 1) (0, 0, 2, 0) …

此函数创建了在此状态空间内作用的4种模式的湮灭算子：

a1, a2, a3, a4 = enr_destroy([5, 5, 5, 5], excitations=2)

从这一点开始，湮灭算符 a1, …, a4 可以按照通常的模式用于设置哈密顿量、坍缩算符和期望值算符等。

Parameters:

dimslist: 复合量子系统每个子系统的维度列表。
excitationsinteger: 状态空间中包含的最大激发数。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

a_opslist of qobj: 由dims描述的复合量子系统中每个模式的湮灭算符列表。

enr_fock(dims, excitations, state, *, dtype=None)[来源]

在激发数受限的状态空间中生成Fock态表示。dims参数是一个整数列表，定义了复合量子系统每个组分的量子态数量，而excitations指定了要包含在状态空间中的基态的最大激发数。state参数是一个整数元组，指定了要生成Fock态表示的状态（在数基表示中）。

Parameters:

dimslist: 复合量子系统每个子系统的维度列表。
excitationsinteger: 状态空间中包含的最大激发数。
statelist of integers: 数字基数表示中的状态。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

ketQobj: 一个Qobj实例，表示在由dims和exciations定义的激发数限制状态空间中的Fock状态。

enr_identity(dims, excitations, *, dtype=None)[source]

为通过dims和exciations参数定义的激发数受限状态空间生成恒等运算符。有关这些参数的更详细描述，请参阅enr_fock的文档字符串。

Parameters:

dimslist: 复合量子系统每个子系统的维度列表。
excitationsinteger: 状态空间中包含的最大激发数。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

opQobj: 一个Qobj实例，表示在由dims和exciations定义的激发数限制状态空间中的恒等运算符。

enr_state_dictionaries(dims, excitations)[source]

返回状态的数量，以及用于将状态元组转换为状态索引的查找字典，反之亦然，适用于具有给定组件数量和最大激发数的系统。

Parameters:

dims: list: 一个包含每个子系统中状态数量的列表。
excitationsinteger: 维度的最大数量

Returns:

nstates, state2idx, idx2state: integer, dict, dict: 状态的数量 nstates，一个用于从状态元组查找状态索引的字典，以及一个用于从状态索引查找状态元组的字典。state2idx 和 idx2state 是相互反转的，即 state2idx[idx2state[idx]] = idx 和 idx2state[state2idx[state]] = state。

enr_thermal_dm(dims, excitations, n, *, dtype=None)[来源]

在由dims和exciations参数定义的激发数限制状态空间中生成热态的密度算子。有关这些参数的更详细描述，请参阅enr_fock的文档。dims中每个模式的温度由平均激发数n指定。

Parameters:

dimslist: 复合量子系统每个子系统的维度列表。
excitationsinteger: 状态空间中包含的最大激发数。
ninteger: 热态中的平均激发数。n 可以是一个浮点数（适用于每个模式），或者是一个与 dims 长度相同的列表/数组，其中每个元素指定相应模式的温度。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

dmQobj: 热态密度矩阵。

随机算符和状态

该模块是随机状态和操作符生成器的集合。

rand_dm( dimensions: int | list[int] | list[list[int]] | Space, density: float = 0.75, distribution: Literal['ginibre', 'hs', 'pure', 'eigen', 'uniform'] = 'ginibre', *, eigenvalues: Sequence[float] = (), rank: int = None, seed: int | SeedSequence | Generator = None, dtype: str | type = None, )[source]

创建一个具有所需维度的随机密度矩阵。

Parameters:

dimensions(int) or (list of int) or (list of list of int)

希尔伯特空间的维度。如果作为整数列表提供，则维度是该列表的乘积，但新Qobj的dims属性将设置为该列表。根据传递的dimensions，可以生成oper或super。

densityfloat, default: 0.75: 输出密度矩阵的密度在[0,1]之间。由“pure”、“eigen”和“herm”使用。

分布 : str {“ginibre”, “hs”, “pure”, “eigen”, “uniform”},

default: “ginibre”

用于获取密度矩阵的方法。

“ginibre” : 使用[BCSZ08]的算法生成的秩为rank的Ginibre随机密度算子。

“hs” : Hilbert-Schmidt 集合，等同于一个全秩的 ginibre 算子。

“pure”：由随机ket创建的密度矩阵。

“eigen”：具有给定eigenvalues的密度矩阵。

“herm”：使用rand_herm从一个随机厄米矩阵构建。

eigenvaluesarray_like, optional: 输出厄米矩阵的特征值。长度必须与矩阵的形状匹配。
rankint, optional: 当使用“ginibre”分布时，密度矩阵的秩。如果未提供，将默认为全秩运算符。
seedint, SeedSequence, Generator, optional: 用于创建随机数生成器的种子或预先准备好的生成器。当未提供时，将使用默认生成器。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 密度矩阵量子算子。

创建一个随机的稀疏厄米量子对象。

Parameters:

dimensions(int) or (list of int) or (list of list of int)

希尔伯特空间的维度。如果作为整数列表提供，则维度是该列表的乘积，但新Qobj的dims属性将设置为该列表。根据传递的dimensions，可以生成oper或super。

densityfloat, default: 0.30

输出埃尔米特算子的密度在[0,1]之间。

distributionstr {“fill”, “pos_def”, “eigen”}, default: “fill”

用于获取密度矩阵的方法。

“fill” : 使用 \(H=0.5*(X+X^{+})\) 其中 \(X\) 是一个随机生成的量子算子，其元素均匀分布在 [-1, 1] + [-1j, 1j] 之间。
“eigen”：一个具有给定eigenvalues的密度矩阵。它使用随机复数雅可比旋转来打乱操作符。
“pos_def”：通过对角线优势返回一个正半定矩阵。

eigenvaluesarray_like, optional

输出厄米矩阵的特征值。长度必须与矩阵的形状匹配。

seedint, SeedSequence, Generator, optional

用于创建随机数生成器的种子或预先准备好的生成器。当未提供时，将使用默认生成器。

dtypetype or str, optional

存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operQobj: 厄米量子算子。

注释

如果给定一个特征值列表，对象将通过复杂的雅可比旋转创建。虽然这种方法对于小矩阵来说很快，但不应该重复用于生成大于约1000x1000的矩阵。

创建一个随机的ket向量。

Parameters:

dimensions(int) or (list of int) or (list of list of int)

希尔伯特空间的维度。如果作为整数列表提供，则维度是该列表的乘积，但新Qobj的dims属性将设置为该列表。根据传递的dimensions，可以生成oper或super。

densityfloat, default: 1

使用fill方法时输出ket状态的密度在[0,1]之间。

distributionstr {“haar”, “fill”}, default: “haar”

用于获取kets的方法。

haar : 通过将Haar随机酉矩阵应用于固定纯态获得的Haar随机纯态。
fill : 用均匀分布的随机复数填充键。

seedint, SeedSequence, Generator, optional

用于创建随机数生成器的种子或预先准备好的生成器。当未提供时，将使用默认生成器。

dtypetype or str, optional

存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 量子态向量。

在N维希尔伯特空间上以Kraus形式创建一个随机的CPTP映射。

Parameters:

dimensions(int) or (list of int) or (list of list of int): 希尔伯特空间的维度。如果作为整数列表提供，则维度是该列表的乘积，但新Qobj的dims属性将设置为该列表。根据传递的dimensions，可以生成oper或super。
seedint, SeedSequence, Generator, optional: 用于创建随机数生成器的种子或预先准备好的生成器。当未提供时，将使用默认生成器。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

oper_listlist of qobj: N^2 x N x N qobj 操作符。

生成一个随机随机矩阵。

Parameters:

dimensions(int) or (list of int) or (list of list of int): 希尔伯特空间的维度。如果作为整数列表提供，则维度是该列表的乘积，但新Qobj的dims属性将设置为该列表。根据传递的dimensions，可以生成oper或super。
densityfloat, default: 0.75: 输出密度矩阵的密度在[0,1]之间。
kindstr {“left”, “right”}, default: “left”: 生成‘左’或‘右’随机矩阵。
seedint, SeedSequence, Generator, optional: 用于创建随机数生成器的种子或预先准备好的生成器。当未提供时，将使用默认生成器。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 随机矩阵的量子算子形式。

返回一个随机绘制的超算子，作用于作用于N维的算子。

Parameters:

dimensions(int) or (list of int) or (list of list of int): 希尔伯特空间的维度。如果作为整数列表提供，则维度是该列表的乘积，但新Qobj的dims属性将设置为该列表。根据传递的dimensions，可以生成oper或super。
superropstr, default: “super”: 超算子的表示
seedint, SeedSequence, Generator, optional: 用于创建随机数生成器的种子或预先准备好的生成器。当未提供时，将使用默认生成器。
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

返回一个从Bruzda等人集合中随机抽取的超算子，用于CPTP映射[BCSZ08]。请注意，由于有限的数值精度，对于小于满秩的秩，零特征值可能会变得略微负，因此返回的算子实际上并不完全是正的。

Parameters:

dimensions(int) or (list of int) or (list of list of int): 希尔伯特空间的维度。如果提供一个整数，它被理解为要返回的超算符维度的平方根，相应的维度为[[[N],[N]], [[N],[N]]]。如果提供为一个整数列表，则维度被理解为该超算符所应用的密度矩阵的空间：dimensions=[2,2] dims=[[[2,2],[2,2]], [[2,2],[2,2]]]。
enforce_tpbool, default: True: 如果为True，则强制执行[BCSZ08]的迹保持条件；否则仅强制执行完全正性。
rankint, optional: 采样的超算符的秩。如果为None，则生成一个全秩的超算符。
seedint, SeedSequence, Generator, optional: 用于创建随机数生成器的种子或预先准备好的生成器。当未提供时，将使用默认生成器。
superropstr, default: “super”: 表示
dtypetype or str, optional: 存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

rhoQobj: 作用于向量化的dim × dim密度算子的超算子，从BCSZ分布中采样。

创建一个随机的稀疏酉量子对象。

Parameters:

dimensions(int) or (list of int) or (list of list of int)

希尔伯特空间的维度。如果作为整数列表提供，则维度是该列表的乘积，但新Qobj的dims属性将设置为该列表。根据传递的dimensions，可以生成oper或super。

densityfloat, default: 1

输出酉算子的密度在[0,1]之间。

distributionstr {“haar”, “exp”}, default: “haar”

用于获取酉矩阵的方法。

haar : 使用[Mez07]算法的Haar随机酉矩阵。
exp : 使用 \(\exp(-iH)\)，其中 H 是一个随机生成的厄米算子。

seedint, SeedSequence, Generator, optional

用于创建随机数生成器的种子或预先准备好的生成器。当未提供时，将使用默认生成器。

dtypetype or str, optional

存储表示。任何qutip.data.to已知的数据层都被接受。

Returns:

operqobj: 单一量子运算符。

Qobj 操作

张量

用于通过张量积创建复合量子对象的模块。

composite(*args: Qobj) → Qobj[source]

composite( *args: Qobj | QobjEvo, ) → QobjEvo

给定两个或多个运算符、kets或bras，返回对应于每个参数上的复合系统的Qobj。对于普通运算符和向量，这是张量积，而对于超算符和向量化运算符，这是列重排的张量积。

如果传入的是在希尔伯特空间和利乌维尔空间上支持的Qobjs混合体，则前者会被提升。普通运算符被假定为酉运算符，并使用to_super进行提升，而kets和bras则通过取其投影器并使用operator_to_vector(ket2dm(arg))进行提升。

super_tensor(*args: Qobj) → Qobj[source]

super_tensor( *args: Qobj | QobjEvo, ) → QobjEvo

计算输入超算符的张量积，通过将每个向量化算符作用的底层希尔伯特空间张量在一起。

Parameters:

argsarray_like: list 或 array 的量子对象，具有 type="super"。

Returns:

objqobj: 一个复合量子对象。

tensor(*args: Qobj) → Qobj[source]

tensor( *args: Qobj | QobjEvo, ) → QobjEvo

计算输入算子的张量积。

Parameters:

argsarray_like: list 或 array 的张量积量子对象。

Returns:

objqobj: 一个复合量子对象。

示例

>>> tensor([sigmax(), sigmax()]) 
Quantum object: dims = [[2, 2], [2, 2]], shape = [4, 4], type = oper, isHerm = True
Qobj data =
[[ 0.+0.j  0.+0.j  0.+0.j  1.+0.j]
 [ 0.+0.j  0.+0.j  1.+0.j  0.+0.j]
 [ 0.+0.j  1.+0.j  0.+0.j  0.+0.j]
 [ 1.+0.j  0.+0.j  0.+0.j  0.+0.j]]

tensor_contract( qobj: Qobj, *pairs: tuple[int, int], ) → Qobj[source]

沿着一个或多个索引对收缩一个qobj。

注意

请注意，这里使用的是密集表示，因此不应该用于非常大的Qobjs。

Parameters:

qobj: Qobj: 用于收缩子空间的运算符。
pairstuple: 一个或多个元组 (i, j) 表示原始 qobj 的 i 和 j 维度应该被收缩。

Returns:

cqobjQobj: 原始的 Qobj，所有命名的索引对都被收缩掉了。

量子对象（Qobj）类，用于表示量子状态和操作符，以及相关函数。

ptrace(Q: Qobj, sel: int | list[int]) → Qobj[源代码]

保留选定组件的Qobj的部分轨迹。

Parameters:

QQobj: 复合量子对象。
selint/list: 一个 int 或 list，用于在部分追踪后保留的组件。

Returns:

operQobj: 表示保留选定组件的部分迹的量子对象。

注释

此函数仅用于旧版兼容性。建议使用 ptrace() Qobj 方法。

partial_transpose(rho, mask, method='dense')[source]

返回Qobj实例rho的部分转置，其中mask是一个长度等于rho组件数量（即rho.dims[0]的长度）的数组/列表， mask中的值指示是否应转置相应的子系统。 mask中的元素可以是布尔值或整数0或1，其中True/1表示应转置相应的子系统。

Parameters:

rhoQobj: 一个密度矩阵。
masklist / array: 一个选择哪些子系统应该被转置的掩码。
methodstr {“dense”, “sparse”}, default: “dense”: 方法选择。对于大型且稀疏的系统（数百个量子态），“sparse”实现可能更快。

Returns:

rho_pr: Qobj: 一个密度矩阵，其中选定的子系统被转置。

超算符和Liouvillians

lindblad_dissipator( a: Qobj, b: Qobj, data_only: bool, chi: list[float], ) → Qobj[源代码]

lindblad_dissipator( a: Qobj | QobjEvo, b: Qobj | QobjEvo, data_only: bool, chi: list[float], ) → QobjEvo

Lindblad耗散器（广义）用于一对坍缩算子(a, b)，或当b未指定时用于单个坍缩算子(a)：

\[\mathcal{D}[a,b]\rho = a \rho b^\dagger - \frac{1}{2}a^\dagger b\rho - \frac{1}{2}\rho a^\dagger b\]

Parameters:

aQobj or QobjEvo: 折叠运算符的左侧部分。
bQobj or QobjEvo, optional: 折叠运算符的右侧部分。如果未指定，b 默认为 a。
chifloat, optional: 在某些系统中，可以通过数值评估稳态占据概率作为人工相位参数chi的函数的导数来确定状态占据数概率分布的统计矩（均值、方差等），该参数乘以耗散项的a \rho a^dagger项，并通过e ^ (i * chi)引入。因子e ^ (i * chi)是通过统计矩的生成函数引入的。有关该技术的示例，请参见纳米机电系统的全计数统计和混合电路-QED中的光子介导电子传输。此参数已被弃用，并可能在QuTiP 5中移除。
data_onlybool, default: False: 返回数据对象而不是Qobj

Returns:

Dqobj, QobjEvo: Lindblad耗散超算子。

liouvillian( H: Qobj, c_ops: list[Qobj], data_only: bool, chi: list[float], ) → Qobj[source]

liouvillian( H: Qobj | QobjEvo, c_ops: list[Qobj | QobjEvo], data_only: bool, chi: list[float], ) → QobjEvo

从哈密顿量和崩溃算子的列表中组装Liouvillian超算子。

Parameters:

HQobj or QobjEvo, optional: 系统的哈密顿量或Liouvillian的哈密顿分量。如果未给出，则视为0。
c_opsarray_like of Qobj or QobjEvo, optional: 一个 list 或 array 的折叠操作符。
data_onlybool, default: False: 返回数据对象而不是Qobj
chiarray_like of float, optional: 在某些系统中，可以通过数值评估稳态占据概率作为人工相位参数chi的导数来确定各种状态占据概率分布的统计矩（均值、方差等），这些参数包含在每个崩溃算子的lindblad_dissipator中。有关参考文献和更多详细信息，请参阅lindblad_dissipator的文档。此参数已被弃用，并可能在QuTiP 5中移除。

Returns:

LQobj or QobjEvo: Liouvillian 超算子。

operator_to_vector(op: Qobj) → Qobj[source]

给定一个矩阵形式的量子算子，创建一个向量表示。传递的对象应具有Qobj.type为'oper'或'super'；此函数不适用于通用矩阵重塑。

Parameters:

opQobj or QobjEvo: 矩阵形式的量子算子。这必须具有‘oper’或‘super’类型。

Returns:

Qobj or QobjEvo: 相同的对象，但重新转换为类型为‘operator-ket’的列堆叠向量形式。输出与传递的对象类型相同。

spost(A: AnyQobj) → AnyQobj[source]

由操作符A后乘形成的超操作符

Parameters:

AQobj or QobjEvo: 用于后乘法的量子运算符。

Returns:

superQobj or QobjEvo: 由输入的量子对象形成的超算子。

spre(A: AnyQobj) → AnyQobj[source]

由算子A预乘形成的超算子。

Parameters:

AQobj or QobjEvo: 用于预乘的量子运算符。

Returns:

super :Qobj or QobjEvo: 由输入的量子对象形成的超算子。

sprepost( A: Qobj, B: Qobj, ) → Qobj[source]

sprepost( A: Qobj | QobjEvo, B: Qobj | QobjEvo, ) → QobjEvo

由A的前乘和B的后乘形成的超算子。

Parameters:

AQobj or QobjEvo: 用于预乘的量子运算符。
BQobj or QobjEvo: 用于后乘法的量子运算符。

Returns:

superQobj or QobjEvo: 由输入的量子对象形成的超算子。

vector_to_operator(op: Qobj) → Qobj[source]

给定一个向量形式的量子算子，创建一个矩阵表示。传递的对象应具有Qobj.type为‘operator-ket’；此函数不适用于通用的矩阵重塑。

Parameters:

opQobj or QobjEvo: 列堆叠向量形式的量子算子。这必须具有‘operator-ket’类型。

Returns:

Qobj or QobjEvo: 相同的对象，但重新转换为“标准”运算符形式。输出与传递的对象类型相同。

超算子表示

该模块实现了超算子表示之间的转换，包括超矩阵、Kraus、Choi和Chi（过程）矩阵形式。

kraus_to_choi(kraus_ops: list[Qobj]) → Qobj[source]

将Kraus算子列表转换为通道的Choi表示。

本质上，Kraus 算子是 Choi 矩阵的分解，并且从它们重建的过程应该遵循 \(E = \sum_{i} |K_i\rangle\rangle \langle\langle K_i|\)，其中我们使用了 Kraus 算子的向量表示。

Parameters:

kraus_opslist[Qobj]: 要转换为Choi表示的Kraus算子列表。

Returns:

choiQobj: 一个量子对象，表示与kraus_ops相同的映射，使得 choi.superrep == "choi"。

kraus_to_super( kraus_list: list[Qobj], sparse=False, ) → Qobj[源代码]

将Kraus运算符列表转换为超运算符。

Parameters:

kraus_listlist of Qobj: 要转换的Kraus超算子列表。
sparse: bool: 如果为真，则防止生成密集的中间结果。

to_chi(q_oper: Qobj) → Qobj[源代码]

将表示量子映射的Qobj转换为Pauli基中的chi（过程）矩阵表示，使得返回的算符的迹等于系统的维度。

Parameters:

q_operQobj: 要转换为Chi表示的超级运算符。如果 q_oper 是 type="oper"，则它被视为通过共轭作用，使得 to_chi(A) == to_chi(sprepost(A, A.dag()))。

Returns:

chiQobj: 一个量子对象，表示与q_oper相同的地图，使得 chi.superrep == "chi"。

Raises:

TypeError:: 如果给定的量子对象不是映射，或者无法转换为Chi表示。

to_choi(q_oper: Qobj) → Qobj[source]

将表示量子映射的Qobj转换为Choi表示，使得返回的算符的迹等于系统的维度。

Parameters:

q_operQobj: 要转换为Choi表示的超级运算符。如果 q_oper 是 type="oper"，则它被视为通过共轭作用，使得 to_choi(A) == to_choi(sprepost(A, A.dag()))。

Returns:

choiQobj: 一个量子对象，表示与q_oper相同的映射，使得 choi.superrep == "choi"。

Raises:

TypeError:: 如果给定的量子对象不是映射，或者无法转换为Choi表示。

to_kraus( q_oper: Qobj, tol: float = 1e-09, ) → list[Qobj][源代码]

将表示量子映射的Qobj转换为量子对象列表，每个对象表示给定映射的Kraus分解中的一个操作符。

Parameters:

q_operQobj: 要转换为Kraus表示的超算子。如果 q_oper 是 type="oper"，则它通过共轭作用，使得 to_kraus(A) == to_kraus(sprepost(A, A.dag())) == [A]。
tolFloat, default: 1e-9: 用于丢弃特征值/Kraus操作的可选阈值参数。

Returns:

kraus_opslist of Qobj: 量子对象的列表，每个对象代表q_oper分解中的一个Kraus算子。

Raises:

TypeError: if the given quantum object is not a map, or cannot be: 分解为Kraus算子。

to_stinespring( q_oper: Qobj, threshold: float = 1e-10, ) → tuple[Qobj, Qobj][源代码]

将表示量子映射 \(\Lambda\) 的 Qobj 转换为一对部分等距 A 和 B，使得对于所有输入 X，有 \(\Lambda(X) = \Tr_2(A X B^\dagger)\)，其中部分迹是在 A 和 B 的输出维度上的新索引上进行的。

对于完全正数的输入，A 将始终等于 B，直到精度误差。

Parameters:

q_operQobj: 要转换为Stinespring对的超算子。
thresholdfloat, default: 1e-10: 用于丢弃特征值/Kraus操作数的阈值参数。

Returns:

A, BQobj: 表示输入Qobj的每个Stinespring矩阵的量子对象。

to_super(q_oper: Qobj) → Qobj[源代码]

将表示量子映射的Qobj转换为超矩阵（Liouville）表示。

Parameters:

q_operQobj: 要转换为超矩阵表示的超级运算符。如果 q_oper 是 type="oper"，则它被视为通过共轭作用，使得 to_super(A) == sprepost(A, A.dag())。

Returns:

superopQobj: 一个量子对象，表示与q_oper相同的地图，使得 superop.superrep == "super"。

Raises:

TypeError: 如果给定的量子对象不是映射，或者无法转换为超矩阵表示。

操作符和超操作符维度

用于操作维度规格的内部使用模块。

from_tensor_rep(tensorrep, dims)[源代码]

to_tensor_rep的反向操作符。从具有N个索引的N维numpy数组和维度创建一个Qobj。

Parameters:

tensorrep: ndarray: Numpy数组，每个维度对应dims中的一个索引。
dims: list of list, Dimensions: Qobj 的维度。

Returns:

Qobj: 重建的Qobj

to_tensor_rep(q_oper)[源代码]

将Qobj转换为一个形状为展平维度的numpy数组。

Parameters:

q_oper: Qobj: 要重塑的对象

Returns:

ndarray:: Numpy数组，每个维度对应dims中的一个索引。

示例

>>> ket.dims
[[2, 3], [1]]
>>> to_tensor_rep(ket).shape
(2, 3, 1)

>>> oper.dims
[[2, 3], [2, 3]]
>>> to_tensor_rep(oper).shape
(2, 3, 2, 3)

>>> super_oper.dims
[[[2, 3], [2, 3]], [[2, 3], [2, 3]]]
>>> to_tensor_rep(super_oper).shape
(2, 3, 2, 3, 2, 3, 2, 3)

杂项

simdiag( ops, evals: bool = True, *, tol: float = 1e-14, safe_mode: bool = True, use_dense_solver: bool = True, )[source]

可交换厄米矩阵的同步对角化。

Parameters:

opslist, array: list 或 array 的 qobjs 表示对易的 Hermitian 运算符。
evalsbool, default: True: 是否返回每个操作的特征值和特征向量，或者仅返回特征向量。
tolfloat, default: 1e-14: 用于检测退化本征态的容差。
safe_modebool, default: True: 是否检查所有操作符是否为厄米且可交换的。如果设置为 False 并且操作符不可交换，返回的特征向量通常只是第一个操作符的特征向量。
use_dense_solver: bool, default: True: 是否强制使用numpy密集特征求解器。当False时，稀疏运算符将使用scipy稀疏特征求解器，这不适用于此用途。

Returns:

eigstuple: 表示量子对象的特征值和特征向量的数组元组，对应于每个算符的同步特征向量和特征值。

从Qobj中提取数据

期望值

expect(oper: Qobj, state: Qobj) → complex[source]

expect( oper: Qobj, state: Qobj | Sequence[Qobj], ) → ndarray[Any, dtype[complex]]

expect( oper: Qobj | Sequence[Qobj], state: Qobj, ) → list[complex]

expect( oper: Qobj | Sequence[Qobj], state: Qobj | Sequence[Qobj], ) → list[ndarray[Any, dtype[complex]]]

计算操作符和状态的期望值。状态 k 在操作符 A 上的期望定义为 k.dag() @ A @ k，而对于密度矩阵 R 在操作符 A 上的期望则是 trace(A @ R)。

Parameters:

operqobj / list of Qobj: 单个或列表的期望值运算符。
stateqobj / list of Qobj: 单个或列表的量子态或密度矩阵。

Returns:

exptfloat / complex / list / array: 期望值。如果 oper 是厄米特矩阵，则为 real，否则为 complex。如果传递了多个 oper，则返回一个数组列表。如果 state 或 oper 是数组，则返回期望值的（嵌套）数组。

示例

>>> expect(num(4), basis(4, 3)) == 3 
    True

variance(oper: Qobj, state: Qobj) → complex[source]

variance( oper: Qobj, state: list[Qobj], ) → ndarray[Any, dtype[complex]]

给定状态向量或密度矩阵的算符的方差。

Parameters:

operQobj: 期望值的运算符。
stateQobj / list of Qobj: 单个或list的量子态或密度矩阵。

Returns:

varfloat: 给定状态下操作符 'oper' 的方差。

熵函数

concurrence(rho)[source]

计算双量子比特态的并发纠缠度量。

Parameters:

stateqobj: 用于双量子比特态的Ket、bra或密度矩阵。

Returns:

concurfloat: 并发

参考文献

[1]

https://en.wikipedia.org/wiki/Concurrence_(quantum_computing)

entropy_conditional(rho, selB, base=2.718281828459045, sparse=False)[source]

计算选定密度矩阵组件的条件熵 \(S(A|B)=S(A,B)-S(B)\)。

Parameters:

rhoqobj: 复合对象的密度矩阵
selBint/list: 为密度矩阵B选择的组件
base{e, 2}, default: e: 对数的底数。
sparsebool, default: False: 使用稀疏特征求解器。

Returns:

ent_condfloat: 条件熵的值

entropy_linear(rho)[source]

密度矩阵的线性熵。

Parameters:

rhoqobj: 敏感度矩阵或ket/bra向量。

Returns:

entropyfloat: ρ的线性熵。

示例

>>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
>>> entropy_linear(rho)
0.5

entropy_mutual(rho, selA, selB, base=2.718281828459045, sparse=False)[源代码]

计算系统密度矩阵的选择组件之间的互信息 S(A:B)。

Parameters:

rhoqobj: 复合量子系统的密度矩阵
selAint/list: int 或 list 第一个选定的密度矩阵组件。
selBint/list: int 或 list 的第二个选择的密度矩阵组件。
base{e, 2}, default: e: 对数的底数。
sparsebool, default: False: 使用稀疏特征求解器。

Returns:

ent_mutfloat: 所选组件之间的互信息。

entropy_relative(rho, sigma, base=2.718281828459045, sparse=False, tol=1e-12)[source]

计算两个密度矩阵之间的相对熵 S(rho||sigma)。

Parameters:

rhoQobj: 第一个密度矩阵（或将被转换为密度矩阵的ket）。
sigmaQobj: 第二密度矩阵（或将被转换为密度矩阵的ket）。
base{e, 2}, default: e: 对数的基数。默认为e。
sparsebool, default: False: 在确定密度矩阵的特征向量时使用稀疏求解器的标志。默认为 False。
tolfloat, default: 1e-12: 用于检测0特征值或特征向量之间点积的容差。默认为1e-12。

Returns:

rel_entfloat: 相对熵的值。保证大于零，并且只有当 rho 和 sigma 相同时才应等于零。

参考文献

参见Nielsen & Chuang的《量子计算与量子信息》，第11.3.1节，第511页，了解量子相对熵的详细解释。

示例

首先我们定义两个密度矩阵：

>>> rho = qutip.ket2dm(qutip.ket("00"))
>>> sigma = rho + qutip.ket2dm(qutip.ket("01"))
>>> sigma = sigma.unit()

然后我们使用基数2（即log2）和基数e（即log）计算它们的相对熵。

>>> qutip.entropy_relative(rho, sigma, base=2)
1.0
>>> qutip.entropy_relative(rho, sigma)
0.6931471805599453

entropy_vn(rho, base=2.718281828459045, sparse=False)[source]

密度矩阵的冯·诺依曼熵

Parameters:

rhoqobj: 密度矩阵。
base{e, 2}, default: e: 对数的底数。
sparsebool, default: False: 使用稀疏特征求解器。

Returns:

entropyfloat: rho的冯·诺伊曼熵。

示例

>>> rho=0.5*fock_dm(2,0)+0.5*fock_dm(2,1)
>>> entropy_vn(rho,2)
1.0

密度矩阵度量

该模块包含一系列用于计算状态和操作符之间度量（距离测量）的函数。

average_gate_fidelity(oper, target=None)[source]

返回量子通道到目标通道的平均门保真度，如果未给出目标，则返回到身份通道的平均门保真度。

Parameters:

operQobj/list: 一个单一操作符，或超矩阵、Choi或chi矩阵形式的超操作符，或Kraus操作符的列表
targetQobj: 一个单一运算符

Returns:

fidfloat: 操作符和目标之间的平均门保真度，或操作符和单位矩阵之间的平均门保真度。

注释

平均门保真度的定义例如在： A. Gilchrist, N.K. Langford, M.A. Nielsen, Phys. Rev. A 71, 062310 (2005)。平均门保真度所基于的状态保真度定义来自 R. Jozsa, Journal of Modern Optics, 41:12, 2315 (1994)。它是qutip.core.metrics.fidelity中实现的保真度的平方，该实现遵循Nielsen & Chuang的 “量子计算与量子信息”

bures_angle(A, B)[source]

返回两个密度矩阵A和B之间的Bures角度。

Bures角度的范围从0（对于具有单位保真度的状态）到pi/2。

Parameters:

Aqobj: 密度矩阵或状态向量。
Bqobj: 密度矩阵或状态向量，其维度与A相同。

Returns:

anglefloat: 密度矩阵之间的Bures角度。

bures_dist(A, B)[source]

返回两个密度矩阵 A 和 B 之间的 Bures 距离。

Bures距离的范围从0（对于具有单位保真度的状态）到sqrt(2)。

Parameters:

Aqobj: 密度矩阵或状态向量。
Bqobj: 密度矩阵或状态向量，其维度与A相同。

Returns:

distfloat: 密度矩阵之间的Bures距离。

dnorm(A, B=None, solver='CVXOPT', verbose=False, force_solve=False, sparse=True)[source]

计算量子映射 q_oper 的钻石范数，使用 [Wat13] 的简化半定规划。

钻石范数SDP通过使用CVXPY来解决。

如果提供了B并且A和B都是酉矩阵，那么使用以下几何解释可以更高效地计算差异的钻石范数： \(\|A - B\|_{\diamond}\) 等于 \(2 \sqrt(1 - d^2)\)，其中 \(d`是原点到 :math:`A B^{\dagger}\) 特征值的凸包的距离。参见[AKN98]第18页，紧接在12.6证明之后的段落，作为参考。

Parameters:

AQobj: 量子映射以获取钻石范数。
BQobj or None: 如果提供，则采用\(A - B\)的钻石范数。
solverstr {“CVXOPT”, “SCS”}, default: “CVXOPT”: 与CVXPY一起使用的求解器。“SCS”通常显著更快，但准确性稍差。
verbosebool, default: False: 如果为True，打印关于解决方案的额外信息。
force_solvebool, default: False: 如果为True，强制dnorm解决相关的SDP，即使已知参数的特殊情况。
sparsebool, default: True: 是否在凸优化问题中使用稀疏矩阵。默认值为True。

Returns:

dnfloat: q_oper的钻石范数。

Raises:

ImportError: 如果无法导入CVXPY。

fidelity(A, B)[source]

计算两个密度矩阵之间的保真度（伪度量）。

Parameters:

Aqobj: 密度矩阵或状态向量。
Bqobj: 密度矩阵或状态向量，其维度与A相同。

Returns:

fidfloat: A和B之间的保真度伪度量。

注释

使用Nielsen和Chuang的“量子计算与量子信息”中的定义。它是R. Jozsa在《现代光学杂志》41:12, 2315 (1994)中定义的保真度的平方根，用于qutip.core.metrics.process_fidelity。

示例

>>> x = fock_dm(5,3)
>>> y = coherent_dm(5,1)
>>> np.testing.assert_almost_equal(fidelity(x,y), 0.24104350624628332)

hellinger_dist(A, B, sparse=False, tol=0)[source]

计算两个密度矩阵之间的量子Hellinger距离。

公式:

hellinger_dist(A, B) = sqrt(2 - 2 * tr(sqrt(A) * sqrt(B)))

参见：D. Spehner, F. Illuminati, M. Orszag, 和 W. Roga, “使用Bures和Hellinger距离的量子相关性的几何度量” arXiv:1611.03449

Parameters:

AQobj: 密度矩阵或状态向量。
BQobj: 密度矩阵或状态向量，其维度与A相同。
tolfloat, default: 0: 如果使用稀疏特征求解器，则使用的容差。（0 = 机器精度）
sparsebool, default: False: 使用稀疏特征求解器。

Returns:

hellinger_distfloat: A和B之间的量子Hellinger距离。范围从0到sqrt(2)。

示例

>>> x = fock_dm(5,3)
>>> y = coherent_dm(5,1)
>>> np.allclose(hellinger_dist(x, y), 1.3725145002591095)
    True

hilbert_dist(A, B)[source]

返回两个密度矩阵A和B之间的希尔伯特-施密特距离。

Parameters:

Aqobj: 密度矩阵或状态向量。
Bqobj: 密度矩阵或状态向量，其维度与A相同。

Returns:

distfloat: 密度矩阵之间的Hilbert-Schmidt距离。

注释

参见 V. Vedral 和 M. B. Plenio, Phys. Rev. A 57, 1619 (1998).

process_fidelity(oper, target=None)[source]

返回量子通道到目标通道的过程保真度，如果未给出目标，则返回到身份通道的过程保真度。两个通道之间的过程保真度定义为它们的归一化Choi矩阵之间的状态保真度。

Parameters:

operQobj/list: 一个单一操作符，或超矩阵、Choi或chi矩阵形式的超操作符，或Kraus操作符的列表
targetQobj/list, optional: 一个单一操作符，或超矩阵、Choi或chi矩阵形式的超操作符，或Kraus操作符的列表

Returns:

fidfloat: 操作符和目标之间的过程保真度，或操作符和单位矩阵之间的过程保真度。

注释

自 Qutip 5.0 起，此函数计算过程保真度，如 A. Gilchrist、N.K. Langford、M.A. Nielsen 在《Phys. Rev. A 71, 062310 (2005)》中所定义。以前，它计算的功能现在在 qutip-qtrl 中实现为 get_fidelity。

过程保真度所基于的状态保真度定义来自R. Jozsa，现代光学杂志，41:12，2315（1994）。它是qutip.core.metrics.fidelity中实现的平方，该实现遵循Nielsen & Chuang的“量子计算与量子信息”。

tracedist(A, B, sparse=False, tol=0)[source]

计算两个密度矩阵之间的迹距离。参见：Nielsen & Chuang, “量子计算与量子信息”

Parameters:

Aqobj: 密度矩阵或状态向量。
Bqobj: 密度矩阵或状态向量，其维度与A相同。
tolfloat, default: 0: 如果使用稀疏特征求解器，则使用的容差。（0 = 机器精度）
sparsebool, default: False: 使用稀疏特征求解器。

Returns:

tracedistfloat: A和B之间的迹距离。

示例

>>> x=fock_dm(5,3)
>>> y=coherent_dm(5,1)
>>> np.testing.assert_almost_equal(tracedist(x,y), 0.9705143161472971)

unitarity(oper)[source]

返回量子映射的单位性，定义为该映射的超算符表示的单位块的弗罗贝尼乌斯范数。

Parameters:

operQobj: 考虑的量子图。

Returns:

ufloat: oper 的单位性。

量子态的测量

用于测量量子对象的模块。

measure(state, ops, tol=None)[source]

一种调度方法，提供处理可观测样式测量和投影仪样式测量（POVMs和PVMs）的测量结果。

有关返回签名，请检查：

measure_observable 用于可观测量的测量。
measure_povm 用于POVM测量。

Parameters:

stateQobj

指定要测量的状态的ket或密度矩阵。

opsQobj or list of Qobj

测量可观测值 (Qobj); 或
测量操作符列表 \(M_i\) 或 kets（列表中的 Qobj）任选其一：
1. 指定一个POVM，使得 \(E_i = M_i^\dagger M_i\)
2. 投影运算符如果操作对应于投影器（使得 \(E_i = M_i^\dagger = M_i\)）
3. kets（转换为投影器）

tolfloat, optional

概率的最小值。默认是qutip核心设置的atol。

measure_observable(state, op, tol=None)[source]

在给定状态上执行由操作符指定的测量。

此函数模拟了许多量子力学入门教材中描述的经典量子测量。测量将状态坍缩到给定算子的一个本征态，测量结果是对应的本征值。

Parameters:

stateQobj: 指定要测量的状态的ket或密度矩阵。
opQobj: 测量操作符。
tolfloat, optional: 概率的最小值。默认是 qutip 核心设置的 atol。

Returns:

measured_valuefloat: 测量的结果（op的一个特征值）。
stateQobj: 新状态（如果给定的是ket，则为ket，否则为密度矩阵）。

示例

测量自旋向上基态的自旋z分量：

>>> measure_observable(basis(2, 0), sigmaz())
(1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
Qobj data =
[[-1.]
 [ 0.]])

由于自旋向上基是sigmaz的本征态，这个测量总是返回1作为测量结果（自旋向上基的本征值）和原始状态（直到一个全局相位）。

测量自旋向下基态的自旋x分量：

>>> measure_observable(basis(2, 1), sigmax())
(-1.0, Quantum object: dims = [[2], [1]], shape = (2, 1), type = ket
Qobj data =
[[-0.70710678]
 [ 0.70710678]])

这个测量在50%的时间内返回1，在另外50%的时间内返回-1。返回的新状态是sigmax的相应本征态。

也可以对密度矩阵进行测量。下面我们执行与上述相同的测量，但是是在表示纯自旋向下状态的密度矩阵上进行的：

>>> measure_observable(ket2dm(basis(2, 1)), sigmax())
(-1.0, Quantum object: dims = [[2], [2]], shape = (2, 2), type = oper
Qobj data =
[[ 0.5 -0.5]
 [-0.5  0.5]])

测量结果相同，但新状态以密度矩阵的形式返回。

measure_povm(state, ops, tol=None)[source]

执行由POVM列表指定的测量。

此函数模拟POVM测量。测量将状态坍缩为测量结果之一，并返回与坍缩状态对应的操作符索引以及坍缩状态。

Parameters:

stateQobj

指定要测量的状态的ket或密度矩阵。

opslist of Qobj

测量操作符列表 \(M_i\) 或 kets。可以是：

指定一个POVM，使得 \(E_i = M_i^\dagger M_i\)
投影运算符如果操作对应于投影器（使得 \(E_i = M_i^\dagger = M_i\)）
kets（转换为投影器）

tolfloat, optional

概率的最小值。默认是 qutip 核心设置的 atol。

Returns:

indexfloat: 测量的结果索引。
stateQobj: 新状态（如果给定的是ket，则为ket，否则为密度矩阵）。

measurement_statistics(state, ops, tol=None)[source]

一种调度方法，提供处理可观测样式测量和投影仪样式测量（POVMs和PVMs）的测量统计。

有关返回签名，请检查：

measurement_statistics_observable 用于可观测测量。
measurement_statistics_povm 用于POVM测量。

Parameters:

stateQobj

指定要测量的状态的ket或密度矩阵。

opsQobj or list of Qobj

测量可观测值 (:class:.Qobj); 或
测量操作符列表 \(M_i\) 或 kets（列表中的 Qobj）任选其一：
1. 指定一个POVM，使得 \(E_i = M_i^\dagger * M_i\)
2. 投影运算符如果操作对应于投影器（使得 \(E_i = M_i^\dagger = M_i\)）
3. kets（转换为投影器）

tolfloat, optional

概率的最小值。默认是 qutip 核心设置的 atol。

measurement_statistics_observable(state, op, tol=None)[source]

返回给定状态和测量算符的测量特征值、特征态（或投影器）和测量概率。

Parameters:

stateQobj: 指定要测量的状态的ket或密度矩阵。
opQobj: 测量操作符。
tolfloat, optional: 概率的最小值。默认是 qutip 核心设置的 atol。

Returns:

eigenvalues: list of float: 测量算子的特征值列表。
projectors: list of Qobj: 返回投影到本征态上的投影器。
probabilities: list of float: 测量状态为相应本征态的概率（测量结果为相应的本征值）。

measurement_statistics_povm(state, ops, tol=None)[source]

返回在指定的ket或密度矩阵上由一组正算子值测量指定的测量统计（结果状态和概率）。

Parameters:

stateQobj

指定要测量的状态的ket或密度矩阵。

opslist of Qobj

测量操作符列表 \(M_i\) 或 kets。可以是：

指定一个POVM，使得 \(E_i = M_i^\dagger M_i\)
投影运算符如果操作对应于投影器（使得 \(E_i = M_i^\dagger = M_i\)）
kets（转换为投影器）

tolfloat, optional

概率的最小值。较小的概率将被四舍五入到0。默认值是qutip核心设置的atol。

Returns:

collapsed_stateslist of Qobj: 在测量量子比特并获得由目标指定的量子比特后，得到的坍缩状态由索引指定的状态。
probabilitieslist of floats: 测量指定索引状态的概率。