Introduktion till kvantprogrammeringsspråket Q#
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 kan också börja med ett användardefinierat namnområde, till exempel:
namespace Superposition {
// Your code goes here.
}
Namnområden kan hjälpa dig att organisera relaterade funktioner. Varje Q# program kan bara ha en namespace. Om ett namnområde inte har angetts Q# använder kompilatorn filnamnet som namnområde. Programmet kan till exempel Superposition skrivas som:
@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;
}
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
Som standard Q# börjar kompilatorn köra ett program från Main() åtgärden, om det är tillgängligt, som kan finnas var som helst i programmet. Du kan också använda @EntryPoint() attributet för att ange alla åtgärder i programmet som körningsplats.
I programmet Superposition är den mer beskrivande MeasureOneQubit() åtgärden startpunkten för programmet.
@EntryPoint()
operation MeasureOneQubit() : Result {
...
Programmet kan dock också skrivas utan @EntryPoint() attributet genom att byta namn på MeasureOneQubit() åtgärden till Main():
// The Q# compiler automatically detects the Main() operation as the entry point.
operation Main() : 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;
}
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 import 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!");
// imports all functions and operations from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.*;
Message("Hello quantum world!");
// imports just the `Message` function from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.Message;
Message("Hello quantum world!");
// namespaces in the standard library may be imported using `Std` instead of `Microsoft.Quantum`.
import Std.Intrinsic.*;
Message("Hello quantum world!");
Programmet Superposition har inga import 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:
// Import the namespace for the MResetZ operation.
import 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.
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 Din Azure Quantum-arbetsyta i Azure Portal 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 qsharpför att aktivera%%qsharp. %%qsharpomfå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
%%qsharpmå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 Portal innehåller de senaste versionerna av python-paketen qsharp och azure-quantum så att du inte behöver installera något. Mer information finns i Kom 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:
