Skip to main content
IBM Quantum Platform

Biblioteca de circuitos

La biblioteca de circuitos de Qiskit contiene funciones y componentes de alto nivel para crear circuitos cuánticos de uso común.

Tipos de datos

QkPauliProductRotation

struct QkPauliProductRotation

Una representación de los datos de rotación del producto de Pauli.

Una rotación del producto de Pauli implementa una rotación de alrededor de angle un eje definido por un producto de Pauli sobre len qubits. El vector Pauli se representa aquí en formato ZX mediante dos matrices booleanas que representan los componentes Z y X.

bool *z

Puntero a una matriz len de longitud * de componentes de tipo Z.

bool *x

Puntero a una matriz len de longitud x con x componentes.

size_t len

El número de términos de Pauli.

QkParam *ángulo

El ángulo de rotación.

QkPauliProductMeasurement

struct QkPauliProductMeasurement

Una representación de los datos de medición del producto de Pauli.

Una medición del producto de Pauli implementa una proyección sobre el espacio propio del producto de Pauli definido en len los qubits. El vector Pauli se representa aquí en formato ZX mediante dos matrices booleanas que representan los componentes Z y X, y puede incluir un signo menos, indicado por flip_outcome.

bool *z

Puntero a una matriz len de longitud * de componentes de tipo Z.

bool *x

Puntero a una matriz len de longitud x con x componentes.

size_t len

El número de términos de Pauli.

bool resultado_del_lanzamiento

Si el resultado de la medición tiene signo negativo.

QkNLocalSettings

struct QkNLocalSettings

Parámetros para generar un circuito variacional n-local.

Esto incluye la estrategia de entrelazamiento (entanglement_strategy), el número de repeticiones de las capas de rotación y entrelazamiento (reps), el prefijo de parámetros para las puertas que tienen parámetros (parameter_prefix), si se desea añadir barreras después de cada capa (insert_barriers) y si se desea omitir la última capa (skip_final_rotation_layer)

Es responsabilidad del usuario que los datos sean coherentes; véase también la sección siguiente sobre seguridad.

Seguridad

parameter_prefix Debe ser un puntero a la memoria que contenga un terminador nulo válido al final de la cadena. Además, debe ser válido para la lectura de bytes hasta el carácter de terminación NUL, incluido este.

QkEntanglementStrategy entanglement_strategy

La estrategia de entrelazamiento que se utilizará en el circuito generado. Consulte QkEntanglementStrategy para obtener más detalles.

size_t reps

Especifica la frecuencia con la que se repiten los bloques de rotación y los bloques de entrelazamiento.

const char *prefijo_parámetro

El prefijo utilizado para los parámetros predeterminados generados.

bool insert_barriers

En ese caso true, se insertan barreras entre cada capa. Si false, no se insertan barreras.

bool omitir_rotación_final_capa

Si se añade una última capa de rotación al circuito.

QkEntanglementStrategy

enum QkEntanglementStrategy

Enumeración que representa todas las estrategias posibles para n bloques de entrelazamiento local.

Valores:

enumerador QkEntanglementStrategy_Full

Entrelazamiento en el que cada qubit está entrelazado con todos los demás.

enumerador QkEntanglementStrategy_Linear

Entrelazamiento en el que el qubit ii está entrelazado con el qubit i+1i + 1 para todos los i∈{0,1,...,n−2}i \in \{0, 1, ... , n - 2\}, siendo nn el número total de qubits.

enumerador QkEntanglementStrategy_ReverseLinear

Entrelazamiento en el que el qubit ii está entrelazado con el qubit i+1i + 1 para todos los i∈{n−2,n−3,...,1,0}i \in \{n-2, n-3, ... , 1, 0\}, siendo nn el número total de qubits.

enumerador QkEntanglementStrategy_Circular

Entrelazamiento que se comporta igual que el entrelazamiento lineal, pero con un entrelazamiento adicional entre el primer y el último qubit antes de la parte lineal.

enumerador QkEntanglementStrategy_Pairwise

Entrelazamiento en el que una capa contiene un qubit ii entrelazado con el qubit i+1i + 1, para todos los valores pares de ii, y, a continuación, una segunda capa en la que un qubit ii está entrelazado con el qubit i+1i + 1, para todos los valores impares de ii.

enumerador QkEntanglementStrategy_Sca

Entrelazamiento desplazado-circular-alternante. Se trata de una versión generalizada y modificada del circuito 14 propuesto en Sim et al.

Consiste en un entrelazamiento circular en el que el entrelazamiento «largo» que conecta el primer qubit con el último se desplaza un qubit en cada bloque.

Además, los roles de los qubits de control y de objetivo se intercambian en cada bloque (por lo tanto, se alternan).

Funciones

qk_circuit_library_iqp

QkCircuit *qk_circuit_library_iqp(uint32_t num_qubits, const int64_t *interactions, bool check_input)

Genera un circuito de polinomio cuántico instantáneo (IQP) a partir de una matriz de interacción entera.

La interactions matriz se interpreta como una matriz n × n ordenada por filas de enteros de 64 bits, donde n = num_qubits. Los elementos diagonales establecen potencias de fase de tipo T, y el triángulo superior codifica las interacciones CPhase de dos qubits.

Seguridad

Si num_qubits > 0, interactions debe ser un puntero válido y no nulo a al menos valores num_qubits * num_qubits int64_t contiguos en orden de filas. La memoria a la que apunta interactions debe estar correctamente alineada, ser legible durante toda la duración de esta llamada y no tener alias mutables. Si se pasa un puntero no válido o un búfer demasiado pequeño, se produce un comportamiento indefinido.

Parámetros

  • num_qubits – Número de qubits lógicos (n). Debe coincidir con la dimensión de la interactions matriz.
  • interacciones – Puntero a una matriz de tipo n × n «row-major» de tipo int64_t. Solo puede ser NULL si num_qubits == 0.
  • check_input – Cuando se trueejecuta, esta función comprueba que la matriz sea simétrica y devuelve un valor NULL si no lo es. En ese caso false, no se realiza ninguna validación adicional.

Devuelve

Una matriz recién asignada QkCircuit* en caso de éxito (el llamante debe liberarla con qk_circuit_free), o NULL si num_qubits > 0 y interactions es NULL, o si check_input es true y la matriz no es simétrica.

qk_circuit_library_random_iqp

QkCircuit *qk_circuit_library_random_iqp(uint32_t num_qubits, int64_t seed)

Genera un circuito aleatorio de polinomio cuántico instantáneo (IQP).

Esto crea internamente una matriz de interacción simétrica aleatoria de números enteros y la utiliza para construir un circuito IQP, imitando el constructor de qiskit.circuit.library.IQP Python.

Parámetros

  • num_qubits – Número de qubits.
  • semilla – semilla del generador de números aleatorios. Si es negativo, la entropía se obtiene del sistema operativo; en caso contrario, se utiliza el valor proporcionado como semilla determinista.

Devuelve

Una variable recién asignada QkCircuit* (el llamante debe liberarla con qk_circuit_free).

qk_circuit_library_n_local

QkCircuit *qk_circuit_library_n_local(uint32_t num_qubits, const QkGate *rotation_blocks, size_t rotation_blocks_size, const QkGate *entanglement_blocks, size_t entanglement_blocks_size, const QkNLocalSettings *settings)

Construye un circuito variacional n-local.

La estructura del circuito n-local está formada por capas alternas de rotación y entrelazamiento. En ambas capas, los bloques de circuito parametrizados actúan sobre el circuito de una forma definida. En la capa de rotación, los bloques se aplican apilados unos encima de otros, mientras que en la capa de entrelazamiento se aplican según la estrategia entanglement . Los bloques del circuito pueden tener tamaños arbitrarios (siempre que sean menores o iguales al número de qubits del circuito). Cada capa se repite reps veces y, por defecto, se añade una capa final de rotación.

Por ejemplo, un bloque de rotación en 2 qubits y un bloque de entrelazamiento en 4 qubits que utiliza QkEntanglementStrategy_Linear entrelazamiento dan como resultado el siguiente circuito.

┌──────┐ ░ ┌──────┐                      ░ ┌──────┐
┤0     ├─░─┤0     ├──────────────── ... ─░─┤0     ├
│  Rot │ ░ │      │┌──────┐              ░ │  Rot │
┤1     ├─░─┤1     ├┤0     ├──────── ... ─░─┤1     ├
├──────┤ ░ │  Ent ││      │┌──────┐      ░ ├──────┤
┤0     ├─░─┤2     ├┤1     ├┤0     ├ ... ─░─┤0     ├
│  Rot │ ░ │      ││  Ent ││      │      ░ │  Rot │
┤1     ├─░─┤3     ├┤2     ├┤1     ├ ... ─░─┤1     ├
├──────┤ ░ └──────┘│      ││  Ent │      ░ ├──────┤
┤0     ├─░─────────┤3     ├┤2     ├ ... ─░─┤0     ├
│  Rot │ ░         └──────┘│      │      ░ │  Rot │
┤1     ├─░─────────────────┤3     ├ ... ─░─┤1     ├
└──────┘ ░                 └──────┘      ░ └──────┘

|                                 |
+---------------------------------+
       repeated reps times

Entrelazamiento:

El entrelazamiento describe las conexiones entre las puertas de la capa de entrelazamiento. Por ejemplo, en el caso de una puerta de dos qubits, el entrelazamiento contiene pares de qubits sobre los que debe actuar la puerta, p. ej., [[ctrl0, target0], [ctrl1, target1], ...]. Para obtener más información sobre las estrategias de entrelazamiento disponibles, consulta QkEntanglementStrategy.

Ejemplo

size_t num_qubits = 2;
QkGate rotation_blocks[1] = {QkGate_H};
QkGate entanglement_blocks[1] = {QkGate_CRX};

QkNLocalSettings settings = qk_circuit_library_n_local_settings_default();
settings.reps = 2;
// For this example we use QkEntanglementStrategy_Linear since
// the default is QkEntanglementStrategy_Full
settings.entanglement_strategy = QkEntanglementStrategy_Linear;

QkCircuit *qc = qk_circuit_library_n_local(num_qubits, rotation_blocks, 1,
                                           entanglement_blocks, 1, &settings);

qk_circuit_free(qc);

Seguridad

  • El comportamiento no está definido si no rotation_blocks es un puntero válido y no nulo a una secuencia de elementos consecutivos rotation_blocks_size de StandardGate.
  • El comportamiento no está definido si no entanglement_blocks es un puntero válido y no nulo a una secuencia de elementos consecutivos entanglement_blocks_size de StandardGate.
  • El comportamiento es indefinido si no settings es un puntero válido y no nulo.

Parámetros

  • num_qubits – El número de qubits del circuito.
  • rotation_blocks – Los bloques utilizados en las capas de rotación.
  • rotation_blocks_size – Longitud de la matriz de bloques de rotación proporcionada.
  • entanglement_blocks – Los bloques utilizados en las capas de entrelazamiento.
  • entanglement_blocks_size – Longitud de la lista de bloques de entrelazamiento proporcionada.
  • configuración : un QkNLocalSettings puntero que representa la configuración que se aplicará al circuito generado. Si es así NULL, se utilizarán los ajustes predeterminados; consulta QkNLocalSettings para obtener más detalles.

Devuelve

Un puntero al circuito generado.

qk_circuit_library_n_local_settings_default

QkNLocalSettings qk_circuit_library_n_local_settings_default(void)

Generar opciones predeterminadas para qk_circuit_library_n_local.

Devuelve

Un objeto QkNLocalSettings con la configuración predeterminada.

qk_pauli_product_rotation_clear

void qk_pauli_product_rotation_clear(QkPauliProductRotation *inst)

Borrar los datos internos de los archivos asignados por Rust QkPauliProductRotation.

Esto libera la memoria de las matrices z x y y libera el angle. Esta función solo debe invocarse para QkPauliProductRotation objetos cuyos datos hayan sido rellenados por Rust.

Ejemplo

// let `circuit` be a QkCircuit* and `index` a size_t at the position of a QkPauliProductRotation
QkPauliProductRotation inst;

// query the QkPauliProductRotation data
assert(qk_circuit_operation_kind(circuit, index) == QkOperationKind_PauliProductRotation);
qk_circuit_inst_pauli_product_rotation(circuit, index, &inst);

// do something with `inst`, and then clear the Rust-allocated data
qk_pauli_product_rotation_clear(&inst);

Por el contrario, no se debe llamar a esta función si C ya se encarga de borrar los datos.

bool z[4] = {false, false, true, true};
bool x[4] = {false, true, true, false};
QkParam *angle = qk_param_from_double(1.0);
QkPauliProductRotation rotation = {z, x, 4, angle};

// since this data is allocated by C, we do not call `qk_pauli_product_rotation_clear(&rotation)`!
qk_param_free(angle);

Seguridad

El comportamiento es indefinido si no inst es un puntero válido y no nulo a un QkPauliProductRotation, o si los datos internos de QkPauliProductRotation son incoherentes.

Parámetros

  • inst – Un puntero al elemento QkPauliProductRotation que se va a borrar.

qk_pauli_product_measurement_clear

void qk_pauli_product_measurement_clear(QkPauliProductMeasurement *inst)

Borrar los datos internos de los archivos asignados por Rust QkPauliProductMeasurement.

Esto libera la memoria de las matrices z x y. Esta función solo debe invocarse para QkPauliProductMeasurement objetos cuyos datos hayan sido rellenados por Rust.

Ejemplo

// let `circuit` be a QkCircuit* and `index` a size_t at the position
// of a QkPauliProductMeasurement
QkPauliProductMeasurement inst;

// query the QkPauliProductMeasurement data
assert(qk_circuit_operation_kind(circuit, index) == QkOperationKind_PauliProductMeasurement);
qk_circuit_inst_pauli_product_measurement(circuit, index, &inst);

// do something with `inst`, and then clear the Rust-allocated data
qk_pauli_product_measurement_clear(&inst);

Por el contrario, no se debe llamar a esta función si C ya se encarga de borrar los datos.

bool z[4] = {false, false, true, true};
bool x[4] = {false, true, true, false};
QkPauliProductMeasurement inst = {z, x, 4, true};

// since this data is allocated by C, we do not call `qk_pauli_product_measurement_clear(&inst)`

Seguridad

El comportamiento es indefinido si no inst es un puntero válido y no nulo a un QkPauliProductMeasurement, o si los datos internos de QkPauliProductMeasurement son incoherentes.

Parámetros

  • inst – Un puntero al elemento QkPauliProductMeasurement que se va a borrar.

qk_circuit_library_quantum_volume

QkCircuit *qk_circuit_library_quantum_volume(uint32_t num_qubits, size_t depth, int64_t seed)

Generar un circuito modelo Quantum Volume

Los circuitos modelo son ejemplos aleatorios de circuitos utilizados para medir la métrica del volumen cuántico, tal y como se introduce en [1]. Los circuitos modelo consisten en capas de elementos aleatorios de Haar de SU(4) aplicados entre pares correspondientes de qubits en una bipartición aleatoria.

Esta función es multihilo y, de forma predeterminada, iniciará un grupo de subprocesos con un número de subprocesos igual al número de CPU. Puede ajustar el número de subprocesos con la variable de entorno RAYON_NUM_THREADS. Por ejemplo, establecer RAYON_NUM_THREADS=4 limitaría el grupo de subprocesos a 4 subprocesos.

[1] A. Cross y otros. Validación de ordenadores cuánticos mediante circuitos modelo aleatorios, Phys. Rev. A 100, 032328 (2019). arXiv:1811.12926

Ejemplo

QkCircuit *qc = qk_circuit_library_quantum_volume(10, 10, -1)

Parámetros

  • num_qubits : el número de qubits que se utilizarán para el circuito generado.
  • Profundidad : el número de capas del circuito generado.
  • semilla : una semilla RNG utilizada para generar las matrices SU(4) aleatorias utilizadas en el circuito de salida. Si el número proporcionado es negativo, la semilla utilizada se obtendrá de la entropía del sistema.

Devuelve

Un puntero al circuito de volumen cuántico.

qk_circuit_library_suzuki_trotter

QkCircuit *qk_circuit_library_suzuki_trotter(const QkObs *op, uint32_t order, uint32_t reps, double time, bool preserve_order, bool insert_barriers)

Genera un circuito utilizando la fórmula del producto de Suzuki-Trotter de orden superior a partir de una observable.

Las fórmulas de Suzuki-Trotter mejoran el error de la aproximación de Lie-Trotter. En esta implementación, los operadores se expresan como sumas de un operador de Pauli. Las descomposiciones de orden superior se basan en recursiones; véase la ref. [1] para obtener más información.

Ejemplo

QkObs *obs = qk_obs_zero(1);

QkBitTerm op1_bits[1] = {QkBitTerm_X};
QkObsTerm term1 = {(QkComplex64){1.0, 0.0}, 1, op1_bits, (uint32_t[1]){0}, 1};
qk_obs_add_term(obs, &term1);

QkBitTerm op2_bits[1] = {QkBitTerm_Y};
QkObsTerm term2 = {(QkComplex64){1.0, 0.0}, 1, op2_bits, (uint32_t[1]){0}, 1};
qk_obs_add_term(obs, &term2);

QkCircuit *qc = qk_circuit_library_suzuki_trotter(obs, 2, 1, 0.1, true, false);

qk_obs_free(obs);
qk_circuit_free(qc);

Seguridad

El comportamiento es indefinido; no op es un puntero válido y no nulo a un QkObs.

Referencias

[1] : D. Berry, G., Ahokas, R., Cleve y B. Sanders, «Algoritmos cuánticos eficientes para simular hamiltonianos dispersos» (2006). arXiv:quant-ph/0508139

[2] : N. Hatano y M. Suzuki, «Búsqueda de fórmulas de productos exponenciales de orden superior» (2005). arXiv:math-ph/0506007

Parámetros

  • op – El QkObs que contiene la suma de los términos de Pauli.
  • orden : el orden de la fórmula del producto.
  • repeticiones : el número de intervalos de tiempo.
  • tiempo – El tiempo de evolución.
  • preserve_order – Si falsese activa, permite reordenar los términos del operador para obtener, en su caso, un circuito de evolución menos profundo. No es relevante al sintetizar un observable con un solo término.
  • insert_barriers – Indica si se deben insertar separadores entre las evoluciones de los términos.

Devuelve

Un puntero al circuito generado.

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