QfFermionOperator

QfFermionOperator *qf_ferm_op_new(uint64_t num_terms, uint64_t num_actions, const QkComplex64 *coeffs, const bool *actions, const uint32_t *modes, const uint32_t *boundaries)

Crée un nouvel opérateur.

Un argument de type pointeur peut être NULL si et seulement si sa longueur correspondante est égale à zéro.

Exemple

1uint64_t num_terms = 3;
2uint64_t num_actions = 4;
3bool actions[4] = {true, false, true, false};
4uint32_t modes[4] = {0, 1, 2, 3};
5QkComplex64 coeffs[3] = {{1.0, 0.0}, {-1.0, 0.0}, {0.0, -1.0}};
6uint32_t boundaries[4] = {0, 0, 2, 4};
7QfFermionOperator *op = qf_ferm_op_new(num_terms, num_actions, coeffs,
8                                       actions, modes, boundaries);

Paramètres

• num_terms – Le nombre de termes dans l'opérateur.
• num_actions – Nombre total d'actions, toutes catégories confondues.
• coeffs – Un pointeur vers un tableau de coefficients de termes. La longueur de ce tableau devrait être de num_terms.
• actions – Un pointeur vers un tableau d'actions sur l'ensemble des termes. La longueur de ce tableau devrait être de num_actions.
• modes – Un pointeur vers un tableau contenant les modes d'action pour tous les termes. La longueur de ce tableau devrait être de num_actions.
• limites – Un pointeur vers un tableau contenant les limites entre les termes. La longueur de ce tableau devrait être de num_terms + 1.

void qf_ferm_op_free(QfFermionOperator *op)

Libère un opérateur existant.

Exemple

1QfFermionOperator *op = qf_ferm_op_one();
2qf_ferm_op_free(op);

Paramètres

• op – Un pointeur vers l'opérateur fermionique à libérer.

void qf_ferm_op_get_coeffs(const QfFermionOperator *op, QkComplex64 **coeffs_out, uint64_t *coeffs_len)

Permet d'accéder en lecture seule aux coefficients de l'opérateur.

Exemple

 1uint64_t num_terms = 2;
 2uint64_t num_actions = 0;
 3QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 4uint32_t boundaries[3] = {0, 0, 0};
 5QfFermionOperator *op =
 6    qf_ferm_op_new(num_terms, num_actions, coeffs, NULL, NULL, boundaries);
 7
 8QkComplex64 *coeffs_out;
 9uint64_t *coeffs_len;
10
11qf_ferm_op_get_coeffs(op, &coeffs_out, &coeffs_len);
12
13assert(coeffs_len == 2);

Paramètres

• op – Un pointeur vers l'opérateur fermionique dont on souhaite accéder aux coefficients.
• coeffs_out – Un pointeur vers le tableau de valeurs complexes dans lequel les coefficients doivent être écrits.
• coeffs_len – Un pointeur vers l'entier dans lequel écrire la longueur du tableau de sortie.

void qf_ferm_op_get_actions(const QfFermionOperator *op, bool **actions_out, uint64_t *actions_len)

Permet un accès en lecture seule aux actions de l'opérateur.

Exemple

 1uint64_t num_terms = 2;
 2uint64_t num_actions = 2;
 3bool actions[2] = {true, false};
 4uint32_t modes[2] = {0, 1};
 5QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 6uint32_t boundaries[3] = {0, 0, 2};
 7QfFermionOperator *op =
 8    qf_ferm_op_new(num_terms, num_actions, coeffs, actions, modes, boundaries);
 9
10QkComplex64 *actions_out;
11uint64_t *actions_len;
12
13qf_ferm_op_get_actions(op, &actions_out, &actions_len);
14
15assert(actions_len == 2);

Paramètres

• op – Un pointeur vers l'opérateur fermionique dont on souhaite accéder aux actions.
• actions_out – Un pointeur vers le tableau de valeurs booléennes dans lequel les actions doivent être écrites.
• actions_len – Un pointeur vers l'entier dans lequel écrire la longueur du tableau de sortie.

void qf_ferm_op_get_modes(const QfFermionOperator *op, uint32_t **modes_out, uint64_t *modes_len)

Fournit un accès en lecture seule aux indices de mode sur lesquels l'opérateur agit.

Exemple

 1uint64_t num_terms = 2;
 2uint64_t num_actions = 2;
 3bool actions[2] = {true, false};
 4uint32_t modes[2] = {0, 1};
 5QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 6uint32_t boundaries[3] = {0, 0, 2};
 7QfFermionOperator *op =
 8    qf_ferm_op_new(num_terms, num_actions, coeffs, actions, modes, boundaries);
 9
10QkComplex64 *modes_out;
11uint64_t *modes_len;
12
13qf_ferm_op_get_modes(op, &modes_out, &modes_len);
14
15assert(modes_len == 2);

Paramètres

• op – Un pointeur vers l'opérateur fermionique dont on souhaite accéder aux modes.
• modes_out – Un pointeur vers le tableau de valeurs booléennes dans lequel écrire les modes.
• modes_len – Un pointeur vers l'entier dans lequel doit être écrite la longueur du tableau de sortie.

void qf_ferm_op_get_boundaries(const QfFermionOperator *op, size_t **boundaries_out, uint64_t *boundaries_len)

Permet un accès en lecture seule aux index indiquant les limites entre les termes d'opérateur.

Exemple

 1uint64_t num_terms = 2;
 2uint64_t num_actions = 2;
 3bool actions[2] = {true, false};
 4uint32_t modes[2] = {0, 1};
 5QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 6uint32_t boundaries[3] = {0, 0, 2};
 7QfFermionOperator *op =
 8    qf_ferm_op_new(num_terms, num_actions, coeffs, actions, modes, boundaries);
 9
10QkComplex64 *boundaries_out;
11uint64_t *boundaries_len;
12
13qf_ferm_op_get_boundaries(op, &boundaries_out, &boundaries_len);
14
15assert(boundaries_len == 3);

Paramètres

• op – Un pointeur vers l'opérateur fermionique dont il faut accéder aux limites.
• boundaries_out – Un pointeur vers le tableau de valeurs booléennes dans lequel les limites doivent être écrites.
• boundaries_len – Un pointeur vers l'entier dans lequel doit être écrite la longueur du tableau de sortie.

QfFermionOperator *qf_ferm_op_zero(void)

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

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

Exemple

1QfFermionOperator *zero = qf_ferm_op_zero();
2
3QfFermionOperator *op_plus_zero = qf_ferm_op_add(op, zero);
4
5assert(qf_ferm_op_equal(op, op_plus_zero));

Retours

Un pointeur vers l'opérateur créé.

QfFermionOperator *qf_ferm_op_one(void)

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

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

Exemple

1QfFermionOperator *one = qf_ferm_op_one();
2
3QfFermionOperator *op_times_one = qf_ferm_op_compose(op, one);
4
5assert(qf_ferm_op_equal(op, op_times_one));

Retours

Un pointeur vers l'opérateur créé.

bool qf_ferm_op_has_groups(const QfFermionOperator *op)

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

Exemple

1QfFCIDump *fcidump = qf_fcidump_from_file("molecule.fcidump");
2QfFermionOperator *op = qf_ferm_op_from_fcidump(fcidump);
3
4bool has_groups = qf_ferm_op_has_groups(op);
5
6assert(!has_groups);

Paramètres

• op – Un pointeur vers l'opérateur fermionique à vérifier.

Retours

Vérifier si l'opérateur fourni possède un attribut groups .

uint32_t qf_ferm_op_num_groups(const QfFermionOperator *op)

Récupère le nombre de groupes d'un opérateur.

Exemple

1QfFCIDump *fcidump = qf_fcidump_from_file("molecule.fcidump");
2QfFermionOperator *op = qf_ferm_op_from_fcidump(fcidump);
3
4uint32_t num_groups = qf_ferm_op_num_groups(op);

Paramètres

• op – Un pointeur vers l'opérateur fermionique dont il faut obtenir le nombre de groupes.

Retours

Le nombre d'indices de groupe issus de l'attribut groups de l'opérateur.

void qf_ferm_op_group_weights(const QfFermionOperator *op, double *weights_out)

Calcule la moyenne de la valeur absolue du coefficient de chaque groupe.

La i-ième entrée correspond à la somme de abs(coeff) sur les termes du groupe i, divisée par le nombre de termes de ce groupe. Il s'agit du poids d'échantillonnage d'une formule de produit aléatoire (par exemple qDRIFT ) qui prélève des groupes entiers plutôt que des termes individuels, et qui est calculé en un seul passage sur l'opérateur plutôt qu'en réduisant qf_ferm_op_get_coeffs() et qf_ferm_op_get_groups() (une valeur par terme non regroupé ) du côté de l'appelant.

Exemple

 1uint64_t num_terms = 4;
 2uint64_t num_actions = 8;
 3bool actions[8] = {true, false, true, false, true, false, true, false};
 4uint32_t modes[8] = {0, 1, 2, 3, 1, 0, 3, 2};
 5QkComplex64 coeffs[4] = {{1.0, 0.0}, {2.0, 0.0}, {-1.0, 0.0}, {-2.0, 0.0}};
 6uint32_t boundaries[5] = {0, 2, 4, 6, 8};
 7QfFermionOperator *op =
 8    qf_ferm_op_new(num_terms, num_actions, coeffs, actions, modes, boundaries);
 9
10uint32_t groups_in[4] = {0, 1, 0, 1};
11qf_ferm_op_set_groups(op, groups_in, num_terms);
12
13double weights[2];
14qf_ferm_op_group_weights(op, weights);
15
16assert(weights[0] == 1.0);
17assert(weights[1] == 2.0);

Paramètres

• op – Un pointeur vers l'opérateur fermionique dont il faut calculer les poids de groupe.
• weights_out – Un pointeur vers le tableau de nombres doubles dans lequel les poids doivent être écrits. Doit être dimensionné selon :c:funcqf_ferm_op_num_groups:.

void qf_ferm_op_get_groups(const QfFermionOperator *op, uint32_t **groups_out, uint64_t *groups_len)

Récupère les indices de groupe pour tous les termes de l'opérateur.

Exemple

1QfFermionOperator *op = ...;
2uint32_t *groups_out;
3uint32_t groups_len;
4
5qf_ferm_op_get_groups(op, &groups_out, &groups_len);

Paramètres

• op – Un pointeur vers l'opérateur fermionique dont on souhaite obtenir les indices de groupe.
• groups_out – Un pointeur vers le tableau d'entiers dans lequel écrire les indices des groupes.
• groups_len – Un pointeur vers l'entier dans lequel écrire la longueur du tableau de sortie.

void qf_ferm_op_set_groups(QfFermionOperator *op, const uint32_t *groups_in, uint64_t groups_len)

Définit l'attribut groups de l'opérateur fourni.

Exemple

1QfFermionOperator *op = ...;
2
3uint32_t num_terms = 4;
4uint32_t groups_in[4] = {0, 1, 0, 1};
5qf_ferm_op_set_groups(op, groups_in, num_terms);

Paramètres

• op – Un pointeur vers l'opérateur fermionique dont l'attribut groups doit être écrit.
• groups_in – Un pointeur vers le tableau d'entiers groups dans lequel l'opérateur doit écrire.
• groups_len – Le nombre d'éléments du tableau groups_in .

void qf_ferm_op_del_groups(QfFermionOperator *op)

Supprime l'attribut groups de l'opérateur indiqué.

Exemple

1QfFermionOperator *op = ...;
2
3qf_ferm_op_del_groups(op);

Paramètres

• op – Un pointeur vers l'opérateur fermionique dont l'attribut groups doit être supprimé.

void qf_ferm_op_split_out_groups(const QfFermionOperator *op, const uint32_t *group_indices, uint64_t num_indices, QfFermionOperator **group_ops_out)

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

Un index en double dans group_indices est écrit une fois par occurrence dans group_ops_out. Demander uniquement un petit nombre de groupes parmi un ensemble beaucoup plus vaste revient nettement moins cher que de tous les demander, car les termes appartenant à un groupe qui n'est pas demandé sont ignorés plutôt que d'être ajoutés n'importe où.

Exemple

 1uint64_t num_terms = 4;
 2uint64_t num_actions = 8;
 3bool actions[8] = {true, false, true, false, true, false, true, false};
 4uint32_t modes[8] = {0, 1, 2, 3, 1, 0, 3, 2};
 5QkComplex64 coeffs[4] = {{1.0, 0.0}, {1.0, 0.0}, {1.0, 0.0}, {1.0, 0.0}};
 6uint32_t boundaries[5] = {0, 2, 4, 6, 8};
 7QfFermionOperator *op =
 8    qf_ferm_op_new(num_terms, num_actions, coeffs, actions, modes, boundaries);
 9
10uint32_t groups_in[4] = {0, 1, 0, 1};
11qf_ferm_op_set_groups(op, groups_in, num_terms);
12
13// build every group, in index order
14QfFermionOperator *group_ops[2];
15qf_ferm_op_split_out_groups(op, NULL, 0, group_ops);
16
17// build only group 1
18uint32_t group_indices[1] = {1};
19QfFermionOperator *group_op[1];
20qf_ferm_op_split_out_groups(op, group_indices, 1, group_op);

Paramètres

• op – Un pointeur vers l'opérateur fermionique dont on groups souhaite extraire la composante.
• group_indices – Un pointeur vers le tableau des indices de groupe pour lesquels il faut créer des opérateurs, dans l'ordre de sortie souhaité. C'est possible NULL; dans ce cas, chaque groupe est construit selon l'ordre des indices (ce qui revient à passer chaque indice de 0 à :c:func:qf_ferm_op_num_groups - 1).
• num_indices – Le nombre d'indices dans le tableau group_indices . Ignoré si est group_indices NULL.
• group_ops_out – Un pointeur vers le tableau de :c:struct:QfFermionOperator dans lequel doivent être écrits les opérateurs pour chaque groupe demandé. Doit être dimensionné à num_indices lorsque est group_indices différent de NULL, ou à :c:func:qf_ferm_op_num_groups lorsqu'il est égal à NULL.

void qf_ferm_op_add_term(QfFermionOperator *op, uint64_t num_actions, const bool *actions, const uint32_t *modes, const QkComplex64 *coeff)

Ajoute un terme à un opérateur existant.

Un argument de type pointeur peut être NULL si et seulement si sa longueur correspondante est égale à zéro.

Exemple

 1QfFermionOperator *one = qf_ferm_op_one();
 2
 3QfFermionOperator *op = qf_ferm_op_zero();
 4bool actions[0] = {};
 5uint32_t modes[0] = {};
 6QkComplex64 coeff = {1.0, 0.0};
 7
 8qf_ferm_op_add_term(op, 0, actions, modes, &coeff);
 9
10assert(qf_ferm_op_equal(op, one));

Paramètres

• op – Un pointeur vers l'opérateur fermionique à modifier.
• num_actions – La longueur du tableau « actions ».
• actions – Un pointeur vers un tableau d'actions. La longueur de ce tableau devrait être de num_actions.
• modes – Un pointeur vers un tableau de modes d'action. La longueur de ce tableau devrait être de num_actions.
• coeff – Un pointeur vers le coefficient complexe.

QfFermionOperator *qf_ferm_op_add(const QfFermionOperator *left, const QfFermionOperator *right)

Additionne deux opérandes.

Exemple

1QfFermionOperator *one = qf_ferm_op_one();
2QfFermionOperator *zero = qf_ferm_op_zero();
3
4QfFermionOperator *result = qf_ferm_op_add(one, zero);
5
6assert(qf_ferm_op_equal(result, one));

Paramètres

• gauche – Un pointeur vers l'opérateur gauche.
• à droite – Un pointeur vers l'opérateur « à droite ».

Retours

Un pointeur vers l'opérateur obtenu.

QfFermionOperator *qf_ferm_op_mul(const QfFermionOperator *op, const QkComplex64 *scalar)

Multiplie un opérateur par un scalaire.

Exemple

 1QfFermionOperator *one = qf_ferm_op_one();
 2QkComplex64 coeff = {2.0, 0.0};
 3QfFermionOperator *result = qf_ferm_op_mul(one, &coeff);
 4
 5QfFermionOperator *expected = qf_ferm_op_zero();
 6bool actions[0] = {};
 7uint32_t modes[0] = {};
 8qf_ferm_op_add_term(expected, 0, actions, modes, &coeff);
 9
10assert(qf_ferm_op_equal(result, expected));

Paramètres

• op – Un pointeur vers l'opérateur.
• scalaire – Un pointeur vers le scalaire.

Retours

Un pointeur vers l'opérateur obtenu.

QfFermionOperator *qf_ferm_op_compose(const QfFermionOperator *left, const QfFermionOperator *right)

Combine deux opérateurs entre eux.

Exemple

1QfFermionOperator *one = qf_ferm_op_one();
2QfFermionOperator *zero = qf_ferm_op_zero();
3
4QfFermionOperator *result = qf_ferm_op_compose(one, zero);
5
6assert(qf_ferm_op_equal(result, zero));

Paramètres

• gauche – Un pointeur vers l'opérateur gauche.
• à droite – Un pointeur vers l'opérateur « à droite ».

Retours

Un pointeur vers l'opérateur obtenu.

QfFermionOperator *qf_ferm_op_adjoint(const QfFermionOperator *op)

Renvoie le conjugué hermitien (ou adjoint) d'un opérateur.

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

• les actions de chaque terme inversent leur ordre et alternent entre création et annihilation
• les coefficients sont les conjugués complexes

Exemple

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions[0] = {};
 3uint32_t modes[0] = {};
 4QkComplex64 coeff = {0.0, 1.0};
 5qf_ferm_op_add_term(op, 0, actions, modes, &coeff);
 6
 7QfFermionOperator *adjoint = qf_ferm_op_adjoint(op);
 8
 9QfFermionOperator *expected = qf_ferm_op_zero();
10QkComplex64 coeff_adj = {0.0, -1.0};
11qf_ferm_op_add_term(expected, 0, actions, modes, &coeff_adj);
12
13assert(qf_ferm_op_equal(adjoint, expected));

Paramètres

• op – Un pointeur vers l'opérateur.

Retours

Un pointeur vers l'opérateur créé.

void qf_ferm_op_ichop(QfFermionOperator *op, double atol)

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

Exemple

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions[0] = {};
 3uint32_t modes[0] = {};
 4QkComplex64 coeff = {1e-8};
 5qf_ferm_op_add_term(op, 0, actions, modes, &coeff);
 6
 7qf_ferm_op_ichop(op, 1e-6);
 8
 9QfFermionOperator *expected = qf_ferm_op_zero();
10
11assert(qf_ferm_op_equal(op, expected));

Paramètres

• op – Un pointeur vers l'opérateur.
• atol – Tolérance absolue pour la troncature des coefficients.

QfFermionOperator *qf_ferm_op_simplify(const QfFermionOperator *op, double atol)

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 (exactement comme qf_ferm_op_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 qf_ferm_op_ichop() tronquer des termes dont la somme donne une valeur absolue de coefficient qui ne devrait pas être tronquée :

 1uint64_t num_terms = 100000;
 2uint64_t num_actions = 0;
 3bool actions[0] = {};
 4uint32_t modes[0] = {};
 5QkComplex64 coeffs[100000];
 6uint32_t boundaries[100001];
 7for (int i = 0; i < 100000; i++) {
 8  coeffs[i].re = 1e-5;
 9  coeffs[i].im = 0.0;
10  boundaries[i] = 0;
11}
12boundaries[100000] = 0;
13QfFermionOperator *op = qf_ferm_op_new(num_terms, num_actions, coeffs,
14                                       actions, modes, boundaries);
15
16QfFermionOperator *canon = qf_ferm_op_simplify(op, 1e-4);
17
18QfFermionOperator *one = qf_ferm_op_one();
19bool canon_is_equal = qf_ferm_op_equiv(canon, one, 1e-6);
20
21qf_ferm_op_ichop(op, 1e-4);
22
23QfFermionOperator *zero = qf_ferm_op_zero();
24bool ichop_is_equal = qf_ferm_op_equiv(op, zero, 1e-6);

Paramètres

• op – Un pointeur vers l'opérateur fermionique à simplifier.
• atol – Tolérance absolue pour la troncature des coefficients.

Retours

Un opérateur équivalent mais simplifié.

QfFermionOperator *qf_ferm_op_normal_ordered(const QfFermionOperator *op, const bool *sandwich)

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 de création apparaissent avant toutes les actions d'annihilation. Au sein de chaque groupe, les modes sur lesquels porte l'action sont classés par ordre lexicographique. Le fait que leur ordre soit croissant ou décroissant dépend de la valeur de l'argument sandwich :

• NULL: les deux groupes sont classés par ordre lexicographique décroissant (par exemple +_1 +_0 -_1 -_0)
• True: les indices les plus grands apparaissent vers le milieu, c'est-à-dire que les actions de création sont classées par ordre lexicographique croissant, tandis que celles d'annihilation sont classées par ordre décroissant (par exemple +_0 +_1 -_1 -_0)
• False: les indices les plus petits apparaissent vers le milieu, c'est-à-dire que les actions de création sont classées par ordre lexicographique décroissant, tandis que celles d'annihilation sont classées par ordre croissant (par exemple +_1 +_0 -_0 -_1)

Exemple

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions[4] = {false, true, false, true};
 3uint32_t modes[4] = {1, 1, 0, 0};
 4QkComplex64 coeff = {1.0, 0.0};
 5qf_ferm_op_add_term(op, 4, actions, modes, &coeff);
 6
 7QfFermionOperator *normal_ordered = qf_ferm_op_normal_ordered(op, NULL);
 8
 9uint64_t num_terms = 4;
10uint64_t num_actions = 8;
11bool actions_exp[8] = {true, false, true, false, true, true, false, false};
12uint32_t modes_exp[8] = {0, 0, 1, 1, 1, 0, 1, 0};
13QkComplex64 coeffs_exp[4] = {
14    {1.0, 0.0}, {-1.0, 0.0}, {-1.0, 0.0}, {-1.0, 0.0}};
15uint32_t boundaries_exp[5] = {0, 0, 2, 4, 8};
16QfFermionOperator *expected =
17    qf_ferm_op_new(num_terms, num_actions, coeffs_exp, actions_exp,
18                   modes_exp, boundaries_exp);
19
20assert(qf_ferm_op_equal(normal_ordered, expected));

Paramètres

• op – Un pointeur vers l'opérateur.
• sandwich – Un pointeur vers une valeur booléenne. Ce pointeur peut être NULL.

Retours

Un pointeur vers l'opérateur créé.

bool qf_ferm_op_is_hermitian(const QfFermionOperator *op, double atol)

Vérifie si un opérateur est hermitien.

Exemple

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions1[2] = {true, false};
 3uint32_t modes1[2] = {0, 1};
 4QkComplex64 coeff1 = {0.0, 1.00001};
 5qf_ferm_op_add_term(op, 2, actions1, modes1, &coeff1);
 6bool actions2[2] = {true, false};
 7uint32_t modes2[2] = {1, 0};
 8QkComplex64 coeff2 = {0.0, -1};
 9qf_ferm_op_add_term(op, 2, actions2, modes2, &coeff1);
10
11assert(qf_ferm_op_is_hermitian(op, 1e-4));
12assert(!qf_ferm_op_is_hermitian(op, 1e-8));

Paramètres

• op – Un pointeur vers l'opérateur fermionique à vérifier.
• atol – Tolérance absolue jusqu'à laquelle les coefficients sont considérés comme égaux.

Retours

Si l'opérateur donné est hermitien.

uint32_t qf_ferm_op_max_rank(const QfFermionOperator *op)

Vérifie le rang maximal d'un opérateur.

Exemple

1QfFermionOperator *op = qf_ferm_op_zero();
2bool actions[4] = {true, false, true, false};
3uint32_t modes[4] = {0, 1, 2, 3};
4QkComplex64 coeff = {1.0, 0.0};
5qf_ferm_op_add_term(op, 4, actions, modes, &coeff);
6
7assert(qf_ferm_op_max_rank(op), 4);

Paramètres

• op – Un pointeur vers l'opérateur fermionique à vérifier.

Retours

Le rang maximal de l'opérateur.

bool qf_ferm_op_conserves_particle_number(const QfFermionOperator *op)

Vérifie si un opérateur préserve le nombre de particules.

Exemple

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions1[2] = {true, false};
 3uint32_t modes1[2] = {0, 1};
 4QkComplex64 coeff1 = {0.0, 1.00001};
 5qf_ferm_op_add_term(op, 2, actions1, modes1, &coeff1);
 6bool actions2[2] = {true, false};
 7uint32_t modes2[2] = {1, 0};
 8QkComplex64 coeff2 = {0.0, -1};
 9qf_ferm_op_add_term(op, 2, actions2, modes2, &coeff2);
10
11assert(qf_ferm_op_is_hermitian(op, 1e-4));
12assert(!qf_ferm_op_is_hermitian(op, 1e-8));

Paramètres

• op – Un pointeur vers l'opérateur fermionique à vérifier.

Retours

L'opérateur fourni préserve-t-il le nombre de particules?

bool qf_ferm_op_equal(const QfFermionOperator *left, const QfFermionOperator *right)

Comparer deux opérateurs pour vérifier s'ils sont égaux.

Exemple

1QfFermionOperator *one = qf_ferm_op_one();
2QfFermionOperator *zero = qf_ferm_op_zero();
3
4assert(qf_ferm_op_equal(one, one));
5assert(!qf_ferm_op_equal(one, zero));

Paramètres

• gauche – Un pointeur vers l'opérateur gauche.
• à droite – Un pointeur vers l'opérateur « à droite ».

Retours

Si les deux opérateurs sont égaux.

bool qf_ferm_op_equiv(const QfFermionOperator *left, const QfFermionOperator *right, double atol)

Comparer deux opérateurs pour vérifier s'ils sont équivalents.

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.

Exemple

 1QfFermionOperator *zero = qf_ferm_op_zero();
 2
 3QfFermionOperator *op = qf_ferm_op_zero();
 4bool actions[0] = {};
 5uint32_t modes[0] = {};
 6QkComplex64 coeff = {1e-7, 0.0};
 7qf_ferm_op_add_term(op, 0, actions, modes, &coeff);
 8
 9assert(qf_ferm_op_equiv(op, zero, 1e-6));
10assert(!qf_ferm_op_equiv(op, zero, 1e-8));

Paramètres

• gauche – Un pointeur vers l'opérateur gauche.
• à droite – Un pointeur vers l'opérateur « à droite ».
• atol – Tolérance absolue pour l'équivalence des coefficients.

Retours

Si les deux opérateurs sont équivalents.

size_t qf_ferm_op_len(const QfFermionOperator *op)

Renvoie la longueur (ou le nombre de termes) de l'opérateur fourni.

Exemple

1QfFermionOperator *op = qf_ferm_op_zero();
2bool actions[4] = {true, false, true, false};
3uint32_t modes[4] = {0, 1, 2, 3};
4QkComplex64 coeff = {1.0, 0.0};
5qf_ferm_op_add_term(op, 4, actions, modes, &coeff);
6
7assert(qf_ferm_op_len(op) == 1);

Paramètres

• op – Un pointeur vers l'opérateur fermionique.

Retours

La longueur (ou le nombre de termes) de l'opérateur.

QfExitCode qf_ferm_op_relabel_modes(QfFermionOperator *op, uint64_t num_modes, const uint32_t *permutation)

Renomme les indices de l’opérateur fourni.

Exemple

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions[4] = {true, false, true, false};
 3uint32_t indices[4] = {0, 1, 2, 3};
 4QkComplex64 coeff = {1.0, 0.0};
 5qf_ferm_op_add_term(op, 4, actions, indices, &coeff);
 6
 7uint32_t permutation[4] = {3, 2, 1, 0};
 8
 9QfExitCode exit = qf_ferm_op_relabel_modes(op, 4, permutation);
10
11assert(exit == QfExitCode_Success);

Paramètres

• op – Un pointeur vers l'opérateur fermionique.
• num_modes – Nombre d'indices de mode dans la liste de permutations fournie.
• permutation – La liste des permutations d'index.

Retours

Un code de sortie.

• QfExitCode_Success en cas de réussite
• QfExitCode_DuplicateIndexError si des indices en double ont été détectés dans la permutation
• QfExitCode_IndexError pour toute autre erreur liée aux index, telle que des index non valides.