Orbit — uma função do Qiskit desenvolvida pela Quantum Elements

Consulte a referência da API

Visão geral

O hardware quântico continua a avançar, mas o ruído e a decoerência ainda limitam a profundidade e a confiabilidade dos circuitos quânticos práticos. Entre as abordagens disponíveis, três técnicas complementares podem atenuar substancialmente essas limitações: desacoplamento dinâmico (DD), transpilação otimizada e mitigação de erros de medição (MEM). A transpilacão otimizada reduz a profundidade do circuito e alinha melhor os circuitos à conectividade do hardware de destino; o DD suprime o ruído em tempo ocioso por meio de sequências de controle cuidadosamente projetadas; e o MEM reduz os efeitos dos erros de leitura e pode ser aplicado durante o pós-processamento.

A escolha de uma estratégia eficaz de DD é particularmente complexa, pois há inúmeras famílias de sequências disponíveis, e uma sequência que apresenta bom desempenho em um determinado circuito ou ambiente de ruído pode não ter o mesmo desempenho em outro. Os benefícios da transpilação, do DD e do MEM dependem do problema, do hardware e da carga de trabalho; usados individualmente ou em combinação, eles podem melhorar o desempenho, mas não são universalmente benéficos em todas as configurações.

O Orbit, uma função do Qiskit desenvolvida pela Quantum Elements, combina perfeitamente os três componentes em um fluxo de trabalho unificado, facilitando seu uso para melhorar a execução de circuitos em um hardwar IBM Quantum. Em sua forma básica, o Orbit aplica automaticamente estratégias ativas de supressão de erros que protegem os estados quânticos durante os períodos de inatividade, ao mesmo tempo em que preserva a lógica original do circuito. Vale destacar que isso é feito sem introduzir nenhum tempo adicional de pré-processamento, seja quântico ou clássico, evitando assim custos adicionais desnecessários ou tempo de espera no fluxo de trabalho.

Em vez de funcionar como uma caixa preta, o Orbit permite que os usuários avaliem e ajustem seus componentes de otimização para um experimento específico. Os usuários podem ativar ou desativar de forma independente a transpilagem otimizada, o DD e o MEM; comparar a seleção automática do DD com sequências especificadas pelo usuário; e executar várias configurações dentro do mesmo fluxo de trabalho. Ao comparar cada configuração com o circuito bruto, os usuários podem determinar quais técnicas proporcionam benefícios mensuráveis para seu circuito e backend, identificar interações entre os diferentes métodos de otimização e selecionar a configuração que melhor atende ao seu objetivo experimental. Esse processo orienta os usuários a compreender de onde provêm os ganhos de desempenho e a tomar decisões mais bem fundamentadas ao otimizar circuitos quânticos para uma determinada carga de trabalho.

Descrição

O Orbit foi projetado para aprimorar a execução de circuitos quânticos em backends d IBM Quantum. No modo automatizado, os usuários podem aplicar sequências DD robustas de ordem elevada de forma integrada, sem precisar selecioná-las ou configurá-las manualmente. Os usuários avançados podem, por outro lado, experimentar as sequências de ordem superior disponíveis para identificar e otimizar a abordagem que oferece o melhor desempenho para um circuito específico.

O Orbit também fornece MEM instantâneo, sem exigir as tarefas adicionais normalmente necessárias para fluxos de trabalho separados de calibração e mitigação. Para cargas de trabalho nas quais a transpilagem não deve alterar a estrutura do circuito, como circuitos de correção de erros quânticos com medições no meio do circuito ou circuitos dinâmicos, o Orbit pode aplicar DD e MEM sem interferir na estratégia de transpilagem existente do usuário. Para usuários que ainda não tenham uma abordagem preferida, o Orbit também inclui um transpilador integrado para otimizar circuitos para o hardware de destino antes de aplicar técnicas de supressão de erros e mitigação de leitura.

Ao contrário de abordagens que dependem de amostragem adicional de circuitos, extrapolação ou pós-processamento clássico extensivo, o Orbit se concentra na supressão de erros durante a execução. A função foi projetada para introduzir uma sobrecarga mínima, preservando a lógica original do circuito. Os usuários podem examinar o circuito resultante e comparar diretamente as execuções otimizadas pelo Orbit com as execuções padrão.

Um fluxo de trabalho prático do Orbit é:

1. Defina um circuito quântico e selecione o Orbit por meio do Qiskit Functions Catalog.
2. Inclua o circuito sem o Orbit, utilizando o modo “Raw”, para estabelecer uma linha de base do circuito bruto.
3. Escolha quais estratégias de otimização aplicar, incluindo sequências de DD automatizadas ou selecionadas pelo usuário, MEM e transpilação otimizada.
4. Ative ou desative métodos individuais, ou envie várias configurações, para avaliar seus efeitos isolados e combinados.

O Orbit é particularmente útil para circuitos que contêm períodos de inatividade ou lacunas de programação, nos quais os qubits não estão participando ativamente das portas lógicas. Ele oferece suporte a circuitos estáticos e dinâmicos, incluindo fluxos de trabalho com medições no meio do circuito e experimentos de computação quântica tolerantes a falhas. As aplicações típicas incluem correção de erros quânticos, experimentos com códigos de superfície em redes quadradas e hexagonais pesadas, algoritmos oraculares como o de Bernstein-Vazirani, circuitos de transformada de Fourier, algoritmos quânticos variacionais, simulação hamiltoniana, experimentos de benchmarking e otimização de circuitos com consideração do hardware.

De olho na era da tolerância a falhas, o Orbit também é compatível com fluxos de trabalho de computação quântica tolerantes a falhas, já que pode ser combinado perfeitamente com a correção de erros quânticos. A longo prazo, o Orbit aponta para o desacoplamento dinâmico no nível lógico [1] como um caminho voltado para o futuro para proteger os qubits lógicos. No exemplo abaixo, dois qubits lógicos foram entrelaçados para criar um estado lógico de Bell no contexto da detecção de erros quânticos. A detecção de erros quântica, por si só, fez com que a fidelidade do estado de Bell decaísse para aproximadamente 44% ao longo de dezenas de microssegundos, enquanto a QED combinada com a proteção do tipo Orbit manteve a fidelidade lógica do estado de Bell próxima do máximo da escala, atingindo aproximadamente 95.3 % durante o mesmo intervalo de tempo.

Referências

Os resultados a seguir resumem execuções representativas do Orbit em um hardware d IBM Quantum. Assim como em outros testes de desempenho de hardware, os resultados dependem do dispositivo selecionado, do estado de calibração, do circuito e das configurações de execução.

Definições de métrica

• Fidelidade da sequência de bits oculta de Bernstein–Vazirani: Probabilidade de medir a sequência de bits oculta correta. Essa métrica indica o grau de confiabilidade com que o algoritmo recupera a solução pretendida à medida que o tamanho do circuito aumenta. A tabela apresenta as três maiores sequências de bits ocultas avaliadas com sucesso em três configurações diferentes: (i) circuitos brutos sem o Orbit, que atingiram 26 qubits; (ii) circuitos apenas com transpilação, que atingiram 60 qubits; e (iii) circuitos que utilizaram o fluxo de trabalho completo do Orbit, que atingiram 70 qubits. Para os circuitos originais (i), o fator de melhoria representa o ganho de desempenho alcançado pelos circuitos DD e MEM em relação aos circuitos não modificados. No caso da configuração exclusiva de transpilagem (ii), isso representa a melhoria alcançada com a adição de DD e MEM aos circuitos transpilados de maneira otimizada. Para a configuração completa do Orbit (iii), não foi relatado nenhum fator de melhoria da linha de base, pois só foi obtida uma probabilidade de sucesso diferente de zero quando todos os componentes do Orbit (transpilação, DD e MEM) estavam ativados. Segue abaixo um exemplo ilustrativo.

• Fidelidade da transformada de Fourier quântica: Tanto para as implementações da QFT unitária quanto para as de circuito dinâmico [2], a fidelidade mede a concordância entre a transformação implementada experimentalmente e o processo ideal da QFT em 20 estados de entrada diferentes. Os circuitos dinâmicos apresentam um tempo de inatividade considerável devido às medições realizadas no meio do circuito e ao feedforward clássico, durante o qual o desacoplamento dinâmico pode suprimir a decoerência. A melhoria relatada compara a fidelidade obtida com o Orbit à fidelidade bruta.

• Preparação do estado de Bell de longo alcance: Criação de um estado de Bell por meio de circuitos dinâmicos e operações de feedforward entre dois qubits separados por até 60 qubits intermediários, demonstrando assim um entrelaçamento eficiente de longo alcance em hardware quântico conectado localmente [3]. O Orbit identifica o melhor roteamento dos qubits, preserva os qubits durante as medições de feedforward e aplica o MEM para mitigar erros de leitura.

• Probabilidade de erro lógico no código de superfície: Para o código de superfície “heavy-hex” [4] e o código de superfície de rede quadrada [5], foram realizadas experiências com memória quântica nas quais um estado lógico codificado foi preservado ao longo de rodadas repetidas de correção de erros. A probabilidade de erro lógico mede a probabilidade de que os erros acumulados façam com que a informação codificada seja recuperada incorretamente (quanto menor for a probabilidade de erro, melhor). A melhoria relatada compara a probabilidade de erro lógico dos circuitos em bruto com a obtida com o Orbit.

• Erro absoluto do VQE: Utilização do VQE com um ansatz unitário de cluster acoplado otimizado para estimar a energia do estado fundamental de um LiH o [6]. A energia medida é comparada com a energia ideal correspondente, obtida a partir do circuito sem ruído. A métrica é a diferença absoluta entre as energias medidas e as ideais (valores mais baixos são melhores). A melhoria relatada é:

Valores maiores que um indicam que o Orbit reduz o erro de energia em relação à execução sem desacoplamento dinâmico.

• Probabilidade de sucesso do QAOA: Probabilidade de se obter uma sequência de bits correspondente a uma solução ótima do problema de otimização definido no grafo borboleta. A melhoria relatada compara a probabilidade de sucesso obtida com o Orbit àquela obtida a partir dos circuitos brutos.

• Fidelidade lógica: No experimento [1] de desacoplamento dinâmico lógico [ [4,2,2] ], dois qubits lógicos foram codificados em quatro qubits físicos e preparados como um estado lógico de Bell entrelaçado. A fidelidade lógica mede a concordância entre o estado codificado recuperado e o estado lógico de Bell alvo. A melhoria relatada compara a fidelidade lógica média obtida com o Orbit e a detecção de erros (capacidade do código) à obtida quando se utiliza apenas o código.

Introdução

Autentique-se usando sua chave de API IBM Quantum Platform e selecione a função Orbit da seguinte forma. Este trecho pressupõe que você já tenha salvo sua conta no seu ambiente local.

from qiskit_ibm_catalog import QiskitFunctionsCatalog
from qiskit import QuantumCircuit

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")
# Verify that you have access to the function.
catalog.list()

Output:

[QiskitFunction(quantum-elements/orbit)]

# Load the function.
orbit = catalog.load("quantum-elements/orbit")

Exemplo

O exemplo a seguir cria um circuito de Bernstein-Vazirani e o envia ao Orbit de duas maneiras em uma única tarefa: execução bruta e configurações padrão do Orbit.

Use esse padrão quando quiser fazer uma comparação direta entre o formato bruto e o Orbit.

Construa um circuito de Bernstein-Vazirani

Escolha a sequência de bits oculta e construa o circuito lógico. O qubit adicional é o alvo do oráculo, enquanto os qubits de entrada são medidos.

def create_bv_circuit(hidden_bitstring: str) -> QuantumCircuit:
    width = len(hidden_bitstring)
    circuit = QuantumCircuit(width + 1, width)

    circuit.x(width)
    circuit.h(range(width + 1))

    for input_qubit, bit in enumerate(reversed(hidden_bitstring)):
        if bit == "1":
            circuit.cx(input_qubit, width)

    circuit.barrier()
    circuit.h(range(width + 1))
    circuit.measure(range(width), range(width))
    return circuit


circuit_width = 50
hidden_bitstring = "1" * circuit_width
shots = 4096

bv_circuit = create_bv_circuit(hidden_bitstring)
bv_circuit.count_ops()

Output:

OrderedDict([('h', 102),
             ('cx', 50),
             ('measure', 50),
             ('x', 1),
             ('barrier', 1)])

Prepare a carga de trabalho do Orbit

Crie um Sampler PUB e, em seguida, duplique-o para os dois modos de comparação. O Orbit recebe o circuito lógico e o mapeia para o backend selecionado durante a execução.

base_pub = (bv_circuit, None, shots)
comparison_labels = ["raw", "orbit"]
pubs = [base_pub] * len(comparison_labels)

Executar no modo “raw” e com as configurações padrão do Orbit

pub_options atribui ao primeiro PUB o modo “raw”, que ignora a otimização do Orbit, o DD e o MEM, e atribui ao segundo PUB as configurações padrão do Orbit, que incluem transpilação otimizada, inserção automatizada de desacoplamento dinâmico (DD) e mitigação de erros de medição (MEM).

backend_name = "ibm_kingston"

job = orbit.run(
    primitive="sampler",
    pubs=pubs,
    backend_name=backend_name,
    options={
        "pub_options": [
            {"mode": "raw"},
            {"mode": "orbit"},
        ],
        "save_backend_info": True,
    },
)

# Check the job ID and status
print(job.job_id)
print(job.status())

Output:

c0f1b99c-8dfa-4ebb-9560-d9a37c990acc
QUEUED

Recupere o resultado e compare os circuitos brutos e os aprimorados pelo Orbit por meio das contagens. Para os resultados do Sampler, get_counts() o registro clássico retornado fornece o histograma de saída. Quando o MEM é executado com sucesso para o Orbit PUB, esse histograma já vem corrigido pelo MEM; as contagens não corrigidas permanecem disponíveis nos metadados do Orbit em measurementErrorMitigation["rawCounts"].

def extract_counts(pub_result) -> dict[str, int]:
    data = getattr(pub_result, "data", None)
    if data is None:
        raise TypeError("pub_result.data is missing")

    for name in dir(data):
        if name.startswith("_"):
            continue
        register = getattr(data, name)
        get_counts = getattr(register, "get_counts", None)
        if callable(get_counts):
            counts = get_counts()
            if counts:
                return counts

    raise TypeError(
        "No classical register with get_counts() found in pub_result.data"
    )


result = job.result()
if len(result) != len(comparison_labels):
    raise RuntimeError(
        f"Expected {len(comparison_labels)} PUB results, received {len(result)}."
    )

comparison_counts = {
    label: extract_counts(pub_result)
    for label, pub_result in zip(comparison_labels, result, strict=True)
}
correct_counts = {
    label: counts.get(hidden_bitstring, 0)
    for label, counts in comparison_counts.items()
}

print(
    {
        "hidden_bitstring": hidden_bitstring,
        "correct_counts": correct_counts,
        "shots": shots,
    }
)

Output:

{'hidden_bitstring': '11111111111111111111111111111111111111111111111111', 'correct_counts': {'raw': 0, 'orbit': 184}, 'shots': 4096}

Faça uma comparação visual entre os circuitos em bruto e os aprimorados pelo Orbit.

import matplotlib.pyplot as plt

labels = list(correct_counts)
values = list(correct_counts.values())
fig, ax = plt.subplots(figsize=(7, 4))
bars = ax.bar(labels, values, width=0.55)
ax.bar_label(bars, labels=[f"{value:g}" for value in values], padding=3)
ax.set_xlabel("Circuit execution mode")
ax.set_ylabel("Correct hidden-bitstring count")
ax.set_title(f"{circuit_width}-qubit Bernstein-Vazirani on {backend_name}")
ax.set_ylim(0, max(1, 1.15 * max(values)))
ax.grid(axis="y", alpha=0.25)
fig.tight_layout()
plt.show()

Output:

Obtenha suporte

Entre em contato com o suporte da Quantum Elements: [email protected]

Certifique-se de incluir as seguintes informações:

• ID da tarefa da função do Qiskit (qiskit-ibm-catalog), job.job_id
• Nome do back-end
• Orbit pub_options utilizado nos modos “raw” e “Orbit”
• Uma descrição detalhada do problema
• Quaisquer mensagens ou códigos de erro relevantes
• Etapas para reproduzir o problema

Próximas etapas

Referências

1. Supressão de erros em nível lógico combinada com a Detecção Quântica de Erros, Nature Communications (2026)
2. Transformada de Fourier quântica utilizando circuitos dinâmicos, Physical Review Letters (2024)
3. Entrelaciamento eficiente de longo alcance utilizando circuitos dinâmicos, PRX Quantum (2024)
4. Experimentos de escalonamento de código de superfície em uma rede Heron do tipo “ IBM ” com conectividade “heavy-hex”, arXiv:2510.18847
5. Experimentos com o código Surface em um Nighthawk d IBM, com conectividade em rede quadrada, arXiv:2606.11496
6. Referência de benchmark VQE, Nature Physics (2024)