PhasedQubitSparsePauliList

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

Basi: object

Un elenco di operatori di Pauli con fasi memorizzate in un formato qubit-sparse.

Rappresentazione

Ogni singolo operatore di Pauli nella lista è un prodotto tensoriale di operatori di Pauli a singolo qubit della forma $P = (-i)^n\bigotimes_n A^{(n)}_i$ , per $A^{(n)}_i \in \{I, X, Y, Z\}$ , e un intero $n$ chiamato esponente di fase. La rappresentazione interna di a PhasedQubitSparsePauliList memorizza solo gli operatori di Pauli non identitari a singolo qubit.

Indicizzazione

PhasedQubitSparsePauliList 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 PhasedQubitSparsePauli istanze.

Costruzioni

PhasedQubitSparsePauliList 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 di stringa densa in un elemento singolo `PhasedQubitSparsePauliList`.
`from_list()`	Costruire da un elenco di etichette di stringhe dense.
`from_sparse_list()`	Elementi forniti come elenco di tuple dell'esponente di fase, etichette di stringhe sparse e i qubit a cui si applicano.
`from_pauli()`	Trasforma un singolo elemento `Pauli` in un elemento singolo `PhasedQubitSparsePauliList`.
`from_phased_qubit_sparse_paulis()`	Costruire da un elenco di `PhasedQubitSparsePauli`s.

new

__new__(data, /, num_qubits=None)

Il costruttore predefinito di PhasedQubitSparsePauliList.

Questo 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 PhasedQubitSparsePauliList, 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 fasati qubit-sparse che agiscono su un dato numero di qubit.

Conversioni

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

Metodo	Riepilogo
`to_sparse_list()`	Esprimere l'osservabile in un formato di lista rada con elementi `(phase, 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 sparsa di qubit sfasati.

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

copy

copy()

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

Esempi

>>> phased_qubit_sparse_pauli_list = PhasedQubitSparsePauliList.from_list(["IXZXYYZZ", "ZXIXYYZZ"])
>>> assert phased_qubit_sparse_pauli_list == phased_qubit_sparse_pauli_list.copy()
>>> assert phased_qubit_sparse_pauli_list is not phased_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 PhasedQubitSparsePauliList istanze.

Esempi

Ottenere l'elenco vuoto su 100 qubit:

>>> PhasedQubitSparsePauliList.empty(100)
<PhasedQubitSparsePauliList 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

>>> PhasedQubitSparsePauliList.from_label("IIIIXZI")
<PhasedQubitSparsePauliList with 1 element on 7 qubits: [X_2 Z_1]>
>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> assert PhasedQubitSparsePauliList.from_label(label) == PhasedQubitSparsePauliList.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 fasata 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:

>>> PhasedQubitSparsePauliList.from_list([
...     "IIIXX",
...     "IIYYI",
...     "IXXII",
...     "ZZIII",
... ])
<PhasedQubitSparsePauliList 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:

>>> PhasedQubitSparsePauliList.from_list([], num_qubits=10)
<PhasedQubitSparsePauliList 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 = PhasedQubitSparsePauliList.from_list(labels)
>>> from_sparse_list = PhasedQubitSparsePauliList.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 PhasedQubitSparsePauliList 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)
>>> PhasedQubitSparsePauliList.from_pauli(pauli)
<PhasedQubitSparsePauliList with 1 element on 5 qubits: [Y_3 X_2 Z_1]>
>>> assert PhasedQubitSparsePauliList.from_label(label) == PhasedQubitSparsePauliList.from_pauli(pauli)

from_phased_qubit_sparse_paulis

static from_phased_qubit_sparse_paulis(obj, /, num_qubits=None)

Costruire un PhasedQubitSparsePauliList a partire da singole PhasedQubitSparsePauli istanze.

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

Parametri

obj (Iterable[PhasedQubitSparsePauli]) – 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 sparse di qubit sfasati 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[int, str, Sequence[int]]]) – tuple di esponenti di fase, 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:

>>> PhasedQubitSparsePauliList.from_sparse_list(
...     [(0, "ZX", (1, 4)), (1, "YY", (0, 3))],
...     num_qubits=5,
... )
<PhasedQubitSparsePauliList with 2 elements on 5 qubits: [X_4 Z_1, (-i)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 = PhasedQubitSparsePauliList.from_list(labels)
>>> from_sparse_list = PhasedQubitSparsePauliList.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_pauli_list

to_pauli_list()

Restituisce un PauliList che rappresenta lo stesso elenco 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 PhasedQubitSparsePauliList.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

>>> phased_qubit_sparse_list = PhasedQubitSparsePauliList.from_list(["IIXIZ", "IIZIX"])
>>> reconstructed = PhasedQubitSparsePauliList.from_sparse_list(phased_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.