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

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

O QDKPython pacote inclui quatro simuladores principais:

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

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

Para executar Q# ou programas QDK diretamente na extensão QDK para Visual Studio Code (VS Code), veja OpenQASM.

Pré-requisitos

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

Instalar os simuladores

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

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 no Jupyter Notebook.

Selecione um simulador com base no Python framework de programação quântica e API que utiliza.

Chame o simulador esparso

O simulador esparso suporta Q#, OpenQASM, e Qiskit programas. Esta tabela mostra como executar 10 shots com o qdk pacote em cada framework.

Estrutura de programação Python API (Interface de Programação de Aplicações) Exemplo de chamada
Q# qsharp.run qsharp.run("MyQsharpProgram()", shots=10)
OpenQASM openqasm.run openqasm.run(my_qasm_program, shots=10)
Qiskit qiskit.QSharpBackend QSharpBackend().run(my_qiskit_program, shots=10)

Note

O simulador esparso suporta modelos de ruído através do noise parâmetro para Q# e OpenQASM programas, mas não para Qiskit programas.

Por exemplo, siga estes passos para executar o programa par Q# Bell num caderno Jupyter em VS Code:

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

  2. Insira Create: New Jupyter Notebook. Um ficheiro vazio do caderno abre numa nova aba.

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

    from qdk import qsharp

  4. Numa célula nova, usa o %%qsharp comando mágico para escrever 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. Criar uma nova célula. Para executar o Q# programa no simulador esparso, chame a run função do qsharp módulo e especifique o número de disparos.

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

Chamar o simulador estabilizador

O simulador de estabilizadores executa eficientemente circuitos largos, dominados por Clifford. A ramificação dos estabilizadores também suporta um número limitado de operações não Clifford, como portas $T$ e $T^\dagger$ e rotações Pauli de ângulo arbitrário. Como o número de ramos pode crescer exponencialmente com o número de operações não-Clifford, utilize-se um simulador de estado completo para circuitos com evolução não-Clifford substancial.

O simulador estabilizador suporta Q#, OpenQASM, Qiskit, e QIR programas. Esta tabela mostra como executar 10 shots em cada framework.

Estrutura de programação Python API (Interface de Programação de Aplicações) Exemplo de chamada
Q# qsharp.run qsharp.run("MyQsharpProgram()", type="stabilizer", shots=10)
OpenQASM openqasm.run openqasm.run(my_qasm_program, type="stabilizer", shots=10)
Qiskit qiskit.NeutralAtomBackend NeutralAtomBackend().run(my_qiskit_program, simulator_type="stabilizer", shots=10)
QIR simulation.NeutralAtomDevice simulation.NeutralAtomDevice().simulate(my_qir, type="stabilizer", shots=10)
QIR simulation.run_qir simulation.run_qir(my_qir, type="stabilizer", shots=10)

As NeutralAtomDevice APIs e NeutralAtomBackend destinam-se especificamente a simulações em computadores quânticos de átomos neutros. Para mais informações, consulte Visão geral do simulador de dispositivo de átomos neutros.

Por exemplo, este Python código executa um OpenQASM programa com uma porta não-Clifford $T$ no simulador 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)

Note

Ambos "stabilizer" e "clifford" selecionam o simulador estabilizador. A API determina se o parâmetro é type ou simulator_type.

A porta $T$ cria ramos estabilizadores. A medição final mede a interferência entre esses ramos.

Chame os GPU e CPU simuladores

Os simuladores GPU e Qiskit suportam programas QIR e CPU. Esta tabela mostra como executar 10 shots no GPU simulador com o qdk pacote em cada framework. Para usar o CPU simulador, substitua gpu por cpu no parâmetro do tipo simulador.

Estrutura de programação Python API (Interface de Programação de Aplicações) Exemplo de chamada
Qiskit qiskit.NeutralAtomBackend NeutralAtomBackend().run(my_qiskit_program, simulator_type="gpu", shots=10)
QIR simulation.NeutralAtomDevice simulation.NeutralAtomDevice().simulate(my_qir, type="gpu", shots=10)
QIR simulation.run_qir simulation.run_qir(my_qir, type="gpu", shots=10)

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

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)
  • Última atualização a