Opérateur

class qiskit.quantum_info.Operator(data, input_dims=None, output_dims=None)

Bases : LinearOp

Classe d'opérateurs matriciels

Il s'agit d'un opérateur matriciel $M$ qui evolve() a Statevector $|\psi\rangle$ par multiplication matrice-vecteur

|\psi\rangle \mapsto M|\psi\rangle,

et volonté evolve() a DensityMatrix $\rho$ par multiplication à gauche et à droite

\rho

Par exemple, l'opérateur suivant $M = X$ appliqué à l'état zéro $|\psi\rangle=|0\rangle (\rho = |0\rangle\langle 0|)$ le transforme en état un $|\psi\rangle=|1\rangle (\rho = |1\rangle\langle 1|)$ :

>>> import numpy as np
>>> from qiskit.quantum_info import Operator
>>> op = Operator(np.array([[0.0, 1.0], [1.0, 0.0]]))  # Represents Pauli X operator

>>> from qiskit.quantum_info import Statevector
>>> sv = Statevector(np.array([1.0, 0.0]))
>>> sv.evolve(op)
Statevector([0.+0.j, 1.+0.j],
            dims=(2,))

>>> from qiskit.quantum_info import DensityMatrix
>>> dm = DensityMatrix(np.array([[1.0, 0.0], [0.0, 0.0]]))
>>> dm.evolve(op)
DensityMatrix([[0.+0.j, 0.+0.j],
            [0.+0.j, 1.+0.j]],
            dims=(2,))

Initialise un objet opérateur.

Paramètres

data (QuantumCircuit |Operation | BaseOperator | np.ndarray) – données nécessaires à l'initialisation de l'opérateur.
input_dims (tuple | None) – les dimensions du sous-système d'entrée.
output_dims (tuple | None) – les dimensions du sous-système de sortie.

Augmentations

QiskitError – si les données d'entrée ne peuvent pas être initialisées en tant qu'opérateur.

Renseignements supplémentaires :

Si les dimensions d'entrée ou de sortie sont nulles, elles seront automatiquement déterminées à partir des données d'entrée. Si les données d'entrée sont un tableau Numpy de forme ( 2**N, 2**N ), des systèmes de qubits seront utilisés. Si l'opérateur d'entrée n'est pas un opérateur N-qubit, il attribue un sous-système unique dont la dimension est spécifiée par la forme de l'entrée. Notez que deux opérateurs initialisés par cette méthode ne sont considérés comme équivalents que s'ils correspondent à leur ordre canonique de qubit (ou : permutation). Voir Operator.from_circuit() pour spécifier une permutation de qubits différente.

Attributs

atol

Valeur par défaut : 1e-08

data

Le tableau Numpy sous-jacent.

dim

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

num_qubits

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

qargs

Retourne les qargs de l'opérateur.

rtol

Valeur par défaut : 1e-05

settings

Retourner les réglages de l'opérateur.

Méthodes

adjoint

adjoint()

Retourne l'adjoint de l'opérateur.

Type de retour

apply_permutation

apply_permutation(perm, front=False)

Modifie les données de l'opérateur en les composant avec une permutation.

Paramètres

perm (list) – le modèle de permutation, décrivant les qubits qui occupent les positions 0, 1, 2, etc. après l'application de la permutation.
front (bool) – Lorsque la valeur est fixée à True , la permutation est appliquée avant l'opérateur, lorsque la valeur est fixée à False , la permutation est appliquée après l'opérateur.

Retours

L'opérateur modifié.

Type de retour

Augmentations

QiskitError – si la taille du motif de permutation ne correspond pas aux dimensions de l'opérateur.

compose

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

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

Paramètres

Retours

L'opérateur composé.

Type de retour

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.

Remarque

La composition (&) est définie par défaut comme une multiplication matricielle à gauche pour les opérateurs matriciels, tandis que @ (équivalent à dot()) est définie comme une multiplication matricielle à droite. C'est-à-dire que A & B == A.compose(B) est équivalent à B @ A == B.dot(A) lorsque A et B sont du même type.

L'utilisation du kwarg front=True permet de passer à une multiplication matricielle à droite, ce qui équivaut à la méthode dot() méthode A.dot(B) == A.compose(B, front=True).

conjugate

conjugate()

Renvoie le conjugué de l'opérateur.

copy

copy()

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

dot

dot(other, qargs=None)

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

Paramètres

Retours

La matrice droite multipliée Opérateur.

Type de retour

Remarque

Le produit de points peut être obtenu en utilisant l'opérateur binaire @ . Par conséquent, a.dot(b) est équivalent à a @ b.

draw

draw(output=None, **drawer_args)

Renvoie une visualisation de l'opérateur.

repr : String of the state's __repr__.

texte : ASCII TextMatrix qui peut être imprimé dans la console.

latex : Un objet IPython Latex à afficher dans les carnets Jupyter.

latex_source : Source ASCII brute, non compilée, pour générer un tableau à l'aide de LaTeX.

Paramètres

output (str) – Sélectionnez la méthode de sortie à utiliser pour dessiner l'état. Les choix valides sont repr, text, latex, latex_source, la valeur par défaut étant repr.
drawer_args - Arguments à transmettre directement à la fonction de dessin ou au constructeur concerné ( TextMatrix( ), array_to_latex()). Voir la fonction concernée sous qiskit.visualization pour la documentation de cette fonction.

Retours

Dessin de l'opérateur.

Type de retour

str ou TextMatrix ou IPython.display.Latex

Augmentations

ValueError - lorsqu'une méthode de sortie non valide est sélectionnée.
MissingOptionalLibrary - Si SymPy n'est pas installé et que 'latex' ou 'latex_source' est sélectionné pour output.

equiv

equiv(other, rtol=None, atol=None)

Retourne True si les opérateurs sont équivalents jusqu'à la phase globale.

Paramètres

Retours

Vrai si les opérateurs sont équivalents jusqu'à la phase globale.

Type de retour

expand

expand(other)

Renvoie le produit tensoriel d'ordre inverse avec un autre opérateur.

Paramètres

other (Operator) – un objet Opérateur.

Retours

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

est l'opérateur actuel, et $b$ est l'autre opérateur.

Type de retour

from_circuit

classmethod from_circuit(circuit, ignore_set_layout=False, layout=None, final_layout=None)

Créer un nouvel objet « Operator » à partir d'un QuantumCircuit

OperatorBien qu'un QuantumCircuit objet puisse être transmis directement en tant qu'argument data au constructeur de la classe, cela ne permet pas de définir la manière dont le circuit est utilisé pour créer un objet. Cette méthode de construction vous permet de contrôler la manière dont l'objet Operator est créé, afin de l'adapter à un cas d'utilisation particulier.

Par défaut, cette méthode de construction permute les qubits sur la base d'une disposition initiale configurée (c'est-à-dire après avoir été transposée). Il offre également la possibilité de fournir manuellement un Layout directement.

Paramètres

circuit (QuantumCircuit) – À partir de quoi QuantumCircuit créer un objet « Operator ».
ignore_set_layout (bool) – Lorsque la valeur est fixée à True , si l'entrée circuit a une disposition définie, elle sera ignorée
layout (Layout) – S'il est spécifié, ce kwarg peut être utilisé pour spécifier une disposition particulière à utiliser pour permuter les qubits dans le fichier créé Operator. Si elle est spécifiée, elle sera utilisée à la place d'une mise en page contenue dans l'entrée circuit . Si cela est spécifié, les bits virtuels dans le Layout doivent être présents dans l'entrée circuit .
final_layout (Layout) – S'il est spécifié, ce kwarg peut être utilisé pour représenter la permutation de sortie causée par les insertions de swaps au cours de l'étape de routage du transpilateur.

Retours

Un opérateur représentant le circuit d'entrée

Type de retour

from_label

classmethod from_label(label)

Retourne un produit tensoriel d'opérateurs à un seul qubit.

Paramètres

label (string) – chaîne d'opérateurs à qubit unique.

Retours

L'opérateur N-qubit.

Type de retour

Opérateur

Augmentations

QiskitError – si l'étiquette contient des caractères non valides, ou si la longueur de l'étiquette dépasse le nombre de qubits explicitement spécifié num_qubits.

Renseignements supplémentaires :

Les étiquettes correspondent aux matrices à un seul qubit : 'I': [ [1, 0], [0, 1] ] 'X': [ [0, 1], [1, 0] ] 'Y': [ [0, -1j], [1j, 0] ] 'Z': [ [1, 0], [0, -1] ] 'H': [ [1, 1], [1, -1] ] / sqrt(2) 'S': [ [1, 0], [0, 1j] ] 'T': [ [1, 0], [0, ( 1+1j ) / sqrt(2)] ] '0': [ [1, 0], [0, 0] ] '1': [ [0, 0], [0, 1] ] '+': [ [0.5, 0.5], [0.5, 0.5] ] '-' : [ [0.5, -0.5], [-0.5, 0.5] ] 'r' : [ [0.5, -0.5j], [0.5j, 0.5] ] 'l' : [ [0.5, 0.5j], [-0.5j, 0.5] ]

input_dims

input_dims(qargs=None)

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

is_unitary

is_unitary(atol=None, rtol=None)

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

output_dims

output_dims(qargs=None)

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

power

power(n, branch_cut_rotation=3.141592653589793e-12, assume_unitary=False)

Renvoie la puissance matricielle de l'opérateur.

Les puissances non entières d'opérateurs ayant une valeur propre dont la phase complexe est $\pi$ ont une coupure de branche dans le plan complexe, ce qui rend le calcul de la racine principale autour de cette coupure sujet à la précision / aux différences dans l'implémentation BLAS. Par exemple, la racine carrée de Pauli Y peut renvoyer la rotation $\pi$ ou $-\pi/2$ Y selon que la valeur propre -1 est trouvée comme complex(-1, tiny) ou complex(-1, -tiny). Ces valeurs propres sont très courantes dans l'information quantique, c'est pourquoi cette fonction effectue d'abord une rotation de phase de la matrice d'entrée afin de déplacer la coupure de la branche vers un point beaucoup moins courant. Les problèmes sous-jacents de précision numérique autour du point de coupure demeurent, si un opérateur a une valeur propre proche de cette phase. L'ampleur de cette rotation peut être contrôlée à l'aide du paramètre branch_cut_rotation .

Le choix de branch_cut_rotation affecte la racine principale qui est trouvée. Par exemple, la racine carrée de ZGate sera calculée comme étant soit SGate ou SdgGate selon le sens de la rotation :

from qiskit.circuit import library
from qiskit.quantum_info import Operator

z_op = Operator(library.ZGate())
assert z_op.power(0.5, branch_cut_rotation=1e-3) == Operator(library.SGate())
assert z_op.power(0.5, branch_cut_rotation=-1e-3) == Operator(library.SdgGate())

Paramètres

n (float) – le pouvoir d'élever la matrice à.
branch_cut_rotation (float) – Angle de rotation à appliquer à la coupe de la branche dans le plan complexe. Cela éloigne la branche coupée du point commun de $-1$ , mais peut entraîner la sélection d'une autre racine comme racine principale. La rotation se fait dans le sens inverse des aiguilles d'une montre, conformément à la convention standard pour la phase complexe.
assume_unitary (bool) – si True, l'opérateur est supposé être unitaire. Dans ce cas, pour les puissances fractionnaires, nous utilisons une implémentation plus rapide basée sur la décomposition de Schur.

Retours

l'opérateur résultant O ** n.

Type de retour

Augmentations

QiskitError – si les dimensions d'entrée et de sortie de l'opérateur ne sont pas identiques.

Remarque

Il n'est prudent de fixer l'argument assume_unitary à True que lorsque l'opérateur est unitaire (ou, plus généralement, normal). Dans le cas contraire, la fonction renverra un résultat incorrect.

reshape

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.

reverse_qargs

reverse_qargs()

Retourne un opérateur dont l'ordre des sous-systèmes est inversé.

Pour un opérateur de produit tensoriel, cela revient à inverser l'ordre des sous-systèmes du produit tensoriel. Pour un opérateur $A = A_{n-1} \otimes ... \otimes A_0$ , l'opérateur retourné sera $A_0 \otimes ... \otimes A_{n-1}$ .

Retours

l'opérateur en inversant l'ordre des sous-systèmes.

Type de retour

tensor

tensor(other)

Renvoie le produit tensoriel avec un autre opérateur.

Paramètres

other (Operator) – un objet Opérateur.

Retours

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

est l'opérateur actuel, et $b$ est l'autre opérateur.

Type de retour

Remarque

Le produit tensoriel peut être obtenu en utilisant l'opérateur binaire ^ . Par conséquent, a.tensor(b) est équivalent à a ^ b.

to_instruction

to_instruction()

Convertir en instruction UnitaryGate.

to_matrix

to_matrix()

Convertir l'opérateur en matrice NumPy.

to_operator

to_operator()

Convertir l'opérateur en classe d'opérateur matriciel

Type de retour

transpose

transpose()

Renvoie la transposition de l'opérateur.

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

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