Sviluppare programmi OpenQASM nel Microsoft Quantum Development Kit

Il Microsoft Quantum Development Kit (QDK) fornisce diversi ambienti di sviluppo per programmi OpenQASM con integrazione Azure Quantum. Questo articolo illustra come sviluppare ed eseguire OpenQASM codice in:

  • Estensione QDK in Visual Studio Code (VS Code)
  • Il pacchetto QDK Python in Jupyter Notebook.

Gli strumenti per sviluppatori come ad esempio CodeLends, IntelliSense, il completamento del codice e il debugging dei breakpoint si trovano disponibili solo nell'estensione VS Code. Altre funzionalità sono disponibili solo nel pacchetto Python. Ad esempio, è possibile passare Q# e OpenQASM callable come oggetti Python e compilare OpenQASM programmi che accettano input in QIR.

Prerequisiti

  • Installare la versione più recente di VS Code

  • Per lavorare direttamente con i OpenQASM file, installa l'estensione QDK più recente su .

  • Per usare OpenQASM in Python e Jupyter Notebook, installare la versione più recente dell'estensione Python e l'estensione Jupyter in VS Code.

  • Installare la versione più recente del qdk pacchetto Python con gli elementi aggiuntivijupyter:

    pip install --upgrade "qdk[jupyter]"

Lavorare con OpenQASM in VS Code utilizzando l'estensione QDK

Per scrivere OpenQASM codice in VS Code, aprire un progetto Q# e creare un OpenQASM file con un'estensione .qasm . Riconosce automaticamente QDK il file .qasm come OpenQASM, e le funzionalità per QDK sono disponibili durante la scrittura del codice OpenQASM.

Le seguenti funzionalità QDK sono disponibili nei programmi OpenQASM in VS Code:

  • Completamento del codice
  • Obiettivi di codice (esecuzione, istogramma, stima, debug e circuito)
  • Evidenziazione della sintassi e funzionalità di base della sintassi, ad esempio corrispondenza delle parentesi graffe
  • Errore durante il controllo dei file di OpenQASM origine
  • Debugging dei punti di interruzione ed esecuzione di script per i file di origine OpenQASM
  • Debug con generazione di circuiti live
  • Integrazione con Azure Quantum per l'esecuzione di processi quantistici

Per eseguire il programma OpenQASM da VS Code, è possibile usare il simulatore locale di QDK oppure inviare il codice come processo a Azure Quantum.

Eseguire il codice nel QDK simulatore locale

Per eseguire il codice OpenQASM nel simulatore quantistico sparso locale in VS Code, aprire un file .qasm e quindi selezionare il comando Esegui da CodeLens all'inizio del file. L'output del tuo programma viene visualizzato nel terminale VS Code.

Annotazioni

QDK tenta automaticamente di impostare un profilo QIR target compatibile con il programma. Se il profilo QIR target non supporta le operazioni nel programma, vengono visualizzati errori del compilatore quando si esegue il OpenQASM codice. Per ulteriori informazioni sui profili target, vedere Tipi diversi di profili target in Azure Quantum.

Programmi di esempio predefiniti

Il QDK viene fornito con diversi esempi di algoritmi quantistici predefiniti per OpenQASM. Per provare gli algoritmi di esempio, immettere sample in un file vuoto .qasm . Viene visualizzato un elenco di completamento che contiene gli algoritmi di esempio. Scegliere un esempio e quindi eseguire il codice generato.

Eseguire il debug in locale in VS Code

QDK include un debugger per OpenQASM. Il debugger supporta il debugging in stile punto di interruzione e può visualizzare lo stato del programma.

Per avviare il debugger, selezionare il comando Debug dalla lente del codice.

In modalità di debug è possibile impostare punti di interruzione nel codice per facilitare il debug. Lo stato del programma viene visualizzato nel riquadro ESEGUI E DEBUG . Ad esempio, è possibile visualizzare gli stati delle variabili locali e gli stati qubit.

Esegui il codice su Azure Quantum

Per eseguire OpenQASM programmi in Azure Quantumtargets, è necessario avere un'area Azure Quantum di lavoro. Per creare un'area Azure Quantum di lavoro, vedere Creare un'area Azure Quantum di lavoro.

Per inviare OpenQASM attività a Azure Quantum da VS Code, devi connetterti al tuo spazio di lavoro Azure Quantum. Per connettersi allo spazio di lavoro da VS Code, vedi Connettersi tramite una stringa di connessione.

Per inviare un OpenQASM job a Azure Quantum da VS Code, segui questi passaggi:

  1. Apri il file qasm che contiene il programma in VS Code.
  2. Selezionare l'icona Microsoft Quantum per aprire il pannello quantum Microsoft.
  3. Espandere l'elenco a discesa QUANTUM WORKSPACES e selezionare l'area di lavoro.
  4. Espandi l'elenco a discesa Providers e seleziona un provider, quindi seleziona l'target su cui eseguire il processo. Ad esempio, invia il tuo job a rigetti.svm.simtarget per eseguire il tuo programma sul simulatore backend di Rigetti. Per altre informazioni sul provider e target sulla disponibilità, vedere Aggiungere o rimuovere un provider in un'area di lavoro esistente.
  5. Selezionare l'icona di riproduzione accanto al target nome.
  6. Per inviare il lavoro, immettere i valori nei campi Nome lavoro e Numero di scatti.

Per visualizzare i tempi e lo stato di un processo, espandere l'elenco a discesa Processi e passare il puntatore del mouse sul nome del processo. Per scaricare i risultati del processo, selezionare l'istogramma o le icone di testo accanto al nome del processo.

Usare OpenQASM in Python e Jupyter Notebook

Con il QDK pacchetto Python, è possibile eseguire OpenQASM il codice direttamente e passare OpenQASM circuiti come operazioni ai programmi Q#. Scrivere il codice come stringa Python e quindi usare tale stringa per eseguire, importare o compilare il codice />

Eseguire OpenQASM direttamente in Python

Per eseguire OpenQASM il codice direttamente, usare la funzione run del modulo qdk.openqasm. Ad esempio, il codice seguente esegue 10 scatti nel simulatore locale di un semplice OpenQASM programma con rumore:

from qdk import BitFlipNoise
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];
    """

results = run(qasm_code, shots=10, noise=BitFlipNoise(0.1))
print(results)

Chiamare un OpenQASM programma in Q#

È possibile usare la funzione per archiviare un programma /> bell:

from qdk import qsharp
from qdk.openqasm import import_openqasm

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

import_openqasm(qasm_code, name="bell")

Quando bell fa parte dell'ambiente, è possibile eseguirlo direttamente da una cella Q#:

%%qsharp

use qs = Qubit[2];
bell(qs)

È anche possibile usare la funzionalità del QDK pacchetto con bell, ad esempio simulazione rumorosa, rendering del circuito e generazione di codice.

Programmi parametrizzati OpenQASM

La cella seguente crea un circuito OpenQASM che accetta un angolo theta come input, quindi chiama il circuito come funzione Python:

from qdk.openqasm import import_openqasm, ProgramType

qasm_code = """
    include "stdgates.inc";
    input float theta;
    qubit[2] q;
    rx(theta) q[0];
    rx(-theta) q[1];
    bit[2] c;
    c = measure q;
    """

import_openqasm(qasm_code, name="parameterized_circuit", program_type=ProgramType.File)

from qdk.code.qasm_import import parameterized_circuit

parameterized_circuit(1.57)

Trasferire il programma OpenQASM a Q#

Con il QDK pacchetto Python, è possibile passare direttamente un OpenQASM programma a un programma Q#. Ad esempio, il codice seguente crea un OpenQASM programma denominato Entangle e quindi usa Entangle come operazione in un programma Q#:

from qdk.openqasm import import_openqasm
from qdk import qsharp

qasm_code = """
    include "stdgates.inc";
    qubit[2] qs;
    h qs[0];
    cx qs[0], qs[1];
    """

import_openqasm(qasm_code, name="Entangle")

qsharp.eval("{ use qs = Qubit[2]; Entangle(qs); MResetEachZ(qs) }")

Quando si importano Q# e si importano programmi OpenQASM in un ambiente Python con qsharp.eval e import_openqasm, questi programmi diventano oggetti Python che è possibile chiamare nel codice Python. Ad esempio, il codice seguente crea un programma Q# denominato TestAntiCorrelation e passa il EntangleOpenQASM programma a TestAntiCorrelation:

qsharp.eval("""
    operation TestAntiCorrelation(entangler : Qubit[] => Unit) : Result[] {
        use qs = Qubit[2];
        X(qs[1]);
        entangler(qs);
        MResetEachZ(qs)
    }
    """)

from qdk.code import Entangle, TestAntiCorrelation

TestAntiCorrelation(Entangle)

OpenQASM Compilare programmi in QIR

È possibile compilare OpenQASM il codice in Quantum Intermediate Representation (QIR) con la funzione compile.

Ad esempio, la cella seguente compila OpenQASM il codice per un circuito con parametri in QIR:

from qdk import TargetProfile
from qdk.openqasm import import_openqasm, ProgramType
from qdk import qsharp

qsharp.init(target_profile=TargetProfile.Base)

qasm_code = """
    include "stdgates.inc";
    input float theta;
    qubit[2] q;
    rx(theta) q[0];
    rx(-theta) q[1];
    bit[2] c;
    c = measure q;
    """

import_openqasm(qasm_code, name="parameterized_circuit", program_type=ProgramType.File)

from qdk.code.qasm_import import parameterized_circuit

bound_compilation = qsharp.compile(parameterized_circuit, 1.57)
print(bound_compilation)

Annotazioni

Per compilare OpenQASM programmi che accettano variabili di input in QIR, è necessario usare il QDK pacchetto Python. Non è possibile compilare programmi parametrizzati \ in QIR usando l'estensione \ in \.

Inviare OpenQASM programmi a Azure Quantum

Per inviare un programma OpenQASM da eseguire su un Azure Quantumtarget, compilare il codice OpenQASM in QIR e quindi inviare il QIR per l'esecuzione su Azure Quantum.

Ad esempio, compila un semplice circuito di intreccio in QIR.

from qdk.openqasm import compile

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

qir_compilation = compile(qasm_code)

Per eseguire un processo QIR su Azure Quantum, connettiti all'area di lavoro quantistica e invia il processo a uno dei targets disponibili nell'area di lavoro. Ad esempio, inviare l'entanglement QIR per l'esecuzione nel simulatore back-end IonQ.

from qdk.azure import Workspace 

workspace = Workspace(resource_id="") # Add the resource ID of your workspace

target = workspace.get_targets('ionq.simulator')
job = target.submit(qir_compilation, shots=100)

print("Job submitted. Waiting for results...")

results = job.get_results()
print(results)

Sviluppo in corso OpenQASM nello QDK

Il supporto per OpenQASM in QDK è in corso.

Per un elenco delle funzionalità di OpenQASM in fase di sviluppo nel QDK, vedere Limitazioni e problemi nel wiki del repository QDK GitHub.

  • Last updated on