Resuelva el problema de la división del mercado con el optimizador cuántico Iskay de Kipu Quantum

Estimación de uso: 20 segundos en un procesador Heron r2. (NOTA: Esto es sólo una estimación. Su tiempo de ejecución puede variar)

En segundo plano

Este tutorial muestra cómo resolver el problema Market Split utilizando el optimizador cuántico Iskay de Kipu Quantum [1]. El problema de la división del mercado representa un reto de asignación de recursos del mundo real en el que los mercados deben dividirse en regiones de ventas equilibradas para satisfacer los objetivos exactos de demanda.

El reto de la división del mercado

El problema de la división del mercado plantea un reto aparentemente sencillo, pero formidable desde el punto de vista computacional, en la asignación de recursos. Consideremos una empresa con $m$ productos que se venden en $n$ mercados diferentes, donde cada mercado compra un paquete específico de productos (representado por las columnas de la matriz $A$ ). El objetivo de la empresa es dividir estos mercados en dos regiones de venta equilibradas, de forma que cada región reciba exactamente la mitad de la demanda total de cada producto.

Formulación matemática:

Buscamos un vector de asignación binario $x$, donde:

• $x_j = 1$ asigna el mercado $j$ a la Región A
• $x_j = 0$ asigna el mercado $j$ a la Región B
• Debe cumplirse la restricción $Ax = b$, donde $b$ representa el objetivo de ventas (normalmente la mitad de la demanda total por producto)

Función de costes:

Para resolver este problema, minimizamos la violación de la restricción al cuadrado:

$C(x) = ||Ax - b||^2 = \sum_{i=1}^{m} \left(\sum_{j=1}^{n} A_{ij}x_j - b_i\right)^2$

donde:

• $A_{ij}$ representa las ventas del producto $i$ en el mercado $j$
• $x_j \in \{0,1\}$ es la asignación binaria del mercado $j$
• $b_i$ es el objetivo de ventas del producto $i$ en cada región
• El coste es igual a cero precisamente cuando se cumplen todas las restricciones

Cada término de la suma representa la desviación al cuadrado de las ventas objetivo de un producto concreto. Al expandir esta función de costes, obtenemos:

$C(x) = x^T A^T A x - 2b^T A x + b^T b$

Dado que $b^T b$ es una constante, minimizar $C(x)$ equivale a minimizar la función cuadrática $x^T A^T A x - 2b^T A x$, que es exactamente un problema QUBO (Quadratic Unconstrained Binary Optimization).

Complejidad computacional:

A pesar de su sencilla interpretación comercial, este problema presenta una notable intratabilidad computacional:

• Fallos a pequeña escala : Los solucionadores convencionales de programación entera mixta fallan en instancias con tan solo siete productos bajo un tiempo de espera de una hora [4]
• Crecimiento exponencial : El espacio de soluciones crece exponencialmente ( $2^n$ posibles asignaciones), lo que hace inviables los enfoques de fuerza bruta

Esta severa barrera computacional, combinada con su relevancia práctica para la planificación territorial y la asignación de recursos, convierte al problema de la división del mercado en una referencia ideal para los algoritmos de optimización cuántica [4].

¿Qué hace que el enfoque de Iskay sea único?

El optimizador Iskay utiliza el algoritmo bf-DCQO (bias-field digitized counterdiabatic quantum optimization) [1], que representa un avance significativo en la optimización cuántica:

Eficiencia del circuito : El algoritmo bf-DCQO consigue una notable reducción de compuertas [1] :

• Hasta 10 veces menos puertas de enredo que el Recocido Cuántico Digital (DQA)
• Permiten circuitos significativamente menos profundos:
  • Menor acumulación de errores durante la ejecución cuántica
  • Capacidad para abordar problemas de mayor envergadura en el hardware cuántico actual
  • No se necesitan técnicas de mitigación de errores

Diseño no variacional : A diferencia de los algoritmos variacionales que requieren aproximadamente 100 iteraciones, bf-DCQO normalmente sólo necesita aproximadamente 10 iteraciones [1]. Esto se consigue mediante:

• Cálculos inteligentes del campo de polarización a partir de distribuciones de estado medidas
• Partiendo en cada iteración de un estado energético próximo a la solución anterior
• Postprocesado clásico integrado con búsqueda local

Protocolos contradiabáticos : El algoritmo incorpora términos contradiabáticos que suprimen las excitaciones cuánticas no deseadas durante tiempos de evolución cortos, lo que permite al sistema permanecer cerca del estado fundamental incluso con transiciones rápidas [1].

Requisitos

Antes de empezar este tutorial, asegúrate de que tienes instalado lo siguiente:

• Qiskit IBM Tiempo de ejecución (pip install qiskit-ibm-runtime)
• Qiskit Functions (pip install qiskit-ibm-catalog)
• NumPy (pip install numpy)
• Solicitudes (pip install requests)
• Complemento Opt Mapper Qiskit (pip install qiskit-addon-opt-mapper)

También tendrá que acceder a la función Iskay Quantum Optimizer desde Qiskit Functions Catalog.

Configuración

En primer lugar, importe todos los paquetes necesarios para este tutorial.

import os
import tempfile
import time
from typing import Tuple, Optional

import numpy as np
import requests

from qiskit_ibm_catalog import QiskitFunctionsCatalog

from qiskit_addon_opt_mapper import OptimizationProblem
from qiskit_addon_opt_mapper.converters import OptimizationProblemToQubo

print("All required libraries imported successfully")

Configurar las credenciales de IBM Quantum

Defina sus IBM Quantum® Platform credenciales. Necesitará:

• Token API : Su clave API de 44 caracteres de IBM Quantum Platform
• CRN de instancia : Su identificador de instancia IBM Cloud®

token = "<YOUR_API_KEY>"
instance = "<YOUR_INSTANCE_CRN>"

Paso 1: Asignar entradas clásicas a un problema cuántico

Empezaremos trasladando nuestro problema clásico a una representación compatible con la cuántica. Este paso implica:

1. Conexión al optimizador cuántico Iskay
2. Carga y formulación del problema de Market Split
3. Comprender el algoritmo bf-DCQO que lo resolverá

Conéctese a Iskay Quantum Optimizer

Empezaremos estableciendo una conexión con Qiskit Functions Catalog y cargando el optimizador cuántico Iskay. El Optimizador Iskay es una función cuántica proporcionada por Kipu Quantum que implementa el algoritmo bf-DCQO para resolver problemas de optimización en hardware cuántico.

catalog = QiskitFunctionsCatalog(token=token, instance=instance)
iskay_solver = catalog.load("kipu-quantum/iskay-quantum-optimizer")

print("Iskay optimizer loaded successfully")
print("Ready to solve optimization problems using bf-DCQO algorithm")

Cargar y formular el problema

Comprender el formato de los datos del problema

Las instancias de problemas de QOBLIB (Quantum Optimization Benchmarking Library) [2] se almacenan en un formato de texto simple. Examinemos el contenido real de nuestra instancia de destino ms_03_200_177.dat:

3 20
60   92  161   53   97    2   75   81    6  139  132   45  108  112  181   93  152  200  164   51 1002
176  196   41  143    2   88    0   79   10   71   75  148   82  135   34  187   33  155   58   46  879
68   68  179  173  127  163   48   49   99   78   44   52  173  131   73  198   84  109  180   95 1040

Estructura del formato:

• Primera línea: 3 20

  • 3 = número de productos (restricciones/filas de la matriz $A$ )
  • 20 = número de mercados (variables/columnas de la matriz $A$ )

• 3 líneas siguientes: Matriz de coeficientes $A$ y vector objetivo $b$

  • Cada línea tiene 21 números: los 20 primeros son coeficientes de fila, el último es el objetivo
  • Línea 2: 60 92 161 ... 51 | 1002
    • Los 20 primeros números: Cuánto vende del Producto 1 cada uno de los 20 mercados
    • Último número (1002): Objetivo de ventas para el Producto 1 en una región
  • Línea 3: 176 196 41 ... 46 | 879
    • Producto 2 ventas por mercado y objetivo (879)
  • Línea 4: 68 68 179 ... 95 | 1040
    • Producto 3 ventas por mercado y objetivo (1040)

Interpretación comercial:

• El mercado 0 vende: 60 unidades del producto 1, 176 unidades del producto 2, 68 unidades del producto 3
• Mercado 1 vende: 92 unidades del Producto 1, 196 unidades del Producto 2, 68 unidades del Producto 3
• Y así para los 20 mercados...
• Objetivo : Dividir estos 20 mercados en dos regiones en las que cada región reciba exactamente 1002 unidades del Producto 1, 879 unidades del Producto 2 y 1040 unidades del Producto 3

Transformación QUBO

De las restricciones al QUBO: la transformación matemática

El poder de la optimización cuántica reside en transformar problemas con restricciones en formas cuadráticas sin restricciones [4]. Para el problema de Market Split, convertimos las restricciones de igualdad

$Ax = b$

donde $x ∈ \{0,1\}^n$, en un QUBO penalizando las violaciones de las restricciones.

El método de penalización: Como necesitamos que $Ax = b$ se cumpla exactamente, minimizamos la violación al cuadrado: $f(x) = ||Ax - b||^2$

Es igual a cero precisamente cuando se cumplen todas las restricciones. Expandir algebraicamente: $f(x) = (Ax - b)^T(Ax - b) = x^T A^T A x - 2b^T A x + b^T b$

Objetivo QUBO: Dado que $b^T b$ es constante, nuestra optimización se convierte en: $\text{minimize} \quad Q(x) = x^T(A^T A)x - 2(A^T b)^T x$

Una idea clave: Esta transformación es exacta, no aproximada. Las restricciones de igualdad se cuadran naturalmente en forma cuadrática sin requerir variables auxiliares ni parámetros de penalización, lo que hace que esta formulación sea matemáticamente elegante y computacionalmente eficiente para los solucionadores cuánticos [4]. Usaremos la clase OptimizationProblem para definir nuestro problema restringido, y luego lo convertiremos a formato QUBO usando OptimizationProblemToQubo, ambos del paquete qiskit_addon_opt_mapper. Esto gestiona automáticamente la transformación basada en penalizaciones.

Implementar funciones de carga de datos y conversión QUBO

A continuación definimos tres funciones de utilidad:

1. parse_marketsplit_dat() - Analiza el formato de archivo .dat y extrae las matrices $A$ y $b$
2. fetch_marketsplit_data() - Descarga instancias de problemas directamente del repositorio QOBLIB

def parse_marketsplit_dat(filename: str) -> Tuple[np.ndarray, np.ndarray]:
    """
    Parse a market split problem from a .dat file format.

    Parameters
    ----------
    filename : str
        Path to the .dat file containing the market split problem data.

    Returns
    -------
    A : np.ndarray
        Coefficient matrix of shape (m, n) where m is the number of products
        and n is the number of markets.
    b : np.ndarray
        Target vector of shape (m,) containing the target sales per product.
    """
    with open(filename, "r", encoding="utf-8") as f:
        lines = [
            line.strip()
            for line in f
            if line.strip() and not line.startswith("#")
        ]

    if not lines:
        raise ValueError("Empty or invalid .dat file")

    # First line: m n (number of products and markets)
    m, n = map(int, lines[0].split())

    # Next m lines: each row of A followed by corresponding element of b
    A, b = [], []
    for i in range(1, m + 1):
        values = list(map(int, lines[i].split()))
        A.append(values[:-1])  # First n values: product sales per market
        b.append(values[-1])  # Last value: target sales for this product

    return np.array(A, dtype=np.int32), np.array(b, dtype=np.int32)


def fetch_marketsplit_data(
    instance_name: str = "ms_03_200_177.dat",
) -> Tuple[Optional[np.ndarray], Optional[np.ndarray]]:
    """
    Fetch market split data directly from the QOBLIB repository.

    Parameters
    ----------
    instance_name : str
        Name of the .dat file to fetch (default: "ms_03_200_177.dat").

    Returns
    -------
    A : np.ndarray or None
        Coefficient matrix if successful, None if failed.
    b : np.ndarray or None
        Target vector if successful, None if failed.
    """
    url = f"https://git.zib.de/qopt/qoblib-quantum-optimization-benchmarking-library/-/raw/main/01-marketsplit/instances/{instance_name}"

    try:
        response = requests.get(url, timeout=30)
        response.raise_for_status()

        with tempfile.NamedTemporaryFile(
            mode="w", suffix=".dat", delete=False, encoding="utf-8"
        ) as f:
            f.write(response.text)
            temp_path = f.name

        try:
            return parse_marketsplit_dat(temp_path)
        finally:
            os.unlink(temp_path)
    except Exception as e:
        print(f"Error: {e}")
        return None, None

Cargar la instancia del problema

Ahora cargamos la instancia específica del problema ms_03_200_177.dat desde QOBLIB [2]. Esta instancia tiene:

• 3 productos (limitaciones)
• 20 mercados (variables de decisión binarias)
• Más de 1 millón de posibles asignaciones de mercado para explorar ( $2^{20} = 1,048,576$ )

# Load the problem instance
instance_name = "ms_03_200_177.dat"
A, b = fetch_marketsplit_data(instance_name=instance_name)

if A is not None:
    print("Successfully loaded problem instance from QOBLIB")
    print("\nProblem Instance Analysis:")
    print("=" * 50)
    print(f"Coefficient Matrix A: {A.shape[0]} × {A.shape[1]}")
    print(f"   → {A.shape[0]} products (constraints)")
    print(f"   → {A.shape[1]} markets (decision variables)")
    print(f"Target Vector b: {b}")
    print("   → Target sales per product for each region")
    print(
        f"Solution Space: "
        f"2^{A.shape[1]} = {2**A.shape[1]:,} possible assignments"
    )

Convertir al formato QUBO

Ahora transformamos el problema de optimización restringido en formato QUBO:

# Create optimization problem
ms = OptimizationProblem(instance_name.replace(".dat", ""))

# Add binary variables (one for each market)
ms.binary_var_list(A.shape[1])

# Add equality constraints (one for each product)
for idx, rhs in enumerate(b):
    ms.linear_constraint(A[idx, :], sense="==", rhs=rhs)

# Convert to QUBO with penalty parameter
qubo = OptimizationProblemToQubo(penalty=1).convert(ms)

print("QUBO Conversion Complete:")
print("=" * 50)
print(f"Number of variables: {qubo.get_num_vars()}")
print(f"Constant term: {qubo.objective.constant}")
print(f"Linear terms: {len(qubo.objective.linear.to_dict())}")
print(f"Quadratic terms: {len(qubo.objective.quadratic.to_dict())}")

Convertir QUBO a formato Iskay

Ahora necesitamos convertir el objeto QUBO al formato de diccionario requerido por el Optimizador Iskay de Kipu Quantum.

Los argumentos problem y problem_type codifican un problema de optimización de la forma

donde

• Al elegir problem_type = "binary", se especifica que la función de coste está en formato binary , lo que significa que $D = \{0, 1\}^{n}$, es decir, la función de coste está escrita en formulación QUBO/HUBO.
• Por otra parte, eligiendo problem_type = "spin", la función de coste se escribe en la formulación de Ising, donde $D = \{-1, 1\}^{n}$.

Los coeficientes del problema deben codificarse en un diccionario de la siguiente manera:

Tenga en cuenta que las claves del diccionario deben ser cadenas que contengan una tupla válida de números enteros no repetidos. Para los problemas binarios, sabemos que:

para $i=j$ (ya que $x_i \in \{0,1\}$ significa $x_i \cdot x_i = x_i$ ). Por tanto, en su formulación QUBO, si tiene tanto contribuciones lineales $b_i x_i$ como contribuciones cuadráticas diagonales $c_{i,i} x_i^2$, estos términos deben combinarse en un único coeficiente lineal:

Coeficiente lineal total para la variable $x_i$ : $b_i + c_{i,i}$

Esto significa:

• Los términos lineales como "(i, )" contienen: coeficiente lineal original + coeficiente cuadrático diagonal
• Los términos cuadráticos diagonales como "(i, i)" NO deben aparecer en el diccionario final
• Sólo los términos cuadráticos no diagonales como "(i, j)" donde $i \neq j$ deben incluirse como entradas separadas

Ejemplo: Si su QUBO tiene $3x_1 + 2x_1^2 + 4x_1 x_2$, el diccionario Iskay debe contener:

• "(0, )": 5.0 (combinando $3 + 2 = 5$ )
• "(0, 1)": 4.0 (término no diagonal)

NO hay entradas separadas para "(0, )": 3.0 y "(0, 0)": 2.0.

# Convert QUBO to Iskay dictionary format:

# Create empty Iskay input dictionary
iskay_input_problem = {}

# Convert QUBO to Iskay dictionary format
iskay_input_problem = {"()": qubo.objective.constant}

for i in range(qubo.get_num_vars()):
    for j in range(i, qubo.get_num_vars()):
        if i == j:
            # Add linear term (including diagonal quadratic contribution)
            iskay_input_problem[f"({i}, )"] = float(
                qubo.objective.linear.to_dict().get(i)
            ) + float(qubo.objective.quadratic.to_dict().get((i, i)))
        else:
            # Add off-diagonal quadratic term
            iskay_input_problem[f"({i}, {j})"] = float(
                qubo.objective.quadratic.to_dict().get((i, j))
            )

# Display Iskay dictionary summary
print("Iskay Dictionary Format:")
print("=" * 50)
print(f"Total coefficients: {len(iskay_input_problem)}")
print(f"  • Constant term: {iskay_input_problem['()']}")
print(
    f"  • Linear terms: "
    f"{sum(1 for k in iskay_input_problem.keys() if k != '()' and ', )' in k)}"
)
print(
    f"  • Quadratic terms: "
    f"{sum(1 for k in iskay_input_problem.keys() if k != '()' and ', )' not in k)}"
)
print("\nSample coefficients:")

# Get first 10 and last 5 items properly
items = list(iskay_input_problem.items())
first_10 = list(enumerate(items[:10]))
last_5 = list(enumerate(items[-5:], start=len(items) - 5))

for i, (key, value) in first_10 + last_5:
    coeff_type = (
        "constant"
        if key == "()"
        else "linear"
        if ", )" in key
        else "quadratic"
    )
    print(f"  {key}: {value} ({coeff_type})")
print("  ...")
print("\n✓ Problem ready for Iskay optimizer!")

Comprender el algoritmo bf-DCQO

Antes de ejecutar la optimización, vamos a entender el sofisticado algoritmo cuántico que impulsa Iskay: bf-DCQO (bias-field digitized counterdiabatic quantum optimization) [1].

¿Qué es bf-DCQO?

bf-DCQO se basa en la evolución temporal de un sistema cuántico en el que la solución del problema está codificada en el estado fundamental (estado de menor energía) del Hamiltoniano cuántico final [1]. El algoritmo aborda un reto fundamental en la optimización cuántica:

El reto : La computación cuántica adiabática tradicional requiere una evolución muy lenta para mantener las condiciones del estado básico según el teorema adiabático. Esto exige circuitos cuánticos cada vez más profundos a medida que aumenta la complejidad del problema, lo que conlleva más operaciones de compuerta y errores acumulados.

La solución : bf-DCQO utiliza protocolos contradiabáticos para permitir una evolución rápida manteniendo la fidelidad al estado base, lo que reduce drásticamente la profundidad del circuito.

Marco matemático

El algoritmo minimiza una función de coste de la forma:

$\min_{(x_1,x_2,...,x_n) \in D} C(x_1,x_2,...,x_n)$

donde $D = \{0,1\}^n$ para variables binarias y:

$C(x) = a + \sum_i b_i x_i + \sum_{i,j} c_{ij} x_i x_j + ... + \sum g_{k_1,...,k_m} x_{k_1}...x_{k_m}$

Para nuestro problema de Market Split, la función de costes es:

$C(x) = ||Ax - b||^2 = x^T A^T A x - 2 b^T A x + b^T b$

El papel de los términos antidiabéticos

Los términos contradiabáticos son términos adicionales introducidos en el Hamiltoniano dependiente del tiempo que suprimen las excitaciones no deseadas durante la evolución cuántica. He aquí por qué son cruciales:

En la optimización cuántica adiabática, hacemos evolucionar el sistema según un Hamiltoniano dependiente del tiempo:

$H(t) = \left(1 - \frac{t}{T}\right) H_{\text{initial}} + \frac{t}{T} H_{\text{problem}}$

donde $H_{\text{problem}}$ codifica nuestro problema de optimización. Para mantener el estado básico durante la evolución rápida, añadimos términos contradiabáticos:

$H_{\text{CD}}(t) = H(t) + H_{\text{counter}}(t)$

Estos términos contradiabáticos hacen lo siguiente:

1. Suprimir las transiciones no deseadas : Evitar que el estado cuántico salte a estados excitados durante la evolución rápida
2. Permiten tiempos de evolución más cortos : Permiten alcanzar el estado final mucho más rápido sin violar la adiabaticidad
3. Reducir la profundidad del circuito : Una evolución más corta conlleva menos puertas y menos errores

El impacto práctico es espectacular: bf-DCQO utiliza hasta 10 veces menos puertas de enredo que Digital Quantum Annealing [1], lo que lo hace práctico para el ruidoso hardware cuántico actual.

Optimización iterativa del campo de sesgo

A diferencia de los algoritmos variacionales que optimizan los parámetros del circuito a través de muchas iteraciones, bf-DCQO utiliza un enfoque guiado por el campo de polarización que converge en aproximadamente 10 iteraciones [1] :

Proceso de iteración:

1. Evolución cuántica inicial : Comenzar con un circuito cuántico que implemente el protocolo de evolución contradiabática

2. Medición : Medir el estado cuántico para obtener una distribución de probabilidad sobre cadenas de bits

3. Cálculo del campo de polarización : Analiza las estadísticas de medición y calcula un campo de polarización óptimo $h_i$ para cada qubit: $h_i = \text{f}(\text{measurement statistics}, \text{previous solutions})$

4. Siguiente iteración : El campo de polarización modifica el Hamiltoniano para la siguiente iteración: $H_{\text{next}} = H_{\text{problem}} + \sum_i h_i \sigma_i^z$

   Esto permite empezar cerca de la buena solución encontrada anteriormente, realizando de hecho una forma de "búsqueda local cuántica"

5. Convergencia : Repetir hasta que la calidad de la solución se estabilice o se alcance un número máximo de iteraciones

Ventaja clave: Cada iteración proporciona un progreso significativo hacia la solución óptima al incorporar información de mediciones anteriores, a diferencia de los métodos variacionales que deben explorar el espacio de parámetros a ciegas.

Postprocesamiento clásico integrado

Tras la convergencia de la optimización cuántica, Iskay realiza un postprocesamiento clásico de búsqueda local :

• Exploración mediante inversión de bits : Invertir sistemática o aleatoriamente los bits en la mejor solución medida.
• Evaluación energética : Calcular $C(x)$ para cada solución modificada
• Selección codiciosa : Aceptar mejoras que reduzcan la función de coste
• Múltiples pasadas : Realiza varias pasadas (controladas por postprocessing_level)

Este enfoque híbrido compensa los errores de cambio de bits derivados de las imperfecciones del hardware y los errores de lectura, garantizando soluciones de alta calidad incluso en dispositivos cuánticos ruidosos.

Por qué bf-DCQO destaca en el hardware actual

El algoritmo bf-DCQO está diseñado específicamente para sobresalir en los dispositivos cuánticos ruidosos de escala intermedia (NISQ) actuales [1] :

1. Resistencia a los errores : Menos compuertas (10 veces menos) significa menos acumulación de errores
2. No se requiere mitigación de errores : La eficiencia inherente del algoritmo elimina la necesidad de costosas técnicas de mitigación de errores [1]
3. Escalabilidad : Puede manejar problemas de hasta 156 qubits (156 variables binarias) con mapeo directo de qubits [1]
4. Rendimiento demostrado : Alcanza ratios de aproximación del 100% en las instancias de referencia MaxCut y HUBO [1]

Veamos ahora este potente algoritmo en acción en nuestro problema de Market Split

Paso 2: Optimizar el problema para la ejecución en hardware cuántico

El algoritmo bf-DCQO se encarga automáticamente de la optimización de los circuitos, creando circuitos cuánticos poco profundos con términos contradiabáticos diseñados específicamente para el backend objetivo.

Configurar la optimización

El Optimizador Iskay requiere varios parámetros clave para resolver eficazmente su problema de optimización. Examinemos cada parámetro y su papel en el proceso de optimización cuántica:

Parámetros necesarios

Conceptos esenciales

• Formato del problema : Utilizamos "binary" ya que nuestras variables son binarias (0/1), representando asignaciones de mercado.
• Selección del backend : Elija entre las QPU disponibles (por ejemplo, "ibm_fez") en función de sus necesidades y de la instancia de recursos informáticos.
• Estructura QUBO : Nuestro diccionario de problemas contiene los coeficientes exactos de la transformación matemática.

Opciones avanzadas (opcional)

Iskay ofrece posibilidades de ajuste mediante parámetros opcionales. Aunque los valores por defecto funcionan bien para la mayoría de los problemas, puede personalizar el comportamiento para requisitos específicos:

Niveles de preprocesamiento (0-3) : Especialmente importante para problemas más grandes que actualmente no caben en los tiempos de coherencia del hardware. Los niveles de preprocesamiento más altos consiguen una menor profundidad de los circuitos mediante aproximaciones en la transpilación del problema:

• Nivel 0 : Circuitos exactos y más largos
• Nivel 1 : Buen equilibrio entre precisión y aproximación, recortando sólo las puertas con ángulos en el percentil 10 más bajo
• Nivel 2 : Aproximación ligeramente superior, recortando las puertas con ángulos en el percentil 20 más bajo y utilizando approximation_degree=0.95 en la transpilación
• Nivel 3 : Nivel de aproximación máxima, recortando las puertas del percentil 30 más bajo y utilizando approximation_degree=0.90 en la transpilación

Niveles de transpilación (0-5) : Controla los ensayos avanzados de optimización del transpilador para la compilación de circuitos cuánticos. Esto puede suponer un aumento de la sobrecarga clásica y, en algunos casos, puede que no cambie la profundidad del circuito. El valor por defecto 2 en general conduce al circuito más pequeño y es relativamente rápido.

• Nivel 0 : Optimización del circuito DCQO descompuesto (diseño, encaminamiento, programación)
• Nivel 1 : Optimización de PauliEvolutionGate y, a continuación, del circuito DCQO descompuesto ( max_trials=10 )
• Nivel 2 : Optimización de PauliEvolutionGate y, a continuación, del circuito DCQO descompuesto ( max_trials=15 )
• Nivel 3 : Optimización de PauliEvolutionGate y, a continuación, del circuito DCQO descompuesto ( max_trials=20 )
• Nivel 4 : Optimización de PauliEvolutionGate y, a continuación, del circuito DCQO descompuesto ( max_trials=25 )
• Nivel 5 : Optimización de PauliEvolutionGate y, a continuación, del circuito DCQO descompuesto ( max_trials=50 )

Niveles de postprocesamiento (0-2) : Controla la cantidad de optimización clásica, compensando los errores de bit-flip con diferente número de pasadas codiciosas de una búsqueda local:

• Nivel 0 : 1 aprobado
• Nivel 1 : 2 pases
• Nivel 2 : 3 pases

Modo sólo transpile : Ahora disponible para usuarios que deseen analizar la optimización de circuitos sin ejecutar el algoritmo cuántico completo.

Ejemplo de configuración personalizada

A continuación te mostramos cómo podrías configurar Iskay con diferentes ajustes:

custom_options = {
    # Higher shot count for better statistics
    "shots": 15_000,

    # More iterations for solution refinement
    "num_iterations": 12,

    # Light preprocessing for problem simplification
    "preprocessing_level": 1,

    # Maximum postprocessing for solution quality
    "postprocessing_level": 2,

    # Using higher transpilation level for circuit optimization
    "transpilation_level": 3,

    # Fixed seed for reproducible results
    "seed_transpiler": 42,

    # Custom tracking tags
    "job_tags": ["market_split"]
}

Para este tutorial, mantendremos la mayoría de los parámetros por defecto y sólo cambiaremos el número de iteraciones del campo de polarización:

# Specify the target backend
backend_name = "ibm_fez"

# Set the number of bias-field iterations and set a tag to identify the jobs
options = {
    "num_iterations": 3,  # Change number of bias-field iterations
    "job_tags": ["market_split_example"],  # Tag to identify jobs
}

# Configure Iskay optimizer
iskay_input = {
    "problem": iskay_input_problem,
    "problem_type": "binary",
    "backend_name": backend_name,
    "options": options,
}

print("Iskay Optimizer Configuration:")
print("=" * 40)
print(f"  Backend: {backend_name}")
print(f"  Problem: {len(iskay_input['problem'])} terms")
print("  Algorithm: bf-DCQO")

Paso 3: Ejecutar utilizando Qiskit primitives

Ahora presentamos nuestro problema para que se ejecute en el hardware IBM Quantum. El algoritmo bf-DCQO lo hará:

1. Construir circuitos cuánticos poco profundos con términos contradiabáticos
2. Ejecutar aproximadamente 10 iteraciones con optimización del campo de polarización
3. Realizar el postprocesamiento clásico con búsqueda local
4. Devolver la asignación óptima al mercado

# Submit the optimization job
print("Submitting optimization job to Kipu Quantum...")
print(
    f"Problem size: {A.shape[1]} variables, {len(iskay_input['problem'])} terms"
)
print(
    "Algorithm: bf-DCQO (bias-field digitized counterdiabatic quantum optimization)"
)

job = iskay_solver.run(**iskay_input)

print("\nJob successfully submitted!")
print(f"Job ID: {job.job_id}")
print("Optimization in progress...")
print(
    f"The bf-DCQO algorithm will efficiently explore "
    f"{2**A.shape[1]:,} possible assignments"
)

Supervisar el estado del trabajo

Puede comprobar el estado actual de su trabajo de optimización. Los estados posibles son:

• QUEUED: El trabajo está esperando en la cola
• RUNNING: El trabajo se está ejecutando actualmente en hardware cuántico
• DONE: Trabajo completado con éxito
• CANCELED: Trabajo cancelado
• ERROR: El trabajo ha encontrado un error

# Check job status
print(f"Job status: {job.status()}")

Espere hasta que finalice

Esta celda se bloqueará hasta que se complete el trabajo. El proceso de optimización incluye:

• Tiempo de espera (espera de acceso al hardware cuántico)
• Tiempo de ejecución (ejecutando el algoritmo bf-DCQO con aproximadamente 10 iteraciones)
• Tiempo de postprocesamiento (búsqueda local clásica)

Los tiempos típicos de finalización oscilan entre unos minutos y decenas de minutos, dependiendo de las condiciones de la cola.

# Wait for job completion
while True:
    status = job.status()
    print(
        f"Waiting for job {job.job_id} to complete... (status: {status})",
        end="\r",
        flush=True,
    )
    if status in ["DONE", "CANCELED", "ERROR"]:
        print(
            f"\nJob {job.job_id} completed with status: {status}" + " " * 20
        )
        break
    time.sleep(30)

# Retrieve the optimization results
result = job.result()
print("\nOptimization complete!")

Paso 4: Procesamiento posterior y devolución del resultado en el formato clásico deseado

Ahora post-procesamos los resultados de la ejecución cuántica. Esto incluye:

• Análisis de la estructura de la solución
• Validación del cumplimiento de las restricciones
• Comparación con los enfoques clásicos

Analizar los resultados

Comprender la estructura del resultado

Iskay devuelve un completo diccionario de resultados que contiene:

• solution: Un diccionario que asigna los índices de las variables a sus valores óptimos (0 ó 1)
• solution_info: Información detallada que incluye:
  • bitstring: La asignación óptima como cadena binaria
  • cost: El valor de la función objetivo (debe ser 0 para una satisfacción perfecta de las restricciones)
  • mapping: Cómo se asignan las posiciones de las cadenas de bits a las variables del problema
  • seed_transpiler: Semilla utilizada para la reproducibilidad
• prob_type: Si la solución está en formato binario o de giro

Examinemos la solución devuelta por el optimizador cuántico.

# Display the optimization results
print("Optimization Results")
print("=" * 50)
print(f"Problem Type: {result['prob_type']}")
print("\nSolution Info:")
print(f"  Bitstring: {result['solution_info']['bitstring']}")
print(f"  Cost: {result['solution_info']['cost']}")
print("\nSolution (first 10 variables):")
for i, (var, val) in enumerate(list(result["solution"].items())[:10]):
    print(f"  {var}: {val}")
print("  ...")

Validación de la Solución

Ahora validamos si la solución cuántica satisface las restricciones de la división del mercado. El proceso de validación comprueba:

¿Qué es una violación de una restricción?

• Para cada producto $i$, calculamos las ventas reales en la región A: $(Ax)_i$
• Lo comparamos con el objetivo de ventas $b_i$
• La violación es la diferencia absoluta: $|(Ax)_i - b_i|$
• Una solución viable tiene cero violaciones para todos los productos

Lo que esperamos:

• Caso ideal : Violación total = 0 (todas las restricciones se cumplen perfectamente)
  • La región A recibe exactamente 1002 unidades del producto 1, 879 unidades del producto 2 y 1040 unidades del producto 3
  • La Región B se queda con las unidades restantes (también 1002, 879 y 1040 respectivamente)
• Buen caso : La violación total es pequeña (solución casi óptima)
• Caso deficiente : Las infracciones graves indican que la solución no satisface los requisitos de la empresa

La función de validación calculará:

1. Ventas reales por producto en cada región
2. Infracciones de las restricciones para cada producto
3. Distribución del mercado entre regiones

def validate_solution(A, b, solution):
    """Validate market split solution."""
    x = np.array(solution)
    region_a = A @ x
    region_b = A @ (1 - x)
    violations = np.abs(region_a - b)

    return {
        "target": b,
        "region_a": region_a,
        "region_b": region_b,
        "violations": violations,
        "total_violation": np.sum(violations),
        "is_feasible": np.sum(violations) == 0,
        "region_a_markets": int(np.sum(x)),
        "region_b_markets": len(x) - int(np.sum(x)),
    }


# Convert bitstring to list of integers and validate
optimal_assignment = [
    int(bit) for bit in result["solution_info"]["bitstring"]
]
validation = validate_solution(A, b, optimal_assignment)

Interprete los resultados de la validación

Los resultados de la validación muestran si el Optimizador Cuántico encontró una solución factible. Examinemos lo siguiente:

Comprobación de viabilidad:

• is_feasible = True significa que la solución satisface perfectamente todas las restricciones (violación total = 0)
• is_feasible = False significa que se infringen algunas restricciones

Análisis de ventas:

• Comparar las ventas previstas con las reales de cada producto
• Para una solución perfecta Real = Objetivo para todos los productos en ambas regiones
• La diferencia indica lo cerca que estamos de la división deseada del mercado

Distribución en el mercado:

• Muestra cuántos mercados están asignados a cada región
• No se exige el mismo número de mercados, sólo que se cumplan los objetivos de ventas

print("Solution Validation")
print("=" * 50)
print(f"Feasible solution: {validation['is_feasible']}")
print(f"Total constraint violation: {validation['total_violation']}")

print("\nSales Analysis (Target vs Actual):")
for i, (target, actual_a, actual_b) in enumerate(
    zip(validation["target"], validation["region_a"], validation["region_b"])
):
    violation_a = abs(actual_a - target)
    violation_b = abs(actual_b - target)
    print(f"  Product {i+1}:")
    print(f"    Target: {target}")
    print(f"    Region A: {actual_a} (violation: {violation_a})")
    print(f"    Region B: {actual_b} (violation: {violation_b})")

print("\nMarket Distribution:")
print(f"  Region A: {validation['region_a_markets']} markets")
print(f"  Region B: {validation['region_b_markets']} markets")

Evaluación de la calidad de la solución

Basándonos en los resultados de validación anteriores, podemos evaluar la calidad de la solución cuántica:

Si is_feasible = True (Violación total = 0):

• El Optimizador Cuántico encontró con éxito una solución óptima
• Se satisfacen perfectamente todas las exigencias de la empresa
• Esto demuestra la ventaja cuántica en un problema en el que los solucionadores clásicos tienen dificultades [4]

Si is_feasible = False (Violación total > 0):

• La solución es casi óptima pero no perfecta
• Las pequeñas infracciones pueden ser aceptables en la práctica
• Considere la posibilidad de ajustar los parámetros del optimizador:
  • Aumentar num_iterations para más pases de optimización
  • Aumentar postprocessing_level para un refinamiento más clásico
  • Aumentar shots para obtener mejores estadísticas de medición

Interpretación de la función de costes:

• El valor cost de solution_info es igual a $||Ax - b||^2$
• Coste = 0: satisfacción perfecta de las restricciones
• Los valores de coste más altos indican mayores violaciones de las restricciones

Conclusión

Lo que hemos logrado

En este tutorial, con éxito:

1. Carga de un problema de optimización real : Obtención de una instancia de Market Split de la biblioteca de pruebas QOBLIB [2]
2. Transformado a formato QUBO : Conversión del problema restringido en una formulación cuadrática no restringida [3]
3. Aprovechamiento de algoritmos cuánticos avanzados : Utilizado el algoritmo bf-DCQO de Kipu Quantum con términos contradiabáticos [1]
4. Obtención de soluciones óptimas : Encontradas soluciones factibles que satisfacen todas las restricciones

Principales conclusiones

Innovación del algoritmo : El algoritmo bf-DCQO representa un avance significativo [1] :

• 10 veces menos puertas que el recocido cuántico digital
• Aproximadamente 10 iteraciones en lugar de las aproximadamente 100 de los métodos variacionales
• Resistencia a errores integrada gracias a la eficiencia de los circuitos

Términos contradiabáticos : Permiten una rápida evolución cuántica manteniendo la fidelidad al estado terreno, lo que hace que la optimización cuántica sea práctica en el ruidoso hardware actual [1].

Orientación por campo de polarización : El enfoque iterativo del campo de polarización permite que cada iteración comience cerca de las buenas soluciones encontradas previamente, proporcionando una forma de búsqueda local mejorada cuánticamente [1].

Próximos pasos

Para profundizar en su comprensión y explorar más a fondo:

1. Pruebe diferentes instancias : Experimente con otras instancias de QOBLIB de distintos tamaños
2. Ajuste los parámetros : Ajuste num_iterations, preprocessing_level, postprocessing_level
3. Comparación con los métodos clásicos: Comparación con los métodos clásicos de optimización
4. Pruebe diferentes estrategias : Intentar encontrar una codificación mejor para el problema o formularlo como HUBO (si es posible)
5. Aplíquelo a su dominio : Adapte las técnicas de formulación QUBO/HUBO a sus propios problemas de optimización

Referencias

[1] IBM Quantum. "Optimización Cuántica Kipu " IBM Quantum Documentación.

[2] QOBLIB - Biblioteca de evaluación comparativa de optimización cuántica. Instituto Zuse de Berlín (ZIB). https://git.zib.de/qopt/qoblib-quantum-optimization-benchmarking-library

[3] Glover, F., Kochenberger, G., & Du, Y. (2019). "Quantum bridge analytics I: a tutorial on formulating and using QUBO models" 4OR: Revista trimestral de investigación operativa, 17(4), 335-371.

[4] Lodi, A., Tramontani, A., y Weninger, K. (2023). "El Decatlón Intratable: Benchmarking Hard Combinatorial Problems" INFORMS Journal on Computing.