PauliLindbladMap

class qiskit.quantum_info.PauliLindbladMap(data, /, num_qubits=None)

Basen: object

Eine Pauli-Lindblad-Karte, die in einem Qubit-armen Format gespeichert ist.

Mathematik

Eine Pauli-Lindblad-Karte ist eine lineare Karte, die auf Dichtematrizen auf $n$ -qubits der Form wirkt:

\Lambda\bigl[\circ\bigr] = \exp\left(\sum_{P \in K} \lambda_P (P \circ P - \circ)\right)

wobei $K$ eine Teilmenge der $n$ -Qubit-Pauli-Operatoren ist und die Raten bzw. Koeffizienten $\lambda_P$ reelle Zahlen sind. Wenn alle Raten $\lambda_P$ nicht-negativ sind, entspricht dies einer vollständig positiven und spurbewahrenden Abbildung. Die Summe im Exponentialausdruck wird als Generator bezeichnet, und jeder einzelne Term als Generator. Um die Schreibweise im weiteren Verlauf der Dokumentation zu vereinfachen, bezeichnen wir $L(P)\bigl[\circ\bigr] = P \circ P - \circ$ .

Quasi-Wahrscheinlichkeitsdarstellung

Die Karte $\Lambda$ kann als ein Produkt geschrieben werden:

\Lambda\bigl[\circ\bigr] = \prod_{P \in K}\exp\left(\lambda_P(P \circ P - \circ)\right).

Für jede $P$ gilt, dass

\exp\left(\lambda_P(P \circ P - \circ)\right) = \omega(\lambda_P) \circ + (1 - \omega(\lambda_P)) P \circ P,

wobei $\omega(x) = \frac{1}{2}(1 + e^{-2 x})$ . Es ist zu beachten, dass wenn $\lambda_P \geq 0$ , dann $\omega(\lambda_P) \in (\frac{1}{2}, 1]$ , und dieser Term eine vollständig positive und spurenerhaltende Karte ist. Wenn jedoch $\lambda_P < 0$ , dann $\omega(\lambda_P) > 1$ und die Karte ist nicht vollständig positiv oder spurenerhaltend. Wir lassen $\gamma_P = \omega(\lambda_P) + |1 - \omega(\lambda_P)|$ , $p_P = \omega(\lambda_P) / \gamma_P$ und $b_P \in \{0, 1\}$ zu $1$ werden, wenn $\lambda_P < 0$ und $0$ andernfalls, dann schreiben wir die Karte wie folgt um:

\omega(\lambda_P) \circ + (1 - \omega(\lambda_P)) P \circ P = \gamma_P \left(p_P \circ + (-1)^{b_P}(1 - p_P) P \circ P\right).

Wenn $\lambda_P \geq 0$ , $\gamma_P = 1$ und der Ausdruck reduziert sich auf die Standardmischung aus der Identitätskarte und der Konjugation durch $P$ . Wenn $\lambda_P < 0$ , $\gamma_P > 1$ und die Karte eine skalierte Differenz aus der Identitätskarte und der Konjugation durch $P$ ist, mit Wahrscheinlichkeitsgewichten (daher "Quasi-Wahrscheinlichkeit"). Dies ist zwar eine etwas andere Darstellung als in der Literatur, aber diese Notation ermöglicht es uns, sowohl nicht-negative als auch negative Raten gleichzeitig zu behandeln. Die gesamte $\gamma$ des Kanals ist das Produkt $\gamma = \prod_{P \in K} \gamma_P$ .

Siehe die PauliLindbladMap.sample() methode für das Stichprobenverfahren für diese Karte.

Darstellung

Jeder einzelne Pauli-Operator im Generator ist ein Tensorprodukt von Ein-Qubit-Pauli-Operatoren der Form $P = \bigotimes_n A^{(n)}_i$ , für $A^{(n)}_i \in \{I, X, Y, Z\}$ . Die interne Darstellung von a PauliLindbladMap speichert nur die nicht-identischen Ein-Qubit-Pauli-Operatoren. Dies macht es wesentlich effizienter, Generatoren wie $\sum_{n\in \text{qubits}} c_n L(Z^{(n)})$ darzustellen, für die PauliLindbladMap eine Speichermenge benötigt, die linear zur Gesamtzahl der Qubits ist.

Intern speichert es PauliLindbladMap ein Array von Raten und ein QubitSparsePauliList Array, das die entsprechenden spärlichen Pauli-Operatoren enthält. Zusätzlich kann die Gesamtkanal PauliLindbladMap $\gamma$ in der gamma() Methode berechnen, ebenso wie die entsprechenden Wahrscheinlichkeiten $p_P$ über die probabilities() Methode.

Indexierung

PauliLindbladMap verhält sich wie eine Python Folge (die Standardform, nicht die erweiterte collections.abc.Sequence). Die Generatoren der Karte können durch ganze Zahlen indiziert und durchlaufen werden, um einzelne Generatorterme zu erhalten.

Jeder Generatorbegriff erscheint als Instanz einer in sich geschlossenen Klasse. Die einzelnen Begriffe werden aus der Basiskarte kopiert; Änderungen an ihnen wirken sich nicht auf die ursprüngliche Karte aus, aus der sie indiziert werden.

GeneratorTerm

class GeneratorTerm(rate, qubit_sparse_pauli)

GitHub

Basen: object

Ein einzelner Begriff aus einer vollständigen PauliLindbladMap.

Diese werden in der Regel durch Indizierung oder Iteration durch eine PauliLindbladMap.

copy

copy()

Besorgen Sie sich eine Kopie dieses Begriffs.

indices

Nur-Lese-Ansicht auf die Indizes jedes nicht-identischen Ein-Qubit-Terms.

Die Indizes werden immer in sortierter Reihenfolge angezeigt.

num_qubits

Die Anzahl der Qubits, für die der Begriff definiert ist.

pauli_labels

pauli_labels()

Gibt die Pauli-Labels des Terms als String zurück.

Die Pauli-Etiketten entsprechen der Reihenfolge von GeneratorTerm.indices, so dass das i-te Zeichen in der Zeichenkette auf den Qubit-Index auf term.indices[i] angewendet wird. E.g. der Term mit dem Operator X , der auf das Qubit 0 wirkt, und Y , der auf das Qubit 3 wirkt, hat term.indices == np.array([0, 3]) und term.pauli_labels == "XY".

Rückgabe

Die Nicht-Identitäts-Bitbegriffe als verkettete Zeichenfolge.

paulis

Nur-Lese-Ansicht auf die einzelnen Ein-Qubit-Terme.

Die einzigen gültigen Werte im Array sind die mit einem entsprechenden Pauli.

qubit_sparse_pauli

Der Begriff ist qubit_sparse_pauli.

rate

Der Zinssatz der Laufzeit.

to_pauli_lindblad_map

to_pauli_lindblad_map()

Konvertieren Sie diesen Begriff in eine vollständige PauliLindbladMap.

Bauwesen

PauliLindbladMap definiert mehrere Konstruktoren. Der Standardkonstruktor versucht, einen der spezifischeren Konstruktoren zu delegieren, der auf dem Typ der Eingabe basiert. Sie können jederzeit die spezifischen Konstruktoren verwenden, um mehr Kontrolle über die Konstruktion zu haben.

Methode	Zusammenfassung
`from_list()`	Generatoren in Form einer Liste von Tupeln mit dichten Zeichenfolgen und den zugehörigen Raten.
`from_sparse_list()`	Generatoren in Form einer Liste von Tupeln mit spärlichen String-Bezeichnungen, den Qubits, für die sie gelten, und ihren Raten.
`from_terms()`	Summe expliziter Einzel `GeneratorTerm` instanzen.
`from_components()`	Erzeugt aus einem Array von Tarifen und einer `QubitSparsePauliList` instanz.

new

__new__(data, /, num_qubits=None)

Der Standardkonstruktor von PauliLindbladMap.

Dies delegiert an eine der expliziten Konvertierungs-Konstruktor-Methoden, basierend auf dem Typ des data Arguments. Wenn num_qubits übergeben wird und der Konstruktor, der durch den Typ von data impliziert wird, keine Zahl akzeptiert, muss die angegebene Ganzzahl mit der Eingabe übereinstimmen.

Parameter

data - Der Datentyp der Eingabe. Dies kann eine andere PauliLindbladMapsein, in diesem Fall wird die Eingabe kopiert, oder es kann eine Liste in einem gültigen Format für entweder from_list() oder sein from_sparse_list().
num_qubits (int|None) – Optionale Anzahl von Qubits für die Karte. Bei den meisten Dateneingaben kann dies abgeleitet werden und muss nicht angegeben werden. Sie ist nur für leere Listen oder das Sparse-List-Format erforderlich. Wenn sie unnötig angegeben wird, muss sie mit den eingegebenen Daten übereinstimmen.

Zusätzlich zu den konvertierungsbasierten Konstruktoren gibt es auch Hilfsmethoden, die spezielle Formen von Maps konstruieren.

Methode	Zusammenfassung
`identity()`	Die Identitätskarte für eine bestimmte Anzahl von Qubits.

Konvertierungen

Ein bestehendes PauliLindbladMap kann in andere Formate konvertiert werden.

Methode	Zusammenfassung
`to_sparse_list()`	Drücken Sie die Karte in einem spärlichen Listenformat mit den Elementen `(paulis, indices, rate)` aus.

Attribute

num_qubits

Die Anzahl der Qubits, auf die die Karte wirkt.

Dies lässt sich nicht aus anderen Formen oder Werten ableiten, da Identitäten nicht explizit gespeichert werden.

num_terms

Die Anzahl der Generatorterme im Exponenten für diese Karte.

rates

Die Preise für die Karte.

Methoden

apply_layout

apply_layout(layout, num_qubits=None)

Wenden Sie ein Transpiler-Layout auf diese Pauli-Lindblad-Karte an.

Dies ermöglicht die Neuzuordnung von Qubit-Indizes, z. B. wenn die Karte in Form von virtuellen Qubit-Labels definiert ist.

Parameter

layout (TranspileLayout |list[int] | None) – Das anzuwendende Layout. In den meisten Fällen sollte bei der Verwendung dieser Funktion das QuantumCircuit.layout Feld aus einem Schaltkreis übergeben werden, der für die Hardware transpiliert wurde. Außerdem können Sie eine Liste mit neuen Qubit-Indizes übergeben. NoneWird dies explizit angegeben, wird keine Neuzuordnung vorgenommen (Sie können jedoch weiterhin verwenden num_qubits , um die Zuordnung zu erweitern).
num_qubits (int | None) – Die Anzahl der Qubits, auf die die Karte erweitert werden soll. Falls nicht angegeben, ist die Ausgabe so breit wie die angegebene TranspileLayoutoder die gleiche Breite wie die Eingabe, wenn layout in einer anderen Form angegeben wird.

Rückgabe

Eine neue PauliLindbladMap mit dem angegebenen Layout.

clear

clear()

Löscht alle Generatorterme aus dieser Karte, so dass sie wieder mit der Identitätskarte übereinstimmt.

Dies hat keinen Einfluss auf die Kapazität der internen Zuweisungen, sodass bei nachfolgenden Additions- oder Subtraktionsoperationen, die sich aus der Zusammensetzung ergeben, möglicherweise keine Neuzuweisung erforderlich ist.

Beispiele

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IXXXYY", 2.0), ("ZZYZII", -1)])
>>> pauli_lindblad_map.clear()
>>> assert pauli_lindblad_map == PauliLindbladMap.identity(pauli_lindblad_map.py_num_qubits())

compose

compose(other)

Mit einem anderen komponieren PauliLindbladMap.

Dadurch werden die internen Arrays von self und other angehängt, so dass eine Map entsteht, deren aufgezählte Begriffe die von self sind, gefolgt von denen von other.

Parameter

other (PauliLindbladMap) – die Pauli-Lindblad-Karte, mit der man komponieren kann.

copy

copy()

Besorgen Sie sich eine Kopie dieser Pauli Lindblad-Karte.

Beispiele

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IXZXYYZZ", 2.5), ("ZXIXYYZZ", 0.5)])
>>> assert pauli_lindblad_map == pauli_lindblad_map.copy()
>>> assert pauli_lindblad_map is not pauli_lindblad_map.copy()

drop_paulis

drop_paulis(indices)

Streiche Paulis aus dieser Pauli-Lindblad-Karte.

Lassen Sie alle Pauli auf den gegebenen Indizes fallen und ersetzen Sie sie durch eine Identität.

Die resultierende Karte kann Duplikate enthalten, die mit der PauliLindbladMap.simplify() methode entfernt werden.

Parameter

indices (Sequence[int]) – Die Indizes, für die Paulis fallen gelassen werden muss.

Rückgabe

Eine neue Pauli-Lindblad-Karte, bei der alle Pauli auf den angegebenen Indizes gestrichen wurden.

Beispiele

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_paulis([1, 2, 4])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("IXIII", 2.0), ("IIIIZ", 0.5), ("IIIIY", -0.25)])

drop_qubits

drop_qubits(indices)

Aus dieser Pauli-Lindblad-Karte werden Qubits herausgenommen, wodurch eine Trace-out-Operation durchgeführt wird.

Die resultierende Karte kann Duplikate enthalten, die mit der PauliLindbladMap.simplify() methode entfernt werden.

Parameter

indices (Sequence[int]) – Die Indizes der zu erfassenden Qubits.

Rückgabe

Eine neue Pauli-Lindblad-Karte, auf der jedes Pauli auf den gegebenen Indizes eingezeichnet ist.

Beispiele

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.drop_qubits([1, 2, 4])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("XI", 2.0), ("IZ", 0.5), ("IY", -0.25)])

from_components

static from_components(rates, qubit_sparse_pauli_list)

from_list

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

Konstruieren Sie eine Pauli-Lindblad-Karte aus einer Liste von dichten Generatorbezeichnungen und Raten.

Dies ist vergleichbar mit SparsePauliOp.from_list(). In dieser dichten Form müssen Sie alle Identitäten explizit in jedem Etikett angeben.

Die Bezeichnung muss eine Folge des Alphabets 'IXYZ' sein. Das Label wird analog zu einem Bitstring interpretiert. Mit anderen Worten: Der Buchstabe ganz rechts ist dem Qubit 0 zugeordnet usw. Dies ist dasselbe wie die Bezeichnungen für Pauli und SparsePauliOp.

Parameter

iter (list[tuple[str, float]]) – Paare von Etiketten und ihre zugehörigen Sätze in der Generatorsumme.
num_qubits (int | None) – Es ist nicht notwendig, dies anzugeben, wenn Sie sicher sind, dass iter keine leere Sequenz ist, da sie aus den Etikettenlängen abgeleitet werden kann. Wenn iter leer sein kann, müssen Sie dieses Argument angeben, um zu verdeutlichen, auf wie viele Qubits die Karte wirkt. Wenn dies angegeben wird und iter nicht leer ist, muss der Wert mit den Etikettenlängen übereinstimmen.

Beispiele

Konstruieren Sie eine Pauli-Lindblad-Karte aus einer Liste von Etiketten:

>>> PauliLindbladMap.from_list([
...     ("IIIXX", 1.0),
...     ("IIYYI", 1.0),
...     ("IXXII", -0.5),
...     ("ZZIII", -0.25),
... ])
<PauliLindbladMap with 4 terms on 5 qubits:
    (1)L(X_1 X_0) + (1)L(Y_2 Y_1) + (-0.5)L(X_3 X_2) + (-0.25)L(Z_4 Z_3)>

Verwenden Sie num_qubits , um potenziell leere Eingaben zu disambiguieren:

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

Diese Methode ist äquivalent zu Aufrufen von from_sparse_list() mit dem expliziten Feld qubit-arguments, das auf abnehmende Ganzzahlen gesetzt ist:

>>> labels = ["XYXZ", "YYZZ", "XYXZ"]
>>> rates = [1.5, 2.0, -0.5]
>>> from_list = PauliLindbladMap.from_list(list(zip(labels, rates)))
>>> from_sparse_list = PauliLindbladMap.from_sparse_list([
...     (label, (3, 2, 1, 0), rate)
...     for label, rate in zip(labels, rates)
... ])
>>> assert from_list == from_sparse_list

Siehe auch

from_sparse_list()

Konstruieren Sie die Karte aus einer Liste von Bezeichnungen ohne explizite Identitäten, aber mit den explizit aufgeführten Qubits, auf die sich jeder Ein-Qubit-Generatorbegriff bezieht.

from_sparse_list

static from_sparse_list(iter, /, num_qubits)

Konstruieren Sie eine Pauli-Lindblad-Karte aus einer Liste von Bezeichnungen, den Qubits, auf die jedes Element zutrifft, und der Rate des gesamten Terms.

Dies ist vergleichbar mit SparsePauliOp.from_sparse_list().

Die Felder "labels" und "indices" der Tripel werden durch Zipping miteinander verbunden. Das bedeutet zum Beispiel, dass ein Aufruf von from_list() in die von dieser Methode verwendete Form umgewandelt werden kann, indem das Feld "indices" jedes Tripels auf (num_qubits-1, ..., 1, 0) gesetzt wird.

Parameter

iter (list[tuple[str, Sequence[int], float]]) – dreiergruppen von Bezeichnungen, die Qubits, auf die sich jeder Ein-Qubit-Term bezieht, und die Rate des gesamten Terms.
num_qubits (int) – die Anzahl der Qubits, auf die die Karte wirkt.

Beispiele

Konstruieren Sie eine einfache Karte:

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

Diese Methode kann das Verhalten von from_list()replizieren, wenn das Feld "Qubit-Argumente" des Tripels auf abnehmende Ganzzahlen gesetzt wird:

>>> labels = ["XYXZ", "YYZZ", "XYXZ"]
>>> rates = [1.5, 2.0, -0.5]
>>> from_list = PauliLindbladMap.from_list(list(zip(labels, rates)))
>>> from_sparse_list = PauliLindbladMap.from_sparse_list([
...     (label, (3, 2, 1, 0), rate)
...     for label, rate in zip(labels, rates)
... ])
>>> assert from_list == from_sparse_list

Siehe auch

to_sparse_list()

Die Umkehrung dieser Methode.

from_terms

static from_terms(obj, /, num_qubits=None)

Konstruieren Sie einen PauliLindbladMap aus den einzelnen Begriffen.

Alle Begriffe müssen die gleiche Anzahl von Qubits haben. Falls angegeben, muss das Argument num_qubits mit den Begriffen übereinstimmen.

Im Rahmen der Kartenerstellung wird keine Vereinfachung vorgenommen.

Parameter

obj (Iterable[Term]) – Iterable der einzelnen Begriffe, aus denen der Kartengenerator aufgebaut wird.
num_qubits (int | None) – Die Anzahl der Qubits, auf die die Karte wirken soll. Dies wird normalerweise aus der Eingabe abgeleitet, kann aber auch explizit angegeben werden, um den Fall einer leeren Iterable zu behandeln.

Rückgabe

Die entsprechende Karte.

gamma

gamma()

Berechnen Sie die $\gamma$ für die Karte.

generators

generators()

Rufe die Generatoren der Karte ab.

Dies ist ein Alias für get_qubit_sparse_pauli_list_copy(), der einen benutzerfreundlicheren Namen bietet, der den in Aer und Runtime für ähnliche Klassen verwendeten Namenskonventionen entspricht.

Rückgabe

Eine Kopie der Bedingungen für den Kartengenerator.

Rückgabetyp

QubitSparsePauliList

get_qubit_sparse_pauli_list_copy

get_qubit_sparse_pauli_list_copy()

Erhalten Sie eine Kopie der Qubit-Sparse-Pauli-Liste der Karte.

identity

static identity(num_qubits)

Ermittelt die Identitätskarte für die angegebene Anzahl von Qubits.

Die Identitätskarte enthält keine Generatorterme und ist das Identitätselement für die Komposition von zwei PauliLindbladMap instanzen; alles, was mit der Identitätskarte komponiert wird, ist gleich sich selbst.

Beispiele

Ermitteln Sie die Identitätskarte für 100 Qubits:

>>> PauliLindbladMap.identity(100)
<PauliLindbladMap with 0 terms on 100 qubits: 0.0>

inverse

inverse()

Gibt ein neues PauliLindbladMap zurück, das die mathematische Umkehrung von self ist.

keep_paulis

keep_paulis(indices)

Behalten Sie alle Pauli auf den angegebenen Indizes und lassen Sie alle anderen fallen.

Dies ist gleichbedeutend mit der Verwendung von PauliLindbladMap.drop_paulis() auf die Komplementmenge der Indizes.

Parameter

indices (Sequence[int]) – Die Indizes, für die Paulis aufbewahrt werden müssen.

Rückgabe

Eine neue Pauli-Lindblad-Karte, bei der jeder Pauli auf den gegebenen Indizes beibehalten wurde und alle anderen Paulis gestrichen wurden.

Beispiele

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_paulis([0, 3])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("IXIII", 2.0), ("IIIIZ", 0.5), ("IIIIY", -0.25)])

keep_qubits

keep_qubits(indices)

Behalte jedes Qubit auf den angegebenen Indizes und verfolge alle anderen Qubits.

Dies ist gleichbedeutend mit der Verwendung von PauliLindbladMap.drop_qubits() auf die Komplementmenge der Indizes.

Parameter

indices (Sequence[int]) – Die Indizes, für die Qubits aufbewahrt werden müssen.

Rückgabe

Eine neue Pauli-Lindblad-Karte, bei der jedes Qubit auf den gegebenen Indizes beibehalten wurde und alle anderen Qubits herausgefiltert wurden.

Beispiele

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_qubits([0, 3])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("XI", 2.0), ("IZ", 0.5), ("IY", -0.25)])

parity_sample

parity_sample(num_samples, seed=None, scale=None, local_scale=None)

Beispielhafte Vorzeichen- und Pauli-Operator-Paare aus der Karte.

Jedes Zeichen wird durch einen booleschen Wert dargestellt, wobei True für -1und False für steht +1.

Ausgehend von der in der Klassendokumentation angegebenen Quasi-Wahrscheinlichkeitsdarstellung wird jede Stichprobe nach dem folgenden Verfahren gezogen:

Initialisieren Sie das boolesche Vorzeichen und eine QubitSparsePauli instanz mit dem Identitätsoperator.
Iterieren Sie durch jedes Pauli auf der Karte. Wählen Sie anhand der mit jedem Operator verbundenen Pseudowahrscheinlichkeit nach dem Zufallsprinzip aus, ob Sie den Operator anwenden oder nicht.
Wenn der Operator angewandt wird, aktualisieren Sie :class`QubitSparsePauli` durch Multiplikation mit dem Pauli. Wenn der mit Pauli verbundene Satz negativ ist, wird das Vorzeichen boolesch umgedreht.

Die Ergebnisse werden als 1d array of booleans zurückgegeben, und die entsprechenden abgetasteten Qubits sparse Paulis in Form von a QubitSparsePauliList.

Die Argumente scale und local_scale können verwendet werden, um die zugrunde liegenden Raten zu ändern, die im Stichprobenverfahren verwendet werden, ohne die aktuelle Instanz zu ändern oder eine neue erstellen zu müssen. Das scale Argument skaliert alle Zinssätze um einen festen Float-Wert und local_scale skaliert die Zinssätze auf Basis der einzelnen Laufzeiten.

Parameter

num_samples (int) – Anzahl der zu ziehenden Proben.
seed (int) – Zufälliges Saatgut.
scale (float) – Für alle Tarife geltende Skala.
local_scale (list[float]) – Lokale Skala, die auf Semesterbasis anzuwenden ist.

Rückgabe

Das boolesche Array der Vorzeichen und die Liste der Qubit-Sparse-Paulis.

Rückgabetyp

zeichen, qubit_sparse_pauli_list

parity_sample_with_history

parity_sample_with_history(num_samples, seed=None, scale=None, local_scale=None)

Wähle aus der Abbildung Paare aus Vorzeichen und Pauli-Operatoren aus, wobei die ausgewählten Generatoren beibehalten werden.

Diese Methode ist identisch mit parity_sample() , abgesehen davon, dass zusätzlich die Informationen zurückgegeben werden, die generators() tatsächlich abgetastet wurden, um den endgültigen Pauli-Operator und das Vorzeichen zu erhalten.

Parameter

num_samples (int) – Anzahl der zu ziehenden Proben.
seed (int) – Zufälliges Saatgut.
scale (float) – Für alle Tarife geltende Skala.
local_scale (list[float]) – Lokale Skala, die auf Semesterbasis anzuwenden ist.

Rückgabe

Das Boolesche Array von

Vorzeichen, die Liste der spärlichen Pauli-Operatoren der Qubits, das zweidimensionale Boolesche Array, das angibt, welche generators() davon abgetastet wurden, und das zweidimensionale Boolesche Array, das ihre Vorzeichen angibt.

Rückgabetyp

signs, qubit_sparse_pauli_list, pauli_history, signs_history

pauli_fidelity

pauli_fidelity(qubit_sparse_pauli)

Berechnen Sie die Pauli-Treue dieser Karte für ein spärliches Pauli-Qubit.

Für eine Pauli $Q$ ist die Treue in Bezug auf die Pauli-Lindblad-Karte $\Lambda$ die reelle Zahl $f(Q)$ für die $\Lambda(Q) = f(Q) Q$ . I.e. jeder Pauli ist ein Eigenvektor der linearen Karte $\Lambda$ , und die Treue ist der entsprechende Eigenwert. Für eine Pauli-Lindblad-Karte mit der Generatormenge $K$ und der Ratefunktion $\lambda : K \rightarrow \mathbb{R}$ ist die Pauli-Treue mathematisch

f(Q) = \exp\left(-2 \sum_{P \in K} \lambda(P) \langle P, Q\rangle_{sp}\right),

wobei $\langle P, Q\rangle_{sp}$ gleich $0$ ist, wenn $P$ und $Q$ gependelt werden, und $1$ , wenn sie nicht gependelt werden.

Args: qubit_sparse_pauli ( QubitSparsePauli ): das qubit sparse Pauli zur Berechnung des Pauli

treue von.

probabilities

probabilities()

Berechnen Sie die Wahrscheinlichkeiten $p_P$ für die Karte. Diese können als Wahrscheinlichkeiten interpretiert werden, mit denen jeder Generator nicht angewendet wird, und sind unabhängig vom Vorzeichen jeder Lindblad-Rate definiert.

sample

sample(num_samples, seed=None)

Für PauliLindbladMap Fälle mit rein nicht-negativen Raten werden Pauli-Operatoren aus der Abbildung entnommen. Wenn die Karte negative Zinssätze enthält, verwenden Sie PauliLindbladMap.parity_sample().

Ausgehend von der in der Klassendokumentation angegebenen Quasi-Wahrscheinlichkeitsdarstellung wird jede Stichprobe nach dem folgenden Verfahren gezogen:

Initialisieren Sie eine :class`~.QubitSparsePauli` -Instanz für den Identitätsoperator.
Iterieren Sie durch jedes Pauli auf der Karte. Wählen Sie anhand der mit jedem Operator verbundenen Pseudowahrscheinlichkeit nach dem Zufallsprinzip aus, ob Sie den Operator anwenden oder nicht.
Wenn der Operator angewandt wird, aktualisieren Sie :class`QubitSparsePauli` durch Multiplikation mit dem Pauli.

Die abgetasteten Qubits sparse Paulis werden in Form eines QubitSparsePauliList.

Parameter

num_samples (int) – Anzahl der zu ziehenden Proben.
seed (int) – Zufälliges Saatgut. Der Standardwert ist None.

Rückgabe

Die Liste der Qubit-Sparse-Paulis.

Rückgabetyp

qubit_sparse_pauli_list

Erhöht

ValueError - Wenn einer der Kurse auf der Karte negativ ist.

scale_rates

scale_rates(scale_factor)

Rückgabe einer neuen PauliLindbladMap mit Raten, die mit scale_factor skaliert sind.

Parameter

scale_factor (float) – der Skalierungskoeffizient.

signed_sample

signed_sample(num_samples, seed=None)

Beispielpaare von Vorzeichen und Pauli-Operatoren aus der Karte. Beachten Sie, dass die boolesche Vorzeichenkonvention in dieser Methode nicht dem Standard entspricht. Die bevorzugte Methode für diese Art der Stichprobenziehung ist PauliLindbladMap.parity_sample(), die auch mehr Funktionen bietet.

Jedes Zeichen wird durch einen Booleschen Wert dargestellt, wobei True für +1 und False für -1 steht.

Ausgehend von der in der Klassendokumentation angegebenen Quasi-Wahrscheinlichkeitsdarstellung wird jede Stichprobe nach dem folgenden Verfahren gezogen:

Initialisieren Sie das boolesche Vorzeichen und eine QubitSparsePauli instanz mit dem Identitätsoperator.
Iterieren Sie durch jedes Pauli auf der Karte. Wählen Sie anhand der mit jedem Operator verbundenen Pseudowahrscheinlichkeit nach dem Zufallsprinzip aus, ob Sie den Operator anwenden oder nicht.
Wenn der Operator angewandt wird, aktualisieren Sie :class`QubitSparsePauli` durch Multiplikation mit dem Pauli. Wenn der mit Pauli verbundene Satz negativ ist, wird das Vorzeichen boolesch umgedreht.

Die Ergebnisse werden als 1d array of booleans zurückgegeben, und die entsprechenden abgetasteten Qubits sparse Paulis in Form von a QubitSparsePauliList.

Parameter

num_samples (int) – Anzahl der zu ziehenden Proben.
seed (int) – Zufälliges Saatgut.

Rückgabe

Das boolesche Array der Vorzeichen und die Liste der Qubit-Sparse-Paulis.

Rückgabetyp

zeichen, qubit_sparse_pauli_list

simplify

simplify(tol=1e-08)

Summiere alle gleichartigen Terme im Generator und entferne sie, wenn der resultierende Wert innerhalb der Toleranz von Null liegt. Dadurch werden auch Terme entfernt, deren Pauli-Operator proportional zur Identitätsfunktion ist, da der entsprechende Generator tatsächlich die Nullabbildung ist.

Als Nebeneffekt sortiert dies die Generatoren in eine feste kanonische Reihenfolge.

Anmerkung

Beachten Sie bei der Verwendung für Gleichheitsvergleiche, dass die Rundung bei Gleitkommazahlen und die Nichtassoziativität der Gleitkommaaddition dazu führen können, dass Koeffizienten von Summanden, die ungleich Null sind, als ungleich verglichen werden. Um zwei Observablen bis auf eine Toleranzgrenze zu vergleichen, ist es am sichersten, die kanonisierte Differenz der beiden Observablen mit Null zu vergleichen.

Parameter

tol (float) – nach der Summierung gleichartiger Terme werden alle Raten, deren absoluter Wert unter der angegebenen absoluten Toleranz liegt, bei der Ausgabe unterdrückt.

Beispiele

Verwendung von simplify() um zwei Operatoren zu vergleichen, die dieselbe Karte darstellen, aber aufgrund der standardmäßigen Strukturtests ungleiche Ergebnisse liefern würden:

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

Im obigen Beispiel sind die Koeffizienten so gewählt, dass alle Fließkommaberechnungen exakt sind und es keine Probleme mit der Rundung oder Assoziativität gibt. Wenn dies nicht garantiert werden kann, ist die sicherere Form:

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

to_sparse_list

to_sparse_list()

Drücken Sie die Karte in einem spärlichen Listenformat aus.

Dies kann als Gegenoperation von PauliLindbladMap.from_sparse_list()gesehen werden, allerdings ist nicht garantiert, dass die Reihenfolge der Terme nach einem Roundtrip zu einer Sparse-Liste und zurück dieselbe ist.

Beispiele

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IIXIZ", 2), ("IIZIX", 3)])
>>> reconstructed = PauliLindbladMap.from_sparse_list(pauli_lindblad_map.to_sparse_list(), pauli_lindblad_map.num_qubits)

Siehe auch

from_sparse_list()

Der Konstruktor, der diese Listen interpretieren kann.

War diese Seite hilfreich?

Melden Sie auf GitHub einen Fehler, einen Tippfehler oder fordern Sie Inhalte an.