Optimizador de Parity Twine: una función de Qiskit de ParityQC

Consulta la referencia de la API

Visión general

El «Parity Twine Optimizer» permite a los usuarios resolver problemas de optimización con ordenadores cuánticos mediante el método «Parity Twine ». Este enfoque, basado en la arquitectura Parity, utiliza el compilador « ParityQC » para minimizar el número de puertas y la profundidad de los circuitos necesarios para ejecutar un algoritmo cuántico, teniendo en cuenta al mismo tiempo la conectividad de los dispositivos.

Esta reducción de recursos permite resolver problemas de optimización relevantes para la industria en escalas que resultan inviables con los métodos de transpilación estándar, que consumen muchos recursos de SWAP. El Parity Twine Optimizer automatiza los pasos de transpilación y se puede utilizar con una intervención mínima por parte del usuario.

El enfoque «Parity Twine» supera a todos los demás métodos de compilación en cuanto a la reducción del número de puertas y la profundidad de los circuitos para algoritmos cuánticos como el algoritmo cuántico de optimización aproximada (QAOA) y la transformada de Fourier cuántica (QFT). Al abstraer la información cuántica de los qubits físicos, las interacciones no locales se implementan sin puertas SWAP. En cambio, las cadenas de Parity Twine (secuencias de puertas CNOT) distribuyen sistemáticamente la información de paridad lógica entre los qubits.

El optimizador utiliza el algoritmo QAOA para minimizar la energía de una función de coste determinada. QAOA es un algoritmo variacional híbrido cuántico-clásico diseñado para resolver problemas de optimización combinatoria mediante la aproximación del estado fundamental de un hamiltoniano de coste ( $H_C$ ). Un término de mezcla ( $H_B$ ) impulsa las transiciones entre estados para explorar el espacio de soluciones. Una secuencia alterna de estos términos, controlada por los parámetros $\gamma$ y $\beta$, define el operador unitario $U(\gamma, \beta) = \Pi_{i=1}^p e^{-i \beta_i H_B} e^{-i \gamma_i H_C}$, que actúa sobre el estado inicial.

La codificación del problema unitario, exp( $-i \beta H_C)$ ), requiere la codificación de todos los operadores de rotación de $n$ -cuerpos (exp( $-i \beta J_{i,j,...n}Z_iZ_j...Z_n$ )). Esto puede lograrse utilizando generadores de $n$ -cuerpos (redes de paridad retorcida), que reducen la profundidad del circuito QAOA y el número de puertas de dos qubits.

Descripción

La entrada del «Parity Twine Optimizer» consta de un problema de optimización, el nombre del hardware « IBM Quantum » seleccionado y argumentos opcionales adicionales para personalizar la transpilación y los ajustes de ejecución en el hardware. La función del optimizador envía la definición del problema al compilador Parity Twine. La figura 1 muestra un resumen del flujo de trabajo de la función.

El problema de optimización de entrada se transforma previamente en un hamiltoniano (normalizado). A continuación, el compilador « ParityQC » construye un circuito de ansatz «Parity Twine» parametrizado, que se transpilaba a un ansatz lógico que se ajusta al conjunto de puertas nativo del hardware elegido.

Los parámetros del circuito QAOA se optimizan de forma clásica mediante el enfoque «efficient depth one» y se asignan al circuito transpilado. Al utilizar una ronda de QAOA, se obtienen los parámetros óptimos $\gamma$ y $\beta$ mediante una búsqueda por cuadrícula en una CPU, sin necesidad de una costosa optimización iterativa a lo largo de numerosas llamadas al circuito. Esto reduce considerablemente el tiempo de ejecución de la QPU que necesita el optimizador. El tiempo de ejecución por circuito viene determinado principalmente por la sobrecarga constante que supone ejecutar un trabajo en la QPU. Una vez configurados los parámetros del circuito, el trabajo se envía a la QPU especificada IBM®.

A continuación, los resultados sin procesar se someten a un procesamiento posterior. En este paso se utiliza una búsqueda codiciosa local que recorre aleatoriamente la cadena de solución e invierte los valores de los bits si ello reduce el valor de la función de coste.

Referencias comparativas

Modelo de Sherrington-Kirkpatrick

La figura 2 muestra la eficacia del «Parity Twine Optimizer». Aquí se comparan los resultados obtenidos mediante el optimizador con los del muestreo aleatorio para el modelo de Sherrington-Kirkpatrick a medida que aumenta el número de qubits.

El posprocesamiento tanto de los resultados aleatorios como de los obtenidos con el optimizador permite obtener estados fundamentales exactos, pero el resultado bruto de energía mínima obtenido con Twine QAOA siempre es mejor que los valores aleatorios. En el caso de los números más elevados de qubits considerados (90 y 100), el ruido del hardware degrada el resultado del optimizador, que vuelve a los valores brutos propios de un muestreo aleatorio.

Consulta este tutorial para obtener una introducción al modelo de Sherrington-Kirkpatrick y información detallada sobre cómo resolverlo con el optimizador Parity Twine.

Problema de división del mercado

La tabla 1 muestra los indicadores de rendimiento específicos del optimizador Parity Twine aplicados a diversas instancias del problema de división del mercado (MS). Estos datos se han obtenido de la biblioteca QOBLIB (Quantum Optimization Benchmarking Library) y corresponden a los resultados enviados a la biblioteca mediante el optimizador Parity Twine.

La violación de MS es una métrica de precisión que mide en qué medida la solución se aleja de cumplir todas las restricciones, y se define como « $\sum_i ((Ax - b)_i)^2$ ». Cuanto más bajos sean los valores de esta métrica, más precisas serán las soluciones. En la tabla 1 se recogen los valores medios de cinco ejecuciones de cada instancia utilizando el optimizador Parity Twine con el dispositivo ibm_boston como backend y 100 000 disparos. Se indica el valor mínimo de la desviación estándar (MS) obtenido a partir de las ejecuciones de cada instancia.

Tabla 1: Indicadores de rendimiento para diferentes casos del problema de la división del mercado. Los nombres de las instancias corresponden a los ejemplos de la biblioteca de problemas de QOBLIB. Como ya se ha mencionado anteriormente en la sección de descripción, el tiempo de ejecución de la QPU es mínimo y casi constante, ya que solo se utiliza una ronda de QAOA con los parámetros óptimos del circuito obtenidos en una CPU.

Consulta este tutorial para obtener una introducción al problema de la división del mercado y detalles sobre cómo resolverlo con el optimizador Parity Twine.

Problema del conjunto independiente máximo

La figura 3 compara los resultados obtenidos con el optimizador Parity Twine frente a los del muestreo aleatorio para el problema del conjunto independiente máximo en instancias seleccionadas obtenidas de la biblioteca QOBLIB (Quantum Optimization Benchmarking Library). Estos oscilan entre 18 (interacciones entre mamíferos y canguros) y 114 ( es60fst03 ) qubits.

En el caso de instancias pequeñas, el tamaño del conjunto independiente máximo obtenido mediante el optimizador y el muestreo aleatorio es similar, pero en el caso de instancias más grandes, el optimizador ofrece resultados mucho mejores. El posprocesamiento tanto de los resultados obtenidos mediante muestreo aleatorio como de los del optimizador vuelve a dar lugar a tamaños de conjuntos que coinciden con los valores exactos.

Cómo empezar

Inicia sesión con tu token de la API de IBM Quantum Platform y selecciona la función de Qiskit como:

from qiskit_ibm_catalog import QiskitFunctionsCatalog

# Authenticate and load the Qiskit Function
catalog = QiskitFunctionsCatalog(
    channel="ibm_quantum_platform",
)
function = catalog.load("parityqc/parity-twine-optimizer")

Ejemplo

El optimizador Parity Twine se puede aplicar a un ejemplo sencillo de QUBO de la siguiente manera. En primer lugar, el problema se define mediante un diccionario:

problem = {"()": 3, "(0,)": 1, "(0, 1)": 2, "(1, 2)": -1}

A continuación, el tipo de variable debe definirse como o binary spin:

variable_type = "spin"

Esto define la función objetivo $3 + s_0 + 2 s_0s_1 - s_1s_2$, donde $s_i \in \{-1, 1\}$.

Elige un backend. Por ejemplo:

backend_name = "ibm_phoenix"

Utiliza catalog.backends() para ver una lista de los backends disponibles desde la cuenta de usuario o la instancia.

Si no se especifica ningún backend, se selecciona automáticamente el backend menos ocupado (el que tenga el menor número de trabajos pendientes).

Una vez cargado el optimizador (véase más arriba), puedes ejecutarlo sobre el problema utilizando las opciones predeterminadas:

function_job = function.run(
    problem=problem, variable_type=variable_type, backend_name=backend_name
)
print(f"Job ID: {function_job.job_id}")

Comprueba el estado del trabajo de la siguiente manera:

# Monitor the job status
function_job.status()

Recupera los resultados de la siguiente manera:

# Retrieve the job result if the status is DONE
result = function_job.result()

result

Al imprimir los resultados, se obtiene lo siguiente:

{
    'solution': {'0': -1, '1': 1, '2': 1},
    'objective_value': -1.0,
    'solution_bitstring': '100',
    'metadata': {
        'circuit_metrics': {
            'depth': 20,
            'gate_count': 198,
            'two_qubit_gate_depth': 4,
            'two_qubit_gate_count': 4,
            'num_qubits': 3,
            'operations': {'delay': 158, 'rz': 17, 'sx': 14, 'cz': 4, 'measure': 3, 'x': 2}
        },
        'solver_info': {
            'variable_mapping': {'0': 0, '1': 1, '2': 2},
            'bitstring_distributions': {
                'before_postprocessing': {'100': 71760, ... },
                'after_postprocessing': {'100': 88440, '011': 11560}
            },
            'best_parameters': {
                'beta': [-0.46259546391008877],
                'gamma': [0.6181957189727373]
            }
        },
        'resource_usage': {
            'RUNNING: MAPPING': {'CPU_TIME': 42.878},
            'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 0.094},
            'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 790.623},
            'RUNNING: EXECUTING_QPU': {'QPU_TIME': 28.0},
            'RUNNING: POST_PROCESSING': {'CPU_TIME': 0.828}
        }
    }
}

El diccionario solution se corresponde con los qubits definidos en el problema ( $s_0, s_1$ y $s_2$ ) y proporciona sus valores de espín optimizados.

El objective_value es el coste o la energía del problema de optimización. Cuantifica la calidad solution .

metadata ofrece información sobre la transpilación (número de puertas de dos qubits/profundidad, puertas utilizadas, qubits activos) y diversos tiempos de ejecución, tanto para el tiempo de cálculo cuántico como para el clásico.

Además, metadata permite hacerse una idea del funcionamiento interno del algoritmo. Puedes ver los parámetros variacionales optimizados (beta y gamma) y comprobar cómo mejoró la distribución de las cadenas de bits medidas tras aplicar un posprocesamiento clásico a los resultados cuánticos sin procesar.

Todas las cadenas de bits de la salida del resultado pueden asignarse a las variables del problema utilizando el variable_mapping. Por ejemplo, puedes asignar el 'solution_bitstring': '100' con el 'variable_mapping': {'0': 0, '1': 1, '2': 2} a la solución binaria: {'0': 1, '1': 0, '2': 0}. Dado que estás resolviendo el problema en términos de variables de espín, debes aplicar la transformación de binario a espín (0 -> 1, 1 -> ) -1 . De este modo, obtienes la solución final 'solution': {'0': -1, '1': 1, '2': 1}.

Consulta la referencia de la API para obtener información detallada sobre los datos de entrada y salida de la función «Parity Twine Optimizer».

Registro de cambios

[1.0.1] - 15 de septiembre de 2026

Notas

Esta versión supone la primera versión estable de producción de la función «Parity Twine Optimizer» de Qiskit. Se prevé que las próximas versiones incluyan lo siguiente:

• compilación de problemas de orden superior,
• algoritmos de optimización adicionales, y
• mejoras en el preprocesamiento y el posprocesamiento.

Características

• Resuelve problemas de QUBO, tanto dispersos como densos, con el eficiente «Parity Twine Compiler».

Documentación

• Guía de inicio para el usuario.
• Tutoriales con ejemplos sobre los problemas de «Market Split» y «Sherrington-Kirkpatrick».
• Documentación de la API.

Obtener soporte

Si tienes alguna duda o problema, ponte en contacto con ParityQC.

Próximos pasos