Raggruppamento funzioni

Si veda la documentazione relativa agli operatori di gruppo: utilizzare la struttura degli operatori per una spiegazione dettagliata delle funzionalità di questo modulo.

Assegnazione

Anziché affidarsi sempre all'utente per l'inserimento degli indici di gruppo, l'API C mette a disposizione una serie di funzioni che determinano automaticamente le informazioni relative al raggruppamento.

Rubrica 1	Rubrica 2
`qf_ferm_op_group_terms_by_electronic_structure()`	Raggruppa i termini di un operatore in base alla loro struttura elettronica.

Analisi

Gli indici di gruppo non hanno alcun significato intrinseco: indicano solo quali termini vanno raggruppati, ma non spiegano mai il perché. Di conseguenza, nessuna delle funzioni riportate di seguito indica se un raggruppamento sia “corretto” e non esiste un unico criterio di correttezza rispetto al quale valutare il risultato. Ciascuna risponde a una domanda specifica e circoscritta su un gruppo esistente, lasciando a te il compito di interpretarla. Vengono forniti affinché un'ipotesi formulata da un consumatore a valle riguardo a un raggruppamento possa essere verificata in anticipo, anziché doverne sostenere il costo ad ogni chiamata.

Poiché queste funzioni operano con rappresentazioni generiche degli operatori (un concetto che non esiste in C), vengono illustrate in modo generico nelle tre sezioni seguenti. Le funzioni effettivamente presenti nell'API C per le varie rappresentazioni degli operatori sono elencate in fondo a questa pagina.

Ognuna di esse richiede all'operatore di tenere traccia degli indici di gruppo. Verifica prima qf_op_type_has_groups questo; se li chiami su un operatore senza gruppi, l'operazione viene interrotta.

Media dei coefficienti di gruppo

qf_op_type_group_coeff_means

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

Attenzione

La firma della funzione qui è generica! In un caso reale, verrà sostituito OpType con una rappresentazione operativa effettiva e op_type con il prefisso corrispondente (ad esempio, ferm_op per QfFermionOperator).

La i-esima voce è la somma di abs(coeff) sui termini del gruppo i, divisa per il numero di termini di quel gruppo. Si tratta del peso di campionamento di una formula di prodotto randomizzata (ad esempio, qDRIFT ) che estrae interi gruppi anziché singoli termini: è l’entità di un gruppo atomico, che costituisce la scala rilevante poiché è proprio il raggruppamento a rendere ogni elemento campionato ermitiano e, di conseguenza, la sua evoluzione temporale unitaria.

Viene calcolato in un unico passaggio sull’operatore, anziché riducendo e qf_op_type_get_coeffs ( qf_op_type_get_groups un valore per ciascun termine non raggruppato ) dal lato del chiamante.

Nota

Un indice di gruppo a cui nessun termine è associato ha un peso pari a 0.0, il che lo esclude dal campione.

Parametri

op – Un puntatore all'operatore i cui gruppi devono essere ridotti.
means_out – Un puntatore all'array di valori di tipo double in cui scrivere le medie. Deve essere dimensionato a qf_op_type_num_groups.

Eremiticità di gruppo

qf_op_type_groups_are_hermitian

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

Attenzione

La firma della funzione qui è generica! Si veda l'avvertenza precedente.

I gruppi non attribuiscono alcun significato proprio; ciò conferma una convenzione comune, ovvero che ogni gruppo è separatamente ermitiano. Questa è la proprietà su cui si basa una formula di prodotto randomizzata quando campiona gruppi interi, poiché solo un gruppo ermitiano presenta un’evoluzione temporale unitaria. Un gruppo vuoto è considerato ermitiano, poiché lo è l'operatore zero.

Nota

Ciò eredita la garanzia unilaterale secondo cui qf_op_type_is_hermitian: una voce true è sempre affidabile, mentre una false voce è affidabile solo per i tipi di operatore la cui forma normale è una forma canonica autentica. Per gli altri, il test è prudente e può indicare false che un gruppo sia in realtà ermitiano. Consultare le indicazioni specifiche dell’operatore per verificare quale sia quella applicabile.

Nota

Ciò non implica né è implicito in qf_op_type_groups_have_uniform_coeffs. I coefficienti uniformi non rendono un gruppo ermitiano, e un gruppo ermitiano può presentare grandezze miste.

Parametri

op – Un puntatore all’operatore di cui si devono verificare i gruppi.
atol – La tolleranza assoluta entro la quale i coefficienti sono considerati uguali.
hermitian_out – Un puntatore all'array di valori booleani in cui scrivere un flag per ogni gruppo. Deve essere dimensionato a qf_op_type_num_groups.

Uniformità dei coefficienti di gruppo

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)

Attenzione

La firma della funzione qui è generica! Si veda l'avvertenza precedente.

Con abs, si confrontano i valori dei coefficienti; questa è l’ipotesi che qf_op_type_group_coeff_means formula quando calcola la media di abs(coeff). In assenza di ciò, i coefficienti devono corrispondere esattamente. Si noti che un gruppo ermitiano può legittimamente non soddisfare la forma più rigorosa, poiché una coppia coniugata con coefficienti complessi ha magnitudini uguali ma coefficienti disuguali. Un gruppo vuoto o composto da un unico termine è, ovviamente, uniforme.

Nota

Non si tratta di una forma più debole di qf_op_type_groups_are_hermitian: nessuna delle due implica l’altra. I coefficienti uniformi non rendono un gruppo ermitiano, e un gruppo ermitiano può presentare grandezze miste.

Parametri

op – Un puntatore all’operatore di cui si devono verificare i gruppi.
atol – La tolleranza assoluta entro la quale i coefficienti sono considerati uguali.
abs – Se confrontare i valori assoluti dei coefficienti anziché i coefficienti stessi.
uniform_out – Un puntatore all'array di valori booleani in cui scrivere un flag per ogni gruppo. Deve essere dimensionato a qf_op_type_num_groups.

Esempio

 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]);

Funzioni

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)

Raggruppa i termini di un operatore in base alla loro struttura elettronica.

Questa funzione popola automaticamente l'attributo groups (vedi anche qf_ferm_op_get_groups()) del fornito, QfFermionOperator in modo tale che i termini che soddisfano una perturbazione simmetrica presente negli hamiltoniani della struttura elettronica vengano raggruppati.

Attenzione

L'operatore fornito deve essere ordinato secondo l'ordine normale! Si tratta di un presupposto di fondo dell'implementazione che non viene verificato! Vedi qf_ferm_op_normal_ordered() per sapere come ottenere un operatore di quella forma.

Più concretamente, dato un hamiltoniano della struttura elettronica della forma

\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 \, ,

questa funzione raggrupperà i termini a un corpo con simmetria permutazionale di (i, j) e i termini a due corpi con simmetria permutazionale di (i, j, k, l). Per quanto riguarda i termini a due corpi, non tutte le permutazioni verranno raggruppate. Al contrario, il determina two_body_physicist_order il modo in cui i quattro indici vengono raggruppati in coppie all’interno delle quali esistono simmetrie permutazionali:

two_body_physicist_order=False (impostazione predefinita): (i, l) e (j, k)
two_body_physicist_order=True: e (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);

Parametri

op – Un puntatore all'operatore fermionico in ordine normale i cui termini devono essere raggruppati.
num_modes – Il numero di modi fermionici presenti nell'operatore.
two_body_physicist_order – indica se i termini a due corpi sono memorizzati nell'ordine dei fisici.

Risultati

Un codice di uscita.

QfExitCode_Success in caso di successo
QfExitCode_ValueError se durante il raggruppamento viene rilevato un termine non valido.

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)

Questa pagina è stata utile?

Segnala un bug, un errore di battitura o richiedi contenuti su GitHub.