Sdílet prostřednictvím

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

  • Článek

V tomto kurzu napíšete 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í. Sestavíte program Q# kus po kusu, abyste představili stavy, operace a měření qubitu.

Tady je několik klíčových konceptů, které je potřeba pochopit před tím, 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 z superpozice.
  • Více qubitů může být propletené tak, že je nelze popsat nezávisle na sobě. To znamená, že cokoli se stane s jedním qubitem v propleteném páru, stane se také s druhým qubitem.

V tomto kurzu se naučíte:

  • Vytvořte Q# operace pro inicializaci qubitu do požadovaného stavu.
  • Umístěte qubit do superpozice.
  • Propletení páru qubitů.
  • Změřte qubit a sledujte výsledky.

Tip

Pokud chcete urychlit cestu k kvantovému computingu, podívejte se na kód s Využitím Azure Quantum, která je jedinečnou funkcí webu Azure Quantum. Tady můžete spouštět předdefinované Q# ukázky nebo vlastní Q# programy, vygenerovat nový Q# kód z výzev, otevřít a spustit kód ve VS Code pro web jedním kliknutím a pokládat Copilot jakékoli otázky týkající se kvantového computingu.

Požadavky

Pokud chcete spustit vzorový kód 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. Tuto operaci lze volat k nastavení qubitu na klasický stav, což znamená, že při měření vrátí Zero buď 100 % času, nebo vrátí One 100 % času. Měření qubitu Q# vrátí typ Result, který může mít pouze hodnotu Zero nebo One.

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

import Microsoft.Quantum.Intrinsic.*;
import 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 a M X, které transformují stav qubitu.

Operace SetQubitState :

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

Napsání testovací operace pro otestování stavu zvonu

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

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

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 {
            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é initial nastavené na 1000 a One v uvedeném pořadí. Tím se inicializuje první qubit a One měří každý qubit 1000krát.

Operace Main:

  1. Nastaví proměnné pro čítač a počáteční stav qubitu.
  2. Zavolá příkaz use , který inicializuje dva qubity.
  3. Smyčky iterací count Pro každou smyčku
    1. Volání SetQubitState , která nastaví zadanou initial hodnotu na prvním qubitu.
    2. Voláním SetQubitState znovu nastavíte druhý qubit do Zero stavu.
    3. M Použije operaci k měření jednotlivých qubitů.
    4. Ukládá počet měření pro každý qubit, který vrací One.
  4. Po dokončení smyčky se znovu zavolá SetQubitState k resetování qubitů do známého stavu (Zero), aby ostatní mohli přidělit qubity ve známém stavu. Příkaz vyžaduje use resetování.
  5. Nakonec pomocí Message funkce vytiskne výsledky 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 kód otestovat až do tohoto okamžiku, abyste viděli inicializaci a měření qubitů.

Aby bylo možné spustit kód jako samostatný program, Q# kompilátor v Copilotu musí vědět , kde program spustit. Vzhledem k tomu, že není zadán žádný obor názvů, kompilátor rozpozná jako operaci výchozí vstupní bod Main . Další informace naleznete v tématu Projekty a implicitní obory názvů.

Až do tohoto okamžiku by váš Q# program měl vypadat takto:

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 {
            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í vzorový kód do okna copilotu pro kód Azure Quantum , 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, zachovají si počáteční hodnoty: první qubit se 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 vidět, že první qubit se Zero vrátí také pokaždé.

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

Tip

Vyberte Ctrl-Z nebo Upravit > zpět a soubor uložte pokaždé, když do kódu před opětovným spuštěním znovu zavedete testovací změnu.

Vložení qubitu do superpozice

V současné době jsou qubity v programu všechny v klasickém stavu, tj. jsou buď 1, nebo 0. Víte to, protože program inicializuje qubity do známého stavu a nepřidali jste žádné procesy pro manipulaci s nimi. Před propletení qubitů vložíte první qubit do stavu superpozice, kde měření qubitu vrátí Zero ~50 % času a One ~50 % času. Qubit lze koncepčně považovat za stejnou pravděpodobnost měření nebo Zero One.

Chcete-li umístit qubit do superpozice, Q# poskytuje Hoperaci , nebo Hadamard. Vzpomeňte si, že operace z inicializace qubitu do známé procedury stavu dříve překlopila qubit z 0 na 1 (nebo naopak), H operace překlopí qubit na polovinu stavu se stejnými pravděpodobnostmi Zero nebo One.X Při měření by měl qubit v superpozici vrátit zhruba stejný počet Zero a One výsledky.

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

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 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 blízko 50 % One a 50 % Zero, zatímco výsledky druhého qubitu zůstanou Zero po celou dobu.

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

Inicializace prvního qubitu tak, aby Zero vrátila 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 vidět, jak se výsledky superpozice mírně liší nad rozdělením 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 se stane s jedním qubitem, stane se také propleteným qubitem. Díky tomu můžete zjistit výsledný stav jednoho qubitu, aniž byste ho změřili, a to pouhým měřením stavu druhého qubitu. (Tento příklad používá dva qubity, ale je také možné propletit tři nebo více qubitů).

Chcete-li povolit propletení, Q# poskytuje CNOT operace, což je zkratka pro Controlled-NOT. Výsledkem spuštění této operace na dvou qubitech je překlopit druhý qubit, pokud je Oneprvní qubit .

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

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 {
            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ď spustíte program, měl by se zobrazit něco takového:

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 přibližně 50/50 šance Zero na měření nebo One po měření), 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 cokoli se stane s jedním z nich, stane se druhé.

Požadavky

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

Vytvoření nového Q# souboru

  1. Otevřete Visual Studio Code a výběrem možnosti Soubor > nový textový soubor vytvořte nový soubor.
  2. 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. Tuto operaci lze volat k nastavení qubitu na klasický stav, což znamená, že vrátí Zero 100 % času nebo vrátí One 100 % času. Zero a One představují Q# pouze dva možné výsledky měření qubitu.

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

import Microsoft.Quantum.Intrinsic.*;
import 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 a M X, které transformují stav qubitu.

Operace SetQubitState :

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

Napsání testovací operace pro otestování stavu zvonu

Dále, chcete-li předvést účinek SetQubitState operace, vytvořte další operaci s názvem Main. Tato operace přidělí dva qubity, volání SetQubitState pro nastavení prvního qubitu do známého stavu a pak změří qubity, aby se zobrazily výsledky.

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

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 {
            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é initial nastavené na 1000 a One v uvedeném pořadí. Tento krok inicializuje první qubit a One měří každý qubit 1000krát.

Operace Main:

  1. Přebírá dva parametry: countpočet spuštění měření a initialpožadovaný stav inicializace qubitu.
  2. Zavolá příkaz use , který inicializuje dva qubity.
  3. Smyčky iterací count Pro každou smyčku
    1. Volání SetQubitState , která nastaví zadanou initial hodnotu na prvním qubitu.
    2. Voláním SetQubitState znovu nastavíte druhý qubit do Zero stavu.
    3. M Použije operaci k měření jednotlivých qubitů.
    4. Ukládá počet měření pro každý qubit, který vrací One.
  4. Po dokončení smyčky se znovu zavolá SetQubitState k resetování qubitů do známého stavu (Zero), aby ostatní mohli přidělit qubity ve známém stavu. Příkaz vyžaduje resetování qubitu use .
  5. 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 tohoto bodu, abyste viděli inicializaci a měření qubitů.

Aby mohl kód spustit jako samostatný program, kompilátor musí vědět, Q# kde program spustit. Vzhledem k tomu, že není zadán žádný obor názvů, kompilátor rozpozná jako operaci výchozí vstupní bod Main . Další informace naleznete v tématu Projekty a implicitní obory názvů.

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

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

  2. Před spuštěním programu se ujistěte, že je cílový profil nastavený na 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 Neomezený, při spuštění programu se zobrazí chyba.

  3. Pokud chcete program spustit, vyberte v rozevíracím seznamu Ikona přehrávání v pravém horním rohu možnost Spustit Q# soubor, v seznamu příkazů předcházejících operaci Main vyberte Spustit nebo stiskněte Kombinaci kláves Ctrl+F5. Program spustí Main operaci na výchozím simulátoru.

  4. 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, zachovají si počáteční hodnoty: první qubit se vrátí One pokaždé a druhý qubit vrátí Zero.

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

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

Tip

Vyberte Ctrl-Z nebo Upravit > zpět a soubor uložte pokaždé, když do kódu před opětovným spuštěním znovu zavedete testovací změnu.

Vložení qubitu do superpozice

V současné době jsou qubity v programu všechny v klasickém stavu, tj. jsou buď 1, nebo 0. Víte to, protože program inicializuje qubity do známého stavu a nepřidali jste žádné procesy pro manipulaci s nimi. Před propletení qubitů vložíte první qubit do stavu superpozice, kde měření qubitu vrátí Zero 50 % času a One 50 % času. Qubit lze koncepčně považovat za půl cesty mezi a Zero One.

Chcete-li umístit qubit do superpozice, Q# poskytuje Hoperaci , nebo Hadamard. Vzpomeňte si, že X operace z inicializace qubitu do známého stavu dříve, která překlopila qubit z Zero One do (nebo naopak), H operace překlopí qubit na polovinu stavu se stejnými pravděpodobnostmi Zero nebo One. Při měření by měl qubit v superpozici vrátit zhruba stejný počet Zero a One výsledky.

  1. Upravte kód v Main operaci tak, 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); 
        ...

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

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

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

  4. Inicializace prvního qubitu tak, aby Zero vrátila 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 se stane s jedním qubitem, stane se také propleteným qubitem. Díky tomu můžete zjistit výsledný stav jednoho qubitu, aniž byste ho změřili, a to pouhým měřením stavu druhého qubitu. (Tento příklad používá dva qubity, ale je také možné propletit tři nebo více qubitů).

Chcete-li povolit propletení, Q# poskytuje CNOT operace, což je zkratka pro Controlled-NOT. Výsledkem spuštění této operace na dvou qubitech je překlopit druhý qubit, pokud je Oneprvní qubit .

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

    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 {
            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
Result: "(502, 498, 502, 498)"

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

Vykreslení histogramu četnosti

Pojďme vizualizovat distribuci výsledků získaných z vícenásobného spuštění kvantového programu. Histogram četnosti pomáhá vizualizovat rozdělení pravděpodobnosti těchto výsledků.

  1. Vyberte Zobrazení –> 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 . Histogram můžete vybrat také ze seznamu příkazů předcházejících Main. Tuto možnost vyberte, pokud chcete otevřít okno histogramu Q# .

  2. Zadejte počet snímků pro spuštění programu, například 100 snímků, a stiskněte Enter. Histogram se zobrazí v okně histogramu Q# .

  3. Každý pruh v histogramu odpovídá možnému výsledku a jeho výška představuje počet pozorovaných výsledků. V tomto případě existuje 50 různých jedinečných výsledků. Všimněte si, že u každého výsledku jsou výsledky měření pro první a druhý qubit vždy stejné.

    Snímek obrazovky s oknem histogramu v editoru Q# Visual Studio Code

    Tip

    Histogram můžete přiblížit pomocí kolečka myši nebo gesta trackpadu. Při přiblížení můžete graf posouvat stisknutím klávesy Alt při posouvání.

  4. Výběrem pruhu zobrazíte procento tohoto výsledku.

  5. Výběrem ikony nastavení vlevo nahoře zobrazíte možnosti. Můžete zobrazit 10 nejlepších výsledků, prvních 25 výsledků nebo všechny výsledky. Výsledky můžete také seřadit od vysokých po nízké nebo nízké až vysoké.

    Snímek obrazovky s oknem histogramu v editoru Q# Visual Studio Code znázorňující, jak zobrazit nastavení

Související obsah

Prozkoumejte další Q# kurzy: