Zelfstudie: Kwantumverstrengeling verkennen met Q#

Artikel
12/18/2024

In deze zelfstudie schrijft u een Q# programma dat qubits bewerkt en meet en demonstreert en de effecten van superpositie en verstrengeling demonstreert. U bereidt twee qubits voor in een specifieke kwantumstatus, leert hoe u op qubits Q# kunt werken om hun status te wijzigen en de effecten van superpositie en verstrengeling te demonstreren. U bouwt uw Q# programma stuk voor stuk om qubitstatussen, bewerkingen en metingen te introduceren.

Hier volgen enkele belangrijke concepten die u moet begrijpen voordat u begint:

Waarbij klassieke bits één binaire waarde bevatten, zoals een 0 of 1, kan de toestand van een qubit zich in een superpositie van twee kwantumtoestanden bevinden, 0 en 1. Elke mogelijke kwantumtoestand heeft een bijbehorende waarschijnlijkheidsamplitude.
De handeling van het meten van een qubit produceert een binair resultaat met een bepaalde waarschijnlijkheid en wijzigt de toestand van de qubit uit superpositie.
Meerdere qubits kunnen worden verstrengeld, zodat ze niet onafhankelijk van elkaar kunnen worden beschreven. Dat wil gezegd, wat er ook gebeurt met één qubit in een verstrengeld paar, gebeurt ook met de andere qubit.

In deze zelfstudie leert u het volgende:

Bewerkingen maken Q# om een qubit te initialiseren naar een gewenste status.
Plaats een qubit in superpositie.
Verstrengel een paar qubits.
Meet een qubit en bekijk de resultaten.

Tip

Als u uw kwantumcomputingtraject wilt versnellen, bekijkt u Code met Azure Quantum, een unieke functie van de Azure Quantum-website. Hier kunt u ingebouwde Q# voorbeelden of uw eigen Q# programma's uitvoeren, nieuwe Q# code genereren vanuit uw prompts, uw code openen en uitvoeren in VS Code voor het web met één klik en Copilot vragen stellen over kwantumcomputing.

Vereisten

Als u het codevoorbeeld wilt uitvoeren in Copilot voor Azure Quantum, hebt u het volgende nodig:

Een Microsoft-e-mailaccount (MSA).

Zie Azure Quantum verkennen voor meer informatie over Copilot.

Een qubit initialiseren naar een bekende status

De eerste stap is het definiëren van een Q# bewerking waarmee een qubit wordt geïnitialiseerd naar een bekende status. Deze bewerking kan worden aangeroepen om een qubit in te stellen op een klassieke toestand, wat betekent dat, wanneer gemeten, het 100% van de tijd retourneert Zero of 100% van de tijd retourneert One . Het meten van een qubit retourneert een Q# type Result, dat alleen een waarde van Zero of Onekan hebben.

Open Copilot voor Azure Quantum en kopieer de volgende code naar het venster van de code-editor. Selecteer nog niet Uitvoeren; u voert de code verderop in de zelfstudie uit.

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

In het codevoorbeeld worden twee standaardbewerkingen M geïntroduceerd en Xwordt de status van een qubit getransformeerd.

De SetQubitState bewerking:

Neemt twee parameters: een type Result, benoemd desired, dat de gewenste status vertegenwoordigt voor de qubit die zich in (Zero of One) en een type Qubitbevindt.
Voert een metingsbewerking uit, Mwaarmee de toestand van de qubit (Zero of One) wordt gemeten en het resultaat wordt vergeleken met de waarde die is opgegeven in desired.
Als de meting niet overeenkomt met de vergeleken waarde, wordt er een X bewerking uitgevoerd, waarmee de toestand van de qubit wordt gespiegeld naar waar de waarschijnlijkheden van een meting worden geretourneerd Zero en One worden omgekeerd. Op deze manier SetQubitState wordt de doel-qubit altijd in de gewenste status gestopt.

Een testbewerking schrijven om de klokstatus te testen

Als u vervolgens het effect van de bewerking wilt demonstreren, maakt u een andere bewerking met de SetQubitState naam Main. Met deze bewerking worden twee qubits toegewezen, aangeroepen SetQubitState om de eerste qubit in te stellen op een bekende status en vervolgens de qubits te meten om de resultaten te zien.

Kopieer de volgende code naar het venster van de code-editor, onder de SetQubitState bewerking.

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

In de code worden de count variabelen initial ingesteld op 1000 respectievelijk One . Hiermee wordt de eerste qubit geïnitialiseerd en One wordt elke qubit 1000 keer gemeten.

De Mainbewerking:

Hiermee stelt u variabelen in voor de teller en de initiële qubitstatus.
Roept de use instructie aan om twee qubits te initialiseren.
Lussen voor count iteraties. Voor elke lus is deze
1. Aanroepen SetQubitState om een opgegeven initial waarde in te stellen voor de eerste qubit.
2. Roept SetQubitState opnieuw aan om de tweede qubit in te stellen op een Zero status.
3. Gebruikt de M bewerking om elke qubit te meten.
4. Slaat het aantal metingen op voor elke qubit die retourneert One.
Nadat de lus is voltooid, wordt opnieuw aanroepen SetQubitState om de qubits opnieuw in te stellen op een bekende status (Zero) zodat anderen de qubits in een bekende status kunnen toewijzen. Opnieuw instellen is vereist voor de use instructie.
Ten slotte wordt de Message functie gebruikt om resultaten af te drukken naar de Copilot-uitvoervensters voordat de resultaten worden geretourneerd.

De code uitvoeren in Copilot voor Azure Quantum

Voordat u verdergaat met de procedures voor superpositie en verstrengeling, kunt u de code tot nu toe testen om de initialisatie en meting van de qubits te zien.

Als u de code wilt uitvoeren als een zelfstandig programma, moet de Q# compiler in Copilot weten waar het programma moet worden gestart. Omdat er geen naamruimte is opgegeven, herkent de compiler het standaardinvoerpunt als de Main bewerking. Zie Projecten en impliciete naamruimten voor meer informatie.

Uw Q# programma tot nu toe moet er nu als volgt uitzien:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
        
    
    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

}

Kopieer en plak het complete codevoorbeeld in het codevenster Copilot voor Azure Quantum, stel de schuifregelaar voor het aantal shots in op "1" en selecteer uitvoeren. De resultaten worden weergegeven in het histogram en in de resultatenvelden .

Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0

Omdat de qubits nog niet zijn gemanipuleerd, hebben ze hun initiële waarden behouden: de eerste qubit retourneert One elke keer en de tweede qubit retourneert Zero.

Als u de waarde van initial het Zero programma wijzigt en opnieuw uitvoert, moet u er rekening mee houden dat de eerste qubit ook elke keer wordt geretourneerd Zero .

Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0

Tip

Selecteer Ctrl-Z of > en sla het bestand op wanneer u een testwijziging in de code introduceert voordat u het opnieuw uitvoert.

Een qubit in superpositie plaatsen

Momenteel hebben de qubits in het programma allemaal een klassieke status, dat wil gezegd: ze zijn 1 of 0. U weet dit omdat het programma de qubits initialiseert naar een bekende status en u geen processen hebt toegevoegd om ze te bewerken. Voordat u de qubits verstrengelt, plaatst u de eerste qubit in een superpositiestatus, waarbij een meting van de qubit ~50% van de tijd en Zero ~50% van de tijd retourneert One . Conceptueel gezien kan de qubit worden beschouwd als een gelijke waarschijnlijkheid van het meten of ZeroOne.

Als u een qubit in superpositie wilt plaatsen, Q# levert u de Hbewerking of Hadamard. U herinnert zich de X bewerking van de initialisatie van een qubit naar een bekende toestandsprocedure eerder, die een qubit van 0 naar 1 heeft gespiegeld (of omgekeerd); de H bewerking spiegelt de qubit halverwege in een toestand van gelijke waarschijnlijkheden van Zero of One. Wanneer gemeten, moet een qubit in superpositie ongeveer een gelijk aantal Zero en One resultaten retourneren.

Wijzig de code in de Main bewerking door de initiële waarde opnieuw in te One voegen en een regel voor de H bewerking in te voegen:

for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        H(q1);                // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

Wanneer u het programma uitvoert, ziet u nu de resultaten van de eerste qubit in superpositie.

Q1 - Zeros: 523            // results vary
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0

Telkens wanneer u het programma uitvoert, variëren de resultaten voor de eerste qubit enigszins, maar liggen dicht bij 50% One en 50% Zero, terwijl de resultaten voor de tweede qubit de hele tijd blijven Zero bestaan.

Q1 - Zeros: 510           
Q1 - Ones: 490
Q2 - Zeros: 1000
Q2 - Ones: 0

Het initialiseren van de eerste qubit om vergelijkbare resultaten te Zero retourneren.

Q1 - Zeros: 504           
Q1 - Ones: 496
Q2 - Zeros: 1000
Q2 - Ones: 0

Notitie

Door de schuifregelaar in Copilot voor Azure Quantum te verplaatsen en het aantal opnamen te verhogen, kunt u zien hoe de superpositieresultaten enigszins verschillen ten opzichte van de distributie van de opnamen.

Twee qubits verstrengelen

Zoals eerder vermeld, zijn verstrengelde qubits zodanig verbonden dat ze niet onafhankelijk van elkaar kunnen worden beschreven. Dat wil gezegd, wat er ook gebeurt met één qubit, gebeurt ook met de verstrengelde qubit. Hierdoor kunt u de resulterende toestand van één qubit kennen zonder deze te meten, alleen door de toestand van de andere qubit te meten. (In dit voorbeeld worden twee qubits gebruikt. Het is echter ook mogelijk om drie of meer qubits te verstrengelen).

Als u verstrengeling wilt inschakelen, Q# biedt u de CNOT bewerking, die staat voor Controlled-NOT. Het resultaat van het uitvoeren van deze bewerking op twee qubits is het spiegelen van de tweede qubit als de eerste qubit is One.

Voeg de CNOT bewerking direct na de H bewerking toe aan uw programma. Uw volledige programma ziet er als volgt uit:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

    operation SetQubitState(desired : Result, target : Qubit) : Unit {
        if desired != M(target) {
            X(target);
        }
    }

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = Zero;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
    
        H(q1);            
        CNOT(q1, q2);      // Add the CNOT operation after the H operation

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

    }

Wanneer u het programma uitvoert, ziet u nu iets als:

Q1 - Zeros: 502           // results will vary
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

U ziet dat de statistieken voor de eerste qubit niet zijn gewijzigd (er is nog steeds een kans van ongeveer 50/50 op een Zero of na One meting), maar de metingsresultaten voor de tweede qubit zijn altijd hetzelfde als de meting van de eerste qubit, ongeacht hoe vaak u het programma uitvoert. De CNOT bewerking heeft de twee qubits verstrengeld, zodat alles wat er met een van deze gebeurt, met de andere gebeurt.

Vereisten

Het codevoorbeeld ontwikkelen en uitvoeren in uw lokale ontwikkelomgeving:

De nieuwste versie van Visual Studio Code of open VS Code op het web.
De nieuwste versie van de Azure Quantum Development Kit-extensie. Zie De QDK-extensie instellenvoor installatiedetails.

Een nieuw Q# bestand maken

Open Visual Studio Code en selecteer Bestand > nieuw tekstbestand om een nieuw bestand te maken.
Sla het bestand op als CreateBellStates.qs. Dit bestand bevat de Q# code voor uw programma.

Een qubit initialiseren naar een bekende status

De eerste stap is het definiëren van een Q# bewerking waarmee een qubit wordt geïnitialiseerd naar een bekende status. Deze bewerking kan worden aangeroepen om een qubit in te stellen op een klassieke toestand, wat betekent dat deze 100% van de tijd retourneert Zero of 100% van de tijd retourneert One . Zero en One zijn Q# waarden die de enige twee mogelijke resultaten van een meting van een qubit vertegenwoordigen.

Open CreateBellStates.qs en kopieer de volgende code:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

In het codevoorbeeld worden twee standaardbewerkingen M geïntroduceerd en Xwordt de status van een qubit getransformeerd.

De SetQubitState bewerking:

Neemt twee parameters: een type Result, benoemd desired, dat de gewenste status vertegenwoordigt voor de qubit die zich in (Zero of One) en een type Qubitbevindt.
Voert een metingsbewerking uit, Mwaarmee de toestand van de qubit (Zero of One) wordt gemeten en het resultaat wordt vergeleken met de waarde die is opgegeven in desired.
Als de meting niet overeenkomt met de vergeleken waarde, wordt er een X bewerking uitgevoerd, waarmee de toestand van de qubit wordt gespiegeld naar waar de waarschijnlijkheden van een meting worden geretourneerd Zero en One worden omgekeerd. Op deze manier SetQubitState wordt de doel-qubit altijd in de gewenste status gestopt.

Een testbewerking schrijven om de klokstatus te testen

Voeg de volgende bewerking toe aan uw CreateBellStates.qs bestand na de SetQubitState bewerking:

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

In de code worden de count variabelen initial ingesteld op 1000 respectievelijk One . Met deze stap wordt de eerste qubit geïnitialiseerd en One wordt elke qubit 1000 keer gemeten.

De Mainbewerking:

Neemt twee parameters: count, het aantal keren dat een meting moet worden uitgevoerd en initial, de gewenste status om de qubit te initialiseren.
Roept de use instructie aan om twee qubits te initialiseren.
Lussen voor count iteraties. Voor elke lus is deze
1. Aanroepen SetQubitState om een opgegeven initial waarde in te stellen voor de eerste qubit.
2. Roept SetQubitState opnieuw aan om de tweede qubit in te stellen op een Zero status.
3. Gebruikt de M bewerking om elke qubit te meten.
4. Slaat het aantal metingen op voor elke qubit die retourneert One.
Nadat de lus is voltooid, wordt opnieuw aanroepen SetQubitState om de qubits opnieuw in te stellen op een bekende status (Zero) zodat anderen de qubits in een bekende status kunnen toewijzen. Het opnieuw instellen van de qubit is vereist voor de use instructie.
Ten slotte wordt de Message functie gebruikt om een bericht af te drukken naar de console voordat de resultaten worden geretourneerd.

De code uitvoeren

Voordat u verdergaat met de procedures voor superpositie en verstrengeling, test u de code tot dit punt om de initialisatie en meting van de qubits te zien.

Als u de code als zelfstandig programma wilt uitvoeren, moet de Q# compiler weten waar het programma moet worden gestart. Omdat er geen naamruimte is opgegeven, herkent de compiler het standaardinvoerpunt als de Main bewerking. Zie Projecten en impliciete naamruimten voor meer informatie.

Het CreateBellStates.qs bestand tot nu toe moet er nu als volgt uitzien:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);


    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Voordat u het programma uitvoert, moet u ervoor zorgen dat het doelprofiel is ingesteld op Unrestricted. Selecteer Weergave -> Opdrachtpalet, zoek naar QIR, selecteer Q#: Stel het Azure Quantum QIR-doelprofiel in en selecteer Q#vervolgens : onbeperkt.

Notitie

Als het doelprofiel niet is ingesteld op Unrestricted, krijgt u een foutmelding wanneer u het programma uitvoert.
Als u het programma wilt uitvoeren, selecteert u Q# uitvoeren in de vervolgkeuzelijst Voor afspelen in de rechterbovenhoek, selecteert u UitvoerenMainop Ctrl+F5. Het programma voert de Main bewerking uit op de standaardsimulator.
De uitvoer wordt weergegeven in de console voor foutopsporing.
```
Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0
```
Omdat de qubits nog niet zijn gemanipuleerd, hebben ze hun initiële waarden behouden: de eerste qubit retourneert One elke keer en de tweede qubit retourneert Zero.
Als u de waarde van initial het Zero programma wijzigt en opnieuw uitvoert, moet u er rekening mee houden dat de eerste qubit ook elke keer wordt geretourneerd Zero .
```
Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0
```

Tip

Selecteer Ctrl-Z of > en sla het bestand op wanneer u een testwijziging in de code introduceert voordat u het opnieuw uitvoert.

Een qubit in superpositie plaatsen

Momenteel hebben de qubits in het programma allemaal een klassieke status, dat wil gezegd: ze zijn 1 of 0. U weet dit omdat het programma de qubits initialiseert naar een bekende status en u geen processen hebt toegevoegd om ze te bewerken. Voordat u de qubits verstrengelt, plaatst u de eerste qubit in een superpositiestatus, waarbij een meting van de qubit 50% van de tijd en Zero 50% van de tijd retourneertOne. Conceptueel gezien kan de qubit worden beschouwd als halverwege tussen de Zero en One.

Als u een qubit in superpositie wilt plaatsen, Q# levert u de Hbewerking of Hadamard. U herinnert zich de X bewerking van de initialisatie van een qubit naar een bekende toestandsprocedure die eerder een qubit heeft gespiegeld van Zero ( One of omgekeerd); de H bewerking spiegelt de qubit halverwege in een toestand van gelijke waarschijnlijkheden van Zero of One. Wanneer gemeten, moet een qubit in superpositie ongeveer een gelijk aantal Zero en One resultaten retourneren.

Wijzig de code in de Main bewerking om de H bewerking op te nemen:

for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);

        H(q1);                // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

Wanneer u het programma uitvoert, ziet u nu de resultaten van de eerste qubit in superpositie:

Q1 - Zeros: 523            // results will vary
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0

Telkens wanneer u het programma uitvoert, variëren de resultaten voor de eerste qubit enigszins, maar liggen dicht bij 50% One en 50% Zero, terwijl de resultaten voor de tweede qubit de hele tijd blijven Zero bestaan.
```
Q1 - Zeros: 510           
Q1 - Ones: 490
Q2 - Zeros: 1000
Q2 - Ones: 0
```
Het initialiseren van de eerste qubit om vergelijkbare resultaten te Zero retourneren.
```
Q1 - Zeros: 504           
Q1 - Ones: 496
Q2 - Zeros: 1000
Q2 - Ones: 0
```

Twee qubits verstrengelen

Voeg de CNOT bewerking direct na de H bewerking toe aan uw programma. Uw volledige programma ziet er als volgt uit:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

    operation SetQubitState(desired : Result, target : Qubit) : Unit {
        if desired != M(target) {
            X(target);
        }
    }

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = Zero;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);

        H(q1);            
        CNOT(q1, q2);      // Add the CNOT operation after the H operation

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);


    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

    }

Q1 - Zeros: 502           
Q1 - Ones: 498       // results will vary
Q2 - Zeros: 502
Q2 - Ones: 498
Result: "(502, 498, 502, 498)"

De statistieken voor de eerste qubit zijn niet gewijzigd (een kans van 50/50 op een Zero of een One na meting), maar de metingresultaten voor de tweede qubit zijn altijd hetzelfde als de meting van de eerste qubit. De CNOT bewerking verstrengelde de twee qubits, zodat alles wat er met een van deze gebeurt, met de andere gebeurt.

Het frequentie histogram tekenen

Laten we de distributie visualiseren van resultaten die zijn verkregen door het uitvoeren van het kwantumprogramma meerdere keren. Het frequentie histogram helpt bij het visualiseren van de waarschijnlijkheidsverdeling van deze resultaten.

Selecteer Weergave -> Opdrachtpalet of druk op Ctrl+Shift+P en typ 'histogram' dat het Q#volgende moet bevatten: Bestand uitvoeren en histogramoptie weergeven. U kunt ook Histogram selecteren in de lijst met opdrachten die voorafgaanMain. Selecteer deze optie om het Q# histogramvenster te openen.
Voer een aantal schoten in om het programma uit te voeren, bijvoorbeeld 100 shots en druk op Enter. Het histogram wordt weergegeven in het Q# histogramvenster.
Elke balk in het histogram komt overeen met een mogelijk resultaat en de hoogte geeft het aantal keren aan dat het resultaat wordt waargenomen. In dit geval zijn er 50 verschillende unieke resultaten. Houd er rekening mee dat voor elk resultaat de meetresultaten voor de eerste en de tweede qubit altijd hetzelfde zijn.

Tip

U kunt het histogram inzoomen met behulp van het muiswiel of een trackpadbeweging. Wanneer u inzoomt, kunt u de grafiek pannen door tijdens het schuiven op Alt te drukken.
Selecteer een balk om het percentage van dat resultaat weer te geven.
Selecteer het pictogram met instellingen linksboven om opties weer te geven. U kunt top 10 resultaten, top 25 resultaten of alle resultaten weergeven. U kunt de resultaten ook sorteren van hoog naar laag of van laag naar hoog.

Bekijk andere Q# zelfstudies:

Het zoekalgoritmen van Grover laten zien hoe u een Q# programma schrijft dat gebruikmaakt van het zoekalgoritmen van Grover.
Quantum Fourier Transform verkent hoe u een Q# programma schrijft waarmee specifieke qubits rechtstreeks worden aangepakt.
De Quantum Katas zijn zelfstudies in eigen tempo en programmeeroefeningen die zijn gericht op het leren van de elementen van kwantumcomputing en Q# programmeren op hetzelfde moment.

Delen via

Zelfstudie: Kwantumverstrengeling verkennen met Q#

Vereisten

Een qubit initialiseren naar een bekende status

Een testbewerking schrijven om de klokstatus te testen

De code uitvoeren in Copilot voor Azure Quantum

Een qubit in superpositie plaatsen

Twee qubits verstrengelen

Vereisten

Een nieuw Q# bestand maken

Een qubit initialiseren naar een bekende status

Een testbewerking schrijven om de klokstatus te testen

De code uitvoeren

Een qubit in superpositie plaatsen

Twee qubits verstrengelen

Het frequentie histogram tekenen

Feedback

Aanvullende resources

Delen via

Zelfstudie: Kwantumverstrengeling verkennen met Q#

Vereisten

Een qubit initialiseren naar een bekende status

Een testbewerking schrijven om de klokstatus te testen

De code uitvoeren in Copilot voor Azure Quantum

Een qubit in superpositie plaatsen

Twee qubits verstrengelen

Vereisten

Een nieuw Q# bestand maken

Een qubit initialiseren naar een bekende status

Een testbewerking schrijven om de klokstatus te testen

De code uitvoeren

Een qubit in superpositie plaatsen

Twee qubits verstrengelen

Het frequentie histogram tekenen

Gerelateerde inhoud

Feedback

Aanvullende resources