Megosztás a következőn keresztül:

Oktatóanyag: A kvantum-összefonódás felfedezése Q#

  • Cikk

Ebben az oktatóanyagban egy Q# olyan programot ír, 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, megtanulhatja, hogyan lehet a qubiteken Q# működni az állapotuk megváltoztatásához, és bemutatja a szuperpozíció és az összefonódás hatásait. A program összeállításával bemutathatja a Q# qubitállapotokat, a műveleteket és a méréseket.

Az alábbiakban néhány fontos fogalmat érdemes megismerni a kezdés előtt:

  • Ha a klasszikus bitek egyetlen bináris értéket, például 0-t vagy 1-et tartanak, 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ése egy bizonyos valószínűségű bináris eredményt hoz létre, és szuperpozícióból módosítja a qubit állapotát.
  • Több qubit is összefonódhat, így egymástól függetlenül nem írhatók le. Vagyis bármi is történik az egyik qubit egy összefonódott párban, az a másik qubitel is megtörténik.

Az oktatóanyag segítségével megtanulhatja a következőket:

  • Hozzon létre Q# műveleteket a qubit kívánt állapotba való inicializálásához.
  • Helyezzen egy qubitet szuperpozícióba.
  • Fonjon össze egy pár qubitet.
  • 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 az Azure Quantum-webhely egyedi funkcióját, az Azure Quantum-ot. 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-ban Q#egy kattintással, és kérdéseket tehet fel a Copilotnak a kvantum-számítástechnikával kapcsolatban.

Előfeltételek

A kódmintát az Azure Quantum Copilot-ban való futtatásához a következőkre van szüksége:

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

A Copilotról további információt az Azure Quantum felfedezése című témakörben talál.

Qubit inicializálása ismert állapotba

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

Nyissa meg az Azure Quantum Copilotját, és másolja a következő kódot a kódszerkesztő ablakába. Még ne válassza a Futtatás lehetőséget; a kódot majd az oktatóanyag későbbi részében fogja futtatni.

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

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

A példakód két szabványos műveletet mutat be, M amelyek Xátalakítják a qubit állapotát.

A SetQubitState művelet:

  1. Két paramétert vesz fel: egy névvel ellátott típustResult, amely a qubit kívánt állapotát jelöli (desired vagy Zero), és egy típustOne.Qubit
  2. Olyan mérési műveletet hajt végre, amely méri a qubit (M vagy Zero) állapotát, Oneés összehasonlítja az eredményt a megadott desiredértékkel.
  3. Ha a mérés nem egyezik 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 visszatérnek Zero , és One fordítottak lesznek. Így SetQubitState mindig a kívánt állapotba helyezi a cél qubitet.

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

Ezután a művelet hatásának SetQubitState bemutatásához hozzon létre egy másik műveletet.Main Ez a művelet két qubitet foglal le, meghívja SetQubitState az első qubitet egy ismert állapotra, majd mé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 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 );
}

A kódban a változók és a count változók initial értéke és 1000One értéke. Ez inicializálja az első qubitet, One és 1000-szer méri az egyes qubiteket.

A Mainművelet:

  1. Beállítja a számláló és a kezdeti qubit állapot változóit.
  2. Meghívja az use utasítást két qubit inicializálására.
  3. Ciklusok iterációkhoz count . Minden ciklushoz
    1. Az első qubit megadott értékének megadására SetQubitState irányuló hívásokinitial.
    2. Ismét meghívja SetQubitState a második qubit állapotát Zero .
    3. A művelettel M méri az egyes qubiteket.
    4. A visszaadott Onequbitek számát tárolja.
  4. A ciklus befejeződése után ismét meghívja SetQubitState a qubiteket egy ismert állapotra (Zero), hogy mások is lefoglalják a qubiteket egy ismert állapotban. Az utasítás alaphelyzetbe állítására use van szükség.
  5. Végül a függvény használatával nyomtatja ki az Message eredményeket a Copilot kimeneti ablakaiba, mielőtt visszaadja az eredményeket.

A kód futtatása az Azure Quantum Copilotjában

Mielőtt továbblépne a szuperpozíciós és összefonódási eljárásokra, addig tesztelheti a kódot, 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 Copilot fordítójának Q# tudnia kell, hol kezdje a programot. Mivel nincs megadva névtér, a fordító felismeri az alapértelmezett belépési pontot műveletként Main . További információ: Projektek és implicit névterek.

A Q# programnak eddig a pontig a következőképpen kell kinéznie:

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

}

Másolja és illessze be a teljes kódmintát az Copilot for Azure Quantum kódablakába, állítsa a csúszkát az "1" értékre, és válassza a Futtatáslehetőséget. 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 manipulálták, megtartották a kezdeti értékeket: az első qubit minden alkalommal visszatér One , a második qubit pedig visszaadja Zeroőket.

Ha módosítja initialZero a program értékét, és újra futtatja a programot, vegye figyelembe, hogy az első qubit is minden alkalommal visszatér Zero .

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

Tipp.

Válassza a Ctrl-Z billentyűkombinációt vagy > szerkesztése lehetőséget, és mentse a fájlt, amikor tesztmódosítást vezet be a kódon, mielőtt újra futtatja.

Qubit elhelyezése szuperpozícióba

Jelenleg a program qubitjei mind klasszikus állapotban vannak, vagyis 1 vagy 0. Ezt azért tudja, mert a program inicializálja a qubiteket egy ismert állapotba, é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 kell helyeznie, ahol a qubit mérése az idő ~50%-át, az Zero idő ~50%-át adja vissza One . Fogalmilag a qubitet úgy lehet elképzelni, hogy egyenlő a mérés valószínűsége, Zero vagy One.

A qubit szuperpozícióba Q# helyezéséhez adja meg a hadamard vagy hadamard Hműveletet. Emlékezzen vissza a Xqubit inicializálásáról egy korábban ismert állapotműveletre, amely 0-ról 1-re tükrözte a qubitet (vagy fordítva); a H művelet félúton megfordítja a qubitet egyenlő valószínűségű Zero vagy One. Méréskor a szuperpozícióban lévő qubitnek nagyjából azonos számú Zero és One eredményt kell visszaadnia.

Módosítsa a kódot a műveletben úgy Main , hogy One visszaá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 a szuperpozícióban.

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

Minden alkalommal, amikor futtatja a programot, az első qubit eredményei kissé eltérnek, de közel 50% One és 50% Zerolesz, míg a második qubit eredményei mindig 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

Feljegyzés

Az Azure Quantum 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 hogyan változnak kissé a felvételek eloszlásához képest.

Két qubit összefonódása

Ahogy korábban említettük, az összekapcsolt qubitek úgy vannak csatlakoztatva, hogy egymástól függetlenül nem írhatók le. Vagyis bármilyen művelet is történik egy qubittel, az összefonódott qubittel is. Ez lehetővé teszi az egyik qubit eredményül kapott állapotát mérés nélkül, 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 qubitet is össze lehet fonni).

Az összefonódás Q# engedélyezéséhez adja meg a műveletet, amely a CNOTControlled-NOT nevet 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 az 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:

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

    }

A program futtatásakor 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:

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

  1. Nyissa meg a Visual Studio Code-ot, és válassza a Fájl > új szövegfájlja lehetőséget egy új fájl létrehozásához.
  2. 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 inicializál egy qubitet egy ismert állapotba. Ez a művelet meghívható úgy, hogy egy qubitet klasszikus állapotra állítson be, ami azt jelenti, hogy az idő 100%-át adja vissza Zero , vagy az idő 100%-át adja vissza One . Zero és One olyan Q# értékek, amelyek a qubit mérésének csak két lehetséges eredményét jelölik.

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

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

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

A példakód két szabványos műveletet mutat be, M amelyek Xátalakítják a qubit állapotát.

A SetQubitState művelet:

  1. Két paramétert vesz fel: egy névvel ellátott típustResult, amely a qubit kívánt állapotát jelöli (desired vagy Zero), és egy típustOne.Qubit
  2. Olyan mérési műveletet hajt végre, amely méri a qubit (M vagy Zero) állapotát, Oneés összehasonlítja az eredményt a megadott desiredértékkel.
  3. Ha a mérés nem egyezik 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 visszatérnek Zero , és One fordítottak lesznek. Így SetQubitState mindig a kívánt állapotba helyezi a cél qubitet.

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

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

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

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

A kódban a változók és a count változók initial értéke és 1000One értéke. Ez a lépés inicializálja az első qubitet One , és 1000-szer méri az egyes qubiteket.

A Mainművelet:

  1. Két paramétert vesz fel: counta mérések futtatásának számát, valamint initiala qubit inicializálásához szükséges állapotot.
  2. Meghívja az use utasítást két qubit inicializálására.
  3. Ciklusok iterációkhoz count . Minden ciklushoz
    1. Az első qubit megadott értékének megadására SetQubitState irányuló hívásokinitial.
    2. Ismét meghívja SetQubitState a második qubit állapotát Zero .
    3. A művelettel M méri az egyes qubiteket.
    4. A visszaadott Onequbitek számát tárolja.
  4. A ciklus befejeződése után ismét meghívja SetQubitState a qubiteket egy ismert állapotra (Zero), hogy mások is lefoglalják a qubiteket egy ismert állapotban. A qubit alaphelyzetbe állítására az use utasításnak van szüksége.
  5. Végül a függvény használatával Message kinyomtat egy üzenetet a konzolra az eredmények visszaadása előtt.

A kód futtatása

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

A kód önálló programként való futtatásához a Q# fordítónak tudnia kell, hol kezdje a programot. Mivel nincs megadva névtér, a fordító felismeri az alapértelmezett belépési pontot műveletként Main . További információ: Projektek és implicit névterek.

  1. Az CreateBellStates.qs eddig a pontig létrehozott fájlnak a következőképpen kell kinéznie:

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

  2. A program futtatása előtt győződjön meg arról, hogy a célprofil korlátlan értékre van állítva. Válassza a Nézet –> Parancskatalógus lehetőséget, keresse meg a QIR-t, válassza Q# beállítása, majd válassza aQ# lehetőséget.

    Feljegyzés

    Ha a célprofil nincs korlátozva, hibaüzenet jelenik meg a program futtatásakor.

  3. A program futtatásához válassza Q# lehetőséget a lejátszás ikon jobb felső részén, válassza a Futtatás lehetőséget a művelet előtti parancsok listájából, vagy nyomja le a Main Ctrl+F5 billentyűkombinációt. A program az Main alapértelmezett szimulátoron futtatja a műveletet.

  4. 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 manipulálták, megtartották a kezdeti értékeket: az első qubit minden alkalommal visszatér One , a második qubit pedig visszaadja Zeroőket.

  5. Ha módosítja initialZero a program értékét, és újra futtatja a programot, vegye figyelembe, hogy az első qubit is minden alkalommal visszatér Zero .

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

Tipp.

Válassza a Ctrl-Z billentyűkombinációt vagy > szerkesztése lehetőséget, és mentse a fájlt, amikor tesztmódosítást vezet be a kódon, mielőtt újra futtatja.

Qubit elhelyezése szuperpozícióba

Jelenleg a program qubitjei mind klasszikus állapotban vannak, vagyis 1 vagy 0. Ezt azért tudja, mert a program inicializálja a qubiteket egy ismert állapotba, é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 és Zero az idő 50%-át adja visszaOne. Elméletileg a qubit úgy gondolható, hogy félúton a és Zeroa One .

A qubit szuperpozícióba Q# helyezéséhez adja meg a hadamard vagy hadamard Hműveletet. Emlékezzen vissza a műveletre a X qubit inicializálásától egy korábbi ismert állapotműveletigOne Méréskor a szuperpozícióban lévő qubitnek nagyjából azonos számú Zero és One eredményt kell visszaadnia.

  1. Módosítsa a művelet kódját úgy, hogy az Main 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); 
        ...

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

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

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

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

  4. 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

Ahogy korábban említettük, az összekapcsolt qubitek úgy vannak csatlakoztatva, hogy egymástól függetlenül nem írhatók le. Vagyis bármilyen művelet is történik egy qubittel, az összefonódott qubittel is. Ez lehetővé teszi az egyik qubit eredményül kapott állapotát mérés nélkül, 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 qubitet is össze lehet fonni).

Az összefonódás Q# engedélyezéséhez adja meg a műveletet, amely a CNOTControlled-NOT nevet 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 az One.

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

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

Az első qubit statisztikái nem változtak (50/50 esély 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. A CNOT művelet összefonta a két qubitet, hogy bármi is történjen az egyikvel, a másik történjen.

A frekvencia hisztogram ábrázolása

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

  1. 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 Q#"hisztogram" kifejezést, amely a következőt jeleníti meg: Fájl futtatása és hisztogram megjelenítése lehetőség. Az előző parancsok listájából is kiválaszthatja Main. Ezzel a beállítással megnyithatja a Q# hisztogramablakot.

  2. Adjon meg több lövést 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.

  3. A hisztogram minden sávja egy lehetséges eredménynek felel meg, magassága pedig az eredmény megfigyelésének hányszorosát jelöli. Ebben az esetben 50 különböző egyedi eredmény érhető el. Vegye figyelembe, hogy minden eredménynél az első és a második qubit mérési eredményei mindig azonosak.

    Képernyőkép a Q# Visual Studio Code hisztogramablakáról.

    Tipp.

    A hisztogramot az egér görgetőkerekével vagy egy trackpad-kézmozdulattal nagyíthatja. Nagyításkor görgetés közben az Alt billentyűt lenyomva pásztázhatja a diagramot.

  4. Jelöljön ki egy sávot az eredmény százalékos arányának megjelenítéséhez.

  5. A beállítások megjelenítéséhez válassza a bal felső beállítások ikont . Megjelenítheti az első 10 találatot, a 25 legjobb eredményt vagy az összes találatot. Az eredményeket a magasról az alacsonyra vagy az alacsonyról a magasra is rendezheti.

    Képernyőkép a Q# Visual Studio Code hisztogramablakáról, amelyen a beállítások megjelenítése látható.

Kapcsolódó tartalom

További Q# oktatóanyagok:

  • 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 és Q# a programozás elemeinek egyidejű tanítása.