Iskay Quantum Optimizer - Uma Função Qiskit da Kipu Quantum

Veja a referência da API

Nota

• As Qiskit Functions são um recurso experimental disponível apenas para usuários dos planos IBM Quantum® Premium Plan, Flex Plan e On-Prem (via IBM Quantum Platform API). Elas estão em status de lançamento de pré-visualização e sujeitas a alterações.

Visão geral

Com o Iskay Quantum Optimizer da Kipu Quantum, você pode resolver problemas de otimização complexos utilizando computadores quânticos IBM®. Este solver utiliza o avançado algoritmo bf-DCQO da Kipu, que requer apenas a função objetivo como entrada para entregar automaticamente as soluções dos problemas. Ele consegue lidar com problemas de otimização envolvendo até 156 qubits, permitindo o uso de todos os qubits dos dispositivos quânticos IBM. O Optimizer usa um mapeamento 1-para-1 entre variáveis clássicas e qubits, o que permite resolver problemas de otimização com até 156 variáveis binárias.

O Optimizer permite resolver problemas de otimização binária sem restrições. Além da formulação QUBO (Quadratic Unconstrained Binary Optimization) comumente utilizada, ele também suporta problemas de otimização de ordem superior (HUBO). O solver utiliza um algoritmo quântico não-variacional, executando a maior parte do cálculo em dispositivos quânticos.

A seguir, há mais detalhes sobre o algoritmo utilizado, um breve guia de como usar a função e resultados de benchmarking em diversas instâncias de problemas de diferentes tamanhos e complexidades.

Descrição

O Optimizer é uma implementação pronta para uso de algoritmos de otimização quântica de ponta. Ele resolve problemas de otimização executando circuitos quânticos altamente comprimidos em hardware quântico. Essa compressão é obtida introduzindo termos contradiabáticos na evolução temporal subjacente do sistema quântico. O algoritmo executa várias iterações de execuções no hardware para obter as soluções finais e as combina com pós-processamento. Essas etapas são integradas de forma transparente no fluxo de trabalho do Optimizer e são executadas automaticamente.

Como o Quantum Optimizer funciona?

Esta seção descreve os fundamentos do algoritmo bf-DCQO implementado. Uma introdução ao algoritmo também pode ser encontrada no canal do YouTube do Qiskit.

O algoritmo é baseado na evolução temporal de um sistema quântico que se transforma ao longo do tempo, onde a solução do problema é codificada no estado fundamental do sistema quântico ao final da evolução. De acordo com o teorema adiabático, essa evolução deve ser lenta para garantir que o sistema permaneça em seu estado fundamental. Digitalizar essa evolução é a base da computação adiabática quântica digitalizada (DQA) e do famoso algoritmo QAOA. No entanto, a evolução lenta necessária não é viável para problemas de tamanho crescente, pois resulta em um aumento da profundidade do circuito. Ao usar protocolos contradiabáticos, é possível suprimir excitações indesejadas que ocorrem durante tempos de evolução curtos, permanecendo no estado fundamental. Aqui, digitalizar esse tempo de evolução mais curto resulta em circuitos quânticos com menor profundidade e menos portas de emaranhamento.

Os circuitos dos algoritmos bf-DCQO geralmente usam até dez vezes menos portas de emaranhamento do que o DQA, e três a quatro vezes menos portas de emaranhamento do que implementações padrão do QAOA. Por causa do menor número de portas, ocorrem menos erros durante a execução do circuito no hardware. Portanto, o optimizer não requer o uso de técnicas como supressão de erros ou mitigação de erros. Implementá-las em versões futuras pode melhorar ainda mais a qualidade da solução.

Embora o algoritmo bf-DCQO use iterações, ele é não-variacional. Após cada iteração do algoritmo, a distribuição de estados é medida. A distribuição obtida é usada para calcular um chamado campo de polarização (bias-field). O campo de polarização permite iniciar a próxima iteração a partir de um estado de energia próximo à solução encontrada anteriormente. Dessa forma, o algoritmo se move a cada iteração para soluções de menor energia. Tipicamente, aproximadamente dez iterações são suficientes para convergir para uma solução, exigindo no total um número muito menor de iterações do que os algoritmos variacionais, que é da ordem de aproximadamente 100 iterações.

O optimizer combina o algoritmo bf-DCQO com pós-processamento clássico. Após medir a distribuição de estados, uma busca local é realizada. Durante a busca local, os bits da solução medida são invertidos aleatoriamente. Após a inversão, a energia da nova string de bits é avaliada. Se a energia for menor, a string de bits é mantida como a nova solução. A busca local escala apenas linearmente com o número de qubits; portanto, é computacionalmente barata. Uma vez que o pós-processamento corrige inversões de bits locais, ele compensa erros de inversão de bit que frequentemente são resultado de imperfeições do hardware e erros de leitura.

Fluxo de trabalho

A seguir, um esquema do fluxo de trabalho do Quantum Optimizer.

Ao usar o Quantum Optimizer, resolver um problema de otimização em hardware quântico pode ser reduzido a:

• Formular a função objetivo do problema
• Acessar o Optimizer via Qiskit Functions
• Executar o Optimizer e coletar o resultado

Benchmarks

As métricas de benchmark abaixo mostram que o Optimizer aborda efetivamente problemas envolvendo até 156 qubits e oferecem uma visão geral da precisão e escalabilidade do optimizer em diferentes tipos de problemas. Note que as métricas de desempenho reais podem variar dependendo das características específicas do problema, como o número de variáveis, a densidade e localidade dos termos na função objetivo e a ordem polinomial.

A tabela a seguir inclui a razão de aproximação (AR), uma métrica definida da seguinte forma:

$$AR = \frac{C^{*} - C_\textrm{max}}{C_{\textrm{min}} - C_{\textrm{max}}},$$

onde $C$ é a função objetivo, $C_{\textrm{min}}$, $C_{\textrm{max}}$ são seus valores mínimo e máximo, e $C^{*}$ é o custo da melhor solução encontrada, respectivamente. Portanto, AR=100% significa que o estado fundamental do problema foi obtido.

Exemplo	Número de qubits	Razão de Aproximação	Tempo total (s)	Uso de runtime (s)	Número total de shots	Número de iterações
Unweighted MaxCut	28	100%	180	30	30k	5
Unweighted MaxCut	30	100%	180	30	30k	5
Unweighted MaxCut	32	100%	180	30	30k	5
Unweighted MaxCut	80	100%	480	60	90k	9
Unweighted MaxCut	100	100%	330	60	60k	6
Unweighted MaxCut	120	100%	370	60	60k	6
HUBO 1	156	100%	600	70	100k	10
HUBO 2	156	100%	600	70	100k	10

• As instâncias MaxCut com 28, 30 e 32 qubits foram executadas no ibm_sherbrooke. As instâncias com 80, 100 e 120 foram executadas em um processador Heron r2.
• As instâncias HUBO também foram executadas em um processador Heron r2.

Todas as instâncias de benchmark estão acessíveis no GitHub (veja instâncias de benchmark da Kipu). Um exemplo para executar essas instâncias pode ser encontrado em Exemplo 3: Instâncias de benchmark.

Primeiros passos

Nesta documentação, percorreremos as etapas de uso do Iskay Quantum Optimizer. No processo, mostraremos rapidamente como carregar a função do catálogo e como converter seu problema em uma entrada válida, ao mesmo tempo em que mostramos como você pode experimentar diferentes parâmetros opcionais.

Para um exemplo mais detalhado, consulte o tutorial Resolva o problema de Market Split com o Iskay Quantum Optimizer da Kipu Quantum, onde trabalhamos todo o processo de uso do Iskay Solver para resolver o problema de Market Split, que representa um desafio real de alocação de recursos onde os mercados devem ser particionados em regiões de vendas equilibradas para atender às metas exatas de demanda.

Autentique-se usando sua chave de API, encontrada no painel do IBM Quantum Platform, e selecione a Qiskit Function da seguinte forma:

# Added by doQumentation — required packages for this notebook
!pip install -q PyGithub networkx qiskit-ibm-catalog

# ruff: noqa: F821

nota

O código a seguir pressupõe que você salvou suas credenciais. Caso não tenha feito isso, siga as instruções em salvar sua conta IBM Cloud para autenticar com sua chave de API.

from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(
    channel="ibm_quantum_platform",
    instance="INSTANCE_CRN",
    token="YOUR_API_KEY",  # Use the 44-character API_KEY you created and saved from the IBM Quantum Platform Home dashboard
)

# Access Function
optimizer = catalog.load("kipu-quantum/iskay-quantum-optimizer")

Exemplo de configuração personalizada

Veja como você pode configurar o Iskay com diferentes configurações:

custom_options = {
    "shots": 15_000,  # Higher shot count for better statistics
    "num_iterations": 12,  # More iterations for solution refinement
    "preprocessing_level": 1,  # Light preprocessing for problem simplification
    "postprocessing_level": 2,  # Maximum postprocessing for solution quality
    "transpilation_level": 3,  # Using higher transpilation level for circuit optimization
    "seed_transpiler": 42,  # Fixed seed for reproducible results
    "job_tags": ["custom_config"],  # Custom tracking tags
}

Exemplo 1: Função de custo simples

Considere a função de custo na formulação spin:

$$C(x_0, x_1, x_2, x_3, x_4) = 1 + 1.5x_0 + 2x_1 + 1.3x_2 + 2.5x_0x_3 + 3.5x_1x_4 + 4x_0x_1x_2$$

onde $(x_0, ..., x_4) \in \{-1, 1\}^5$.

A solução desta função de custo simples é

$$(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)$$

com valor mínimo $C^{*} = -6$

1. Criar a função objetivo

Começamos criando um dicionário com os coeficientes da função objetivo da seguinte forma:

objective_func = {
    "()": 1,
    "(0,)": 1.5,
    "(1,)": 2,
    "(2,)": 1.3,
    "(0, 3)": 2.5,
    "(1, 4)": 3.5,
    "(0, 1, 2)": 4,
}

2. Executar o Optimizer

Resolvemos o problema executando o optimizer. Como $(x_0, ..., x_4) \in \{-1, 1\}^5$, devemos definir problem_type=spin.

# Setup options to run the optimizer
options = {"shots": 5000, "num_iterations": 5, "use_session": True}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": backend_name,  # such as "ibm_fez"
    "options": options,
}

job = optimizer.run(**arguments)

3. Recuperar o resultado

A solução do problema de otimização é fornecida diretamente pelo optimizer.

print(job.result())

Isso exibirá um dicionário da forma:

{'solution': {'0': -1, '1': -1, '2': -1, '3': 1, '4': 1},
 'solution_info': {'bitstring': '11100',
  'cost': -13.8,
  'seed_transpiler': 42,
  'mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}},
 'prob_type': 'spin'}

Observe que o dicionário solution exibe o vetor resultado $(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)$.

Exemplo 2: MaxCut

Muitos problemas de grafos como MaxCut ou conjunto independente máximo são problemas NP-difíceis e candidatos ideais para testar algoritmos quânticos e hardware. Este exemplo demonstra como resolver o problema MaxCut de um grafo 3-regular com o Quantum Optimizer.

Para executar este exemplo, você deve instalar o pacote networkx além do qiskit-ibm-catalog. Para instalá-lo, execute o seguinte comando:

# %pip install networkx numpy

1. Criar a função objetivo

Comece gerando um grafo 3-regular aleatório. Para este grafo, definimos a função objetivo do problema MaxCut.

import networkx as nx

# Create a random 3-regular graph
G = nx.random_regular_graph(3, 10, seed=42)

# Create the objective function for MaxCut in Ising formulation
def graph_to_ising_maxcut(G):
    """
    Convert a NetworkX graph to an Ising Hamiltonian for the max-cut problem.
    Args:
        G (networkx.Graph): The input graph.
    Returns:
        dict: The objective function of the Ising model
    """
    # Initialize the linear and quadratic coefficients
    objective_func = {}
    # Populate the coefficients
    for i, j in G.edges:
        objective_func[f"({i}, {j})"] = 0.5
    return objective_func

objective_func = graph_to_ising_maxcut(G)

2. Executar o Optimizer

Resolva o problema executando o optimizer.

options = {"shots": 5000, "num_iterations": 5, "use_session": True}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": backend_name,  # such as "ibm_fez"
    "options": options,
}

job = optimizer.run(**arguments)

3. Recuperar o resultado

Recupere o resultado e mapeie a string de bits da solução de volta aos nós do grafo original.

print(job.result())

A solução para o problema MaxCut está diretamente contida no sub-dicionário solution do objeto de resultado

maxcut_solution = job.result()["solution"]

Exemplo 3: Instâncias de benchmark

As instâncias de benchmark estão disponíveis no GitHub: instâncias de benchmark da Kipu.

As instâncias podem ser carregadas usando a biblioteca pygithub. Para instalá-la, execute o seguinte comando:

# %pip install pygithub

Os caminhos para as instâncias de benchmark são:

Maxcut:

• 'maxcut/maxcut_28_nodes.json'
• 'maxcut/maxcut_30_nodes.json'
• 'maxcut/maxcut_32_nodes.json'
• 'maxcut/maxcut_80_nodes.json'
• 'maxcut/maxcut_100_nodes.json'
• 'maxcut/maxcut_120_nodes.json'

HUBO:

• 'HUBO/hubo1_marrakesh.json'
• 'HUBO/hubo2_marrakesh.json'

Para reproduzir o desempenho do benchmark para as instâncias HUBO, selecione o backend ibm_marrakesh e defina direct_qubit_mapping como True no sub-dicionário options. O exemplo a seguir executa a instância Maxcut com 32 nós.

from github import Github
import urllib
import json
import ast

repo = "Kipu-Quantum-GmbH/benchmark-instances"
path = "maxcut/maxcut_32_nodes.json"
gh = Github()
repo = gh.get_repo(repo)
branch = "main"
file = repo.get_contents(urllib.parse.quote(path), ref=branch)

# load json file with benchmark problem
problem_json = json.loads(file.decoded_content)

# convert objective function to compatible format
objective_func = {
    key: ast.literal_eval(value) for key, value in problem_json.items()
}

# Setup configuration to run the optimizer
options = {
    "shots": 5_000,
    "num_iterations": 5,
    "use_session": True,
    "direct_qubit_mapping": False,
}

arguments = {
    "problem": objective_func,
    "problem_type": "spin",
    "backend_name": "ibm_brisbane",
    "options": options,
}

job = optimizer.run(**arguments)

result = job.result()

Casos de uso

Casos de uso típicos para o solver de otimização são problemas de otimização combinatória. Você pode resolver problemas de muitas indústrias como finanças, farmácia ou logística. Alguns exemplos:

• Otimização de portfólio (QUBO): publicação científica e white paper
• Dobramento de proteínas (HUBO): publicação científica
• Agendamento logístico (QUBO): publicação científica
• Otimização de redes: webinar
• Market split (QUBO): tutorial

Se você tiver interesse em abordar um caso de uso específico e desenvolver um mapeamento dedicado, podemos ajudá-lo. Entre em contato conosco.

Obter suporte

Para suporte, entre em contato pelo e-mail support@kipu-quantum.com.

Próximos passos

• Solicite acesso ao Quantum Optimizer da Kipu Quantum.
• Visite a referência da API para esta Qiskit Function.
• Experimente o tutorial Resolva o problema de Market Split com o Iskay Quantum Optimizer da Kipu Quantum.
• Consulte Romero, S. V., et al. (2025). Bias-Field Digitized Counterdiabatic Quantum Algorithm for Higher-Order Binary Optimization. arXiv preprint arXiv:2409.04477.
• Consulte Cadavid, A. G., et al. (2024). Bias-field digitized counterdiabatic quantum optimization. arXiv preprint arXiv:2405.13898.
• Consulte Chandarana, P., et al. (2025). Runtime Quantum Advantage with Digital Quantum Optimization. arXiv preprint arXiv:2505.08663.

Informações adicionais

Iskay, assim como o nome da nossa empresa Kipu Quantum, é uma palavra peruana. Embora sejamos uma startup da Alemanha, essas palavras vêm do país natal de um dos nossos co-fundadores, onde o Quipu foi uma das primeiras máquinas de cálculo desenvolvidas pela humanidade há 2000 anos a.C.