MajoranaOperator

Un vecteur facultatif d'indices de groupe pour chaque terme.

Pour plus d'informations, consultez le module grouping .

adjoint()

Renvoie le conjugué hermitien (ou adjoint) de cet opérateur.

Cela a les conséquences suivantes sur les termes et les coefficients :

• les actions de chaque trimestre changent d'ordre
• les coefficients sont des nombres complexes conjugués

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): -1.0j, (gamma(0, False), gamma(0, True)): 1.0})
>>> adj = op.adjoint()
>>> print(format(adj))
 -0.000000e0 +1.000000e0j * ()
  1.000000e0 -0.000000e0j * (γ'0 γ0)

equiv(other, atol=1e-08)

Vérifie si cet opérateur est équivalent à un autre opérateur.

Dans ce contexte, l’équivalence désigne une égalité approximative, dans les limites de la tolérance absolue spécifiée. Plus précisément, cette méthode renvoie True, lorsque toutes les valeurs absolues des coefficients de la différence other - self sont inférieures au seuil spécifié atol.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 1e-7})
>>> zero = MajoranaOperator.zero()
>>> op.equiv(zero)
False
>>> op.equiv(zero, 1e-6)
True
>>> op.equiv(zero, 1e-9)
False

Paramètres

• autre – l'autre opérateur à comparer.
• atol – la tolérance absolue pour la comparaison. Cette valeur est définie par défaut sur 1e-8.

classmethod from_dict(data)

Crée un nouvel opérateur à partir d'un dictionnaire.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict(
...     {
...         (): 1.0-1.0j,
...         (0, 1): 2.0,
...     }
... )
>>> print(format(op))
  1.000000e0 -1.000000e0j * ()
  2.000000e0 +0.000000e0j * (γ0 γ'0)

Paramètres

données – un dictionnaire associant des tuples de termes à des coefficients complexes. Chaque clé est un tuple d'entiers qui indexent les modes de Majorana. Vous pouvez utiliser gamma() pour simplifier l'attribution d'indices pairs et impairs à $\gamma$ et $\gamma'$.

Retours

Un nouvel opérateur.

classmethod from_terms(terms)

Crée un nouvel opérateur à partir d'un itérateur de termes (voir aussi iter_terms()).

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0, (0,): 1.0, (1,): -1.0j})
>>> op.equiv(MajoranaOperator.from_terms(op.iter_terms()))
True

Paramètres

termes – un itérateur de termes tels que générés par iter_terms().

Retours

Un nouvel opérateur.

classmethod from_terms_with_groups(terms)

Crée un nouvel opérateur à partir d'un itérateur de termes comportant des groupes (voir aussi iter_terms_with_groups()).

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator([2.0, 1.0, -1.0j], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> reconstructed = MajoranaOperator.from_terms_with_groups(op.iter_terms_with_groups())
>>> op.equiv(reconstructed) and op.groups == reconstructed.groups
True

Paramètres

termes – un itérateur de termes tels que générés par iter_terms_with_groups().

Retours

Un nouvel opérateur.

get_boundaries()

Renvoie une liste en lecture seule contenant les indices indiquant les limites entre les termes de l'opérateur.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.one()
>>> op += MajoranaOperator.from_dict({(0, 1): 1.0})
>>> op.get_boundaries()
[0, 0, 2]

Retours

Liste des limites prévues par les conditions générales de l'opérateur.

get_coeffs()

Renvoie une liste en lecture seule contenant les coefficients de l'opérateur.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.one()
>>> op += -1j * MajoranaOperator.one()
>>> op.get_coeffs()
[(1+0j), -1j]

Retours

Liste des coefficients de l'opérateur.

get_modes()

Renvoie une liste en lecture seule contenant les indices des modes sur lesquels l'opérateur a agi.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.one()
>>> op += MajoranaOperator.from_dict({(0, 1): 1.0})
>>> op.get_modes()
[0, 1]

Retours

Liste des modes de l'opérateur.

get_support()

Renvoie l'ensemble des indices de mode sur lesquels cet opérateur agit.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict(
...     {
...         (0, 4): 1,
...         (1, 3, 4, 7): 1,
...     }
... )
>>> assert op.get_support() == {0, 1, 3, 4, 7}

Retours

L'ensemble des indices de mode sur lesquels agit cet opérateur.

group_weights()

Renvoie la moyenne de l'amplitude absolue des coefficients de chaque groupe.

La i-ième entrée correspond à la somme abs(coeff) des termes du groupe i, divisée par le nombre de termes de ce groupe. Si vaut groups None, cette fonction renvoie également None.

Il s'agit du poids d'échantillonnage d'une formule de produit aléatoire (par exemple, qDRIFT ) qui sélectionne des groupes entiers plutôt que des termes individuels. Le calcul en mode natif est nettement moins coûteux que la réduction de et get_coeffs() groups dans NumPy,, car ces deux accesseurs copient chacun une valeur par terme non regroupé à partir de l'opérateur, pour ensuite les regrouper en une seule valeur par groupe, alors que cette méthode renvoie directement les valeurs réduites num_groups() .

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> print(op.group_weights())
None
>>> op.groups = [0, 1, 0, 1]
>>> op.group_weights()
[1.0, 2.0]

Retours

La valeur moyenne absolue du coefficient de chaque indice de groupe.

has_groups()

Indique si cet opérateur prend en compte les indices de groupe.

Cela revient à vérifier (mais coûte moins cher que) op.groups is not None, car cela ne nécessite pas de copier les indices de groupe hors de l'opérateur pour les inspecter.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> op.has_groups()
False
>>> op.groups = [0, 1, 0, 1]
>>> op.has_groups()
True

Retours

Vérifier si cet opérateur groups est activé.

ichop(atol=1e-08)

Supprime les termes dont la valeur absolue du coefficient est inférieure au seuil indiqué.

Cette méthode modifie l'opérateur in situ et renvoie None.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 1e-4, (0,): 1e-6, (1,): 1e-10})
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
  1.000000e-6 +0.000000e0j * (γ0)
 1.000000e-10 +0.000000e0j * (γ'0)
>>> op.ichop()
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
  1.000000e-6 +0.000000e0j * (γ0)
>>> op.ichop(1e-5)
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()

Paramètres

atol – la tolérance absolue pour le seuil de coupure. Cette valeur est définie par défaut sur 1e-8.

is_even()

Indique si cet opérateur est pair.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(0, 1): 1})
>>> op.is_even()
True
>>> op = MajoranaOperator.from_dict({(0,): 1})
>>> op.is_even()
False

Retours

Vérifier si cet opérateur est pair.

is_hermitian(atol=1e-08)

Indique si cet opérateur est hermitien.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({
...     (0, 1, 2, 3): 1.00001j,
...     (3, 2, 1, 0): -1j,
... })
>>> op.is_hermitian()
False
>>> op.is_hermitian(1e-4)
True

Paramètres

atol – Précision numérique jusqu'à laquelle les coefficients sont considérés comme égaux. Cette valeur est définie par défaut sur 1e-8.

Retours

Si cet opérateur est hermitien.

iter_terms()

Un itérateur parcourant les termes de l'opérateur.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0, (0,): 1.0, (1,): -1.0j})
>>> list(sorted(op.iter_terms()))
[([], (2+0j)), ([0], (1+0j)), ([1], (-0-1j))]

iter_terms_with_groups()

Un itérateur parcourant les termes de l'opérateur avec leur indice de groupe associé.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator([2.0, 1.0, -1.0j], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> list(op.iter_terms_with_groups())
[([], (2+0j), 0), ([0], (1+0j), 1), ([1], (-0-1j), 1)]

max_rank()

Renvoie le rang maximal des termes de cet opérateur.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(0, 1, 2, 3): 1})
>>> op.max_rank()
4

Retours

Le rang maximal de cet opérateur.

normal_ordered(ascending=False, reduce=True)

Renvoie un opérateur équivalent dont les termes sont classés selon l'ordre habituel.

L'ordre normal d'un terme d'opérateur est défini de telle sorte que toutes les actions soient classées par ordre lexicographique. Le fait qu'ils montent ou descendent dépend de la valeur du paramètre ascending . Conformément à la convention établie par pour gamma() placer « $\gamma$ » ( $\gamma'$ ) sur les indices pairs (impairs), on obtient l'exemple suivant (pour la valeur par défaut, ascending=False) : [\gamma(1, True), \gamma(1, False), \gamma(0, True), \gamma(0, False)] = [3, 2, 1, 0].

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(gamma(0, False), gamma(0, True), gamma(0, False)): 1})
>>> print(format(op.normal_ordered(reduce=False)))
 -1.000000e0 +0.000000e0j * (γ'0 γ0 γ0)
>>> print(format(op.normal_ordered(reduce=True)))
 -1.000000e0 +0.000000e0j * (γ'0)

Paramètres

• ascendant – si les indices doivent augmenter ou diminuer.
• réduire – déterminer s'il convient de réduire chaque terme à sa forme minimale en supprimant les actions dont le carré est égal à l'identité. Voir également l'exemple ci-dessus.

Retours

Un opérateur équivalent mais ordonné selon l'ordre normal.

num_groups()

Renvoie le nombre de groupes.

Si vaut groups None, cette fonction renvoie également None. Sinon, elle renvoie le nombre de groupes, défini comme étant l'indice du plus grand groupe présent plus 1 (ce qui peut donc servir d'indice pour le groupe suivant).

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> op.groups = [0, 1, 0, 1]
>>> op.num_groups()
2

Retours

L'indice du plus grand groupe affiche une groups hausse de 1.

classmethod one()

Construit l'opérateur d'identité multiplicative.

La composition de l'opérateur ainsi construit avec un autre opérateur n'a aucun effet.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0})
>>> one = MajoranaOperator.one()
>>> op & one == op
True

relabel_modes(permutation)

Renvoie un nouvel opérateur dont les modes ont été renommés.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({
...     (0, 1): 1,
...     (0, 1, 2, 3): 1,
... })
>>> permutation = [5, 6, 4, 3]
>>> relabeled = op.relabel_modes(permutation)
>>> print(format(relabeled))
  1.000000e0 +0.000000e0j * (γ'2 γ3)
  1.000000e0 +0.000000e0j * (γ'2 γ3 γ2 γ'1)

Paramètres

permutation – la liste des permutations d'index. Le mode est i renommé permutation[i], la liste ne doit donc contenir aucune entrée en double et doit être suffisamment longue pour répertorier tous les modes sur lesquels l'opérateur agit (sa longueur doit dépasser le plus grand indice de mode de l'opérateur).

Retours

Un nouvel opérateur dont les modes ont été renommés.

Augmentations

ValueError – si contient permutation des entrées en double, ou s'il est trop court pour renommer un mode sur lequel l'opérateur agit.

simplify(atol=1e-08)

Renvoie un opérateur équivalent mais simplifié.

Le processus de simplification commence par additionner tous les coefficients appartenant à des termes identiques, puis ne conserve que ceux dont le coefficient total dépasse la tolérance spécifiée (tout comme ichop()).

Lorsqu'un opérateur a fait l'objet d'une manipulation arithmétique ou a été construit d'une manière qui ne garantit pas l'unicité des termes, il convient d'appeler cette méthode avant d'appliquer toute méthode filtrant les coefficients numériquement faibles, afin d'éviter toute perte d'information. Consultez l'exemple ci-dessous, qui montre comment peut ichop() tronquer des termes dont la somme donne une valeur de coefficient totale qui ne devrait pas être tronquée :

>>> from qiskit_fermions.operators import MajoranaOperator
>>> coeffs = [1e-5] * int(1e5)
>>> boundaries = [0] + [0] * int(1e5)
>>> op = MajoranaOperator(coeffs, [], boundaries)
>>> canon = op.simplify(1e-4)
>>> assert canon.equiv(op.one(), 1e-6)
>>> op.ichop(1e-4)
>>> assert op.equiv(op.zero(), 1e-6)

Paramètres

atol – la tolérance absolue pour le seuil de coupure. Cette valeur est définie par défaut sur 1e-8.

Retours

Un opérateur équivalent mais simplifié.

split_out_groups(group_indices=None)

Divise cet opérateur en une liste facultative de nouveaux opérateurs en fonction de groups.

Si vaut groups None, cette fonction renvoie également None. Sinon, si group_indices est None (valeur par défaut), la fonction renvoie une liste contenant un nouvel opérateur pour chaque indice de groupe de groups, classés par ordre d'indice. Si group_indices est fourni, seuls les indices demandés sont construits, dans l'ordre indiqué : cela permet d'éviter le coût lié à la construction d'opérateurs pour des groupes qui ne seront jamais utilisés, ce qui est particulièrement avantageux lorsqu'on n'a besoin que d'un petit nombre de groupes parmi un ensemble beaucoup plus vaste, par exemple lors du sous-échantillonnage de groupes pour une formule de produit aléatoire. Un index en double dans group_indices est renvoyé une fois par occurrence.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator(
...     [1.0, 2.0, -1.0, -2.0],
...     [0, 1, 2, 3, 1, 0, 3, 2],
...     [0, 2, 4, 6, 8],
... )
>>> print(op.split_out_groups())
None
>>> op.groups = [0, 1, 0, 1]
>>> groups = op.split_out_groups()
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([0, 1], (1+0j)), ([1, 0], (-1+0j))]
[([2, 3], (2+0j)), ([3, 2], (-2+0j))]
>>> groups = op.split_out_groups(group_indices=[1])
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([2, 3], (2+0j)), ([3, 2], (-2+0j))]

Paramètres

group_indices – les indices de groupe pour lesquels créer des opérateurs, dans l'ordre de sortie souhaité. En l'absence de spécification, tous les groupes sont créés, par ordre d'index.

Retours

Un vecteur facultatif contenant un nouvel opérateur pour chaque indice de groupe demandé.

classmethod zero()

Construit l'opérateur d'identité additive.

L'ajout de l'opérateur ainsi créé à un autre opérateur n'a aucun effet.

>>> from qiskit_fermions.operators import MajoranaOperator
>>> op = MajoranaOperator.from_dict({(): 2.0})
>>> zero = MajoranaOperator.zero()
>>> op + zero == op
True

static _anti_commutator_(op_a, op_b)

static _commutator_(op_a, op_b)

static _double_commutator_(op_a, op_b, op_c, sign)

_fermion_operator_()

Convertit cet opérateur en un FermionOperator.

Cela implémente le protocole SupportsFermionOperator en déléguant à majorana_to_fermion().