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

Článek
04/17/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 Q# stavu, naučíte se, jak s nimi pracovat, abyste změnili jejich stav, a předvedete účinky superpozice a propletení. Program vytváříte Q# po jednotlivých dílech, abyste mohli zavádět 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ář QDK, doporučujeme přejít na novou sadu Azure Quantum Development Kit (Moderní sada QDK), abyste mohli 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:

Pokud 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.
Několik qubitů je možné propletit tak, aby je nebylo možné popsat nezávisle na sobě. To znamená, že cokoli se stane s jedním qubitem v propleteném páru, se stane i druhému qubitu.

V tomto kurzu se naučíte:

Vytvořte Q# operace pro inicializaci qubitu do požadovaného stavu.
Vlož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ód s využitím Azure Quantum, jedinečné funkce webu Azure Quantum. Tady můžete spustit předdefinované Q# ukázky nebo vlastní Q# programy, vygenerovat nový Q# kód z výzev, otevřít a spustit kód v editoru VS Code pro web jedním kliknutím a zeptat se společnosti Copilot na jakékoli otázky týkající se kvantových výpočtů.

Požadavky

Pokud chcete spustit ukázku kódu v copilotu pro Azure Quantum, potřebujete:

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

Další informace o službě Copilot 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 měření vrátí Zero buď 100 % času, nebo vrátí One 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. Ještě neklikejte 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 (Zero nebo One) a typ Qubit.
Provede operaci měření , Mkterá měří 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 vrátí Zero pravděpodobnosti měření a One vrátí se zpět. Tímto způsobem SetQubitState vždy umístí cílový qubit do požadovaného stavu.

Zápis testovací operace k otestování stavu bellu

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 , 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 a One každý qubit měří 1000krát.

Operace TestBellState:

Nastaví proměnné pro čítač a počáteční stav qubitu.
use Zavolá příkaz pro inicializaci dvou qubitů.
Smyčky pro count iterace. Pro každou smyčku
1. Volání SetQubitState pro nastavení zadané initial hodnoty v prvním qubitu.
2. Znovu zavolá SetQubitState , aby se druhý qubit nastavil Zero do 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 znovu zavolá SetQubitState , aby se qubity resetují do známého stavu (Zero), aby ostatní mohli 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 superpozice a propletení, můžete až do tohoto okamžiku otestovat kód, abyste viděli inicializaci a měření qubitů.

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

Poznámka

@EntryPoint() se vyžaduje pouze pro samostatné Q# programy. Při spuštění Q# programu v Jupyter Notebooks nebo volání Q# programu ze souboru hostitele Pythonu není tento program povinný a pokud je součástí, 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 Copylot 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í Zero.

Pokud změníte hodnotu initial na Zero a spustíte program znovu, měli byste si všimnout, že se vždy vrátí Zero i 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, to znamená, že jsou buď 1, nebo 0. Ví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ů umístíte první qubit do stavu superpozice, kde měření qubitu vrátí Zero přibližně 50 % času a One ~50 % času. Koncepčně lze qubit považovat za stejný pravděpodobnost měření buď Zero nebo One.

Pokud chcete qubit umístit do superpozice, Q# poskytuje Hoperaci , nebo Hadamard. X Vzpomeňte si dříve na operaci Inicializace qubitu do známého stavu, která překlopila qubit z 0 na 1 (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 vrátit přibližně 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 prvního qubitu 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 vrátí Zero podobné výsledky.

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

Poznámka

Přesunutím posuvníku v copilotu pro Azure Quantum a zvýšením počtu snímků můžete zjistit, jak se výsledky superpozice mírně liší v rozdělení snímků.

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 museli měřit, jen měřením stavu 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, která je zkratkou 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 );

    }
}

Při spuštění programu by se teď mělo zobrazit něco jako:

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

Všimněte si, že statistiky pro první qubit se nezměnily (stále existuje pravděpodobnost ZeroOne , že měření nebo po něm bude přibližně 50/50), ale výsledky měření pro druhý qubit jsou vždy stejné jako měření prvního qubitu bez ohledu na to, kolikrát program spustíte. Operace CNOT propletla dva qubity, takže ať se stane cokoliv 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.

Vytvoření 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

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.

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

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

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

Pokud chcete program spustit, vyberte Spustit Q# soubor z rozevíracího seznamu ikony přehrávání v pravém horním rohu nebo stiskněte Kombinaci kláves Ctrl+F5. Program spustí operaci nebo funkci označenou atributem @EntryPoint() ve výchozím simulátoru.

Poznámka

Pokud cílový profil není nastavený na hodnotu Unrestricted, zobrazí se při spuštění programu chyba.

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ů

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 = 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 . 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á Fourierová transformace zkoumá, jak napsat Q# program, který přímo řeší konkrétní qubity.
Kvantové katy jsou kurzy a programovací cvičení zaměřené na výuku prvků kvantového computingu a Q# programování najednou.

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

Požadavky

Inicializace qubitu do známého stavu

Zápis testovací operace k otestování stavu bellu

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

Vložení qubitu do superpozice

Propletení dvou qubitů

Požadavky

Vytvoření 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