SparseObservable

__new__(data, /, num_qubits=None)

Le constructeur par défaut de SparseObservable.

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 SparseObservableauquel cas l'entrée est copiée, un Pauli ou SparsePauliOp, auquel cas from_pauli() ou from_sparse_pauli_op() sont appelés comme il convient, 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 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. 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.

Une liste plate de termes à un seul qubit. Il s'agit plus naturellement d'une liste de listes, mais elle est stockée à plat pour des raisons d'utilisation de la mémoire et de localité, les sous-listes étant désignées par des limites.

Indices qui partitionnent bit_terms et indices en sous-listes pour chaque terme de la somme. boundaries[0] : boundaries[1] est l'intervalle des indices dans bit_terms et indices qui correspondent au premier terme de la somme. Tous les indices de qubits non spécifiés sont implicitement l'identité. C'est un élément de plus que coeffspuisque boundaries[0] est toujours un zéro explicite (pour des raisons de facilité algorithmique).

Les coefficients de chaque terme abstrait dans la somme. Il y a autant d'éléments que de termes dans la somme.

Une liste plate des indices de qubits sur lesquels agissent les entrées correspondantes dans bit_terms agissent. Cette liste doit toujours être triée par terme, un terme étant une sous-liste désignée par boundaries.

Le nombre de qubits sur lesquels l'opérateur agit.

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

Le nombre de termes de la somme que cet opérateur suit.

adjoint()

Calculer l'adjoint de cette observable.

Cette notion est bien définie au sens mathématique abstrait. Tous les termes de l'alphabet à un qubit sont auto-adjoints, de sorte que le résultat de cette opération est la même observable, sauf que ses coefficients sont tous leurs conjugués complexes.

Exemples

>>> left = SparseObservable.from_list([("XY+-", 1j)])
>>> right = SparseObservable.from_list([("XY+-", -1j)])
>>> assert left.adjoint() == right

apply_layout(layout, num_qubits=None)

Appliquer un schéma de transposition à ceci SparseObservable.

En règle générale, vous aurez défini votre observable en termes de qubits virtuels des circuits que vous utiliserez pour préparer les états. Après la transpilation, les qubits virtuels sont mis en correspondance avec des qubits physiques particuliers sur un dispositif, qui peut être plus large que votre circuit. Cette cartographie peut également changer au cours du circuit. Cette méthode transforme l'observable d'entrée sur les qubits virtuels en un observable qui peut être appliqué immédiatement après le circuit physique entièrement transposé.

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 valeur est explicitement indiquée, aucun remappage n'est appliqué (mais vous pouvez tout de même utiliser num_qubits pour développer l'observable).
• num_qubits (int | None) – Le nombre de qubits pour étendre l'observable. 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 SparseObservable avec la mise en page fournie.

as_paulis()

Exprimer l'observable en termes de Pauli uniquement, en écrivant chaque projecteur comme une somme de termes de Pauli.

Notez qu'il n'y a aucune garantie quant à l'ordre des termes de Pauli qui en résultent. Utiliser SparseObservable.simplify() pour obtenir une représentation canonique.

Retours

La même observable, mais exprimée uniquement en termes de Pauli.

Exemples

Réécrire une observable en termes de projecteurs en opérateurs de Pauli :

>>> obs = SparseObservable("+")
>>> obs.as_paulis()
<SparseObservable with 2 terms on 1 qubit: (0.5+0j)() + (0.5+0j)(X_0)>
>>> direct = SparseObservable.from_list([("I", 0.5), ("Z", 0.5)])
>>> assert direct.simplify() == obs.as_paulis().simplify()

Pour les petits opérateurs, cela peut être utilisé avec simplify() comme forme canonique unique :

>>> left = SparseObservable.from_list([("+", 0.5), ("-", 0.5)])
>>> right = SparseObservable.from_list([("r", 0.5), ("l", 0.5)])
>>> assert left.as_paulis().simplify() == right.as_paulis().simplify()

clear()

Effacez tous les termes de cet opérateur, ce qui le rend à nouveau égal à l'opérateur zéro.

Cela ne modifie pas la capacité des allocations internes; par conséquent, les opérations d'addition ou de soustraction ultérieures ne nécessiteront peut-être pas de réallocation.

Exemples

>>> obs = SparseObservable.from_list([("IX+-rl", 2.0), ("01YZII", -1j)])
>>> obs.clear()
>>> assert obs == SparseObservable.zero(obs.py_num_qubits())

commutes(other, tol=1e-12)

Vérifiez si l'observable commute avec un autre.

Paramètres

• other (SparseObservable) – L'autre observable permettant de vérifier la commutation.
• tol (float) – Si les coefficients dans le produit de soi et d'autrui sont inférieurs à la tolérance (en magnitude), les termes sont ignorés.

Retours

True si les termes commutent, jusqu'à la tolérance, False sinon.

Augmentations

TypeError – Si ne other pouvait être contraint à SparseObservable.

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

Composer un autre SparseObservable sur celui-ci.

En termes d'algèbres d'opérateurs, la composition correspond à la multiplication à gauche : c = a.compose(b) correspond à $C = B A$. En d'autres termes, a.compose(b) renvoie un opérateur qui "exécute a, puis b sur le résultat". L'argument front=True en fait une multiplication à droite.

self et other doivent avoir la même taille, sauf si qargs est donné, auquel cas other peut être plus petit que self, à condition que le nombre de qubits dans other et la longueur de qargs correspondent. qargs ne peut jamais contenir de doublons ou d'indices de qubits qui n'existent pas dans self.

Attention, cette fonction peut entraîner une explosion exponentielle de l'utilisation de la mémoire de l'observable, car l'alphabet de SparseObservable n'est pas fermé à la composition; la composition de deux termes d'un seul bit peut être une somme, ce qui multiplie le nombre total de termes. Cette utilisation de la mémoire n'est pas nécessairement inhérente à l'observable résultant, mais la recherche d'une refactorisation efficace de la somme est généralement tout aussi difficile sur le plan du calcul. Il est préférable d'utiliser la connaissance du domaine de vos observables pour minimiser le nombre de termes existants, plutôt que d'essayer de les simplifier après coup.

Paramètres

• other - l'observable utilisé pour multiplier à gauche self.

• qargs -

  s'il est donné, les qubits de self à associer aux qubits de other. En d'autres termes, si elle est donnée, elle est similaire à une mise en œuvre plus efficace de :

  self.compose(other.apply_layout(qargs, self.num_qubits))

  car aucun observable temporaire n'est créé pour stocker la forme de présentation appliquée de other.

• front - si True, multiplier à droite par other au lieu de multiplier à gauche (par défaut False). Les qargs sont toujours appliqués aux other. Ceci est particulièrement utile lorsque qargs est défini, ou que other peut être un objet qui doit être contraint à SparseObservable.

conjugate()

Calculer la conjugaison complexe de cette observable.

Cette opération est définie en termes de conventions matricielles standard de Qiskit, en ce sens que la forme matricielle est considérée comme étant dans la base de calcul $Z$. Les termes de l'alphabet liés à $X$- et $Z$ ne sont pas affectés par la conjugaison complexe, mais les termes liés à $Y$ modifient leurs termes de l'alphabet. Précisément :

• $Y$ se conjugue à $-Y$
• $\lvert r\rangle\langle r\rvert$ conjugués à $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ conjugués à $\lvert r\rangle\langle r\rvert$

En outre, tous les coefficients sont conjugués.

Exemples

>>> obs = SparseObservable([("III", 1j), ("Yrl", 0.5)])
>>> assert obs.conjugate() == SparseObservable([("III", -1j), ("Ylr", -0.5)])

copy()

Obtenir une copie de cet observable.

Exemples

>>> obs = SparseObservable.from_list([("IXZ+lr01", 2.5), ("ZXI-rl10", 0.5j)])
>>> assert obs == obs.copy()
>>> assert obs is not obs.copy()

evolve(other, /, qargs=None)

Fais évoluer cet observable à l'aide d'un terme de Pauli.

Une évolution de l' $O$ e observable par une $P$ de Pauli correspond à $P^\dagger O P$.

Contrairement à une mise en œuvre littérale via deux compositions complètes, cette méthode effectue la conjugaison directement au niveau d'un seul qubit à l'aide d'une table de correspondance fixe. Cela évite de matérialiser toute expression intermédiaire SparseObservable et permet de calculer l'observable évolué en un seul passage sur les termes. self et other doit comporter le même nombre de qubits, sauf si qargs est spécifié, auquel cas other peut être inférieur à self, à condition que le nombre de qubits dans other et la longueur de qargs soient identiques. qargs précise quels qubits de self sont mis en évolution par other.

Actuellement, cette méthode ne prend en charge l'évolution que par un opérateur à un seul terme, ce qui signifie que other doit être un opérateur de Pauli représenté par Pauli.

Paramètres

• autre – l'opérateur de Pauli utilisé pour conjuguer self.
• qargs – si spécifié, les qubits de self à faire évoluer par other. La longueur doit correspondre au nombre de qubits dans other.

Retours

Une nouvelle forme a été développée SparseObservable avec des conjugaisons appliquées.

Augmentations

• TypeError – si other n'est pas de type Pauli.
• ValueError – si self et other ont un nombre différent de qubits (et qargs n'est pas donné).
• ValueError – si qargs la longueur ne correspond pas other au nombre de qubits.
• ValueError – si qargs contient des doublons ou des indices hors limites.
• ValueError – si other comporte plusieurs termes.

expand(other, /)

Produit tensoriel d'ordre inverse.

Ceci est équivalent à other.tensor(self), sauf que other sera d'abord transformé en SparseObservable s'il ne l'est pas déjà (en appelant le constructeur par défaut).

Paramètres

autre - l'observable à placer du côté gauche du produit tensoriel.

Exemples

Cela équivaut à tensor() en inversant l'ordre des arguments :

>>> left = SparseObservable.from_label("XYZ")
>>> right = SparseObservable.from_label("+-IIrl")
>>> assert left.tensor(right) == right.expand(left)

static from_label(label, /)

Construire une observable à terme unique à partir d'une étiquette de chaîne dense.

L'opérateur résultant aura un coefficient de 1. L'étiquette doit être une séquence de l'alphabet 'IXYZ+-rl01'. 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

>>> SparseObservable.from_label("IIII+ZI")
<SparseObservable with 1 term on 7 qubits: (1+0j)(+_2 Z_1)>
>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> assert SparseObservable.from_label(label) == SparseObservable.from_pauli(pauli)

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

Construire un observable à partir d'une liste d'étiquettes et de coefficients denses.

Il est analogue à SparsePauliOp.from_list()sauf qu'il utilise l'alphabet étendu de SparseObservable. 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+-rl01'. 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, complex]]) – Paires d'étiquettes et leurs coefficients associés à additionner. Les étiquettes sont interprétées de la même manière qu'en from_label().
• 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 pour lesquels l'observable est utilisé. Si cette valeur est donnée et que iter n'est pas vide, la valeur doit correspondre à la longueur des étiquettes.

Exemples

Construire un observable à partir d'une liste d'étiquettes de même longueur :

>>> SparseObservable.from_list([
...     ("III++", 1.0),
...     ("II--I", 1.0j),
...     ("I++II", -0.5),
...     ("--III", -0.25j),
... ])
<SparseObservable with 4 terms on 5 qubits:
    (1+0j)(+_1 +_0) + (0+1j)(-_2 -_1) + (-0.5+0j)(+_3 +_2) + (-0-0.25j)(-_4 -_3)>

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

>>> SparseObservable.from_list([], num_qubits=10)
<SparseObservable 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 = ["XY+Z", "rl01", "-lXZ"]
>>> coeffs = [1.5j, 2.0, -0.5]
>>> from_list = SparseObservable.from_list(list(zip(labels, coeffs)))
>>> from_sparse_list = SparseObservable.from_sparse_list([
...     (label, (3, 2, 1, 0), coeff)
...     for label, coeff in zip(labels, coeffs)
... ])
>>> assert from_list == from_sparse_list

static from_pauli(pauli, /)

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

L'observable de sortie aura un seul terme, avec un coefficient unitaire dépendant de la phase.

Paramètres

pauli (Pauli) – le seul Pauli à convertir.

Exemples

>>> label = "IYXZI"
>>> pauli = Pauli(label)
>>> SparseObservable.from_pauli(pauli)
<SparseObservable with 1 term on 5 qubits: (1+0j)(Y_3 X_2 Z_1)>
>>> assert SparseObservable.from_label(label) == SparseObservable.from_pauli(pauli)

static from_raw_parts(num_qubits, coeffs, bit_terms, indices, boundaries, check=True)

Construire un SparseObservable à 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 dans l'observable.

• coeffs - coefficients complexes de chaque terme de l'observable. Il doit s'agir d'un tableau Numpy avec le dtype complex128.

• bit_terms - liste aplatie des termes à qubit unique comprenant tous les termes complets. Il doit s'agir d'un tableau Numpy avec le dtype uint8 (qui est compatible avec BitTerm).

• indices - liste triée par terme aplati des qubits auxquels correspond chaque terme d'un qubit unique. Il doit s'agir d'un tableau Numpy avec le dtype uint32.

• les limites - les indices qui divisent bit_terms et indices en termes. Il doit s'agir d'un tableau Numpy avec le dtype uintp.

• vérifier -

  si True (par défaut), valider que les données satisfont à toutes les garanties de cohérence. Si False, aucun contrôle n'est effectué.

  Avertissement

  Si check=False, les bit_terms doivent absolument être toutes des valeurs valides de SparseObservable.BitTerm. Si ce n'est pas le cas, un comportement indéfini dans l'espace Rust peut se produire, invalidant entièrement l'exécution du programme.

Exemples

Construire une somme de $Z$ sur chaque qubit individuel :

>>> num_qubits = 100
>>> terms = np.full((num_qubits,), SparseObservable.BitTerm.Z, dtype=np.uint8)
>>> indices = np.arange(num_qubits, dtype=np.uint32)
>>> coeffs = np.ones((num_qubits,), dtype=complex)
>>> boundaries = np.arange(num_qubits + 1, dtype=np.uintp)
>>> SparseObservable.from_raw_parts(num_qubits, coeffs, terms, indices, boundaries)
<SparseObservable with 100 terms on 100 qubits: (1+0j)(Z_0) + ... + (1+0j)(Z_99)>

static from_sparse_list(iter, /, num_qubits)

Construire un observable à partir d'une liste d'étiquettes, des qubits auxquels chaque élément s'applique et du coefficient du terme entier.

Il est analogue à SparsePauliOp.from_sparse_list()sauf qu'il utilise l'alphabet étendu de SparseObservable.

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], complex]]) – des triples d'étiquettes, les qubits auxquels s'applique chaque terme de qubit unique et le coefficient du terme entier.
• num_qubits (int) – le nombre de qubits dans l'opérateur.

Exemples

Construire un opérateur simple :

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

Construire l'observable d'identité (bien qu'en réalité, il suffise d'utiliser identity()) :

>>> SparseObservable.from_sparse_list([("", (), 1.0)], num_qubits=100)
<SparseObservable with 1 term on 100 qubits: (1+0j)()>

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 = ["XY+Z", "rl01", "-lXZ"]
>>> coeffs = [1.5j, 2.0, -0.5]
>>> from_list = SparseObservable.from_list(list(zip(labels, coeffs)))
>>> from_sparse_list = SparseObservable.from_sparse_list([
...     (label, (3, 2, 1, 0), coeff)
...     for label, coeff in zip(labels, coeffs)
... ])
>>> assert from_list == from_sparse_list

static from_sparse_pauli_op(op, /)

Construire un SparseObservable à partir d'une SparsePauliOp d'une instance.

Il s'agira d'une traduction largement directe de l'article SparsePauliOpen particulier, il n'y a pas de sommation à la volée de termes similaires, ni de tentative de refactorisation des sommes de termes de Pauli en opérateurs de projection équivalents.

Paramètres

op (SparsePauliOp) – l'opérateur à convertir.

Exemples

>>> spo = SparsePauliOp.from_list([("III", 1.0), ("IIZ", 0.5), ("IZI", 0.5)])
>>> SparseObservable.from_sparse_pauli_op(spo)
<SparseObservable with 3 terms on 3 qubits: (1+0j)() + (0.5+0j)(Z_0) + (0.5+0j)(Z_1)>

static from_terms(obj, /, num_qubits=None)

Construire un SparseObservable à 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 observable.

Paramètres

• obj (Iterable[Term]) – Itérable de termes individuels à partir desquels l'observable est construit.
• num_qubits (int | None) – Le nombre de qubits sur lesquels l'observable 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

L'observable correspondant.

static identity(num_qubits)

Obtenir l'opérateur d'identité sur le nombre de qubits donné.

Exemples

Obtenez l'opérateur d'identité pour 100 qubits :

>>> SparseObservable.identity(100)
<SparseObservable with 1 term on 100 qubits: (1+0j)()>

pauli_bases()

Obtenir un PauliList qui représente la base de mesure nécessaire pour chaque terme (dans l'ordre) de cet observable.

Par exemple, le projecteur 0l+ renverra un Pauli ZXY. Le résultat Pauli est dense, dans le sens où les identités explicites sont stockées. Une identité dans la sortie de Pauli ne nécessite pas de mesure concrète.

Cela renvoie une entrée dans la liste de Pauli pour chaque terme de la somme.

Retours

la liste des opérateurs de Pauli représentant les bases de mesure nécessaires.

Type de retour

PauliList

simplify(tol=1e-08)

Additionner tous les termes similaires dans cet opérateur, en les supprimant si le coefficient complexe résultant a une valeur absolue dans la tolérance de zéro.

Cette opération a pour effet secondaire de trier l'opérateur dans l' ordre canonique.

Paramètres

tol (float) – après avoir additionné les termes similaires, tous les coefficients 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 le même observable, mais dont la comparaison serait inégale en raison des tests structurels par défaut :

>>> base = SparseObservable.from_sparse_list([
...     ("XZ", (2, 1), 1e-10),  # value too small
...     ("+-", (3, 1), 2j),
...     ("+-", (3, 1), 2j),     # can be combined with the above
...     ("01", (3, 1), 0.5),    # out of order compared to `expected`
... ], num_qubits=5)
>>> expected = SparseObservable.from_list([("I0I1I", 0.5), ("I+I-I", 4j)])
>>> 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 ou d'associativité intermédiaires. Si cela ne peut être garanti, la forme la plus sûre est la suivante :

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

tensor(other, /)

Produit tensoriel de deux observables.

L'ordre des bits est défini de telle sorte que les indices des qubits de l'argument restent inchangés, et que les indices de self soient décalés du nombre de qubits contenus dans other. Il s'agit de la même convention que celle utilisée par les autres opérateurs de Qiskit quantum_info .

Cette fonction est utilisée pour l'opérateur infixe ^ . Si vous utilisez cet opérateur, sachez que les règles de priorité des opérateurs de Python peuvent modifier l'ordre d'évaluation par rapport à vos attentes. En particulier, l'opérateur + se lie plus étroitement que ^, tout comme * se lie plus étroitement que +. Utilisez des parenthèses pour fixer l'ordre d'évaluation, si nécessaire.

L'argument sera transformé en SparseObservable en utilisant son constructeur par défaut, s'il n'est pas déjà sous la forme correcte.

Paramètres

autre - l'observable à placer du côté droit du produit tensoriel.

Exemples

L'ordre des bits est tel que le produit tensoriel de deux observables obtenues à partir d'une seule étiquette "ressemble" à une observable obtenue en concaténant les deux chaînes :

>>> left = SparseObservable.from_label("XYZ")
>>> right = SparseObservable.from_label("+-IIrl")
>>> assert left.tensor(right) == SparseObservable.from_label("XYZ+-IIrl")

Vous pouvez également utiliser l'opérateur infixe ^ pour les produits tensoriels, qui moulera de manière similaire le côté droit de l'opération s'il ne s'agit pas déjà d'un produit tensoriel SparseObservable:

>>> assert SparseObservable("rl") ^ Pauli("XYZ") == SparseObservable("rlXYZ")

to_sparse_list()

Exprimez l'observable en termes de format de liste clairsemée.

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

>>> obs = SparseObservable.from_list([("IIXIZ", 2j), ("IIZIX", 2j)])
>>> reconstructed = SparseObservable.from_sparse_list(obs.to_sparse_list(), obs.num_qubits)

transpose()

Calculer la transposition matricielle de cet observable.

Cette opération est définie en termes de conventions matricielles standard de Qiskit, en ce sens que la forme matricielle est considérée comme étant dans la base de calcul $Z$. Les termes de l'alphabet liés à $X$- et $Z$ ne sont pas affectés par la transposition, mais les termes liés à $Y$ modifient leurs termes de l'alphabet. Précisément :

• $Y$ transpose en $-Y$
• $\lvert r\rangle\langle r\rvert$ transpose en $\lvert l\rangle\langle l\rvert$
• $\lvert l\rangle\langle l\rvert$ transpose en $\lvert r\rangle\langle r\rvert$

Exemples

>>> obs = SparseObservable([("III", 1j), ("Yrl", 0.5)])
>>> assert obs.transpose() == SparseObservable([("III", 1j), ("Ylr", -0.5)])

static zero(num_qubits)

Obtenir l'opérateur zéro sur le nombre de qubits donné.

L'opérateur zéro est l'opérateur dont la valeur d'espérance est nulle pour tous les états quantiques. Il n'y a pas de termes. C'est l'élément d'identité pour l'addition de deux instances SparseObservable tout ce qui est ajouté à l'opérateur zéro est égal à lui-même.

Si vous souhaitez que le projecteur passe à l'état zéro, utilisez :

>>> num_qubits = 10
>>> all_zeros = SparseObservable.from_label("0" * num_qubits)

Exemples

Obtenez l'opérateur zéro pour 100 qubits :

>>> SparseObservable.zero(100)
<SparseObservable with 0 terms on 100 qubits: 0.0>