{
"cells": [
{
"cell_type": "markdown",
"id": "f7d9993f",
"metadata": {},
"source": [
"---\n",
"title: \"Iskay Quantum Optimizer - Uma função Qiskit da Kipu Quantum\"\n",
"description: \"Resolva problemas de otimização com eficiência usando o Iskay Quantum Optimizer da Kipu Quantum, disponível no IBM Qiskit Functions Catalog\"\n",
"---\n",
"\n",
"{/* cspell:ignore Kipu, DCQO, QUBO, HUBO, counterdiabatic, Iskay, bitflips, Cadavid, Chandarana */}\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "dde95705",
"metadata": {},
"source": [
"\n",
"\n",
"# Iskay Quantum Optimizer - Uma função Qiskit da Kipu Quantum\n",
"\n",
"*Consulte a [referência da API](/docs/api/functions/kipu-optimization)*\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "61da1dd5",
"metadata": {
"tags": [
"version-info"
]
},
"source": [
"\n"
]
},
{
"cell_type": "markdown",
"id": "c60ba821",
"metadata": {},
"source": [
"\n",
" * As funções do Qiskit 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). Eles estão no status de versão prévia e estão sujeitos a alterações.\n",
"\n",
"\n",
"\n",
"\n",
"## Visão geral\n",
"\n",
"Com o Iskay Quantum Optimizer da Kipu Quantum, você pode lidar com problemas complexos de otimização usando computadores quânticos IBM®. Este solucionador aproveita [o algoritmo bf-DCQO](https://doi.org/10.48550/arXiv.2409.04477) de ponta da Kipu, exigindo apenas a função objetivo como entrada para fornecer soluções de problemas automaticamente. Ele pode lidar com problemas de otimização que envolvem até 156 qubits, permitindo o uso de todos os qubits dos dispositivos quânticos do IBM. O Otimizador usa um mapeamento 1-to-1 entre variáveis clássicas e qubits, o que permite que você lide com problemas de otimização com até 156 variáveis binárias.\n",
"\n",
"O Optimizer permite a solução de problemas de otimização binária sem restrições. Além da formulação QUBO (Quadratic Unconstrained Binary Optimization) comumente usada, ele também suporta problemas de otimização de ordem superior (HUBO). O solucionador utiliza um algoritmo quântico não-variacional, realizando a maior parte da computação em dispositivos quânticos.\n",
"\n",
"A seguir, há mais detalhes sobre o algoritmo usado e um breve guia sobre como usar a função, além de resultados de benchmarking em várias instâncias de problemas de diferentes tamanhos e complexidades.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "5f761442",
"metadata": {},
"source": [
"\n",
"\n",
"## Descrição\n",
"\n",
"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 compactados em hardware quântico. Essa compressão é obtida com a introdução de termos contra-diabáticos na evolução do tempo subjacente do sistema quântico. O algoritmo executa várias iterações de execuções de hardware para obter as soluções finais e as combina com o pós-processamento. Essas etapas são perfeitamente integradas ao fluxo de trabalho do Optimizer e são executadas automaticamente.\n",
"\n",
"\n",
"\n",
"### Como funciona o Otimizador Quântico?\n",
"\n",
"Esta seção descreve os fundamentos do algoritmo bf-DCQO implementado. Uma introdução ao algoritmo também pode ser encontrada no [canal](https://www.youtube.com/watch?v=33QmsXhIlpU\\&t=1223s) Qiskit YouTube.\n",
"\n",
"O algoritmo é baseado na evolução temporal de um sistema quântico que é transformado ao longo do tempo, em que a solução do problema é codificada no estado fundamental do sistema quântico no final da evolução. De acordo com o [teorema adiabático](https://en.wikipedia.org/wiki/Adiabatic_theorem), essa evolução deve ser lenta para garantir que o sistema permaneça em seu estado fundamental. A digitalização dessa 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 tamanhos cada vez maiores, pois resulta em um aumento da profundidade do circuito. Ao usar protocolos contra-diabáticos, você pode suprimir excitações indesejadas que ocorrem durante tempos curtos de evolução, enquanto permanece no estado fundamental. Aqui, a digitalização desse tempo de evolução mais curto resulta em circuitos quânticos com profundidade mais curta e menos portas de emaranhamento.\n",
"\n",
"Os circuitos dos algoritmos bf-DCQO normalmente usam até dez vezes menos portas de emaranhamento do que o DQA e de três a quatro vezes menos portas de emaranhamento do que as implementações padrão do QAOA. Devido ao menor número de portas, ocorrem menos erros durante a execução do circuito no hardware. Portanto, o otimizador não requer o uso de técnicas como supressão ou atenuação de erros. Implementá-los em versões futuras pode melhorar ainda mais a qualidade da solução.\n",
"\n",
"Embora o algoritmo bf-DCQO use iterações, ele é não-variacional. Após cada iteração do algoritmo, a distribuição dos estados é medida. A distribuição obtida é usada para calcular o chamado campo de polarização. 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. Normalmente, cerca de 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 são da ordem de aproximadamente 100 iterações.\n",
"\n",
"O otimizador combina o algoritmo bf-DCQO com o pós-processamento clássico. Depois de medir a distribuição dos estados, é realizada uma pesquisa local. Durante a pesquisa local, os bits da solução medida são invertidos aleatoriamente. Após a inversão, a energia da nova cadeia de bits é avaliada. Se a energia for menor, a bitstring será mantida como a nova solução. A pesquisa local é escalonada linearmente com o número de qubits; portanto, é computacionalmente barata. Como o pós-processamento corrige os erros de bit-flip locais, ele compensa os erros de bit-flip que geralmente são resultado de imperfeições de hardware e erros de leitura.\n",
"\n",
"\n",
"\n",
"### Fluxo de trabalho\n",
"\n",
"Segue um esquema do fluxo de trabalho do Quantum Optimizer.\n",
"\n",
"![Fluxo de trabalho](https://quantum.cloud.ibm.com/docs/images/guides/kipu-optimization/workflow.svg \"Fluxo de trabalho do Quantum Optimizer\")\n",
"\n",
"Ao usar o Quantum Optimizer, a solução de um problema de otimização em hardware quântico pode ser reduzida a\n",
"\n",
"* Formule a função objetiva do problema\n",
"* Acesse o Otimizador por meio do Qiskit Functions\n",
"* Execute o Optimizer e colete o resultado\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "b34fe075",
"metadata": {},
"source": [
"\n",
"\n",
"## Referências\n",
"\n",
"As métricas de benchmark abaixo mostram que o Otimizador aborda com eficácia problemas que envolvem até 156 qubits e oferecem uma visão geral da precisão e da escalabilidade do otimizador em diferentes tipos de problemas. Observe 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 a localidade dos termos na função objetiva e a ordem polinomial.\n",
"\n",
"A tabela a seguir inclui a taxa de aproximação (AR), uma métrica definida da seguinte forma:\n",
"\n",
"$$\n",
"AR = \\frac{C^{*} - C_\\textrm{max}}{C_{\\textrm{min}} - C_{\\textrm{max}}},\n",
"$$\n",
"\n",
"em que $C$ é a função objetiva, $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 básico do problema foi obtido.\n",
"\n",
"| Exemplo | Número de qubits | Índice de aproximação | Tempo Total (s) | Uso do tempo de execução (s) | Número total de disparos | Número de iterações |\n",
"| -------------------- | :--------------: | :-------------------: | :-------------: | :--------------------------: | :----------------------: | :-----------------: |\n",
"| Não ponderado MaxCut | 28 | 100% | 180 | 30 | 30k | 5 |\n",
"| Não ponderado MaxCut | 30 | 100% | 180 | 30 | 30k | 5 |\n",
"| Não ponderado MaxCut | 32 | 100% | 180 | 30 | 30k | 5 |\n",
"| Não ponderado MaxCut | 130 | 100% | 480 | 60 | 90k | 9 |\n",
"| Não ponderado MaxCut | 100 | 100% | 330 | 60 | 60k | 6 |\n",
"| Não ponderado MaxCut | 120 | 100% | 370 | 60 | 60k | 6 |\n",
"| HUBO 1 | 156 | 100% | 600 | 65 | 100k | 22 |\n",
"| HUBO 2 | 156 | 100% | 600 | 65 | 100k | 22 |\n",
"\n",
"* As instâncias do 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.\n",
"* As instâncias do HUBO também foram executadas em um processador Heron r2.\n",
"\n",
"Todas as instâncias de benchmark podem ser acessadas em GitHub (consulte [Instâncias de benchmark do Kipu](https://github.com/Kipu-Quantum-GmbH/benchmark-instances) ). Um exemplo para executar essas instâncias pode ser encontrado em [Exemplo 3: Instâncias de benchmark](#example-3-benchmark-instances).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "73390a19",
"metadata": {},
"source": [
"\n",
"\n",
"## Introdução\n",
"\n",
"Nesta documentação, vamos percorrer as etapas de utilização 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.\n",
"\n",
"Para um exemplo mais detalhado, consulte o tutorial [Resolva o problema da divisão de mercado com o Iskay Quantum Optimizer da Kipu Quantum](/docs/tutorials/solve-market-split-problem-with-iskay-quantum-optimizer), onde trabalhamos todo o processo de utilização do Iskay Solver para resolver o problema da divisão de mercado, que representa um desafio real de alocação de recursos, em que os mercados devem ser divididos em regiões de vendas equilibradas para atender às metas exatas de demanda.\n",
"\n",
"Autentique-se usando sua chave de API, encontrada no [painel da IBM Quantum Platform](http://quantum.cloud.ibm.com/), e selecione a Qiskit Function da seguinte forma:\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "e5cd4ac8",
"metadata": {},
"source": [
"\n",
" O código a seguir pressupõe que você já tenha salvo suas credenciais. Caso ainda não tenha feito isso, siga as instruções na seção [“Salvar sua conta do IBM Cloud ”](/docs/guides/functions-get-started#install-qiskit-functions-catalog-client) para se autenticar com sua chave de API.\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "68d3ecea-f7e3-4b4b-b299-1670abc72415",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[QiskitFunction(qunova/hivqe-chemistry),\n",
" QiskitFunction(global-data-quantum/quantum-portfolio-optimizer),\n",
" QiskitFunction(algorithmiq/tem),\n",
" QiskitFunction(qedma/qesem),\n",
" QiskitFunction(multiverse/singularity),\n",
" QiskitFunction(ibm/circuit-function),\n",
" QiskitFunction(q-ctrl/optimization-solver),\n",
" QiskitFunction(colibritd/quick-pde),\n",
" QiskitFunction(q-ctrl/performance-management),\n",
" QiskitFunction(kipu-quantum/iskay-quantum-optimizer)]"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit_ibm_catalog import QiskitFunctionsCatalog\n",
"\n",
"catalog = QiskitFunctionsCatalog(\n",
" channel=\"ibm_quantum_platform\",\n",
" instance=\"INSTANCE_CRN\",\n",
" # For `token`, use the 44-character API_KEY you created\n",
" # and saved from the IBM Quantum Platform Home dashboard\n",
" token=\"YOUR_API_KEY\",\n",
")\n",
"\n",
"# verify that you have access to the function\n",
"catalog.list()"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "95a715d2",
"metadata": {},
"outputs": [],
"source": [
"# Access Function\n",
"optimizer = catalog.load(\"kipu-quantum/iskay-quantum-optimizer\")"
]
},
{
"cell_type": "markdown",
"id": "4a8e24f7",
"metadata": {},
"source": [
"\n",
"\n",
"## Exemplo de configuração personalizada\n",
"\n",
"Veja como você pode configurar o Iskay com diferentes opções:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "712dbae3",
"metadata": {},
"outputs": [],
"source": [
"custom_options = {\n",
" \"shots\": 15_000, # Higher shot count for better statistics\n",
" \"num_iterations\": 12, # More iterations for solution refinement\n",
" \"preprocessing_level\": 1, # Light preprocessing for problem simplification\n",
" \"postprocessing_level\": 2, # Maximum postprocessing for solution quality\n",
" \"transpilation_level\": 3, # Use higher transpilation level to optimize circuit\n",
" \"seed_transpiler\": 42, # Fixed seed for reproducible results\n",
" \"job_tags\": [\"custom_config\"], # Custom tracking tags\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "50690350",
"metadata": {},
"source": [
"**Otimização da semente** : Observe que `seed_transpiler` é definido como `None` por padrão. Isso permite o processo de otimização automática do transpiler. Quando `None`, o sistema iniciará um teste com várias sementes e selecionará aquela que produzir a melhor profundidade de circuito, aproveitando todo o poder do `max_trials` parâmetro para cada nível de transpilagem.\n",
"\n",
"**Desempenho do nível de transpilagem** : aumentar o número de `max_trials` com valores mais altos para inevitavelmente `transpilation_level` aumentará o tempo de transpilagem, mas nem sempre alterará o circuito final — isso depende muito da estrutura e da complexidade específicas do circuito. Para alguns circuitos/problemas, no entanto, a diferença entre 10 tentativas (nível 1) e 50 tentativas (nível 5) pode ser dramática, portanto, explorar esses parâmetros pode ser a chave para encontrar uma solução com sucesso.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "d4ca2590",
"metadata": {},
"source": [
"\n",
"\n",
"## Exemplo 1: Função de custo simples\n",
"\n",
"Considere a função de custo na formulação de spin:\n",
"\n",
"$$\n",
"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\n",
"$$\n",
"\n",
"onde $(x_0, ..., x_4) \\in \\{-1, 1\\}^5$.\n",
"\n",
"A solução para essa função de custo simples é\n",
"\n",
"$$\n",
"(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)\n",
"$$\n",
"\n",
"com valor mínimo $C^{*} = -6$\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "a98e8232",
"metadata": {},
"source": [
"\n",
"\n",
"### 1. Crie a função objetivo\n",
"\n",
"Começamos criando um dicionário com os coeficientes da função objetiva da seguinte forma:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3b4a58b1",
"metadata": {},
"outputs": [],
"source": [
"objective_func = {\n",
" \"()\": 1,\n",
" \"(0,)\": 1.5,\n",
" \"(1,)\": 2,\n",
" \"(2,)\": 1.3,\n",
" \"(0, 3)\": 2.5,\n",
" \"(1, 4)\": 3.5,\n",
" \"(0, 1, 2)\": 4,\n",
"}"
]
},
{
"cell_type": "markdown",
"id": "ab63b08f",
"metadata": {},
"source": [
"\n",
"\n",
"### 2. Execute o Otimizador\n",
"\n",
"Resolvemos o problema executando o otimizador. Como $(x_0, ..., x_4) \\in \\{-1, 1\\}^5$, devemos definir `problem_type=spin`.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "469ae361",
"metadata": {},
"outputs": [],
"source": [
"# Setup options to run the optimizer\n",
"options = {\"shots\": 5000, \"num_iterations\": 5, \"use_session\": True}\n",
"\n",
"arguments = {\n",
" \"problem\": objective_func,\n",
" \"problem_type\": \"spin\",\n",
" \"backend_name\": backend_name, # such as \"ibm_fez\"\n",
" \"options\": options,\n",
"}\n",
"\n",
"job = optimizer.run(**arguments)\n",
"\n",
"# Print the ID so you can use it later, if necessary\n",
"print(job.job_id)"
]
},
{
"cell_type": "markdown",
"id": "1e3a8542",
"metadata": {},
"source": [
"\n",
"\n",
"### 3. Recuperar o resultado\n",
"\n",
"A solução do problema de otimização é fornecida diretamente pelo otimizador.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2f74d7e2",
"metadata": {},
"outputs": [],
"source": [
"print(job.result())"
]
},
{
"cell_type": "markdown",
"id": "c4d0a0f8",
"metadata": {},
"source": [
"Isso mostrará um dicionário do formulário:\n",
"\n",
"```\n",
"{'solution': {'0': -1, '1': -1, '2': -1, '3': 1, '4': 1},\n",
" 'solution_info': {'bitstring': '11100',\n",
" 'cost': -13.8,\n",
" 'seed_transpiler': 42,\n",
" 'mapping': {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}},\n",
" 'prob_type': 'spin'}\n",
"```\n",
"\n",
"Observe que o dicionário `solution` exibe o vetor de resultados $(x_0, x_1, x_2, x_3, x_4) = (-1, -1, -1, 1, 1)$.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "7eaa5cac",
"metadata": {},
"source": [
"\n",
"\n",
"## Exemplo 2: MaxCut\n",
"\n",
"Muitos problemas de gráficos, como MaxCut ou Maximum independent set, são problemas NP-hard e candidatos ideais para testar algoritmos e hardware quânticos. Este exemplo demonstra a solução do problema MaxCut de um gráfico 3-regular com o Quantum Optimizer.\n",
"\n",
"Para executar este exemplo, você deve instalar o pacote `networkx` , além do `qiskit-ibm-catalog`. Para instalá-lo, execute o seguinte comando:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9ea6d138",
"metadata": {},
"outputs": [],
"source": [
"# %pip install networkx numpy"
]
},
{
"cell_type": "markdown",
"id": "0c63487f",
"metadata": {},
"source": [
"\n",
"\n",
"### 1. Crie a função objetivo\n",
"\n",
"Comece gerando um gráfico 3-regular aleatório. Para esse gráfico, definimos a função objetiva do problema MaxCut.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d1d4017f",
"metadata": {},
"outputs": [],
"source": [
"import networkx as nx\n",
"\n",
"# Create a random 3-regular graph\n",
"G = nx.random_regular_graph(3, 10, seed=42)\n",
"\n",
"\n",
"# Create the objective function for MaxCut in Ising formulation\n",
"def graph_to_ising_maxcut(G):\n",
" \"\"\"\n",
" Convert a NetworkX graph to an Ising Hamiltonian for the max-cut problem.\n",
" Args:\n",
" G (networkx.Graph): The input graph.\n",
" Returns:\n",
" dict: The objective function of the Ising model\n",
" \"\"\"\n",
" # Initialize the linear and quadratic coefficients\n",
" objective_func = {}\n",
" # Populate the coefficients\n",
" for i, j in G.edges:\n",
" objective_func[f\"({i}, {j})\"] = 0.5\n",
" return objective_func\n",
"\n",
"\n",
"objective_func = graph_to_ising_maxcut(G)"
]
},
{
"cell_type": "markdown",
"id": "3be09664",
"metadata": {},
"source": [
"\n",
"\n",
"### 2. Execute o Otimizador\n",
"\n",
"Resolva o problema executando o otimizador.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2499ab67",
"metadata": {},
"outputs": [],
"source": [
"options = {\"shots\": 5000, \"num_iterations\": 5, \"use_session\": True}\n",
"\n",
"arguments = {\n",
" \"problem\": objective_func,\n",
" \"problem_type\": \"spin\",\n",
" \"backend_name\": backend_name, # such as \"ibm_fez\"\n",
" \"options\": options,\n",
"}\n",
"\n",
"job = optimizer.run(**arguments)"
]
},
{
"cell_type": "markdown",
"id": "3548f6dc",
"metadata": {},
"source": [
"\n",
"\n",
"### 3. Recuperar o resultado\n",
"\n",
"Recuperar o resultado e mapear a bitstring da solução de volta para os nós do gráfico original.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "169cbd6e",
"metadata": {},
"outputs": [],
"source": [
"print(job.result())"
]
},
{
"cell_type": "markdown",
"id": "7f22d66a",
"metadata": {},
"source": [
"A solução do problema Maxcut está contida diretamente no subdicionário `solution` do objeto de resultado\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "38309554",
"metadata": {},
"outputs": [],
"source": [
"maxcut_solution = job.result()[\"solution\"]"
]
},
{
"cell_type": "markdown",
"id": "19a664c4",
"metadata": {},
"source": [
"\n",
"\n",
"## Exemplo 3: Instâncias de referência\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "98545ce3",
"metadata": {},
"source": [
"As instâncias de referência estão disponíveis em [Instâncias de referência do Kipu](https://github.com/Kipu-Quantum-GmbH/benchmark-instances) no GitHub:.\n",
"\n",
"As instâncias podem ser carregadas usando a biblioteca `pygithub` . Para instalá-lo, execute o seguinte comando:\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1d8777e4",
"metadata": {},
"outputs": [],
"source": [
"# %pip install pygithub"
]
},
{
"cell_type": "markdown",
"id": "e3a03447",
"metadata": {},
"source": [
"Os caminhos para as instâncias de benchmark são:\n",
"\n",
"**Maxcut:**\n",
"\n",
"* `'maxcut/maxcut_regular_3_100_nodes_weighted.json'`\n",
"* `'maxcut/maxcut_regular_3_140_nodes_weighted.json'`\n",
"* `'maxcut/maxcut_regular_3_150_nodes_weighted.json'`\n",
"* `'maxcut/maxcut_regular_4_130_nodes_weighted.json'`\n",
"\n",
"**HUBO:**\n",
"\n",
"* `'HUBO/hubo1_marrakesh.json'`\n",
"* `'HUBO/hubo2_marrakesh.json'`\n",
"\n",
"Para reproduzir o desempenho do parâmetro de comparação para as instâncias do HUBO, selecione o backend `ibm_marrakesh` e defina `direct_qubit_mapping` como `True` no subdicionário `options` .\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "adbed9be",
"metadata": {},
"source": [
"O exemplo a seguir executa a instância do Maxcut com 150 nós.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "da681a18",
"metadata": {},
"outputs": [],
"source": [
"from github import Github\n",
"import urllib\n",
"import json\n",
"import ast\n",
"\n",
"repo = \"Kipu-Quantum-GmbH/benchmark-instances\"\n",
"path = \"maxcut/maxcut_regular_3_150_nodes_weighted.json\"\n",
"gh = Github()\n",
"repo = gh.get_repo(repo)\n",
"branch = \"main\"\n",
"file = repo.get_contents(urllib.parse.quote(path), ref=branch)\n",
"\n",
"# load json file with benchmark problem\n",
"problem_json = json.loads(file.decoded_content)\n",
"\n",
"# convert objective function to compatible format\n",
"objective_func = {\n",
" key: ast.literal_eval(value) for key, value in problem_json.items()\n",
"}\n",
"\n",
"\n",
"# Setup configuration to run the optimizer\n",
"options = {\n",
" \"shots\": 5_000,\n",
" \"num_iterations\": 5,\n",
" \"use_session\": True,\n",
" \"direct_qubit_mapping\": False,\n",
"}\n",
"\n",
"arguments = {\n",
" \"problem\": objective_func,\n",
" \"problem_type\": \"spin\",\n",
" \"backend_name\": \"\",\n",
" \"options\": options,\n",
"}\n",
"\n",
"job = optimizer.run(**arguments)\n",
"\n",
"result = job.result()"
]
},
{
"cell_type": "markdown",
"id": "664476ff",
"metadata": {},
"source": [
"\n",
"\n",
"## Casos de uso\n",
"\n",
"Os casos de uso típicos do solucionador de otimização são problemas de otimização combinatória. Você pode resolver problemas de vários setores, como financeiro, farmacêutico ou de logística. Seguem-se\n",
"alguns exemplos:\n",
"\n",
"* Otimização de portfólio (QUBO): [publicação científica](https://doi.org/10.1103/PhysRevApplied.22.054037) e [white paper](https://kipu-quantum.com/zope64/kipu_2024/content/e3915/e3916/e4187/White-Paper-2-Financial-modeling-on-quantum-computers-using-digitally-compressed-algorithms-1.pdf)\n",
"* Dobramento de proteínas (HUBO): [publicação científica](https://doi.org/10.1103/PhysRevApplied.20.014024)\n",
"* Programação de logística (QUBO): [publicação científica](https://doi.org/10.1103/PhysRevApplied.22.064068)\n",
"* Otimização de rede: [webinar](https://www.youtube.com/watch?v=w5SrCIK88No)\n",
"* Divisão do mercado (QUBO): [tutorial](/docs/tutorials/solve-market-split-problem-with-iskay-quantum-optimizer)\n",
"\n",
"Se você estiver interessado em abordar um caso de uso específico e desenvolver um mapeamento dedicado, podemos ajudá-lo. [Entre em contato conosco](https://share-eu1.hsforms.com/2Ff8cgWvTR9ukT_fPoaNhDw2dqpz5).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "e9ec2e67",
"metadata": {},
"source": [
"\n",
"\n",
"## Obtenha suporte\n",
"\n",
"Para obter suporte, entre em contato com [support@kipu-quantum.com](mailto:support@kipu-quantum.com).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "5a6a25c8",
"metadata": {},
"source": [
"\n",
"\n",
"## Próximas etapas\n",
"\n",
"* [Solicite acesso ao Quantum Optimizer da Kipu Quantum](https://share-eu1.hsforms.com/2Ff8cgWvTR9ukT_fPoaNhDw2dqpz5).\n",
"* Consulte a [referência da API](/docs/api/functions/kipu-optimization) para esta função do Qiskit.\n",
"* Experimente [resolver o problema da divisão do mercado com](/docs/tutorials/solve-market-split-problem-with-iskay-quantum-optimizer) o tutorial Iskay Quantum Optimizer da Kipu Quantum.\n",
"* Revisão [Romero, S. V., et al. (2025). Algoritmo quântico contra-diabático digitalizado de campo de polarização para otimização binária de ordem superior. arXiv pré-impressão arXiv:2409.04477](https://arxiv.org/abs/2409.04477).\n",
"* Revisão [Cadavid, A. G., et al. (2024). Otimização quântica contra-diabática digitalizada em campo de polarização. arXiv pré-impressão arXiv:2405.13898](https://arxiv.org/abs/2405.13898).\n",
"* Revisão [Chandarana, P., et al. (2025). Vantagem quântica em tempo de execução com otimização quântica digital. arXiv pré-impressão arXiv:2505.08663](https://arxiv.org/abs/2505.08663).\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "f73ef6c4",
"metadata": {},
"source": [
"\n",
"\n",
"## Informações Adicionais\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "52b5221c",
"metadata": {},
"source": [
"Iskay, assim como o nome de nossa empresa, Kipu Quantum, é uma palavra peruana. Embora sejamos uma startup da Alemanha, essas palavras vêm do país natal de um de nossos cofundadores, onde o Quipu foi uma das primeiras máquinas de calcular desenvolvidas pela humanidade há 2000 anos a.C.\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
}
},
"nbformat": 4,
"nbformat_minor": 5
}