QubitSparsePauli

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

Bases : object

Un opérateur de Pauli sans phase stocké dans un format épargné par les qubits.

Représentation

Un opérateur de Pauli est un produit tensoriel d'opérateurs de Pauli à qubit unique de la forme $P = \bigotimes_n A^{(n)}_i$ , pour $A^{(n)}_i \in \{I, X, Y, Z\}$ . La représentation interne de a QubitSparsePauli ne stocke que les opérateurs de Pauli à qubit unique non identiques.

En interne, chaque opérateur de Pauli à qubit unique est stocké avec une valeur numérique, explicitement :

Libellé	Opérateur	Valeur numérique	`Pauli` attribut
`"I"`	$I$ (identité)	Non stocké.	Non stocké.
`"X"`	$X$ (Pauli X)	`0b10` (2)	`X`
`"Y"`	$Y$ (Pauli Y)	`0b11` (3)	`Y`
`"Z"`	$Z$ (Pauli Z)	`0b01` (1)	`Z`

Attribut	Longueur	Description
`paulis`	$s$	Chacun des opérateurs de Pauli non identiques pour un qubit unique. Ils correspondent aux $A^{(n)}_i$ non identiques de la liste, où les entrées sont stockées dans l'ordre croissant de $i$ en premier, et dans l'ordre croissant de $n$ à l'intérieur de chaque terme.
`indices`	$s$	Le qubit correspondant ( $n$ ) pour chacun des opérateurs dans `paulis`. `QubitSparsePauli` exige que cette liste soit triée par terme, et les algorithmes peuvent compter sur le respect de cet invariant.

Le paramètre $s$ est le nombre total de termes de qubits uniques non identiques.

L'élément scalaire du tableau paulis est stocké sous la forme d'un octet numérique. Les valeurs numériques sont liées à la représentation symplectique de Pauli utilisée SparsePauliOp utilise, et sont accessibles avec un accès nommé par une énumération :

Pauli

class Pauli

GitHub

Un IntEnum qui fournit un accès nommé aux valeurs numériques utilisées pour représenter chacun des termes de l'alphabet du qubit unique énumérés dans Alphabet des opérateurs de Pauli du qubit unique utilisés dans QubitSparsePauliList.

Cette classe est rattachée à QubitSparsePauli. Accédez-y en tant que QubitSparsePauli.Pauli. Si cela représente trop de travail de saisie et que vous n'avez affaire qu'à des QubitSparsePauliList et que le nom Pauli n'est pas ambigu, vous pouvez l'abréger comme suit :

>>> ops = QubitSparsePauli.Pauli
>>> assert ops.X is QubitSparsePauli.Pauli.X

Vous pouvez accéder à toutes les valeurs de l'énumération soit par l'accès aux attributs, soit par un indexage de type dictionnaire par chaîne de caractères :

>>> assert QubitSparsePauli.Pauli.X is QubitSparsePauli.Pauli["X"]

Les bits représentant chaque qubit unique de Pauli sont la représentation symplectique (sans phase) de l'opérateur de Pauli.

Valeurs

X

Valeur par défaut : 2

L'opérateur Pauli $X$ . Utilise l'étiquette à lettre unique "X".

Y

Valeur par défaut : 3

L'opérateur Pauli $Y$ . Utilise l'étiquette à lettre unique "Y".

Z

Valeur par défaut : 1

L'opérateur Pauli $Z$ . Utilise l'étiquette à lettre unique "Z".

Chacun des attributs de type tableau se comporte comme une séquence Python. Vous pouvez les indexer et les découper avec une sémantique list-standard. Le découpage d'un attribut renvoie un Numpy ndarray contenant une copie des données pertinentes avec le dtype naturel du champ; cela vous permet d'effectuer facilement des opérations mathématiques sur les résultats, telles que des opérations bit à bit sur paulis.

Construction

QubitSparsePauli définit plusieurs constructeurs. Le constructeur par défaut tentera de déléguer à l'un des constructeurs plus spécifiques, en fonction du type d'entrée. Vous pouvez toujours utiliser les constructeurs spécifiques pour mieux contrôler la construction.

Méthode	Récapitulatif
`from_label()`	Convertir une étiquette de chaîne dense en une étiquette de `QubitSparsePauli`.
`from_sparse_label()`	Construire un `QubitSparsePauli` à partir d'un tuple composé d'un label de chaîne clairsemée et des qubits auxquels il s'applique.
`from_pauli()`	Transformer un simple `Pauli` en un `QubitSparsePauli`.
`from_raw_parts()`	Construire l'opérateur à partir des tableaux de données brutes.

new

__new__(data, /, num_qubits=None)

Le constructeur par défaut de QubitSparsePauli.

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 QubitSparsePauliauquel cas l'entrée est copiée, ou il peut s'agir d'un format valide pour l'un ou l'autre des formats from_label() ou from_sparse_label().
num_qubits (int|None) – Nombre facultatif de qubits pour l'opérateur. Pour la plupart des entrées de données, ce paramètre peut être déduit et n'a pas besoin d'être transmis. Il n'est nécessaire que pour le format à étiquettes éparses. S'il est donné inutilement, il doit correspondre aux données saisies.

Attributs

indices

Vue en lecture seule sur les indices de chaque terme non identitaire d'un qubit unique.

Les indices seront toujours triés.

num_qubits

Le nombre de qubits sur lesquels le terme est défini.

paulis

Vue en lecture seule sur les termes individuels du qubit unique.

Les seules valeurs valables dans le tableau sont celles qui ont une valeur correspondante de Pauli.

Méthodes

commutes

commutes(other)

Vérifiez si « self » commute avec un autre qubit de type Pauli clairsemé.

Paramètres

other (QubitSparsePauli) – le qubit sparse Pauli pour vérifier la commutation avec.

compose

compose(other)

Composition sans phase avec une autre QubitSparsePauli.

Paramètres

other (QubitSparsePauli) – le qubit sparse Pauli à composer.

copy

copy()

Obtenez une copie de ce terme.

from_label

static from_label(label, /)

Construit à partir d'une étiquette de chaîne 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

>>> QubitSparsePauli.from_label("IIIIXZI")
<QubitSparsePauli on 7 qubits: X_2 Z_1>
>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> assert QubitSparsePauli.from_label(label) == QubitSparsePauli.from_pauli(pauli)

from_pauli

static from_pauli(pauli, /)

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

Notez que la phase de Pauli est supprimée.

Paramètres

pauli (Pauli) – le seul Pauli à convertir.

Exemples

>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> QubitSparsePauli.from_pauli(pauli)
<QubitSparsePauli on 5 qubits: Y_3 X_2 Z_1>
>>> assert QubitSparsePauli.from_label(label) == QubitSparsePauli.from_pauli(pauli)

from_raw_parts

static from_raw_parts(num_qubits, paulis, indices)

Construire un QubitSparsePauli à partir de tableaux Numpy bruts qui correspondent à la représentation des données requise décrite dans la documentation au niveau de la classe.

Les données de chaque tableau sont copiées dans des allocations d'espace Rust fraîches et évolutives.

Paramètres

num_qubits - nombre de qubits sur lesquels l'opérateur agit.
paulis - liste des termes du qubit unique. Il doit s'agir d'un tableau Numpy avec le dtype uint8 (qui est compatible avec Pauli).
indices - liste triée des qubits auxquels correspond chaque terme de qubit unique. Il doit s'agir d'un tableau Numpy avec le dtype uint32.

Exemples

Construire un opérateur $Z$ agissant sur le qubit 50 de 100 qubits.

>>> num_qubits = 100
>>> terms = np.array([QubitSparsePauli.Pauli.Z], dtype=np.uint8)
>>> indices = np.array([50], dtype=np.uint32)
>>> QubitSparsePauli.from_raw_parts(num_qubits, terms, indices)
<QubitSparsePauli on 100 qubits: Z_50>

from_sparse_label

static from_sparse_label(sparse_label, num_qubits)

Construire un qubit sparse Pauli à partir d'un label sparse, donné comme un tuple d'une chaîne de Paulis, et les indices des qubits correspondants.

Ceci est analogue à SparsePauliOp.from_sparse_list().

Paramètres

sparse_label (tuple[str, Sequence[int]]) – et les qubits auxquels s'applique chaque terme de qubit unique.
num_qubits (int) – le nombre de qubits sur lesquels l'opérateur agit.

Exemples

Construire un simple Pauli :

>>> QubitSparsePauli.from_sparse_label(
...     ("ZX", (1, 4)),
...     num_qubits=5,
... )
<QubitSparsePauli on 5 qubits: X_4 Z_1>

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

>>> label = "XYXZ"
>>> from_label = QubitSparsePauli.from_label(label)
>>> from_sparse_label = QubitSparsePauli.from_sparse_label(
...     (label, (3, 2, 1, 0)),
...     num_qubits=4
... )
>>> assert from_label == from_sparse_label

identity

static identity(num_qubits)

Obtenir l'opérateur d'identité pour un nombre donné de qubits.

Exemples

Obtenez l'identité sur 100 qubits :

>>> QubitSparsePauli.identity(100)
<QubitSparsePauli on 100 qubits: >

to_pauli

to_pauli()

Retourner un Pauli représentant le même Pauli sans phase.

to_qubit_sparse_pauli_list

to_qubit_sparse_pauli_list()

Convertir ce Pauli en un seul élément QubitSparsePauliList.

Cette page a-t-elle été utile ?

Signaler un bogue, une coquille ou proposer du contenu sur GitHub.