PhasedQubitSparsePauliList

__new__(data, /, num_qubits=None)

Le constructeur par défaut de PhasedQubitSparsePauliList.

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 PhasedQubitSparsePauliListauquel 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 phasés.

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 explicitement spécifiée, aucun remappage n'est appliqué (mais vous pouvez tout de même 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 = PhasedQubitSparsePauliList.from_list(["IXXXYY", "ZZYZII"])
>>> pauli_list.clear()
>>> assert pauli_list == PhasedQubitSparsePauliList.empty(pauli_list.num_qubits)

copy()

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

Exemples

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

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 PhasedQubitSparsePauliList instances.

Exemples

Obtenir la liste vide sur 100 qubits :

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

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

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

Construire une liste de Pauli qubit-sparse phasée à 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 d'é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 :

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

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

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

static from_pauli(pauli, /)

Construire un PhasedQubitSparsePauliList à 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)
>>> 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)

static from_phased_qubit_sparse_paulis(obj, /, num_qubits=None)

Construire un PhasedQubitSparsePauliList à partir d'instances individuelles de PhasedQubitSparsePauli 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[PhasedQubitSparsePauli]) – 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 en phase à 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[int, str, Sequence[int]]]) – tuples d'exposants de phase, d'étiquettes et de qubits auxquels s'applique chaque terme de qubit unique.
• num_qubits (int) – le nombre de qubits sur lesquels agissent les opérateurs de la liste.

Exemples

Construire une liste simple :

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

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

to_pauli_list()

Retourne un PauliList représentant la même liste de Paulis.

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

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