Skip to main content
IBM Quantum Platform

Funciones de agrupación

Consulte los términos del operador de grupo: utilice la estructura del operador para obtener una explicación detallada de la funcionalidad de este módulo.

Asignación

En lugar de depender siempre de que el usuario facilite los índices de grupo por sí mismo, la API de C ofrece un conjunto de funciones que determinan la información de agrupación de forma automática.

Columna « 1 »
Columna « 2 »
qf_ferm_op_group_terms_by_electronic_structure()Agrupa los términos de un operador según su estructura electrónica.

Análisis

Los índices de grupo no tienen ningún significado intrínseco: solo indican qué términos van juntos, pero nunca por qué. Por consiguiente, ninguna de las funciones que se indican a continuación indica si una agrupación es «correcta» y no existe un único concepto de corrección con respecto al cual se pueda evaluar. Cada una responde a una pregunta concreta y específica sobre una agrupación existente, dejando la interpretación en tus manos. Se proporcionan para que se pueda verificar desde el principio una suposición que haga un consumidor posterior sobre una agrupación, en lugar de tener que pagar por ello en cada llamada.

Dado que estas funciones funcionan con representaciones genéricas de operadores (un concepto que no existe en C), se explican de forma genérica en las tres secciones siguientes. Las funciones concretas que contiene la API de C para las distintas representaciones de los operadores se enumeran al final de esta página.

Cada uno de ellos requiere que el operador realice un seguimiento de los índices de grupo. Comprueba esto primero qf_op_type_has_groups ; si los invocas en un operador sin grupos, la operación se interrumpe.

Media del coeficiente de grupo

qf_op_type_group_coeff_means

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

Precaución

¡La firma de la función aquí es genérica! En el caso real, se sustituirá OpType por una representación real del operador y op_type por su prefijo correspondiente (por ejemplo, ferm_op por QfFermionOperator).

La entrada inúmero -es es la suma de abs(coeff) sobre los términos del grupo i, dividida por el número de términos de ese grupo. Se trata de la ponderación de muestreo de una fórmula de producto aleatoria (por ejemplo, qDRIFT ) que extrae grupos completos en lugar de términos individuales: es la magnitud de un grupo atómico, que constituye la escala relevante, ya que es precisamente la agrupación lo que hace que cada elemento muestreado sea hermitiano y, por lo tanto, que su evolución temporal sea unitaria, en primer lugar.

Se calcula en una sola pasada sobre el operador, en lugar de mediante la reducción de y qf_op_type_get_coeffs ( qf_op_type_get_groups un valor por cada término no agrupado ) en el lado del llamante.

Nota

Un índice de grupo que ningún término tiene un peso de 0.0, lo que hace que quede excluido de la muestra.

Parámetros

  • op : un puntero al operador cuyos grupos se van a reducir.
  • means_out – Un puntero a la matriz de valores de tipo double en la que se escribirán las medias. Debe tener las dimensiones de qf_op_type_num_groups.

Ermiticidad de grupo

qf_op_type_groups_are_hermitian

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

Precaución

¡La firma de la función aquí es genérica! Consulta la advertencia anterior.

Los grupos no asignan ningún significado por sí mismos; esto confirma una convención común, a saber, que cada grupo es hermitiano por separado. Esa es la propiedad en la que se basa una fórmula de producto aleatoria cuando toma muestras de grupos completos, ya que solo un grupo hermitiano tiene una evolución temporal unitaria. Un grupo vacío se considera hermitiano, ya que el operador cero lo es.

Nota

Esto hereda la garantía unidireccional de que qf_op_type_is_hermitian: una entrada true es siempre fiable, mientras que una false entrada solo es fiable para los tipos de operadores cuya forma normal sea una forma canónica genuina. En los demás casos, la comprobación es conservadora y puede indicar false que se trata de un grupo que, de hecho, es hermitiano. Consulta la descripción específica del operador para saber cuál es la que se aplica.

Nota

Esto no implica ni se deduce de qf_op_type_groups_have_uniform_coeffs. El hecho de que los coeficientes sean uniformes no implica que un grupo sea hermitiano, y un grupo hermitiano puede mezclar magnitudes.

Parámetros

  • op : un puntero al operador cuyos grupos se deben comprobar.
  • atol – La tolerancia absoluta hasta la cual se considera que los coeficientes son iguales.
  • hermitian_out – Un puntero a la matriz de valores booleanos en la que se escribirá un indicador por cada grupo. Debe tener las dimensiones de qf_op_type_num_groups.

Uniformidad de los coeficientes del grupo

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)

Precaución

¡La firma de la función aquí es genérica! Consulta la advertencia anterior.

Con abs, se comparan las magnitudes de los coeficientes, que es la hipótesis que qf_op_type_group_coeff_means establece al calcular la media de abs(coeff). Sin ello, los coeficientes deben coincidir exactamente. Cabe señalar que un grupo hermitiano puede, legítimamente, no cumplir la forma más estricta, ya que un par conjugado con coeficientes complejos tiene magnitudes iguales pero coeficientes desiguales. Un grupo vacío o de un solo término es, evidentemente, uniforme.

Nota

Esto no es una forma más débil de qf_op_type_groups_are_hermitian: ninguna de las dos cosas implica a la otra. El hecho de que los coeficientes sean uniformes no implica que un grupo sea hermitiano, y un grupo hermitiano puede mezclar magnitudes.

Parámetros

  • op : un puntero al operador cuyos grupos se deben comprobar.
  • atol – La tolerancia absoluta hasta la cual se considera que los coeficientes son iguales.
  • abs – Indica si se deben comparar las magnitudes de los coeficientes en lugar de los propios coeficientes.
  • uniform_out – Un puntero a la matriz de valores booleanos en la que se escribirá un indicador por cada grupo. Debe tener las dimensiones de qf_op_type_num_groups.

Ejemplo

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

Funciones

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)

Agrupa los términos de un operador según su estructura electrónica.

Esta función rellena automáticamente el atributo groups (véase también qf_ferm_op_get_groups()) del proporcionado, de tal QfFermionOperator forma que se agrupen los términos que satisfacen una perturbación simétrica presente en los hamiltonianos de estructura electrónica.

Precaución

¡El operador proporcionado debe estar ordenado de forma normal! ¡Se trata de una suposición subyacente de la implementación que no se está verificando! Consulta qf_ferm_op_normal_ordered() aquí cómo obtener un operador de esa forma.

Más concretamente, dado un hamiltoniano de estructura electrónica de la forma

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

Esta función agrupará los términos de un cuerpo con simetría permutacional de, (i, j) así como los términos de dos cuerpos con simetría permutacional de (i, j, k, l). En el caso de los términos de dos cuerpos, no se agruparán todas las permutaciones. En cambio, esto determina two_body_physicist_order cómo se agrupan los cuatro índices en pares de dos, dentro de los cuales existen simetrías de permutación:

  • two_body_physicist_order=False (por defecto): (i, l) y (j, k)
  • two_body_physicist_order=True: y (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);

Parámetros

  • op – Un puntero al operador fermiónico ordenado normalmente cuyos términos se van a agrupar.
  • num_modes – El número de modos fermiónicos en el operador.
  • two_body_physicist_order : indica si los términos de dos cuerpos se almacenan en el orden de los físicos.

Devuelve

Un código de salida.

  • QfExitCode_Success en caso de éxito
  • QfExitCode_ValueError si se encuentra un término no válido durante la agrupación.

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)

¿Le ha resultado útil esta página?
Informe de un error, de una errata o solicite contenido en GitHub.