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

V tomto kurzu napíšete Q# program, který připraví dva qubity v určitém kvantovém stavu, pracuje na qubitech, aby je propletl mezi sebou, a provede měření, které demonstruje účinky superpozice a propletení. Sestavíte program Q# kus po kusu, abyste představili stavy qubitů, kvantové operace a měření.

Než začnete, projděte si následující koncepty kvantových výpočtů:

Klasické bity obsahují jednu binární hodnotu, například 0 nebo 1, ale qubity můžou být ve superpozici dvou stavů, 0 a 1. Každý možný stav qubitu je popsán sadou amplitud pravděpodobnosti.
Když změříte stav qubitu, vždy získáte buď 0, nebo 1. Pravděpodobnost každého výsledku je určena amplitudami pravděpodobnosti, které definují stav superpozice při měření.
Více qubitů může být propletené tak, že je nemůžete popsat nezávisle na sobě. Když změříte jeden qubit v propleteném páru, získáte také informace o druhém qubitu bez měření.

V tomto návodu se naučíte, jak:

Vytvořte Q# operace pro inicializaci qubitu do požadovaného stavu.
Vložte qubit do stavu superpozice.
Proplette pár qubitů.
Změřte qubit a sledujte výsledky.

Tip

Pokud chcete urychlit svou cestu k kvantovému computingu, podívejte se na kód pomocí Azure Quantum, který je jedinečnou funkcí webu Microsoft 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 otázky copilotu týkající se kvantového computingu.

Požadavky

Pokud chcete spustit ukázku kódu pomocí Copilotu pro Azure Quantum, musíte mít e-mailový účet Microsoft (MSA).

Další informace o Copilotu pro Azure Quantum viz Prozkoumání Azure Quantum.

Inicializace qubitu do známého stavu

Prvním krokem je definování Q# operace, která inicializuje qubit do požadovaného klasického stavu, buď 0, nebo 1. Tato operace měří qubit v obecném kvantovém stavu, což vrací hodnotu typu Q#Result, buď Zero nebo One. Pokud se výsledek měření liší od požadovaného stavu, operace překlopí stav tak, aby operace vrátila požadovaný stav 100% času.

Otevřete Copilot pro Azure Quantum, vymažte výchozí kód a zkopírujte následující kód do okna editoru kódu. Tento kód nejde spustit sám, protože zatím není úplný Q# program.

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

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

Tady je podrobný popis SetQubitState fungování operace:

Přebírá dva parametry: Result parametr typu s názvem desired , který představuje požadovaný stav qubitu, který má být in (Zero nebo One) a Qubit parametr typu.
Provede měrnou operaci, Mkterá měří stav qubitu (Zero nebo One) a porovná výsledek s hodnotou, pro kterou předáte desired.
Pokud výsledek měření neodpovídá hodnotě desired, pak se použije operace X na qubit. Tato operace změní stav qubitu tak, aby pravděpodobnosti měření pro Zero a One byly obráceny.

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

Chcete-li volat SetQubitState operaci v Q# programu, vytvořte další operaci nazvanou Main. Tato operace přidělí dva qubity, volání SetQubitState pro nastavení prvního qubitu do známého stavu a pak měří qubity, aby se zobrazily výsledky.

Zkopírujte následující kód do okna kódového editoru po 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 provede následující:

Nastaví proměnné pro počet snímků (count) a počáteční stav qubitu (One).
Zavolá příkaz use , který inicializuje dva qubity.
Opakuje se countkrát u experimentu.
Ve smyčce volá SetQubitState, což nastaví zadanou initial hodnotu na prvním qubitu, a pak znovu volá SetQubitState, aby nastavil druhý qubit do Zero stavu.
Ve smyčce použije M operaci k měření každého qubitu a pak uloží počet měření pro každý qubit, který vrací One.
Po dokončení smyčky zavolá SetQubitState znovu a resetuje qubity do známého stavu (Zero). Musíte resetovat qubity, které přidělíte pomocí use příkazu.
Message Zavolá funkci k vytištění výsledků v okně výstupu.

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

Než napíšete kód pro superpozici a propletení, otestujte aktuální program, abyste viděli inicializaci a měření qubitů.

Pokud chcete kód spustit jako samostatný program, Q# kompilátor v Copilotu musí vědět, kde program spustit. Protože jste nezadali 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ů.

Váš Q# program teď vypadá takto:

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 copilotu pro kód Azure Quantum , nastavte posuvník pro počet snímků na 1 a pak zvolte 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

Program zatím neupravuje stavy qubitu, takže měření prvního qubitu vždy vrátí Onea druhý qubit vždy vrátí Zero.

Pokud změníte hodnotu initial na Zero a spustíte program znovu, pak první qubit také vždy vrátí Zero.

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

Vložení qubitu do stavu superpozice

V současné době jsou qubity ve vašem programu v klasickém stavu, a to buď 1, nebo 0, stejně jako bity v běžném počítači. Chcete-li propletit qubity, musíte nejprve umístit jeden z qubitů do stejného stavu superpozice. Měření qubitu v rovnoměrné superpozici má 50% šanci vrátit Zero a 50% šanci vrátit One.

Pokud chcete qubit vložit do stavu superpozice, použijte Q#H, nebo Hadamardovu operaci. Operace H převede qubit, který je v čistém stavu Zero nebo One na stav superpozice mezi Zero a One.

Upravte kód v Main operaci. Obnovte počáteční hodnotu One a vložte řádek 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); 
        ...

Spusťte program znovu. Protože první qubit je při měření ve stejné superpozici, blíží se výsledku 50/50 pro Zero a One. Výstup například vypadá nějak takto:

Q1 - Zeros: 523
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 jsou stále vždy Zero.

Inicializujte první qubit na Zero místo na One a spusťte program znovu. Podobné výsledky získáte, protože H operace změní čistý Zero stav i čistý One stav na stejný stav superpozice.

Poznámka:

Pokud chcete zjistit, jak se výsledky superpozice liší podle distribuce snímků, přesuňte posuvník v Copilotu pro Azure Quantum a zvyšte počet snímků.

Propletení dvou qubitů

Propletené qubity korelují tak, že je nelze popsat nezávisle na sobě. Při měření stavu jednoho propleteného qubitu znáte také stav druhého qubitu bez měření. Tento kurz používá příklad se dvěma propletenými qubity, ale můžete také propletit tři nebo více qubitů.

Chcete-li vytvořit propletený stav, použijte operaci Q#CNOT, nebo Controlled-NOT. Když použijete CNOT na dva qubity, jeden qubit je řídicí qubit a druhý je cílový qubit. Pokud je Onestav řídicího qubitu , CNOT operace převrátí stav cílového qubitu. CNOT jinak s qubity nedělá nic.

CNOT Přidejte operaci do programu ihned po H operaci. Celý program vypadá takto:

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

Spusťte program a zobrazte výstup. Vaše výsledky se při každém spuštění programu velmi jemně liší.

Q1 - Zeros: 502
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

Statistika pro první qubit stále ukazuje přibližně 50% šanci měření obojího One a Zero, ale nyní výsledky měření pro druhý qubit nejsou vždy Zero. Každý qubit má stejný počet Zero výsledků a One výsledků. Výsledek měření druhého qubitu je vždy stejný jako výsledek prvního qubitu, protože dva qubity jsou propletené. Pokud je první qubit změřen jako Zero, pak musí být také propletený qubit jako Zero. Pokud je první qubit změřen jako One, pak musí být také propletený qubit One.

Požadavky

Pokud chcete vyvíjet a spouštět ukázku kódu v místním vývojovém prostředí, nainstalujte následující nástroje:

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

Vytvoření nového Q# souboru

V nástroji VS Code otevřete nabídku Soubor a zvolte Nový textový soubor a vytvořte nový soubor.
Uložte soubor jako CreateBellStates.qs. Tento soubor je místo, kde napíšete Q# kód pro svůj program.

Inicializace qubitu do známého stavu

Prvním krokem je definování Q# operace, která inicializuje qubit do požadovaného klasického stavu, buď 0, nebo 1. Tato operace měří qubit v obecném kvantovém stavu, který vrací hodnotu typu Q#Result, která může být buď Zero, nebo One. Pokud se výsledek měření liší od požadovaného stavu, operace překlopí stav tak, aby operace vrátila požadovaný stav 100% času.

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

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

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

Tady je podrobný popis SetQubitState fungování operace:

Přebírá dva parametry: Result parametr typu s názvem desired , který představuje požadovaný stav qubitu, který má být in (Zero nebo One) a Qubit parametr typu.
Provede měrnou operaci, Mkterá měří stav qubitu (Zero nebo One) a porovná výsledek s hodnotou, pro kterou předáte desired.
Pokud výsledek měření neodpovídá hodnotě desired, pak se na qubit použije operace X. Tato operace překlopí stav qubitu tak, aby se pravděpodobnosti měření pro Zero a One obrátily.

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

Pro volání operace SetQubitState ve vašem programu Q# vytvořte další operaci pojmenovanou Main. Tato operace přidělí dva qubity, volání SetQubitState pro nastavení prvního qubitu do známého stavu a pak měří 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 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 provede následující:

Nastaví proměnné pro počet snímků (count) a počáteční stav qubitu (One).
Zavolá příkaz use , který inicializuje dva qubity.
Opakuje experiment count krát.
Ve smyčce volá SetQubitState, která nastaví zadanou initial hodnotu na prvním qubitu, a poté znovu volá SetQubitState, aby nastavila druhý qubit do stavu Zero.
Ve smyčce použije M operaci k měření každého qubitu a pak uloží počet měření pro každý qubit, který vrací One.
Po dokončení smyčky volá SetQubitState znovu, aby resetovalo qubity do známého stavu (Zero). Musíte resetovat qubity, které přidělíte pomocí use příkazu.
Message Zavolá funkci pro tisk výsledků v konzole.

Spuštění kódu

Než napíšete kód pro superpozici a propletení, otestujte aktuální program, abyste viděli inicializaci a měření qubitů.

Ke spuštění kódu jako samostatného programu potřebuje kompilátor vědět, Q# kde program spustit. Protože jste nezadali 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ů.

Soubor CreateBellStates.qs teď vypadá takto:

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

Pokud chcete program spustit, zvolte příkaz Spustit z code lens, který je před Main operací, nebo zadejte Ctrl + F5. Program spustí operaci Main na 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

Program zatím neupravuje stavy qubitu, takže měření prvního qubitu vždy vrátí Onea druhý qubit vždy vrátí Zero.

Pokud změníte hodnotu initial na Zero a spustíte program znovu, pak první qubit také vždy vrátí Zero.

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

Vložení qubitu do stavu superpozice

V současné době jsou qubity ve vašem programu v klasickém stavu, a to buď 1, nebo 0, stejně jako bity v běžném počítači. Chcete-li propletit qubity, musíte nejprve umístit jeden z qubitů do stejného stavu superpozice. Měření qubitu v rovnovážném stavu superpozice má 50% šanci na vrácení Zero a 50% šanci na vrácení One.

Pokud chcete qubit vložit do stavu superpozice, použijte Q#Hoperaci , nebo Hadamard. Operace H převede qubit, který je v čistém stavu Zero nebo One, do stavu, který je napůl mezi Zero a One.

Upravte kód v Main operaci. Obnovte počáteční hodnotu One a vložte řádek 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); 
        ...

Spusťte program znovu. Protože první qubit je při měření ve stejné superpozici, blíží se výsledku 50/50 pro Zero a One. Výstup například vypadá nějak takto:

Q1 - Zeros: 523
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 jsou stále vždy Zero.

Inicializujte první qubit na Zero místo One a znovu spusťte program. Podobné výsledky získáte, protože H operace změní čistý Zero stav i čistý One stav na stejný stav superpozice.

Propletení dvou qubitů

Chcete-li vytvořit propletený stav, použijte Q#CNOToperaci , nebo Controlled-NOT. Když použijete CNOT na dva qubity, jeden z nich je řídicí a druhý cílový. Pokud je Onestav řídicího qubitu , CNOT operace převrátí stav cílového qubitu. CNOT Jinak nic nedělá s qubity.

CNOT Přidejte operaci do programu ihned po H operaci. Celý program vypadá takto:

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

Spusťte program a zobrazte výstup. Vaše výsledky se při každém spuštění programu velmi mírně liší.

Q1 - Zeros: 502
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

Statistika prvního qubitu stále ukazuje přibližně 50% šanci měřit jak One, tak Zero, ale výsledky měření pro druhý qubit už nejsou vždy Zero. Každý qubit má stejný počet Zero výsledků a One výsledků. Výsledek měření druhého qubitu je vždy stejný jako výsledek prvního qubitu, protože dva qubity jsou propletené. Pokud je první qubit změřen jako Zero, pak musí být také provázaný qubit Zero. Pokud je první qubit změřen jako One, pak bude také propletený qubit One.

Vykreslete četnostní histogram

Pokud chcete vykreslit histogram četnosti, který zobrazuje rozdělení výsledků při spuštění programu několikrát, proveďte následující kroky:

Otevřete soubor CreateBellStates.qs v editoru VS Code.
Otevřete nabídku Zobrazení a zvolte Paleta příkazů.
Zadáním histogramu otevřete QDK: Spusťte soubor a zobrazte možnost histogramu . Nebo zvolte příkaz Histogram z možnosti Main Code Lens, která předchází operaci. Pak zadejte počet snímků (například 100). Histogram Q# se otevře na nové kartě.

Každý sloupec v histogramu odpovídá možnému výsledku, když se propletený obvod spustí 1000krát. Výška pruhu představuje počet výskytů výsledku. Například následující histogram ukazuje rozdělení s 50 jedinečnými výsledky. Všimněte si, že pro každý výsledek jsou výsledky měření pro první a druhý qubit vždy stejné.

Tip

Pokud chcete histogram přiblížit, použijte kolečko myši nebo gesto trackpadu. Pokud chcete graf posunout při přiblížení, podržte při posouvání klávesu Alt .
Výběrem pruhu zobrazíte procento celkových snímků, které tento výsledek vytvořily.
Výběrem ikony nastavení v levém horním rohu zobrazíte možnosti vizualizace.
Spusťte kód znovu, tentokrát ale s 1000 pokusy. S rostoucím počtem snímků se rozdělení výsledků blíží normálnímu rozdělení.

Prozkoumejte další Q# kurzy:

Groverův vyhledávací algoritmus ukazuje, jak napsat Q# program, který používá Groverův vyhledávací algoritmus.
Quantum Fourier Transform zkoumá, jak napsat Q# program, který přímo řeší konkrétní qubity.
Kvantové katy jsou sebevzdělávací tutoriály a programovací cvičení, která učí prvky kvantového počítání a Q# programování současně.

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-12-03

Sdílet prostřednictvím

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

Požadavky

Inicializace qubitu do známého stavu

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

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

Vložení qubitu do stavu superpozice

Propletení dvou qubitů

Požadavky

Vytvoření nového Q# souboru

Inicializace qubitu do známého stavu

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

Spuštění kódu

Vložení qubitu do stavu superpozice

Propletení dvou qubitů

Vykreslete četnostní histogram

Související obsah

Váš názor

Další materiály