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 quântica de erros (QEC). Use o qdk.ec módulo para analisar códigos de correção de erros, construir protocolos executáveis, validar declarações de protocolo e estudar falhas de circuito. Use qdk.simulation para executar programas lógicos através desses protocolos.

Compreenda as ferramentas QDK de correção de erros

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

A qodec é uma descrição formal de um protocolo executável de QEC. Liga instruções lógicas a circuitos físicos através de uma ou mais camadas. O qodec pacote define este modelo de dados e a sua YAML representação. O qdk.ec módulo deriva factos do modelo e verifica se as suas declarações correspondem aos seus circuitos.

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

O qdk.qre módulo tem um propósito diferente. Modela o custo de recursos de um esquema de correção de erros. Não define, não audita nem executa qodec gadgets. Para mais informações sobre a estimativa de recursos quânticos no QDK, veja O que é o estimador de recursos quânticos da Microsoft?

Compreender os qodec componentes do protocolo

Os seguintes componentes definem um qodec protocolo e suportam a sua execução.

A qodec pode conter várias camadas. A camada superior pode definir operações lógicas sobre blocos codificados. Os gadgets na camada superior podem chamar instruções na camada inferior seguinte. A camada inferior contém as operações físicas que o simulador executa.

Exemplo de fluxo de trabalho de protocolo

Um fluxo de trabalho típico tem seis passos. Os passos seguintes utilizam funções e classes do qdk.ec módulo.

1. Defina um código. Cria um qodec.Code com estabilizadores e operadores lógicos Pauli .
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. Construa ou carregue um qodec. Use a função build_qodec para criar um protocolo base, ou carregue um qodec existente a partir de YAML.
4. Complete e valide o protocolo. Utilize a função filled para derivar equações de verificação e leitura suportadas. Use a função audit para encontrar 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 dos gadgets.
6. Execute programas lógicos. Compilar código Q# ou OpenQASM para QIR. Passe o QIR e qodec para qdk.simulation.run_qir, depois selecione um descodificador e um modelo de ruído.

O código seguinte mostra os principais objetos deste 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 bare-css/v1 estratégia neste exemplo cria um protocolo base simples sem qubits flag. Ajuda a inspecionar o fluxo de trabalho, mas não garante aparelhos tolerantes a falhas. Utilize a análise da distância entre gadgets 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 aspetos de um protocolo QEC.

• As auditorias de protocolo verificam se o protocolo declarado corresponde aos 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 detetada.

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

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

Antes de usares um protocolo para simulações ruidosas, faz uma auditoria ao protocolo e analisa as distâncias do código e dos dispositivos lógicos.

Escolha uma estratégia de construção

A build_qodec função suporta duas estratégias de construção base 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 todos os códigos suportam todos os candidatos. Com a definição strict=Truepadrão, build_qodec gera um erro quando não consegue construir e verificar uma instrução. Com strict=False, build_qodec mantém as instruções suportadas e regista cada instrução saltada nos qodec metadados.

Escolhe a tua próxima tarefa

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

Para um caderno completo que segue todo o fluxo de trabalho, consulte Desenvolver e testar um protocolo QEC no QDK repositório.