Inleiding tot de kwantumprogrammeertaal Q#
Als kwantumprogrammeertaal voldoet Q# aan de volgende vereisten voor taal, compiler en runtime:
- Hardwareneutraal: Qubits in kwantumalgoritmen zijn niet gekoppeld aan een specifieke kwantumhardware of -indeling. De Q# compiler en runtime verwerken de toewijzing van programma-qubits naar fysieke qubits, zodat dezelfde code kan worden uitgevoerd op verschillende kwantumprocessors.
- integratie van kwantum- en klassieke computing:Q# biedt de integratie van kwantum- en klassieke berekeningen, wat essentieel is voor universele kwantumcomputing.
- qubitbeheer:Q# biedt ingebouwde bewerkingen en functies voor het beheren van qubits, waaronder het maken van superpositiestatussen, verstrengeling van qubits en het uitvoeren van kwantummetingen.
- Respecteer de wetten van de natuurkunde:Q# en kwantumalgoritmen moeten voldoen aan de regels van kwantumfysica. U kunt bijvoorbeeld de qubitstatus niet rechtstreeks kopiëren of openen in Q#.
Zie het blogbericht Waarom hebben we Q#nodig voor meer informatie over de oorsprong van Q#?.
Structuur van een Q# programma
Voordat u begint met het schrijven van Q# programma's, is het belangrijk om hun structuur en onderdelen te begrijpen. Houd rekening met het volgende Q# programma, met de naam Superpositie, waarmee een superpositiestatus wordt gemaakt:
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;
}
}
Op basis van de opmerkingen (//) wijst het Q# programma eerst een qubit toe, past een bewerking toe om de qubit in superpositie te plaatsen, meet de qubitstatus, stelt de qubit opnieuw in en retourneert ten slotte het resultaat.
Laten we dit Q# programma opsplitsen in de onderdelen ervan.
Gebruikersnaamruimten
Q# programma's kunnen eventueel beginnen met een door de gebruiker gedefinieerde naamruimte, zoals:
namespace Superposition {
// Your code goes here.
}
Naamruimten kunnen u helpen bij het organiseren van gerelateerde functionaliteit. Naamruimten zijn optionaL in Q# programma's, wat betekent dat u een programma kunt schrijven zonder een naamruimte te definiëren.
Het Superpositie--programma van het voorbeeld kan bijvoorbeeld ook worden geschreven zonder een naamruimte als:
@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;
}
Notitie
Elk Q# programma kan slechts één namespacehebben. Als u geen naamruimte opgeeft, gebruikt de Q# compiler de bestandsnaam als de naamruimte.
Toegangspunten
Elk Q# programma moet een toegangspunt hebben. Dit is het beginpunt van het programma. De compiler start standaard met het Q# uitvoeren van een programma vanaf de Main() bewerking, indien beschikbaar, die zich overal in het programma kan bevinden. U kunt desgewenst het @EntryPoint() kenmerk gebruiken om elke bewerking in het programma op te geven als het uitvoeringspunt.
In het programma Superpositie is de MeasureOneQubit() bewerking bijvoorbeeld het toegangspunt van het programma omdat deze het kenmerk @EntryPoint() heeft vóór de bewerkingsdefinitie:
@EntryPoint()
operation MeasureOneQubit() : Result {
...
}
Het programma kan echter ook worden geschreven zonder het kenmerk @EntryPoint() door de naam van de MeasureOneQubit() bewerking te wijzigen in Main(), zoals:
// 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;
}
Typen
Typen zijn essentieel in elke programmeertaal omdat ze de gegevens definiëren waarmee een programma kan werken.
Q# biedt ingebouwde typen die gebruikelijk zijn voor de meeste talen, waaronder Int, Double, Boolen String, en typen die reeksen, arrays en tuples definiëren.
Q# biedt ook typen die specifiek zijn voor kwantumcomputing. Het Result type vertegenwoordigt bijvoorbeeld het resultaat van een qubitmeting en kan twee waarden hebben: Zero of One.
In het programma Superpositie retourneert de MeasureOneQubit() bewerking een Result type, dat overeenkomt met het retourtype van de M bewerking. Het meetresultaat wordt opgeslagen in een nieuwe variabele die is gedefinieerd met behulp van de let instructie:
// 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);
...
}
Een ander voorbeeld van een kwantumspecifiek type is het Qubit type, dat een kwantumbit vertegenwoordigt.
Q# stelt u ook in staat om uw eigen aangepaste types te definiëren. Zie Typedeclaratiesvoor meer informatie.
Qubits toewijzen
In Q#wijst u qubits toe met behulp van het trefwoord use en het Qubit type. Qubits worden altijd in de $\ket{0}$ status toegewezen.
Het programma Superpositie definieert bijvoorbeeld één qubit en slaat deze op in de variabele q:
// Allocate a qubit.
use q = Qubit();
U kunt ook meerdere qubits toewijzen en elke qubit openen via de 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.
Zie use-instructie voor meer informatie.
Kwantumbewerkingen
Nadat u een qubit hebt toewijzen, kunt u deze doorgeven aan bewerkingen en functies. Bewerkingen zijn de basisbouwstenen van een Q# programma. Een Q# bewerking is een kwantumsubroutine of een aanroepbare routine die kwantumbewerkingen bevat die de status van het qubitregister wijzigen.
Als u een Q# bewerking wilt definiëren, geeft u een naam op voor de bewerking, de bijbehorende invoer en de uitvoer. In het programma Superpositie heeft de MeasureOneQubit() bewerking geen parameters en retourneert het een type Result.
operation MeasureOneQubit() : Result {
...
}
Hier volgt een basisvoorbeeld waarbij geen parameters worden gebruikt en geen retourwaarde wordt verwacht. De Unit waarde is gelijk aan NULL in andere talen:
operation SayHelloQ() : Unit {
Message("Hello quantum world!");
}
De Q# standaardbibliotheek biedt ook bewerkingen die u kunt gebruiken in kwantumprogramma's, zoals de Hadamard-bewerking, Hin het Superposition programma. Met een qubit in de Z-basis wordt H de qubit in een zelfs superpositie geplaatst, waarbij het een kans van 50% heeft om te worden gemeten als Zero of One.
Qubits meten
Hoewel er veel soorten kwantummetingen zijn, Q# richt u zich op projectieve metingen op enkele qubits, ook wel bekend als Pauli-metingen.
In Q#, de Measure bewerking meet een of meer qubits in de opgegeven Pauli basis, die kan PauliXPauliY, of PauliZ.
Measure retourneert een Result type of ZeroOne.
Als u een meting wilt implementeren in de rekenkundige basis $\lbrace,\ket{0}\rbrace\ket{1}$, kunt u ook de M bewerking gebruiken, waarmee een qubit in de Pauli Z-basis wordt gemeten. Dit maakt M gelijk aan Measure([PauliZ], [qubit]).
Het programma Superpositie gebruikt bijvoorbeeld de bewerking M:
// Measure the qubit in the Z-basis.
let result = M(q);
Qubits opnieuw instellen
In Q#moeten qubits de status $\ket{0}$ hebben wanneer ze worden vrijgegeven om fouten in de kwantumhardware te voorkomen. U kunt een qubit opnieuw instellen op de status $\ket{0}$ met behulp van de Reset bewerking aan het einde van het programma. Fout bij het opnieuw instellen van een qubit resulteert in een runtimefout.
// Reset a qubit.
Reset(q);
Standaardbibliotheeknaamruimten
De Q# standaardbibliotheek bevat ingebouwde naamruimten die functies en bewerkingen bevatten die u in kwantumprogramma's kunt gebruiken. De naamruimte bevat bijvoorbeeld Microsoft.Quantum.Intrinsic veelgebruikte bewerkingen en functies, zoals M het meten van resultaten en Message het weergeven van gebruikersberichten overal in het programma.
Als u een functie of bewerking wilt aanroepen, kunt u de volledige naamruimte opgeven of een import instructie gebruiken, waardoor alle functies en bewerkingen voor die naamruimte beschikbaar zijn en uw code beter leesbaar wordt. In de volgende voorbeelden wordt dezelfde bewerking aangeroepen:
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!");
Notitie
Het Superpositie programma heeft geen import instructies of aanroepen met volledige naamruimten. Dat komt doordat in de Q# ontwikkelomgeving automatisch twee naamruimten worden geladen: Microsoft.Quantum.Core en Microsoft.Quantum.Intrinsic, die veelgebruikte functies en bewerkingen bevatten.
U kunt profiteren van de Microsoft.Quantum.Measurement-naamruimte door de MResetZ-bewerking te gebruiken om het -Superpositie--programma te optimaliseren.
MResetZ combineert de metings- en resetbewerkingen in één stap, zoals in het volgende voorbeeld:
// 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);
}
Meer informatie over het ontwikkelen van kwantumprogramma's met Q# en Azure Quantum
Q# En Azure Quantum zijn een krachtige combinatie voor het ontwikkelen en uitvoeren van kwantumprogramma's. Met Q# en Azure Quantum kunt u kwantumprogramma's schrijven, hun gedrag simuleren, resourcevereisten schatten en uitvoeren op echte kwantumhardware. Met deze integratie kunt u het potentieel van kwantumcomputing verkennen en innovatieve oplossingen ontwikkelen voor complexe problemen. Of u nu een beginner of ervaren kwantumontwikkelaar bent en Q# Azure Quantum biedt de hulpprogramma's en resources die u nodig hebt om de kracht van kwantumcomputing te ontgrendelen.
In het volgende diagram ziet u de fasen waarmee een kwantumprogramma wordt doorgegeven wanneer u het ontwikkelt met Q# en Azure Quantum. Uw programma begint met de ontwikkelomgeving en eindigt met het verzenden van de taak naar echte kwantumhardware.
Laten we de stappen in het diagram opsplitsen.
Uw ontwikkelomgeving kiezen
Voer uw kwantumprogramma's uit in uw favoriete ontwikkelomgeving. U kunt de online code-editor gebruiken op de Azure Quantum-website, de gehoste Jupyter Notebooks in uw Azure Quantum-werkruimte in Azure Portal of een lokale ontwikkelomgeving met Visual Studio Code. Zie Q# uit te voeren voor meer informatie.
Uw kwantumprogramma schrijven
U kunt kwantumprogramma's schrijven met Q# behulp van de Quantum Development Kit (QDK). Zie Quickstart: Uw eerste Q# programma maken om aan de slag te gaan.
Bovendien Q#biedt de QDK ondersteuning voor andere talen voor kwantumcomputing, zoals Qiskit en Cirq.
Integreren met Python
U kunt zelfstandig of samen met Python in verschillende IDE's gebruiken Q# . U kunt bijvoorbeeld een Q# project gebruiken met een Python-hostprogramma om Q# bewerkingen aan te roepen of Q# te integreren met Python in Jupyter Notebooks. Zie Integratie van Q# en Pythonvoor meer informatie.
De opdracht %%qsharp
Q# Standaard gebruiken programma's in Jupyter Notebooks het ipykernel Python-pakket. Als u code wilt toevoegen Q# aan een notebookcel, gebruikt u de %%qsharp opdracht, die is ingeschakeld met het qsharp Python-pakket, gevolgd door uw Q# code.
Houd bij het gebruik %%qsharprekening met het volgende:
- U moet eerst worden uitgevoerd
import qsharpom in te schakelen%%qsharp. -
%%qsharpbereiken in de notebookcel waarin deze wordt weergegeven en wijzigt het celtype van Python in Q#. - U kunt een Python-instructie niet vóór of na
%%qsharpplaatsen. -
Q# de volgende
%%qsharpcode moet voldoen aan Q# de syntaxis. Gebruik bijvoorbeeld//in plaats van#opmerkingen aan te geven en;coderegels te beëindigen.
Resources schatten
Voordat u echte kwantumhardware uitvoert, moet u nagaan of uw programma op bestaande hardware kan worden uitgevoerd en hoeveel resources er worden verbruikt.
Met de Azure Quantum Resource Estimator kunt u architectuurbeslissingen beoordelen, qubittechnologieën vergelijken en de resources bepalen die nodig zijn om een bepaald kwantumalgoritme uit te voeren. U kunt kiezen uit vooraf gedefinieerde fouttolerante protocollen en veronderstellingen opgeven van het onderliggende fysieke qubitmodel.
Zie Uw eerste resourceraming uitvoeren voor meer informatie.
Notitie
De Estimator voor Azure Quantum Resources is gratis en vereist geen Azure-account.
Uw programma uitvoeren in simulatie
Wanneer u een kwantumprogramma compileert en uitvoert, maakt de QDK een exemplaar van de kwantumsimulator en geeft de Q# code eraan door. De simulator gebruikt de Q#-code voor het maken van qubits (simulaties van kwantumdeeltjes) en het toepassen van transformaties om hun toestand te wijzigen. De resultaten van de kwantumbewerkingen in de simulator worden vervolgens teruggestuurd naar het programma. Het isoleren van de Q#-code in de simulator zorgt ervoor dat de algoritmen de wetten van kwantumfysica volgen en op de juiste wijze op kwantumcomputers kunnen worden uitgevoerd.
Uw programma verzenden naar echte kwantumhardware
U kunt uw Q#-programma's verzenden naar Azure Quantum om te worden uitgevoerd op echte kwantumhardware. U kunt ook kwantumcircuits uitvoeren en verzenden die zijn geschreven in Qiskit- en Cirq-talen. Wanneer u een kwantumprogramma uitvoert in Azure Quantum, maakt en voert u een taak uit. Zie hoe u Q# programma's verzendt naar Azure Quantumvoor meer informatie.
xref:microsoft.quantum.work-with-jobs
Azure Quantum biedt een aantal van de meest aantrekkelijke en diverse kwantumhardware die momenteel beschikbaar is van toonaangevende bedrijven. Zie Kwantumcomputingproviders voor de huidige lijst met ondersteunde hardwareproviders.
Notitie
Als u een taak wilt verzenden naar de Azure Quantum-providers, hebt u een Azure-account en kwantumwerkruimte nodig. Zie Een Azure Quantum-werkruimte maken als u geen kwantumwerkruimte hebt.
Zodra u uw taak hebt ingediend, beheert Azure Quantum de levenscyclus van de taak, inclusief taakplanning, uitvoering en bewaking. U kunt de status van uw taak bijhouden en de resultaten bekijken in de Azure Quantum-portal. Zie Werken met Azure Quantum-takenvoor meer informatie.