TransferVertexOperator

class TransferVertexOperator(coeffs, left_indices, right_indices, boundaries)

ベース： object

転送頂点演算子。

定義

この演算子は、転送頂点（ $T_{jk}$ 、 $V_j$ ）の演算子を用いて定義される：

\begin{align} V_j &= -i \gamma_{2j-1} \gamma_{2j} = -(a_j a_j - a_j a^\dagger_j + a^\dagger_j a_j - a^\dagger_j a^\dagger_j) = 1 - 2 a^\dagger_j a_j \, , \nonumber \\ T_{jk} &= \frac{i}{2} V_j E_{jk} = \frac{i}{2} \gamma_{2j} \gamma_{2k-1} \, , \nonumber \\ T_{kj} &= \frac{i}{2} E_{jk} V_k = -\frac{i}{2} \gamma_{2j-1} \gamma_{2k} \nonumber \end{align}

ここで、はのエッジ演算子であり $E_{jk}$ 、これらの個々の項は EdgeVertexOperator 、に対して以下のフェルミオン・ボソン混合の交換関係を満たす $j \lt k \lt l \lt m$ ： [1]

\begin{align} \left\{ T_{jk}, V_k \right\} &= 0 \nonumber \\ \left\{ T_{jk}, T_{lk} \right\} &= 0 \nonumber \\ \left[ V_k, V_l \right] &= 0 \nonumber \\ \left[ T_{jk}, V_l \right] &= 0 \nonumber \\ \left[ T_{jk}, T_{lm} \right] &= 0 \nonumber \\ \left[ T_{jk}, T_{kj} \right] &= 0 \nonumber \\ \left[ T_{jk}, T_{km} \right] &= 0 \nonumber \, . \end{align}

簡単な例を視覚的に表すと、次のようになります：

表記法を少し大雑把に扱って、 $V_j = T_{jj}$ を定義することができます。これは、この演算子の内部データ構造がどのように機能するかを反映したものです。これにより、演算子全体の定義は次のようになります：

\text{\texttt{EdgeVertexOperator}} = \sum_i c_i \bigotimes_{lr} T_{lr} \, ,

ここで、 $lr$ は関連する演算子項の添字を表し、 $c_i$ は積の線形結合を構成する（複素）係数である。インデックス $l$ および $r$ は、0 から、その演算子が作用するフェルミオンモードの数から 1 を引いた値までの間の任意の値をとることができます。

$T_{lr}$ を一般化された転送演算子と呼ぶことにする。

実装

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

コラム「 1 」	コラム「 2 」
`coeffs`	2つの64ビット浮動小数点数からなる、複素係数のベクトル。
`left_indices`	左側のフェルミオンモードのインデックスを格納する32ビット整数のベクトル（上記の $l$ ）。
`right_indices`	正しいフェルミオンモードのインデックスを格納する32ビット整数のベクトル（上記の $r$ ）。
`boundaries`	および `actions` における境界を示す整数のベクトル `modes`。

および left_indices でインデックス付けられたフェルミオンモードは、スピンを持たないとみなされる right_indices 。

注

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

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

建設

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

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> coeffs = [1.0, 2.0, -3.0, 4.0j, -0.5j]
>>> left_indices = [0, 3, 0, 2, 3, 0]
>>> right_indices = [1, 4, 1, 2, 3, 1]
>>> boundaries = [0, 0, 1, 2, 4, 6]
>>> op = TransferVertexOperator(coeffs, left_indices, right_indices, boundaries)
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
  2.000000e0 +0.000000e0j * (T(0,1))
  0.000000e0 +4.000000e0j * (T(0,1) V(2))
 -0.000000e0-5.000000e-1j * (V(3) T(0,1))
 -3.000000e0 +0.000000e0j * (T(3,4))

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

>>> op = TransferVertexOperator.from_dict(
...     {
...         (): 1.0,
...         ((0, 1),): 2.0,
...         ((3, 4),): -3.0,
...         ((0, 1), (2, 2)): 4.0j,
...         ((3, 3), (0, 1)): -0.5j,
...     }
... )
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
  2.000000e0 +0.000000e0j * (T(0,1))
  0.000000e0 +4.000000e0j * (T(0,1) V(2))
 -0.000000e0-5.000000e-1j * (V(3) T(0,1))
 -3.000000e0 +0.000000e0j * (T(3,4))

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

コラム「 1 」	コラム「 2 」
`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 * (T(0,1))
  0.000000e0 +4.000000e0j * (T(0,1) V(2))
 -0.000000e0-5.000000e-1j * (V(3) T(0,1))
 -3.000000e0 +0.000000e0j * (T(3,4))

注

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

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

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

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

>>> print(str(op))
<TransferVertexOperator with 5 terms>

反復

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

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

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

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

関連資料

iter_terms()

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

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

コラム「 1 」	コラム「 2 」
`iter_terms`()	演算子の項を順に巡回するイテレータ。
`iter_terms_with_groups`()	演算子の項と、それに対応する群インデックスを保持するイテレータ。

算数

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

足し算・引き算

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

スカラーの乗算・除算

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

オペレーターの構成

注

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

>>> op1 = TransferVertexOperator.from_dict({(): 2.0, ((0, 1),): 3.0})
>>> op2 = TransferVertexOperator.from_dict({(): 1.5, ((2, 2),): 4.0})
>>> comp = (op1 & op2).simplify()
>>> print(format(comp))
  3.000000e0 +0.000000e0j * ()
  4.500000e0 +0.000000e0j * (T(0,1))
  8.000000e0 +0.000000e0j * (V(2))
  1.200000e1 +0.000000e0j * (V(2) T(0,1))
>>> op2 &= op1
>>> print(format(op2.simplify()))
  3.000000e0 +0.000000e0j * ()
  4.500000e0 +0.000000e0j * (T(0,1))
  1.200000e1 +0.000000e0j * (T(0,1) V(2))
  8.000000e0 +0.000000e0j * (V(2))
>>> squared = (op1 ** 2).simplify()
>>> print(format(squared))
  4.000000e0 +0.000000e0j * ()
  1.200000e1 +0.000000e0j * (T(0,1))
  9.000000e0 +0.000000e0j * (T(0,1) T(0,1))

注

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

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

その他の操作

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

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

プロパティ－

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

コラム「 1 」	コラム「 2 」
`is_hermitian`( [アトール] )	この演算子がエルミート演算子であるかどうかを返します。

[ 1 ]

Gandon ら、 arXiv:2512.11418.

属性

groups

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

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

方法

adjoint

adjoint()

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

すべての用語には、次の2つのことが起こります：

係数は複素共役である
各項内の生成子の順序が逆になっている

この逆転が必要な理由は、 $(AB)^\dagger = B^\dagger A^\dagger$ であるためです。個々の頂点生成子および転送生成子はエルミート演算子ですが、 インデックスが同じ場合、それらは反交換します（上記の定義を参照）。したがって、逆転させた積は元の積とは等しくならず、順序を単に省略することはできません。

なお、これによって演算子が一般に自己随伴になるわけではないことに注意してください。複素係数を持つ演算子は、その随伴演算子とは異なります（以下のdoctestが示すように）。

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> op = TransferVertexOperator.from_dict({(): -1.0j, ((0, 0), (0, 1)): 1.0})
>>> adj = op.adjoint()
>>> print(format(adj))
 -0.000000e0 +1.000000e0j * ()
  1.000000e0 -0.000000e0j * (T(0,1) V(0))

equiv

equiv(other, atol=1e-08)

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

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

注

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

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> op = TransferVertexOperator.from_dict({(): 1e-7})
>>> zero = TransferVertexOperator.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 TransferVertexOperator
>>> op = TransferVertexOperator.from_dict(
...     {
...         (): 1.0-1.0j,
...         ((0, 0),): 2.0,
...         ((0, 1),): 2.0j,
...     }
... )
>>> print(format(op))
  1.000000e0 -1.000000e0j * ()
  2.000000e0 +0.000000e0j * (V(0))
  0.000000e0 +2.000000e0j * (T(0,1))

パラメーター

data – 項のタプルを複素係数に割り当てる辞書。各キーは、一般化転移演算子 $T_{lr}$ のインデックスを示すp (int, int) 組のタプルです（ $l = r$ の場合、これは頂点演算子 $V_l$ に対応します）。

戻り値

新しいオペレーター。

from_terms

classmethod from_terms(terms)

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

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> op = TransferVertexOperator.from_dict({(): 2.0, ((0, 0),): 1.0, ((0, 1),): -1.0j})
>>> op.equiv(TransferVertexOperator.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 TransferVertexOperator
>>> op = TransferVertexOperator([2.0, 1.0, -1.0j], [0, 0], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> reconstructed = TransferVertexOperator.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 TransferVertexOperator
>>> op = TransferVertexOperator.one()
>>> op += TransferVertexOperator.from_dict({((0, 1),): 1.0})
>>> op.get_boundaries()
[0, 0, 1]

戻り値

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

get_coeffs

get_coeffs()

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

注

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

関連資料

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

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

戻り値

演算子の係数のリスト。

get_left_indices

get_left_indices()

すべての一般化転送演算子項の左インデックスからなる、読み取り専用のリストを返します。

注

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

関連資料

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

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

戻り値

すべての一般化転送演算子項の左添字の一覧。

get_right_indices

get_right_indices()

すべての一般化転送演算子項の右インデックスからなる、読み取り専用のリストを返します。

注

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

関連資料

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

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

戻り値

すべての一般化転送演算子項の右辺の指標の一覧。

get_support

get_support()

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

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

戻り値

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

has_groups

has_groups()

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

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

注

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

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

戻り値

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

ichop

ichop(atol=1e-08)

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

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

警告

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

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

パラメーター

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

is_hermitian

is_hermitian(atol=1e-08)

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

注

このチェックは、 self およびそのおよび adjoint() の完全に簡約化された normal_ordered() 差分 equiv() を用いて実装されています zero()。

注

このチェックは保守的なものです。実際にはハーミティアンである演算子に対 False しても、このチェックではが返される可能性があります。結果は True 常に信頼できる。

normal_ordered() 隣接する発電機の各ペアは、 より短い項に結合されますが、単一のモードを共有する2つの転送演算子についてはそうではありません。そこで説明されているように、 $T_{jk} T_{jl}$ は、長さ2の積に書き換えることしかできません。どちらの形式も他方より標準的であるとは言えないため、このような積はそのままにされ、一方を書き換えた後にのみその随伴に対して相殺される項は、ゼロとは見なされない。 EdgeVertexOperator そこにはそのようなギャップが存在しない。なぜなら、そこでは類似の積が単一のエッジ演算子に融合するからである。

パラメーター

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

戻り値

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

iter_terms

iter_terms()

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

警告

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

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

iter_terms_with_groups

iter_terms_with_groups()

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

警告

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

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

normal_ordered

normal_ordered(reduce=True)

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

演算子項の通常の順序は、すべての頂点演算子がすべての転送演算子よりも前に現れるように定義される。各グループ内では、作用を受けるモードは辞書順に並べられます。

注

項の順序を入れ替える際には、交換関係と反交換関係を併せて考慮しなければならない。詳しい定義についてはこちらをご覧ください。

注

ここでは、よりも利用できる収縮の数が少ないです EdgeVertexOperator。単一のモードを共有する2つのエッジ演算子は1つに融合するが、それに対応する転送積はそうならない。 $T_{jk} = \frac{i}{2} \gamma_{2j} \gamma_{2k-1}$ と表すと、共有されるマジョラナを相殺しても、常に2つの異なるモードから選ばれた（偶数、奇数）のペアが残り、これは単一の生成子ではない。ただし V(j) V(j)、および T(j,k) T(j,k) のみが契約 T(j,k) T(k,j) の対象となる。

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> op = TransferVertexOperator.from_dict({((0, 1), (1, 0), (1, 2), (0, 0), (2, 2)): 1})
>>> print(format(op.normal_ordered(reduce=False).simplify()))
 -1.000000e0 -0.000000e0j * (V(0) V(2) T(0,1) T(1,0) T(1,2))
>>> print(format(op.normal_ordered().simplify()))
 2.500000e-1 +0.000000e0j * (V(1) V(2) T(1,2))

パラメーター

reduce – 隣接するジェネレータを、スカラーに結合するか、あるいは一対の頂点演算子に結合するかを指定します。上記の例をご覧ください。この値のデフォルトは True. です。

戻り値

等価であるが、通常順序付けられた演算子。

num_groups

num_groups()

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

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

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

戻り値

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

one

classmethod one()

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

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

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

relabel_modes

relabel_modes(permutation)

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

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

パラメーター

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

戻り値

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

昇給

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

simplify

simplify(atol=1e-08)

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

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

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

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> coeffs = [1e-5] * int(1e5)
>>> boundaries = [0] + [0] * int(1e5)
>>> op = TransferVertexOperator(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 TransferVertexOperator
>>> op = TransferVertexOperator(
...     [1.0, 2.0, -1.0],
...     [0, 1, 2, 3],
...     [1, 0, 3, 2],
...     [0, 1, 3, 4],
... )
>>> print(op.split_out_groups())
None
>>> op.groups = [0, 1, 0]
>>> groups = op.split_out_groups()
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([(0, 1)], (1+0j)), ([(3, 2)], (-1+0j))]
[([(1, 0), (2, 3)], (2+0j))]
>>> groups = op.split_out_groups(group_indices=[1])
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([(1, 0), (2, 3)], (2+0j))]

パラメーター

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

戻り値

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

zero

classmethod zero()

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

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

>>> from qiskit_fermions.operators import TransferVertexOperator
>>> op = TransferVertexOperator.from_dict({(): 2.0})
>>> zero = TransferVertexOperator.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 を実装しています transfer_vertex_to_fermion()。

_majorana_operator_

_majorana_operator_()

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

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

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

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