Utveckla OpenQASM-program i Microsoft Quantum Development Kit

Microsoft Quantum Development Kit (QDK) tillhandahåller olika utvecklingsmiljöer för OpenQASM-program med Azure Quantum integration. I den här artikeln får du lära dig hur du utvecklar och kör OpenQASM kod i:

• tillägget QDK i Visual Studio Code (VS Code)
• Det QDK Python paketet i Jupyter Notebook.

Vývojárske nástroje som CodeLends, IntelliSense, kodkomplettering och felsökning av brytpunkter är endast tillgängliga i tillägget VS Code. Andra funktioner är endast tillgängliga i Python-paketet. Du kan till exempel skicka Q# och OpenQASM anropsbara objekt som Python objekt och kompilera OpenQASM program som tar indata till QIR.

Förutsättningar

• Installera den senaste versionen av VS Code

• Om du vill arbeta direkt med OpenQASM filer installerar du den senaste versionen av QDK tillägget i VS Code.

• Om du vill arbeta med OpenQASM i Python och Jupyter Notebook installerar du den senaste versionen av tillägget Python och tillägget Jupyter i VS Code.

• Installera den senaste versionen av qdk Python-paketet med det jupyter extra:

  pip install --upgrade "qdk[jupyter]"
  

Arbeta med OpenQASM i VS Code med tillägget QDK

Om du vill skriva OpenQASM kod i VS Codeöppnar du ett Q#-projekt och skapar en OpenQASM fil med ett .qasm tillägg. Programvaran QDK identifierar automatiskt .qasm filen som OpenQASM, och QDK funktionerna för OpenQASM är tillgängliga medan du skriver din kod.

Följande QDK funktioner är tillgängliga för OpenQASM program i VS Code:

• Kod har slutförts
• Kodlinser (Kör, Histogram, Uppskatta, Felsök och Krets)
• Syntaxmarkering och grundläggande syntaxfunktioner, till exempel klammerparentesmatchning
• Fel vid kontroll av OpenQASM källfiler
• Felsökning av brytpunkt och skriptkörning för OpenQASM källfiler
• Felsökning med live-kretsgenerering
• Integrering med Azure Quantum för inlämning av kvantjobb

Om du vill köra ditt OpenQASM-program från VS Code kan du antingen använda den lokala simulatorn för QDK eller skicka koden som ett jobb till Azure Quantum.

Kör koden på den QDK lokala simulatorn

Om du vill köra koden OpenQASM på den lokala glesa kvantsimulatorn i VS Codeöppnar du en .qasm fil och väljer sedan kommandot Kör från kodlinsen i början av filen. Utdata från programmet visas i terminalen VS Code .

Inbyggda exempelprogram

QDK kommer med flera inbyggda kvantalgoritmexempel för OpenQASM. Om du vill testa exempelalgoritmerna anger du sample i en tom .qasm fil. En slutförandelista visas som innehåller exempelalgoritmerna. Välj ett exempel och kör sedan den genererade koden.

Felsöka lokalt i VS Code

Det QDK innehåller ett felsökningsprogram för OpenQASM. Felsökningsprogrammet stöder felsökning i brytpunktsformat och kan återge programtillståndet.

Starta felsökningsprogrammet genom att välja kommandot Felsöka från kodlinsen.

I felsökningsläge kan du ange brytpunkter i koden för att hjälpa dig att felsöka. Programmets tillstånd visas i fönstret KÖR OCH FELSÖK . Du kan till exempel visa dina lokala variabeltillstånd och kvantbitstillstånd.

Kör koden på Azure Quantum

Om du vill köra OpenQASM program på Azure Quantumtargetsmåste du ha en Azure Quantum arbetsyta. Information om hur du skapar en Azure Quantum arbetsyta finns i Skapa en Azure Quantum arbetsyta.

Om du vill skicka OpenQASM jobb till Azure Quantum från VS Codemåste du ansluta till din Azure Quantum arbetsyta. Om du vill ansluta till din arbetsyta från VS Code, se Ansluta med en anslutningssträng.

Följ dessa steg för att skicka ett OpenQASM jobb till Azure Quantum från VS Code:

1. qasm Öppna filen som innehåller ditt program i VS Code.
2. Välj ikonen Microsoft Quantum för att öppna panelen Microsoft Quantum.
3. Expandera listrutan QUANTUM WORKSPACES och välj din arbetsyta.
4. Expandera listrutan Providers och välj en provider och välj target sedan den som du vill köra jobbet på. Skicka till exempel ditt jobb till rigetti.svm.simtarget för att köra programmet på Rigettis backend-simulator. Mer information om provider och target tillgänglighet finns i Lägga till eller ta bort en provider på en befintlig arbetsyta.
5. Välj uppspelningsikonen bredvid namnet target .
6. Om du vill skicka jobbet anger du värden för uppmaningen Jobbnamn och Antal bilder .

Om du vill visa tid och status för ett jobb expanderar du listrutan Jobb och hovra över jobbnamnet. Om du vill ladda ned jobbresultatet väljer du histogrammet eller textikonerna bredvid jobbnamnet.

Arbeta med OpenQASM i Python och Jupyter Notebook

Med Python-paketet QDK kan du köra OpenQASM kod direkt och skicka OpenQASM kretsar som åtgärder till Q#-program. Skriv din OpenQASM kod som en Python sträng och använd sedan strängen för att köra, importera eller kompilera din OpenQASM-kod i Python miljön.

Kör OpenQASM direkt i Python

Om du vill köra OpenQASM kod direkt använder du run funktionen från modulen qdk.openqasm . Följande kod kör till exempel 10 körningar på den lokala simulatorn av ett enkelt OpenQASM-program med brus:

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)

Anropa ett OpenQASM program i Q#

Du kan använda funktionen import_openqasm för att lagra ett OpenQASM-program som ett Python-objekt och sedan anropa objektet senare i din Python-kod. Följande cell lagrar till exempel en OpenQASM krets i ett Python objekt som heter 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")

När bell är en del av din miljö kan du köra den direkt från en Q#-cell:

%%qsharp

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

Du kan också använda paketfunktionerna QDK med bell, till exempel brussimulering, kretsrendering och kodgenerering.

Parametriserade OpenQASM program

Följande cell skapar en OpenQASM krets som tar en vinkel theta som indata och anropar sedan kretsen som en Python funktion:

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)

Skicka ett OpenQASM program till Q#

Med Python-paketet QDK kan du direkt skicka ett OpenQASM program till ett Q#-program. Följande kod skapar till exempel ett OpenQASM program med namnet Entangle och använder Entangle sedan som en åtgärd i ett Q#-program:

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) }")

När du importerar Q# och importerar OpenQASM-program i en Python miljö med qsharp.eval och import_openqasm blir dessa program Python objekt som du kan anropa i din Python kod. Följande kod skapar till exempel ett Q#-program som heter TestAntiCorrelation och skickar programmet EntangleOpenQASM till 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)

Kompilera OpenQASM program till QIR

Du kan kompilera OpenQASM kod till Quantum Intermediate Representation (QIR) med compile funktionen .

Följande cell kompilerar OpenQASM till exempel kod för en parametriserad krets till 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)

Skicka OpenQASM program till Azure Quantum

Om du vill skicka ett OpenQASM program som ska köras på en Azure Quantumtargetkompilerar du OpenQASM koden till QIR och skickar sedan den QIR som ska köras på Azure Quantum.

Kompilera till exempel en enkel sammanflätningskrets till 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)

Om du vill köra ett QIR-jobb till Azure Quantumansluter du till din kvantarbetsyta och skickar jobbet till en av de tillgängliga targets på din arbetsyta. Skicka till exempel sammanflätnings-QIR för att köras på IonQ-backend-simulatorn.

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)

Pågående OpenQASM utveckling i QDK

Stöd för OpenQASM i QDK är pågående.

En lista över OpenQASM funktioner som är under utveckling i QDK finns i Known limitations and issues på GitHub repositoryns QDK wiki.