Inleiding tot de kwantumprogrammeertaal Q#

Q#is een opensource-programmeertaal op hoog niveau voor het ontwikkelen en uitvoeren van kwantumalgoritmen. Q# is opgenomen in de Quantum Development Kit (QDK). Zie De Quantum Development Kit instellen voor meer informatie.

Als kwantumprogrammeertaal Q# voldoet 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.
• Integreert kwantum- en klassieke computing: de mogelijkheid om klassieke en kwantumberekeningen uit te voeren, is essentieel in een universele kwantumcomputer.
• Respecteert de wetten van de natuurkunde:Q# en kwantumalgoritmen volgen de regels van kwantumfysica. U kunt bijvoorbeeld de qubitstatus niet rechtstreeks kopiëren of openen in Q#.

Structuur van een Q# programma

Voordat u begint met het schrijven van kwantumprogramma's, is het belangrijk om hun structuur en onderdelen te begrijpen. Houd rekening met het volgende Q# programma 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 Superposition 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 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. Elk Q# programma kan slechts één namespacehebben. Als er geen naamruimte is opgegeven, gebruikt de Q# compiler de bestandsnaam als de naamruimte. Het programma kan bijvoorbeeld Superposition worden geschreven 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;
}

De Q# standaardbibliotheek bevat vooraf gedefinieerde naamruimten die functies en bewerkingen bevatten die u in kwantumprogramma's kunt gebruiken. Zie Ingebouwde naamruimten voor meer informatie.

Toegangspunten

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 Superposition programma is de meer beschrijvende MeasureOneQubit() bewerking het toegangspunt van het programma.

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

Het programma kan echter ook zonder het @EntryPoint() kenmerk worden geschreven door de naam van de MeasureOneQubit() bewerking te wijzigen in 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;
}

Typen

Q#biedt ingebouwde typen die gebruikelijk zijn voor de meeste talen, waaronderInt, Doubleen BoolStringtypen die specifiek zijn voor kwantumcomputing. Het type vertegenwoordigt bijvoorbeeld Result het resultaat van een qubitmeting en kan een van de volgende twee waarden hebben: Zero of One.

In het Superposition programma 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);
    ...

Q# biedt ook typen waarmee bereiken, matrices en tuples worden gedefinieerd. U kunt zelfs uw eigen aangepaste typen definiëren.

Qubits toewijzen

In Q#, wijst u qubits toe met behulp van het use trefwoord. Qubits worden altijd in de $\ket{0}$ status toegewezen.

Het Superposition programma definieert één qubit:

// 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, ook wel aanroepbare functies genoemd. 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 Superposition programma is de MeasureOneQubit() bewerking in feite het hele programma. Er worden geen parameters gebruikt en er wordt een Result type geretourneerd:

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 Zero One.

Als u een meting wilt implementeren in de rekenkundige basis $\lbrace,\ket{1}\rbrace\ket{0}$, 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 Superposition programma maakt gebruik van de M bewerking:

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

Qubits opnieuw instellen

In Q#moeten qubits de $\ket{0}$ status hebben wanneer ze worden vrijgegeven. Gebruik de Reset bewerking om elke qubit opnieuw in te stellen op de $\ket{0}$ status voordat u deze aan het einde van het programma vrijgeeft. Fout bij het opnieuw instellen van een qubit resulteert in een runtimefout.

// Reset a qubit.
Reset(q);

Ingebouwde naamruimten

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!");

Het Superposition programma heeft import geen 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 Superposition 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);
}

Kwantumprogramma's ontwikkelen 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 Verschillende manieren om programma's uit te voeren Q# 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 met een Python-hostprogramma gebruiken om bewerkingen aan te roepen Q# . U kunt ook integreren Q# met Python in Jupyter Notebooks. Zie Verschillende manieren om programma's uit te voeren Q# voor 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 qsharp om in te schakelen %%qsharp.
• %%qsharp bereiken 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 %%qsharp code moet voldoen aan Q# de syntaxis. Gebruik bijvoorbeeld // in plaats van # opmerkingen aan te geven en ; coderegels te beëindigen.

Notitie

Azure-notebooks in Azure Portal bevatten de nieuwste versies van de qsharp en azure-quantum Python-pakketten, dus u hoeft niets te installeren. Zie Aan de slag met Q# En Azure Quantum-notebooks voor meer informatie.

Resources schatten

Voordat u echte kwantumhardware uitvoert, moet u erachter komen of uw programma op bestaande hardware kan worden uitgevoerd en hoeveel resources het gaat verbruiken.

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 (ook wel taken genoemd) verzenden naar Azure Quantum via uw favoriete ontwikkelomgeving, zowel lokaal als online. Zie voor meer informatie hoe u taken verzendtQ#. U kunt ook kwantumcircuits uitvoeren en verzenden die zijn geschreven in Qiskit- en Cirq-talen.

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

Het clouddoel Quantinuum H-Series Emulator is beschikbaar zonder een Azure-account. Als u een taak wilt verzenden naar de rest van de Azure Quantum-providers, hebt u een Azure-account en kwantumwerkruimte nodig. Zie Een Azure Quantum-werkruimte maken als u geen kwantumwerkruimte hebt.

In het volgende diagram ziet u de basiswerkstroom nadat u uw taak hebt verzonden:

Gerelateerde inhoud

• Verschillende manieren om programma's uit te voeren Q#
• De Quantum Development Kit instellen
• Quickstart: Uw eerste Q# programma maken