EdgeVertexOperator

class EdgeVertexOperator(coeffs, left_indices, right_indices, boundaries)

Bases : object

Un opérateur arête-sommet.

Définition

Cet opérateur est défini à partir des opérateurs « arête-sommet » ( $E_{jk}$ , $V_j$ ) :

\begin{align} V_j &= -i \gamma_{2j-1} \gamma_{2j} = -(a_j a_j - a_j a^\dagger_j + a^\dagger_j a_j - a^\dagger_j a^\dagger_j) = 1 - 2 a^\dagger_j a_j \, , \nonumber \\ E_{jk} &= -i \gamma_{2j-1} \gamma_{2k-1} = -i (a_j a_k + a_j a^\dagger_k + a^\dagger_j a_k + a^\dagger_j a^\dagger_k) = -E_{kj} \nonumber \end{align}

qui satisfont les relations de commutation mixtes fermioniques-bosoniques suivantes pour l’ $j \neq k \neq l \neq m$ : [1]

\begin{align} \left\{ E_{jk}, V_k \right\} &= 0 \nonumber \\ \left\{ E_{jk}, E_{kl} \right\} &= 0 \nonumber \\ \left[ V_k, V_l \right] &= 0 \nonumber \\ \left[ E_{jk}, V_l \right] &= 0 \nonumber \\ \left[ E_{jk}, E_{lm} \right] &= 0 \nonumber \, . \end{align}

En résumé, les opérateurs d'arête et de sommet commutent, sauf s'ils partagent exactement un indice, auquel cas ils anticommutent.

Remarque

Les relations ci-dessus s'appliquent à des $j \neq k \neq l \neq m$ ; elles ne couvrent donc pas les cas où deux opérateurs de bord couvrent la même paire de modes. Ces relations de commutation : puisque $E_{kj} = -E_{jk}$ , une telle paire est colinéaire, et tout opérateur commute avec lui-même. C'est pourquoi la condition est « exactement un » index partagé plutôt que « au moins un ».

Un exemple simple peut être représenté visuellement comme suit :

Représentation graphique d'un opérateur « arête-sommet ».

On peut prendre quelques libertés avec la notation et définir $V_j = E_{jj}$ , qui reflète le fonctionnement de la structure de données interne de cet opérateur. La définition de l'opérateur dans son ensemble est donc la suivante :

\text{\texttt{EdgeVertexOperator}} = \sum_i c_i \bigotimes_{lr} E_{lr} \, ,

où $lr$ désigne l'indice des termes de l'opérateur concerné et $c_i$ est le coefficient (complexe) constituant la combinaison linéaire des produits. Les indices $l$ et $r$ peuvent prendre n'importe quelle valeur comprise entre 0 et le nombre de modes fermioniques sur lesquels agit l'opérateur, moins 1.

Nous appellerons « opérateurs de bord généralisés » les $E_{lr}$ .

Implémentation

Cette classe stocke les termes et les coefficients dans plusieurs vecteurs creux, à l'instar du format « compressed sparse row » couramment utilisé pour les matrices creuses. Plus précisément, un opérateur contient 4 tableaux :

Chronique « 1 »	Chronique « 2 »
`coeffs`	Un vecteur de coefficients complexes composé de deux nombres à virgule flottante de 64 bits.
`left_indices`	Un vecteur d'entiers de 32 bits contenant les indices des modes fermioniques de gauche (voir $l$ ).
`right_indices`	Un vecteur d'entiers de 32 bits contenant les indices des modes fermioniques de droite (voir $r$ ci-dessus).
`boundaries`	Un vecteur d'entiers indiquant les limites dans `actions` et `modes`.

Les modes fermioniques indexés par left_indices et right_indices sont considérés comme dépourvus de spin.

Remarque

Vous pouvez accéder à des copies en lecture seule de ces tableaux internes via leurs méthodes respectives : get_coeffs(), get_left_indices(), get_right_indices(), et get_boundaries().

Cette structure de données permet de créer et de manipuler des opérateurs de manière très efficace. Cela implique toutefois qu'un opérateur puisse contenir à tout moment des termes en double. Ces problèmes doivent être résolus manuellement à l'aide de simplify().

Construction

Il est possible de créer un opérateur directement en fournissant les tableaux décrits ci-dessus :

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> coeffs = [1.0, 2.0, -3.0, 4.0j, -0.5j]
>>> left_indices = [0, 3, 0, 2, 3, 0]
>>> right_indices = [1, 4, 1, 2, 3, 1]
>>> boundaries = [0, 0, 1, 2, 4, 6]
>>> op = EdgeVertexOperator(coeffs, left_indices, right_indices, boundaries)
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
  2.000000e0 +0.000000e0j * (E(0,1))
  0.000000e0 +4.000000e0j * (E(0,1) V(2))
 -0.000000e0-5.000000e-1j * (V(3) E(0,1))
 -3.000000e0 +0.000000e0j * (E(3,4))

Pour plus de commodité, il est possible de créer un opérateur à partir d’un dictionnaire de type « Python » de la manière suivante :

>>> op = EdgeVertexOperator.from_dict(
...     {
...         (): 1.0,
...         ((0, 1),): 2.0,
...         ((3, 4),): -3.0,
...         ((0, 1), (2, 2)): 4.0j,
...         ((3, 3), (0, 1)): -0.5j,
...     }
... )
>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
  2.000000e0 +0.000000e0j * (E(0,1))
  0.000000e0 +4.000000e0j * (E(0,1) V(2))
 -0.000000e0-5.000000e-1j * (V(3) E(0,1))
 -3.000000e0 +0.000000e0j * (E(3,4))

Par ailleurs, les méthodes de construction et d'aide rapide suivantes sont disponibles :

Chronique « 1 »	Chronique « 2 »
`zero`()	Construit l'opérateur d'identité additive.
`one`()	Construit l'opérateur d'identité multiplicative.
`from_terms`(conditions)	Crée un nouvel opérateur à partir d'un itérateur de termes (voir aussi `iter_terms()`).
`from_terms_with_groups`(conditions)	Crée un nouvel opérateur à partir d'un itérateur de termes comportant des groupes (voir aussi `iter_terms_with_groups()`).

Formatage

Dans les exemples ci-dessus, les opérateurs créés ont été affichés à l'aide de la sortie de format(), ce qui permet d'obtenir une représentation lisible par l'utilisateur de l'opérateur.

>>> print(format(op))
  1.000000e0 +0.000000e0j * ()
  2.000000e0 +0.000000e0j * (E(0,1))
  0.000000e0 +4.000000e0j * (E(0,1) V(2))
 -0.000000e0-5.000000e-1j * (V(3) E(0,1))
 -3.000000e0 +0.000000e0j * (E(3,4))

Remarque

L'ordre d'impression de format(op) est explicitement trié avant l'impression. Par conséquent, cela ne reflète pas l'ordre des termes à l'intérieur de l'opérateur.

La fonction repr() permet d'obtenir une forme alternative, qui donne lieu à une représentation interprétable par Python. En d'autres termes, cette sortie peut facilement être copiée-collée dans un shell Python :

>>> print(repr(op))
EdgeVertexOperator.from_dict({...})

Enfin, pour les grands opérateurs, ces deux sorties peuvent s'avérer très longues et indésirables. On peut alors obtenir, grâce à cette fonction str() , un formulaire très simple contenant un minimum d'informations :

>>> print(str(op))
<EdgeVertexOperator with 5 terms>

Itération

La structure de données sous-jacente étant implémentée en Rust et présentant une disposition complexe, il n'est pas possible d'itérer directement dessus :

>>> list(iter(op))
Traceback (most recent call last):
  ...
TypeError: 'qiskit_fermions.operators.edge_vertex_operator.EdgeVertexOperator' object is not iterable

Cette classe fournit plutôt des itérateurs personnalisés pour répondre à ce besoin :

>>> list(sorted(op.iter_terms()))
[([], (1+0j)), ([(0, 1)], (2+0j)), ([(0, 1), (2, 2)], 4j), ([(3, 3), (0, 1)], (-0-0.5j)), ([(3, 4)], (-3+0j))]

Voir aussi

iter_terms()

Pour plus de détails sur la mise en œuvre.

Le tableau ci-dessous répertorie tous les itérateurs disponibles :

Chronique « 1 »	Chronique « 2 »
`iter_terms`()	Un itérateur parcourant les termes de l'opérateur.
`iter_terms_with_groups`()	Un itérateur parcourant les termes de l'opérateur avec leur indice de groupe associé.

Arithmétique

Les opérations arithmétiques suivantes sont prises en charge :

Addition/Soustraction

>>> op = EdgeVertexOperator.one()
>>> (op + op).simplify()
EdgeVertexOperator.from_dict({(): 2+0j})
>>> (op - op).simplify()
EdgeVertexOperator.from_dict({})
>>> op += op
>>> op.simplify()
EdgeVertexOperator.from_dict({(): 2+0j})
>>> op -= op
>>> op.simplify()
EdgeVertexOperator.from_dict({})

Multiplication et division scalaires

>>> op = EdgeVertexOperator.one()
>>> (2 * op).simplify()
EdgeVertexOperator.from_dict({(): 2+0j})
>>> (op / 2).simplify()
EdgeVertexOperator.from_dict({(): 0.5+0j})
>>> op *= 2
>>> op.simplify()
EdgeVertexOperator.from_dict({(): 2+0j})
>>> op /= 2
>>> op.simplify()
EdgeVertexOperator.from_dict({(): 1+0j})

Composition de l'opérateur

Remarque

La composition des opérateurs correspond à la multiplication à gauche : c = a & b correspond à $C = B A$ . En d’autres termes, la composition de deux opérateurs renvoie un opérateur résultant qui effectue « d’abord a puis ». b

>>> op1 = EdgeVertexOperator.from_dict({(): 2.0, ((0, 1),): 3.0})
>>> op2 = EdgeVertexOperator.from_dict({(): 1.5, ((2, 2),): 4.0})
>>> comp = (op1 & op2).simplify()
>>> print(format(comp))
  3.000000e0 +0.000000e0j * ()
  4.500000e0 +0.000000e0j * (E(0,1))
  8.000000e0 +0.000000e0j * (V(2))
  1.200000e1 +0.000000e0j * (V(2) E(0,1))
>>> op2 &= op1
>>> print(format(op2.simplify()))
  3.000000e0 +0.000000e0j * ()
  4.500000e0 +0.000000e0j * (E(0,1))
  1.200000e1 +0.000000e0j * (E(0,1) V(2))
  8.000000e0 +0.000000e0j * (V(2))
>>> squared = (op1 ** 2).simplify()
>>> print(format(squared))
  4.000000e0 +0.000000e0j * ()
  1.200000e1 +0.000000e0j * (E(0,1))
  9.000000e0 +0.000000e0j * (E(0,1) E(0,1))

Remarque

Pour plus de commodité, la multiplication à droite est implémentée par c = a @ b (ce qui donne « $C = A B$ »).

>>> (op1 @ op2).equiv(op2 & op1)
True

Autres opérations

Outre les méthodes « magiques » correspondant aux opérations arithmétiques décrites ci-dessus, les méthodes suivantes sont disponibles :

Chronique « 1 »	Chronique « 2 »
`adjoint`()	Renvoie le conjugué hermitien (ou adjoint) de cet opérateur.
`ichop`( [atol] )	Supprime les termes dont la valeur absolue du coefficient est inférieure au seuil indiqué.
`simplify`( [atol] )	Renvoie un opérateur équivalent mais simplifié.
`normal_ordered`( [par ordre croissant, réduire] )	Renvoie un opérateur équivalent dont les termes sont classés selon l'ordre habituel.
`relabel_modes`(permutation)	Renvoie un nouvel opérateur dont les modes ont été renommés.

Propriétés

Enfin, il existe différentes méthodes permettant de vérifier certaines propriétés d'un opérateur :

Chronique « 1 »	Chronique « 2 »
`is_hermitian`( [atol] )	Indique si cet opérateur est hermitien.

[ 1 ]

Gandon et al., arXiv:2512.11418.

Attributs

groups

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

Pour plus d'informations, consultez le module grouping .

Méthodes

adjoint

adjoint()

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

Chaque trimestre, deux choses se produisent :

les coefficients sont des nombres complexes conjugués
l'ordre des générateurs au sein de chaque terme est inversé

Cette inversion est nécessaire car $(AB)^\dagger = B^\dagger A^\dagger$ . Bien que les générateurs individuels de sommets et d'arêtes soient hermitiens, ils anticommutent lorsqu'ils partagent un indice (voir la définition ci-dessus ); par conséquent, le produit inversé n'est pas égal au produit d'origine et l'ordre ne peut pas être simplement ignoré.

Notez que cela ne rend pas pour autant l'opérateur auto-adjoint en général : un opérateur à coefficients complexes diffère de son adjoint (comme l'illustre le doctest ci-dessous).

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): -1.0j, ((0, 0), (0, 1)): 1.0})
>>> adj = op.adjoint()
>>> print(format(adj))
 -0.000000e0 +1.000000e0j * ()
  1.000000e0 -0.000000e0j * (E(0,1) V(0))

equiv

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.

Remarque

C'est la comparaison mathématique que l'on recherche presque toujours. Il diffère de l'opérateur == , qui vérifie l'égalité exacte des termes stockés (leurs coefficients, leurs indices et les limites internes des termes) sans tolérance ni simplification. Deux opérateurs mathématiquement égaux peuvent donc donner un résultat différent lors d'une comparaison sous == s'ils sont stockés différemment – par exemple, un non simplifié par a + a rapport à un 2 * a, ou des termes classés dans un ordre différent. Utilisez equiv pour comparer des opérateurs dans les limites de la tolérance numérique.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): 1e-7})
>>> zero = EdgeVertexOperator.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.

from_dict

classmethod from_dict(data)

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

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

Paramètres

données – un dictionnaire associant des tuples de termes à des coefficients complexes. Chaque clé est un tuple de paires (int, int) indiquant les indices de l'opérateur d'arête généralisé, $E_{lr}$ (si $l = r$ , cela correspond à l'opérateur de sommet $V_l$ ).

Retours

Un nouvel opérateur.

from_terms

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 EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): 2.0, ((0, 0),): 1.0, ((0, 1),): -1.0j})
>>> op.equiv(EdgeVertexOperator.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.

from_terms_with_groups

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 EdgeVertexOperator
>>> op = EdgeVertexOperator([2.0, 1.0, -1.0j], [0, 0], [0, 1], [0, 0, 1, 2])
>>> op.groups = [0, 1, 1]
>>> reconstructed = EdgeVertexOperator.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

get_boundaries()

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

Remarque

Cette méthode renvoie une copie des données internes.

Voir aussi

Vous trouverez ici une explication de la structure interne des données.

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

Retours

Liste des limites des conditions générales de l'opérateur.

get_coeffs

get_coeffs()

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

Remarque

Cette méthode renvoie une copie des données internes.

Voir aussi

Vous trouverez ici une explication de la structure interne des données.

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

Retours

Liste des coefficients de l'opérateur.

get_left_indices

get_left_indices()

Renvoie une liste en lecture seule contenant les indices de gauche de tous les termes d'opérateurs d'arêtes généralisés.

Remarque

Cette méthode renvoie une copie des données internes.

Voir aussi

Vous trouverez ici une explication de la structure interne des données.

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

Retours

Une liste des indices de gauche de tous les termes d'opérateurs d'arête généralisés.

get_right_indices

get_right_indices()

Renvoie une liste en lecture seule contenant les indices de droite de tous les termes d'opérateurs d'arêtes généralisés.

Remarque

Cette méthode renvoie une copie des données internes.

Voir aussi

Vous trouverez ici une explication de la structure interne des données.

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

Retours

Une liste des indices de droite de tous les termes de l'opérateur de bord généralisé.

get_support

get_support()

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

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

Retours

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

has_groups

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 examiner.

Remarque

Cette fonction renvoie une valeur même True lorsque groups est une liste vide, ce qui correspond à l'état d'un opérateur groupé ne contenant aucun terme.

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

Retours

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

ichop

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.

Attention

Cette méthode tronque les coefficients de manière « gloutonne »! Si l'opérateur sur lequel porte l'action peut contenir des coefficients distincts pour des termes identiques, pensez plutôt simplify() à appeler!

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): 1e-4, ((1, 0),): 1e-6, ((0, 1),): 1e-10})
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
 1.000000e-10 +0.000000e0j * (E(0,1))
  1.000000e-6 +0.000000e0j * (E(1,0))
>>> op.ichop()
>>> print(format(op))
  1.000000e-4 +0.000000e0j * ()
  1.000000e-6 +0.000000e0j * (E(1,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_hermitian

is_hermitian(atol=1e-08)

Indique si cet opérateur est hermitien.

Remarque

Cette vérification est mise en œuvre à l'aide de equiv() sur la différence normal_ordered() entièrement réduite de self et de ses et adjoint() zero(). Étant donné que cette forme normale contracte chaque paire réductible de générateurs adjacents — y compris la fusion de deux opérateurs de bord qui partagent un même mode via l’ $E_{ab} E_{bc} = -i E_{ac}$ —, un terme qui ne s’annule qu’avec son adjoint après une telle contraction est toujours considéré comme égal à zéro.

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

iter_terms()

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

Avertissement

La modification des éléments de l'itération n'affecte pas les données sous-jacentes de l'opérateur.

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

iter_terms_with_groups

iter_terms_with_groups()

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

Avertissement

La modification des éléments de l'itération n'affecte pas les données sous-jacentes de l'opérateur.

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

normal_ordered

normal_ordered(ascending=True, 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 tous les opérateurs de sommet apparaissent avant tous les opérateurs d'arête. Au sein de chaque groupe, les modes sur lesquels porte l'action sont classés par ordre lexicographique.

Remarque

Lorsqu'on réorganise un terme, il faut tenir compte des relations mixtes de commutation et d'ant COMMUTATION. Cliquez ici pour consulter les définitions détaillées.

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({((0, 1), (1, 0), (1, 2), (0, 0), (2, 2)): 1})
>>> print(format(op.normal_ordered(reduce=False).simplify()))
 -1.000000e0 -0.000000e0j * (V(0) V(2) E(0,1) E(1,0) E(1,2))
>>> print(format(op.normal_ordered().simplify()))
  1.000000e0 +0.000000e0j * (V(0) V(2) E(1,2))

Paramètres

ascendant – la convention d'orientation pour les opérateurs de bord. Depuis $E_{kj} = -E_{jk}$ , chaque opérateur de arête possède deux représentations; True choisit $j < k$ et False choisit $j > k$ , en intégrant le signe dans le coefficient. Les opérateurs de sommets ne sont pas affectés. Cette valeur est définie par défaut sur True.
réduire – déterminer s’il convient de regrouper les générateurs adjacents en un scalaire ou en un seul générateur. Voir l'exemple ci-dessus. Cette valeur est définie par défaut sur True.

Retours

Un opérateur équivalent mais à ordre normal.

num_groups

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 rencontré plus 1 (ce qui peut donc servir d'indice pour le groupe suivant).

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

Retours

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

one

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 EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): 2.0})
>>> one = EdgeVertexOperator.one()
>>> op & one == op
True

relabel_modes

relabel_modes(permutation)

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

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

Paramètres

permutation – la liste des permutations des indices. Le mode est i renommé en permutation[i], de sorte que la liste ne doit 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 permutation contient des entrées en double ou si sa longueur est insuffisante pour redéfinir un mode sur lequel l'opérateur agit.

simplify

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 absolue de coefficient qui ne devrait pas être tronquée :

>>> from qiskit_fermions.operators import EdgeVertexOperator
>>> coeffs = [1e-5] * int(1e5)
>>> boundaries = [0] + [0] * int(1e5)
>>> op = EdgeVertexOperator(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

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), elle renvoie une liste contenant un nouvel opérateur pour chaque indice de groupe dans 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 EdgeVertexOperator
>>> op = EdgeVertexOperator(
...     [1.0, 2.0, -1.0],
...     [0, 1, 2, 3],
...     [1, 0, 3, 2],
...     [0, 1, 3, 4],
... )
>>> print(op.split_out_groups())
None
>>> op.groups = [0, 1, 0]
>>> groups = op.split_out_groups()
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([(0, 1)], (1+0j)), ([(3, 2)], (-1+0j))]
[([(1, 0), (2, 3)], (2+0j))]
>>> groups = op.split_out_groups(group_indices=[1])
>>> for g in groups:
...     print(list(sorted(g.iter_terms())))
[([(1, 0), (2, 3)], (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é.

zero

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 EdgeVertexOperator
>>> op = EdgeVertexOperator.from_dict({(): 2.0})
>>> zero = EdgeVertexOperator.zero()
>>> op + zero == op
True

Méthodes protocolaires

_anti_commutator_

static _anti_commutator_(op_a, op_b)

_commutator_

static _commutator_(op_a, op_b)

_double_commutator_

static _double_commutator_(op_a, op_b, op_c, sign)

_fermion_operator_

_fermion_operator_()

Convertit cet opérateur en un FermionOperator.

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

_majorana_operator_

_majorana_operator_()

Convertit cet opérateur en un MajoranaOperator.

Cela implémente le protocole SupportsMajoranaOperator en déléguant à edge_vertex_to_majorana().

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

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