Kurz: Prozkoumání kvantového propletení pomocí Q#
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
Result
s názvemdesired
, který představuje požadovaný stav qubitu (Zero
neboOne
) a typQubit
. - Provede operaci měření ,
M
která měří stav qubitu (Zero
neboOne
) a porovná výsledek s hodnotou zadanou vdesired
. - 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í aOne
vrátí se zpět. Tímto způsobemSetQubitState
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- Volání
SetQubitState
pro nastavení zadanéinitial
hodnoty v prvním qubitu. - Znovu zavolá
SetQubitState
, aby se druhý qubit nastavilZero
do stavu. - Použije operaci
M
k měření jednotlivých qubitů. - Ukládá počet měření pro každý qubit, který vrací
One
hodnotu .
- Volání
- 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říkazemuse
. - 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 H
operaci , 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 One
první 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 Zero
One
, ž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
Result
s názvemdesired
, který představuje požadovaný stav qubitu v (Zero
neboOne
) a typQubit
. - Provede operaci měření ,
M
která změří stav qubitu (Zero
neboOne
) a porovná výsledek s hodnotou zadanou vdesired
. - 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
aOne
jsou obrácené. Tímto způsobemSetQubitState
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.qs
SetQubitState
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í ainitial
požadovaný stav inicializace qubitu. - Zavolá příkaz k
use
inicializaci dvou qubitů. - Smyčky pro
count
iterace. Smyčka pro každou- Zavolá
SetQubitState
nastavení zadanéinitial
hodnoty na prvním qubitu. - Opětovným voláním
SetQubitState
nastavíte druhý qubit doZero
stavu. - Použije operaci
M
k měření jednotlivých qubitů. - Ukládá počet měření pro každý qubit, který vrací
One
hodnotu .
- Zavolá
- 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říkazemuse
. - 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í Zero
hodnotu .
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 H
operaci , 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 One
první 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 Zero
One
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.
Váš názor
https://aka.ms/ContentUserFeedback.
Připravujeme: V průběhu roku 2024 budeme postupně vyřazovat problémy z GitHub coby mechanismus zpětné vazby pro obsah a nahrazovat ho novým systémem zpětné vazby. Další informace naleznete v tématu:Odeslat a zobrazit názory pro