PauliLindbladMap

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

Basi: object

Una mappa di Pauli Lindblad memorizzata in un formato qubit-sparse.

Matematica

Una mappa di Pauli-Lindblad è una mappa lineare che agisce su matrici di densità su $n$ -quit della forma:

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

dove $K$ è un sottoinsieme degli operatori di Pauli a $n$ -qubit, e i tassi, o coefficienti, $\lambda_P$ sono numeri reali. Quando tutte le norme $\lambda_P$ sono non negative, ciò corrisponde a una mappa completamente positiva e che preserva la traccia. Il numero che compare nell'esponenziale è chiamato generatore, mentre ogni singolo termine è chiamato generatore. Per semplificare la notazione nel resto della documentazione, indicheremo l' $L(P)\bigl[\circ\bigr] = P \circ P - \circ$

Rappresentazione quasi-probabilistica

La mappa $\Lambda$ può essere scritta come un prodotto:

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

Per ogni $P$ , vale che

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

dove $\omega(x) = \frac{1}{2}(1 + e^{-2 x})$ . Osserviamo che se $\lambda_P \geq 0$ , allora $\omega(\lambda_P) \in (\frac{1}{2}, 1]$ , e questo termine è una mappa completamente positiva e che conserva la traccia. Tuttavia, se $\lambda_P < 0$ , allora $\omega(\lambda_P) > 1$ e la mappa non è completamente positiva o preservante la traccia. Lasciando che $\gamma_P = \omega(\lambda_P) + |1 - \omega(\lambda_P)|$ , $p_P = \omega(\lambda_P) / \gamma_P$ e $b_P \in \{0, 1\}$ siano $1$ se $\lambda_P < 0$ e $0$ altrimenti, riscriviamo la mappa come:

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

Se $\lambda_P \geq 0$ , $\gamma_P = 1$ e l'espressione si riduce alla miscela standard della mappa di identità e della coniugazione di $P$ . Se $\lambda_P < 0$ , $\gamma_P > 1$ , e la mappa è una differenza scalare della mappa di identità e della coniugazione per $P$ , con pesi di probabilità (quindi "quasi-probabilità"). Si noti che si tratta di una presentazione leggermente diversa rispetto alla letteratura, ma questa notazione ci permette di gestire contemporaneamente tassi non negativi e negativi. La $\gamma$ complessiva del canale è il prodotto $\gamma = \prod_{P \in K} \gamma_P$ .

Si veda il PauliLindbladMap.sample() per la procedura di campionamento di questa mappa.

Rappresentazione

Ogni singolo operatore di Pauli nel generatore è un prodotto tensoriale di operatori di Pauli a singolo qubit della forma $P = \bigotimes_n A^{(n)}_i$ , per $A^{(n)}_i \in \{I, X, Y, Z\}$ . La rappresentazione interna di a PauliLindbladMap memorizza solo gli operatori Pauli single-qubit non identici. Questo rende significativamente più efficiente la rappresentazione di generatori come $\sum_{n\in \text{qubits}} c_n L(Z^{(n)})$ ; per i quali PauliLindbladMap richiede una quantità di memoria lineare rispetto al numero totale di qubit.

Internamente, PauliLindbladMap memorizza una serie di tassi e un QubitSparsePauliList contenente i corrispondenti operatori di Pauli sparsi. Inoltre, PauliLindbladMap è possibile calcolare l' $\gamma$ e complessiva del canale nel gamma() metodo, nonché le probabilità corrispondenti $p_P$ tramite il probabilities() metodo.

Indicizzazione

PauliLindbladMap si comporta come una sequenza Python (la forma standard, non quella espansa collections.abc.Sequence). I generatori della mappa possono essere indicizzati da numeri interi e iterati per ottenere i singoli termini del generatore.

Ogni termine generatore appare come un'istanza di una classe autonoma. I singoli termini sono copiati dalla mappa di base; le mutazioni ad essi apportate non influiscono sulla mappa originale da cui sono indicizzati.

GeneratorTerm

class GeneratorTerm(rate, qubit_sparse_pauli)

GitHub

Basi: object

Un singolo termine di un'opera completa PauliLindbladMap.

In genere vengono creati indicizzando o iterando in un file PauliLindbladMap.

copy

copy()

Ottenere una copia di questo termine.

indices

Visualizzazione in sola lettura degli indici di ogni termine non identitario a singolo qubit.

Gli indici saranno sempre in ordine sparso.

num_qubits

Il numero di qubit su cui è definito il termine.

pauli_labels

pauli_labels()

Restituisce le etichette pauli del termine come stringa.

Le etichette pauli corrispondono all'ordine di GeneratorTerm.indices, in modo tale che l'i-esimo carattere della stringa sia applicato all'indice del qubit all'indirizzo term.indices[i]. E.g. il termine con l'operatore X che agisce sul qubit 0 e Y che agisce sul qubit 3 avrà term.indices == np.array([0, 3]) e term.pauli_labels == "XY".

Risultati

I termini di bit non identici come stringa concatenata.

paulis

Visualizzazione in sola lettura dei singoli termini a singolo qubit.

Gli unici valori validi nell'array sono quelli con un corrispondente Pauli.

qubit_sparse_pauli

Il termine è qubit_sparse_pauli.

rate

Il tasso del termine.

to_pauli_lindblad_map

to_pauli_lindblad_map()

Convertire questo termine in un termine completo PauliLindbladMap.

Costruzioni

PauliLindbladMap definisce diversi costruttori. Il costruttore predefinito tenterà di delegare a uno dei costruttori più specifici, in base al tipo di input. Si possono sempre usare i costruttori specifici per avere un maggiore controllo sulla costruzione.

Metodo	Riepilogo
`from_list()`	Generatori forniti come elenco di tuple di etichette di stringhe dense e dei tassi associati.
`from_sparse_list()`	Generatori forniti come elenco di tuple di etichette di stringhe sparse, i qubit a cui si applicano e i loro tassi.
`from_terms()`	Somma esplicita di singole `GeneratorTerm` istanze.
`from_components()`	Costruire da un array di tassi e un'istanza `QubitSparsePauliList` istanza.

new

__new__(data, /, num_qubits=None)

Il costruttore predefinito di PauliLindbladMap.

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. Può essere un altro PauliLindbladMap, nel qual caso l'input viene copiato, oppure può essere un elenco in un formato valido per entrambi i formati from_list() o from_sparse_list().
num_qubits (int|None) – Numero opzionale di qubit per la mappa. 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.

Oltre ai costruttori basati sulla conversione, esistono anche metodi di aiuto che costruiscono forme speciali di mappe.

Metodo	Riepilogo
`identity()`	La mappa di identità su un dato numero di qubit.

Conversioni

Un formato esistente PauliLindbladMap può essere convertito in altri formati.

Metodo	Riepilogo
`to_sparse_list()`	Esprimere la mappa in un formato di lista rada con elementi `(paulis, indices, rate)`.

Attributi

num_qubits

Il numero di qubit su cui agisce la mappa.

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

num_terms

Il numero di termini del generatore nell'esponente di questa mappa.

rates

Le tariffe per la mappa.

Metodi

apply_layout

apply_layout(layout, num_qubits=None)

Applicare un layout di transpiler a questa mappa di Pauli Lindblad.

Ciò consente di rimappare gli indici dei qubit, ad esempio se la mappa è definita in termini di etichette di qubit virtuali.

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 la mappa).
num_qubits (int | None) – Il numero di qubit a cui espandere la mappa. 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 PauliLindbladMap con l'applicazione del layout fornito.

clear

clear()

Cancella tutti i termini del generatore da questa mappa, rendendola di nuovo uguale alla mappa di identità.

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

Esempi

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

Comporre con un altro PauliLindbladMap.

In questo modo si aggiungono gli array interni di self e other, ottenendo così una mappa i cui termini enumerati sono quelli di self seguiti da quelli di other.

Parametri

other (PauliLindbladMap) – la mappa Pauli Lindblad da comporre.

copy

copy()

Ottenete una copia di questa mappa di Pauli Lindblad.

Esempi

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

Eliminare Paulis da questa mappa di Pauli Lindblad.

Elimina ogni Pauli sugli indici dati, sostituendoli di fatto con un'identità.

La mappa risultante può contenere duplicati, che possono essere rimossi con il metodo PauliLindbladMap.simplify() metodo.

Parametri

indices (Sequence[int]) – Gli indici per i quali Paulis deve essere abbandonato.

Risultati

Una nuova mappa Pauli Lindblad in cui ogni Pauli sugli indici dati è stato eliminato.

Esempi

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

Eliminare i qubit da questa mappa di Pauli Lindblad, eseguendo di fatto un'operazione di trace-out.

La mappa risultante può contenere duplicati, che possono essere rimossi con il metodo PauliLindbladMap.simplify() metodo.

Parametri

indices (Sequence[int]) – Gli indici dei qubit da tracciare.

Risultati

Una nuova mappa di Pauli Lindblad in cui è stato tracciato ogni Pauli sugli indici dati.

Esempi

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

Costruire una mappa di Pauli Lindblad da un elenco di etichette di generatori densi e tassi.

Questo è analogo a SparsePauliOp.from_list(). In questa forma densa, è necessario fornire esplicitamente tutte le identità in ogni etichetta.

L'etichetta deve essere una sequenza dell'alfabeto 'IXYZ'. 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, float]]) – Coppie di etichette e tassi associati nella somma dei generatori.
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 su quanti qubit agisce la mappa. Se viene dato e iter non è vuoto, il valore deve corrispondere alle lunghezze delle etichette.

Esempi

Costruire una mappa di Pauli Lindblad da un elenco di etichette:

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

Utilizzare num_qubits per disambiguare gli input potenzialmente vuoti:

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

Vedi anche

from_sparse_list()

Costruire la mappa da una lista di etichette senza identità esplicite, ma con i qubit a cui si applica ogni termine del generatore a singolo qubit elencati esplicitamente.

from_sparse_list

static from_sparse_list(iter, /, num_qubits)

Costruire una mappa di Pauli Lindblad da un elenco di etichette, i qubit a cui si applica ogni elemento e il tasso dell'intero termine.

Questo è analogo a SparsePauliOp.from_sparse_list().

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], float]]) – triple di etichette, i qubit a cui si applica ogni termine a singolo qubit e il tasso dell'intero termine.
num_qubits (int) – il numero di qubit su cui agisce la mappa.

Esempi

Costruire una mappa semplice:

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

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

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

Vedi anche

to_sparse_list()

L'inverso di questo metodo.

from_terms

static from_terms(obj, /, num_qubits=None)

Costruire un PauliLindbladMap 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 della mappa.

Parametri

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

Risultati

La mappa corrispondente.

gamma

gamma()

Calcolare il sito $\gamma$ per la mappa.

generators

generators()

Recupera i generatori della mappa.

Si tratta di un alias per get_qubit_sparse_pauli_list_copy(), che offre un nome più intuitivo, in linea con le convenzioni di denominazione utilizzate in Aer e Runtime per classi simili.

Risultati

Una copia dei termini e delle condizioni del generatore di mappe.

Tipo di restituzione

QubitSparsePauliList

get_qubit_sparse_pauli_list_copy

get_qubit_sparse_pauli_list_copy()

Ottenere una copia dell'elenco dei qubit sparse pauli della mappa.

identity

static identity(num_qubits)

Ottiene la mappa di identità sul numero di qubit indicato.

La mappa di identità non contiene termini generatori ed è l'elemento di identità per la composizione di due istanze PauliLindbladMap qualsiasi cosa composta con la mappa di identità è uguale a se stessa.

Esempi

Ottenere la mappa di identità su 100 qubit:

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

inverse

inverse()

Restituisce un nuovo PauliLindbladMap che è l'inverso matematico di self.

keep_paulis

keep_paulis(indices)

Mantenere ogni Pauli sugli indici dati e abbandonare tutti gli altri.

Questo è equivalente all'utilizzo di PauliLindbladMap.drop_paulis() sul complemento degli indici.

Parametri

indices (Sequence[int]) – Gli indici per i quali è necessario conservare Paulis.

Risultati

Una nuova mappa Pauli Lindblad in cui ogni Pauli sugli indici dati è stato mantenuto e tutti gli altri Pauli sono stati eliminati.

Esempi

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

Mantenere ogni qubit sugli indici dati e tracciare tutti gli altri qubit.

Questo è equivalente all'utilizzo di PauliLindbladMap.drop_qubits() sul complemento degli indici.

Parametri

indices (Sequence[int]) – Gli indici per i quali i qubit devono essere conservati.

Risultati

Una nuova mappa di Pauli Lindblad in cui ogni qubit sugli indici dati è stato mantenuto e tutti gli altri qubit sono stati tracciati.

Esempi

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

Campione di coppie di segni e operatori Pauli dalla mappa.

Ogni segno è rappresentato da un valore booleano, dove True rappresenta -1e False rappresenta +1.

Data la rappresentazione di quasi-probabilità fornita nella documentazione a livello di classe, ogni campione viene estratto attraverso il seguente processo:

Inizializza il segno booleano e un'istanza di QubitSparsePauli all'operatore di identità.
Iterare ogni Pauli nella mappa. Utilizzando la pseudo-probabilità associata a ciascun operatore, scegliere casualmente se applicare o meno l'operatore.
Se l'operatore è applicato, aggiornare :class`QubitSparsePauli` moltiplicandolo con il Pauli. Se il tasso associato al Pauli è negativo, invertire il segno booleano.

I risultati vengono restituiti come array di booleani 1d e il corrispondente qubit sparse Paulis campionato nella forma di un QubitSparsePauliList.

Gli argomenti scale e local_scale possono essere utilizzati per modificare i tassi sottostanti utilizzati nel processo di campionamento senza modificare l'istanza corrente o richiedere la creazione di una nuova. L'argomento scale scala tutti i tassi con un fattore fisso e local_scale scala i tassi termine per termine.

Parametri

num_samples (int) – Numero di campioni da prelevare.
seed (int) – Semi casuali.
scale (float) – Scala da applicare a tutte le tariffe.
local_scale (list[float]) – Scala locale da applicare su base trimestrale.

Risultati

L'array booleano di segni e l'elenco dei qubit sparse pauli.

Tipo di restituzione

segni, elenco dei qubit_sparse_pauli

parity_sample_with_history

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

Campiona coppie di segni e operatori di Pauli dalla mappa, conservando i generatori campionati.

Questo metodo è identico a parity_sample() tranne per il fatto che restituisce anche le informazioni relative a quali generators() sono stati effettivamente campionati per ottenere l'operatore di Pauli finale e il segno.

Parametri

num_samples (int) – Numero di campioni da prelevare.
seed (int) – Semi casuali.
scale (float) – Scala da applicare a tutte le tariffe.
local_scale (list[float]) – Scala locale da applicare su base trimestrale.

Risultati

L'array booleano di

i segni, l'elenco dei Pauli sparsi dei qubit, l'array booleano bidimensionale che indica quali generators() sono stati campionati e l'array booleano bidimensionale che indica i loro segni.

Tipo di restituzione

segni, qubit_sparse_pauli_list, pauli_history, segni_history

pauli_fidelity

pauli_fidelity(qubit_sparse_pauli)

Calcolare la fedeltà Pauli di questa mappa per un qubit Pauli sparse.

Per un Pauli $Q$ , la fedeltà rispetto alla mappa di Pauli Lindblad $\Lambda$ è il numero reale $f(Q)$ per il quale $\Lambda(Q) = f(Q) Q$ . I.e. ogni Pauli è un autovettore della mappa lineare $\Lambda$ , e la fedeltà è l'autovalore corrispondente. Per una mappa di Pauli Lindblad con insieme di generatori $K$ e funzione di tasso $\lambda : K \rightarrow \mathbb{R}$ , la fedeltà di Pauli è matematicamente

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

dove $\langle P, Q\rangle_{sp}$ è $0$ se $P$ e $Q$ commutano, e $1$ se sono anticommutativi.

Args: qubit_sparse_pauli ( QubitSparsePauli ): il qubit sparse Pauli per calcolare il Pauli

fedeltà di.

probabilities

probabilities()

Calcola le probabilità $p_P$ per la mappa. Questi possono essere interpretati come le probabilità che ciascun generatore non venga applicato e sono definiti come indipendenti dal segno di ciascun tasso di Lindblad.

sample

sample(num_samples, seed=None)

Per PauliLindbladMap gli esempi con tassi puramente non negativi, campionare gli operatori di Pauli dalla mappa. Se la mappa presenta tassi negativi, utilizzare PauliLindbladMap.parity_sample().

Data la rappresentazione di quasi-probabilità fornita nella documentazione a livello di classe, ogni campione viene estratto attraverso il seguente processo:

Inizializza un'istanza di :class`~.QubitSparsePauli` all'operatore di identità.
Iterare ogni Pauli nella mappa. Utilizzando la pseudo-probabilità associata a ciascun operatore, scegliere casualmente se applicare o meno l'operatore.
Se l'operatore è applicato, aggiornare :class`QubitSparsePauli` moltiplicandolo con il Pauli.

I qubit sparsi campionati di Paulis sono restituiti sotto forma di un QubitSparsePauliList.

Parametri

num_samples (int) – Numero di campioni da prelevare.
seed (int) – Semi casuali. L'impostazione predefinita è None.

Risultati

L'elenco dei qubit sparse pauli.

Tipo di restituzione

elenco dei qubit_sparse_pauli

Aumenti

ValueError - Se uno qualsiasi dei tassi della mappa è negativo.

scale_rates

scale_rates(scale_factor)

Restituisce un nuovo PauliLindbladMap con i tassi scalati dal fattore di scala.

Parametri

scale_factor (float) – il coefficiente di scala.

signed_sample

signed_sample(num_samples, seed=None)

Esempi di coppie di segni e operatori di Pauli dalla mappa. Si noti che la convenzione dei segni booleani in questo metodo non è standard. Il metodo preferito per questo tipo di campionamento è PauliLindbladMap.parity_sample(), che è anche più ricco di funzionalità.

Ogni segno è rappresentato da un booleano, con True che rappresenta +1, e False che rappresenta -1.

Data la rappresentazione di quasi-probabilità fornita nella documentazione a livello di classe, ogni campione viene estratto attraverso il seguente processo:

Inizializza il segno booleano e un'istanza di QubitSparsePauli all'operatore di identità.
Iterare ogni Pauli nella mappa. Utilizzando la pseudo-probabilità associata a ciascun operatore, scegliere casualmente se applicare o meno l'operatore.
Se l'operatore è applicato, aggiornare :class`QubitSparsePauli` moltiplicandolo con il Pauli. Se il tasso associato al Pauli è negativo, invertire il segno booleano.

I risultati vengono restituiti come array di booleani 1d e il corrispondente qubit sparse Paulis campionato nella forma di un QubitSparsePauliList.

Parametri

num_samples (int) – Numero di campioni da prelevare.
seed (int) – Semi casuali.

Risultati

L'array booleano di segni e l'elenco dei qubit sparse pauli.

Tipo di restituzione

segni, elenco dei qubit_sparse_pauli

simplify

simplify(tol=1e-08)

Somma tutti i termini simili nel generatore, eliminandoli se il tasso risultante ha un valore assoluto compreso entro una tolleranza rispetto allo zero. In questo modo si eliminano anche i termini il cui operatore di Pauli è proporzionale all'identità, poiché il generatore corrispondente è in realtà la mappa nulla.

Come effetto collaterale, questo ordina i generatori in un ordine canonico fisso.

Nota

Quando si utilizza questa operazione per confronti di uguaglianza, occorre tenere presente che l'arrotondamento dei valori in virgola mobile e la non associatività dell'addizione in virgola mobile possono far sì che coefficienti diversi da zero dei termini sommati risultino disuguali al confronto. Per confrontare due grandezze osservabili entro un certo margine di tolleranza, il metodo più sicuro consiste nel verificare se la differenza canonizzata delle due grandezze è pari a zero.

Parametri

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

Esempi

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

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

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

Esprimere la mappa in termini di formato di elenco sparso.

Questa può essere vista come una contro-operazione di PauliLindbladMap.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

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

Vedi anche

from_sparse_list()

Il costruttore che può interpretare questi elenchi.

Questa pagina è stata utile?

Segnala un bug, un errore di battitura o richiedi contenuti su GitHub.