SparsePauliOp

Valeur par défaut : 1e-08

Retourne les coefficients de Pauli.

Retourne un tuple (forme_d'entrée, forme_de_sortie).

Renvoie le nombre de qubits s'il s'agit d'un opérateur à N qubits ou None dans le cas contraire.

Retourner le Parameters libre dans les coefficients.

Retourner le site PauliList.

Retourne les qargs de l'opérateur.

Valeur par défaut : 1e-05

Paramètres de retour.

Le nombre de termes de Pauli dans l'opérateur.

adjoint()

Retourne l'adjoint de l'opérateur.

apply_layout(layout, num_qubits=None)

Appliquer un schéma de transposition à cette SparsePauliOp

Paramètres

• layout (TranspileLayout |list[int] | None) – Soit a TranspileLayout, soit une liste d'entiers, soit None. Si la configuration et le nombre de qubits sont tous deux nuls, une copie de l'opérateur est renvoyée.
• num_qubits (int | None) – Le nombre de qubits auquel l'opérateur doit être étendu. S'il n'est pas fourni, alors si layout est un TranspileLayout le nombre de qubits du circuit de sortie du transpondeur sera utilisé par défaut. Si layout est une liste d'entiers, la permutation spécifiée sera appliquée sans expansion. Si la disposition est nulle, l'opérateur sera étendu au nombre de qubits indiqué.

Retours

Un nouveau SparsePauliOp avec la mise en page fournie appliquée

Type de retour

SparsePauliOp

argsort(weight=False)

Renvoie des indices permettant de trier les lignes du tableau.

Renvoie la composition des permutations dans l'ordre du tri par coefficient et du tri par Pauli. En utilisant le poids kwarg, la sortie peut également être triée en fonction du nombre de termes non identiques dans le Pauli, où l'ensemble de tous les Pauli d'un poids donné est toujours ordonné lexicographiquement.

Exemple

Voici un exemple d'utilisation de SparsePauliOp argsort.

import numpy as np
from qiskit.quantum_info import SparsePauliOp

# 2-qubit labels
labels = ["XX", "XX", "XX", "YI", "II", "XZ", "XY", "XI"]
# coeffs
coeffs = [2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j]

# init
spo = SparsePauliOp(labels, coeffs)
print('Initial Ordering')
print(spo)

# Lexicographic Ordering
srt = spo.argsort()
print('Lexicographically sorted')
print(srt)

# Lexicographic Ordering
srt = spo.argsort(weight=False)
print('Lexicographically sorted')
print(srt)

# Weight Ordering
srt = spo.argsort(weight=True)
print('Weight sorted')
print(srt)

Initial Ordering
SparsePauliOp(['XX', 'XX', 'XX', 'YI', 'II', 'XZ', 'XY', 'XI'],
              coeffs=[2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j])
Lexicographically sorted
[4 7 0 1 2 6 5 3]
Lexicographically sorted
[4 7 0 1 2 6 5 3]
Weight sorted
[4 7 3 0 1 2 6 5]

Paramètres

• weight (bool) – optionnellement trier par poids si True (Défaut : False).
• sorted (By using the weight kwarg the output can additionally be)
• Pauli. (by the number of non-identity terms in the)

Retours

les indices permettant de trier le tableau.

Type de retour

Tableau

assign_parameters(parameters, inplace=False)

Lier les Parameters libres des coefficients aux valeurs fournies.

Paramètres

• parameters (Mapping[Parameter, complex |ParameterExpression] | Sequence[complex |ParameterExpression]) – Les valeurs auxquelles lier les paramètres.
• inplace (bool) – Si False, une copie de l'opérateur avec les paramètres liés est renvoyée. Si True , l'opérateur lui-même est modifié.

Retours

Une copie de l'opérateur avec les paramètres liés, si inplace est False, sinon None.

Type de retour

SparsePauliOp | Aucun

chop(tol=1e-14)

Mettre les parties réelles et imaginaires des coefficients à 0 si < tol en magnitude.

Par exemple, l'opérateur représentant 1+1e-17j X + 1e-17 Y avec une tolérance supérieure à 1e-17 sera réduit à 1 X alors que SparsePauliOp.simplify() renverrait 1+1e-17j X.

Si, après le tranchage, les parties réelle et imaginaire d'un coefficient sont toutes deux égales à 0, le terme de Pauli correspondant est supprimé de l'opérateur.

Paramètres

tol (float) – Tolérance absolue permettant de vérifier si une partie réelle ou imaginaire doit être mise à 0.

Retours

Cet opérateur à coefficients hachés.

Type de retour

SparsePauliOp

compose(other, qargs=None, front=False)

Retourner la composition de l'opérateur avec un autre SparsePauliOp.

Paramètres

• other (SparsePauliOp) – un objet SparsePauliOp.
• qargs (list or None) – une liste des postes au sein du sous-système auxquels appliquer d'autres mesures. Si « None » s'applique à tous les sous-systèmes (par défaut : None).
• front (bool) – Si True, composer en utilisant la multiplication de l'opérateur de droite, au lieu de la multiplication de gauche [par défaut : False].

Retours

La composition SparsePauliOp.

Type de retour

SparsePauliOp

Augmentations

QiskitError – si l'autre ne peut pas être converti en opérateur ou si ses dimensions sont incompatibles avec celles des sous-systèmes spécifiés.

conjugate()

Retourne le conjugué de SparsePauliOp.

copy()

Effectuer une copie intégrale de l'opérateur actuel.

dot(other, qargs=None)

Retourne l'opérateur multiplié par la droite self * other.

Paramètres

• other (Operator) – un objet opérateur.
• qargs (list or None) – une liste des postes au sein du sous-système auxquels appliquer d'autres mesures. Si « None » s'applique à tous les sous-systèmes (par défaut : None).

Retours

La matrice droite multipliée Opérateur.

Type de retour

Opérateur

equiv(other, atol=None)

Vérifier si deux opérateurs SparsePauliOp sont équivalents.

Paramètres

• other (SparsePauliOp) – un objet opérateur.
• atol (float | None) – Tolérance numérique absolue pour le contrôle de l'équivalence.

Retours

Vrai si l'opérateur est équivalent à self.

Type de retour

booléen

expand(other)

Renvoyer le produit tensoriel d'ordre inverse avec un autre SparsePauliOp.

Paramètres

other (SparsePauliOp) – un objet SparsePauliOp.

Retours

le produit tensoriel $b \otimes a$, où $a$

est l'actuel SparsePauliOp, et $b$ est l'autre SparsePauliOp.

Type de retour

SparsePauliOp

static from_list(obj, dtype=None, *, num_qubits=None)

Construit à partir d'une liste de chaînes de Pauli et de coefficients.

Par exemple, l'hamiltonien à 5 qubits

peut être construit comme suit

from qiskit.quantum_info import SparsePauliOp

# via tuples and the full Pauli string
op = SparsePauliOp.from_list([("XIIZI", 1), ("IYIIY", 2)])

Paramètres

• obj (Iterable[Tuple[str, complex]]) – La liste des 2-tuples spécifiant les termes de Pauli.
• dtype (type | None) – Type de données des coefficients. Si None (par défaut), le type de données est automatiquement déduit.
• num_qubits (int) – Le nombre de qubits de l'opérateur (par défaut : aucun).

Retours

La représentation SparsePauliOp des termes de Pauli.

Type de retour

SparsePauliOp

Augmentations

• QiskitError – Si une liste vide est transmise et que num_qubits est None.
• QiskitError – Si le nombre de qubits ne correspond pas au nombre d'éléments de la liste d'entrée.

static from_operator(obj, atol=None, rtol=None)

Construire à partir d'un objet Operator.

Notez que le coût de cette construction est exponentiel en général car le nombre de termes de Pauli possibles dans la décomposition est exponentiel dans le nombre de qubits.

En interne, il utilise une implémentation de la "décomposition de Pauli tensoriée" présentée dans Hantzko, Binkowski et Gupta (2023).

Paramètres

• obj (Operator) – un opérateur N-qubit.
• atol (float) – En option. Tolérance absolue pour vérifier si les coefficients sont nuls (par défaut : 1e-8 ). Comme la comparaison se fait par rapport à zéro, la tolérance utilisée est en fait le maximum de atol et rtol.
• rtol (float) – En option. tolérance relative pour vérifier si les coefficients sont nuls (par défaut : 1e-5 ). Comme la comparaison se fait par rapport à zéro, la tolérance utilisée est en fait le maximum de atol et rtol.

Retours

la représentation SparsePauliOp de l'opérateur.

Type de retour

SparsePauliOp

Augmentations

QiskitError – si l'opérateur d'entrée n'est pas un opérateur à N qubits.

static from_sparse_list(obj, num_qubits, do_checks=True, dtype=None)

Construit à partir d'une liste de chaînes de Pauli locales et de coefficients.

Chaque élément de la liste est un triplet composé d'une chaîne de Pauli locale, d'indices permettant de l'appliquer et d'un coefficient.

Par exemple, l'hamiltonien à 5 qubits

peut être construit comme suit

from qiskit.quantum_info import SparsePauliOp

# via triples and local Paulis with indices
op = SparsePauliOp.from_sparse_list([("ZX", [1, 4], 1), ("YY", [0, 3], 2)], num_qubits=5)

# equals the following construction from "dense" Paulis
op = SparsePauliOp.from_list([("XIIZI", 1), ("IYIIY", 2)])

Paramètres

• obj (Iterable[tuple[str, list[int], complex]]) – La liste des 3-tuples spécifiant les Paulis.
• num_qubits (int) – Le nombre de qubits de l'opérateur.
• do_checks (bool) – Indique s'il faut effectuer des contrôles de validité sur les indices fournis.
• dtype (type | None) – Type de données des coefficients. Si None (par défaut), le type de données est automatiquement déduit.

Retours

La représentation SparsePauliOp des termes de Pauli.

Type de retour

SparsePauliOp

Augmentations

• QiskitError – Si le nombre de qubits n'est pas compatible avec les indices des termes de Pauli.
• QiskitError – Si le qubit désigné est déjà attribué.

static from_sparse_observable(obs)

Initialiser à partir d'un SparseObservable.

Paramètres

obs (SparseObservable) – Les SparseObservable à convertir.

Retours

A SparsePauliOp version de l'observable.

Type de retour

SparsePauliOp

group_commuting(qubit_wise=False)

Partitionner un site SparsePauliOp en ensembles de cordes de Pauli commutées.

Paramètres

qubit_wise (bool) –

si la règle de commutation est appliquée à l'ensemble de l'opérateur ou à chaque qubit. Par exemple :

>>> from qiskit.quantum_info import SparsePauliOp
>>> op = SparsePauliOp.from_list([("XX", 2), ("YY", 1), ("IZ",2j), ("ZZ",1j)])
>>> op.group_commuting()
[SparsePauliOp(["IZ", "ZZ"], coeffs=[0.+2.j, 0.+1j]),
 SparsePauliOp(["XX", "YY"], coeffs=[2.+0.j, 1.+0.j])]
>>> op.group_commuting(qubit_wise=True)
[SparsePauliOp(['XX'], coeffs=[2.+0.j]),
 SparsePauliOp(['YY'], coeffs=[1.+0.j]),
 SparsePauliOp(['IZ', 'ZZ'], coeffs=[0.+2.j, 0.+1.j])]

Retours

Liste de SparsePauliOp où chaque SparsePauliOp contient

opérateurs de Pauli commutés.

Type de retour

liste [ SparsePauliOp ]

input_dims(qargs=None)

Retourne un ensemble de dimensions d'entrée pour les sous-systèmes spécifiés.

is_unitary(atol=None, rtol=None)

Retourne True si l'opérateur est une matrice unitaire.

Cette méthode vérifie si l'opérateur composé avec son adjoint est égal à l'identité, jusqu'à la tolérance fournie. La tolérance est utilisée pour simplifier l'opérateur composé et vérifier si le résultat est l'identité.

Paramètres

• atol (float) – En option. Tolérance absolue pour vérifier si les coefficients sont nuls (par défaut : 1e-8 ).
• rtol (float) – En option. Tolérance relative pour vérifier si les coefficients sont nuls (par défaut : 1e-5 ).

Retours

Vrai si l'opérateur est unitaire, Faux sinon.

Type de retour

booléen

label_iter()

Renvoie un itérateur de représentation des étiquettes.

Il s'agit d'un itérateur paresseux qui convertit chaque terme du site SparsePauliOp en un tuple (label, coeff). Pour convertir l'ensemble du tableau en étiquettes, utilisez la méthode to_labels() .

Retours

objet itérateur d'étiquettes pour le site SparsePauliOp.

Type de retour

LabelIterator

matrix_iter(sparse=False)

Retourne un itérateur de représentation de la matrice.

Il s'agit d'un itérateur paresseux qui convertit chaque terme du site SparsePauliOp en une matrice au fur et à mesure de son utilisation. Pour convertir en une seule matrice, utilisez la méthode to_matrix() méthode.

Paramètres

sparse (bool) – Renvoie des matrices CSR creuses si la valeur est True; sinon, renvoie des matrices sous forme de tableaux Numpy (par défaut : False)

Retours

objet itérateur de matrice pour PauliList.

Type de retour

MatrixIterator

noncommutation_graph(qubit_wise)

Créez le graphe de non-commutation de cette SparsePauliOp.

Cela transforme le problème de regroupement des opérateurs de mesure en un problème de coloration de graphe. Le graphe construit contient un nœud pour chaque Pauli. Les nœuds seront connectés pour tout terme de Pauli qui ne commute pas.

Paramètres

qubit_wise (bool) – si la règle de commutation est appliquée à l'ensemble de l'opérateur ou à chaque qubit.

Retours

le graphe de non-commutation avec des nœuds pour chaque Pauli et des arêtes

indiquant une relation de non-commutation. Chaque nœud contient l'indice du terme de Pauli auquel il correspond dans ses données. Les bords du graphique ne contiennent aucune donnée.

Type de retour

rustworkx.PyGraph

output_dims(qargs=None)

Retourne un tuple de dimensions de sortie pour les sous-systèmes spécifiés.

power(n)

Renvoie le résultat de la composition d'un opérateur avec lui-même n fois.

Paramètres

n (int) – le nombre de fois où l'on compose avec soi-même ( n>0 ).

Retours

l'opérateur composé n fois.

Type de retour

Clifford

Augmentations

QiskitError – si les dimensions d'entrée et de sortie de l'opérateur ne sont pas égales, ou si la puissance n'est pas un nombre entier positif.

reshape(input_dims=None, output_dims=None, num_qubits=None)

Renvoyer une copie peu profonde avec les dimensions des sous-systèmes d'entrée et de sortie remodelées.

Paramètres

• input_dims (None or tuple) – les nouvelles dimensions d'entrée du sous-système. Si aucun, les gradations d'entrée d'origine seront conservées. [Par défaut : Aucun].
• output_dims (None or tuple) – les nouvelles dimensions de sortie du sous-système. Si aucun, les gradations de sortie d'origine seront conservées. [Par défaut : Aucun].
• num_qubits (None or int) – transformer en un opérateur N-qubit [Défaut : Aucun].

Retours

renvoie l'utilisateur avec les dimensions d'entrée et de sortie remodelées.

Type de retour

BaseOperator

Augmentations

QiskitError – si la somme des dimensions d'entrée ou de sortie de tous les sous-systèmes n'est pas constante.

simplify(atol=None, rtol=None)

Simplifiez PauliList en combinant les doublons et en supprimant les zéros.

Paramètres

• atol (float) – En option. Tolérance absolue pour vérifier si les coefficients sont nuls (par défaut : 1e-8 ).
• rtol (float) – En option. tolérance relative pour vérifier si les coefficients sont nuls (par défaut : 1e-5 ).

Retours

l'opérateur simplifié SparsePauliOp.

Type de retour

SparsePauliOp

sort(weight=False)

Trier les lignes du tableau.

Après avoir trié les coefficients à l'aide de numpy's argsort, trier par Pauli. Le tri de Pauli est prioritaire. Si Pauli est le même, il sera trié par coefficient. En utilisant le poids kwarg, la sortie peut également être triée en fonction du nombre de termes non identiques dans le Pauli, où l'ensemble de tous les Pauli d'un poids donné est toujours ordonné lexicographiquement.

Exemple

Voici un exemple d'utilisation du tri SparsePauliOp.

import numpy as np
from qiskit.quantum_info import SparsePauliOp

# 2-qubit labels
labels = ["XX", "XX", "XX", "YI", "II", "XZ", "XY", "XI"]
# coeffs
coeffs = [2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j]

# init
spo = SparsePauliOp(labels, coeffs)
print('Initial Ordering')
print(spo)

# Lexicographic Ordering
srt = spo.sort()
print('Lexicographically sorted')
print(srt)

# Lexicographic Ordering
srt = spo.sort(weight=False)
print('Lexicographically sorted')
print(srt)

# Weight Ordering
srt = spo.sort(weight=True)
print('Weight sorted')
print(srt)

Initial Ordering
SparsePauliOp(['XX', 'XX', 'XX', 'YI', 'II', 'XZ', 'XY', 'XI'],
              coeffs=[2.+1.j, 2.+2.j, 3.+0.j, 3.+0.j, 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j])
Lexicographically sorted
SparsePauliOp(['II', 'XI', 'XX', 'XX', 'XX', 'XY', 'XZ', 'YI'],
              coeffs=[4.+0.j, 7.+0.j, 2.+1.j, 2.+2.j, 3.+0.j, 6.+0.j, 5.+0.j, 3.+0.j])
Lexicographically sorted
SparsePauliOp(['II', 'XI', 'XX', 'XX', 'XX', 'XY', 'XZ', 'YI'],
              coeffs=[4.+0.j, 7.+0.j, 2.+1.j, 2.+2.j, 3.+0.j, 6.+0.j, 5.+0.j, 3.+0.j])
Weight sorted
SparsePauliOp(['II', 'XI', 'YI', 'XX', 'XX', 'XX', 'XY', 'XZ'],
              coeffs=[4.+0.j, 7.+0.j, 3.+0.j, 2.+1.j, 2.+2.j, 3.+0.j, 6.+0.j, 5.+0.j])

Paramètres

• weight (bool) – optionnellement trier par poids si True (Défaut : False).
• sorted (By using the weight kwarg the output can additionally be)
• Pauli. (by the number of non-identity terms in the)

Retours

une copie triée du tableau original.

Type de retour

SparsePauliOp

static sum(ops)

Somme de SparsePauliOps.

Il s'agit d'une version spécialisée de la fonction intégrée sum pour SparsePauliOp avec des frais généraux moindres.

Paramètres

ops (list[SparsePauliOp]) – une liste de SparsePauliOps.

Retours

le site SparsePauliOp représentant la somme de la liste d'entrée.

Type de retour

SparsePauliOp

Augmentations

• QiskitError – si la liste d'entrée est vide.
• QiskitError – si la liste d'entrée contient un objet qui n'est pas de type « SparsePauliOp ».
• QiskitError – si le nombre de qubits des objets figurant dans la liste d'entrée ne correspond pas.

tensor(other)

Retourner le produit tensoriel avec un autre SparsePauliOp.

Paramètres

other (SparsePauliOp) – un objet SparsePauliOp.

Retours

le produit tensoriel $a \otimes b$, où $a$

est l'actuel SparsePauliOp, et $b$ est l'autre SparsePauliOp.

Type de retour

SparsePauliOp

to_list(array=False)

Convertir en une liste d'étiquettes et de coefficients de la chaîne de Pauli.

Pour les opérateurs comportant un grand nombre de termes, la conversion à l'aide de array=True kwarg sera plus efficace car elle alloue à l'avance de la mémoire pour le tableau Numpy complet d'étiquettes.

Paramètres

array (bool) – renvoie un tableau Numpy si True, sinon renvoie une liste (Défaut : False).

Retours

Liste des paires (label, coeff) pour les lignes du site PauliList.

Type de retour

liste ou tableau

to_matrix(sparse=False, force_serial=False)

Convertir en une matrice dense ou éparse.

Paramètres

• sparse (bool) – si True renvoie une matrice CSR éparse, sinon renvoie un tableau Numpy dense (par défaut).
• force_serial (bool) – si True, utiliser une implémentation non threadée, quel que soit l'état des variables d'environnement de contrôle du threading de Qiskit. Par défaut, le parallélisme threadé est utilisé sur les unités centrales disponibles.

Retours

Une matrice dense si sparse=False. csr_matrix : Une matrice éparse au format CSR si sparse=True.

Type de retour

Tableau

to_operator()

Convertir en objet opérateur de matrice

Type de retour

Opérateur

to_sparse_list()

Convertir en un format de liste de Pauli clairsemée avec des éléments (pauli, qubits, coefficient).

transpose()

Retourne la transposition de SparsePauliOp.