Stim suporte para correção de erro quântico no QDK

Stim é uma ferramenta de software livre da Google Quantum AI para simulação rápida e análise de circuitos estabilizadores quânticos, especialmente circuitos de QEC (correção de erros quânticos). Os protocolos QEC geralmente usam rodadas repetidas de Clifford operações e Pauli medidas, e os pesquisadores geralmente analisam protocolos QEC com Pauli modelos de ruído. Essa estrutura de circuito é muito mais eficiente para simular clássicamente do que um circuito quântico geral, para que os pesquisadores possam testar muitas execuções de grandes circuitos de correção de erros.

O Microsoft Quantum Development Kit (QDK) inclui QDK-Stim, que amplia Stim com recursos adicionais. Você pode escrever circuitos com o Stim conjunto de instruções, compilá-los para representação intermediária quântica (QIR) e executá-los nos QDK simuladores. QDK-Stim adiciona suporte para perda de qubit, pós-seleção, padrões de repetição até o sucesso e operações não Clifford.

Acesse QDKQDK-Stim por meio do qdk.stim módulo. O módulo aceita o Stim código-fonte e executa o programa compilado em QDK simuladores. A QDKPython API não tem a funcionalidade completa do pacote stim.Circuitstim e não expõe classes como Python, samplers compilados ou modelos de erro do detector.

Para obter mais informações sobreStim, consulte o Stim repositório no GitHub.

Prerequisites

Para usar circuitos Stim com o QDK, você precisa de:

  • Python 3.10 ou posterior.
  • pip ou outro gerenciador Python de pacotes.
  • Um Python ambiente, como um ambiente virtual ou Jupyter Notebook.
  • Familiaridade básica com o formato doStim circuito.

Instalar e usar Stim com o QDK

Instale ou atualize o QDKPython pacote:

pip install --upgrade qdk

Importe o stim módulo de qdk, defina um Stim circuito como uma cadeia de caracteres e passe o circuito para stim.run. O exemplo a seguir prepara e mede um estado Bell:

from qdk import stim

bell = """
H 0
CX 0 1
M 0 1
"""

results = stim.run(bell, shots=100, type="stabilizer")
print(results[:5])

Cada item em results contém os resultados da medição de uma execução. Um resultado padrão é Result.Zero ou Result.One. QDK QDK-Stim também inclui Result.Loss para medidas de qubits perdidos.

Para circuitos de estabilizador padrão Stim , comece com type="stabilizer". Para obter mais informações sobre os simuladores, consulte Visão geral dos simuladores quânticos no QDK.

Recursos QDK para circuitos Stim

O QDK estende o conjunto de instruções do Stim e o conecta ao QIR e aos simuladores QDK. Essas adições dão suporte a fluxos de trabalho de simulação que não estão disponíveis em Stim.

Compile circuitos Stim para QIR

O QDK compila o código-fonte do circuito Stim para QIR antes de executar o circuito. stim.run A função executa as duas etapas em uma chamada. Use stim.compile quando quiser inspecionar o QIR gerado ou executá-lo em outro simulador ou serviço.

A stim.compile função retorna o QIR código-fonte e o QDKNoiseConfig que o simulador precisa. O exemplo a seguir compila um circuito de estado bell e imprime o QIR:

from qdk import stim

bell = """
H 0
CX 0 1
M 0 1
"""

qir, noise = stim.compile(bell)
print(qir)

Adicionar ruído aos circuitos Stim

Você pode adicionar ruído a um Stim circuito com Stim instruções de ruído ou com um QDKNoiseConfig. Escolha o método que melhor corresponde à forma como você define o circuito e o modelo de ruído:

Método de ruído Como usar Usar quando
Instruções de ruído Stim Adicione instruções como X_ERROR, DEPOLARIZE1 e CORRELATED_ERROR ao código Stim. O ruído faz parte da definição do Stim circuito.
QDK modelo de ruído Defina um NoiseConfig e passe-o com o noise argumento. Você deseja aplicar um modelo de ruído existente QDK a um Stim circuito que não contém instruções de ruído.

O NoiseConfig retornado por stim.compile representa as instruções de ruído no circuito Stim. Não é um modelo de ruído separado.

Caution

Escolha um método de geração de ruído. Use instruções de ruído Stim ou um QDKNoiseConfig. Se você usar ambos, o simulador aplicará ambos os modelos de ruído.

O exemplo a seguir define um Stim circuito que tem ruído despolarizante:

from qdk import stim

noisy_bell = """
H 0
CX 0 1
DEPOLARIZE2(0.01) 0 1
M 0 1
"""

results = stim.run(noisy_bell, shots=1000, type="stabilizer")

Para mais informações, consulte Como construir modelos de ruído para simulações quânticas em QDK.

Perda de qubit do modelo

O QDK adiciona instruções e alvos de perda ao formato de circuito Stim. A medição de um qubit perdido retorna Result.Loss em vez de Result.Zero ou Result.One.

Constructo Syntax Behavior
Erro de perda LOSS_ERROR(p) 0 1 Perde cada destino independentemente, com probabilidade p.
Meta de perda correlacionada L0 Representa a perda de um qubit em um evento CORRELATED_ERROR ou ELSE_CORRELATED_ERROR.
Inspeção de perda PEEK_LOSS 0 1 Acrescenta 1 para um qubit perdido e 0 para um qubit presente sem medi-lo ou reiniciá-lo.

O exemplo a seguir aplica a perda independente a dois qubits, inspeciona seu estado de perda e, em seguida, os mede:

from qdk import Result, stim

loss_program = """
H 0
LOSS_ERROR(0.2) 0 1
PEEK_LOSS 0 1
M 0 1
"""

results = stim.run(loss_program, shots=100, type="stabilizer")

symbols = {
    Result.Zero: "0",
    Result.One: "1",
    Result.Loss: "L",
}

formatted = ["".join(symbols[value] for value in shot) for shot in results[:10]]

print(formatted)

Cada disparo formatado contém quatro caracteres. Os dois primeiros caracteres são os PEEK_LOSS valores e os dois últimos são os resultados da medida. Um L final significa que o qubit correspondente foi perdido.

Use alvos L para combinar erros de perda e Pauli em um evento correlacionado:

CORRELATED_ERROR(0.1) L0 X1
ELSE_CORRELATED_ERROR(0.1) L1

Note

Em QDKQDK-Stim, CORRELATED_ERROR e ELSE_CORRELATED_ERROR devem vir um imediatamente após o outro. Em Stim, eles não precisam necessariamente.

Resultados de medição pós-seleção

O QDK adiciona blocos SELECT para padrões de pós-seleção e repetição até o sucesso com base em medições de paridade e verificações de perda de qubit. Se uma condição em um SELECT bloco falhar, o simulador executará novamente esse bloco até que todas as suas condições passem. Um bloco aninhado é reiniciado independentemente de seu bloco externo.

Constructo Syntax Behavior
Bloco de seleção SELECT { ... } Executa novamente o corpo do bloco até que cada critério de seleção seja atendido.
Condição de paridade REQUIRE rec[-1] Requer que os registros de medida referenciados tenham paridade par. Um registro perdido também não atende à condição.
Registro invertido REQUIRE !rec[-1] Inverte um registro antes da verificação de paridade. Com um registro, isso mantém o resultado da medição 1.
Condição somente de perda NOTLEAKED rec[-1] Requer que as medições referenciadas não sejam de perda, mas não restringe seus valores de bit.

Liste vários alvos rec[...] em uma única instrução REQUIRE para selecionar sua paridade conjunta. O programa a seguir mantém apenas os resultados não perdidos com paridade par, portanto, as medidas finais são 00 ou 11:

from qdk import stim

post_selected = """
SELECT {
    H 0
    H 1
    LOSS_ERROR(0.1) 0 1
    M 0 1
    REQUIRE rec[-1] rec[-2]
}
"""

results = stim.run(post_selected, shots=1000, type="stabilizer")

Use NOTLEAKED quando 0 e 1 forem resultados válidos, mas você quiser descartar medições de qubits perdidos:

SELECT {
    H 0
    LOSS_ERROR(0.2) 0
    M 0
    NOTLEAKED rec[-1]
}

Cada condição deve referenciar pelo menos um registro que o bloco atual SELECT ou um bloco aninhado produz. O compilador rejeitará uma condição se uma nova execução do bloco não puder alterar nenhum de seus registros referenciados.

Simule operações não Clifford

Stim concentra-se em circuitos estabilizadores e não suporta operações não Clifford como portas T e Toffoli. QDK QDK-Stim adiciona operações semelhantes às suportadas por Clifft, um simulador para circuitos near-Clifford.

Category Instruções Agrupamento de destino
Portas de fase T, T_DAG Um qubit por destino
PauliPortas de fase de produto TPP, TPP_DAG Um Pauli produto por grupo de destino
Portões controlados CH Pares consecutivos
Portões controlados CCX, CCZ Triplos consecutivos
Rotações em um único qubit R_X(a), R_Y(a), R_Z(a) Um qubit por target
Portas gerais de um único qubit U3(t, p, l), U(t, p, l) Um qubit por destino
Rotações de dois qubits R_XX(a), R_YY(a), R_ZZ(a) Pares consecutivos
Pauli-rotações de produto R_PAULI(a) Um Pauli produto por grupo-alvo

Por padrão, os argumentos de rotação usam meias voltas. Por exemplo, R_X(0.5) gira em $\pi/2$ radianos. Adicione o rad sufixo para especificar radianos diretamente, como R_X(0.5rad). Você pode usar U3 ou U para misturar unidades angulares porque ambas são iguais.

O circuito a seguir usa uma porta Toffoli e uma rotação Y arbitrária:

from qdk import stim

near_clifford = """
X 0 1
CCX 0 1 2
R_Y(0.25) 3
M 0 1 2 3
"""

results = stim.run(near_clifford, shots=1000, type="stabilizer")

O QDK simulador de estabilizador ramifica a decomposição do estabilizador quando encontra uma operação não-Clifford. Essa abordagem permanece eficiente quando as operações não-Clifford são esparsas, mas o espaço de estado necessário aumenta exponencialmente com o número de operações não-Clifford. Use type="cpu" ou type="gpu" para circuitos que contenham muitas operações não-Clifford.

Para as definições completas de portas não Clifford consulte a referência de portas suportadas Clifft.

Limitações atuais

O QDK oferece suporte à maioria das instruções na referência de gate Stim, com as seguintes limitações. Para obter o status de implementação atual, consulte o QDKQDK-Stim problema de acompanhamento de recursos ausentes.

Recurso do Stim Comportamento atual QDK
DETECTOR e OBSERVABLE_INCLUDE Analisado e ignorado. O QDK não fornece amostragem de detector ou observável.
HERALDED_ERASE e HERALDED_PAULI_CHANNEL_1 A compilação falha porque QDK não dá suporte a essas instruções.
MPAD A compilação falha porque QDK não dá suporte a essas instruções.
Destinos de bit de varredura, como CX sweep[5] 7 A compilação falha porque o QDK não suporta alvos de varredura de bits.
Pauli produtos que se reduzem à identidade, como MPP Z0*Z0 A compilação falha porque o QDK não dá suporte ao destino de identidade resultante.

Use Stim quando precisar de modelos de erro do detector, amostradores Stim compilados, Sinter ou outras APIs StimPython. Use qdk.stim quando quiser compilar código Stim para QIR e executar o QIR em simuladores QDK ou usar as extensões QDK de perda, pós-seleção e não-Clifford.