MajoranaOperator

class MajoranaOperator(coeffs, modes, boundaries)

ベース： object

マジョラーナフェルミオン演算子。

定義

この演算子は、マジョラナ演算子の積の線形結合によって定義される [1]。これは、標準的なフェルミオンの第二量子化による生成・消滅演算子を用いて定義することができる（こちらも参照 FermionOperator）：

\gamma = a^\dagger + a ~~\text{and}~~ \gamma' = i(a^\dagger - a)

マジョラナフェルミオンがそれ自身の反粒子であるという重要な性質は、すぐに明らかになる：

\gamma_i = \gamma_i^\dagger ~~\text{and}~~ \gamma_i^2 = (\gamma_i^\dagger)^2 = 1

これにより、 $2n$ 個のマジョラナフェルミオンについては、以下の反交換関係が導かれる：

\left\{\gamma_i,\gamma_j\right\} = 2\delta_{ij}

これにより、演算子全体の定義は次のようになります：

\text{\texttt{MajoranaOperator}} = \sum_i c_i \bigotimes_j \hat{\gamma_j} \, ,

ここで、 $c_i$ は、 $\gamma_j$ の積の線形結合を構成する（複素）係数である。添字 $j$ は、0 から、その演算子が作用するマジョラナ・フェルミオンモードの数から 1 を引いた値までの間の任意の値をとることができる。

実装

このクラスは、疎行列で一般的に使用される「圧縮疎行形式」と同様に、項と係数を複数の疎ベクトルに格納します。より具体的に言えば、1つの演算子には4つの配列が含まれています：


`coeffs`	2つの64ビット浮動小数点数からなる、複素係数のベクトル。
`modes`	操作の対象となったマジョラナモードのインデックスを格納する、32ビット整数のベクトル。
`boundaries`	内の境界を示す整数のベクトル `modes`。

整数は、 $j$ として、マジョラナモードの添字 modes となります。便利関数を使用する場合 gamma()、 $\gamma$ （ $\gamma'$ ）に対して、偶数（奇数）の添字が使用されます。

注

これらの内部配列の読み取り専用コピー には、それぞれのメソッド（ get_coeffs(), get_modes(), および）を通じてアクセスできます get_boundaries()。

このデータ構造により、演算子の構築や操作を非常に効率的に行うことができます。しかし、これは、演算子の中にいつでも重複する項が含まれている可能性があることを意味します。これらは、. を使用して手動で解決する必要があります simplify()。

建設

上記の配列を指定することで、演算子を直接作成することができます：

>>> from qiskit_fermions.operators import MajoranaOperator
>>> coeffs = [1.0, -2.0, 3.0j, -0.5j]
>>> modes = [0, 1, 0, 2, 0, 1, 2, 3]
>>> boundaries = [0, 0, 2, 4, 8]
>>> op = MajoranaOperator(coeffs, modes, boundaries)
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
 -2.000000e0 +0.000000e0j * (γ0 γ'0)
 -0.000000e0-5.000000e-1j * (γ0 γ'0 γ1 γ'1)
  0.000000e0 +3.000000e0j * (γ0 γ1)

便宜上、 Python 辞書から次のように演算子を構築することができます：

>>> from qiskit_fermions.operators import gamma
>>> op = MajoranaOperator.from_dict(
...     {
...         (): 1.0,
...         (gamma(0, False), gamma(0, True)): -2.0,
...         (gamma(0, False), gamma(1, False)): 3.0j,
...         (gamma(0, False), gamma(0, True), gamma(1, False), gamma(1, True)): -0.5j,
...     }
... )
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
 -2.000000e0 +0.000000e0j * (γ0 γ'0)
 -0.000000e0-5.000000e-1j * (γ0 γ'0 γ1 γ'1)
  0.000000e0 +3.000000e0j * (γ0 γ1)

この例では、マジョラナ演算子の生成 gamma() にを活用しました。

さらに、以下の構築メソッドおよびクイックヘルパーメソッドが利用可能です：


`zero`()	加法単位演算子を構築する。
`one`()	乗法単位演算子を構築します。
`from_terms`（用語）	項のイテレータから新しい演算子を構築します（こちらも参照 `iter_terms()`）。
`from_terms_with_groups`（用語）	グループを含む項のイテレータから、新しい演算子を構築します（こちらも参照 `iter_terms_with_groups()`）。

フォーマット設定

上記の例では、構築された演算子はの出力を用いて表示されており format()、その結果、人間が読みやすい形式の演算子が得られています。

>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
 -2.000000e0 +0.000000e0j * (γ0 γ'0)
 -0.000000e0-5.000000e-1j * (γ0 γ'0 γ1 γ'1)
  0.000000e0 +3.000000e0j * (γ0 γ1)

注

の印刷順序は、印刷前に明示的にソート format(op) されます。したがって、演算子内の項の順序は反映されません。

この関数 repr() から別の形式を取得することができ、その結果、 Python で解釈可能な表現が得られます。つまり、この出力を Python のシェルにそのままコピー＆ペーストすることができます：

>>> print(repr(op))
MajoranaOperator.from_dict({...})

最後に、大規模なオペレーターの場合、これら2つの出力はどちらも非常に長くなり、望ましくない結果となる可能性があります。すると、この関数 str() から、最小限の情報しか含まない非常にシンプルなフォームを取得することができます：

>>> print(str(op))
<MajoranaOperator with 4 terms>

反復

基礎となるデータ構造はRustで実装されており、レイアウトも複雑であるため、直接反復処理を行うことはできません：

>>> list(iter(op))
Traceback (most recent call last):
  ...
TypeError: 'qiskit_fermions.operators.majorana_operator.MajoranaOperator' object is not iterable

その代わりに、このクラスはこの目的を果たすためのカスタムイテレータを提供しています：

>>> list(sorted(op.iter_terms()))
[([], (1+0j)), ([0, 1], (-2+0j)), ([0, 1, 2, 3], (-0-0.5j)), ([0, 2], 3j)]

関連資料

iter_terms()

実装に関する詳細については、以下をご覧ください。

以下の表には、利用可能なすべてのイテレータが一覧表示されています：


`iter_terms`()	演算子の項を順にたどるイテレータ。
`iter_terms_with_groups`()	演算子の項と、それに対応する群のインデックスを保持するイテレータ。

算数

以下の算術演算がサポートされています：

足し算・引き算

>>> op = MajoranaOperator.one()
>>> (op + op).simplify()
MajoranaOperator.from_dict({(): 2+0j})
>>> (op - op).simplify()
MajoranaOperator.from_dict({})
>>> op += op
>>> op.simplify()
MajoranaOperator.from_dict({(): 2+0j})
>>> op -= op
>>> op.simplify()
MajoranaOperator.from_dict({})

スカラーの乗算・除算

>>> op = MajoranaOperator.one()
>>> (2 * op).simplify()
MajoranaOperator.from_dict({(): 2+0j})
>>> (op / 2).simplify()
MajoranaOperator.from_dict({(): 0.5+0j})
>>> op *= 2
>>> op.simplify()
MajoranaOperator.from_dict({(): 2+0j})
>>> op /= 2
>>> op.simplify()
MajoranaOperator.from_dict({(): 1+0j})

オペレーターの構成

注

演算子の合成は左乗法に対応します：は $C = B A$ に対応 c = a & b します。つまり、2つの演算子を合成すると、「まず a 、次に」を実行する結果の演算子が得られます。 b

>>> op1 = MajoranaOperator.from_dict({(): 2.0, (gamma(0, False),): 3.0})
>>> op2 = MajoranaOperator.from_dict({(): 1.5, (gamma(0, True),): 4.0})
>>> comp = (op1 & op2).simplify()
>>> print(format(comp))
  3.000000e0 +0.000000e0j * ()
  4.500000e0 +0.000000e0j * (γ0)
  8.000000e0 +0.000000e0j * (γ'0)
  1.200000e1 +0.000000e0j * (γ'0 γ0)
>>> op2 &= op1
>>> print(format(op2.simplify()))
  3.000000e0 +0.000000e0j * ()
  4.500000e0 +0.000000e0j * (γ0)
  1.200000e1 +0.000000e0j * (γ0 γ'0)
  8.000000e0 +0.000000e0j * (γ'0)
>>> squared = (op1 ** 2).simplify()
>>> print(format(squared))
  4.000000e0 +0.000000e0j * ()
  1.200000e1 +0.000000e0j * (γ0)
  9.000000e0 +0.000000e0j * (γ0 γ0)

注

便宜上、右乗算はによって実装されています c = a @ b （これにより、 $C = A B$ となります）。

>>> (op1 @ op2).equiv(op2 & op1)
True

その他の操作

上記の算術演算に対応するマジックメソッドに加え、以下のメソッドも利用可能です：


`adjoint`()	この演算子のエルミート共役（または随伴）を返します。
`ichop`( [アトール] )	指定された閾値未満の係数の絶対値を持つ項を除去します。
`simplify`( [アトール] )	同等だが簡略化された演算子を返します。
`normal_ordered`( [昇順、削減] )	通常の順序を持つ項を持つ等価演算子を返します。
`relabel_modes`(順列)	モードのラベルが変更された新しい演算子を返します。

プロパティ－

最後に、演算子の特定の性質を確認するためのさまざまな方法があります：


`is_hermitian`( [アトール] )	この演算子がエルミート演算子であるかどうかを返します。
`max_rank`()	この演算子に含まれる項の最大ランクを返します。
`is_even`()	この演算子が偶数であるかどうかを返します。

[ 1 ]

https://en.wikipedia.org/wiki/Majorana _fermion

属性

groups

各項に対するグループインデックスのベクトル（オプション）。

詳細については、当該モジュ grouping ールを参照してください。

方法

adjoint

adjoint()

この演算子のエルミート共役（または随伴）を返します。

これにより、項と係数には次のような影響が生じます：

各項の操作の順序が逆になる
係数は複素共役である

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): -1.0j, (gamma(0, False), gamma(0, True)): 1.0})
>>> adj = op.adjoint()
>>> print(format(adj))
 -0.000000e0 +1.000000e0j * ()
  1.000000e0 -0.000000e0j * (γ'0 γ0)

equiv

equiv(other, atol=1e-08)

この演算子が別の演算子と等価であるかどうかを確認します。

この文脈における「等価」とは、指定された絶対許容誤差の範囲内での近似的な等しさを意味します。より正確に言えば、このメソッドは True、差分に含まれる係数の絶対値がすべて、指定された閾値を下回 other - self っている場合に、を返します atol。

注

これは、ほとんどの場合、求めている数学的な比較です。これは、許容誤差や簡略化を行わずに、 格納された項（その係数、モード、および内部項の境界）の完全な等価性を検査する演算 == 子とは異なります。したがって、数学的には等しい2つの演算子であっても、保存方法が異なれば == 、その下では不等となる可能性があります。例えば、単純化されていないとの場合 a + a や 2 * a、項の順序が異なる場合などが挙げられます。を使用して、数値許容誤差の範囲内で演算子を比較 equiv します。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 1e-7})
>>> zero = MajoranaOperator.zero()
>>> op.equiv(zero)
False
>>> op.equiv(zero, 1e-6)
True
>>> op.equiv(zero, 1e-9)
False

パラメーター

その他 – 比較の対象となるもう一方の演算子。
atol – 比較における絶対許容誤差。この値のデフォルトは 1e-8. です。

from_dict

classmethod from_dict(data)

辞書から新しい演算子を生成します。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict(
...     {
...         (): 1.0-1.0j,
...         (0, 1): 2.0,
...     }
... )
>>> print(format(op))
  1.000000e0 -1.000000e0j * ()
  2.000000e0 +0.000000e0j * (γ0 γ'0)

パラメーター

data – 項のタプルを複素係数にマッピングする辞書。各キーは、マジョラナモードのインデックスとなる整数のタプルです。 $\gamma$ および $\gamma'$ への偶数および奇数のインデックスの割り当てを簡略化 gamma() するには、を使用することができます。

戻り値

新しいオペレーター。

from_terms

classmethod from_terms(terms)

項のイテレータから新しい演算子を構築します（こちらも参照 iter_terms()）。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0, (0,): 1.0, (1,): -1.0j})
>>> op.equiv(MajoranaOperator.from_terms(op.iter_terms()))
True

パラメーター

項 – によって生成される項のイテレータ iter_terms()。

戻り値

新しいオペレーター。

from_terms_with_groups

classmethod from_terms_with_groups(terms)

グループを含む項のイテレータから、新しい演算子を構築します（こちらも参照 iter_terms_with_groups()）。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator([2.0, 1.0, -1.0j], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> reconstructed = MajoranaOperator.from_terms_with_groups(op.iter_terms_with_groups())
>>> op.equiv(reconstructed) and op.groups == reconstructed.groups
True

パラメーター

項 – によって生成される項のイテレータ iter_terms_with_groups()。

戻り値

新しいオペレーター。

get_boundaries

get_boundaries()

演算子の項間の境界を示すインデックスの、読み取り専用のリストを返します。

注

このメソッドは、内部データのコピー を返します。

関連資料

内部データ構造の説明はこちらです。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.one()
>>> op += MajoranaOperator.from_dict({(0, 1): 1.0})
>>> op.get_boundaries()
[0, 0, 2]

戻り値

当該事業者の利用規約の適用範囲の一覧。

get_coeffs

get_coeffs()

演算子の係数からなる読み取り専用のリストを返します。

注

このメソッドは、内部データのコピー を返します。

関連資料

内部データ構造の説明はこちらです。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.one()
>>> op += -1j * MajoranaOperator.one()
>>> op.get_coeffs()
[(1+0j), -1j]

戻り値

演算子の係数のリスト。

get_modes

get_modes()

オペレータの対象となったモードのインデックスからなる、読み取り専用のリストを返します。

注

このメソッドは、内部データのコピー を返します。

関連資料

内部データ構造の説明はこちらです。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.one()
>>> op += MajoranaOperator.from_dict({(0, 1): 1.0})
>>> op.get_modes()
[0, 1]

戻り値

このオペレーターのモードの一覧。

get_support

get_support()

この演算子が作用するモードインデックスの集合を返します。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict(
...     {
...         (0, 4): 1,
...         (1, 3, 4, 7): 1,
...     }
... )
>>> assert op.get_support() == {0, 1, 3, 4, 7}

戻り値

この演算子が作用するモード指数の集合。

group_weights

group_weights()

各グループの平均絶対係数絶対値を返します。

第- i番目の項は、グループ内の各項 abs(coeff) についての和を i、そのグループの項の数で割ったものです。 groups がの場合 None、この関数はも返します None。

これは、個々の項ではなくグループ全体を抽出するランダム化積分式（例： qDRIFT ）のサンプリング重みです。これをネイティブに計算する方が、 NumPy, 内で groups と get_coeffs() を還元するよりもかなり効率的です。なぜなら、これら2つのアクセサは、 グループ化されていない項ごとに1つの値を演算子からコピーし、それをグループごとに1つの値に再集約するだけであるのに対し、この方法ではの還元 num_groups() 済み値のみが返されるからです。

注

どの項も含まれていないグループインデックスの重みはであり 0.0、これによりそのグループはサンプルから除外される。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> print(op.group_weights())
None
>>> op.groups = [0, 1, 0, 1]
>>> op.group_weights()
[1.0, 2.0]

戻り値

各グループ指標の平均絶対係数絶対値。

has_groups

has_groups()

この演算子がグループインデックスを追跡しているかどうかを返します。

これは、グループインデックスを確認するために演算子からそれらをコピーしないため op.groups is not None、（ただし、それよりも効率的である）チェックを行うことと同等です。

注

これは、が空のリスト groups である場合でも True 返されます。これは、項を一切持たないグループ化された演算子の状態です。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> op.has_groups()
False
>>> op.groups = [0, 1, 0, 1]
>>> op.has_groups()
True

戻り値

この演算子にが設定されている groups かどうか。

ichop

ichop(atol=1e-08)

指定された閾値未満の係数の絶対値を持つ項を除去します。

このメソッドは、演算子をその場で変更し、を返します None。

警告

この手法は、係数を貪欲に切り捨ててしまいます！対象となる演算子に、重複する項に対して個別の係数が含まれている可能性がある場合は、代わりに simplify() を呼び出すことを検討してください！

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 1e-4, (0,): 1e-6, (1,): 1e-10})
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
  1.000000e-6 +0.000000e0j * (γ0)
 1.000000e-10 +0.000000e0j * (γ'0)
>>> op.ichop()
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
  1.000000e-6 +0.000000e0j * (γ0)
>>> op.ichop(1e-5)
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()

パラメーター

atol – カットオフ値の絶対許容誤差。この値のデフォルトは 1e-8. です。

is_even

is_even()

この演算子が偶数であるかどうかを返します。

注

演算子の各項に含まれるアクションの数がすべて偶数である場合でも、その演算子は偶数とみなされます。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(0, 1): 1})
>>> op.is_even()
True
>>> op = MajoranaOperator.from_dict({(0,): 1})
>>> op.is_even()
False

戻り値

この演算子が偶数であるかどうか。

is_hermitian

is_hermitian(atol=1e-08)

この演算子がエルミート演算子であるかどうかを返します。

注

このチェックは、と self 、その、 adjoint() およびの normal_ordered() 差 equiv() を用いて実装されています zero()。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({
...     (0, 1, 2, 3): 1.00001j,
...     (3, 2, 1, 0): -1j,
... })
>>> op.is_hermitian()
False
>>> op.is_hermitian(1e-4)
True

パラメーター

atol – 係数が等しいとみなされる数値的精度の上限。この値のデフォルトは 1e-8. です。

戻り値

この演算子がエルミートであるかどうか。

iter_terms

iter_terms()

演算子の項を順にたどるイテレータ。

警告

反復項目の値を変更しても、その基礎となる演算子のデータには影響しません。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0, (0,): 1.0, (1,): -1.0j})
>>> list(sorted(op.iter_terms()))
[([], (2+0j)), ([0], (1+0j)), ([1], (-0-1j))]

iter_terms_with_groups

iter_terms_with_groups()

演算子の項と、それに対応する群のインデックスを保持するイテレータ。

警告

反復項目の値を変更しても、その基礎となる演算子のデータには影響しません。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator([2.0, 1.0, -1.0j], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> list(op.iter_terms_with_groups())
[([], (2+0j), 0), ([0], (1+0j), 1), ([1], (-0-1j), 1)]

max_rank

max_rank()

この演算子に含まれる項の最大ランクを返します。

注

最長の項の長さは、演算子の形式によって異なる場合があり、つまり（例えば）演算子の簡約や正規順序付けを行うことで、最大ランクが異なる結果となる可能性がある。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(0, 1, 2, 3): 1})
>>> op.max_rank()
4

戻り値

この演算子の最大ランク。

normal_ordered

normal_ordered(ascending=False, reduce=True)

通常の順序を持つ項を持つ等価演算子を返します。

演算子項の通常の順序とは、すべてのアクションが辞書順に並べられるように定義されるものである。上昇するか下降するかは、 ascending パラメータの値によって決まります。 $\gamma$ ( $\gamma'$ ) を偶数（奇数）のインデックスに配置 gamma() するという規則に従うと、次の例（デフォルトの場合 ascending=False）が得られます： [\gamma(1, True), \gamma(1, False), \gamma(0, True), \gamma(0, False)] = [3, 2, 1, 0]。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(gamma(0, False), gamma(0, True), gamma(0, False)): 1})
>>> print(format(op.normal_ordered(reduce=False)))
 -1.000000e0 +0.000000e0j * (γ'0 γ0 γ0)
>>> print(format(op.normal_ordered(reduce=True)))
 -1.000000e0 +0.000000e0j * (γ'0)

パラメーター

昇順 – インデックスを昇順にするか降順にするか。
reduce – 各項について、恒等式に二乗される作用を除去することで、最小形に簡約するかどうか。上記の例も参照してください。

戻り値

等価であるが、正規順序を持つ演算子。

num_groups

num_groups()

グループの数を返します。

groups がの場合 None、この関数はも返します None。そうでない場合、グループの数は、出現するグループのインデックスの最大値に1を加えた値として返されます（したがって、この値は次のグループのインデックスとして使用できます）。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> op.groups = [0, 1, 0, 1]
>>> op.num_groups()
2

戻り値

[]における最大のグループ指数がプラス groups 1。

one

classmethod one()

乗法単位演算子を構築します。

この方法で構築された演算子を別の演算子と組み合わせても、何の効果もありません。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0})
>>> one = MajoranaOperator.one()
>>> op & one == op
True

relabel_modes

relabel_modes(permutation)

モードのラベルが変更された新しい演算子を返します。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({
...     (0, 1): 1,
...     (0, 1, 2, 3): 1,
... })
>>> permutation = [5, 6, 4, 3]
>>> relabeled = op.relabel_modes(permutation)
>>> print(format(relabeled))
  1.000000e0 +0.000000e0j * (γ'2 γ3)
  1.000000e0 +0.000000e0j * (γ'2 γ3 γ2 γ'1)

パラメーター

順列 – インデックスの順列リスト。「モード」はに再ラベル付けされる i ため permutation[i]、このリストには重複するエントリが含まれてはならず、また、演算子が作用するすべてのモードをインデックス化できるだけの十分な長さである必要があります（その長さは、演算子の最大のモードインデックスを上回っていなければなりません）。

戻り値

モードの名称が変更された新しい演算子。

昇給

ValueError – if に重複するエントリが含ま permutation れている場合、またはオペレータが作用するモードに再ラベル付けするには短すぎる場合。

simplify

simplify(atol=1e-08)

同等だが簡略化された演算子を返します。

簡略化のプロセスでは、まず同じ項に属するすべての係数を合計し、その合計係数が指定された許容誤差を超えるもののみを残します（ちょうど…のように ichop()）。

演算子が算術的に操作されたり、一意な項が保証されない方法で構築されたりした場合、情報の損失を防ぐために、数値的に小さい係数をフィルタリングするメソッドを適用する前に、このメソッドを呼び出す必要があります。以下の例では、合計係数の大きさが切り捨てられるべきではないにもかかわらず、項が切り捨てられて ichop() しまう様子が示されています：

>>> from qiskit_fermions.operators import MajoranaOperator
>>> coeffs = [1e-5] * int(1e5)
>>> boundaries = [0] + [0] * int(1e5)
>>> op = MajoranaOperator(coeffs, [], boundaries)
>>> canon = op.simplify(1e-4)
>>> assert canon.equiv(op.one(), 1e-6)
>>> op.ichop(1e-4)
>>> assert op.equiv(op.zero(), 1e-6)

パラメーター

atol – カットオフ値の絶対許容誤差。この値のデフォルトは 1e-8. です。

戻り値

同等だが簡略化された演算子。

split_out_groups

split_out_groups(group_indices=None)

この演算子を、に基づいて、新しい演算子のオプションのリストに分割します groups。

groups がの場合 None、この関数はも返します None。それ以外の場合、が None （デフォルト）である group_indices ときは、内の各グループインデックスに対して groups、インデックスの順序に従って新しい演算子を1つずつ含むリストを返します。が指定 group_indices された場合、要求されたインデックスのみが、指定された順序で構築されます。これにより、決して使用されない群に対する演算子の構築にかかるコストを回避できます。これは、総数に比べてごく少数の群のみが必要な場合、例えば、ランダム化積公式のために群をサブサンプリングする場合などに、特に有益です。内の重複するインデックスは、出現するたびに1回ずつ返されます group_indices 。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> print(op.split_out_groups())
None
>>> op.groups = [0, 1, 0, 1]
>>> groups = op.split_out_groups()
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([0, 1], (1+0j)), ([1, 0], (-1+0j))]
[([2, 3], (2+0j)), ([3, 2], (-2+0j))]
>>> groups = op.split_out_groups(group_indices=[1])
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([2, 3], (2+0j)), ([3, 2], (-2+0j))]

パラメーター

group_indices – 演算子を構築するグループインデックス。希望する出力順で指定します。省略された場合、すべてのグループがインデックスの順に構築されます。

戻り値

要求された各グループインデックスに対して、1つの新しい演算子を含むオプションのベクトル。

zero

classmethod zero()

加法単位演算子を構築する。

この方法で構築された演算子を別の演算子に追加しても、何の効果もありません。

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0})
>>> zero = MajoranaOperator.zero()
>>> op + zero == op
True

プロトコルの手法

_anti_commutator_

static _anti_commutator_(op_a, op_b)

_commutator_

static _commutator_(op_a, op_b)

_double_commutator_

static _double_commutator_(op_a, op_b, op_c, sign)

_fermion_operator_

_fermion_operator_()

この演算子を.に変換します FermionOperator。

これは、に委譲することでプロトコル SupportsFermionOperator を実装しています majorana_to_fermion()。

このページは役に立ちましたか？

バグや誤字の報告、またはコンテンツの要求はGitHubで行ってください。