SparseObservable

__new__(data, /, num_qubits=None)

Der Standardkonstruktor von SparseObservable.

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 SparseObservablesein, in diesem Fall wird die Eingabe kopiert, ein Pauli oder SparsePauliOpsein, wobei in diesem Fall from_pauli() oder from_sparse_pauli_op() entsprechend aufgerufen werden, 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 den Operator. 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.

Eine flache Liste von Ein-Qubit-Termen. Dies ist natürlich eher eine Liste von Listen, wird aber aus Gründen der Speichernutzung und der Lokalisierung flach gespeichert, wobei die Unterlisten durch Grenzen gekennzeichnet sind.

Indizes, die die bit_terms und indices in Unterlisten für jeden einzelnen Begriff in der Summe aufteilen. boundaries[0] : boundaries[1] ist der Bereich der Indizes in bit_terms und indices die dem ersten Term der Summe entsprechen. Alle nicht spezifizierten Qubit-Indizes sind implizit die Identität. Dies ist ein Element länger als coeffs, da boundaries[0] immer eine explizite Null ist (zur Vereinfachung des Algorithmus).

Die Koeffizienten der einzelnen abstrakten Terme in der Summe. Diese hat so viele Elemente wie Terme in der Summe.

Eine flache Liste der Qubit-Indizes, auf die die entsprechenden Einträge in bit_terms wirken. Diese Liste muss immer nach Begriffen sortiert sein, wobei ein Begriff eine Unterliste ist, die mit boundaries.

Die Anzahl der Qubits, auf die der Operator wirkt.

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

Die Anzahl der Terme in der Summe, die dieser Operator verfolgt.

adjoint()

Berechnen Sie die Adjungierte dieser Beobachtungsgröße.

Dies ist im abstrakten mathematischen Sinne gut definiert. Alle Terme des Ein-Qubit-Alphabets sind selbstadjungiert, so dass das Ergebnis dieser Operation dieselbe Beobachtungsgröße ist, nur dass die Koeffizienten alle konjugiert komplex sind.

Beispiele

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

apply_layout(layout, num_qubits=None)

Wenden Sie ein Transpiler-Layout auf diese SparseObservable.

In der Regel haben Sie Ihre Beobachtungsgröße in Form der virtuellen Qubits der Schaltkreise definiert, die Sie zur Vorbereitung von Zuständen verwenden werden. Nach der Transpilierung werden die virtuellen Qubits bestimmten physischen Qubits auf einem Gerät zugeordnet, das breiter als Ihr Schaltkreis sein kann. Diese Zuordnung kann sich auch im Laufe der Schaltung ändern. Mit dieser Methode wird die Eingangsbeobachtung auf virtuellen Qubits in eine Beobachtung umgewandelt, die unmittelbar nach dem vollständig umgesetzten physikalischen Schaltkreis angewendet werden kann.

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 Beobachtbare zu erweitern).
• num_qubits (int | None) – Die Anzahl der Qubits, auf die die Observable 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 SparseObservable mit dem angegebenen Layout.

as_paulis()

Drücken Sie die beobachtbare Größe nur in Pauli-Termen aus, indem Sie jeden Projektor als Summe von Pauli-Termen schreiben.

Beachten Sie, dass es keine Garantie für die Ordnung der resultierenden Pauli-Terme gibt. Verwenden Sie SparseObservable.simplify() zusätzlich, um eine kanonische Darstellung zu erhalten.

Rückgabe

Die gleiche Beobachtung, aber nur in Pauli-Termen ausgedrückt.

Beispiele

Umschreiben einer beobachtbaren Größe in Form von Projektoren in Pauli-Operatoren:

>>> 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()

Für kleine Operatoren kann dies mit simplify() als eine eindeutige kanonische Form verwendet werden:

>>> 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()

Löscht alle Terme aus diesem Operator und macht ihn wieder gleich dem Null-Operator.

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

Beispiele

>>> 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)

Überprüfen Sie, ob die beobachtbare Größe mit einer anderen kommutiert.

Parameter

• other (SparseObservable) – Das andere Beobachtungselement, mit dem die Kommutierung überprüft werden kann.
• tol (float) – Wenn die Koeffizienten im Produkt von Selbst und Anderen unterhalb der Toleranz (in der Größe) liegen, werden die Terme ignoriert.

Rückgabe

True wenn die Bedingungen bis auf Toleranzen austauschbar sind, andernfalls False .

Erhöhungen

TypeError – Wenn nicht dazu gezwungen other werden SparseObservable konnte,.

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

Fügen Sie eine weitere SparseObservable auf dieses.

In Bezug auf Operator-Algebren entspricht die Komposition der Links-Multiplikation: c = a.compose(b) entspricht $C = B A$. Mit anderen Worten: a.compose(b) liefert einen Operator, der " a ausführt und dann b auf das Ergebnis anwendet". Das Argument front=True macht dies zu einer Rechtsmultiplikation.

self und other müssen gleich groß sein, es sei denn, qargs ist angegeben. In diesem Fall kann other kleiner sein als self, sofern die Anzahl der Qubits in other und die Länge von qargs übereinstimmen. qargs kann niemals Duplikate oder Indizes von Qubits enthalten, die in self nicht existieren.

Beachten Sie, dass diese Funktion zu einer exponentiellen Explosion des Speicherverbrauchs der Observablen führen kann, da das Alphabet von SparseObservable bei der Komposition nicht geschlossen ist; die Komposition von zwei Einzelbit-Termen kann eine Summe sein, die die Gesamtzahl der Terme vervielfacht. Dieser Speicherverbrauch ist nicht zwangsläufig mit der resultierenden Beobachtungsgröße verbunden, aber die Suche nach einer effizienten Neuformulierung der Summe ist im Allgemeinen ebenso rechenintensiv. Es ist besser, das Fachwissen über die Beobachtungswerte zu nutzen, um die Anzahl der Begriffe zu minimieren, anstatt zu versuchen, sie nachträglich zu vereinfachen.

Parameter

• andere - die für die Linksmultiplikation verwendete Beobachtungsgröße self.

• qargs -

  falls gegeben, die Qubits in self , die mit den Qubits in other verbunden werden sollen. Anders ausgedrückt: Wenn dies gegeben ist, ist es ähnlich wie eine effizientere Implementierung von:

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

  da keine temporäre Observable erstellt wird, um die angewandte Layoutform von other zu speichern.

• front - wenn True, dann rechtsmultiplizieren mit other statt linksmultiplizieren (Standardwert False). Die qargs sind weiterhin auf other zu finden. Dies ist besonders nützlich, wenn qargs gesetzt ist, oder other ein Objekt ist, das gezwungen werden muss, um SparseObservable.

conjugate()

Berechnen Sie die komplexe Konjugation dieser Beobachtungsgröße.

Diese Operation wird gemäß den Standard-Matrixkonventionen von Qiskit definiert, d. h. die Matrixform wird als $Z$-Rechenbasis betrachtet. Die $X$- und $Z$-bezogenen Alphabetterme bleiben von der komplexen Konjugation unberührt, aber $Y$-bezogene Terme ändern ihre Alphabetterme. Ganz genau:

• $Y$ konjugiert zu $-Y$
• $\lvert r\rangle\langle r\rvert$ konjugiert zu $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ konjugiert zu $\lvert r\rangle\langle r\rvert$

Außerdem sind alle Koeffizienten konjugiert.

Beispiele

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

copy()

Holen Sie sich eine Kopie dieses Observablen.

Beispiele

>>> 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)

Führe eine Entwicklung dieses Observables um einen Pauli-Term durch.

Eine Entwicklung des Observables $O$ durch eine Pauli- $P$ entspricht $P^\dagger O P$.

Im Gegensatz zu einer wörtlichen Umsetzung mittels zweier vollständiger Kompositionen führt diese Methode die Konjugation direkt auf der Ebene einzelner Qubits unter Verwendung einer festen Nachschlagetabelle durch. Dadurch wird die Materialisierung von Zwischenausdrücken vermieden SparseObservable , und die entwickelte Observable wird in einem einzigen Durchlauf über die Terme berechnet. self und other müssen dieselbe Anzahl an Qubits aufweisen, es sei denn, qargs ist vorgegeben; in diesem Fall other kann kleiner als sein self, vorausgesetzt, die Anzahl der Qubits in other und die Länge von qargs stimmen überein. qargs gibt an, welche Qubits von durch self entwickelt other werden.

Derzeit unterstützt diese Methode nur die Entwicklung durch einen Ein-Term -Operator, was bedeutet, dass ein durch dargestellter other PauliPauli-Operator sein muss.

Parameter

• anderes – der Pauli-Operator, der zur Konjugation selfverwendet wird.
• qargs – falls angegeben, die Qubits in, die durch self entwickelt werden other sollen. Die Länge muss mit der Anzahl der Qubits in otherübereinstimmen.

Rückgabe

Eine neue Entwicklung SparseObservable mit angewandten Konjugationen.

Erhöhungen

• TypeError – wenn nicht vom other Typ ist Pauli.
• ValueError – wenn self und eine unterschiedliche other Anzahl von Qubits haben (und nicht gegeben qargs ist).
• ValueError – wenn qargs die Länge nicht mit other der Anzahl der Qubits übereinstimmt.
• ValueError – wenn Duplikate oder Indizes außerhalb qargs des zulässigen Bereichs enthält.
• ValueError – wenn mehr als einen other Term enthält.

expand(other, /)

Tensorprodukt umgekehrter Ordnung.

Dies ist äquivalent zu other.tensor(self), außer dass other zuerst in den Typ SparseObservable umgewandelt wird, wenn es nicht bereits einer ist (durch Aufruf des Standardkonstruktors).

Parameter

andere - die Beobachtungsgröße, die auf der linken Seite des Tensorprodukts steht.

Beispiele

Dies ist äquivalent zu tensor() wobei die Reihenfolge der Argumente vertauscht ist:

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

static from_label(label, /)

Konstruieren Sie eine Beobachtungsgröße mit einem einzigen Begriff aus einem dichten String-Label.

Der resultierende Operator hat einen Koeffizienten von 1. Die Bezeichnung muss eine Folge des Alphabets 'IXYZ+-rl01' 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

label (str) – das dichte Etikett.

Beispiele

>>> 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)

Konstruieren Sie eine Observable aus einer Liste von dichten Etiketten und Koeffizienten.

Dies ist analog zu SparsePauliOp.from_list()mit der Ausnahme, dass es das erweiterte Alphabet von SparseObservable. In dieser dichten Form müssen Sie alle Identitäten explizit in jedem Etikett angeben.

Die Bezeichnung muss eine Folge des Alphabets 'IXYZ+-rl01' 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, complex]]) – Paare von Etiketten und ihre zugehörigen Koeffizienten, die zu addieren sind. Die Bezeichnungen werden auf die gleiche Weise interpretiert wie in from_label().
• 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, für wie viele Qubits das Observable gilt. Wenn dies angegeben wird und iter nicht leer ist, muss der Wert mit den Etikettenlängen übereinstimmen.

Beispiele

Konstruieren Sie ein Observable aus einer Liste von Etiketten gleicher Länge:

>>> 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)>

Verwenden Sie num_qubits , um potenziell leere Eingaben zu disambiguieren:

>>> SparseObservable.from_list([], num_qubits=10)
<SparseObservable 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 = ["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, /)

Konstruieren Sie eine SparseObservable aus einer einzelnen Pauli instanz.

Die Ausgangsgröße hat einen einzigen Term mit einem von der Phase abhängigen Einheitskoeffizienten.

Parameter

pauli (Pauli) – den einzelnen Pauli zu konvertieren.

Beispiele

>>> 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)

Konstruieren Sie eine SparseObservable aus rohen Numpy-Arrays, die der in der Dokumentation auf Klassenebene beschriebenen erforderlichen Datendarstellung entsprechen.

Die Daten aus jedem Array werden in neue, erweiterbare Rust-Space-Zuweisungen kopiert.

Parameter

• num_qubits - Anzahl der Qubits in der Beobachtungsgröße.

• coeffs - komplexe Koeffizienten der einzelnen Terme der Beobachtungsgröße. Dies sollte ein Numpy-Array mit dtype sein complex128.

• bit_terms - abgeflachte Liste der Ein-Qubit-Terme, die alle vollständigen Terme enthält. Dies sollte ein Numpy-Array mit dtype sein uint8 (der kompatibel ist mit BitTerm).

• indizes - abgeflachte, termweise sortierte Liste der Qubits, denen jeder Ein-Qubit-Term entspricht. Dies sollte ein Numpy-Array mit dtype sein uint32.

• grenzen - die Indizes, die bit_terms und indices in Begriffe unterteilen. Dies sollte ein Numpy-Array mit dtype sein uintp.

• prüfen -

  falls True (Standardeinstellung), überprüfen Sie, ob die Daten alle Kohärenzgarantien erfüllen. Wenn False, werden keine Kontrollen durchgeführt.

  Achtung

  Wenn check=False, müssen die bit_terms unbedingt alle gültige Werte von SparseObservable.BitTerm. Ist dies nicht der Fall, kann es zu einem undefinierten Verhalten im Rust-Space kommen, das die Programmausführung vollständig ungültig macht.

Beispiele

Bilden Sie eine Summe von $Z$ für jedes einzelne Qubit:

>>> 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)

Konstruieren Sie eine Observable aus einer Liste von Bezeichnungen, den Qubits, auf die jedes Element zutrifft, und dem Koeffizienten des gesamten Terms.

Dies ist analog zu SparsePauliOp.from_sparse_list()mit der Ausnahme, dass es das erweiterte Alphabet von SparseObservable.

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], complex]]) – dreiergruppen von Bezeichnungen, die Qubits, auf die sich jeder Ein-Qubit-Term bezieht, und der Koeffizient des gesamten Terms.
• num_qubits (int) – die Anzahl der Qubits im Operator.

Beispiele

Konstruieren Sie einen einfachen Operator:

>>> 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)>

Konstruieren Sie das Identitätsobservable (obwohl Sie eigentlich nur identity()):

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

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

>>> 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, /)

Konstruieren Sie eine SparseObservable aus einer SparsePauliOp instanz.

Dies ist eine weitgehend direkte Übersetzung der SparsePauliOp; insbesondere gibt es keine fliegende Summierung gleicher Terme und auch keinen Versuch, Summen von Pauli-Termen in äquivalente Projektionsoperatoren umzuformulieren.

Parameter

op (SparsePauliOp) – den zu konvertierenden Operator.

Beispiele

>>> 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)

Konstruieren Sie einen SparseObservable 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.

Bei der Erstellung der Beobachtungsdaten wird keine Vereinfachung vorgenommen.

Parameter

• obj (Iterable[Term]) – Iterable der einzelnen Begriffe, aus denen die Observable aufgebaut werden soll.
• num_qubits (int | None) – Die Anzahl der Qubits, auf die die Beobachtungsgröße 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 Beobachtungsgröße.

static identity(num_qubits)

Ermittelt den Identitätsoperator über die angegebene Anzahl von Qubits.

Beispiele

Ermitteln Sie den Identitätsoperator für 100 Qubits:

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

pauli_bases()

Erhalten Sie ein PauliList objekt, das die Messbasis darstellt, die für jeden Term (in dieser Reihenfolge) in dieser Observable benötigt wird.

Der Projektor 0l+ liefert zum Beispiel ein Pauli ZXY. Die resultierende Pauli ist dicht in dem Sinne, dass explizite Identitäten gespeichert werden. Eine Identität in der Pauli-Ausgabe erfordert keine konkrete Messung.

Dadurch wird für jeden Begriff in der Summe ein Eintrag in der Pauli-Liste zurückgegeben.

Rückgabe

die Liste der Pauli-Operatoren, die die notwendigen Messgrundlagen darstellen.

Rückgabetyp

PauliList

simplify(tol=1e-08)

Summiert alle gleichartigen Terme in diesem Operator und entfernt sie, wenn der resultierende komplexe Koeffizient einen Absolutwert innerhalb der Toleranz von Null hat.

Als Nebeneffekt sortiert dies den Operator in kanonischer Reihenfolge.

Parameter

tol (float) – nach der Summierung gleichartiger Terme werden alle Koeffizienten, deren absoluter Wert kleiner als die angegebene absolute Toleranz ist, bei der Ausgabe unterdrückt.

Beispiele

Verwendung von simplify() um zwei Operatoren zu vergleichen, die dieselbe Beobachtungsgröße darstellen, aber aufgrund der strukturellen Tests standardmäßig ungleiche Ergebnisse liefern würden:

>>> 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()

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 = 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, /)

Tensorprodukt von zwei Observablen.

otherDie Bitreihenfolge ist so definiert, dass die Qubit-Indizes des Arguments unverändert bleiben und die Indizes von self um die Anzahl der Qubits in verschoben werden. Dies entspricht der Konvention, die auch bei den übrigen Operatoren von Qiskit quantum_info verwendet wird.

Diese Funktion wird für den Infix-Operator ^ verwendet. Wenn Sie diesen Operator verwenden, beachten Sie bitte, dass die Operator-Präzedenzregeln von Python dazu führen können, dass die Auswertungsreihenfolge von Ihren Erwartungen abweicht. Insbesondere bindet der Operator + fester als ^, ebenso wie * fester als + bindet. Verwenden Sie bei Bedarf Klammern, um die Reihenfolge der Auswertung festzulegen.

Das Argument wird in SparseObservable umgewandelt, wenn es nicht bereits in der richtigen Form vorliegt.

Parameter

andere - die Beobachtungsgröße, die auf der rechten Seite des Tensorprodukts steht.

Beispiele

Die Bitreihenfolge ist dabei so, dass das Tensorprodukt zweier Observablen, die aus einem einzigen Etikett gebildet werden, "wie" eine Observable aussieht, die durch Verkettung der beiden Zeichenketten gebildet wird:

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

Sie können auch den Infix-Operator ^ für Tensorprodukte verwenden, der in ähnlicher Weise die rechte Seite der Operation umwandelt, wenn sie nicht bereits ein SparseObservable:

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

to_sparse_list()

Drücken Sie die Beobachtungsgröße in Form einer dünn besetzten Liste aus.

Dies kann als Gegenoperation von SparseObservable.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

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

transpose()

Berechnen Sie die Matrixtransposition dieser Beobachtungsgröße.

Diese Operation wird gemäß den Standard-Matrixkonventionen von Qiskit definiert, d. h. die Matrixform wird als $Z$-Rechenbasis betrachtet. Die $X$- und $Z$-bezogenen Alphabetterme bleiben von der Transposition unberührt, aber $Y$-bezogene Terme ändern ihre Alphabetterme. Ganz genau:

• $Y$ wird umgesetzt in $-Y$
• $\lvert r\rangle\langle r\rvert$ wird umgesetzt in $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ wird umgesetzt in $\lvert r\rangle\langle r\rvert$

Beispiele

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

static zero(num_qubits)

Ermittelt den Null-Operator über die angegebene Anzahl von Qubits.

Der Nulloperator ist der Operator, dessen Erwartungswert für alle Quantenzustände gleich Null ist. Sie hat keine Bedingungen. Es ist das Identitätselement für die Addition von zwei SparseObservable instanzen; alles, was mit dem Null-Operator addiert wird, ist gleich sich selbst.

Wenn Sie den Projektor in den Zustand "Alle Nullen" versetzen wollen, verwenden Sie:

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

Beispiele

Holen Sie sich den Null-Operator für 100 Qubits:

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