Quickstart: Uw eerste Q# programma maken

Artikel
10/29/2024

Leer hoe u een basisprogramma Q# schrijft dat verstrengeling demonstreert, een belangrijk concept van kwantumcomputing.

Wanneer twee of meer qubits verstrengeld zijn, delen ze kwantuminformatie, wat betekent dat wat er ook gebeurt met de ene qubit ook met de andere. In deze quickstart maakt u een bepaalde twee-qubit-verstrengelde toestand, een belpaar genaamd. Als u in een belpaar één qubit in de $\ket{0}$ toestand meet, weet u dat de andere qubit zich ook in de $\ket{0}$ toestand bevindt zonder deze te meten. Zie Kwantumverstrengeling voor meer informatie.

In deze snelstart, gaat u het volgende doen:

Maak een Q#-bestand.
Een paar qubits toewijzen.
Verstrengel de qubits.

Vereisten

De nieuwste versie van Visual Studio Code.
De extensie Azure Quantum Development Kit (QDK). Zie De Quantum Development Kit instellen voor meer informatie over de installatie.

Q# Een bestand maken

Open Visual Studio Code.
Selecteer Nieuw>tekstbestand bestand.
Sla het bestand op als Main.qs. De extensie .qs geeft een Q# programma aan.

Q# Uw code schrijven

Volg deze stappen in het Main.qs bestand om een paar qubits te verstrengelen en meten.

Een kwantumbibliotheek importeren

De QDK bevat de Q# standaardbibliotheek met vooraf gedefinieerde functies en bewerkingen voor uw kwantumprogramma's. Als u deze wilt gebruiken, moet u eerst de relevante bibliotheek importeren.

Gebruik in uw programma een import instructie om de Microsoft.Quantum.Diagnostics bibliotheek te openen. Hiermee hebt u toegang tot alle functies en bewerkingen, waaronder DumpMachine(), die u later gebruikt om de verstrengelde status weer te geven.

    import Microsoft.Quantum.Diagnostics.*;

Een bewerking definiëren

Nadat u de relevante bibliotheken hebt geïmporteerd, definieert u uw kwantumbewerking en de bijbehorende invoer- en uitvoerwaarden. Voor deze quickstart is Mainuw bewerking . Hier schrijft u de resterende Q# code om twee qubits toe te wijzen, te bewerken en te meten.

Mainneemt geen parameters en retourneert twee Result waarden, ofwel OneZero , die de resultaten van de qubitmetingen vertegenwoordigen:

    operation Main() : (Result, Result) {
        // Your entanglement code goes here.
}

Twee qubits toewijzen

De Main bewerking is momenteel leeg, dus de volgende stap is het toewijzen van twee qubits en q2q1 . In Q#, wijst u qubits toe met behulp van het use trefwoord:

        // Allocate two qubits, q1 and q2, in the 0 state.
        use (q1, q2) = (Qubit(), Qubit());

Notitie

In Q#, qubits worden altijd toegewezen in de $\ket{0}$ status.

Eén qubit in superpositie plaatsen

De qubits q1 en q2 hebben de $\ket{0}$ status. Als u de qubits wilt voorbereiden op verstrengeling, moet u een van deze in een even superpositie plaatsen, waarbij het een kans van 50% heeft om te worden gemeten als $\ket{0}$ of $\ket{1}$.

U plaatst een qubit in superpositie door de Hadamard-bewerking Htoe te passen:

        // Put q1 into an even superposition.
        H(q1);

De resulterende toestand q1 is $\frac{{1}{\sqrt{2}}(\ket{{0}+\ket{1}),$ een even superpositie van $\ket{0}$ en $\ket{{1}$.

De qubits verstrengelen

U bent nu klaar om de qubits te verstrengelen met behulp van de bewerking controlled-NOT. CNOT CNOT is een besturingsbewerking die twee qubits gebruikt, één die fungeert als het besturingselement en de andere als het doel.

Voor deze quickstart stelt q1 u in als de controle-qubit en q2 als de doel-qubit. Dit betekent dat CNOT de toestand verandert van q2 wanneer de toestand q1 is $\ket{1}$.

        // Entangle q1 and q2, making q2 depend on q1.
        CNOT(q1, q2);

De resulterende toestand van beide qubits is het belpaar $\frac{{1}{\sqrt{2}}(\ket{00}+\ket{{11}).$

Tip

Als u wilt weten hoe de Hadamard- en CNOT-bewerkingen de status van de qubits transformeren, raadpleegt u Verstrengeling maken met kwantumbewerkingen.

De verstrengelde status weergeven

Voordat u de qubits meet, is het belangrijk om te controleren of uw vorige code deze verstrengelt. U kunt de DumpMachine bewerking, die deel uitmaakt van de Microsoft.Quantum.Diagnostics bibliotheek, gebruiken om de huidige status van uw Q# programma uit te voeren:

        // Show the entangled state of the qubits.
        DumpMachine();

De qubits meten

Nu u hebt gecontroleerd of de qubits zijn verstrengeld, kunt u de M bewerking gebruiken om ze te meten. Meten q1 en q2 samenvouwen van hun kwantumtoestanden in Zero of One met zelfs waarschijnlijkheid.

In Q#, gebruikt u het let trefwoord om een nieuwe variabele te declareren. Als u de meetresultaten van q1 respectievelijk de variabelen m1 wilt q2opslaan en, declareert um2:

        // Measure q1 and q2 and store the results in m1 and m2.
        let (m1, m2) = (M(q1), M(q2));

De qubits opnieuw instellen

Voordat u aan het einde van elk Q# programma wordt vrijgegeven, moeten qubits de $\ket{0}$ status hebben. U doet dit met behulp van de Reset bewerking:

        // Reset q1 and q2 to the 0 state.
        Reset(q1);
        Reset(q2);

De meetresultaten retourneren

Ten slotte, om de Main bewerking te voltooien en de verstrengelde toestand te observeren, retourneert u de meetresultaten van m1 en m2:

        // Return the measurement results.
        return (m1, m2);

Tip

Als u meer wilt weten over een Q# functie of bewerking, plaatst u de muisaanwijzer erop.

Schermopname van de details die worden weergegeven wanneer u de bewerking H in Visual Studio Code aanwijst.

Uw Q# code uitvoeren

Gefeliciteerd U hebt een Q# programma geschreven dat twee qubits verstrengelt en een belpaar maakt.

Uw uiteindelijke Q# programma ziet er als volgt uit:

import Microsoft.Quantum.Diagnostics.*;

operation Main() : (Result, Result) {  
    // Allocate two qubits, q1 and q2, in the 0 state.
    use (q1, q2) = (Qubit(), Qubit());
    
    // Put q1 into an even superposition.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q1);
    
    // Entangle q1 and q2, making q2 depend on q1.
    CNOT(q1, q2);
    
    // Show the entangled state of the qubits.
    DumpMachine();
    
    // Measure q1 and q2 and store the results in m1 and m2.
    let (m1, m2) = (M(q1), M(q2));
    
    // Reset q1 and q2 to the 0 state.
    Reset(q1);
    Reset(q2);
    
    // Return the measurement results.
    return (m1, m2);
}

Als u het programma wilt uitvoeren en het resultaat van beide qubits wilt weergeven, selecteert u Uitvoeren boven de Main bewerking of drukt u op Ctrl+F5

Schermopname van het Q# bestand in Visual Studio Code waarin wordt weergegeven waar u de opdracht Uitvoeren kunt vinden.

U kunt het programma meerdere keren uitvoeren, elk met een ander resultaat in de foutopsporingsconsole. Dit demonstreert de probabilistische aard van kwantummetingen en de verstrengeling van de qubits.

Als het resultaat bijvoorbeeld is Zero, ziet de foutopsporingsconsole er als volgt uit:

DumpMachine:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
  |00⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
  |11⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

Result: "(Zero, Zero)"

Volgende stap

Zie Zelfstudie: Kwantumverstrengeling verkennen met voor meer informatie over kwantumverstrengeling.Q#Q# Deze zelfstudie breidt de concepten uit die in deze quickstart worden behandeld en helpt u bij het schrijven van een geavanceerder verstrengelingsprogramma.

Delen via