Comece com QDK para correção de erros

O Microsoft Quantum Development Kit (QDK) inclui Python ferramentas para desenvolver e testar protocolos de correção de erros quânticos (QEC). Use o módulo qdk.ec para analisar códigos de correção de erros, criar protocolos executáveis, validar declarações de protocolo e estudar falhas de circuito. Use qdk.simulation para executar programas lógicos por meio desses protocolos.

Entenda as ferramentas de correção de erros QDK

O QDK fluxo de trabalho de correção de erro usa estes pacotes e módulos:

Uma qodec é uma descrição formal de um protocolo QEC executável. Ele conecta instruções lógicas a circuitos físicos por meio de uma ou mais camadas. O qodec pacote define esse modelo de dados e sua YAML representação. O qdk.ec módulo deriva fatos do modelo e verifica se suas declarações correspondem a seus circuitos.

Para obter mais informações, consulte a qodec visão geral.

O qdk.qre módulo tem uma finalidade diferente. Ele modela o custo em recursos de um esquema de correção de erros. Ele não define, audita ou executa dispositivos qodec. Para obter mais informações sobre a estimativa de recurso quântico no QDK, consulte O que é o avaliador de recursos do Microsoft Quantum?

Entender os componentes do qodec protocolo

Os componentes a seguir definem um qodec protocolo e dão suporte à sua execução.

Uma qodec pode conter várias camadas. A camada superior pode definir operações lógicas em blocos codificados. Os gadgets na camada superior podem chamar instruções na próxima camada inferior. A camada inferior contém as operações físicas executadas pelo simulador.

Fluxo de trabalho do protocolo de exemplo

Um fluxo de trabalho típico tem seis etapas. As etapas a seguir usam funções e classes do qdk.ec módulo.

1. Defina um código. Crie um qodec.Code com estabilizadores e Pauli operadores lógicos.
2. Analise o código. Use a classe CodeProfile para inspecionar operadores lógicos, calcular síndromes e calcular a distância do código.
3. Criar ou carregar uma qodec. Use a função build_qodec para criar um protocolo de linha de base ou carregar um qodec existente de YAML.
4. Conclua e valide o protocolo. Use a função filled para derivar equações de verificação e leitura compatíveis. Use a função audit para localizar declarações inconsistentes ou incompletas.
5. Analisar falhas de circuito. Use a classe GadgetProfile para inspecionar ações lógicas, efeitos de falha e distância do dispositivo.
6. Execute os programas lógicos. Compile o código Q# ou OpenQASM para QIR. Passe o QIR e o qodec para qdk.simulation.run_qir, em seguida, selecione um decodificador e um modelo de ruído.

O código a seguir mostra os principais objetos neste fluxo de trabalho:

import qodec
from qdk import ec
from qdk.simulation import run_qir

code = qodec.Code(
    "C4",
    stabilizers=["X_0 X_1 X_2 X_3", "Z_0 Z_1 Z_2 Z_3"],
    x=["X_0 X_1", "X_0 X_2"],
    z=["Z_0 Z_2", "Z_0 Z_1"],
)

code_profile = ec.CodeProfile(code)
print("Code distance:", code_profile.distance())

protocol = ec.build_qodec(code, strategy="bare-css/v1", strict=False)
print(ec.audit(protocol))

# Compile a logical program to QIR before you call run_qir.
# results = run_qir(qir, qodec=protocol, shots=100)

A estratégia bare-css/v1 neste exemplo cria um protocolo de linha de base simples sem qubits de sinalizador. Ele ajuda você a inspecionar o fluxo de trabalho, mas não garante dispositivos tolerantes a falhas. Use a análise de distância entre dispositivos antes de escolher uma implementação de protocolo.

Separe a validação do protocolo da análise de falhas

Auditorias de protocolo e análise de distância avaliam diferentes aspectos de um protocolo QEC.

• As auditorias de protocolo verificam se o protocolo declarado corresponde a seus circuitos e equações quando não ocorrem falhas.
• A análise de distância determina o número mínimo de erros permitidos ou falhas de circuito que podem causar uma falha lógica não detectada.

Use a função audit para verificar a consistência sem ruído. A auditoria verifica a álgebra de código, declarações de instrução, ações de dispositivo, verificações, leituras, sinalizadores, relações de quadro e referências entre objetos qodec.

Uma auditoria que não relata problemas não garante tolerância a falhas. Um circuito pode implementar a ação lógica correta sem falhas e ainda falhar após uma falha física. Use o método CodeProfile.distance para analisar o código e o método GadgetProfile.distance para analisar cada implementação de circuito.

Antes de usar um protocolo para simulações barulhentas, execute uma auditoria de protocolo e analise distâncias de código e gadget.

Escolher uma estratégia de construção

A função build_qodec dá suporte a duas estratégias de construção de baseline CSS.

Ambas as estratégias tentam criar estas instruções lógicas:

• prepare_z_all
• prepare_x_all
• syndrome
• measure_z_all
• measure_x_all
• h_all
• cx_all

Nem todo código dá suporte a todas as opções. Com a configuração strict=Truepadrão, build_qodec gera um erro quando ele não pode criar e verificar uma instrução. Com strict=False, build_qodec mantém as instruções com suporte e registra cada instrução ignorada nos metadados qodec.

Escolha sua próxima tarefa

• Para preparar um Python ambiente, consulte Como instalar QDK para correção de erro.
• Para definir um código e criar um protocolo, consulte Desenvolver e validar um protocolo QEC.
• Para compilar, simular e decodificar programas lógicos, consulte Executar e decodificar programas lógicos.

Para um notebook completo que segue o fluxo de trabalho completo, consulte Desenvolva e teste um protocolo QEC no repositório QDK.