Como instalar e executar os QDK simuladores quânticos

O Microsoft Quantum Development Kit (QDK) inclui um conjunto de simuladores quânticos que você pode acessar da extensão Visual Studio Code (VS Code) e da biblioteca QDKPython. Esses simuladores permitem testar como seus programas quânticos são executados em hardware quântico real. Este artigo explica como instalar os simuladores e como executar simulações básicas em Jupyter Notebook e VS Code.

Inclui QDK quatro simuladores quânticos:

• Simulador esparso
• Simulador clifford
• Simulador de GPU
• Simulador de CPU

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

Prerequisites

Para seguir as etapas deste artigo, você precisa instalar as seguintes ferramentas:

• Um ambiente Python (versão 3.10 ou superior), com Python e Pip
• A versão mais recente de Visual Studio Code (VS Code)
• As versões mais recentes da extensão Python e Jupyter em VS Code

Instalar os simuladores

Todos os quatro simuladores estão disponíveis na biblioteca QDKPython, mas somente o simulador esparso está disponível na extensão QDKVS Code.

Para usar o simulador esparso na extensão VS Code, instale a extensão QDK para VS Code.

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

pip install --upgrade "qdk[jupyter]"

O jupyter extra não é necessário para usar os simuladores, mas instala o qdk.widgets módulo. O módulo widgets permite criar visualizações com base nos resultados da simulação em Jupyter Notebook.

Executar simulações usando a QDK extensão para VS Code

A extensão QDK para VS Code oferece apenas o simulador esparso. Para executar seu programa no simulador esparso em VS Code, abra um programa Q# (.qs) ou OpenQASM (.qasm) em VS Code e execute o arquivo.

Por exemplo, siga estas etapas para executar um dos programas de exemplo de Q# que vêm com a QDK extensão:

1. In VS Code, abra o menu Arquivo e selecione Novo Arquivo de Texto.
2. Dê ao arquivo um nome que termine com a .qs extensão.
3. No arquivo vazio, insira o exemplo. Uma lista de exemplos de código incluídos é aberta.
4. Escolha um exemplo de código, por exemplo, exemplo de Bell Pair.
5. Para executar o programa no simulador esparso, selecione o comando Executar na lente de código acima da operação Principal .

O VS Code terminal mostra a saída da simulação.

Executar simulações usando a biblioteca QDKPython

A biblioteca QDKPython oferece todos os quatro simuladores. Como chamar os simuladores depende do simulador e da estrutura de programação quântica.

Execute o simulador parcimonioso

Você pode invocar o simulador esparso para programas Q#, OpenQASM e Qiskit. A tabela a seguir mostra como chamar o simulador esparso da qdk biblioteca para 10 capturas em cada estrutura de programação quântica com suporte.

Por exemplo, siga estas etapas para executar o programa Q# do par Bell em um Jupyter bloco de anotações em VS Code:

1. In VS Code, abra o menu Exibir e selecione 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 qsharp módulo da qdk biblioteca.

   from qdk import qsharp
   

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

   %%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 execuções.

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

Invocar o simulador Clifford

Você pode chamar o simulador Clifford para programas Q#, OpenQASM, Qiskit e QIR. A tabela a seguir mostra como chamar o simulador Clifford da qdk biblioteca para 10 capturas em cada estrutura de programação quântica com suporte.

Por exemplo, o seguinte código Python cria um programa OpenQASM simples e executa o programa no simulador Clifford:

from qdk.openqasm import run

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

run(qasm_code, type='clifford', shots=10)

Acionar os simuladores de GPU e CPU

Você pode usar os simuladores de GPU e de CPU para programas Qiskit e QIR. A tabela a seguir mostra como chamar o simulador de GPU da biblioteca qdk para 10 execuções em cada um dos frameworks de programação quântica compatíveis. Para chamar o simulador de CPU, substitua 'gpu''cpu' pelos parâmetros de tipo de simulador.

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

from qdk.openqasm import compile#, ProgramType
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)