Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
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.
-
pipou 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.