SparseObservable

__new__(data, /, num_qubits=None)

Il costruttore predefinito di SparseObservable.

Delega a uno dei metodi espliciti del costruttore di conversione, in base al tipo dell'argomento data . Se viene fornito num_qubits e il costruttore implicito nel tipo di data non accetta un numero, il numero intero fornito deve corrispondere all'input.

Parametri

• data - Il tipo di dati dell'ingresso. Questo può essere un altro SparseObservable, nel qual caso l'input viene copiato, un Pauli o SparsePauliOp, nel qual caso from_pauli() o from_sparse_pauli_op() vengono richiamati a seconda dei casi, oppure può essere un elenco in un formato valido per i due metodi from_list() o from_sparse_list().
• num_qubits (int|None) – Numero opzionale di qubit per l'operatore. Per la maggior parte degli input di dati, questo può essere dedotto e non è necessario passarlo. È necessario solo per gli elenchi vuoti o per il formato sparse-list. Se viene dato inutilmente, deve corrispondere ai dati immessi.

Un elenco piatto di termini a singolo qubit. Si tratta più naturalmente di un elenco di elenchi, ma viene memorizzato in modo piatto per motivi di utilizzo della memoria e di localizzazione, con i sottoelenchi indicati dai confini.

Indici che dividono bit_terms e indices in sottoelenchi per ogni singolo termine della somma. boundaries[0] : boundaries[1] è l'intervallo di indici in bit_terms e indices che corrispondono al primo termine della somma. Tutti gli indici di qubit non specificati sono implicitamente l'identità. Questo è un elemento più lungo di coeffs, dato che boundaries[0] è sempre uno zero esplicito (per semplicità algoritmica).

I coefficienti di ciascun termine astratto nella somma. Questo ha tanti elementi quanti sono i termini della somma.

Un elenco piatto degli indici dei qubit su cui agiscono le voci corrispondenti in bit_terms agiscono su di essi. Questo elenco deve essere sempre ordinato per termini, dove un termine è un sottoelenco indicato da boundaries.

Il numero di qubit su cui agisce l'operatore.

Questo non è deducibile da altre forme o valori, poiché le identità non sono memorizzate esplicitamente.

Il numero di termini della somma che l'operatore sta tracciando.

adjoint()

Calcolare l'adjoint di questa osservabile.

Questo è ben definito in senso matematico astratto. Tutti i termini dell'alfabeto a singolo qubit sono auto-aggiunti, quindi il risultato di questa operazione è lo stesso osservabile, con la differenza che i suoi coefficienti sono tutti i loro coniugati complessi.

Esempi

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

apply_layout(layout, num_qubits=None)

Applicare un layout di transpiler a questo SparseObservable.

In genere si definisce l'osservabile in termini di qubit virtuali dei circuiti da utilizzare per preparare gli stati. Dopo la transpilazione, i qubit virtuali vengono mappati su particolari qubit fisici di un dispositivo, che può essere più ampio del vostro circuito. Questa mappatura può anche cambiare nel corso del circuito. Questo metodo trasforma l'osservabile di ingresso sui qubit virtuali in un'osservabile adatta ad essere applicata immediatamente dopo il circuito fisico completamente transpilato.

Parametri

• layout (TranspileLayout |list[int] | None) – Il layout da applicare. Nella maggior parte dei casi, questa funzione dovrebbe ricevere il QuantumCircuit.layout campo proveniente da un circuito che è stato transpilato per l'hardware. Inoltre, è possibile passare un elenco di indici dei nuovi qubit. NoneSe specificato in modo esplicito, non viene applicata alcuna rimappatura (ma è comunque possibile utilizzare num_qubits per espandere l'osservabile).
• num_qubits (int | None) – Il numero di qubit a cui espandere l'osservabile. Se non viene fornito, l'output sarà largo quanto il dato TranspileLayouto della stessa larghezza dell'input se layout è fornito in un'altra forma.

Risultati

Un nuovo SparseObservable con l'applicazione del layout fornito.

as_paulis()

Esprimere l'osservabile solo in termini di Pauli, scrivendo ogni proiettore come somma di termini di Pauli.

Si noti che non è garantito l'ordine dei termini di Pauli risultanti. Utilizzare SparseObservable.simplify() per ottenere una rappresentazione canonica.

Risultati

La stessa osservabile, ma espressa solo in termini di Pauli.

Esempi

Riscrivere un'osservabile in termini di proiettori in operatori di Pauli:

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

Per piccoli operatori, questo può essere usato con simplify() come forma canonica unica:

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

Cancella tutti i termini da questo operatore, rendendolo di nuovo uguale all'operatore zero.

Ciò non modifica la capacità delle allocazioni interne, pertanto le successive operazioni di aggiunta o sottrazione potrebbero non richiedere una riallocazione.

Esempi

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

Verifica se l'osservabile commuta con un altro.

Parametri

• other (SparseObservable) – L'altro osservabile con cui verificare la commutazione.
• tol (float) – Se i coefficienti nel prodotto di sé e dell'altro sono inferiori alla tolleranza (in grandezza), i termini vengono ignorati.

Risultati

True se i termini sono commutativi, fino alla tolleranza, False altrimenti.

Aumenti

TypeError – Se non other potesse essere costretto a SparseObservable.

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

Comporre un altro SparseObservable su questo.

In termini di algebre di operatori, la composizione corrisponde alla moltiplicazione a sinistra: c = a.compose(b) corrisponde a $C = B A$. In altre parole, a.compose(b) restituisce un operatore che "esegue a e poi esegue b sul risultato". L'argomento front=True rende invece questa moltiplicazione giusta.

self e other devono avere la stessa dimensione, a meno che non venga dato qargs , nel qual caso other può essere più piccolo di self, purché il numero di qubit in other e la lunghezza di qargs corrispondano. qargs non può mai contenere duplicati o indici di qubit che non esistono in self.

Attenzione: questa funzione può causare un'esplosione esponenziale dell'utilizzo della memoria dell'osservabile, poiché l'alfabeto di SparseObservable non è chiuso sotto composizione; la composizione di due termini a singolo bit può essere una somma, che moltiplica il numero totale di termini. Questo utilizzo di memoria non è ´necessariamente´ inerente all'osservabile risultante, ma trovare una rifattorizzazione efficiente della somma è generalmente altrettanto difficile dal punto di vista computazionale. È meglio utilizzare la conoscenza del dominio delle osservabili per ridurre al minimo il numero di termini esistenti, piuttosto che cercare di semplificarli a posteriori.

Parametri

• altro - l'osservabile utilizzato per la moltiplicazione a sinistra self.

• qargs -

  se dato, i qubit in self da associare ai qubit in other. Detto altrimenti: se questo è dato, è simile a un'implementazione più efficiente di:

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

  poiché non viene creato un osservabile temporaneo per memorizzare la forma di layout applicato di other.

• front - se True, allora moltiplica a destra per other invece di moltiplicare a sinistra (default False). Il sito qargs è ancora applicato a other. Questo è molto utile quando qargs è impostato, o other potrebbe essere un oggetto che deve essere forzato a SparseObservable.

conjugate()

Calcolare la coniugazione complessa di questa osservabile.

Questa operazione è definita in termini di convenzioni matriciali standard di Qiskit, in quanto la forma della matrice è considerata nella base computazionale $Z$. I termini dell'alfabeto legati a ´X´ e ´Z´ non sono influenzati dalla coniugazione complessa, ma i termini legati a ´Y´ modificano i loro termini dell'alfabeto. Precisamente:

• $Y$ si coniuga con $-Y$
• $\lvert r\rangle\langle r\rvert$ coniugati a $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ coniugati a $\lvert r\rangle\langle r\rvert$

Inoltre, tutti i coefficienti sono coniugati.

Esempi

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

copy()

Ottenere una copia di questo osservabile.

Esempi

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

Evolvi questa osservabile mediante un termine di Pauli.

Un'evoluzione dell' $O$ e osservabile mediante un' $P$ e di Pauli corrisponde a $P^\dagger O P$.

A differenza di un'implementazione letterale tramite due composizioni complete, questo metodo esegue la coniugazione direttamente a livello di singolo qubit utilizzando una tabella di consultazione fissa. In questo modo si evita di materializzare qualsiasi grandezza intermedia SparseObservable e si calcola l'osservabile risultante in un unico passaggio sui termini. self e other deve avere lo stesso numero di qubit, a meno che qargs non sia specificato, nel qual caso other può essere inferiore a self, a condizione che il numero di qubit in other e la lunghezza di qargs corrispondano. qargs specifica quali qubit di self vengono fatti evolvere da other.

Attualmente, questo metodo supporta l'evoluzione solo tramite un operatore a termine singolo, il che significa che other deve essere un operatore di Pauli rappresentato da Pauli.

Parametri

• altro – l'operatore di Pauli utilizzato per coniugare self.
• qargs – se specificato, i qubit in self da sottoporre all'evoluzione tramite other. La lunghezza deve corrispondere al numero di qubit in other.

Risultati

Una nuova versione evoluta SparseObservable con coniugazioni applicate.

Aumenti

• TypeError – se non other è di tipo Pauli.
• ValueError – se self e other hanno un numero diverso di qubit (e non qargs è specificato).
• ValueError – se qargs la lunghezza non corrisponde other al numero di qubit.
• ValueError – se qargs contiene duplicati o indici fuori intervallo.
• ValueError – se other contiene più di un termine.

expand(other, /)

Prodotto tensoriale di ordine inverso.

Questo è equivalente a other.tensor(self), tranne che per il fatto che other verrà prima trasformato in SparseObservable se non lo è già (richiamando il costruttore predefinito).

Parametri

altro - l'osservabile da mettere sul lato sinistro del prodotto tensoriale.

Esempi

Questo è equivalente a tensor() con l'ordine degli argomenti invertito:

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

static from_label(label, /)

Costruire un osservabile a termine singolo da un'etichetta di stringa densa.

L'operatore risultante avrà un coefficiente pari a 1. L'etichetta deve essere una sequenza dell'alfabeto 'IXYZ+-rl01'. L'etichetta viene interpretata in modo analogo a una stringa di bit. In altre parole, la lettera più a destra è associata al qubit 0 e così via. Questa è la stessa etichetta per Pauli e SparsePauliOp.

Parametri

label (str) – l'etichetta densa.

Esempi

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

Costruire un osservabile da un elenco di etichette e coefficienti densi.

È analogo a SparsePauliOp.from_list()con la differenza che utilizza l'alfabeto esteso di SparseObservable. In questa forma densa, è necessario fornire esplicitamente tutte le identità in ogni etichetta.

L'etichetta deve essere una sequenza dell'alfabeto 'IXYZ+-rl01'. L'etichetta viene interpretata in modo analogo a una stringa di bit. In altre parole, la lettera più a destra è associata al qubit 0 e così via. Questa è la stessa etichetta per Pauli e SparsePauliOp.

Parametri

• iter (list[tuple[str, complex]]) – Coppie di etichette e coefficienti associati da sommare. Le etichette vengono interpretate come in from_label().
• num_qubits (int | None) – Non è necessario specificarlo se si è sicuri che iter non è una sequenza vuota, poiché può essere dedotta dalle lunghezze delle etichette. Se iter può essere vuoto, è necessario specificare questo argomento per disambiguare il numero di qubit dell'osservabile. Se viene dato e iter non è vuoto, il valore deve corrispondere alle lunghezze delle etichette.

Esempi

Costruire un osservabile da un elenco di etichette della stessa lunghezza:

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

Utilizzare num_qubits per disambiguare gli input potenzialmente vuoti:

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

Questo metodo è equivalente alle chiamate a from_sparse_list() con il campo esplicito qubit-arguments impostato su numeri interi decrescenti:

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

Costruire un SparseObservable da una singola Pauli istanza.

L'osservabile di uscita avrà un unico termine, con un coefficiente unitario dipendente dalla fase.

Parametri

pauli (Pauli) – il singolo Pauli da convertire.

Esempi

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

Costruire una classe SparseObservable da array Numpy grezzi che corrispondono alla rappresentazione dei dati richiesta, descritta nella documentazione a livello di classe.

I dati di ogni array vengono copiati in allocazioni fresche e crescenti dello spazio Rust.

Parametri

• num_qubit - numero di qubit nell'osservabile.

• coeff - coefficienti complessi di ciascun termine dell'osservabile. Dovrebbe essere una matrice Numpy con il tipo dtype complex128.

• bit_terms - elenco appiattito dei termini single-qubit che comprende tutti i termini completi. Dovrebbe essere un array Numpy con dtype uint8 (che è compatibile con BitTerm).

• indici - elenco appiattito ordinato per termini dei qubit a cui corrisponde ogni termine a singolo qubit. Dovrebbe essere una matrice Numpy con il tipo dtype uint32.

• confini - gli indici che suddividono bit_terms e indices in termini. Dovrebbe essere un array Numpy con il tipo dtype uintp.

• controllo -

  se True (l'impostazione predefinita), convalida che i dati soddisfino tutte le garanzie di coerenza. Se False, non viene effettuato alcun controllo.

  Avvertenza

  Se check=False, i bit_terms devono assolutamente essere tutti valori validi di SparseObservable.BitTerm. In caso contrario, potrebbe verificarsi un comportamento non definito nello spazio di Rust, invalidando completamente l'esecuzione del programma.

Esempi

Costruire una somma di $Z$ su ogni singolo 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)

Costruire un osservabile da un elenco di etichette, i qubit a cui si applica ogni elemento e il coefficiente dell'intero termine.

È analogo a SparsePauliOp.from_sparse_list()con la differenza che utilizza l'alfabeto esteso di SparseObservable.

I campi "label" e "indices" delle triple sono associati tra loro mediante lo zippaggio. Per esempio, ciò significa che una chiamata a from_list() può essere convertita nella forma utilizzata da questo metodo impostando il campo "indici" di ogni tripla a (num_qubits-1, ..., 1, 0).

Parametri

• iter (list[tuple[str, Sequence[int], complex]]) – triple di etichette, i qubit a cui si applica ogni termine a singolo qubit e il coefficiente dell'intero termine.
• num_qubits (int) – il numero di qubit nell'operatore.

Esempi

Costruire un operatore semplice:

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

Costruire l'osservabile identità (anche se, in realtà, basta usare identity()):

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

Questo metodo può replicare il comportamento di from_list()se il campo qubit-arguments della tripla è impostato su numeri interi decrescenti:

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

Costruire un SparseObservable da un'istanza SparsePauliOp istanza.

Si tratta di una traduzione in gran parte diretta del modello SparsePauliOpin particolare, non c'è alcuna somma al volo di termini simili, né alcun tentativo di rifattorizzare le somme di termini di Pauli in operatori di proiezione equivalenti.

Parametri

op (SparsePauliOp) – l'operatore da convertire.

Esempi

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

Costruire un SparseObservable con i singoli termini.

Tutti i termini devono avere lo stesso numero di qubit. Se fornito, l'argomento num_qubits deve corrispondere ai termini.

Non viene effettuata alcuna semplificazione nell'ambito della creazione dell'osservabile.

Parametri

• obj (Iterable[Term]) – Iterabile di termini individuali da cui costruire l'osservabile.
• num_qubits (int | None) – Il numero di qubit su cui deve agire l'osservabile. Di solito viene dedotto dall'input, ma può essere dato esplicitamente per gestire il caso di un iterabile vuoto.

Risultati

L'osservabile corrispondente.

static identity(num_qubits)

Ottiene l'operatore di identità sul numero di qubit dato.

Esempi

Ottenere l'operatore di identità per 100 qubit:

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

pauli_bases()

Ottenere un PauliList che rappresenta la base di misura necessaria per ogni termine (in ordine) di questa osservabile.

Ad esempio, il proiettore 0l+ restituirà un Pauli ZXY. Il risultato Pauli è denso, nel senso che vengono memorizzate identità esplicite. Un'identità nell'uscita di Pauli non richiede una misura concreta.

Questo restituirà una voce nell'elenco Pauli per ogni termine della somma.

Risultati

l'elenco degli operatori di Pauli che rappresentano le basi di misura necessarie.

Tipo di restituzione

PauliList

simplify(tol=1e-08)

Somma tutti i termini simili in questo operatore, eliminandoli se il coefficiente complesso risultante ha un valore assoluto entro la tolleranza di zero.

Come effetto collaterale, questo ordina l'operatore in ordine canonico.

Parametri

tol (float) – dopo aver sommato i termini simili, i coefficienti il cui valore assoluto è inferiore alla tolleranza assoluta indicata saranno eliminati dall'uscita.

Esempi

Utilizzando simplify() per confrontare due operatori che rappresentano lo stesso osservabile, ma che si confronterebbero in modo diseguale a causa dei test strutturali predefiniti:

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

Si noti che nell'esempio precedente i coefficienti sono scelti in modo tale che tutti i calcoli in virgola mobile siano esatti e non vi siano problemi di arrotondamento o associatività intermedia. Se non è possibile garantire che ciò avvenga, la forma più sicura è la seguente:

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

Prodotto tensoriale di due osservabili.

L'ordinamento dei bit è definito in modo tale che gli indici dei qubit dell'argomento rimangano gli stessi, mentre gli indici di self vengano spostati del numero di qubit presenti in other. Si tratta della stessa convenzione utilizzata dal resto degli operatori di Qiskit quantum_info .

Questa funzione viene utilizzata per l'operatore infix ^ . Se si usa questo operatore, bisogna tenere presente che le regole di precedenza degli operatori di Python ' possono far sì che l'ordine di valutazione sia diverso da quello previsto. In particolare, l'operatore + si lega più strettamente di ^, così come * si lega più strettamente di +. Usare le parentesi per fissare l'ordine di valutazione, se necessario.

L'argomento verrà lanciato in SparseObservable utilizzando il suo costruttore predefinito, se non è già nella forma corretta.

Parametri

altro - l'osservabile da mettere sul lato destro del prodotto tensoriale.

Esempi

L'ordinamento dei bit è tale che il prodotto tensoriale di due osservabili ricavati da una singola etichetta "assomiglia" a un osservabile ricavato dalla concatenazione delle due stringhe:

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

Si può anche usare l'operatore infix ^ per i prodotti tensoriali, che in modo analogo casterà il lato destro dell'operazione, se non è già un elemento SparseObservable:

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

to_sparse_list()

Esprimere l'osservabile in termini di formato di elenco sparso.

Questa può essere vista come una contro-operazione di SparseObservable.from_sparse_list()ma non è garantito che l'ordine dei termini sia lo stesso dopo un viaggio di andata e ritorno verso un elenco rado.

Esempi

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

transpose()

Calcolare la trasposizione matriciale di questa osservabile.

Questa operazione è definita in termini di convenzioni matriciali standard di Qiskit, in quanto la forma della matrice è considerata nella base computazionale $Z$. I termini dell'alfabeto legati a ´X´ e ´Z´ non sono influenzati dalla trasposizione, ma i termini legati a ´Y´ modificano i loro termini dell'alfabeto. Precisamente:

• $Y$ si traspone in $-Y$
• $\lvert r\rangle\langle r\rvert$ si traspone in $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ si traspone in $\lvert r\rangle\langle r\rvert$

Esempi

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

static zero(num_qubits)

Ottiene l'operatore zero sul numero di qubit indicato.

L'operatore zero è l'operatore il cui valore di aspettativa è zero per tutti gli stati quantistici. Non ha termini. È l'elemento di identità per l'addizione di due SparseObservable qualsiasi cosa venga aggiunta all'operatore zero è uguale a se stesso.

Se si desidera che il proiettore si trovi nello stato di tutti gli zeri, utilizzare:

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

Esempi

Ottenere l'operatore zero per 100 qubit:

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