QubitSparsePauliList

__new__(data, /, num_qubits=None)

Le constructeur par défaut de QubitSparsePauliList.

Elle délègue à l'une des méthodes explicites de conversion-construction, en fonction du type de l'argument data . Si num_qubits est fourni et que le constructeur impliqué par le type de data n'accepte pas de nombre, l'entier donné doit correspondre à l'entrée.

Paramètres

• data - Le type de données de l'entrée. Il peut s'agir d'un autre QubitSparsePauliListauquel cas l'entrée est copiée, ou il peut s'agir d'une liste dans un format valide pour soit from_list() ou from_sparse_list().
• num_qubits (int|None) – Nombre facultatif de qubits pour la liste. Pour la plupart des entrées de données, ce paramètre peut être déduit et n'a pas besoin d'être transmis. Elle n'est nécessaire que pour les listes vides ou le format "sparse-list". S'il est donné inutilement, il doit correspondre aux données saisies.

Le nombre de qubits sur lesquels agissent les opérateurs de la liste.

Cela ne peut être déduit d'aucune autre forme ou valeur, puisque les identités ne sont pas stockées explicitement.

Le nombre d'éléments de la liste.

apply_layout(layout, num_qubits=None)

Appliquer un schéma de transposition à cette liste de Pauli clairsemée de qubits.

Cela permet de remapper les indices des qubits, par exemple si la liste est définie en termes d'étiquettes de qubits virtuels.

Paramètres

• layout (TranspileLayout |list[int] | None) – La mise en page à appliquer. Dans la plupart des cas, cette fonction devrait recevoir le QuantumCircuit.layout champ provenant d'un circuit qui a été transpilé pour le matériel. De plus, vous pouvez transmettre une liste de nouveaux indices de qubits. NoneSi cette option est spécifiée explicitement, aucun remappage n'est appliqué (mais vous pouvez toujours utiliser num_qubits pour développer les qubits de la liste).
• num_qubits (int | None) – Le nombre de qubits à ajouter aux éléments de la liste. S'il n'est pas fourni, la sortie sera aussi large que l'élément donné, ou de la même largeur que l'élément donné si l'élément est donné sous une autre forme TranspileLayoutou de la même largeur que l'entrée si l'adresse layout est donnée sous une autre forme.

Retours

Un nouveau QubitSparsePauli avec la mise en page fournie.

clear()

Efface tous les éléments de la liste, ce qui la rend à nouveau égale à la liste vide.

Cela ne modifie pas la capacité des allocations internes; par conséquent, les opérations d'addition ou de soustraction ultérieures résultant de la composition ne nécessiteront peut-être pas de réallocation.

Exemples

>>> pauli_list = QubitSparsePauliList.from_list(["IXXXYY", "ZZYZII"])
>>> pauli_list.clear()
>>> assert pauli_list == QubitSparsePauliList.empty(pauli_list.num_qubits)

commutes(other)

Vérifiez si les éléments de la liste de Pauli clairsemée de self commutent avec ceux d'un autre qubit.

Paramètres

other (QubitSparsePauliList) – la liste de Pauli clairsemée des qubits à utiliser pour vérifier la commutation.

copy()

Obtenez une copie de cette liste de Pauli éparse de qubits.

Exemples

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

static empty(num_qubits)

Obtenir la liste vide pour un nombre donné de qubits.

La liste vide ne contient aucun élément et constitue l'élément d'identité pour joindre deux instances QubitSparsePauliList instances.

Exemples

Obtenir la liste vide sur 100 qubits :

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

static from_label(label, /)

Construire une liste avec un seul terme à partir d'une chaîne de caractères dense.

L'étiquette doit être une séquence de l'alphabet 'IXYZ'. L'étiquette est interprétée de manière analogue à une chaîne de bits. En d'autres termes, la lettre la plus à droite est associée au qubit 0, et ainsi de suite. C'est la même chose que les étiquettes pour Pauli et SparsePauliOp.

Paramètres

label (str) – l'étiquette dense.

Exemples

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

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

Construire une liste de Pauli à qubits épars à partir d'une liste d'étiquettes denses.

Ceci est analogue à SparsePauliOp.from_list(). Dans ce formulaire dense, vous devez fournir toutes les identités explicitement dans chaque étiquette.

L'étiquette doit être une séquence de l'alphabet 'IXYZ'. L'étiquette est interprétée de manière analogue à une chaîne de bits. En d'autres termes, la lettre la plus à droite est associée au qubit 0, et ainsi de suite. C'est la même chose que les étiquettes pour Pauli et SparsePauliOp.

Paramètres

• iter (list[str]) – Liste des étiquettes de chaînes denses.
• num_qubits (int | None) – Il n'est pas nécessaire de le préciser si vous êtes sûr que iter n'est pas une séquence vide, puisqu'elle peut être déduite de la longueur des étiquettes. Si iter peut être vide, vous devez spécifier cet argument pour déterminer le nombre de qubits sur lesquels les opérateurs agissent. Si cette valeur est donnée et que iter n'est pas vide, la valeur doit correspondre à la longueur des étiquettes.

Exemples

Construire une liste de Pauli éparse de qubits à partir d'une liste d'étiquettes :

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

Utiliser num_qubits pour désambiguïser les entrées potentiellement vides :

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

Cette méthode est équivalente aux appels à from_sparse_list() avec le champ explicite qubit-arguments fixé à des entiers décroissants :

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

static from_pauli(pauli, /)

Construire un QubitSparsePauliList à partir d'une seule instance de Pauli instance.

La liste de sortie ne comportera qu'un seul terme. Notez que la phase est supprimée.

Paramètres

pauli (Pauli) – le seul Pauli à convertir.

Exemples

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

static from_qubit_sparse_paulis(obj, /, num_qubits=None)

Construire un QubitSparsePauliList à partir d'instances individuelles de QubitSparsePauli individuelles.

Tous les termes doivent avoir le même nombre de qubits. S'il est fourni, l'argument num_qubits doit correspondre aux termes.

Paramètres

• obj (Iterable[QubitSparsePauli]) – Itérable de termes individuels à partir desquels la liste est construite.
• num_qubits (int | None) – Le nombre de qubits sur lesquels les éléments de la liste doivent agir. Elle est généralement déduite de l'entrée, mais peut être explicitement donnée pour gérer le cas d'un itérable vide.

Retours

La liste correspondante.

static from_sparse_list(iter, /, num_qubits)

Construire une liste de Pauli éparse de qubits à partir d'une liste d'étiquettes et des qubits auxquels chaque élément s'applique.

Ceci est analogue à SparsePauliOp.from_sparse_list().

Les champs "labels" et "indices" des tuples sont associés en les zippant ensemble. Par exemple, cela signifie qu'un appel à from_list() peut être converti dans la forme utilisée par cette méthode en fixant le champ "indices" de chaque triple à (num_qubits-1, ..., 1, 0).

Paramètres

• iter (list[tuple[str, Sequence[int]]]) – des tuples d'étiquettes et les qubits auxquels s'applique chaque terme à qubit unique.
• num_qubits (int) – le nombre de qubits sur lesquels agissent les opérateurs de la liste.

Exemples

Construire une liste simple :

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

Cette méthode peut reproduire le comportement de from_list()si le champ qubit-arguments du tuple est réglé sur des nombres entiers décroissants :

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

to_dense_array()

Exprimez la liste sous la forme d'un tableau dense.

Chaque entrée est un u8 suivant la représentation Pauli tandis que les lignes indexent des Paulis distincts et les colonnes des qubits distincts.

Exemples

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

to_pauli_list()

Renvoyer un PauliList représentant la même liste de Paulis sans phase.

to_sparse_list()

Exprime la liste en termes de format de liste clairsemée.

Cela peut être considéré comme une contre-opération de QubitSparsePauliList.from_sparse_list()mais il n'est pas garanti que l'ordre des termes soit le même après un aller-retour vers une liste clairsemée.

Exemples

>>> qubit_sparse_list = QubitSparsePauliList.from_list(["IIXIZ", "IIZIX"])
>>> reconstructed = QubitSparsePauliList.from_sparse_list(qubit_sparse_list.to_sparse_list(), qubit_sparse_list.num_qubits)