Dela via

Introduktion till kvantprogrammeringsspråket Q#

  • Artikel

Q#är ett programmeringsspråk med öppen källkod på hög nivå för att utveckla och köra kvantalgoritmer. Q# ingår i Quantum Development Kit (QDK). Mer information finns i Konfigurera Quantum Development Kit.

Som ett kvantprogrammeringsspråk Q# uppfyller du följande krav för språk, kompilator och körning:

  • Maskinvaruagnostik: Kvantbitar i kvantalgoritmer är inte knutna till en specifik kvantmaskinvara eller layout. Kompilatorn Q# och körningen hanterar mappningen från program qubits till fysiska kvantbitar.
  • Integrerar kvantberäkning och klassisk databehandling: Möjligheten att utföra klassiska beräkningar och kvantberäkningar är viktig i en universell kvantdator.
  • Respekterar fysikens lagar:Q# och kvantalgoritmer följer kvantfysikens regler. Du kan till exempel inte kopiera eller komma åt qubittillståndet direkt i Q#.

Struktur för ett Q# program

Innan du börjar skriva kvantprogram är det viktigt att förstå deras struktur och komponenter. Överväg följande Q# program som skapar ett superpositionstillstånd:

namespace Superposition {
    @EntryPoint()
    operation MeasureOneQubit() : Result {
        // Allocate a qubit. By default, it's in the 0 state.  
        use q = Qubit();  
        // Apply the Hadamard operation, H, to the state.
        // It now has a 50% chance of being measured as 0 or 1.
        H(q);      
        // Measure the qubit in the Z-basis.
        let result = M(q);
        // Reset the qubit before releasing it.
        Reset(q);
        // Return the result of the measurement.
        return result;
    }
}

Baserat på kommentarerna (//) Superposition allokerar programmet först en qubit, tillämpar en åtgärd för att placera kvantbiten i superposition, mäter qubittillståndet, återställer kvantbiten och returnerar slutligen resultatet. Nu ska vi dela upp det här programmet i dess komponenter.

Användarnamnrymder

Q# program börjar med ett användardefinierat namnområde, till exempel:

namespace Superposition {
    // Your code goes here.
}

Namnrymder hjälper dig att organisera relaterade funktioner. Varje Q# program kan bara ha en namespace.

Standardbiblioteket Q# har fördefinierade namnområden som innehåller funktioner och åtgärder som du kan använda i kvantprogram. Mer information finns i Inbyggda namnområden.

Startpunkter

Attributet @EntryPoint() talar om för Q# kompilatorn var programmet ska börja köras. I ett program med flera funktioner och åtgärder kan du placera @EntryPoint() innan någon av dem för att programmet ska starta där och fortsätta sekventiellt.

@EntryPoint()
operation MeasureOneQubit() : Result {
    ...

Typer

Q# innehåller inbyggda typer som är gemensamma för de flesta språk, inklusive Int, Double, Booloch String, och typer som är specifika för kvantberäkning. Typen representerar till exempel Result resultatet av en kvantbitsmätning och kan ha ett av två värden: Zero eller One.

I programmet Superposition returnerar åtgärden MeasureOneQubit() en Result typ som motsvarar åtgärdens returtyp M . Mätresultatet lagras i en ny variabel som definieras med hjälp av -instruktionen let :

// The operation definition returns a Result type.
operation MeasureOneQubit() : Result {
    ...
    // Measure the qubit in the Z-basis, returning a Result type.
    let result = M(q);
    ...

Q# innehåller också typer som definierar intervall, matriser och tupplar. Du kan till och med definiera dina egna anpassade typer.

Allokera qubitar

I Q#allokerar du kvantbitar med hjälp av nyckelordet use . Kvantbitar allokeras alltid i tillståndet $\ket{0}$ .

Programmet Superposition definierar en enda qubit:

// Allocate a qubit.
use q = Qubit();

Du kan också allokera flera kvantbitar och komma åt var och en via dess index:

use qubits = Qubit[2]; // Allocate two qubits.
H(qubits[0]); // Apply H to the first qubit.
X(qubits[1]); // Apply X to the second qubit.

Mer information finns i Använda -instruktion.

Kvantåtgärder

När du har allokerat en kvantbit kan du skicka den till åtgärder och funktioner, även kallade anropsbara objekt. Åtgärder är de grundläggande byggstenarna i ett Q# program. En Q# åtgärd är en kvantunderrutin eller en anropsbar rutin som innehåller kvantåtgärder som ändrar tillståndet för kvantbitsregistret.

Om du vill definiera en Q# åtgärd anger du ett namn för åtgärden, dess indata och dess utdata. I programmet Superposition är åtgärden MeasureOneQubit() i stort sett hela programmet. Det tar inga parametrar och returnerar en Result typ:

operation MeasureOneQubit() : Result {
    ...
}

Här är ett grundläggande exempel som inte tar några parametrar och förväntar sig inget returvärde. Värdet Unit motsvarar NULL på andra språk:

operation SayHelloQ() : Unit {
    Message("Hello quantum world!");
}

Standardbiblioteket Q# innehåller även åtgärder som du kan använda i kvantprogram, till exempel Hadamard-åtgärden , Hi programmet Superposition . Givet en qubit i Z-basis, H placerar qubiten i en jämn superposition, där den har en 50% chans att mätas som Zero eller One.

Mäta kvantbitar

Det finns många typer av kvantmätningar, Q# men fokuserar på projektiva mätningar på enskilda kvantbitar, även kallade Pauli-mätningar.

I Q#mäter åtgärden en eller flera qubits i den angivna Pauli-basen, som kan vara PauliX, PauliYeller PauliZ.Measure Measure returnerar en Result typ av antingen Zero eller One.

Om du vill implementera ett mått i beräkningsbasen $\lbrace\ket{0},\ket{1}\rbrace$ kan du också använda M åtgärden, som mäter en qubit i Pauli Z-basis. Detta motsvarar M Measure([PauliZ], [qubit]).

Programmet Superposition använder åtgärden M :

// Measure the qubit in the Z-basis.
let result = M(q);

Återställa kvantbitar

I Q#måste kvantbitar vara i tillståndet $\ket{0}$ när de släpps. Använd åtgärden Reset för att återställa varje qubit till $\ket{0}$ tillståndet innan du släpper den i slutet av programmet. Det gick inte att återställa en kvantbit, vilket resulterar i ett körningsfel.

// Reset a qubit.
Reset(q);

Inbyggda namnområden

Standardbiblioteket Q# har inbyggda namnområden som innehåller funktioner och åtgärder som du kan använda i kvantprogram. Namnområdet innehåller till exempel Microsoft.Quantum.Intrinsic vanliga åtgärder och funktioner, till exempel för att mäta resultat och Message visa användarmeddelanden var som M helst i programmet.

Om du vill anropa en funktion eller åtgärd kan du ange det fullständiga namnområdet eller använda en open instruktion, vilket gör alla funktioner och åtgärder för namnområdet tillgängliga och gör koden mer läsbar. I följande exempel anropas samma åtgärd:

Microsoft.Quantum.Intrinsic.Message("Hello quantum world!");

open Microsoft.Quantum.Intrinsic;
Message("Hello quantum world!");

Programmet Superposition har inga open instruktioner eller anrop med fullständiga namnområden. Det beror på att Q# utvecklingsmiljön automatiskt läser in två namnområden: Microsoft.Quantum.Core och Microsoft.Quantum.Intrinsic, som innehåller vanliga funktioner och åtgärder.

Du kan dra nytta av Microsoft.Quantum.Measurement namnområdet genom att använda åtgärden MResetZ för att optimera programmet Superposition . MResetZ kombinerar mått- och återställningsåtgärderna i ett steg, som i följande exempel:

namespace Superposition {
    // Open the namespace for the MResetZ operation.
    open Microsoft.Quantum.Measurement;

    @EntryPoint()
    operation MeasureOneQubit() : Result {
        // Allocate a qubit. By default, it's in the 0 state.      
        use q = Qubit();  
        // Apply the Hadamard operation, H, to the state.
        // It now has a 50% chance of being measured as 0 or 1. 
        H(q);   
        // Measure and reset the qubit, and then return the result value.
        return MResetZ(q);
    }
}

Utveckla kvantprogram med Q# och Azure Quantum

Q# och Azure Quantum är en kraftfull kombination för att utveckla och köra kvantprogram. Med Q# och Azure Quantum kan du skriva kvantprogram, simulera deras beteende, uppskatta resurskrav och köra dem på verklig kvantmaskinvara. Med den här integreringen kan du utforska potentialen i kvantberäkning och utveckla innovativa lösningar på komplexa problem. Oavsett om du är nybörjare eller erfaren kvantutvecklare Q# och Azure Quantum tillhandahåller de verktyg och resurser som du behöver för att frigöra kraften i kvantberäkning.

Följande diagram visar de steg genom vilka ett kvantprogram passerar när du utvecklar det med Q# och Azure Quantum. Programmet börjar med utvecklingsmiljön och slutar med att jobbet skickas till verklig kvantmaskinvara.

Diagram som visar arbetsflödet för kvantprogrammeringsutveckling.

Nu ska vi dela upp stegen i diagrammet.

Välj utvecklingsmiljö

Kör dina kvantprogram i önskad utvecklingsmiljö. Du kan använda onlinekodredigeraren på Azure Quantum-webbplatsen, de värdbaserade Jupyter Notebooks i Azure Quantum-arbetsytan i Azure-portalen eller en lokal utvecklingsmiljö med Visual Studio Code. Mer information finns i Olika sätt att köra Q# program.

Skriva ditt kvantprogram

Du kan skriva kvantprogram i Q# med hjälp av Quantum Development Kit (QDK). Kom igång genom att läsa Snabbstart: Skapa ditt första Q# program.

Q#Dessutom har QDK stöd för andra språk för kvantberäkning, till exempel Qiskit och Cirq.

Integrera med Python

Du kan använda Q# själv eller tillsammans med Python i olika IDE:er. Du kan till exempel använda ett Q# projekt med ett Python-värdprogram för att anropa Q# åtgärder. Du kan också integrera Q# med Python i Jupyter Notebooks. Mer information finns i Olika sätt att köra Q# program.

Kommandot %%qsharp

Som standard Q# använder program i Jupyter Notebooks Python-paketet ipykernel . Om du vill lägga till Q# kod i en notebook-cell använder du %%qsharp kommandot, som är aktiverat med qsharp Python-paketet, följt av din Q# kod.

Tänk på följande när du använder %%qsharp:

  • Du måste först köra import qsharp för att aktivera %%qsharp.
  • %%qsharp omfång för notebook-cellen där den visas och ändrar celltypen från Python till Q#.
  • Du kan inte placera en Python-instruktion före eller efter %%qsharp.
  • Q# kod som följer %%qsharp måste följa Q# syntaxen. Använd till exempel // i stället för # att ange kommentarer och ; för att avsluta kodrader.

Kommentar

Azure-notebook-filer i Azure-portalen innehåller de senaste versionerna av och azure-quantum Python-paketenqsharp, så du behöver inte installera något. Mer information finns i Komma igång med Q# och Azure Quantum Notebooks.

Beräkna resurser

Innan du kör verklig kvantmaskinvara måste du ta reda på om programmet kan köras på befintlig maskinvara och hur många resurser det kommer att förbruka.

Med Azure Quantum Resource Estimator kan du utvärdera arkitektoniska beslut, jämföra kvantbitstekniker och fastställa de resurser som behövs för att köra en viss kvantalgoritm. Du kan välja mellan fördefinierade feltoleranta protokoll och ange antaganden för den underliggande fysiska qubitmodellen.

Mer information finns i Kör din första resursuppskattning.

Kommentar

Azure Quantum Resources Estimator är kostnadsfri och kräver inget Azure-konto.

Köra programmet i simulering

När du kompilerar och kör ett kvantprogram skapar QDK en instans av kvantsimulatorn och skickar koden till den Q# . Simulatorn använder Q#-koden för att skapa kvantbitar (simuleringar av kvantpartiklar) och tillämpa transformeringar för att ändra deras tillstånd. Resultatet av kvantåtgärderna i simulatorn returneras sedan till programmet. Isolering av Q#-koden i simulatorn ser till att algoritmerna följer kvantfysikens lagar och att de körs korrekt på kvantdatorer.

Skicka in ditt program till verklig kvantmaskinvara

Du kan skicka dina Q# program (även kallade jobb) till Azure Quantum via önskad utvecklingsmiljö, både lokalt och online. Mer information finns i skicka Q# jobb. Du kan också köra och skicka kvantkretsar skrivna på Qiskit- och Cirq-språk.

Azure Quantum erbjuder några av de mest övertygande och mångsidiga kvantmaskinvara som finns i dag från branschledare. Se Quantum Computing-leverantörer för den aktuella listan över maskinvaruleverantörer som stöds.

Kommentar

Det molnbaserade quantinuum H-seriens emulatormål är tillgängligt utan ett Azure-konto. Om du vill skicka ett jobb till resten av Azure Quantum-leverantörerna behöver du ett Azure-konto och en kvantarbetsyta. Om du inte har någon kvantarbetsyta kan du läsa Skapa en Azure Quantum-arbetsyta.

Följande diagram visar det grundläggande arbetsflödet när du har skickat jobbet:

Diagram som visar arbetsflödet efter att ett jobb har överförts till Azure Quantum.

Relaterat innehåll