QubitSparsePauliList

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

Basi: object

Un elenco di operatori di Pauli senza fase memorizzati in un formato qubit-sparse.

Rappresentazione

Ogni singolo operatore Pauli della lista è un prodotto tensoriale di operatori 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 QubitSparsePauliList memorizza solo gli operatori Pauli single-qubit non identici. Questo rende molto più efficiente la rappresentazione di liste di operatori di Pauli con pesi bassi su un gran numero di qubit. Ad esempio, l'elenco degli operatori :math`n`-qubit $[Z^{(0)}, \dots Z^{(n-1)}]$ , dove $Z^{(j)}$ rappresenta l'operatore $Z$ sul qubit $j$ e l'identità su tutti gli altri, può essere memorizzato in QubitSparsePauliList con una quantità di memoria lineare rispetto al numero di qubit.

Indicizzazione

QubitSparsePauliList si comporta come una sequenza Python (la forma standard, non quella espansa collections.abc.Sequence). Gli elementi dell'elenco possono essere indicizzati da numeri interi e iterati. Sia attraverso l'indicizzazione che attraverso l'iterazione, gli elementi dell'elenco vengono restituiti come QubitSparsePauli istanze.

Costruzioni

QubitSparsePauliList 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_label()`	Convertire un'etichetta stringa densa in un elemento singolo `QubitSparsePauliList`.
`from_list()`	Costruire da un elenco di etichette di stringhe dense.
`from_sparse_list()`	Elementi forniti come elenco di tuple di etichette di stringhe sparse e dei qubit a cui si applicano.
`from_pauli()`	Trasforma un singolo elemento `Pauli` in un elemento singolo `QubitSparsePauliList`.
`from_qubit_sparse_paulis()`	Costruire da un elenco di `QubitSparsePauli`s.

new

__new__(data, /, num_qubits=None)

Il costruttore predefinito di QubitSparsePauliList.

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 QubitSparsePauliList, 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 l'elenco. 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, il metodo empty() può essere utilizzato per costruire una lista vuota di paoli qubit-sparse che agiscono su un dato numero di qubit.

Conversioni

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

Metodo	Riepilogo
`to_sparse_list()`	Esprimere l'osservabile in un formato di lista rada con elementi `(paulis, indices)`.

Attributi

num_qubits

Il numero di qubit su cui agiscono gli operatori della lista.

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

num_terms

Il numero di elementi dell'elenco.

Metodi

apply_layout

apply_layout(layout, num_qubits=None)

Applicare un layout transpiler a questa lista Pauli rada di qubit.

Ciò consente di rimappare gli indici dei qubit, ad esempio se l'elenco è definito 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 i qubit presenti nell'elenco).
num_qubits (int | None) – Il numero di qubit a cui espandere gli elementi dell'elenco. 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 QubitSparsePauli con l'applicazione del layout fornito.

clear

clear()

Cancella tutti gli elementi dall'elenco, rendendolo nuovamente uguale all'elenco vuoto.

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_list = QubitSparsePauliList.from_list(["IXXXYY", "ZZYZII"])
>>> pauli_list.clear()
>>> assert pauli_list == QubitSparsePauliList.empty(pauli_list.num_qubits)

commutes

commutes(other)

Verifica se gli elementi di self` commutano con un’altra lista di Pauli sparsa di un altro qubit.

Parametri

other (QubitSparsePauliList) – l'elenco di Pauli sparsa dei qubit con cui verificare la commutatività.

copy

copy()

Ottenere una copia di questa lista di Pauli rada di qubit.

Esempi

>>> qubit_sparse_pauli_list = QubitSparsePauliList.from_list(["IXZXYYZZ", "ZXIXYYZZ"])
>>> assert qubit_sparse_pauli_list == qubit_sparse_pauli_list.copy()
>>> assert qubit_sparse_pauli_list is not qubit_sparse_pauli_list.copy()

empty

static empty(num_qubits)

Ottiene l'elenco vuoto per un determinato numero di qubit.

L'elenco vuoto non contiene elementi ed è l'elemento di identità per unire due istanze QubitSparsePauliList istanze.

Esempi

Ottenere l'elenco vuoto su 100 qubit:

>>> QubitSparsePauliList.empty(100)
<QubitSparsePauliList with 0 elements on 100 qubits: []>

from_label

static from_label(label, /)

Costruisce un elenco con un singolo termine a partire da un'etichetta di stringa densa.

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

label (str) – l'etichetta densa.

Esempi

>>> QubitSparsePauliList.from_label("IIIIXZI")
<QubitSparsePauliList with 1 element on 7 qubits: [X_2 Z_1]>
>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> assert QubitSparsePauliList.from_label(label) == QubitSparsePauliList.from_pauli(pauli)

Vedi anche

from_list()

Una generalizzazione di questo metodo che costruisce un elenco da più etichette.

from_list

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

Costruire una lista di Pauli qubit-sparse da una lista di etichette dense.

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

Parametri

iter (list[str]) – Elenco di etichette di stringhe dense.
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 su cui agiscono gli operatori. Se viene dato e iter non è vuoto, il valore deve corrispondere alle lunghezze delle etichette.

Esempi

Costruire una lista di Pauli sparsa di qubit a partire da un elenco di etichette:

>>> QubitSparsePauliList.from_list([
...     "IIIXX",
...     "IIYYI",
...     "IXXII",
...     "ZZIII",
... ])
<QubitSparsePauliList with 4 elements on 5 qubits:
    [X_1 X_0, Y_2 Y_1, X_3 X_2, Z_4 Z_3]>

Utilizzare num_qubits per disambiguare gli input potenzialmente vuoti:

>>> QubitSparsePauliList.from_list([], num_qubits=10)
<QubitSparsePauliList with 0 elements on 10 qubits: []>

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

>>> labels = ["XYXZ", "YYZZ", "XYXZ"]
>>> from_list = QubitSparsePauliList.from_list(labels)
>>> from_sparse_list = QubitSparsePauliList.from_sparse_list([
...     (label, (3, 2, 1, 0))
...     for label in labels
... ])
>>> assert from_list == from_sparse_list

Vedi anche

from_sparse_list()

Costruire la lista dalle etichette senza identità esplicite, ma con i qubit a cui si applica ogni termine dell'operatore a singolo qubit elencati esplicitamente.

from_pauli

static from_pauli(pauli, /)

Costruire un QubitSparsePauliList da una singola Pauli istanza.

L'elenco di output avrà un solo termine. Si noti che la fase viene abbandonata.

Parametri

pauli (Pauli) – il singolo Pauli da convertire.

Esempi

>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> QubitSparsePauliList.from_pauli(pauli)
<QubitSparsePauliList with 1 element on 5 qubits: [Y_3 X_2 Z_1]>
>>> assert QubitSparsePauliList.from_label(label) == QubitSparsePauliList.from_pauli(pauli)

from_qubit_sparse_paulis

static from_qubit_sparse_paulis(obj, /, num_qubits=None)

Costruire un QubitSparsePauliList a partire da singole QubitSparsePauli istanze.

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

Parametri

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

Risultati

L'elenco corrispondente.

from_sparse_list

static from_sparse_list(iter, /, num_qubits)

Costruire una lista di Pauli sparsa di qubit a partire da un elenco di etichette e dai qubit a cui si applica ciascun elemento.

Questo è analogo a SparsePauliOp.from_sparse_list().

I campi "etichette" e "indici" delle tuple sono associati tra loro mediante zippatura. 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]]]) – tuple di etichette e i qubit a cui si applica ogni termine a singolo qubit.
num_qubits (int) – il numero di qubit su cui agiscono gli operatori della lista.

Esempi

Costruire un semplice elenco:

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

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

>>> labels = ["XYXZ", "YYZZ", "XYXZ"]
>>> from_list = QubitSparsePauliList.from_list(labels)
>>> from_sparse_list = QubitSparsePauliList.from_sparse_list([
...     (label, (3, 2, 1, 0))
...     for label in labels
... ])
>>> assert from_list == from_sparse_list

Vedi anche

to_sparse_list()

L'inverso di questo metodo.

to_dense_array

to_dense_array()

Esprimere l'elenco in un formato di matrice densa.

Ogni voce è un u8 che segue la Pauli mentre le righe indicizzano paoli distinti e le colonne qubit distinti.

Esempi

>>> paulis = QubitSparsePauliList.from_sparse_list(
...     [("ZX", (1, 4)), ("YY", (0, 3)), ("XX", (0, 1))],
...     num_qubits=5,
... )
>>> paulis.to_dense_array()

to_pauli_list

to_pauli_list()

Restituisce un PauliList che rappresenta lo stesso elenco senza fase di Paulis.

to_sparse_list

to_sparse_list()

Esprime l'elenco in termini di formato di elenco rado.

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

>>> qubit_sparse_list = QubitSparsePauliList.from_list(["IIXIZ", "IIZIX"])
>>> reconstructed = QubitSparsePauliList.from_sparse_list(qubit_sparse_list.to_sparse_list(), qubit_sparse_list.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.