Executar simulações quânticas com o QDKPython pacote

O MicrosoftQuantum Development Kit pacote (QDK) Python inclui simuladores quânticos locais que você pode usar para testar e desenvolver programas quânticos. Este artigo explica como instalar os simuladores e executar os programas Q#, OpenQASM, Qiskit e QIR em Python ou Jupyter Notebook.

O QDKPython pacote inclui quatro simuladores primários:

• Simulador esparso
• Simulador de estabilizador
• GPU simulador
• CPU simulador

Para obter mais informações sobre os QDK simuladores quânticos, consulte Visão geral dos simuladores quânticos no QDK.

Para executar programas Q# ou OpenQASM diretamente na extensão QDK para Visual Studio Code (VS Code), consulte Executar simulações quânticas na extensão QDK para Visual Studio Code.

Prerequisites

Para seguir os exemplos de Jupyter Notebook neste artigo, instale estas ferramentas:

• Um Python ambiente com Python 3.10 ou posterior e pip
• A versão mais recente do Visual Studio Code (VS Code)
• As versões mais recentes da extensão e da Pythonextensão do Jupyter no VS Code

Instalar os simuladores

Para usar os simuladores quânticos dentro Python e Jupyter Notebook, instale a versão mais recente do qdkPython pacote com o jupyter extra:

pip install --upgrade "qdk[jupyter]"

Os simuladores não exigem o jupyter extra, mas o extra adiciona o qdk.widgets módulo para visualizar os resultados da simulação em Jupyter Notebook.

Selecione um simulador com base no framework de programação quântica e na API que você usa.

Execute o simulador parcimonioso

O simulador esparso oferece suporte a programas Q#, Qiskit e OpenQASM. Esta tabela mostra como executar 10 execuções com o pacote qdk em cada framework.

Por exemplo, siga estas etapas para executar o programa de par Q# Bell em um jupyter notebook no VS Code:

1. No VS Code, selecione Exibir>Paleta de Comandos.

2. Insira Criar: Novo Jupyter Notebook. Um arquivo de notebook vazio se abre em uma nova guia.

3. Na primeira célula, importe o módulo qsharp do pacote qdk.

   from qdk import qsharp
   

4. Em uma nova célula, use o %%qsharp comando magic para gravar o Q# código.

   %%qsharp
   
   operation Main() : (Result, Result) {
       use (q1, q2) = (Qubit(), Qubit());
       PrepareBellPair(q1, q2);
       (MResetZ(q1), MResetZ(q2))
   }
   
   operation PrepareBellPair(q1 : Qubit, q2 : Qubit) : Unit {
       H(q1);
       CNOT(q1, q2);
   }
   

5. Crie uma nova célula. Para executar o programa Q# no simulador esparso, chame a função run do módulo qsharp e especifique o número de shots.

   qsharp.run("Main()", shots=10)
   

Chamar o simulador do estabilizador

O simulador estabilizador executa com eficiência circuitos largos dominados por Clifford. A ramificação do estabilizador também dá suporte a um número limitado de operações não-Clifford, como portas $T$ e $T^\dagger$ e rotações de ângulo arbitrário Pauli. Como o número de branches pode aumentar exponencialmente com o número de operações não-Clifford, use um simulador de estado completo para circuitos com evolução não-Clifford substancial.

O simulador de estabilizador suporta os programas Q#, OpenQASM, Qiskit e QIR. Esta tabela mostra como executar 10 execuções em cada framework.

As APIs NeutralAtomDevice e NeutralAtomBackend são para simulações especificamente em computadores quânticos de átomos neutros. Para obter mais informações, consulte a visão geral do simulador de dispositivos de átomos neutros.

Por exemplo, esse Python código executa um OpenQASM programa com uma Clifford porta diferente de $T$ no simulador do estabilizador:

from qdk.openqasm import run

qasm_code = """
include "stdgates.inc";
qubit[1] q;
bit[1] result;

h q[0];
t q[0];
h q[0];
result = measure q;
"""

run(qasm_code, type="stabilizer", shots=1000)

A porta $T$ cria ramificações estabilizadoras. A medição final mede a interferência entre esses branches.

Chamar os simuladores GPU e CPU

Os simuladores GPU e CPU suportam os programas Qiskit e QIR. Esta tabela mostra como executar 10 execuções no simulador GPU com o pacote qdk em cada estrutura. Para usar o simulador CPU, substitua gpu por cpu no parâmetro de tipo de simulador.

Por exemplo, esse Python código converte um programa QIR simples para OpenQASM e executa o QIR no simulador GPU:

from qdk.openqasm import compile
from qdk.simulation import run_qir

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

qir = compile(qasm_code)
run_qir(qir, type="gpu", shots=10)