Samouczek: eksplorowanie splątania kwantowego za pomocą polecenia Q#
W tym samouczku pokazano, jak napisać Q# program, który manipuluje kubitami i mierzy je oraz demonstruje efekty superpozycji i splątania. Przygotowujesz dwa kubity w określonym stanie kwantowym, dowiesz się, jak działać na kubitach Q# , aby zmienić ich stan, i zademonstrować skutki superpozycji i splątania. Program jest kompilowany po kawałku, Q# aby wprowadzić stany, operacje i pomiary kubitu.
Uwaga
Zestaw Microsoft Quantum Development Kit (klasyczny zestaw QDK) nie będzie już obsługiwany po 30 czerwca 2024 r. Jeśli jesteś istniejącym deweloperem zestawu QDK, zalecamy przejście do nowego zestawu Azure Quantum Development Kit (nowoczesnego zestawu QDK), aby kontynuować opracowywanie rozwiązań kwantowych. Aby uzyskać więcej informacji, zobacz Migrowanie Q# kodu do nowoczesnego zestawu QDK.
Poniżej przedstawiono kilka kluczowych pojęć, które należy zrozumieć przed rozpoczęciem:
- Jeśli bity klasyczne przechowują pojedynczą wartość binarną, taką jak 0 lub 1, stan kubitu może znajdować się w superpozycji dwóch stanów kwantowych, 0 i 1. Każdy możliwy stan kwantowy ma skojarzona amplituda prawdopodobieństwa.
- Czynność pomiaru kubitu generuje wynik binarny z pewnym prawdopodobieństwem i zmienia stan kubitu z superpozycji.
- Wiele kubitów można splątać w taki sposób, że nie można ich opisać niezależnie od siebie. Oznacza to, że cokolwiek się dzieje z jednym kubitem w splątanej parze również dzieje się z drugim kubitem.
Z tego samouczka dowiesz się, jak wykonywać następujące czynności:
- Q# Twórca operacji inicjowania kubitu do żądanego stanu.
- Umieść kubit w superpozycji.
- Splątanie pary kubitów.
- Zmierz kubit i obserwuj wyniki.
Porada
Jeśli chcesz przyspieszyć podróż po obliczeniach kwantowych, zapoznaj się z kodem w usłudze Azure Quantum, unikatową funkcją witryny internetowej usługi Azure Quantum. W tym miejscu możesz uruchamiać wbudowane Q# przykłady lub własne Q# programy, generować nowy Q# kod z monitów, otwierać i uruchamiać kod w programie VS Code dla sieci Web za pomocą jednego kliknięcia i zadać Copilot wszelkie pytania dotyczące obliczeń kwantowych.
Wymagania wstępne
Aby uruchomić przykładowy kod w rozwiązaniu Copilot for Azure Quantum, potrzebne są następujące elementy:
- Konto e-mail firmy Microsoft (MSA).
Aby uzyskać więcej informacji na temat rozwiązania Copilot, zobacz Eksplorowanie usługi Azure Quantum.
Inicjowanie kubitu do znanego stanu
Pierwszym krokiem Q# jest zdefiniowanie operacji, która zainicjuje kubit do znanego stanu. Można to wywołać, aby ustawić kubit na stan klasyczny, co oznacza, że w przypadku pomiaru zwraca Zero
100% czasu lub zwraca One
100% czasu. Pomiar kubitu zwraca Q# typ Result
, który może mieć tylko wartość Zero
lub One
.
Otwórz narzędzie Copilot for Azure Quantum i skopiuj następujący kod do okna edytora kodu. Nie klikaj jeszcze przycisku Uruchom . W dalszej części samouczka uruchomisz kod.
namespace Bell {
open Microsoft.Quantum.Intrinsic;
open Microsoft.Quantum.Canon;
operation SetQubitState(desired : Result, target : Qubit) : Unit {
if desired != M(target) {
X(target);
}
}
}
W przykładzie kodu wprowadzono dwie standardowe operacje M
i X
, które przekształcają stan kubitu.
SetQubitState
Operacja:
- Przyjmuje dwa parametry: typ o nazwie
desired
, który reprezentuje żądany stan kubitu, który ma znajdować się w (Zero
lubOne
) i typQubit
.Result
- Wykonuje operację pomiaru ,
M
która mierzy stan kubitu (Zero
lubOne
) i porównuje wynik z wartością określoną wdesired
elemecie . - Jeśli miara nie jest zgodna z porównywaną wartością, uruchamia operację
X
, która przerzuca stan kubitu, gdzie prawdopodobieństwo zwracaniaZero
miary iOne
są odwrócone. W ten sposóbSetQubitState
zawsze umieszcza kubit docelowy w żądanym stanie.
Pisanie operacji testowej w celu przetestowania stanu dzwonka
Następnie, aby zademonstrować efekt SetQubitState
operacji, utwórz kolejną operację o nazwie TestBellState
. Ta operacja przydzieli dwa kubity, wywołaj polecenie SetQubitState
, aby ustawić pierwszy kubit na znany stan, a następnie zmierzy kubity, aby zobaczyć wyniki.
Skopiuj następujący kod do okna edytora kodu poniżej SetQubitState
operacji.
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 );
}
W kodzie count
zmienne i initial
są ustawione odpowiednio na 1000
i One
. Inicjuje to pierwszy kubit i One
mierzy każdy kubit 1000 razy.
TestBellState
Operacja:
- Ustawia zmienne dla licznika i początkowego stanu kubitu.
- Wywołuje instrukcję w
use
celu zainicjowania dwóch kubitów. - Pętle dla
count
iteracji. Dla każdej pętli- Wywołania
SetQubitState
ustawiają określonąinitial
wartość na pierwszym kubitie. - Wywołaj ponownie polecenie
SetQubitState
, aby ustawić drugi kubit naZero
stan. M
Używa operacji do mierzenia każdego kubitu.- Przechowuje liczbę pomiarów dla każdego kubitu, który zwraca wartość
One
.
- Wywołania
- Po zakończeniu pętli wywołuje ona ponownie polecenie
SetQubitState
resetowania kubitów do znanego stanu (Zero
), aby umożliwić innym osobom przydzielanie kubitów w znanym stanie. Jest to wymagane przez instrukcjęuse
. - Na koniec używa
Message
funkcji do drukowania wyników w oknach danych wyjściowych Copilot przed zwróceniem wyników.
Uruchamianie kodu w rozwiązaniu Copilot for Azure Quantum
Przed przejściem do procedur superpozycji i splątania można przetestować kod do tego momentu, aby zobaczyć inicjowanie i pomiar kubitów.
Aby uruchomić kod jako autonomiczny program, kompilator w Copilot musi wiedzieć, Q#gdzie uruchomić program. Jest to wykonywane w Q# pliku przez dodanie bezpośrednio poprzedzającej @EntryPoint()
operację, którą chcesz uruchomić najpierw. Na przykład w tym przypadku jest TestBellState
to operacja.
Uwaga
@EntryPoint()
program jest wymagany tylko w przypadku programów autonomicznych Q# . W przypadku uruchamiania Q# programu w notesach Jupyter Notebook lub wywoływania Q# programu z pliku hosta języka Python nie jest to wymagane i zgłasza błąd, jeśli zostanie uwzględniony.
Dodaj bezpośrednio przed operacją@EntryPoint()
, a Q# program do tego punktu powinien teraz wyglądać następująco:TestBellState
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 );
}
}
Skopiuj i wklej kompletny przykładowy kod w oknie Copilot for Azure Quantum code, ustaw slajd dla liczby strzałów na "1", a następnie kliknij przycisk Uruchom. Wyniki są wyświetlane w histogramie i w polach Wyniki .
Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0
Ponieważ kubity nie zostały jeszcze manipulowane, zachowały swoje wartości początkowe: pierwszy kubit zwraca One
wartość za każdym razem, a drugi kubit zwraca wartość Zero
.
Jeśli zmienisz wartość elementu initial
na Zero
i ponownie uruchomisz program, zwróć uwagę, że pierwszy kubit również jest zwracany Zero
za każdym razem.
Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0
Umieszczanie kubitu w superpozycji
Obecnie kubity w programie są w stanie klasycznym, czyli są to 1 lub 0. Wiesz to, ponieważ program inicjuje kubity do znanego stanu i nie dodano żadnych procesów do manipulowania nimi. Przed splątaniem kubitów pierwszy kubit zostanie umieszczony w stanie superpozycji, w którym pomiar kubitu zwróci Zero
ok. 50% czasu i One
ok. 50% czasu. Koncepcyjnie kubit można traktować jako równy prawdopodobieństwo pomiaru wartości Zero
lub One
.
Aby umieścić kubit w superpozycji, Q# zapewnia operację H
, lub Hadamard. X
Przypomnij sobie operację z inicjowania kubitu do znanej procedury stanu wcześniej, która przerzuca kubit z zakresu od 0 do 1 (lub na odwrót); H
operacja przerzuca kubit w połowie stanu równego prawdopodobieństwa Zero
lub One
. Po zmierzeniu kubit w superpozycji powinien zwracać mniej więcej taką samą liczbę Zero
wyników i One
.
Zmodyfikuj TestBellState
kod w operacji, resetując wartość początkową i One
wstawiając wiersz dla H
operacji:
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);
...
Teraz po uruchomieniu programu można zobaczyć wyniki pierwszego kubitu w superpozycji.
Q1 - Zeros: 523 // results will vary
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0
Za każdym razem, gdy uruchamiasz program, wyniki pierwszego kubitu będą się nieznacznie różnić, ale będą zbliżone do 50% i 50% One
Zero
, podczas gdy wyniki drugiego kubitu pozostaną Zero
cały czas.
Q1 - Zeros: 510
Q1 - Ones: 490
Q2 - Zeros: 1000
Q2 - Ones: 0
Inicjowanie pierwszego kubitu w celu Zero
zwracania podobnych wyników.
Q1 - Zeros: 504
Q1 - Ones: 496
Q2 - Zeros: 1000
Q2 - Ones: 0
Uwaga
Przesuwając suwak w copilot dla usługi Azure Quantum i zwiększając liczbę zdjęć, możesz zobaczyć, jak wyniki superpozycji różnią się nieznacznie w rozkładzie strzałów.
Splątanie dwóch kubitów
Jak wspomniano wcześniej, splątane kubity są połączone tak, że nie można ich opisać niezależnie od siebie. Oznacza to, że jakakolwiek operacja dzieje się z jednym kubitem, dzieje się również z splątanym kubitem. Dzięki temu można znać wynikowy stan jednego kubitu bez mierzenia go, po prostu mierząc stan drugiego kubitu. (W tym przykładzie użyto dwóch kubitów; jednak można również splątać trzy lub więcej kubitów).
Aby włączyć splątanie, Q# zapewnia operację CNOT
, która oznacza kontrolowaną notę. Wynikiem uruchomienia tej operacji na dwóch kubitach jest przerzucanie drugiego kubitu, jeśli pierwszy kubit to One
.
Dodaj operację CNOT
do programu bezpośrednio po H
operacji. Pełny program powinien wyglądać następująco:
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 );
}
}
Teraz po uruchomieniu programu powinien zostać wyświetlony następujący komunikat:
Q1 - Zeros: 502 // results will vary
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498
Zwróć uwagę, że statystyki pierwszego kubitu nie uległy zmianie (nadal istnieje prawdopodobieństwo ok. 50/50 wartości Zero
One
lub po pomiarze), ale wyniki pomiaru drugiego kubitu są zawsze takie same jak pomiar pierwszego kubitu, bez względu na to, ile razy uruchamiasz program. Operacja CNOT
splątał dwa kubity, tak aby cokolwiek się z nimi stało, dzieje się z drugim.
Wymagania wstępne
Aby utworzyć i uruchomić przykładowy kod w lokalnym środowisku projektowym:
- Najnowsza wersja Visual Studio Code lub otwórz program VS Code w sieci Web.
- Najnowsza wersja rozszerzenia zestawu Azure Quantum Development Kit . Aby uzyskać szczegółowe informacje na temat instalacji, zobacz Instalowanie nowoczesnego zestawu QDK w programie VS Code.
Twórca nowy Q# plik
- Otwórz Visual Studio Code i wybierz pozycję Plik > nowy plik tekstowy, aby utworzyć nowy plik.
- Zapisz plik jako
CreateBellStates.qs
. Ten plik będzie zawierać Q# kod programu.
Inicjowanie kubitu do znanego stanu
Pierwszym krokiem Q# jest zdefiniowanie operacji, która zainicjuje kubit do znanego stanu. Można to wywołać, aby ustawić kubit na stan klasyczny, co oznacza, że zwraca Zero
100% czasu lub zwraca One
100% czasu. Zero
i One
są Q# wartościami reprezentującymi tylko dwa możliwe wyniki pomiaru kubitu.
Otwórz CreateBellStates.qs
i skopiuj następujący kod:
namespace Bell {
open Microsoft.Quantum.Intrinsic;
open Microsoft.Quantum.Canon;
operation SetQubitState(desired : Result, target : Qubit) : Unit {
if desired != M(target) {
X(target);
}
}
}
W przykładzie kodu wprowadzono dwie standardowe operacje M
i X
, które przekształcają stan kubitu.
SetQubitState
Operacja:
- Przyjmuje dwa parametry: typ o nazwie
desired
, który reprezentuje żądany stan kubitu, który ma znajdować się w (Zero
lubOne
) i typQubit
.Result
- Wykonuje operację pomiaru ,
M
która mierzy stan kubitu (Zero
lubOne
) i porównuje wynik z wartością określoną wdesired
elemecie . - Jeśli miara nie jest zgodna z porównywaną wartością, uruchamia operację
X
, która przerzuca stan kubitu, gdzie prawdopodobieństwo zwracaniaZero
miary iOne
są odwrócone. W ten sposóbSetQubitState
zawsze umieszcza kubit docelowy w żądanym stanie.
Pisanie operacji testowej w celu przetestowania stanu dzwonka
Następnie, aby zademonstrować efekt SetQubitState
operacji, utwórz kolejną operację o nazwie TestBellState
. Ta operacja przydzieli dwa kubity, wywołaj polecenie SetQubitState
, aby ustawić pierwszy kubit na znany stan, a następnie zmierzy kubity, aby zobaczyć wyniki.
Dodaj następującą operację do CreateBellStates.qs
pliku po SetQubitState
operacji:
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 );
}
W kodzie count
zmienne i initial
są ustawione odpowiednio na 1000
i One
. Inicjuje to pierwszy kubit i One
mierzy każdy kubit 1000 razy.
TestBellState
Operacja:
- Przyjmuje dwa parametry:
count
, liczbę razy do uruchomienia miary iinitial
, żądany stan do zainicjowania kubitu. - Wywołuje instrukcję w
use
celu zainicjowania dwóch kubitów. - Pętle dla
count
iteracji. Dla każdej pętli- Wywołania
SetQubitState
ustawiają określonąinitial
wartość na pierwszym kubitie. - Wywołaj ponownie polecenie
SetQubitState
, aby ustawić drugi kubit naZero
stan. M
Używa operacji do mierzenia każdego kubitu.- Przechowuje liczbę pomiarów dla każdego kubitu, który zwraca wartość
One
.
- Wywołania
- Po zakończeniu pętli wywołuje ona ponownie polecenie
SetQubitState
resetowania kubitów do znanego stanu (Zero
), aby umożliwić innym osobom przydzielanie kubitów w znanym stanie. Jest to wymagane przez instrukcjęuse
. - Na koniec używa
Message
funkcji do drukowania komunikatu w konsoli przed zwróceniem wyników.
Uruchamianie kodu
Przed przejściem do procedur superpozycji i splątania przetestuj kod do tego momentu, aby zobaczyć inicjowanie i pomiar kubitów.
Jest to wykonywane w Q# pliku przez dodanie bezpośrednio poprzedzającej @EntryPoint()
operację, którą chcesz uruchomić. Na przykład w tym przypadku jest TestBellState
to operacja.
Uwaga
@EntryPoint()
program jest wymagany tylko w przypadku programów autonomicznych Q# . W przypadku uruchamiania Q# programu w notesach Jupyter Notebook lub wywoływania Q# programu z pliku hosta języka Python nie jest to wymagane i zgłasza błąd, jeśli zostanie uwzględniony.
Plik
CreateBellStates.qs
powinien teraz wyglądać następująco: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 ); } }
Przed uruchomieniem programu należy ustawić profil docelowy na Wartość Nieograniczone. Wybierz pozycję Widok —> paleta poleceń, wyszukaj ciąg QIR, wybierz pozycję Q#: Ustaw profil docelowy usługi Azure Quantum QIR, a następnie wybierz pozycję Q#: nieograniczone.
Uwaga
Jeśli profil docelowy nie jest ustawiony na Wartość Nieograniczone, podczas uruchamiania programu zostanie wyświetlony błąd.
Aby uruchomić program, wybierz pozycję Uruchom Q# plik z listy rozwijanej ikona odtwarzania w prawym górnym rogu, kliknij pozycję Uruchom z listy poleceń poniżej
@EntryPoint()
lub naciśnij klawisze Ctrl+F5. Program uruchamia operację lub funkcję oznaczoną atrybutem@EntryPoint()
w symulatorze domyślnym.Dane wyjściowe są wyświetlane w konsoli debugowania.
Q1 - Zeros: 0 Q1 - Ones: 1000 Q2 - Zeros: 1000 Q2 - Ones: 0
Ponieważ kubity nie zostały jeszcze manipulowane, zachowały swoje wartości początkowe: pierwszy kubit zwraca
One
wartość za każdym razem, a drugi kubit zwraca wartośćZero
.Jeśli zmienisz wartość elementu
initial
naZero
i ponownie uruchomisz program, zwróć uwagę, że pierwszy kubit również jest zwracanyZero
za każdym razem.Q1 - Zeros: 1000 Q1 - Ones: 0 Q2 - Zeros: 1000 Q2 - Ones: 0
Porada
Pamiętaj, aby zapisać plik za każdym razem, gdy wprowadzasz zmianę kodu przed ponownym uruchomieniem.
Umieszczanie kubitu w superpozycji
Obecnie kubity w programie są w stanie klasycznym, czyli są to 1 lub 0. Wiesz to, ponieważ program inicjuje kubity do znanego stanu i nie dodano żadnych procesów do manipulowania nimi. Przed splątaniem kubitów pierwszy kubit zostanie umieszczony w stanie superpozycji, w którym pomiar kubitu zwróci Zero
50% czasu i One
50% czasu. Koncepcyjnie kubit może być uważany za pół drogi między Zero
i One
.
Aby umieścić kubit w superpozycji, Q# zapewnia operację H
, lub Hadamard. X
Przypomnij sobie operację z inicjowania kubitu do znanej procedury stanu wcześniej, która przerzuciła kubit z Zero
do One
(lub na odwrót); H
operacja przerzuca kubit w połowie stanu równego prawdopodobieństwa Zero
lub One
. Po zmierzeniu kubit w superpozycji powinien zwracać mniej więcej taką samą liczbę Zero
wyników i One
.
Zmodyfikuj
TestBellState
kod w operacji, aby uwzględnić operację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); ...
Teraz po uruchomieniu programu można zobaczyć wyniki pierwszego kubitu w superpozycji:
Q1 - Zeros: 523 // results will vary Q1 - Ones: 477 Q2 - Zeros: 1000 Q2 - Ones: 0
Za każdym razem, gdy uruchamiasz program, wyniki pierwszego kubitu będą się nieznacznie różnić, ale będą zbliżone do 50% i 50%
One
Zero
, podczas gdy wyniki drugiego kubitu pozostanąZero
cały czas.Q1 - Zeros: 510 Q1 - Ones: 490 Q2 - Zeros: 1000 Q2 - Ones: 0
Inicjowanie pierwszego kubitu w celu
Zero
zwracania podobnych wyników.Q1 - Zeros: 504 Q1 - Ones: 496 Q2 - Zeros: 1000 Q2 - Ones: 0
Splątanie dwóch kubitów
Jak wspomniano wcześniej, splątane kubity są połączone tak, że nie można ich opisać niezależnie od siebie. Oznacza to, że jakakolwiek operacja dzieje się z jednym kubitem, dzieje się również z splątanym kubitem. Dzięki temu można znać wynikowy stan jednego kubitu bez mierzenia go, po prostu mierząc stan drugiego kubitu. (W tym przykładzie użyto dwóch kubitów; jednak można również splątać trzy lub więcej kubitów).
Aby włączyć splątanie, Q# zapewnia operację CNOT
, która oznacza kontrolowaną notę. Wynikiem uruchomienia tej operacji na dwóch kubitach jest przerzucanie drugiego kubitu, jeśli pierwszy kubit to One
.
Dodaj operację
CNOT
do programu bezpośrednio poH
operacji. Pełny program powinien wyglądać następująco: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
Statystyki pierwszego kubitu nie uległy zmianie (50/50 szans na Zero
pomiar lub One
po pomiarze), ale wyniki pomiaru drugiego kubitu są zawsze takie same jak pomiar pierwszego kubitu. Operacja CNOT
splątał dwa kubity, tak aby cokolwiek się z nimi stało, dzieje się z drugim.
Wykreśl histogram częstotliwości
Zwizualizujmy rozkład wyników uzyskanych z uruchamiania programu kwantowego wiele razy. Histogram częstotliwości pomaga wizualizować rozkład prawdopodobieństwa tych wyników.
Wybierz pozycję Widok —> paleta poleceń lub naciśnij klawisze Ctrl+Shift+P, a następnie wpisz "histogram", który powinien wyświetlić Q#polecenie : Uruchom plik i pokaż histogram . Możesz również kliknąć pozycję Histogram z listy poleceń poniżej
@EntryPoint()
. Wybierz tę opcję, aby otworzyć okno histogramu Q# .Wprowadź kilka strzałów do wykonania programu, na przykład 100 strzałów, a następnie naciśnij klawisz Enter. Histogram zostanie wyświetlony w oknie histogramu Q# .
Każdy słupek w histogramie odpowiada możliwemu wynikowi, a jego wysokość reprezentuje liczbę obserwowanych wyników. W tym przypadku istnieje 50 różnych unikatowych wyników. Należy pamiętać, że dla każdego wyniku wyniki pomiaru dla pierwszego i drugiego kubitu są zawsze takie same.
Porada
Histogram można powiększyć za pomocą kółka przewijania myszy lub gestu klawiatury. Po powiększeniu wykres można przesuwać, naciskając klawisze "Alt" podczas przewijania.
Kliknij pasek, aby wyświetlić procent tego wyniku.
Kliknij ikonę ustawień w lewym górnym rogu, aby wyświetlić opcje. Możesz wyświetlić 10 pierwszych wyników, 25 pierwszych wyników lub wszystkie wyniki. Możesz również sortować wyniki z wysokiej do niskiej lub niskiej do wysokiej.
Następne kroki
Zapoznaj się z innymi Q# samouczkami:
- Kwantowy generator liczb losowych pokazuje, jak napisać Q# program, który generuje losowe liczby z kubitów w superpozycji.
- Algorytm wyszukiwania Grovera pokazuje, jak napisać Q# program korzystający z algorytmu wyszukiwania Grovera.
- Quantum Fourier Transform bada sposób pisania Q# programu, który bezpośrednio dotyczy określonych kubitów.
- Quantum Kata to samouczki realizowane samodzielnie i ćwiczenia programistyczne mające na celu nauczanie elementów obliczeń kwantowych i Q# programowania w tym samym czasie.
Opinia
https://aka.ms/ContentUserFeedback.
Dostępne już wkrótce: W 2024 r. będziemy stopniowo wycofywać zgłoszenia z serwisu GitHub jako mechanizm przesyłania opinii na temat zawartości i zastępować go nowym systemem opinii. Aby uzyskać więcej informacji, sprawdź:Prześlij i wyświetl opinię dla