QfMajoranaOperator

QfMajoranaOperator *qf_maj_op_new(uint64_t num_terms, uint64_t num_modes, const QkComplex64 *coeffs, const uint32_t *modes, const uint32_t *boundaries)

Crea un nuevo operador.

Cualquiera de los argumentos de tipo puntero puede ser NULL si y solo si su longitud correspondiente es cero.

Ejemplo

1uint64_t num_terms = 3;
2uint64_t num_modes = 4;
3uint32_t modes[4] = {0, 1, 2, 3};
4QkComplex64 coeffs[3] = {{1.0, 0.0}, {-1.0, 0.0}, {0.0, -1.0}};
5uint32_t boundaries[4] = {0, 0, 2, 4};
6QfMajoranaOperator *op = qf_maj_op_new(num_terms, num_modes, coeffs,
7                                       modes, boundaries);

Parámetros

• num_terms – El número de términos del operador.
• num_modes – El número de modos sumados en todos los términos.
• coeffs : un puntero a una matriz de coeficientes de términos. La longitud de este array debería ser num_terms.
• modos : un puntero a una matriz de modos que abarca todos los términos. La longitud de este array debería ser num_modes.
• límites : un puntero a una matriz que contiene los límites entre los términos. La longitud de este array debería ser num_terms + 1.

void qf_maj_op_free(QfMajoranaOperator *op)

Libera un operador ya existente.

Ejemplo

1QfMajoranaOperator *op = qf_maj_op_one();
2qf_maj_op_free(op);

Parámetros

• op : un puntero al operador de Majorana que se va a liberar.

void qf_maj_op_get_coeffs(const QfMajoranaOperator *op, QkComplex64 **coeffs_out, uint64_t *coeffs_len)

Proporciona acceso de solo lectura a los coeficientes del operador.

Ejemplo

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

Parámetros

• op : un puntero al operador de Majorana cuyos coeficientes se desean consultar.
• coeffs_out : un puntero a la matriz de valores complejos en la que se van a escribir los coeficientes.
• coeffs_len : un puntero a la variable entera en la que se escribirá la longitud de la matriz de salida.

void qf_maj_op_get_modes(const QfMajoranaOperator *op, uint32_t **modes_out, uint64_t *modes_len)

Proporciona acceso de solo lectura a los índices de modo sobre los que actúa el operador.

Ejemplo

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

Parámetros

• op : un puntero al operador de Majorana cuyos modos se desean acceder.
• modes_out – Un puntero a la matriz de valores booleanos en la que se escribirán los modos.
• modes_len – Un puntero al entero en el que se va a escribir la longitud de la matriz de salida.

void qf_maj_op_get_boundaries(const QfMajoranaOperator *op, size_t **boundaries_out, uint64_t *boundaries_len)

Proporciona acceso de solo lectura a los índices que indican los límites entre los términos del operador.

Ejemplo

 1uint64_t num_terms = 2;
 2uint64_t num_modes = 2;
 3uint32_t modes[2] = {0, 1};
 4QkComplex64 coeffs[2] = {{1.0, 0.0}, {0.0, -1.0}};
 5uint32_t boundaries[3] = {0, 0, 2};
 6QfMajoranaOperator *op =
 7    qf_maj_op_new(num_terms, num_modes, coeffs, modes, boundaries);
 8
 9QkComplex64 *boundaries_out;
10uint64_t *boundaries_len;
11
12qf_maj_op_get_boundaries(op, &boundaries_out, &boundaries_len);
13
14assert(boundaries_len == 3);

Parámetros

• op : un puntero al operador de Majorana cuyos límites se desean acceder.
• boundaries_out – Un puntero a la matriz de valores booleanos en la que se escribirán los límites.
• boundaries_len – Un puntero al entero en el que se escribirá la longitud de la matriz de salida.

QfMajoranaOperator *qf_maj_op_zero(void)

Crea el operador de identidad aditiva.

Añadir el operador creado mediante este método a otro no tiene ningún efecto.

Ejemplo

1QfMajoranaOperator *zero = qf_maj_op_zero();
2
3QfMajoranaOperator *op_plus_zero = qf_maj_op_add(op, zero);
4
5assert(qf_maj_op_equal(op, op_plus_zero));

Devuelve

Un puntero al operador creado.

QfMajoranaOperator *qf_maj_op_one(void)

Construye el operador de identidad multiplicativa.

La composición del operador creado mediante este método con otro operador no tiene ningún efecto.

Ejemplo

1QfMajoranaOperator *one = qf_maj_op_one();
2
3QfMajoranaOperator *op_times_one = qf_maj_op_compose(op, one);
4
5assert(qf_maj_op_equal(op, op_times_one));

Devuelve

Un puntero al operador creado.

bool qf_maj_op_has_groups(const QfMajoranaOperator *op)

Comprueba si este operador realiza un seguimiento de los índices de grupo.

Ejemplo

1QfMajoranaOperator *op = ...;
2
3bool has_groups = qf_maj_op_has_groups(op);

Parámetros

• op : un puntero al operador de Majorana que se va a comprobar.

Devuelve

Si el operador proporcionado tiene un atributo groups .

uint32_t qf_maj_op_num_groups(const QfMajoranaOperator *op)

Obtiene el número de grupos de un operador.

Ejemplo

1QfMajoranaOperator *op = ...;
2
3uint32_t num_groups = qf_maj_op_num_groups(op);

Parámetros

• op : un puntero al operador de Majorana cuyo número de grupos se desea obtener.

Devuelve

El número de índices de grupo a partir del atributo groups del operador.

void qf_maj_op_group_weights(const QfMajoranaOperator *op, double *weights_out)

Obtiene la media de la magnitud absoluta del coeficiente de cada grupo.

La entrada inúmero - 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 del peso de muestreo de una fórmula de producto aleatoria (por ejemplo, qDRIFT ) que extrae grupos completos en lugar de términos individuales, y se calcula en una sola pasada por el operador, en lugar de mediante la reducción de y qf_maj_op_get_coeffs() ( qf_maj_op_get_groups() un valor por cada término no agrupado ) en el lado del llamante.

Ejemplo

 1uint64_t num_terms = 4;
 2uint64_t num_modes = 8;
 3uint32_t modes[8] = {0, 1, 2, 3, 1, 0, 3, 2};
 4QkComplex64 coeffs[4] = {{1.0, 0.0}, {2.0, 0.0}, {-1.0, 0.0}, {-2.0, 0.0}};
 5uint32_t boundaries[5] = {0, 2, 4, 6, 8};
 6QfMajoranaOperator *op = qf_maj_op_new(num_terms, num_modes, coeffs, modes, boundaries);
 7
 8uint32_t groups_in[4] = {0, 1, 0, 1};
 9qf_maj_op_set_groups(op, groups_in, num_terms);
10
11double weights[2];
12qf_maj_op_group_weights(op, weights);
13
14assert(weights[0] == 1.0);
15assert(weights[1] == 2.0);

Parámetros

• op : un puntero al operador de Majorana cuyos pesos de grupo se van a calcular.
• weights_out – Un puntero a la matriz de valores de tipo double en la que se escribirán los pesos. Debe tener el tamaño adecuado para :c:funcqf_maj_op_num_groups:.

void qf_maj_op_get_groups(const QfMajoranaOperator *op, uint32_t **groups_out, uint64_t *groups_len)

Obtiene los índices de grupo de todos los términos del operador.

Ejemplo

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

Parámetros

• op : un puntero al operador de Majorana cuyos índices de grupo se desean obtener.
• groups_out – Un puntero a la matriz de enteros en la que se escribirán los índices de los grupos.
• groups_len – Un puntero al entero en el que se escribirá la longitud de la matriz de salida.

void qf_maj_op_set_groups(QfMajoranaOperator *op, const uint32_t *groups_in, uint64_t groups_len)

Establece el atributo groups del operador indicado.

Ejemplo

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

Parámetros

• op : un puntero al operador de Majorana cuyo atributo groups se va a escribir.
• groups_in – Un puntero a la matriz de enteros groups en la que se va a escribir el operador.
• groups_len – El número de elementos del matriz groups_in .

void qf_maj_op_del_groups(QfMajoranaOperator *op)

Elimina el atributo groups del operador indicado.

Ejemplo

1QfMajoranaOperator *op = ...;
2
3qf_maj_op_del_groups(op);

Parámetros

• op : un puntero al operador de Majorana cuyo atributo groups se va a eliminar.

void qf_maj_op_split_out_groups(const QfMajoranaOperator *op, const uint32_t *group_indices, uint64_t num_indices, QfMajoranaOperator **group_ops_out)

Divide este operador en una lista de nuevos operadores en función de su groups atributo.

Un índice duplicado en group_indices se escribe una vez por cada aparición en group_ops_out. Solicitar solo un pequeño número de grupos de entre un total mucho mayor resulta considerablemente más barato que solicitarlos todos, ya que los términos que pertenecen a un grupo que no se ha solicitado se omiten, en lugar de añadirse en cualquier lugar.

Ejemplo

 1uint64_t num_terms = 4;
 2uint64_t num_modes = 8;
 3uint32_t modes[8] = {0, 1, 2, 3, 1, 0, 3, 2};
 4QkComplex64 coeffs[4] = {{1.0, 0.0}, {1.0, 0.0}, {1.0, 0.0}, {1.0, 0.0}};
 5uint32_t boundaries[5] = {0, 2, 4, 6, 8};
 6QfMajoranaOperator *op = qf_maj_op_new(num_terms, num_modes, coeffs, modes, boundaries);
 7
 8uint32_t groups_in[4] = {0, 1, 0, 1};
 9qf_maj_op_set_groups(op, groups_in, num_terms);
10
11// build every group, in index order
12QfMajoranaOperator *group_ops[2];
13qf_maj_op_split_out_groups(op, NULL, 0, group_ops);
14
15// build only group 1
16uint32_t group_indices[1] = {1};
17QfMajoranaOperator *group_op[1];
18qf_maj_op_split_out_groups(op, group_indices, 1, group_op);

Parámetros

• op : un puntero al operador de Majorana del que groups se quiere extraer la componente.
• group_indices – Un puntero a la matriz de índices de grupo para los que se van a crear operadores, en el orden de salida deseado. Puede que sí NULL; en ese caso, cada grupo se construye siguiendo el orden de los índices (lo que equivale a pasar cada índice desde 0 hasta :c:func: qf_maj_op_num_groups``- 1 ).
• num_indices : el número de índices del matriz group_indices . Se ignora si es group_indices NULL.
• group_ops_out – Un puntero a la matriz de :c:struct:QfMajoranaOperator en la que se escribirán los operadores de cada grupo solicitado. Debe ajustarse a num_indices cuando no group_indices sea NULL, o a :c:func:qf_maj_op_num_groups cuando sea NULL.

void qf_maj_op_add_term(QfMajoranaOperator *op, uint64_t num_modes, const uint32_t *modes, const QkComplex64 *coeff)

Añade un término a un operador ya existente.

Cualquiera de los argumentos de tipo puntero puede ser NULL si y solo si su longitud correspondiente es cero.

Ejemplo

1QfMajoranaOperator *one = qf_maj_op_one();
2
3QfMajoranaOperator *op = qf_maj_op_zero();
4uint32_t modes[0] = {};
5QkComplex64 coeff = {1.0, 0.0};
6
7qf_maj_op_add_term(op, 0, modes, &coeff);
8
9assert(qf_maj_op_equal(op, one));

Parámetros

• op : un puntero al operador de Majorana que se va a modificar.
• num_modes – La longitud de la matriz «modes».
• modos : un puntero a una matriz de índices de modos. La longitud de este array debería ser num_modes.
• coeff : un puntero al coeficiente complejo.

QfMajoranaOperator *qf_maj_op_add(const QfMajoranaOperator *left, const QfMajoranaOperator *right)

Suma dos operandos.

Ejemplo

1QfMajoranaOperator *one = qf_maj_op_one();
2QfMajoranaOperator *zero = qf_maj_op_zero();
3
4QfMajoranaOperator *result = qf_maj_op_add(one, zero);
5
6assert(qf_maj_op_equal(result, one));

Parámetros

• izquierda – Un puntero al operador de izquierda.
• derecha – Un puntero al operador de derecha.

Devuelve

Un puntero al operador resultante.

QfMajoranaOperator *qf_maj_op_mul(const QfMajoranaOperator *op, const QkComplex64 *scalar)

Multiplica un operador por un escalar.

Ejemplo

1QfMajoranaOperator *one = qf_maj_op_one();
2QkComplex64 coeff = {2.0, 0.0};
3QfMajoranaOperator *result = qf_maj_op_mul(one, &coeff);
4
5QfMajoranaOperator *expected = qf_maj_op_zero();
6uint32_t modes[0] = {};
7qf_maj_op_add_term(expected, 0, modes, &coeff);
8
9assert(qf_maj_op_equal(result, expected));

Parámetros

• op : un puntero al operador.
• escalar : un puntero al escalar.

Devuelve

Un puntero al operador resultante.

QfMajoranaOperator *qf_maj_op_compose(const QfMajoranaOperator *left, const QfMajoranaOperator *right)

Combina dos operadores entre sí.

Ejemplo

1QfMajoranaOperator *one = qf_maj_op_one();
2QfMajoranaOperator *zero = qf_maj_op_zero();
3
4QfMajoranaOperator *result = qf_maj_op_compose(one, zero);
5
6assert(qf_maj_op_equal(result, zero));

Parámetros

• izquierda – Un puntero al operador de izquierda.
• derecha – Un puntero al operador de derecha.

Devuelve

Un puntero al operador resultante.

QfMajoranaOperator *qf_maj_op_adjoint(const QfMajoranaOperator *op)

Devuelve el conjugado hermitiano (o adjunto) de un operador.

Esto afecta a los términos y coeficientes de la siguiente manera:

• las acciones de cada término invierten su orden
• los coeficientes son conjugados complejos

Ejemplo

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes[0] = {};
 3QkComplex64 coeff = {0.0, 1.0};
 4qf_maj_op_add_term(op, 0, modes, &coeff);
 5
 6QfMajoranaOperator *adjoint = qf_maj_op_adjoint(op);
 7
 8QfMajoranaOperator *expected = qf_maj_op_zero();
 9QkComplex64 coeff_adj = {0.0, -1.0};
10qf_maj_op_add_term(expected, 0, modes, &coeff_adj);
11
12assert(qf_maj_op_equal(adjoint, expected));

Parámetros

• op : un puntero al operador.

Devuelve

Un puntero al operador creado.

void qf_maj_op_ichop(QfMajoranaOperator *op, double atol)

Elimina los términos cuyo coeficiente sea inferior al umbral indicado.

Ejemplo

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes[0] = {};
 3QkComplex64 coeff = {1e-8};
 4qf_maj_op_add_term(op, 0, modes, &coeff);
 5
 6qf_maj_op_ichop(op, 1e-6);
 7
 8QfMajoranaOperator *expected = qf_maj_op_zero();
 9
10assert(qf_maj_op_equal(op, expected));

Parámetros

• op : un puntero al operador.
• atol – La tolerancia absoluta para el truncamiento de coeficientes.

QfMajoranaOperator *qf_maj_op_simplify(const QfMajoranaOperator *op, double atol)

Devuelve un operador equivalente pero simplificado.

El proceso de simplificación suma primero todos los coeficientes que pertenecen a términos iguales y, a continuación, solo conserva aquellos cuyo coeficiente total supera la tolerancia especificada (igual que qf_maj_op_ichop()).

Cuando un operador haya sido manipulado aritméticamente o construido de tal forma que no garantice la unicidad de los términos, se debe llamar a este método antes de aplicar cualquier método que filtre los coeficientes numéricamente pequeños, con el fin de evitar la pérdida de información. Observa el ejemplo siguiente, que muestra cómo se qf_maj_op_ichop() pueden truncar términos cuya suma da como resultado una magnitud de coeficiente total que no debería truncarse:

 1uint64_t num_terms = 100000;
 2uint64_t num_modes = 0;
 3uint32_t modes[0] = {};
 4QkComplex64 coeffs[100000];
 5uint32_t boundaries[100001];
 6for (int i = 0; i < 100000; i++) {
 7  coeffs[i].re = 1e-5;
 8  coeffs[i].im = 0.0;
 9  boundaries[i] = 0;
10}
11boundaries[100000] = 0;
12QfMajoranaOperator *op =
13    qf_maj_op_new(num_terms, num_modes, coeffs, modes, boundaries);
14
15QfMajoranaOperator *canon = qf_maj_op_simplify(op, 1e-4);
16
17QfMajoranaOperator *one = qf_maj_op_one();
18bool canon_is_equal = qf_maj_op_equiv(canon, one, 1e-6);
19
20qf_maj_op_ichop(op, 1e-4);
21
22QfMajoranaOperator *zero = qf_maj_op_zero();
23bool ichop_is_equal = qf_maj_op_equiv(op, zero, 1e-6);

Parámetros

• op : un puntero al operador de Majorana que se va a simplificar.
• atol – La tolerancia absoluta para el truncamiento de coeficientes.

Devuelve

Un operador equivalente, pero simplificado.

QfMajoranaOperator *qf_maj_op_normal_ordered(const QfMajoranaOperator *op, bool ascending, bool reduce)

Devuelve un operador equivalente con términos ordenados normalmente.

El orden normal de un término de operador se define de tal manera que todas las acciones se ordenan lexicográficamente. Que suban o bajen depende del valor del parámetro ascending .

Ejemplo

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes[4] = {0, 2, 1, 3};
 3QkComplex64 coeff = {1.0, 0.0};
 4qf_maj_op_add_term(op, 4, modes, &coeff);
 5
 6QfMajoranaOperator *normal_ordered = qf_maj_op_normal_ordered(op, false, true);
 7
 8QkComplex64 coeff_minus = {-1.0, 0.0};
 9QfMajoranaOperator *expected = qf_maj_op_zero();
10uint32_t modes_exp[4] = {3, 2, 1, 0};
11qf_maj_op_add_term(expected, 4, modes_exp, &coeff_minus);
12
13assert(qf_maj_op_equal(normal_ordered, expected));

Parámetros

• op : un puntero al operador.
• ascendente : si los índices deben subir o bajar.
• reducir : determina si se debe reducir cada término a su forma mínima eliminando las acciones que se elevan al cuadrado a la identidad.

Devuelve

Un puntero al operador creado.

bool qf_maj_op_is_hermitian(const QfMajoranaOperator *op, double atol)

Comprueba si un operador es hermitiano.

Ejemplo

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes1[2] = {0, 1};
 3QkComplex64 coeff1 = {0.0, 1.00001};
 4qf_maj_op_add_term(op, 2, modes1, &coeff1);
 5uint32_t modes2[2] = {0, 1};
 6QkComplex64 coeff2 = {0.0, -1};
 7qf_maj_op_add_term(op, 2, modes2, &coeff2);
 8
 9assert(qf_maj_op_is_hermitian(op, 1e-4));
10assert(!qf_maj_op_is_hermitian(op, 1e-8));

Parámetros

• op : un puntero al operador de Majorana que se va a comprobar.
• atol – La tolerancia absoluta hasta la cual se considera que los coeficientes son iguales.

Devuelve

Si el operador dado es hermitiano.

uint32_t qf_maj_op_max_rank(const QfMajoranaOperator *op)

Comprueba el rango máximo de un operador.

Ejemplo

1QfMajoranaOperator *op = qf_maj_op_zero();
2uint32_t modes[4] = {0, 1, 2, 3};
3QkComplex64 coeff = {1.0, 0.0};
4qf_maj_op_add_term(op, 4, modes, &coeff);
5
6assert(qf_maj_op_max_rank(op), 4);

Parámetros

• op : un puntero al operador de Majorana que se va a comprobar.

Devuelve

El rango máximo del operador.

bool qf_maj_op_is_even(const QfMajoranaOperator *op)

Comprueba si un operador es par.

Ejemplo

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2QkComplex64 coeff = {1.0, 0.0};
 3uint32_t modes1[2] = {0, 1};
 4qf_maj_op_add_term(op, 2, modes1, &coeff);
 5
 6assert(qf_maj_op_is_even(op));
 7
 8uint32_t modes2[1] = {2};
 9qf_maj_op_add_term(op, 2, modes2, &coeff);
10
11assert(!qf_maj_op_is_even(op));

Parámetros

• op : un puntero al operador de Majorana que se va a comprobar.

Devuelve

Si el operador proporcionado es par.

bool qf_maj_op_equal(const QfMajoranaOperator *left, const QfMajoranaOperator *right)

Compara dos operadores para comprobar si son iguales.

Ejemplo

1QfMajoranaOperator *one = qf_maj_op_one();
2QfMajoranaOperator *zero = qf_maj_op_zero();
3
4assert(qf_maj_op_equal(one, one));
5assert(!qf_maj_op_equal(one, zero));

Parámetros

• izquierda – Un puntero al operador de izquierda.
• derecha – Un puntero al operador de derecha.

Devuelve

Si los dos operadores son iguales.

bool qf_maj_op_equiv(const QfMajoranaOperator *left, const QfMajoranaOperator *right, double atol)

Compara dos operadores para ver si son equivalentes.

En este contexto, «equivalencia» significa igualdad aproximada dentro de los límites de la tolerancia absoluta especificada. Para ser más precisos, este método devuelve True, cuando todos los valores absolutos de los coeficientes de la diferencia other - self están por debajo del umbral especificado atol.

Ejemplo

1QfMajoranaOperator *zero = qf_maj_op_zero();
2
3QfMajoranaOperator *op = qf_maj_op_zero();
4uint32_t modes[0] = {};
5QkComplex64 coeff = {1e-7, 0.0};
6qf_maj_op_add_term(op, 0, modes, &coeff);
7
8assert(qf_maj_op_equiv(op, zero, 1e-6));
9assert(!qf_maj_op_equiv(op, zero, 1e-8));

Parámetros

• izquierda – Un puntero al operador de izquierda.
• derecha – Un puntero al operador de derecha.
• atol – La tolerancia absoluta para la equivalencia de coeficientes.

Devuelve

Si los dos operadores son equivalentes.

size_t qf_maj_op_len(const QfMajoranaOperator *op)

Devuelve la longitud (o el número de términos) del operador proporcionado.

Ejemplo

1QfMajoranaOperator *op = qf_maj_op_zero();
2uint32_t modes[4] = {0, 1, 2, 3};
3QkComplex64 coeff = {1.0, 0.0};
4qf_maj_op_add_term(op, 4, modes, &coeff);
5
6assert(qf_maj_op_len(op) == 1);

Parámetros

• op : un puntero al operador de Majorana.

Devuelve

La longitud (o el número de términos) del operador.

QfExitCode qf_maj_op_relabel_modes(QfMajoranaOperator *op, uint64_t num_modes, const uint32_t *permutation)

Reetiqueta los modos del operador proporcionado.

Ejemplo

 1QfMajoranaOperator *op = qf_maj_op_zero();
 2uint32_t modes[4] = {0, 1, 2, 3};
 3QkComplex64 coeff = {1.0, 0.0};
 4qf_maj_op_add_term(op, 4, modes, &coeff);
 5
 6uint32_t permutation[4] = {3, 2, 1, 0};
 7
 8QfExitCode exit = qf_maj_op_relabel_modes(op, 4, permutation);
 9
10assert(exit == QfExitCode_Success);

Parámetros

• op : un puntero al operador de Majorana.
• num_modes : el número de índices de modo en la lista de permutaciones facilitada.
• permutación – La lista de permutaciones de índices.

Devuelve

Un código de salida.

• QfExitCode_Success en caso de éxito
• QfExitCode_DuplicateIndexError si se han encontrado índices duplicados en la permutación
• QfExitCode_IndexError para cualquier otro error relacionado con los índices, como los índices no válidos.