Skip to main content
IBM Quantum Platform

Fonctions de regroupement

Reportez-vous à la documentation relative aux opérateurs de groupe : consultez la structure des opérateurs pour obtenir une explication détaillée des fonctionnalités de ce module.

Affectation

Plutôt que de compter systématiquement sur l'utilisateur pour fournir lui-même les indices de groupe, l'API C propose un ensemble de fonctions qui déterminent automatiquement les informations de regroupement.

Chronique « 1 »
Chronique « 2 »
qf_ferm_op_group_terms_by_electronic_structure()Regroupe les termes d'un opérateur en fonction de leur structure électronique.

Analyse

Les indices de groupe n'ont aucune signification intrinsèque : ils indiquent simplement quels termes vont ensemble, sans jamais expliquer pourquoi. Par conséquent, aucune des fonctions ci-dessous n'indique si un regroupement est « correct » et il n'existe pas de notion unique de « justesse » à laquelle se référer. Chacune répond à une question précise et bien définie concernant un groupe existant, en vous laissant le soin d'en tirer vos propres conclusions. Ils sont fournis afin de permettre de vérifier dès le départ une hypothèse émise par un consommateur en aval concernant un regroupement, plutôt que de devoir payer à chaque appel.

Comme ces fonctions utilisent des représentations d'opérateurs génériques (une notion qui n'existe pas en C), elles sont expliquées de manière générique dans les trois sections suivantes. Les fonctions réelles contenues dans l'API C pour les différentes représentations des opérateurs sont répertoriées au bas de cette page.

Chacune d'entre elles exige que l'opérateur suive les indices de groupe. Vérifiez d'abord qf_op_type_has_groups cela; si vous les appelez sur un opérateur sans groupes, l'opération est interrompue.

Moyenne des coefficients de groupe

qf_op_type_group_coeff_means

void qf_op_type_group_coeff_means(const OpType *op, double *means_out)

Attention

La signature de cette fonction est générique! Dans le cas réel, sera remplacé OpType par une représentation d'opérateur concrète et op_type par son préfixe correspondant (par exemple, ferm_op pour QfFermionOperator).

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 : c'est l'amplitude d'un groupe atomique, qui constitue l'échelle pertinente, car c'est le regroupement qui rend chaque élément échantillonné hermitien, et donc son évolution temporelle unitaire, en premier lieu.

Il est calculé en un seul passage sur l'opérateur, plutôt qu'en réduisant qf_op_type_get_coeffs et ( qf_op_type_get_groups une valeur par terme non dégroupé ) du côté de l'appelant.

Remarque

Un indice de groupe auquel aucun terme n'est associé a une valeur de 0.0, ce qui l'exclut de l'échantillon.

Paramètres

  • op – Un pointeur vers l’opérateur dont les groupes doivent être réduits.
  • means_out – Un pointeur vers le tableau de types double dans lequel les moyennes doivent être écrites. Doit être dimensionné à qf_op_type_num_groups.

Hermiticité de groupe

qf_op_type_groups_are_hermitian

void qf_op_type_groups_are_hermitian(const OpType *op, double atol, bool *hermitian_out)

Attention

La signature de cette fonction est générique! Voir la mise en garde ci-dessus.

Les groupes ne se dotent pas d'une signification propre; cela permet de vérifier une convention courante, à savoir que chaque groupe est hermitien en soi. C'est la propriété sur laquelle repose une formule de produit aléatoire lorsqu'elle échantillonne des groupes entiers, car seul un groupe hermitien présente une évolution temporelle unitaire. Un groupe vide est considéré comme hermitien, car l'opérateur nul l'est.

Remarque

Cela reprend la garantie unilatérale selon laquelle qf_op_type_is_hermitian: une entrée true est toujours fiable, tandis qu'une entrée false n'est fiable que pour les types d'opérateurs dont la forme normale est une forme canonique véritable. Pour les autres, la vérification est prudente et peut aboutir à un résultat false indiquant qu'un groupe est en réalité hermitien. Consultez les conditions spécifiques de l'opérateur pour savoir lesquelles s'appliquent.

Remarque

Cela n'implique pas et n'est pas non plus sous-entendu par qf_op_type_groups_have_uniform_coeffs. Des coefficients uniformes ne suffisent pas à rendre un groupe hermitien, et un groupe hermitien peut mélanger les amplitudes.

Paramètres

  • op – Un pointeur vers l'opérateur dont les groupes doivent être vérifiés.
  • atol – Tolérance absolue au-delà de laquelle les coefficients ne sont plus considérés comme égaux.
  • hermitian_out – Un pointeur vers le tableau de valeurs booléennes dans lequel écrire un indicateur par groupe. Doit être dimensionné à qf_op_type_num_groups.

Uniformité des coefficients du groupe

qf_op_type_groups_have_uniform_coeffs

void qf_op_type_groups_have_uniform_coeffs(const OpType *op, double atol, bool abs, bool *uniform_out)

Attention

La signature de cette fonction est générique! Voir la mise en garde ci-dessus.

On compare ici les amplitudes des coefficients abs, ce qui correspond à l'hypothèse que qf_op_type_group_coeff_means formule lorsqu'il calcule la moyenne de abs(coeff). Sans cela, les coefficients doivent correspondre exactement. Il convient de noter qu'un groupe hermitien peut légitimement ne pas satisfaire à cette condition plus stricte, puisqu'une paire de conjugués à coefficients complexes présente des amplitudes égales mais des coefficients inégaux. Un groupe vide ou ne comportant qu'un seul terme est, par définition, uniforme.

Remarque

Il ne s'agit pas d'une forme plus faible de qf_op_type_groups_are_hermitian: l'un n'implique pas l'autre. Des coefficients uniformes ne suffisent pas à rendre un groupe hermitien, et un groupe hermitien peut mélanger les amplitudes.

Paramètres

  • op – Un pointeur vers l'opérateur dont les groupes doivent être vérifiés.
  • atol – Tolérance absolue au-delà de laquelle les coefficients ne sont plus considérés comme égaux.
  • abs – Indique s'il faut comparer l'ordre de grandeur des coefficients plutôt que les coefficients eux-mêmes.
  • uniform_out – Un pointeur vers le tableau de valeurs booléennes dans lequel écrire un indicateur par groupe. Doit être dimensionné à qf_op_type_num_groups.

Exemple

 1QfFermionOperator *op = qf_ferm_op_zero();
 2bool actions[2] = {true, false};
 3QkComplex64 coeff = {1.0, 0.0};
 4uint32_t modes_a[2] = {0, 1};
 5qf_ferm_op_add_term(op, 2, actions, modes_a, &coeff);
 6uint32_t modes_b[2] = {1, 0};
 7qf_ferm_op_add_term(op, 2, actions, modes_b, &coeff);
 8
 9uint32_t groups_in[2] = {0, 0};
10assert(qf_ferm_op_set_groups(op, groups_in, 2) == QfExitCode_Success);
11
12double means[1];
13qf_ferm_op_group_coeff_means(op, means);
14assert(means[0] == 1.0);
15
16bool hermitian[1];
17qf_ferm_op_groups_are_hermitian(op, 1e-8, hermitian);
18assert(hermitian[0]);
19
20bool uniform[1];
21qf_ferm_op_groups_have_uniform_coeffs(op, 1e-8, true, uniform);
22assert(uniform[0]);

Fonctions

qf_ferm_op_group_terms_by_electronic_structure

QfExitCode qf_ferm_op_group_terms_by_electronic_structure(QfFermionOperator *op, uint32_t num_modes, bool two_body_physicist_order)

Regroupe les termes d'un opérateur en fonction de leur structure électronique.

Cette fonction remplit automatiquement l'attribut groups (voir également qf_ferm_op_get_groups()) de l'objet fourni, QfFermionOperator de telle sorte que les termes satisfaisant à une perturbation symétrique présente dans les hamiltoniens de structure électronique soient regroupés.

Attention

L'opérateur fourni doit être ordonné selon la norme! Il s'agit d'une hypothèse sous-jacente de la mise en œuvre qui n'est pas vérifiée! Voir qf_ferm_op_normal_ordered() pour savoir comment obtenir un opérateur de cette forme.

Plus concrètement, étant donné un hamiltonien de structure électronique de la forme

H=∑ijcijai†aj+∑ijklcijklai†aj†akal ,\mathcal{H} = \sum_{ij} c_{ij} a^\dagger_i a_j + \sum_{ijkl} c_{ijkl} a^\dagger_i a^\dagger_j a_k a_l \, ,

Cette fonction regroupera les termes à un corps présentant une symétrie de permutation de (i, j) ainsi que les termes à deux corps présentant une symétrie de permutation de (i, j, k, l). En ce qui concerne les termes à deux corps, toutes les permutations ne seront pas regroupées. Au contraire, c'est la qui détermine two_body_physicist_order comment les quatre indices sont regroupés en paires au sein desquelles existent des symétries de permutation :

  • two_body_physicist_order=False (par défaut) : (i, l) et (j, k)
  • two_body_physicist_order=True: et (i, k) (j, l)
1QfFCIDump *fcidump = NULL;
2qf_fcidump_from_file("molecule.fcidump", &fcidump);
3QfFermionOperator *op = qf_ferm_op_from_fcidump(fcidump);
4
5uint32_t num_modes = 2 * qf_fcidump_norb(fcidump);
6
7QfFermionOperator *normal = qf_ferm_op_normal_ordered(op, NULL);
8
9QfExitCode exit = qf_ferm_op_group_terms_by_electronic_structure(normal, num_modes, false);

Paramètres

  • op – Un pointeur vers l'opérateur fermionique ordonné selon l'ordre normal dont les termes doivent être regroupés.
  • num_modes – Nombre de modes fermioniques dans l'opérateur.
  • two_body_physicist_order – indique si les termes à deux corps sont stockés selon l'ordre des physiciens.

Retours

Un code de sortie.

  • QfExitCode_Success en cas de réussite
  • QfExitCode_ValueError si un terme non valide est détecté lors du regroupement.

qf_ferm_op_group_coeff_means

void qf_ferm_op_group_coeff_means(const QfFermionOperator *op, double *means_out)

qf_ferm_op_groups_are_hermitian

void qf_ferm_op_groups_are_hermitian(const QfFermionOperator *op, double atol, bool *hermitian_out)

qf_ferm_op_groups_have_uniform_coeffs

void qf_ferm_op_groups_have_uniform_coeffs(const QfFermionOperator *op, double atol, bool abs, bool *uniform_out)

qf_maj_op_group_coeff_means

void qf_maj_op_group_coeff_means(const QfMajoranaOperator *op, double *means_out)

qf_maj_op_groups_are_hermitian

void qf_maj_op_groups_are_hermitian(const QfMajoranaOperator *op, double atol, bool *hermitian_out)

qf_maj_op_groups_have_uniform_coeffs

void qf_maj_op_groups_have_uniform_coeffs(const QfMajoranaOperator *op, double atol, bool abs, bool *uniform_out)

qf_edge_op_group_coeff_means

void qf_edge_op_group_coeff_means(const QfEdgeVertexOperator *op, double *means_out)

qf_edge_op_groups_are_hermitian

void qf_edge_op_groups_are_hermitian(const QfEdgeVertexOperator *op, double atol, bool *hermitian_out)

qf_edge_op_groups_have_uniform_coeffs

void qf_edge_op_groups_have_uniform_coeffs(const QfEdgeVertexOperator *op, double atol, bool abs, bool *uniform_out)

qf_transfer_op_group_coeff_means

void qf_transfer_op_group_coeff_means(const QfTransferVertexOperator *op, double *means_out)

qf_transfer_op_groups_are_hermitian

void qf_transfer_op_groups_are_hermitian(const QfTransferVertexOperator *op, double atol, bool *hermitian_out)

qf_transfer_op_groups_have_uniform_coeffs

void qf_transfer_op_groups_have_uniform_coeffs(const QfTransferVertexOperator *op, double atol, bool abs, bool *uniform_out)

Cette page a-t-elle été utile ?
Signaler un bogue, une coquille ou proposer du contenu sur GitHub.