Oktatóanyag: A kvantum-összefonódás megismerése a következővel: Q#

Cikk
02/21/2024

Ez az oktatóanyag bemutatja, hogyan írhat olyan Q# programot, amely manipulálja és méri a qubiteket, és bemutatja a szuperpozíció és az összefonódás hatásait. Két qubitet készíthet elő egy adott kvantumállapotban, megtudhatja, hogyan használhatja a qubiteket Q# az állapotuk megváltoztatásához, és bemutatja a szuperpozíció és az összefonódás hatásait. A program összeállítása Q# lépésről lépésre lehetővé teszi a qubitállapotok, műveletek és mérések bemutatását.

Megjegyzés

A Microsoft Quantum Development Kit (klasszikus QDK) 2024. június 30. után már nem támogatott. Ha Ön egy meglévő QDK-fejlesztő, javasoljuk, hogy térjen át az új Azure Quantum Development Kitre (Modern QDK) a kvantummegoldások fejlesztésének folytatásához. További információ: Kód migrálása Q# a modern QDK-ba.

A kezdés előtt az alábbiakban néhány fontos fogalmat ismerhet meg:

Ahol a klasszikus bitek egyetlen bináris értéket ,például 0-t vagy 1-et tárolnak, a qubit állapota két kvantumállapot szuperpozíciójában lehet: 0 és 1. Minden lehetséges kvantumállapothoz tartozik egy valószínűségi amplitúdó.
A qubit mérésének eredménye egy bizonyos valószínűségű bináris eredmény, és a qubit szuperpozíción kívüli állapotát változtatja meg.
Több qubit is összefonódhat, így nem írhatók le egymástól függetlenül. Vagyis bármi is történik egy összefonódott pár egyik qubitjével, az a másik qubitel is történik.

Ebből az oktatóanyagból az alábbiakat sajátíthatja el:

Hozzon létre Q# műveleteket a qubit kívánt állapotba való inicializálásához.
Helyezzen egy qubitet szuperpozícióba.
Összefonódjon egy qubitpár.
Mérje meg a qubitet, és figyelje meg az eredményeket.

Tipp

Ha fel szeretné gyorsítani a kvantum-számítástechnika folyamatát, tekintse meg a Code with Azure Quantum (Kód az Azure Quantum használatával) című témakört, amely az Azure Quantum webhelyének egyedülálló funkciója. Itt futtathat beépített mintákat vagy saját Q# programokat, új Q# kódot hozhat létre az üzeneteiből, megnyithatja és futtathatja a kódot a WEBES VS Code-banQ# egyetlen kattintással, és kérdéseket tehet fel a Copilotnak a kvantum-számítástechnikával kapcsolatban.

Előfeltételek

A kódminta Azure Quantumhoz készült Copilotban való futtatásához a következőkre van szükség:

Egy Microsoft(MSA) e-mail-fiók.

További információ a Copilotról: Az Azure Quantum felfedezése.

Qubit inicializálása ismert állapotba

Az első lépés egy Q# olyan művelet definiálása, amely egy qubitet egy ismert állapotba inicializál. Ez úgy hívható meg, hogy egy qubitet klasszikus állapotra állítson be, ami azt jelenti, hogy méréskor vagy az idő 100%-át adja vissza Zero , vagy az idő 100%-át adja vissza One . A qubit mérése olyan típust Q#Resultad vissza, amelynek értéke Zero csak vagy Onelehet.

Nyissa meg az Azure Quantumhoz készült Copilotot , és másolja a következő kódot a kódszerkesztő ablakába. Még ne kattintson a Futtatás gombra; a kódot az oktatóanyag későbbi részében fogja futtatni.

   namespace Bell {
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Canon;

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

A példakód két standard műveletet mutat be, a és Xa-t, M amelyek átalakítják a qubit állapotát.

A SetQubitState művelet:

Két paramétert vesz fel: egy nevű típustResult, amely a qubit kívánt állapotát jelöli (Zero vagy One), és egy típustQubit.desired
Egy olyan mérési műveletet hajt végre, Mamely a qubit (Zero vagy One) állapotát méri, és összehasonlítja az eredményt a megadott desiredértékkel.
Ha a mérés nem egyezik meg az összehasonlított értékkel, egy műveletet futtat X , amely a qubit állapotát oda fordítja, ahol a mérés valószínűségei visszaállnak Zero , és One vissza lesznek fordítva. Így SetQubitState mindig a cél qubitet a kívánt állapotba helyezi.

Tesztművelet írása a Bell állapot teszteléséhez

Ezután a művelet hatásának SetQubitState bemutatásához hozzon létre egy másik, nevű TestBellStateműveletet. Ez a művelet két qubitet foglal le, meghívja SetQubitState az első qubitet egy ismert állapotra, majd megméri a qubiteket az eredmények megtekintéséhez.

Másolja a következő kódot a kódszerkesztő ablakába a SetQubitState művelet alatt.

operation TestBellState() : (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 {
            set numOnesQ1 += 1;
        }
        if resultQ2 == One {
            set 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 );

}

A kódban a és initial a count változó a és One a értékre 1000 van állítva. Ez inicializálja az első qubitet, One és minden qubitet 1000-szer mér.

A TestBellStateművelet:

Beállítja a számláló és a kezdeti qubitállapot változóit.
Meghívja az use utasítást két qubit inicializálásához.
Ciklusok iterációkhoz count . Minden hurokhoz
1. Meghívja SetQubitState a megadott initial érték beállítását az első qubiten.
2. A SetQubitState második qubit állapotra való beállításához hívja meg újra a metódust Zero .
3. A művelettel M méri az egyes qubiteket.
4. A visszaadott Onequbitek mérésének számát tárolja.
A hurok befejeződése után ismét meghívja SetQubitState a qubiteket egy ismert állapotba (Zero), hogy mások is lefoglalják a qubiteket egy ismert állapotban. Ez a use utasítás miatt szükséges.
Végül a függvény használatával kinyomtatja az Message eredményeket a Copilot kimeneti ablakaiba, mielőtt visszaadja az eredményeket.

A kód futtatása a Copilot for Azure Quantumban

Mielőtt továbblépne a szuperpozíció és az összefonódás eljárásaira, tesztelheti a kódot addig a pontig, hogy lássa a qubitek inicializálását és mérését.

A kód önálló programként való futtatásához a Q# Copilot fordítójának tudnia kell, hol kezdje a programot. Ez úgy történik a Q# fájlban, hogy hozzáad egy @EntryPoint() közvetlenül a futtatni kívánt műveletet megelőző műveletet. Ebben az esetben például a TestBellState művelet.

Megjegyzés

@EntryPoint() csak különálló Q# programokhoz szükséges. Ha jupyter notebookokban futtat egy Q# programot, vagy egy Python-gazdafájlból hív meg egy Q# programot, az nem szükséges, és hibát jelez, ha belefoglalja.

Adja hozzá a közvetlenül a @EntryPoint() művelet előtt TestBellState lévő műveletet, és a Q# programnak ekkor a következőképpen kell kinéznie:

namespace Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

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

    @EntryPoint()
    operation TestBellState() : (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 {
                set numOnesQ1 += 1;
            }
            if resultQ2 == One {
                set 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 );

    }
}

Másolja és illessze be a teljes kódmintát az Azure Quantum-hoz készült Copilot kódablakba, állítsa a felvételszám diáját "1" értékre, majd kattintson a Futtatás gombra. Az eredmények a hisztogramban és az Eredmények mezőkben jelennek meg.

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

Mivel a qubiteket még nem módosították, megtartották a kezdeti értékeiket: az első qubit minden alkalommal, One a második pedig a értéket adja vissza Zero.

Ha a értékét értékre módosítjainitial, és újra futtatja a programot, megfigyelheti, hogy az első qubit is minden alkalommal visszaadZero.Zero

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

Qubit elhelyezése szuperpozícióban

Jelenleg a program qubitjei mind klasszikus állapotban vannak, azaz 1 vagy 0. Ezt azért tudja, mert a program a qubiteket egy ismert állapotba inicializálja, és nem adott hozzá semmilyen folyamatot a módosításukhoz. A qubitek összefonódása előtt az első qubitet szuperpozíciós állapotba helyezi, ahol a qubit mérése az idő ~50%-át, az One idő ~50%-át adja vissza Zero . Elméletileg a qubit úgy is felfogható, hogy egyenlő a vagy a mérésének ZeroOnevalószínűsége.

Ha egy qubitet szuperpozícióba szeretne helyezni, Q# adja meg az H, vagy Hadamard műveletet. Emlékezzen vissza a Xqubit inicializálásáról egy ismert állapotú eljárásra korábban, amely egy qubitet 0-ról 1-esre tükrözött (vagy fordítva); a H művelet félúton a vagy a azonos valószínűségű ZeroOneállapotba fordítja a qubitet. Méréskor a szuperpozícióban lévő qubitnek nagyjából egyenlő számú Zero és One eredményt kell visszaadnia.

Módosítsa a kódot a műveletben úgy TestBellState , hogy One alaphelyzetbe állítja a kezdeti értéket, és beszúr egy sort a H művelethez:

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

Most, amikor futtatja a programot, láthatja az első qubit eredményeit szuperpozícióban.

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

Minden alkalommal, amikor futtatja a programot, az első qubit eredményei kissé eltérőek lesznek, de közel 50% One és 50% Zerolesz, míg a második qubit eredményei folyamatosan megmaradnak Zero .

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

Az első qubit Zero inicializálása hasonló eredményeket ad vissza.

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

Megjegyzés

Az Azure QuantumHoz készült Copilot csúszkája mozgatásával és a felvételek számának növelésével láthatja, hogy a szuperpozíciós eredmények kismértékben eltérnek a felvételek eloszlásától.

Két qubit összefonódása

Ahogy korábban említettük, az összefonódott qubitek úgy vannak összekapcsolva, hogy nem írhatók le egymástól függetlenül. Vagyis bármilyen művelet is történik egy qubittel, az összefonódott qubittel is. Ez lehetővé teszi, hogy az egyik qubit eredményül kapott állapotát mérés nélkül is megismerje, csak a másik qubit állapotának mérésével. (Ez a példa két qubitet használ, de három vagy több qubit is összefonódhat.

Az összefonódás Q# engedélyezéséhez biztosítja a CNOT műveletet, amely a Controlled-NOT rövidítést jelenti. A művelet két qubiten való futtatásának eredménye a második qubit tükrözése, ha az első qubit .One

Közvetlenül a művelet után adja hozzá a CNOT műveletet a programhoz H . A teljes programnak így kell kinéznie:

namespace Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

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

    @EntryPoint()
    operation TestBellState() : (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 {
                set numOnesQ1 += 1;
            }
            if resultQ2 == One {
                set 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 );

    }
}

Most, amikor futtatja a programot, a következőhöz hasonlót kell látnia:

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

Figyelje meg, hogy az első qubit statisztikái nem változtak (még mindig ~50/50 esély van egy Zero vagy egy One mérés után), de a második qubit mérési eredményei mindig megegyeznek az első qubit mérésével, függetlenül attól, hogy hányszor futtatja a programot. A CNOT művelet összefonta a két qubitet, így bármi is történjen az egyikvel, a másikat is.

Előfeltételek

A kódminta fejlesztése és futtatása a helyi fejlesztési környezetben:

A Visual Studio Code legújabb verziója, vagy nyissa meg a VS Code-ot a weben.
Az Azure Quantum Development Kit bővítmény legújabb verziója. A telepítés részleteiért lásd : A modern QDK telepítése a VS Code-on.

Új Q# fájl létrehozása

Nyissa meg a Visual Studio Code-ot, és válassza az Új szövegfájl fájlja > lehetőséget egy új fájl létrehozásához.
Mentse a fájlt CreateBellStates.qs néven. Ez a fájl tartalmazza a Q# program kódját.

Qubit inicializálása ismert állapotba

Az első lépés egy Q# olyan művelet definiálása, amely egy qubitet egy ismert állapotba inicializál. Ez meghívható úgy, hogy egy qubitet klasszikus állapotra állítson be, ami azt jelenti, hogy vagy az idő 100%-át adja vissza Zero , vagy az idő 100%-át adja vissza One . Zero és One olyan Q# értékek, amelyek egy qubit mérésének csak két lehetséges eredményét felelnek meg.

Nyissa meg CreateBellStates.qs és másolja ki a következő kódot:

   namespace Bell {
       open Microsoft.Quantum.Intrinsic;
       open Microsoft.Quantum.Canon;

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

A példakód két standard műveletet mutat be, a és Xa-t, M amelyek átalakítják a qubit állapotát.

A SetQubitState művelet:

Két paramétert vesz fel: egy nevű típustResult, amely a qubit kívánt állapotát jelöli (Zero vagy One), és egy típustQubit.desired
Egy olyan mérési műveletet hajt végre, Mamely a qubit (Zero vagy One) állapotát méri, és összehasonlítja az eredményt a megadott desiredértékkel.
Ha a mérés nem egyezik meg az összehasonlított értékkel, egy műveletet futtat X , amely a qubit állapotát oda fordítja, ahol a mérés valószínűségei visszaállnak Zero , és One vissza lesznek fordítva. Így SetQubitState mindig a cél qubitet a kívánt állapotba helyezi.

Tesztművelet írása a Bell állapot teszteléséhez

Adja hozzá a következő műveletet a CreateBellStates.qs fájlhoz a SetQubitState művelet után:

operation TestBellState() : (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 {
            set numOnesQ1 += 1;
        }
        if resultQ2 == One {
            set 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 );

}

A kódban a és initial a count változó a és One a értékre 1000 van állítva. Ez inicializálja az első qubitet, One és minden qubitet 1000-szer mér.

A TestBellStateművelet:

Két paramétert vesz igénybe: count, a mérések futtatásának számát, és initiala kívánt állapotot a qubit inicializálásához.
Meghívja az use utasítást két qubit inicializálásához.
Ciklusok iterációkhoz count . Minden hurokhoz
1. Meghívja SetQubitState a megadott initial érték beállítását az első qubiten.
2. A SetQubitState második qubit állapotra való beállításához hívja meg újra a metódust Zero .
3. A művelettel M méri az egyes qubiteket.
4. A visszaadott Onequbitek mérésének számát tárolja.
A hurok befejeződése után ismét meghívja SetQubitState a qubiteket egy ismert állapotba (Zero), hogy mások is lefoglalják a qubiteket egy ismert állapotban. Ez a use utasítás miatt szükséges.
Végül a függvény használatával Message egy üzenetet nyomtat ki a konzolra, mielőtt visszaadja az eredményeket.

A kód futtatása

Mielőtt továbblépne a szuperpozíció és az összefonódás eljárásaira, tesztelje a kódot addig a pontig, hogy lássa a qubitek inicializálását és mérését.

Ez a Q# fájlban úgy történik, hogy közvetlenül a futtatni kívánt művelet elé ad hozzá egy @EntryPoint() műveletet. Ebben az esetben például a TestBellState művelet.

Megjegyzés

A CreateBellStates.qs fájlnak így kell kinéznie:

namespace Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

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

    @EntryPoint()
    operation TestBellState() : (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 {
                set numOnesQ1 += 1;
            }
            if resultQ2 == One {
                set 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 );

    }
}

A program futtatása előtt a célprofilt Korlátlan értékre kell állítania. Válassza a Nézet –> Parancskatalógus lehetőséget, keresse meg a QIR-t, válassza Q#a : Az Azure Quantum QIR-célprofil beállítása lehetőséget, majd válassza a : korlátlan lehetőségetQ#.

Megjegyzés

Ha a célprofil nincs Korlátlan értékre állítva, hibaüzenet jelenik meg a program futtatásakor.
A program futtatásához válassza a Fájl futtatása Q# lehetőséget a jobb felső sarokban található lejátszás ikon legördülő listájából, kattintson a Futtatás elemre az alábbi @EntryPoint()parancsok listájából, vagy nyomja le a Ctrl+F5 billentyűkombinációt. A program az alapértelmezett szimulátor attribútumával @EntryPoint() megjelölt műveletet vagy függvényt futtatja.
A kimenet megjelenik a hibakeresési konzolon.
```
Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0
```
Mivel a qubiteket még nem módosították, megtartották a kezdeti értékeiket: az első qubit minden alkalommal, One a második pedig a értéket adja vissza Zero.
Ha a értékét értékre módosítjainitial, és újra futtatja a programot, megfigyelheti, hogy az első qubit is minden alkalommal visszaadZero.Zero
```
Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0
```

Tipp

Ne felejtse el menteni a fájlt minden alkalommal, amikor módosítást vezet be a kódban, mielőtt újra futtatja.

Qubit elhelyezése szuperpozícióban

Jelenleg a program qubitjei mind klasszikus állapotban vannak, azaz 1 vagy 0. Ezt azért tudja, mert a program a qubiteket egy ismert állapotba inicializálja, és nem adott hozzá semmilyen folyamatot a módosításukhoz. A qubitek összefonódása előtt az első qubitet szuperpozíciós állapotba helyezi, ahol a qubit mérése az idő 50%-át, az One idő 50%-át adja visszaZero. Elméletileg a qubit úgy is felfogható, mint a és Onea Zero közötti félúton.

Ha egy qubitet szuperpozícióba szeretne helyezni, Q# adja meg az H, vagy Hadamard műveletet. Emlékezzen vissza a Xqubit inicializálásáról egy korábbi ismert állapotú eljárásra, amely a qubitet a -ről Zero a -ra One fordította (vagy fordítva). A H művelet a qubitet félúton a vagy Oneazonos valószínűségű Zero állapotba fordítja. Méréskor a szuperpozícióban lévő qubitnek nagyjából egyenlő számú Zero és One eredményt kell visszaadnia.

Módosítsa a művelet kódját úgy TestBellState , hogy tartalmazza a H műveletet:

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

Most, amikor futtatja a programot, láthatja az első qubit eredményeit szuperpozícióban:

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

Minden alkalommal, amikor futtatja a programot, az első qubit eredményei kissé eltérőek lesznek, de közel 50% One és 50% Zerolesz, míg a második qubit eredményei folyamatosan megmaradnak Zero .
```
Q1 - Zeros: 510           
Q1 - Ones: 490
Q2 - Zeros: 1000
Q2 - Ones: 0
```

Az első qubit Zero inicializálása hasonló eredményeket ad vissza.

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

Két qubit összefonódása

Közvetlenül a művelet után adja hozzá a CNOT műveletet a programhoz H . A teljes programnak így kell kinéznie:

namespace Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

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

    @EntryPoint()
    operation TestBellState() : (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);

            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 {
                set numOnesQ1 += 1;
            }
            if resultQ2 == One {
                set 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

Az első qubit statisztikái nem változtak (50/50 esély Zero egy vagy egy One mérés után), de a második qubit mérési eredményei mindig megegyeznek az első qubit mérésével. A CNOT művelet összefonta a két qubitet, így bármi is történjen az egyikvel, a másikat is.

A frekvencia hisztogram ábrázolása

Vizualizáljuk a kvantumprogram többszöri futtatásából származó eredmények eloszlását. A gyakorisági hisztogram segít megjeleníteni ezeknek az eredményeknek a valószínűségi eloszlását.

Válassza a Nézet –> Parancskatalógus lehetőséget, vagy nyomja le a Ctrl+Shift+P billentyűkombinációt, és írja be a "hisztogram" kifejezést, amely megjeleníti a Q#: Fájl futtatása és a hisztogram megjelenítése lehetőséget. A hisztogramra az alábbi @EntryPoint()parancsok listájából is kattinthat. Ezzel a beállítással megnyithatja a Q# hisztogramablakot.
Adjon meg néhány felvételt a program végrehajtásához, például 100 lövést, és nyomja le az Enter billentyűt. A hisztogram megjelenik a Q# hisztogram ablakban.
A hisztogram minden sávja egy lehetséges eredménynek felel meg, magassága pedig azt jelzi, hogy hányszor figyelhető meg az eredmény. Ebben az esetben 50 különböző egyedi eredmény van. Vegye figyelembe, hogy minden eredménynél az első és a második qubit mérési eredményei mindig azonosak.

Tipp

A hisztogramot az egér görgetőkerekével vagy egy érintőpad kézmozdulattal nagyíthatja. Nagyításkor pásztázhatja a diagramot úgy, hogy görgetés közben lenyomja az "Alt" billentyűt.
Kattintson egy sávra az eredmény százalékos arányának megjelenítéséhez.
A beállítások megjelenítéséhez kattintson a bal felső beállítások ikonra . Megjelenítheti az első 10 találatot, az első 25 találatot vagy az összes találatot. Az eredményeket rendezheti magasról alacsonyra vagy alacsonyról magasra is.

Megjegyzés

A CreateBellStates.qs program nem engedélyezi a kvantumcsoport-vizualizációt, mert Unrestricted a célprofilok nem támogatják a kvantumcsoport-vizualizációt, ha a program egy érték összehasonlítását Result tartalmazza.

Következő lépések

További Q# oktatóanyagok:

A kvantum-véletlenszám-generátor bemutatja, hogyan írhat olyan Q# programot, amely véletlenszerű számokat generál a szuperpozícióban lévő qubitből.
A Grover keresési algoritmusa bemutatja, hogyan írhat olyan Q# programot, amely a Grover keresési algoritmusát használja.
A Quantum Fourier Transform azt vizsgálja, hogyan írhat olyan Q# programot, amely közvetlenül kezeli az adott qubiteket.
A Quantum Katas öngyors oktatóanyagok és programozási gyakorlatok, amelyek célja a kvantum-számítástechnika elemeinek egyidejű Q# tanítása.

Oktatóanyag: A kvantum-összefonódás megismerése a következővel: Q#

Előfeltételek

Qubit inicializálása ismert állapotba

Tesztművelet írása a Bell állapot teszteléséhez

A kód futtatása a Copilot for Azure Quantumban

Qubit elhelyezése szuperpozícióban

Két qubit összefonódása

Előfeltételek

Új Q# fájl létrehozása

Qubit inicializálása ismert állapotba

Tesztművelet írása a Bell állapot teszteléséhez

A kód futtatása

Qubit elhelyezése szuperpozícióban

Két qubit összefonódása

A frekvencia hisztogram ábrázolása

Következő lépések

Visszajelzés

Visszajelzés

További források