PauliLindbladMap

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

Bases : object

Une carte de Pauli Lindblad stockée dans un format de qubits épars.

Mathematics

Une carte de Pauli-Lindblad est une carte linéaire agissant sur les matrices de densité sur $n$ -qubits de la forme :

\Lambda\bigl[\circ\bigr] = \exp\left(\sum_{P \in K} \lambda_P (P \circ P - \circ)\right)

où $K$ est un sous-ensemble des opérateurs de Pauli à -qubits $n$ , et les taux, ou coefficients, $\lambda_P$ sont des nombres réels. Lorsque tous les taux $\lambda_P$ sont non négatifs, cela correspond à une application entièrement positive et préservant la trace. La somme dans l'expression exponentielle est appelée « générateur », et chaque terme pris individuellement est appelé « générateur ». Pour simplifier la notation dans la suite de la documentation, nous désignons par « $L(P)\bigl[\circ\bigr] = P \circ P - \circ$ ».

Représentation quasi-probabiliste

La carte $\Lambda$ peut être écrite comme un produit :

\Lambda\bigl[\circ\bigr] = \prod_{P \in K}\exp\left(\lambda_P(P \circ P - \circ)\right).

Pour chaque $P$ , on peut dire que

\exp\left(\lambda_P(P \circ P - \circ)\right) = \omega(\lambda_P) \circ + (1 - \omega(\lambda_P)) P \circ P,

où $\omega(x) = \frac{1}{2}(1 + e^{-2 x})$ . Observez que si $\lambda_P \geq 0$ , alors $\omega(\lambda_P) \in (\frac{1}{2}, 1]$ , et que ce terme est une carte complètement positive et préservant la trace. Cependant, si $\lambda_P < 0$ , alors $\omega(\lambda_P) > 1$ et la carte n'est pas complètement positive ou ne préserve pas la trace. En considérant que $\gamma_P = \omega(\lambda_P) + |1 - \omega(\lambda_P)|$ , $p_P = \omega(\lambda_P) / \gamma_P$ et $b_P \in \{0, 1\}$ sont $1$ si $\lambda_P < 0$ et $0$ sinon, nous réécrivons la carte comme suit :

\omega(\lambda_P) \circ + (1 - \omega(\lambda_P)) P \circ P = \gamma_P \left(p_P \circ + (-1)^{b_P}(1 - p_P) P \circ P\right).

Si $\lambda_P \geq 0$ , $\gamma_P = 1$ et l'expression se réduit au mélange standard de la carte d'identité et de la conjugaison par $P$ . Si $\lambda_P < 0$ , $\gamma_P > 1$ , et la carte est une différence à l'échelle de la carte d'identité et de la conjugaison par $P$ , avec des poids de probabilité (d'où la "quasi-probabilité"). Il s'agit d'une présentation légèrement différente de celle utilisée dans la littérature, mais cette notation nous permet de traiter simultanément les taux non négatifs et négatifs. Le site global $\gamma$ de la chaîne est le produit $\gamma = \prod_{P \in K} \gamma_P$ .

Voir la PauliLindbladMap.sample() pour la procédure d'échantillonnage de cette carte.

Représentation

Chaque opérateur de Pauli individuel dans le générateur 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 PauliLindbladMap ne stocke que les opérateurs de Pauli à qubit unique non identiques. Il est donc nettement plus efficace de représenter des générateurs tels que $\sum_{n\in \text{qubits}} c_n L(Z^{(n)})$ ; pour lesquels la mémoire est linéaire par rapport au nombre total de qubits PauliLindbladMap nécessite une quantité de mémoire linéaire par rapport au nombre total de qubits.

En interne, PauliLindbladMap stocke un tableau de taux et un QubitSparsePauliList contenant les opérateurs de Pauli clairsemés correspondants. De plus, PauliLindbladMap peut calculer l' $\gamma$ globale du canal dans la gamma() méthode, ainsi que les probabilités correspondantes $p_P$ via la probabilities() méthode.

Indexation

PauliLindbladMap se comporte comme une séquence Python (la forme standard, pas la forme développée collections.abc.Sequence). Les générateurs de la carte peuvent être indexés par des nombres entiers et parcourus par itération pour obtenir les termes individuels du générateur.

Chaque terme du générateur apparaît comme une instance, une classe autonome. Les termes individuels sont copiés à partir de la carte de base; les modifications qui leur sont apportées n'affectent pas la carte originale à partir de laquelle ils sont indexés.

GeneratorTerm

class GeneratorTerm(rate, qubit_sparse_pauli)

GitHub

Bases : object

Un seul terme d'un ensemble complet PauliLindbladMap.

Ceux-ci sont généralement créés par indexation ou itération dans un fichier PauliLindbladMap.

copy

copy()

Obtenez une copie de ce terme.

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.

pauli_labels

pauli_labels()

Renvoie les étiquettes pauli du terme sous forme de chaîne de caractères.

Les étiquettes pauli correspondront à l'ordre de GeneratorTerm.indicesde telle sorte que le i-ième caractère de la chaîne soit appliqué à l'index du qubit à l'adresse term.indices[i]. E.g. le terme avec l'opérateur X agissant sur le qubit 0 et Y agissant sur le qubit 3 aura term.indices == np.array([0, 3]) et term.pauli_labels == "XY".

Retours

Les termes binaires de non-identité sous forme de chaîne concaténée.

paulis

Vue en lecture seule sur les termes individuels d'un qubit unique.

Les seules valeurs valables dans le tableau sont celles qui correspondent à Pauli.

qubit_sparse_pauli

Le terme est qubit_sparse_pauli.

rate

Le taux du terme.

to_pauli_lindblad_map

to_pauli_lindblad_map()

Convertir ce terme en un terme complet PauliLindbladMap.

Construction

PauliLindbladMap 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_list()`	Générateurs donnés sous la forme d'une liste de tuples d'étiquettes de chaînes denses et de taux associés.
`from_sparse_list()`	Générateurs donnés sous la forme d'une liste de tuples d'étiquettes de chaînes éparses, des qubits auxquels ils s'appliquent et de leurs taux.
`from_terms()`	Somme des instances individuelles explicites `GeneratorTerm` instances.
`from_components()`	Construit à partir d'un tableau de taux et d'une instance `QubitSparsePauliList` l'exemple.

new

__new__(data, /, num_qubits=None)

Le constructeur par défaut de PauliLindbladMap.

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 PauliLindbladMapauquel 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 carte. 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.

Outre les constructeurs basés sur la conversion, il existe également des méthodes d'aide qui construisent des formes spéciales de cartes.

Méthode	Récapitulatif
`identity()`	La carte d'identité sur un nombre donné de qubits.

Conversions

Un fichier existant PauliLindbladMap peut être converti dans d'autres formats.

Méthode	Récapitulatif
`to_sparse_list()`	Exprimez la carte sous la forme d'une liste clairsemée dont les éléments sont `(paulis, indices, rate)`.

Attributs

num_qubits

Le nombre de qubits sur lesquels la carte agit.

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

num_terms

Le nombre de termes générateurs dans l'exposant de cette carte.

rates

Les tarifs de la carte.

Méthodes

apply_layout

apply_layout(layout, num_qubits=None)

Appliquez un schéma de transposition à cette carte de Pauli Lindblad.

Cela permet de remapper les indices des qubits, par exemple si la carte 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 la carte).
num_qubits (int | None) – Le nombre de qubits à étendre la carte. 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 PauliLindbladMap avec la mise en page fournie.

clear

clear()

Effacez tous les termes générateurs de cette carte, ce qui la rend à nouveau égale à la carte d'identité.

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_lindblad_map = PauliLindbladMap.from_list([("IXXXYY", 2.0), ("ZZYZII", -1)])
>>> pauli_lindblad_map.clear()
>>> assert pauli_lindblad_map == PauliLindbladMap.identity(pauli_lindblad_map.py_num_qubits())

compose

compose(other)

Composer avec un autre PauliLindbladMap.

Cette opération ajoute les tableaux internes de self et d'other, ce qui donne une carte dont les termes énumérés sont ceux de self suivis de ceux d'other.

Paramètres

other (PauliLindbladMap) – la carte Pauli Lindblad pour composer.

copy

copy()

Obtenez une copie de cette carte de Pauli Lindblad.

Exemples

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IXZXYYZZ", 2.5), ("ZXIXYYZZ", 0.5)])
>>> assert pauli_lindblad_map == pauli_lindblad_map.copy()
>>> assert pauli_lindblad_map is not pauli_lindblad_map.copy()

drop_paulis

drop_paulis(indices)

Retirez Paulis de cette carte de Pauli Lindblad.

Supprimez tous les Pauli sur les indices donnés, en les remplaçant par une identité.

La carte obtenue peut contenir des doublons, qui peuvent être supprimés à l'aide de la méthode PauliLindbladMap.simplify() méthode.

Paramètres

indices (Sequence[int]) – Les indices pour lesquels Paulis doit être supprimé.

Retours

Une nouvelle carte de Pauli Lindblad où chaque Pauli sur les indices donnés a été supprimé.

Exemples

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_paulis([1, 2, 4])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("IXIII", 2.0), ("IIIIZ", 0.5), ("IIIIY", -0.25)])

drop_qubits

drop_qubits(indices)

Retirer des qubits de cette carte de Pauli Lindblad, en effectuant une opération de traçage.

La carte obtenue peut contenir des doublons, qui peuvent être supprimés à l'aide de la méthode PauliLindbladMap.simplify() méthode.

Paramètres

indices (Sequence[int]) – Les indices des qubits à tracer.

Retours

Une nouvelle carte de Pauli Lindblad où chaque Pauli sur les indices donnés a été tracé.

Exemples

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.drop_qubits([1, 2, 4])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("XI", 2.0), ("IZ", 0.5), ("IY", -0.25)])

from_components

static from_components(rates, qubit_sparse_pauli_list)

from_list

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

Construire une carte de Pauli Lindblad à partir d'une liste d'étiquettes de générateurs denses et de taux.

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[tuple[str, float]]) – Paires d'étiquettes et leurs taux associés dans la somme du générateur.
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 la carte agit. Si cette valeur est donnée et que iter n'est pas vide, la valeur doit correspondre à la longueur des étiquettes.

Exemples

Construire une carte de Pauli Lindblad à partir d'une liste d'étiquettes :

>>> PauliLindbladMap.from_list([
...     ("IIIXX", 1.0),
...     ("IIYYI", 1.0),
...     ("IXXII", -0.5),
...     ("ZZIII", -0.25),
... ])
<PauliLindbladMap with 4 terms on 5 qubits:
    (1)L(X_1 X_0) + (1)L(Y_2 Y_1) + (-0.5)L(X_3 X_2) + (-0.25)L(Z_4 Z_3)>

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

>>> PauliLindbladMap.from_list([], num_qubits=10)
<PauliLindbladMap with 0 terms on 10 qubits: 0.0>

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"]
>>> rates = [1.5, 2.0, -0.5]
>>> from_list = PauliLindbladMap.from_list(list(zip(labels, rates)))
>>> from_sparse_list = PauliLindbladMap.from_sparse_list([
...     (label, (3, 2, 1, 0), rate)
...     for label, rate in zip(labels, rates)
... ])
>>> assert from_list == from_sparse_list

Voir aussi

from_sparse_list()

Construire la carte à partir d'une liste d'étiquettes sans identités explicites, mais avec les qubits auxquels s'applique chaque terme du générateur de qubits uniques listés explicitement.

from_sparse_list

static from_sparse_list(iter, /, num_qubits)

Construire une carte de Pauli Lindblad à partir d'une liste d'étiquettes, des qubits auxquels chaque élément s'applique et du taux du terme entier.

Ceci est analogue à SparsePauliOp.from_sparse_list().

Les champs "labels" et "indices" des triples 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], float]]) – des triples d'étiquettes, les qubits auxquels s'applique chaque terme de qubit unique et le taux du terme entier.
num_qubits (int) – le nombre de qubits sur lesquels la carte agit.

Exemples

Construire une carte simple :

>>> PauliLindbladMap.from_sparse_list(
...     [("ZX", (1, 4), 1.0), ("YY", (0, 3), 2)],
...     num_qubits=5,
... )
<PauliLindbladMap with 2 terms on 5 qubits: (1)L(X_4 Z_1) + (2)L(Y_3 Y_0)>

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

>>> labels = ["XYXZ", "YYZZ", "XYXZ"]
>>> rates = [1.5, 2.0, -0.5]
>>> from_list = PauliLindbladMap.from_list(list(zip(labels, rates)))
>>> from_sparse_list = PauliLindbladMap.from_sparse_list([
...     (label, (3, 2, 1, 0), rate)
...     for label, rate in zip(labels, rates)
... ])
>>> assert from_list == from_sparse_list

Voir aussi

to_sparse_list()

L'inverse de cette méthode.

from_terms

static from_terms(obj, /, num_qubits=None)

Construire un PauliLindbladMap à partir de termes individuels.

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

Aucune simplification n'est effectuée dans le cadre de la création de la carte.

Paramètres

obj (Iterable[Term]) – Tableau itératif des termes individuels à partir desquels le générateur de cartes est construit.
num_qubits (int | None) – Le nombre de qubits sur lesquels la carte doit 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 carte correspondante.

gamma

gamma()

Calculer le site $\gamma$ pour la carte.

generators

generators()

Récupérez les générateurs de la carte.

Il s'agit d'un alias pour get_qubit_sparse_pauli_list_copy(), qui offre un nom plus pratique, conforme aux conventions de nommage utilisées dans Aer et Runtime pour des classes similaires.

Retours

Une copie des conditions d'utilisation du générateur de carte.

Type de retour

QubitSparsePauliList

get_qubit_sparse_pauli_list_copy

get_qubit_sparse_pauli_list_copy()

Obtenir une copie de la liste de pauli de qubits épars de la carte.

identity

static identity(num_qubits)

Obtenir la carte d'identité sur le nombre de qubits donné.

La carte d'identité ne contient aucun terme générateur et constitue l'élément d'identité pour la composition de deux instances; tout ce qui est composé avec la carte d'identité est égal à lui-même PauliLindbladMap tout ce qui est composé avec la carte d'identité est égal à lui-même.

Exemples

Obtenez la carte d'identité sur 100 qubits :

>>> PauliLindbladMap.identity(100)
<PauliLindbladMap with 0 terms on 100 qubits: 0.0>

inverse

inverse()

Renvoyer un nouveau PauliLindbladMap qui est l'inverse mathématique de soi.

keep_paulis

keep_paulis(indices)

Conservez tous les Pauli sur les indices donnés et abandonnez tous les autres.

Cela équivaut à utiliser PauliLindbladMap.drop_paulis() sur l'ensemble complémentaire d'indices.

Paramètres

indices (Sequence[int]) – Les indices pour lesquels Paulis doit être conservé.

Retours

Une nouvelle carte de Pauli Lindblad où tous les Pauli sur les indices donnés ont été conservés et tous les autres Pauli ont été supprimés.

Exemples

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_paulis([0, 3])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("IXIII", 2.0), ("IIIIZ", 0.5), ("IIIIY", -0.25)])

keep_qubits

keep_qubits(indices)

Conservez chaque qubit sur les indices donnés et tracez tous les autres qubits.

Cela équivaut à utiliser PauliLindbladMap.drop_qubits() sur l'ensemble complémentaire d'indices.

Paramètres

indices (Sequence[int]) – Les indices pour lesquels les qubits doivent être conservés.

Retours

Une nouvelle carte de Pauli Lindblad où chaque qubit sur les indices donnés a été conservé et où tous les autres qubits ont été tracés.

Exemples

>>> pauli_map_in = PauliLindbladMap.from_list([("XXIZI", 2.0), ("IIIYZ", 0.5), ("ZIIXY", -0.25)])
>>> pauli_map_out = pauli_map_in.keep_qubits([0, 3])
>>> assert pauli_map_out == PauliLindbladMap.from_list([("XI", 2.0), ("IZ", 0.5), ("IY", -0.25)])

parity_sample

parity_sample(num_samples, seed=None, scale=None, local_scale=None)

Échantillonner les paires de signes et d'opérateurs de Pauli sur la carte.

Chaque signe est représenté par une valeur booléenne, où True représente -1et False représente +1.

Compte tenu de la représentation de la quasi-probabilité donnée dans la documentation au niveau de la classe, chaque échantillon est tiré selon le processus suivant :

Initialiser le signe booléen, et une instance de QubitSparsePauli à l'opérateur d'identité.
Itérer à travers chaque Pauli de la carte. En utilisant la pseudo-probabilité associée à chaque opérateur, choisissez au hasard d'appliquer ou non l'opérateur.
Si l'opérateur est appliqué, mettre à jour le site :class`QubitSparsePauli` en le multipliant par le Pauli. Si le taux associé au Pauli est négatif, inverser le signe booléen.

Les résultats sont renvoyés sous la forme d'un tableau de booléens 1d, et le qubit échantillonné sparse Paulis correspondant sous la forme d'un tableau de booléens QubitSparsePauliList.

Les arguments scale et local_scale peuvent être utilisés pour modifier les taux sous-jacents utilisés dans le processus d'échantillonnage sans modifier l'instance actuelle ni nécessiter la création d'une nouvelle instance. L'argument scale multiplie tous les taux par un nombre à virgule flottante fixe et local_scale multiplie les taux terme par terme.

Paramètres

num_samples (int) – Nombre d'échantillons à prélever.
seed (int) – Graine aléatoire.
scale (float) – Échelle applicable à tous les taux.
local_scale (list[float]) – Échelle locale à appliquer trimestre par trimestre.

Retours

Le tableau booléen des signes et la liste des paulis épars de qubits.

Type de retour

signes, qubit_sparse_pauli_list

parity_sample_with_history

parity_sample_with_history(num_samples, seed=None, scale=None, local_scale=None)

Échantillonner des paires de signes et d'opérateurs de Pauli à partir de la carte, en conservant les générateurs échantillonnés.

Cette méthode est identique à parity_sample() à ceci près qu'elle renvoie également les informations qui generators() ont effectivement été échantillonnées pour obtenir l'opérateur de Pauli final et son signe.

Paramètres

num_samples (int) – Nombre d'échantillons à prélever.
seed (int) – Graine aléatoire.
scale (float) – Échelle applicable à tous les taux.
local_scale (list[float]) – Échelle locale à appliquer trimestre par trimestre.

Retours

Le tableau booléen de

les signes, la liste des Pauli clairsemés des qubits, le tableau booléen bidimensionnel indiquant lesquels generators() ont été échantillonnés et le tableau booléen bidimensionnel indiquant leurs signes.

Type de retour

signs, qubit_sparse_pauli_list, pauli_history, signs_history

pauli_fidelity

pauli_fidelity(qubit_sparse_pauli)

Calculer la fidélité de Pauli de cette carte pour un qubit de Pauli clairsemé.

Pour un Pauli $Q$ , la fidélité par rapport à la carte de Pauli Lindblad $\Lambda$ est le nombre réel $f(Q)$ pour lequel $\Lambda(Q) = f(Q) Q$ . I.e. chaque Pauli est un vecteur propre de la carte linéaire $\Lambda$ , et la fidélité est la valeur propre correspondante. Pour une carte de Pauli Lindblad avec un ensemble de générateurs $K$ et une fonction de taux $\lambda : K \rightarrow \mathbb{R}$ , la fidélité de Pauli est mathématiquement la suivante

f(Q) = \exp\left(-2 \sum_{P \in K} \lambda(P) \langle P, Q\rangle_{sp}\right),

où $\langle P, Q\rangle_{sp}$ est $0$ si $P$ et $Q$ sont concomitants, et $1$ s'ils sont anti-concomitants.

Args : qubit\sparse_pauli ( QubitSparsePauli ) : le qubit sparse Pauli pour calculer la valeur de Pauli

fidélité de.

probabilities

probabilities()

Calculez les probabilités $p_P$ pour la carte. Celles-ci peuvent être interprétées comme les probabilités que chaque générateur ne soit pas appliqué, et sont définies comme étant indépendantes du signe de chaque taux de Lindblad.

sample

sample(num_samples, seed=None)

Pour PauliLindbladMap les instances avec des taux purement non négatifs, échantillonnez les opérateurs de Pauli à partir de la carte. Si la carte comporte des taux négatifs, utilisez PauliLindbladMap.parity_sample().

Compte tenu de la représentation de la quasi-probabilité donnée dans la documentation au niveau de la classe, chaque échantillon est tiré selon le processus suivant :

Initialiser une instance :class`~.QubitSparsePauli` à l'opérateur d'identité.
Itérer à travers chaque Pauli de la carte. En utilisant la pseudo-probabilité associée à chaque opérateur, choisissez au hasard d'appliquer ou non l'opérateur.
Si l'opérateur est appliqué, mettre à jour le site :class`QubitSparsePauli` en le multipliant par le Pauli.

Les Paulis épars des qubits échantillonnés sont renvoyés sous la forme d'un QubitSparsePauliList.

Paramètres

num_samples (int) – Nombre d'échantillons à prélever.
seed (int) – Graine aléatoire. Prend par défaut la valeur None.

Retours

La liste des qubits sparse paulis.

Type de retour

qubit_sparse_pauli_list

Augmentations

ValueError - Si l'un des taux de la carte est négatif.

scale_rates

scale_rates(scale_factor)

Renvoie un nouveau PauliLindbladMap avec des taux mis à l'échelle par le facteur scale_factor.

Paramètres

scale_factor (float) – le coefficient d'échelle.

signed_sample

signed_sample(num_samples, seed=None)

Exemples de paires signe et opérateur de Pauli tirés de la carte. Notez que la convention de signe booléen dans cette méthode n'est pas standard. La méthode privilégiée pour ce type d'échantillonnage est PauliLindbladMap.parity_sample(), qui est également plus riche en fonctionnalités.

Chaque signe est représenté par un booléen, True représentant +1, et False représentant -1.

Compte tenu de la représentation de la quasi-probabilité donnée dans la documentation au niveau de la classe, chaque échantillon est tiré selon le processus suivant :

Initialiser le signe booléen, et une instance de QubitSparsePauli à l'opérateur d'identité.
Itérer à travers chaque Pauli de la carte. En utilisant la pseudo-probabilité associée à chaque opérateur, choisissez au hasard d'appliquer ou non l'opérateur.
Si l'opérateur est appliqué, mettre à jour le site :class`QubitSparsePauli` en le multipliant par le Pauli. Si le taux associé au Pauli est négatif, inverser le signe booléen.

Les résultats sont renvoyés sous la forme d'un tableau de booléens 1d, et le qubit échantillonné sparse Paulis correspondant sous la forme d'un tableau de booléens QubitSparsePauliList.

Paramètres

num_samples (int) – Nombre d'échantillons à prélever.
seed (int) – Graine aléatoire.

Retours

Le tableau booléen des signes et la liste des paulis épars de qubits.

Type de retour

signes, qubit_sparse_pauli_list

simplify

simplify(tol=1e-08)

Additionnez tous les termes similaires dans le générateur, en les supprimant si le taux obtenu a une valeur absolue comprise dans la marge de tolérance autour de zéro. Cela permet également d'éliminer les termes dont l'opérateur de Pauli est proportionnel à l'identité, car le générateur correspondant est en fait l'application nulle.

Cela a pour effet secondaire de trier les générateurs dans un ordre canonique fixe.

Remarque

Lorsque vous utilisez cette fonction pour des comparaisons d'égalité, notez que l'arrondi des nombres à virgule flottante et la non-associativité de l'addition de nombres à virgule flottante peuvent faire en sorte que des coefficients non nuls de termes additionnés soient jugés inégaux. Pour comparer deux observables dans les limites d'une tolérance donnée, la méthode la plus sûre consiste à vérifier si la différence canonicisée entre ces deux observables est nulle.

Paramètres

tol (float) – après avoir additionné les termes similaires, tous les taux dont la valeur absolue est inférieure à la tolérance absolue donnée seront supprimés de la sortie.

Exemples

En utilisant simplify() pour comparer deux opérateurs qui représentent la même carte, mais dont la comparaison serait inégale en raison des tests structurels par défaut :

>>> base = PauliLindbladMap.from_sparse_list([
...     ("XZ", (2, 1), 1e-10),  # value too small
...     ("XX", (3, 1), 2),
...     ("XX", (3, 1), 2),      # can be combined with the above
...     ("ZZ", (3, 1), 0.5),    # out of order compared to `expected`
... ], num_qubits=5)
>>> expected = PauliLindbladMap.from_list([("IZIZI", 0.5), ("IXIXI", 4)])
>>> assert base != expected  # non-canonical comparison
>>> assert base.simplify() == expected.simplify()

Notez que dans l'exemple ci-dessus, les coefficients sont choisis de manière à ce que tous les calculs en virgule flottante soient exacts et qu'il n'y ait pas de problèmes d'arrondi intermédiaire ou d'associativité. Si cela ne peut être garanti, la forme la plus sûre est la suivante :

>>> left = PauliLindbladMap.from_list([("XYZ", 1.0/3.0)] * 3)   # sums to 1.0
>>> right = PauliLindbladMap.from_list([("XYZ", 1.0/7.0)] * 7)  # doesn't sum to 1.0
>>> assert left.simplify() != right.simplify()
>>> assert left.compose(right.inverse()).simplify() == PauliLindbladMap.identity(left.num_qubits)

to_sparse_list

to_sparse_list()

Exprimer la carte sous la forme d'une liste éparse.

Cela peut être considéré comme une contre-opération de PauliLindbladMap.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

>>> pauli_lindblad_map = PauliLindbladMap.from_list([("IIXIZ", 2), ("IIZIX", 3)])
>>> reconstructed = PauliLindbladMap.from_sparse_list(pauli_lindblad_map.to_sparse_list(), pauli_lindblad_map.num_qubits)

Voir aussi

from_sparse_list()

Le constructeur qui peut interpréter ces listes.

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

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