Kurz: Prozkoumání kvantového propletení pomocí Q#

Článek
04/28/2024

V tomto kurzu se dozvíte, jak napsat Q# program, který manipuluje s qubity a měří je a demonstruje účinky superpozice a propletení. Připravíte dva qubity v konkrétním kvantovém stavu, naučíte se pracovat s qubity, Q# abyste změnili jejich stav, a předvedete účinky superpozice a propletení. Program sestavíte Q# po jednotlivých kusech tak, aby zaváděl stavy, operace a měření qubitů.

Poznámka

Sada Microsoft Quantum Development Kit (Classic QDK) už nebude po 30. červnu 2024 podporována. Pokud jste stávající vývojář sady QDK, doporučujeme přejít na novou sadu Azure Quantum Development Kit (Moderní QDK) a pokračovat ve vývoji kvantových řešení. Další informace najdete v tématu Migrace Q# kódu do moderní sady QDK.

Tady je několik klíčových konceptů, které je potřeba pochopit, než začnete:

Tam, kde klasické bity obsahují jednu binární hodnotu, například 0 nebo 1, může být stav qubitu v superpozici dvou kvantových stavů, 0 a 1. Každý možný kvantový stav má přidruženou amplitudu pravděpodobnosti.
Měření qubitu vytvoří binární výsledek s určitou pravděpodobností a změní stav qubitu ze superpozice.
Více qubitů může být propletené tak, aby je nebylo možné popsat nezávisle na sobě. To znamená, že co se stane s jedním qubitem v propleteném páru, se stane i druhému qubitu.

V tomto kurzu se naučíte:

Q# Create operací k inicializaci qubitu do požadovaného stavu.
Umístěte qubit do superpozice.
Propletení dvojice qubitů
Změřte qubit a sledujte výsledky.

Tip

Pokud chcete zrychlit cestu k kvantovému computingu, podívejte se na kódování pomocí Azure Quantum, jedinečné funkce webu Azure Quantum. Tady můžete spouštět integrované Q# ukázky nebo vlastní Q# programy, generovat nový Q# kód z výzev, otevírat a spouštět kód v editoru VS Code pro web jedním kliknutím a pokládat společnosti Copilot jakékoli otázky týkající se kvantových výpočtů.

Požadavky

Ke spuštění ukázky kódu v copilotu pro Azure Quantum potřebujete:

E-mailový účet Microsoft (MSA).

Další informace o copilotu najdete v tématu Prozkoumání Azure Quantum.

Inicializace qubitu do známého stavu

Prvním krokem je definování Q# operace, která inicializuje qubit do známého stavu. To se dá volat, aby se qubit nastavil do klasického stavu, což znamená, že při změření vrátí Zero buď 100 % času, nebo One vrátí 100 % času. Měření qubitu vrátí Q# typ Result, který může mít pouze hodnotu Zero nebo One.

Otevřete Copilot pro Azure Quantum a do okna editoru kódu zkopírujte následující kód. Neklikejte ještě na Spustit . kód spustíte později v tomto kurzu.

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

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

Příklad kódu představuje dvě standardní operace, M a X, které transformují stav qubitu.

Operace SetQubitState :

Přebírá dva parametry: typ Results názvem desired, který představuje požadovaný stav qubitu v (Zero nebo One) a typ Qubit.
Provede operaci měření , Mkterá změří stav qubitu (Zero nebo One) a porovná výsledek s hodnotou zadanou v desired.
Pokud měření neodpovídá porovnávané hodnotě, spustí X operaci, která překlopí stav qubitu na místo, kde se pravděpodobnosti měření vrací Zero a One jsou obrácené. Tímto způsobem SetQubitState vždy uvede cílový qubit do požadovaného stavu.

Zápis testovací operace pro otestování stavu zvonku

Pokud chcete předvést účinek SetQubitState operace, vytvořte další operaci s názvem TestBellState. Tato operace přidělí dva qubity, zavolá SetQubitState volání, aby se první qubit nastavil do známého stavu, a pak změří qubity, aby se zobrazily výsledky.

Do okna editoru kódu pod SetQubitState operací zkopírujte následující kód.

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

}

V kódu count jsou proměnné a initial nastaveny na 1000 hodnotu a One (v uvedeném pořadí). Tím se inicializuje první qubit do One a každý z nich se měří 1000krát.

Operace TestBellState:

Nastaví proměnné pro čítač a počáteční stav qubitu.
Zavolá příkaz k use inicializaci dvou qubitů.
Smyčky pro count iterace. Smyčka pro každou
1. Zavolá SetQubitState nastavení zadané initial hodnoty na prvním qubitu.
2. Opětovným voláním SetQubitState nastavíte druhý qubit do Zero stavu.
3. Použije operaci M k měření jednotlivých qubitů.
4. Ukládá počet měření pro každý qubit, který vrací Onehodnotu .
Po dokončení smyčky volání znovu obnoví SetQubitState qubity do známého stavu (Zero), aby mohli ostatní přidělit qubity ve známém stavu. To je provedeno příkazem use.
Nakonec použije Message funkci k tisku výsledků do výstupních oken Copilot před vrácením výsledků.

Spuštění kódu v copilotu pro Azure Quantum

Než přejdete k postupům pro superpozici a propletení, můžete až do této chvíle otestovat kód, abyste viděli inicializaci a měření qubitů.

Aby bylo možné spustit kód jako samostatný program, kompilátor v Copilotu potřebuje vědět, Q#kde má program spustit. To se provede v souboru přidáním objektu Q#@EntryPoint() přímo před operaci, kterou chcete spustit jako první. V tomto případě je TestBellState to například operace .

Poznámka

@EntryPoint() se vyžaduje pouze pro samostatné Q# programy. Při spouštění Q# programu v poznámkových blocích Jupyter nebo volání Q# programu z hostitelského souboru Pythonu to není povinné a pokud je součástí programu, vyvolá chybu.

@EntryPoint() Přidejte operaci bezprostředně před TestBellState a váš Q# program by teď měl vypadat takto:

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

    }
}

Zkopírujte a vložte kompletní ukázku kódu do okna Copilot for Azure Quantum code, nastavte snímek pro počet snímků na 1 a klikněte na Spustit. Výsledky se zobrazí v histogramu a v polích Výsledky .

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

Vzhledem k tomu, že qubity ještě nebyly manipulovány, zachovaly si své počáteční hodnoty: první qubit vrátí One pokaždé a druhý qubit vrátí Zerohodnotu .

Pokud změníte hodnotu initial na Zero a spustíte program znovu, měli byste zpozorovat, že se pokaždé vrátí Zero také první qubit.

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

Vložení qubitu do superpozice

V současné době jsou qubity v programu všechny v klasickém stavu, tedy buď 1, nebo 0. Znáte to proto, že program inicializuje qubity do známého stavu a vy jste nepřidali žádné procesy pro manipulaci s nimi. Před propletení qubitů převedete první qubit do stavu superpozice, kde měření qubitu vrátí Zero ~50 % času a One ~50 % času. Qubit si můžete představit jako qubit se stejnou pravděpodobností měření nebo ZeroOne.

Pokud chcete qubit umístit do superpozice, Q# poskytnete Hoperaci , nebo Hadamard. X Vzpomeňte si dříve na operaci Inicializace qubitu do známého stavu, která překlopí qubit z 0 na 1 (nebo naopak). H Operace převrátí qubit do poloviny do stavu se stejnou pravděpodobností Zero nebo One. Při měření by qubit v superpozici měl vracet zhruba stejný počet Zero výsledků a One .

Upravte kód v TestBellState operaci resetováním počáteční hodnoty na One a vložením řádku pro H operaci:

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

Když teď program spustíte, uvidíte výsledky prvního qubitu v superpozici.

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

Při každém spuštění programu se výsledky pro první qubit mírně liší, ale budou se blížit 50 % One a 50 % Zero, zatímco výsledky pro druhý qubit zůstanou Zero po celou dobu.

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

Inicializace prvního qubitu tak, aby vracela Zero podobné výsledky.

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

Poznámka

Posunutím posuvníku v copilotu pro Azure Quantum a zvýšením počtu snímků můžete vidět, jak se výsledky superpozice mírně liší v závislosti na rozdělení záběrů.

Propletení dvou qubitů

Jak už bylo zmíněno dříve, propletené qubity jsou propojené tak, že je nelze popsat nezávisle na sobě. To znamená, že jakákoli operace, která se stane s jedním qubitem, se také stane s propleteným qubitem. To vám umožní zjistit výsledný stav jednoho qubitu, aniž byste ho změřili, stačí změřit stav druhého qubitu. (V tomto příkladu se používají dva qubity, ale je také možné propletit tři nebo více qubitů).

Pro povolení propletení Q# poskytuje CNOT operaci , což je zkratka pro Controlled-NOT. Výsledkem spuštění této operace na dvou qubitech je překlopení druhého qubitu, pokud je Oneprvní qubit .

CNOT Přidejte operaci do programu ihned po operaciH. Celý program by měl vypadat takto:

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

    }
}

Když teď program spustíte, měli byste vidět něco jako:

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

Všimněte si, že statistika prvního qubitu se nezměnila (stále existuje pravděpodobnost Zero , že se jedná o hodnotu 50/50 po měření), One ale výsledky měření druhého qubitu jsou vždy stejné jako výsledky měření prvního qubitu, bez ohledu na to, kolikrát program spustíte. Operace CNOT propletla dva qubity, takže cokoliv se stane s jedním z nich, stane se s druhým.

Požadavky

Vývoj a spuštění ukázky kódu v místním vývojovém prostředí:

Nejnovější verze editoru Visual Studio Code nebo otevřete VS Code na webu.
Nejnovější verze rozšíření Azure Quantum Development Kit . Podrobnosti o instalaci najdete v tématu Instalace moderní sady QDK ve VS Code.

Create nového Q# souboru

Otevřete Visual Studio Code a vyberte Soubor > Nový textový soubor a vytvořte nový soubor.
Uložte soubor jako CreateBellStates.qs. Tento soubor bude obsahovat Q# kód pro váš program.

Inicializace qubitu do známého stavu

Prvním krokem je definování Q# operace, která inicializuje qubit do známého stavu. To lze volat, aby se qubit nastavil do klasického stavu, což znamená, že vrátí Zero buď 100 % času, nebo One vrátí 100 % času. Zero a One jsou Q# hodnoty, které představují pouze dva možné výsledky měření qubitu.

Otevřete CreateBellStates.qs a zkopírujte následující kód:

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

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

Příklad kódu představuje dvě standardní operace, M a X, které transformují stav qubitu.

Operace SetQubitState :

Přebírá dva parametry: typ Results názvem desired, který představuje požadovaný stav qubitu v (Zero nebo One) a typ Qubit.
Provede operaci měření , Mkterá změří stav qubitu (Zero nebo One) a porovná výsledek s hodnotou zadanou v desired.
Pokud měření neodpovídá porovnávané hodnotě, spustí X operaci, která překlopí stav qubitu na místo, kde se pravděpodobnosti měření vrací Zero a One jsou obrácené. Tímto způsobem SetQubitState vždy uvede cílový qubit do požadovaného stavu.

Zápis testovací operace pro otestování stavu zvonku

Za operaci přidejte do souboru CreateBellStates.qsSetQubitState následující operaci:

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

}

V kódu count jsou proměnné a initial nastaveny na 1000 hodnotu a One (v uvedeném pořadí). Tím se inicializuje první qubit do One a každý z nich se měří 1000krát.

Operace TestBellState:

Přijímá dva parametry: count, počet spuštění měření a initialpožadovaný stav inicializace qubitu.
Zavolá příkaz k use inicializaci dvou qubitů.
Smyčky pro count iterace. Smyčka pro každou
1. Zavolá SetQubitState nastavení zadané initial hodnoty na prvním qubitu.
2. Opětovným voláním SetQubitState nastavíte druhý qubit do Zero stavu.
3. Použije operaci M k měření jednotlivých qubitů.
4. Ukládá počet měření pro každý qubit, který vrací Onehodnotu .
Po dokončení smyčky volání znovu obnoví SetQubitState qubity do známého stavu (Zero), aby mohli ostatní přidělit qubity ve známém stavu. To je provedeno příkazem use.
Nakonec pomocí Message funkce vytiskne zprávu do konzoly před vrácením výsledků.

Spuštění kódu

Než přejdete k postupům superpozice a propletení, otestujte kód až do této chvíle, abyste viděli inicializaci a měření qubitů.

To se provede v souboru přidáním objektu Q#@EntryPoint() přímo před operaci, kterou chcete spustit. V tomto případě je TestBellState to například operace .

Poznámka

Soubor CreateBellStates.qs by teď měl vypadat takto:

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

    }
}

Před spuštěním programu je potřeba nastavit cílový profil na Hodnotu Neomezený. Vyberte Zobrazit –> Paleta příkazů, vyhledejte QIR, vyberte Q#: Nastavte cílový profil Azure Quantum QIR a pak vyberte Q#: neomezené.

Poznámka

Pokud cílový profil není nastavený na hodnotu Unrestricted, zobrazí se při spuštění programu chyba.
Pokud chcete program spustit, vyberte Spustit Q# soubor z rozevíracího seznamu ikony přehrávání v pravém horním rohu, v seznamu příkazů dole @EntryPoint()klikněte na Spustit nebo stiskněte Ctrl+F5. Program spustí operaci nebo funkci označenou atributem @EntryPoint() ve výchozím simulátoru.
Výstup se zobrazí v konzole ladění.
```
Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0
```
Vzhledem k tomu, že qubity ještě nebyly manipulovány, zachovaly si své počáteční hodnoty: první qubit vrátí One pokaždé a druhý qubit vrátí Zerohodnotu .
Pokud změníte hodnotu initial na Zero a spustíte program znovu, měli byste zpozorovat, že se pokaždé vrátí Zero také první qubit.
```
Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0
```

Tip

Připomeňme si, že soubor uložíte pokaždé, když před dalším spuštěním kódu zavednete nějakou změnu.

Vložení qubitu do superpozice

V současné době jsou qubity v programu všechny v klasickém stavu, tedy buď 1, nebo 0. Znáte to proto, že program inicializuje qubity do známého stavu a vy jste nepřidali žádné procesy pro manipulaci s nimi. Před propletení qubitů uvedete první qubit do stavu superpozice, kde měření qubitu vrátí Zero 50 % času a One 50 % času. Qubit si můžete představit jako polovinu Zero cesty mezi a One.

Pokud chcete qubit umístit do superpozice, Q# poskytnete Hoperaci , nebo Hadamard. X Vzpomeňte si dříve na operaci Inicializace qubitu do známého stavu, která překlopí qubit z Zero na One (nebo naopak). H Operace překlopí qubit do poloviny do stavu se stejnou pravděpodobností Zero nebo One. Při měření by qubit v superpozici měl vracet zhruba stejný počet Zero výsledků a One .

Upravte kód v operaci tak, TestBellState aby zahrnoval H operaci:

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

Když teď program spustíte, uvidíte výsledky prvního qubitu v superpozici:

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

Při každém spuštění programu se výsledky pro první qubit mírně liší, ale budou se blížit 50 % One a 50 % Zero, zatímco výsledky pro druhý qubit zůstanou Zero po celou dobu.
```
Q1 - Zeros: 510           
Q1 - Ones: 490
Q2 - Zeros: 1000
Q2 - Ones: 0
```

Inicializace prvního qubitu tak, aby vracela Zero podobné výsledky.

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

Propletení dvou qubitů

CNOT Přidejte operaci do programu ihned po operaciH. Celý program by měl vypadat takto:

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

Statistika prvního qubitu se nezměnila (šance ZeroOne 50/50 na nebo po měření), ale výsledky měření pro druhý qubit jsou vždy stejné jako výsledky měření prvního qubitu. Operace CNOT propletla dva qubity, takže cokoliv se stane s jedním z nich, stane se s druhým.

Vykreslení histogramu frekvence

Pojďme si vizualizovat rozdělení výsledků získaných spuštěním kvantového programu několikrát. Histogram frekvence pomáhá vizualizovat rozdělení pravděpodobnosti těchto výsledků.

Vyberte Zobrazit –> Paleta příkazů nebo stiskněte Kombinaci kláves Ctrl+Shift+P a zadejte histogram, který by měl zobrazit Q#soubor : Spustit a zobrazit možnost histogramu . Můžete také kliknout na Histogram ze seznamu příkazů níže @EntryPoint(). Tuto možnost vyberte, Q# pokud chcete otevřít okno histogramu.
Zadejte několik snímků , které se mají spustit, například 100 snímků, a stiskněte Enter. Histogram se zobrazí v okně histogramu Q# .
Každý pruh v histogramu odpovídá možnému výsledku a jeho výška představuje počet pozorování výsledku. V tomto případě existuje 50 různých jedinečných výsledků. Všimněte si, že pro každý výsledek jsou výsledky měření pro první a druhý qubit vždy stejné.

Tip

Histogram můžete přiblížit pomocí kolečka myši nebo gesta trackpadu. Při přiblížení můžete graf posunovat stisknutím klávesy Alt při posouvání.
Kliknutím na pruh zobrazíte procento tohoto výsledku.
Kliknutím na ikonu nastavení vlevo nahoře zobrazíte možnosti. Můžete zobrazit 10 nejlepších výsledků, 25 nejlepších výsledků nebo všechny výsledky. Výsledky můžete také seřadit od vysokých po nízké nebo od nejnižších po vysoké.

Další kroky

Projděte si další Q# kurzy:

Kvantový generátor náhodných čísel ukazuje, jak napsat Q# program, který generuje náhodná čísla z qubitů v superpozici.
Groverův vyhledávací algoritmus ukazuje, jak napsat Q# program, který používá Groverův vyhledávací algoritmus.
Kvantová Fourierova transformace zkoumá, jak napsat Q# program, který přímo řeší konkrétní qubity.
Kvantové katy jsou kurzy a programovací cvičení s vlastním tempem zaměřené na výuku prvků kvantového computingu a Q# programování současně.

Kurz: Prozkoumání kvantového propletení pomocí Q#

Požadavky

Inicializace qubitu do známého stavu

Zápis testovací operace pro otestování stavu zvonku

Spuštění kódu v copilotu pro Azure Quantum

Vložení qubitu do superpozice

Propletení dvou qubitů

Požadavky

Create nového Q# souboru

Inicializace qubitu do známého stavu

Zápis testovací operace pro otestování stavu zvonku

Spuštění kódu

Vložení qubitu do superpozice

Propletení dvou qubitů

Vykreslení histogramu frekvence

Další kroky

Váš názor

Váš názor

Další materiály