PauliEvolutionGate

class qiskit.circuit.library.PauliEvolutionGate(operator, time=1.0, label=None, synthesis=None)

Bases : Gate

Evolution temporelle d'un opérateur constitué de Paulis.

Pour un opérateur hermitien $H$ composé de termes de Pauli et de temps d'évolution (réel) $t$ , cette porte représente l'unité

U(t) = e^{-itH}.

Les portes d'évolution sont liées aux portes de rotation de Pauli par un facteur de 2. Par exemple, l'évolution temporelle de l'opérateur de Pauli $X$ est liée à la rotation de Pauli $X$ $R_X$ par

U(t) = e^{-itX} = R_X(2t).

Compilation :

Cette porte représente l'évolution exacte de l'opération « $U(t)$ ». Cependant, la mise en œuvre exacte de cette opération nécessite généralement un nombre exponentiel de portes. Le compilateur met donc généralement en œuvre une approximation de l' $U(t)$ unitaire, par exemple en utilisant une formule de produit telle que celle définie par LieTrotter. En passant l'argument synthesis , vous pouvez spécifier la méthode que le compilateur doit utiliser; consultez qiskit.synthesis pour connaître les options disponibles.

Il convient de noter que l'ordre dans lequel l'approximation et les méthodes telles que control() et power() sont appelées. Un changement d'ordre peut conduire à des unitaires différents.

Contrôles de commutation :

Qiskit prend en charge les vérifications de commutation efficaces des PauliEvolutionGate instances avec d'autres portes basées sur Pauli, telles que PauliGate ou PauliProductMeasurement. Cependant, ces vérifications nécessitent la conversion de l'opérateur au SparseObservable format, c'est pourquoi nous recommandons vivement de créer des opérateurs à l'aide de cette classe d'opérateurs si un grand nombre de vérifications de commutation est prévu (par exemple, si vous avez un circuit avec un grand nombre de séquences PauliEvolutionGates).

Exemples :

from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.quantum_info import SparsePauliOp

X = SparsePauliOp("X")
Z = SparsePauliOp("Z")
I = SparsePauliOp("I")

# build the evolution gate
operator = (Z ^ Z) - 0.1 * (X ^ I)
evo = PauliEvolutionGate(operator, time=0.2)

# plug it into a circuit
circuit = QuantumCircuit(2)
circuit.append(evo, range(2))
print(circuit.draw())

Ce qui précède s'imprimera (notez que le coefficient -0.1 n'est pas imprimé!):

     ┌──────────────────────────┐
q_0: ┤0                         ├
     │  exp(-it (ZZ + XI))(0.2) │
q_1: ┤1                         ├
     └──────────────────────────┘

Références :

[1] G. Li et al. Paulihedral : A Generalized Block-Wise Compiler Optimization Framework For Quantum Simulation Kernels (2021). arXiv:2109.03371

Paramètres

operator (qiskit.quantum_info.Pauli |SparsePauliOp |SparseObservable |list[qiskit.quantum_info.Pauli |SparsePauliOp |SparseObservable]) – L'opérateur doit évoluer. Elle peut également être fournie sous la forme d'une liste d'opérateurs non commutatifs dont les éléments sont des sommes d'opérateurs commutatifs. Par exemple : [XY + YX, ZZ + ZI + IZ, YY].
time (ParameterValueType) – Le temps d'évolution.
label (str | None) – Une étiquette pour la porte à afficher dans les visualisations. Par défaut, l'étiquette est fixée à exp(-it <operators>) où <operators> est la somme des Paulis. Notez que l'étiquette n'inclut pas les coefficients de Paulis. Voir la docstring de la classe pour un exemple.
synthesis (EvolutionSynthesis | None) – Une stratégie de synthèse. Si elle est nulle, la synthèse par défaut est la formule du produit de Lie-Trotter avec une seule répétition.

Attributs

base_class

Obtenir la classe de base de cette instruction. Il est assuré de figurer dans l'arbre généalogique de self.

La "classe de base" d'une instruction est la classe la plus basse de son arbre d'héritage avec laquelle l'objet doit être considéré comme entièrement compatible pour les applications de circuit. Cela signifie généralement que la sous-classe est définie uniquement pour offrir une certaine commodité au programmeur par rapport à la classe de base, et que la classe de base est la "vraie" classe d'un point de vue comportemental. En particulier, vous ne devez pas outrepasser base_class si vous définissez une version personnalisée d'une instruction qui sera implémentée différemment par le matériel, comme une stratégie de mesure alternative, ou une version d'une porte paramétrée avec un ensemble particulier de paramètres dans le but de la distinguer dans un Target à partir de la porte entièrement paramétrée.

Ceci est souvent exactement équivalent à type(obj), sauf dans le cas d'instances uniques d'instructions de la bibliothèque standard. Ces instances singleton sont des sous-classes spéciales de leur classe de base, et cette propriété renverra cette base. Par exemple :

>>> isinstance(XGate(), XGate)
True
>>> type(XGate()) is XGate
False
>>> XGate().base_class is XGate
True

En général, il ne faut pas se fier à la classe précise d'une instruction; dans un circuit donné, on s'attend à ce que Instruction.name soit un discriminant plus approprié dans la plupart des situations.

decompositions

Obtenir les décompositions de l'instruction à partir de SessionEquivalenceLibrary.

definition

Définition du retour en termes d'autres portes de base.

label

Étiquette d'instruction de retour

mutable

Cette instance est-elle une instance unique mutable ou non?

Si cet attribut est False , l'instance du portail est un singleton partagé et n'est pas mutable.

name

Renvoyer le nom.

num_clbits

Retourne le nombre de clbits.

num_qubits

Renvoie le nombre de qubits.

params

Les paramètres de ce site Instruction. Idéalement, il s'agit d'angles de porte.

time

Renvoie le temps d'évolution tel qu'il est enregistré dans les paramètres de la porte.

Retours

Le temps d'évolution.

Méthodes

add_decomposition

add_decomposition(decomposition)

GitHub

Ajouter une décomposition de l'instruction à l'adresse SessionEquivalenceLibrary.

broadcast_arguments

broadcast_arguments(qargs, cargs)

GitHub

Validation et traitement des arguments et de leur relation.

Par exemple, cx([q[0],q[1]], q[2]) signifie cx(q[0], q[2]); cx(q[1], q[2]). Cette méthode permet d'obtenir les arguments dans le bon groupe. Dans l'exemple donné :

in: [[q[0],q[1]], q[2]],[]
outs: [q[0], q[2]], []
      [q[1], q[2]], []

Les règles générales de diffusion sont les suivantes :

Si len(qargs) == 1 :
```
[q[0], q[1]] -> [q[0]],[q[1]]
```

Si len(qargs) == 2 :

[[q[0], q[1]], [r[0], r[1]]] -> [q[0], r[0]], [q[1], r[1]]
[[q[0]], [r[0], r[1]]]       -> [q[0], r[0]], [q[0], r[1]]
[[q[0], q[1]], [r[0]]]       -> [q[0], r[0]], [q[1], r[0]]

Si len(qargs) >= 3 :

[q[0], q[1]], [r[0], r[1]],  ...] -> [q[0], r[0], ...], [q[1], r[1], ...]

Paramètres

qargs (list) – Liste des arguments des bits quantiques.
cargs (list) – Liste des arguments classiques en matière de bits.

Retours

Un tuple avec des arguments uniques.

Augmentations

CircuitError – Si la saisie n'est pas valide. Par exemple, le nombre d'arguments ne correspond pas à ce qu'on attend de la porte logique.

Type de retour

Iterable [ tuple [ liste, liste ]]

control

control(num_ctrl_qubits=1, label=None, ctrl_state=None, annotated=None)

GitHub

Renvoie la version contrôlée de lui-même.

Le résultat est la version contrôlée spécifiée de $e^{-itH}$ . La porte renvoyée représente $e^{-it H_C}$ , où $H_C$ est l'opérateur d'origine $H$ , tensorisé avec les projecteurs $|0\rangle\langle 0|$ et $|1\rangle\langle 1|$ (en fonction de l'état de contrôle).

La porte contrôlée est implémentée comme PauliEvolutionGate, quelle que soit la valeur de annotated.

Paramètres

num_ctrl_qubits (int) – Nombre de contrôles à ajouter. Prend par défaut la valeur 1.
label (str | None) – Une étiquette pour la porte d'évolution de Pauli résultante, à afficher dans les visualisations. Par défaut, l'étiquette est définie sur exp(-it <operators>) où <operators> est la somme des Paulis. Notez que l'étiquette n'inclut aucun coefficient de Pauli. Consultez la chaîne docstring de la classe pour obtenir un exemple.
ctrl_state (int |str | None) – L'état de commande de la porte, spécifié soit sous forme d'entier, soit sous forme de chaîne de bits (par exemple "110"). Si None, la valeur par défaut est l'état « 2**num_ctrl_qubits - 1tout à 1 ».
annotated (bool | None) – Ignoré.

Retours

Une version contrôlée de cette porte.

Type de retour

Portail

copy

copy(name=None)

GitHub

Copie de l'instruction.

Paramètres

name (str) – nom à donner au circuit copié, si None le nom reste le même.

Retours

une copie de l'instruction en cours, avec le nom mis à jour s'il a été fourni

Type de retour

qiskit.circuit.Instruction

inverse

inverse(annotated=False)

GitHub

Retourne l'inverse, qui est obtenu en inversant le signe du temps d'évolution.

Paramètres

annotated (bool)

is_parameterized

is_parameterized()

GitHub

Indique si la fonction Instruction contient des paramètres définis à la compilation.

power

power(exponent, annotated=False)

GitHub

Élevez cette porte au pouvoir de exponent.

Le résultat représente $e^{-i tp H}$ où $p$ est égal à exponent.

Paramètres

exponent (float) – Le pouvoir d'élever le portail à.
annotated (bool) – Non applicable à cette classe. Habituellement, lorsque cela se fait à l'adresse True , nous renvoyons un AnnotatedOperation avec un modificateur de puissance au lieu d'un Gate. Cependant, nous pouvons représenter efficacement les puissances des évolutions de Pauli sous la forme de PauliEvolutionGatece qui est utilisé ici.

Retours

Une opération mettant en œuvre gate^exponent.

Type de retour

Portail

repeat

repeat(n)

GitHub

Crée une instruction self répétée $n$ fois.

Paramètres

n (int) – Nombre de répétitions de l'instruction

Retours

Contenant la définition.

Type de retour

qiskit.circuit.Instruction

Augmentations

CircuitError – Si n < 1.

reverse_ops

reverse_ops()

GitHub

Pour une instruction composite, inverser l'ordre des sous-instructions.

Pour ce faire, toutes les sous-instructions sont inversées de manière récursive. Il n'inverse aucune porte.

Retours

une nouvelle instruction avec

les sous-instructions sont inversées.

Type de retour

qiskit.circuit.Instruction

soft_compare

soft_compare(other)

GitHub

Comparaison en douceur entre les portes. Leurs noms, le nombre de qubits et les numéros de bits classiques doivent correspondre. Le nombre de paramètres doit correspondre. Chaque paramètre est comparé. Si l'on est sur ParameterExpression, cela n'est pas pris en compte.

Paramètres

other (instruction) – d'autres instructions.

Retours

sont égaux à soi et à l'autre jusqu'à l'expression des paramètres.

Type de retour

booléen

to_matrix

to_matrix()

GitHub

Retourne la matrice $e^{-it H}$ sous la forme numpy.ndarray.

Retours

La matrice que cette porte représente.

Augmentations

ValueError - Si le paramètre time n'est pas numérique.

Type de retour

ndarray

to_mutable

to_mutable()

GitHub

Renvoie une copie mutable de cette porte.

Cette méthode renvoie une nouvelle copie mutable de cette instance de porte. Si une instance singleton est utilisée, il s'agit d'une nouvelle instance unique qui peut être modifiée. Si l'instance est déjà mutable, il s'agira d'une copie profonde de cette instance.

validate_parameter

validate_parameter(parameter)

GitHub

Les paramètres de la porte doivent être de type int, float ou ParameterExpression

Paramètres

parameter (ParameterExpression |float)

Type de retour

ParameterExpression | flotteur

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

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