Parity Twine Optimizer: Uma Qiskit Function da ParityQC

Consulte a referência da API

nota

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

Visão geral

O Parity Twine Optimizer permite que os usuários resolvam problemas de otimização com computadores quânticos usando o método Parity Twine. Essa abordagem, construída sobre a Parity Architecture, usa o compilador da ParityQC para minimizar a contagem de portas e a profundidade do circuito necessárias para executar um algoritmo quântico, levando em conta a conectividade do dispositivo.

Essa redução de recursos permite resolver problemas de otimização relevantes para a indústria em tamanhos inviáveis com métodos de transpilação padrão, com uso intenso de SWAPs. O Parity Twine Optimizer automatiza as etapas de transpilação e pode ser usado com entrada mínima do usuário.

A abordagem Parity Twine supera todos os outros métodos de compilação em termos de redução da contagem de portas e da profundidade de circuito para algoritmos quânticos como o algoritmo de otimização aproximada quântica (QAOA) e a transformada de Fourier quântica (QFT). Ao abstrair a informação quântica dos qubits físicos, interações não locais são implementadas sem portas SWAP. Em vez disso, as cadeias Parity Twine (sequências de portas CNOT) distribuem sistematicamente informação de paridade lógica entre os qubits.

O otimizador usa o QAOA para minimizar a energia de uma dada função de custo. O QAOA é um algoritmo variacional híbrido quântico-clássico projetado para resolver problemas de otimização combinatória aproximando o estado fundamental de um Hamiltoniano de custo ($H_C$). Um termo de mistura ($H_B$) impulsiona transições entre estados para explorar o espaço de soluções. Uma sequência alternada desses termos, controlada pelos parâmetros $\gamma$ e $\beta$, define o unitário $U(\gamma, \beta) = \Pi_{i=1}^p e^{-i \beta_i H_B} e^{-i \gamma_i H_C}$, que atua sobre o estado inicial.

A codificação do unitário do problema, exp($-i \beta H_C)$), requer a codificação de todos os operadores de rotação lógicos de $n$ corpos (exp($-i \beta J_{i,j,...n}Z_iZ_j...Z_n$)). Isso pode ser realizado usando geradores de $n$ corpos (Parity Twine Networks), que reduzem a profundidade do circuito QAOA e a contagem de portas de dois qubits.

Descrição

A entrada do Parity Twine Optimizer consiste em um problema de otimização, no nome do hardware IBM Quantum escolhido e em argumentos opcionais adicionais para ajustar as configurações de transpilação e execução em hardware. A função do otimizador encaminha a definição do problema para o Parity Twine Compiler. A Figura 1 mostra um resumo do fluxo de trabalho da função.

O problema de otimização de entrada é pré-processado em um Hamiltoniano (normalizado). O compilador da ParityQC então constrói um circuito ansatz Parity Twine parametrizado, que é transpilado para um ansatz lógico correspondente ao conjunto de portas nativas do hardware escolhido.

Os parâmetros do circuito QAOA são otimizados classicamente usando a abordagem "efficient depth one" e atribuídos ao circuito transpilado. Como é usada apenas uma rodada de QAOA, os parâmetros ótimos $\gamma$ e $\beta$ são obtidos por meio de uma busca em grade (grid search) em uma CPU, sem a necessidade de uma otimização iterativa custosa ao longo de muitas chamadas de circuito. Isso minimiza bastante o tempo de execução em QPU necessário para o otimizador. O tempo de execução por circuito é determinado majoritariamente pelo overhead constante para executar um job na QPU. Com os parâmetros do circuito definidos, o job é submetido à QPU IBM® especificada.

Os resultados brutos são então pós-processados. Esta etapa usa uma busca gulosa (greedy) local que itera aleatoriamente pela string de solução e inverte valores de bit se isso reduzir o valor da função de custo.

Benchmarks

Aviso legal

O desempenho pode depender tanto da instância do problema quanto das etapas de processamento subsequentes. Em alguns casos, amostras clássicas e amostras geradas quanticamente podem atingir qualidade final de solução semelhante após pós-processamento equivalente. A avaliação deve, portanto, considerar o fluxo de trabalho completo de otimização.

Modelo de Sherrington-Kirkpatrick

A Figura 2 demonstra a eficácia do Parity Twine Optimizer. Ela compara os resultados obtidos com o otimizador aos da amostragem aleatória para o modelo de Sherrington-Kirkpatrick com número crescente de qubits.

O pós-processamento tanto dos resultados aleatórios quanto dos do otimizador leva a estados fundamentais exatos, mas a saída bruta de energia mínima do Twine QAOA é sempre melhor do que os valores aleatórios. Para os maiores números de qubits considerados (90 e 100), o ruído do hardware degrada o resultado do otimizador, que reverte para valores brutos equivalentes à amostragem aleatória.

Consulte este tutorial para uma introdução ao modelo de Sherrington-Kirkpatrick e detalhes sobre como resolvê-lo com o Parity Twine Optimizer.

Problema Market Split

A Tabela 1 mostra métricas específicas de desempenho para o Parity Twine Optimizer aplicado a várias instâncias do problema Market Split (MS). Estas foram obtidas na QOBLIB - Quantum Optimization Benchmarking Library e correspondem a submissões feitas à biblioteca usando o Parity Twine Optimizer.

A violação MS é uma métrica de acurácia que mede o quão longe a solução está de satisfazer todas as restrições, definida como $\sum_i ((Ax - b)_i)^2$. Valores menores dessa métrica indicam soluções mais precisas. A Tabela 1 apresenta valores médios de cinco execuções de cada instância usando o Parity Twine Optimizer com o dispositivo ibm_boston como backend e 100.000 shots. É reportada a violação MS mínima obtida entre as execuções de cada instância.

Instância	Qubits	Portas de dois qubits	Profundidade de dois qubits	Violação MS	Tempo de mapeamento (s)	Tempo de execução em QPU (s)	Tempo de pós-processamento (s)
ms_03_050_002	20	399	76	0	45	29	71
ms_03_100_022	20	399	76	0	30	29	77
ms_03_200_177	20	399	76	0	33	29	63
ms_04_050_001	30	899	116	1	68	29	216
ms_04_100_003	30	899	116	2	89	29	187
ms_04_200_030	30	899	116	3	89	29	219
ms_05_100_003	40	1599	156	3	237	30	364
ms_06_050_001	50	2499	196	4	499	30	464
ms_07_050_001	60	3599	236	17	858	31	637
ms_08_050_001	70	4899	276	36	1561	31	773

Tabela 1: Métricas de desempenho para diferentes instâncias do problema Market Split. Os nomes das instâncias correspondem a exemplos na biblioteca de problemas QOBLIB. Como mencionado anteriormente na seção de descrição, o tempo de QPU é mínimo e quase constante, já que apenas uma rodada de QAOA é usada com parâmetros de circuito ótimos obtidos em uma CPU.

Consulte este tutorial para uma introdução ao problema Market Split e detalhes sobre como resolvê-lo com o Parity Twine Optimizer.

Problema Maximum Independent Set

A Figura 3 compara os resultados obtidos usando o otimizador Parity Twine com a amostragem aleatória para o problema do maximum independent set em instâncias selecionadas obtidas na QOBLIB - Quantum Optimization Benchmarking Library. Essas instâncias variam de 18 (mammalia-kangaroo-interactions) a 114 (es60fst03) qubits.

Para instâncias pequenas, os resultados brutos de tamanho do Maximum Independent Set do otimizador e da amostragem aleatória são semelhantes, mas para instâncias maiores, o otimizador oferece resultados muito melhores. O pós-processamento tanto dos resultados de amostragem aleatória quanto dos do otimizador leva novamente a tamanhos de conjunto de acordo com os valores exatos.

Primeiros passos

Autentique-se usando seu token de API do IBM Quantum Platform e selecione a Qiskit Function como:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit_ibm_catalog": "qiskit-ibm-catalog"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

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")

Exemplo

O Parity Twine Optimizer pode ser aplicado a um exemplo simples de QUBO da seguinte forma. O problema é primeiro definido usando um dicionário:

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

Em seguida, o tipo da variável deve ser definido como binary ou spin:

variable_type = "spin"

Isso define a função objetivo $3 + s_0 + 2 s_0s_1 - s_1s_2$, em que $s_i \in \{-1, 1\}$.

Escolha um backend. Por exemplo:

backend_name = "ibm_phoenix"

Use catalog.backends() para ver uma lista dos backends disponíveis na conta/instância do usuário.

Se nenhum backend for especificado, o backend menos ocupado (aquele com o menor número de jobs pendentes) é selecionado automaticamente.

Depois que o otimizador é carregado (veja anteriormente), você pode executá-lo no problema usando as opções padrão:

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

Verifique o status do job da seguinte forma:

# Monitor the job status
function_job.status()

Recupere os resultados da seguinte forma:

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

result

Ao imprimir os resultados, obtém-se o seguinte:

{
    '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}
        }
    }
}

O dicionário solution corresponde aos qubits definidos no problema ($s_0, s_1$ e $s_2$) e fornece seus valores de spin otimizados.

O objective_value é o custo ou a energia do problema de otimização. Ele quantifica a qualidade da solution.

metadata fornece informações sobre a transpilação (contagem/profundidade de portas de dois qubits, portas usadas, qubits ativos) e vários tempos de execução, tanto para o tempo de computação quântica quanto clássica.

Além disso, metadata oferece um vislumbre do funcionamento interno do algoritmo. Você pode ver os parâmetros variacionais otimizados (beta e gamma) e revisar como a distribuição das bitstrings medidas melhorou após o pós-processamento clássico ser aplicado aos resultados quânticos brutos.

Todas as bitstrings na saída de resultado podem ser mapeadas para as variáveis do problema usando variable_mapping. Por exemplo, você pode mapear 'solution_bitstring': '100' com 'variable_mapping': {'0': 0, '1': 1, '2': 2} para a solução binária: {'0': 1, '1': 0, '2': 0}. Como você está resolvendo o problema em termos de variáveis de spin, é necessário aplicar a transformação de binário para spin (0 -> 1, 1 -> -1). Você então chega à solução final 'solution': {'0': -1, '1': 1, '2': 1}.

Consulte a referência da API para todos os detalhes da entrada e saída da função Parity Twine Optimizer.

Registro de alterações

[1.0.2] - 2026-09-15

Notes

Esta versão marca a primeira versão estável de produção da Qiskit Function Parity Twine Optimizer. Espera-se que versões futuras introduzam o seguinte:

• compilação de problemas de ordem superior,
• algoritmos de otimização adicionais, e
• melhorias no pré e no pós-processamento.

Recursos

• Resolva problemas QUBO esparsos e densos com o eficiente Parity Twine Compiler.

Documentação

• Guia do usuário de primeiros passos.
• Tutoriais com exemplos para os problemas Market Split e Sherrington-Kirkpatrick.
• Documentação da API.

Obtenha suporte

Entre em contato com a ParityQC para qualquer dúvida ou problema.

Próximos passos

Recomendações

• Solicite acesso à função preenchendo este formulário.
• Visite a referência da API para esta Qiskit Function.
• Experimente o tutorial para aplicar o Parity Twine Optimizer ao problema Market Split.
• Experimente o tutorial para aplicar o Parity Twine Optimizer ao modelo Sherrington-Kirkpatrick.
• Consulte o preprint do ArXiv Connectivity-aware Synthesis of Quantum Algorithms, Drier et al. (2025).