SparseObservable

__new__(data, /, num_qubits=None)

のデフォルトコンストラクタは SparseObservable.

これは、 data の引数の型に基づいて、 明示的な変換コンストラクタ・メソッドのいずれかに委譲する。 num_qubits が与えられ、 data の型が暗示するコンストラクタが数値を受け付けない場合、与えられた整数は入力と一致しなければならない。

パラメーター

• data - 入力のデータ型。 これは、別の SparseObservableこの場合、入力はコピーされる。 Pauli または SparsePauliOpであり、その場合は from_pauli() または from_sparse_pauli_op() が呼び出される。 from_list() または from_sparse_list().
• num_qubits (int|None) – 演算子の量子ビット数（オプション）。 ほとんどのデータ入力では、これは推測できるので、渡す必要はない。 これは空リストかスパース・リスト形式でのみ必要である。 不必要に与えられる場合は、入力されたデータと一致しなければならない。

単一量子ビット項のフラットリスト。 これは、より自然なリストのリストだが、メモリ使用量と局所性の理由から平坦に保存され、サブリストは境界で示される。

分割するインデックス bit_terms と indices を分割するインデックス。 boundaries[0] : boundaries[1] へのインデックスの範囲である。 bit_terms と indices へのインデックスの範囲である。 すべての不特定の量子ビット・インデックスは暗黙的に同一である。 これは coeffsなぜなら、 boundaries[0] は常に明示的なゼロだからである（アルゴリズム的に簡単にするため）。

各抽象項の係数は合計に含まれる。 これは和の項と同じ数の要素を持つ。

の対応するエントリーが作用する量子ビット・インデックスのフラット・リスト。 bit_terms の対応するエントリが作用する量子ビットインデックスのフラットリスト。 このリストは常に項ごとにソートされなければならない。 boundaries.

演算子が作用する量子ビットの数。

アイデンティティは明示的に保存されないため、これは他の形状や値からは推測できない。

この演算子が追跡している和の項数。

adjoint()

この観測値の随伴点を計算する。

これは、抽象的な数学的な意味でうまく定義されている。 単一量子ビットのアルファベットの項はすべて自己合同なので、この演算の結果は、その係数がすべて複素共役であることを除けば、同じ観測値である。

例

>>> left = SparseObservable.from_list([("XY+-", 1j)])
>>> right = SparseObservable.from_list([("XY+-", -1j)])
>>> assert left.adjoint() == right

apply_layout(layout, num_qubits=None)

これにトランスパイラ・レイアウトを適用する。 SparseObservable.

通常、状態を準備するために使用する回路の仮想量子ビットの観点から観測可能なものを定義する。 トランスパイレーションの後、仮想量子ビットはデバイス上の特定の物理量子ビットにマッピングされる。 このマッピングは、サーキットの過程で変化することもある。 この方法は、仮想量子ビットの入力観測値を、完全にトランスパイルされた物理回路の直後に適用するのに適した観測値に変換する。

パラメーター

• layout (TranspileLayout |list[int] | None) – レイアウトを適用する。 この関数のほとんどの用途は、ハードウェア用にトランスパイルされた回路から QuantumCircuit.layout フィールドを渡すべきである。 さらに、新しい量子ビット・インデックスのリストを渡すこともできる。 明示的に None、リマッピングは適用されない（ただし、 num_qubits 、observableを拡張することはできる）。
• num_qubits (int | None) – 観測可能な量子ビットの数。 もし与えなければ、出力は与えられた TranspileLayoutと同じ幅になる。 layout が別の形式で与えられている場合は、入力と同じ幅になる。

戻り値

新しい SparseObservable を作成し、提供されたレイアウトを適用します。

as_paulis()

各投影をパウリ項の和として書くことにより、観測値をパウリ項のみで表す。

結果として得られるパウリ項の次数は保証されていないことに注意。 使用する SparseObservable.simplify() を加えて、正準表現を得る。

戻り値

同じ観測値だが、パウリ項のみで表現される。

例

パウリ作用素に射影することで、観測値を書き換える：

>>> obs = SparseObservable("+")
>>> obs.as_paulis()
<SparseObservable with 2 terms on 1 qubit: (0.5+0j)() + (0.5+0j)(X_0)>
>>> direct = SparseObservable.from_list([("I", 0.5), ("Z", 0.5)])
>>> assert direct.simplify() == obs.as_paulis().simplify()

小さな演算子の場合、これは simplify() をユニークな正準形式として使うことができる：

>>> left = SparseObservable.from_list([("+", 0.5), ("-", 0.5)])
>>> right = SparseObservable.from_list([("r", 0.5), ("l", 0.5)])
>>> assert left.as_paulis().simplify() == right.as_paulis().simplify()

clear()

この演算子からすべての項を消去し、再びゼロ演算子と等しくする。

これにより内部の割り当て容量は変更されないため、その後の加算や減算の操作において再割り当てが必要なくなる場合があります。

例

>>> obs = SparseObservable.from_list([("IX+-rl", 2.0), ("01YZII", -1j)])
>>> obs.clear()
>>> assert obs == SparseObservable.zero(obs.py_num_qubits())

commutes(other, tol=1e-12)

ある観測可能量が別の観測可能量と可換であるかどうかを確認する。

パラメーター

• other (SparseObservable) – 交換性を確認するためのもう一つの観測量。
• tol (float) – 自己と他者の積における係数が許容値（絶対値）を下回る場合、それらの項は無視される。

戻り値

True 許容範囲内で条件が交換可能であれば、そうでなければ False 。

昇給

TypeError – が に強制変換できなかった other``SparseObservable 場合。

compose(other, /, qargs=None, *, front=False)

この上に別の SparseObservable を作成する。

作用素代数の観点からは、合成は左掛け算に相当する。 c = a.compose(b) は、 $C = B A$ に相当する。つまり、 a.compose(b) は「 a を行い、その結果に b を行う」演算子を返す。 その代わり、 front=True 。

self と other は同じサイズでなければならない。ただし、 qargs が与えられている場合を除く。その場合、 other は self より小さくてもよい。ただし、 other の量子ビット数と qargs の長さが一致していることが条件である。 qargs は、 self に存在しない量子ビットの重複やインデックスを含むことはできない。

のアルファベットは合成の下では閉じていないので、この関数は観測可能なメモリ使用量を指数関数的に爆発させる可能性があることに注意してください。 SparseObservable のアルファベットは合成の下では閉じていないので、この関数は観測可能なメモリ使用量を指数関数的に爆発させる可能性があることに注意すること。 このメモリ使用量は、結果的なオブザーバブルに固有のものではないが、合計の効率的な再ファクタリゼーションを見つけることは、一般的に同様に計算が難しい。 後から単純化するのではなく、観測値の知識を利用して、存在する項の数を最小限にする方が良い。

パラメーター

• other - self の左乗算に使われる観測値。

• qargs

  もし与えられれば、 self の量子ビットが other の量子ビットに関連付けられる。 別の言い方をすれば、これが与えられれば、より効率的な実装に似ている：

  self.compose(other.apply_layout(qargs, self.num_qubits))

  というのも、 other のアプライドレイアウトフォームを保存するための一時的なオブザーバブルは作成されないからである。

• front - True の場合、左掛けではなく other で右掛けする（デフォルトは False ）。 qargs はまだ other に適用されている。 これは、 qargs が設定されている場合、あるいは、 other が、以下のように強制されなければならないオブジェクトである場合に最も便利である。 SparseObservable.

conjugate()

この観測値の複素共役を計算する。

この演算はQiskitの標準的な行列規約の観点から定義され、行列の形が♪Z$計算基底にあるとみなされる。 X-関連項とZ-関連項は複素共役の影響を受けないが、Y-関連項はそのアルファベット項を修正する。 その通りだ：

• $Y$ に通じる。 $-Y$
• $\lvert r\rangle\langle r\rvert$ に結合する。 $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ に結合する。 $\lvert r\rangle\langle r\rvert$

さらに、すべての係数は共役である。

例

>>> obs = SparseObservable([("III", 1j), ("Yrl", 0.5)])
>>> assert obs.conjugate() == SparseObservable([("III", -1j), ("Ylr", -0.5)])

copy()

このobservableのコピーを取得する。

例

>>> obs = SparseObservable.from_list([("IXZ+lr01", 2.5), ("ZXI-rl10", 0.5j)])
>>> assert obs == obs.copy()
>>> assert obs is not obs.copy()

evolve(other, /, qargs=None)

この観測量をパウリ項を用いて展開せよ。

観測可能量 $O$ のパウリ演算子 $P$ による演算は、 $P^\dagger O P$ に対応する。

2つの完全な構成を用いた文字通りの実装とは異なり、この手法では固定のルックアップテーブルを用いて、単一量子ビットレベルで直接共役変換を行います。 これにより、中間状態の具体化を回避し、項を一度だけ SparseObservable 走査するだけで、進化後の観測量を計算することができる。 self また、 が qargs 指定されていない限り、両者の量子 other ビット数は同じでなければならない。ただし、 が指定されている場合は、 other と の量子ビット数が other 一致 qargs していれば、 は selfよりも小さくてもよい。 qargs は、のどの量子ビットがによって self 進化するかを other指定する。

現在、この手法は単項演算子による演化のみをサポートしており、つまり は で表される other パウリ演算子 Pauliでなければならない。

パラメーター

• その他 – 共役化に用いられる selfパウリ演算子。
• qargs – 指定された場合、関数 self によって進化させる量子 otherビット。 長さは、の量子ビット数と一致 otherしていなければなりません。

戻り値

新しい進化形 SparseObservable に、活用形が適用された。

昇給

• TypeError – が型 Pauliでない other 場合。
• ValueError – もし self と other の量子ビット数が異なる場合（かつ qargs が与えられていない場合）。
• ValueError – length が量子ビットの数 qargs と other 一致しない場合。
• ValueError – 重複や範囲外のインデックスが含まれている qargs 場合。
• ValueError – もし other に複数の項が含まれている場合。

expand(other, /)

逆順テンソル積。

これは other.tensor(self) と等価であるが、 other が（デフォルトのコンストラクタを呼び出すことによって）まだ型キャストされていなければ、最初に型キャストされる。 SparseObservable に型キャストされる（デフォルトのコンストラクタが呼び出される）。

パラメーター

other - テンソル積の左辺に置く観測値。

例

これは tensor() と等価である：

>>> left = SparseObservable.from_label("XYZ")
>>> right = SparseObservable.from_label("+-IIrl")
>>> assert left.tensor(right) == right.expand(left)

static from_label(label, /)

密な文字列ラベルから単一項の観測値を構築する。

その結果、演算子の係数は1になる。 ラベルはアルファベット 'IXYZ+-rl01' の並びでなければならない。 ラベルはビット列と同様に解釈される。 つまり、一番右の文字が0番量子ビットに対応し、以下同様である。 のラベルと同じである。 Pauli と SparsePauliOp.

パラメーター

label (str) – 濃密なラベル。

例

>>> SparseObservable.from_label("IIII+ZI")
<SparseObservable with 1 term on 7 qubits: (1+0j)(+_2 Z_1)>
>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> assert SparseObservable.from_label(label) == SparseObservable.from_pauli(pauli)

static from_list(iter, /, *, num_qubits=None)

密なラベルと係数のリストからobservableを構築する。

と似ている。 SparsePauliOp.from_list()と似ている。 SparseObservable. この密なフォームでは、各ラベルにすべてのIDを明示的に与えなければならない。

ラベルはアルファベット 'IXYZ+-rl01' の並びでなければならない。 ラベルはビット列と同様に解釈される。 つまり、一番右の文字が0番量子ビットに対応し、以下同様である。 のラベルと同じである。 Pauli と SparsePauliOp.

パラメーター

• iter (list[tuple[str, complex]]) – ラベルとその係数の和のペア。 ラベルの解釈は from_label().
• num_qubits (int | None) – ラベルの長さから推測できるので、 iter が空の配列でないことが確かならば、これを指定する必要はない。 もし iter が空であれば、いくつの量子ビットの観測値であるかを明確にするためにこの引数を指定しなければなりません。 これが与えられ、 iter が空でない場合、値はラベルの長さと一致しなければならない。

例

同じ長さのラベルのリストからobservableを構築する：

>>> SparseObservable.from_list([
...     ("III++", 1.0),
...     ("II--I", 1.0j),
...     ("I++II", -0.5),
...     ("--III", -0.25j),
... ])
<SparseObservable with 4 terms on 5 qubits:
    (1+0j)(+_1 +_0) + (0+1j)(-_2 -_1) + (-0.5+0j)(+_3 +_2) + (-0-0.25j)(-_4 -_3)>

num_qubits を使って、空の可能性のある入力を曖昧さをなくす：

>>> SparseObservable.from_list([], num_qubits=10)
<SparseObservable with 0 terms on 10 qubits: 0.0>

このメソッドは from_sparse_list() を呼び出すのと同じである：

>>> labels = ["XY+Z", "rl01", "-lXZ"]
>>> coeffs = [1.5j, 2.0, -0.5]
>>> from_list = SparseObservable.from_list(list(zip(labels, coeffs)))
>>> from_sparse_list = SparseObservable.from_sparse_list([
...     (label, (3, 2, 1, 0), coeff)
...     for label, coeff in zip(labels, coeffs)
... ])
>>> assert from_list == from_sparse_list

static from_pauli(pauli, /)

を構築する。 SparseObservable インスタンスから Pauli インスタンスから構築する。

出力観測値は、位相に依存するユニタリー係数を持つ単一の項を持つ。

パラメーター

pauli (Pauli) – コンバートするシングル・パウリ。

例

>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> SparseObservable.from_pauli(pauli)
<SparseObservable with 1 term on 5 qubits: (1+0j)(Y_3 X_2 Z_1)>
>>> assert SparseObservable.from_label(label) == SparseObservable.from_pauli(pauli)

static from_raw_parts(num_qubits, coeffs, bit_terms, indices, boundaries, check=True)

を構築する。 SparseObservable を、 クラスレベルのドキュメントに記述されている必要なデータ表現に一致する生のNumpy配列から構築します。

各配列のデータは、新しい、成長可能なRust-spaceアロケーションにコピーされる。

パラメーター

• num_qubits - 観測可能な量子ビットの数。

• coeffs - 観測値の各項の複素係数。 これはd型のNumpy配列でなければならない。 complex128.

• bit_terms - すべての完全項を含む単一量子ビット項の平坦化リスト。 のNumpy配列でなければならない。 uint8 (これは BitTerm).

• indices - 各単一量子ビット項が対応する量子ビットを項ごとに平らにソートしたリスト。 これはd型のNumpy配列でなければならない。 uint32.

• 境界 - bit_terms と indices をタームに分割するインデックス。 これはd型のNumpy配列でなければならない。 uintp.

• チェック

  True （デフォルト）の場合、データがすべてのコヒーレンス保証を満たしているかどうかを検証する。 False の場合、チェックは行われない。

  警告

  check=False の場合、 bit_terms はすべて有効な値でなければならない。 SparseObservable.BitTerm. そうでない場合、Rust-spaceの未定義動作が発生し、プログラムの実行が完全に無効になる可能性がある。

例

個々の量子ビットについて、 $Z$ の和を構築する：

>>> num_qubits = 100
>>> terms = np.full((num_qubits,), SparseObservable.BitTerm.Z, dtype=np.uint8)
>>> indices = np.arange(num_qubits, dtype=np.uint32)
>>> coeffs = np.ones((num_qubits,), dtype=complex)
>>> boundaries = np.arange(num_qubits + 1, dtype=np.uintp)
>>> SparseObservable.from_raw_parts(num_qubits, coeffs, terms, indices, boundaries)
<SparseObservable with 100 terms on 100 qubits: (1+0j)(Z_0) + ... + (1+0j)(Z_99)>

static from_sparse_list(iter, /, num_qubits)

ラベルのリスト、各項目が適用される量子ビット、項全体の係数からobservableを構築する。

と似ている。 SparsePauliOp.from_sparse_list()と似ている。 SparseObservable.

トリプルの "labels "フィールドと "indices "フィールドは、ジップすることで関連付けられる。 たとえば、これは from_list() の呼び出しは、各トリプルの "indices" フィールドを (num_qubits-1, ..., 1, 0) に設定することで、このメソッドで使用される形式に変換できることを意味します。

パラメーター

• iter (list[tuple[str, Sequence[int], complex]]) – ラベル、各単位量子ビットの項、項全体の係数の三つ組。
• num_qubits (int) – 演算子の量子ビットの数。

例

単純な演算子を作る：

>>> SparseObservable.from_sparse_list(
...     [("ZX", (1, 4), 1.0), ("YY", (0, 3), 2j)],
...     num_qubits=5,
... )
<SparseObservable with 2 terms on 5 qubits: (1+0j)(X_4 Z_1) + (0+2j)(Y_3 Y_0)>

identityオブザーバブルを構築する（本当は identity()):

>>> SparseObservable.from_sparse_list([("", (), 1.0)], num_qubits=100)
<SparseObservable with 1 term on 100 qubits: (1+0j)()>

この方法は from_list()トリプルのqubit-argumentsフィールドが減少する整数に設定されている場合：

>>> labels = ["XY+Z", "rl01", "-lXZ"]
>>> coeffs = [1.5j, 2.0, -0.5]
>>> from_list = SparseObservable.from_list(list(zip(labels, coeffs)))
>>> from_sparse_list = SparseObservable.from_sparse_list([
...     (label, (3, 2, 1, 0), coeff)
...     for label, coeff in zip(labels, coeffs)
... ])
>>> assert from_list == from_sparse_list

static from_sparse_pauli_op(op, /)

から SparseObservable インスタンスから SparsePauliOp インスタンスを作成する。

これは SparsePauliOp特に、同じような項をその場で合計したり、パウリ項の合計を等価な射影演算子にリファクタライズする試みはない。

パラメーター

op (SparsePauliOp) – 変換する演算子。

例

>>> spo = SparsePauliOp.from_list([("III", 1.0), ("IIZ", 0.5), ("IZI", 0.5)])
>>> SparseObservable.from_sparse_pauli_op(spo)
<SparseObservable with 3 terms on 3 qubits: (1+0j)() + (0.5+0j)(Z_0) + (0.5+0j)(Z_1)>

static from_terms(obj, /, num_qubits=None)

を構築する。 SparseObservable を構成する。

すべての項は同じ数の量子ビットを持たなければならない。 指定された場合、 num_qubits 引数は条件と一致しなければならない。

観測可能なものを作る過程で、単純化することはない。

パラメーター

• obj (Iterable[Term]) – observableを構築する個々の用語の反復可能。
• num_qubits (int | None) – 観測可能な量子ビットの数。 これは通常、入力から推測されるが、イテレート可能なものが空の場合に対処するために明示的に指定することもできる。

戻り値

対応する観測値。

static identity(num_qubits)

指定された数の量子ビットに対する恒等演算子を取得します。

例

100量子ビットのID演算子を取得します：

>>> SparseObservable.identity(100)
<SparseObservable with 1 term on 100 qubits: (1+0j)()>

pauli_bases()

を取得する。 PauliList このobservableの各項目（順番に）に必要な測定基底を表すオブジェクトを取得する。

例えば、プロジェクター 0l+ は Pauli ZXY を返す。 その結果 Pauli は、明示的な同一性が格納されるという意味で、密である。 パウリ出力における同一性は、具体的な測定を必要としない。

これは、和のすべての項について、パウリ・リストの項目を返す。

戻り値

必要な測定ベースを表すパウリ演算子リスト。

戻りの型

PauliList

simplify(tol=1e-08)

この演算子に含まれる同類の項をすべて合計し、その結果得られる複素係数の絶対値が許容範囲内のゼロであれば、それらを取り除く。

副次的な効果として、これは演算子を正準順にソートする。

パラメーター

tol (float) – 同じような項を合計した後、絶対値が与えられた絶対許容誤差より小さい係数は、出力から抑制される。

例

を使用する。 simplify() を使うことで、同じ観測値を表す2つの演算子を比較することができますが、デフォルトでは構造検定のために不等間隔で比較されます：

>>> base = SparseObservable.from_sparse_list([
...     ("XZ", (2, 1), 1e-10),  # value too small
...     ("+-", (3, 1), 2j),
...     ("+-", (3, 1), 2j),     # can be combined with the above
...     ("01", (3, 1), 0.5),    # out of order compared to `expected`
... ], num_qubits=5)
>>> expected = SparseObservable.from_list([("I0I1I", 0.5), ("I+I-I", 4j)])
>>> assert base != expected  # non-canonical comparison
>>> assert base.simplify() == expected.simplify()

上記の例では、すべての浮動小数点計算が正確になるように係数が選択されており、中間的な丸めや連想性の懸念がないことに注意してください。 これが保証されない場合は、より安全な形がある：

>>> left = SparseObservable.from_list([("XYZ", 1.0/3.0)] * 3)   # sums to 1.0
>>> right = SparseObservable.from_list([("XYZ", 1.0/7.0)] * 7)  # doesn't sum to 1.0
>>> assert left.simplify() != right.simplify()
>>> assert (left - right).simplify() == SparseObservable.zero(left.num_qubits)

tensor(other, /)

2つの観測値のテンソル積。

ビットオーダーは、引数の量子ビットのインデックスが変わらないように定義され、 self のインデックスは other の量子ビットの数だけオフセットされる。 これはQiskitの他の quantum_info 演算子で使われているのと同じ規則です。

この関数は、 ^ の infix 演算子に使用される。 この演算子を使う場合、 Python 'の演算子優先順位規則によって、評価順序が期待したものと異なることがあるので注意すること。 特に、演算子 + は、 ^ よりも強く結合し、 * は、 + よりも強く結合する。 必要であれば、括弧を使って評価順序を固定する。

引数は SparseObservable にキャストされます。

パラメーター

その他 - テンソル積の右辺に置く観測値。

例

このビット順序は、1つのラベルから作られた2つの観測値のテンソル積が、2つの文字列を連結して作られた観測値の「ように見える」ようになっている：

>>> left = SparseObservable.from_label("XYZ")
>>> right = SparseObservable.from_label("+-IIrl")
>>> assert left.tensor(right) == SparseObservable.from_label("XYZ+-IIrl")

また、テンソル積には ^ という infix 演算子を使うこともできる。 SparseObservable:

>>> assert SparseObservable("rl") ^ Pauli("XYZ") == SparseObservable("rlXYZ")

to_sparse_list()

観測値をスパースリスト形式で表現する。

の逆演算と見なすことができる。 SparseObservable.from_sparse_list()しかし、スパース・リストへの往復の後では、項の順序が同じであることは保証されない。

例

>>> obs = SparseObservable.from_list([("IIXIZ", 2j), ("IIZIX", 2j)])
>>> reconstructed = SparseObservable.from_sparse_list(obs.to_sparse_list(), obs.num_qubits)

transpose()

この観測値の行列転置を計算する。

この演算はQiskitの標準的な行列規約の観点から定義され、行列の形が♪Z$計算基底にあるとみなされる。 X項とZ項は転置の影響を受けないが、Y項は転置の影響を受ける。 その通りだ：

• $Y$ に転化する。 $-Y$
• $\lvert r\rangle\langle r\rvert$ に転化する。 $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ に転化する。 $\lvert r\rangle\langle r\rvert$

例

>>> obs = SparseObservable([("III", 1j), ("Yrl", 0.5)])
>>> assert obs.transpose() == SparseObservable([("III", 1j), ("Ylr", -0.5)])

static zero(num_qubits)

与えられた数の量子ビットのゼロ演算子を取得します。

ゼロ作用素は、すべての量子状態に対して期待値がゼロとなる作用素である。 条件はない。 これは、2つのインスタンスの加算のための同一要素である。 SparseObservable ゼロ演算子に追加されたものはそれ自身に等しい。

プロジェクターをオールゼロの状態にしたい場合は、次のようにする：

>>> num_qubits = 10
>>> all_zeros = SparseObservable.from_label("0" * num_qubits)

例

100量子ビットのゼロ演算子を取得します：

>>> SparseObservable.zero(100)
<SparseObservable with 0 terms on 100 qubits: 0.0>