Snabbstart: Skapa ditt första Q# program

Artikel
10/29/2024

Lär dig hur du skriver ett grundläggande Q# program som visar sammanflätning, ett nyckelbegrepp inom kvantberäkning.

När två eller flera kvantbitar är sammanflätade delar de kvantinformation, vilket innebär att vad som än händer med en kvantbit också händer med den andra. I den här snabbstarten skapar du ett särskilt två-qubit-sammanflätat tillstånd som kallas bellpar. I ett Bell-par, om du mäter en qubit i $\ket{0}$ tillståndet, vet du att den andra qubiten $\ket{0}$ också är i tillståndet utan att mäta den. Mer information finns i Quantum-sammanflätning.

I den här snabbstarten kommer du att göra följande:

Skapa en Q#-fil.
Allokera ett par kvantbitar.
Sammanfläta kvantbitarna.

Förutsättningar

Den senaste versionen av Visual Studio Code.
Tillägget Azure Quantum Development Kit (QDK). Installationsinformation finns i Konfigurera Quantum Development Kit.

Skapa en Q# fil

Öppna Visual Studio Code.
Välj Fil>Ny textfil.
Spara filen som Main.qs. Tillägget .qs anger ett Q# program.

Skriv din Q# kod

Main.qs I filen följer du de här stegen för att sammanfläta och mäta ett par kvantbitar.

Importera ett kvantbibliotek

QDK innehåller standardbiblioteket Q# med fördefinierade funktioner och åtgärder för dina kvantprogram. Om du vill använda dem måste du först importera det relevanta biblioteket.

I programmet använder du en import instruktion för att öppna Microsoft.Quantum.Diagnostics biblioteket. Detta ger dig åtkomst till alla dess funktioner och åtgärder, inklusive DumpMachine(), som du senare använder för att visa det sammanflätade tillståndet.

    import Microsoft.Quantum.Diagnostics.*;

Definiera en åtgärd

När du har importerat relevanta bibliotek definierar du kvantåtgärden och dess indata- och utdatavärden. För den här snabbstarten är Mainåtgärden . Det är här du skriver den återstående Q# koden för att allokera, manipulera och mäta två kvantbitar.

Main tar inga parametrar och returnerar två Result värden, antingen Zero eller One, som representerar resultatet av kvantbitsmätningarna:

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

Allokera två kvantbitar

Åtgärden Main är för närvarande tom, så nästa steg är att allokera två kvantbitar q1 och q2. I Q#allokerar du kvantbitar med hjälp av nyckelordet use :

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

Kommentar

I Q#allokeras kvantbitar alltid i tillståndet $\ket{0}$ .

Placera en qubit i superposition

Kvantbitarna q1 och q2 är i tillståndet $\ket{0}$ . För att förbereda kvantbitarna för sammanflätning måste du placera en av dem i en jämn superposition, där den har 50 % chans att mätas som $\ket{0}$ eller $\ket{1}$.

Du lägger en qubit i superposition genom att tillämpa åtgärden Hadamard, H, :

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

Det resulterande tillståndet q1 för är $\frac{{1}{\sqrt{2}}(\ket{{0}+\ket{1})$, vilket är en jämn superposition av $\ket{0}$ och $\ket{{1}$.

Sammanfläta kvantbitarna

Nu är du redo att sammanfläta kvantbitarna med hjälp av åtgärden controlled-NOT, CNOT, . CNOT är en kontrollåtgärd som tar två kvantbitar, den ena fungerar som kontroll och den andra som mål.

I den här snabbstarten anger q1 du som kontrollkvenbit och q2 som målkvenbit. Det innebär att CNOT vänder tillståndet q2 för när tillståndet q1 för är $\ket{1}$.

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

Det resulterande tillståndet för båda kvantbitarna är klockparet $\frac{{1}{\sqrt{2}}(\ket{00}+\ket{{11})$.

Dricks

Om du vill lära dig hur Hadamard- och CNOT-åtgärderna omvandlar tillståndet för kvantbitarna kan du läsa Skapa sammanflätning med kvantåtgärder.

Visa det sammanflätade tillståndet

Innan du mäter kvantbitarna är det viktigt att kontrollera att din tidigare kod sammanflätar dem. Du kan använda åtgärden DumpMachine , som är en del av Microsoft.Quantum.Diagnostics biblioteket, för att mata ut programmets Q# aktuella tillstånd:

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

Mäta kvantbitarna

Nu när du har kontrollerat att kvantbitarna är sammanflätade kan du använda M åtgärden för att mäta dem. Mätning q1 och q2 kollaps av kvanttillstånd i Zero eller One med jämn sannolikhet.

I Q#använder du nyckelordet let för att deklarera en ny variabel. Om du vill lagra mätresultaten för q1 och q2deklarerar du variablerna m1 respektive m2:

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

Återställa kvantbitarna

Innan de släpps i slutet av varje Q# program måste kvantbitar vara i tillståndet $\ket{0}$ . Du gör detta med hjälp av åtgärden Reset :

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

Returnera mätresultatet

Slutligen, för att slutföra Main åtgärden och observera det sammanflätade tillståndet, returnerar du mätresultaten för m1 och m2:

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

Dricks

Om du vill veta mer om en Q# funktion eller åtgärd hovra över den.

Skärmbild av informationen som visas när du hovra över H-åtgärden i Visual Studio Code.

Kör koden Q#

Grattis! Du skrev ett Q# program som sammanflätar två kvantbitar och skapar ett Bell-par.

Ditt slutliga Q# program bör se ut så här:

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);
}

Om du vill köra programmet och visa resultatet av båda kvantbitarna väljer du Kör ovanför Main åtgärden eller trycker på Ctrl+F5

Skärmbild av Q# filen i Visual Studio Code som visar var du hittar kommandot

Du kan köra programmet flera gånger, var och en med olika resultat i felsökningskonsolen. Detta visar kvantmätningarnas probabilistiska karaktär och sammanflätningen av kvantbitarna.

Om resultatet till exempel är Zerobör felsökningskonsolen se ut så här:

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

Gå vidare

Mer information om kvantsammanflätning med finns i Självstudie: Utforska kvantsammanflätning med Q#.Q# Den här självstudien går igenom de begrepp som beskrivs i den här snabbstarten och hjälper dig att skriva ett mer avancerat sammanflätningsprogram.

Dela via