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

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. Zatím nevybírejte 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 MX, 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ě, proběhne X operace, která překlopí stav qubitu tak, že se pravděpodobnosti, že měření vrátí Zero a One, obrátí. Tímto způsobem SetQubitState vždy umístí cílový qubit do požadovaného stavu.

Napište testovací operaci pro otestování Bellova stavu

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.

Zkopírujte následující kód do okna editoru kódu, pod operaci 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 );
}

V kódu jsou count a initial proměnné nastaveny na 1000 a One v uvedeném pořadí. Tím se inicializuje první qubit na One a každý qubit se měří 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ždý prvek smyčky
   1. Volá SetQubitState, aby nastavilo zadanou hodnotu initial na prvním qubitu.
   2. Voláním SetQubitState znovu nastavíte druhý qubit do Zero stavu.
   3. Používá operaci M k měření každého qubitu.
   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. Resetování je vyžadováno příkazem use.
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 {
            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 );

}

Zkopírujte a vložte kompletní vzorový kód do okna kódu Copilot pro Azure Quantum, nastavte posuvník pro počet snímků na 1 a vyberte 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 znovu spustíte program, měli byste pozorovat, že se první qubit pokaždé vrací Zero.

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 ve 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 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. Koncepčně lze kvantový bit považovat za stav, ve kterém je stejná pravděpodobnost naměřit buď Zero nebo One.

Chcete-li umístit qubit do superpozice, Q# poskytuje operaci H, nebo Hadamard. Vzpomeňte si na operaci X z procedury Inicializace qubitu do známého stavu, která převrátila qubit z 0 na 1 (nebo naopak); operace H obrací qubit do poloviny do stavu s rovnoměrnou pravděpodobností Zero nebo One. Při měření by měl qubit v superpozici vrátit zhruba stejný počet výsledků typu Zero a One.

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 blíží se 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

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 jednomu qubitu, se rovněž stane vzájemně provázaný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 operaci CNOT, která značí 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 {
            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 );

    }

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í:

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

Vytvoření nového Q# souboru

1. Otevřete Visual Studio Code a vyberte Soubor > Nový textový soubor, abyste vytvořili 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 MX, 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á srovnávané hodnotě, spustí operaci X, která překlopí stav qubitu tak, že pravděpodobnosti, že měření vrátí Zero a One, jsou obrácené. Tímto způsobem SetQubitState vždy umístí cílový qubit do požadovaného stavu.

Napsat testovací operaci pro otestování Bellova stavu

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 CreateBellStates.qs operaci přidejte do SetQubitState 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 {
            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 );
}

V kódu jsou proměnné count a initial nastaveny na 1000 a One. Tento krok inicializuje první qubit na One a každý qubit měří 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 pro count iterací. Pro každou smyčku
   1. Volá se SetQubitState, aby se nastavila zadaná hodnota initial na prvním qubitu.
   2. Voláním SetQubitState znovu 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í 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 use vyžaduje resetování qubitu.
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 {
               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. Před spuštěním programu se ujistěte, že je cílový profil nastavený na Neomezený. Vyberte Zobrazit –> Paletu příkazů, vyhledejte QIR, vyberte Q#: Nastavit cílový profil Azure Quantum QIR a pak vyberte Q#: neomezeno.

   Poznámka:

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

3. Pro spuštění programu vyberte Spustit Q# Soubor z rozevíracího seznamu přehrávací ikony v pravém horním rohu, v seznamu příkazů předcházejících operaci vyberte Spustit, nebo stiskněte kombinaci kláves Ctrl+F5. Program spustí operaci Main 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 pozorovat, že první qubit se Zero vrátí také pokaždé.

   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, 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 něco mezi Zero a One.

Chcete-li umístit qubit do superpozice, Q# poskytuje operaci H, nebo Hadamard. Vzpomeňte si na operaci X z dřívější části Inicializace qubitu do známého stavu, která převrátila qubit z Zero na One (nebo naopak); operace H převrátí qubit do stavu, kde je pravděpodobnost Zero nebo One stejná. Při měření by měl qubit v superpozici vrátit zhruba stejný počet výsledků Zero a One.

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, která se stane s jedním qubitem, se stane také s provázaný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 operaci CNOT, což znamená 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 {
               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)"
   

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.

Vykreslete četnostní histogram

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 Zobrazit –> Paletu příkazů nebo stiskněte Ctrl+Shift+P a zadejte "histogram", což by mělo zobrazit možnost Q#: Spustit soubor a zobrazit histogram. Můžete také vybrat Histogram 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ě pro histogram 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é.

   

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