Öğretici: Q# ile dolaşıklığı keşfetme
Bu öğreticide, Q# qubits 'i işleyen ve ölçtüğünden ve üst konum ve entanglement 'in etkilerini gösteren bir programın nasıl yazılacağı gösterilmektedir.
BellHisse antanglement 'i göstermek için adlı bir uygulama yazacaksınız. Bell adı, en basit süper konum ve kuantum dolaşıklığı örneklerini göstermek için kullanılan iki kubitin belirli kuantum durumları olan Bell durumlarını ifade eder.
Ön koşullar
- Tercih ettiğiniz dil ve geliştirme ortamınızı kullanarak hisse geliştirme setini (QDK) yükler .
- Zaten QDK yüklüyse, en son sürüme güncelleştirdiğinizden emin olun.
- Bir Q# Q# uygulamaiçin bir Python ana bilgisayar programıylaveya bir C# ana bilgisayar programıylabir proje oluşturun.
Ayrıca, QDK 'yi yüklemeden anlatıcı olarak, programlama dilinin genel bakışlarını Q# ve hisse bilgi işlem kavramlarının ilk kavramlarını gözden geçirerek da izleyebilirsiniz.
Bu öğreticide aşağıdakilerin nasıl yapılacağını öğreneceksiniz:
- Q 'da işlemler oluşturun ve birleştirin # .
- Qubits 'i üst konuma yerleştirmek için işlemler oluşturun, bunları zenginedin ve ölçün.
- Bir benzeticide çalıştırılan bir programla hisse entanglement 'i gösterir Q# .
QDK ile qubit davranışı gösterme
Klasik bitler 0 veya 1 gibi tek bir ikili değeri barındırırken, kubitin durumu 0 ve 1’in bir süper konumunda olabilir. Kavramsal olarak, bir qubit durumu soyut bir alanda (vektör olarak da bilinir) bir yön olarak düşünülebilir. Bir qubit durumu olası yönlere ait olabilir. İki klasik durum, iki yöndür. Bu da %100 oranında 0 ölçme şansını ve %100 oranında 1 ölçme şansını gösterir.
Ölçüm işlemi ikili sonuç üretir ve bir kubit durumunu değiştirir. Ölçüm, 0 veya 1 olan bir ikili değer üretir. Kubit, süper konumdan (herhangi bir yöne) klasik durumlardan birine geçer. Bundan sonra aynı ölçümün başka bir işlemle müdahale edilmeden yinelenmesi durumunda aynı ikili sonuç ortaya çıkar.
Birden çok kubit dolaşık hale getirilebilir. Dolaşık bir kubitin ölçümünü yaptığınızda, diğerinin durumuna ilişkin bilginiz de güncelleştirilir.
Q uygulamasını yazma #
Amaç, belirli bir hisse durumunda iki qubit hazırlanmaktır. Bu, Q# eyaletlerin durumunu değiştirmek ve üst konum ve entanglement 'in etkilerini göstermek için ile qubit üzerinde nasıl çalışılacağını gösterir. Bu parçayı, qubit durumları, işlemleri ve ölçümü tanıtmak için bir parça olarak oluşturacaksınız.
Ölçüyü kullanarak qubit Başlat
Aşağıdaki kod parçacığı, içindeki qubits ile çalışmayı gösterir Q# . Kod iki işlem tanıtır M ve X bir qubit durumunu dönüştürür.
Bir işlem, bir SetQubitState qubit ve başka bir parametre olarak alan, desired qubit için istenen durumu temsil eden bir parametre olarak tanımlanır. SetQubitState işlemi, M işlemini kullanarak kubit üzerinde bir ölçüm gerçekleştirir. Q#' De, bir qubit ölçümü her zaman Zero ya da döndürür One . Ölçüm, istenen değere eşit olmayan bir değer döndürürse, SetQubitState "qubit" değerini çevirir; diğer bir deyişle, bir işlem çalıştırır ve bu, X qubit durumunu döndürülen ve geri çevrilen bir ölçünün olasılıkların ne olduğu yeni bir duruma geçirir Zero One . Bu şekilde, SetQubitState her zaman hedef qubit 'i istenen duruma geçirir.
İçeriğini Program.qs aşağıdaki kodla değiştirin:
namespace Bell {
open Microsoft.Quantum.Intrinsic;
open Microsoft.Quantum.Canon;
operation SetQubitState(desired : Result, q1 : Qubit) : Unit {
if desired != M(q1) {
X(q1);
}
}
}
Bu işlem artık kubiti klasik bir duruma getirerek %100 Zero veya %100 One döndürmesi sağlanabilir.
Zero ve One, bir kubit ölçümünün mümkün olan iki sonucunu gösteren sabitlerdir.
SetQubitState işlemi kubiti ölçer. Qubit istenen durumdaysa, SetQubitState bunu tek başına bırakır; Aksi takdirde X işlemi çalıştırarak qubit durumu istenen duruma değişir.
Q#İşlemler hakkında
Q#İşlem bir hisse alt yordamı. Diğer bir deyişle, diğer hisse işleme çağrıları içeren çağrılabilir bir yordamdır.
İşlemin bağımsız değişkenleri parantez içinde tanımlama grubu olarak belirtilir.
Bir iki nokta işareti eklendikten sonra işlemin dönüş türü belirtilir. Bu durumda, SetQubitState işlemin dönüş türü yoktur, bu nedenle döndürülen olarak işaretlenir Unit . Bu, Q# C# ' de unit kabaca benzer olan void ve Python 'da boş bir tanımlama grubu olan ( () tür Ipucuyla temsil edilen) F # ' ın eşdeğeridir Tuple[()] .
İlk işlem sırasında iki hisse işlem kullandınız Q# :
Kuantum işlemi, kubitin durumunu dönüştürür. Bazen kuantum işlemleri, klasik mantıksal geçitlere benzetildiğinden geçit olarak adlandırılır. Bu kullanım kuantum bilgisayarların ilk dönemlerine dayanır. Bu dönemde algoritmaların yalnızca teorik yapılardı ve klasik bilgi işlem devre şemalarına benzer şekilde görselleştirilirdi.
Ölçüm sonuçlarını sayma
Sonrasında SetQubitState işleminin etkisini göstermek için bir TestBellState işlemi eklenir. Bu işlem giriş olarak Zero veya One alır. Ardından SetQubitState işlemini bu girişle birkaç kez çağırıp kubitin ölçümünden döndürülen Zero sayısı ile döndürülen One sayısını hesaplar. Tabii ki, işlemin bu ilk simülasyonu içinde, TestBellState bir, çıkışın parametre girişi olarak, qubit kümesinin tüm ölçümlerinin Zero geri dönecektir Zero ve parametresi girişi olarak bir qubit kümesinin tüm ölçümleri One dönecektir One . Daha fazla üzerinde kod, TestBellState üst konum ve entanglement 'i göstermek için öğesine eklenir.
Aşağıdaki işlemi Program.qs dosyasında ad alanının içine, SetQubitState işleminin sonuna ekleyin:
operation TestBellState(count : Int, initial : Result) : (Int, Int) {
mutable numOnes = 0;
use qubit = Qubit();
for test in 1..count {
SetQubitState(initial, qubit);
let res = M(qubit);
// Count the number of ones we saw:
if res == One {
set numOnes += 1;
}
}
SetQubitState(Zero, qubit);
// Return number of times we saw a |0> and number of times we saw a |1>
Message("Test results (# of 0s, # of 1s): ");
return (count - numOnes, numOnes);
}
return( Message ) () [Microsoft. hisse. iç. ileti] işleviyle konsolda açıklayıcı bir ileti yazdırmak için önce bir satır olduğunu unutmayın.
Bu işlem (TestBellState) count yinelemeleri için döngü yapar, bir kubitte belirtilen initial değerini ayarlar ve ardından sonucu ölçer (M). Kaç sıfır ve bir ölçtüğümüzle ilgili istatistikleri toplar ve bunları çağrıyı yapana döndürür. Bir gerekli işlem daha gerçekleştirir. Kubiti döndürmeden önce bilinen bir duruma (Zero) sıfırlayarak diğerlerinin bu kubiti bilinen durumda ayırmasına olanak tanır. Bu, use deyimi için gereklidir.
Q içindeki değişkenler hakkında#
Varsayılan olarak, ' deki değişkenler Q# sabittir; bu değerler bağlandıktan sonra değiştirilemez. Sabit bir değişkenin bağlamasını göstermek için let anahtar sözcüğü kullanılır. İşlem bağımsız değişkenleri her zaman sabittir.
Değeri değişebilen numOnes gibi bir değişkene ihtiyacınız varsa değişkeni mutable anahtar sözcüğüyle bildirebilirsiniz. Değişebilir değişkenin değeri set deyimi kullanılarak değiştirilebilir.
Her iki durumda da, değişkenin türü derleyici tarafından çıkarsanır. Q# değişkenler için herhangi bir tür ek açıklaması gerektirmez.
useQ içindeki deyimler hakkında#
useİfade için de özeldir Q# . Kubitleri bir kod bloğunda kullanım amacıyla ayırmak için kullanılır. ' De Q# , tüm qubits, karmaşık bir algoritmanın tüm kullanım ömrü boyunca yer alan sabit kaynaklar yerine dinamik olarak ayrılır ve serbest bırakılır. Başlangıçta use deyimi bir kubit kümesi ayırır ve bloğun sonunda bu kubitleri serbest bırakır.
Komut isteminden kodu çalıştırma
Kodu çalıştırmak için, komut sağlamamız durumunda , derleyicinin çalıştırılabilir olduğunu söylememiz gerekir dotnet run . Bu, Q# @EntryPoint() çağrılabilir: TestBellState Bu durumda işlem tarafından doğrudan bir satır eklenerek, dosyada basit bir değişiklik ile yapılır. Tam kod şu şekilde olmalıdır:
namespace Bell {
open Microsoft.Quantum.Canon;
open Microsoft.Quantum.Intrinsic;
operation SetQubitState(desired : Result, target : Qubit) : Unit {
if desired != M(target) {
X(target);
}
}
@EntryPoint()
operation TestBellState(count : Int, initial : Result) : (Int, Int) {
mutable numOnes = 0;
use qubit = Qubit();
for test in 1..count {
SetQubitState(initial, qubit);
let res = M(qubit);
// Count the number of ones we saw:
if res == One {
set numOnes += 1;
}
}
SetQubitState(Zero, qubit);
// Return number of times we saw a |0> and number of times we saw a |1>
Message("Test results (# of 0s, # of 1s): ");
return (count - numOnes, numOnes);
}
}
Programı çalıştırmak için count initial komut isteminden ve bağımsız değişkenleri belirtmemiz gerekir. Örneğin count = 1000 , ve ' i seçelim initial = One . Aşağıdaki komutu girin:
dotnet run --count 1000 --initial One
Aşağıdaki çıktıyı gözlemleymelisiniz:
Test results (# of 0s, # of 1s):
(0, 1000)
İle çalışırsanız şunu initial = Zero gözlemleyebilirsiniz:
dotnet run --count 1000 --initial Zero
Test results (# of 0s, # of 1s):
(1000, 0)
Süper konumu hazırlama
Şimdi Q# de bilgeler 'yi üst konuma yerleştirmek için nasıl ifade etmenin nasıl olduğunu inceleyelim. Hatırlayacağınız gibi bir kubit 0 ve 1 süper konumlarında olabilir. İşlem kullanılarak bu gerçekleştirilebilir Hadamard . Kubitin klasik durumlardan birine olması halinde (ölçümün her zaman Zero veya her zaman One döndürmesi durumunda) Hadamard ya da H işlemi kubiti ölçümün %50 oranında Zero ve %50 oranında One döndüreceği bir duruma alır. Kavramsal olarak, qubit, ve arasında yarı olarak düşünülebilir Zero One . Şimdi, TestBellState işlem simülasyonda, sonuçlar yaklaşık olarak eşit sayıda Zero ve One ölçüden sonra döndürülür.
X qubit durumunu çevirir
İlk olarak, qubit ' i (qubit durumunda ise bunun tersi) ters çevirmeyi deneyelim Zero One . Bu, kubiti TestBellState işleminde ölçmeden önce bir X işlemi gerçekleştirilerek yapılır:
X(qubit);
let res = M(qubit);
Şimdi sonuçlar tersine çevrilir:
dotnet run --count 1000 --initial One
Test results (# of 0s, # of 1s):
(1000, 0)
dotnet run --count 1000 --initial Zero
Test results (# of 0s, # of 1s):
(0, 1000)
Şimdi kubitlerin kuantum özelliklerini keşfederiz.
H süper konumlandırmayı hazırlar
Tek ihtiyacınız olan, önceki çalıştırmada yapılan işlemi bir veya X H Hadamard işlemiyle değiştirmek. Bu, kubiti 0'dan 1'e kadar çevirmek yerine yalnızca yarıya çevirir. TestBellState işleminde değiştirilen satırlar şöyle görünür:
H(qubit);
let res = M(qubit);
Daha ilginç sonuçlar görülmeye başlar:
dotnet run --count 1000 --initial One
Test results (# of 0s, # of 1s):
(496, 504)
dotnet run --count 1000 --initial Zero
Test results (# of 0s, # of 1s):
(506, 494)
Her ölçü klasik bir değer sorar, ancak kubit 0 ile 1 arasında yarı yoldadır, bu nedenle (istatistiksel olarak) sürenin yarısına 0, yarısında ise 1 elde ederiz. Bu süper konum olarak bilinir ve bize kuantum durumunun ilk gerçek görünümünü verir.
Dolaşıklığı hazırlama
Şimdi Q# kubitleri nasıl dolaya dolaya dolanın yollarını ifade edene bakalım. İlk olarak, ilk kubiti başlangıç durumuna ayarlayın ve ardından H süper konumlandırmaya koymak için işlemi kullanın. Ardından, ilk kubiti ölçmeden önce Controlled-NOT (Denetimli-NOT) olan yeni bir işlem () CNOT kullanın. Bu işlemi iki kubitte çalıştırmanın sonucu, ilk kubit ise ikinci kubiti One çevirmektir. Şimdi iki kubit de dolaşık hale geldi. İlk kubitin istatistikleri değişmemiştir (ölçümün ardından veya sonrasında 50-50 şans) ama şimdi ikinci kubit ölçülürken, ilk kubit için ölçtükle her zaman aynı Zero One olur. CNOT geçidimiz iki kubiti dolaşık hale getirmiş, bu şekilde ilkine olanın aynısı diğerine de olmuştur. Ölçümleri ters çevirirseniz (ilk kubitten önce ikincisini yaparsanız), aynı durum ortaya çıkar. İlk ölçüm rastgele olacak ve ikincisi ilkinde bulunanla aynı yolu izleyecektir.
Doyma hazırlamak için önce içinde bir yerine iki kubit TestBellState ayırın:
use (q0, q1) = (Qubit(), Qubit());
Bu, içinde ölçmeden önce yeni bir işlem ( CNOT ) M eklememizi TestBellState sağlar:
SetQubitState(initial, q0);
SetQubitState(Zero, q1);
H(q0);
CNOT(q0, q1);
let res = M(q0);
Her SetQubitState zaman durumda olduğundan emin olmak için ilk kubiti başlatmak için başka bir işlem Zero ekleyin.
Son olarak, serbest bırakmadan önce ikinci kubiti sıfırlayın.
SetQubitState(Zero, q0);
SetQubitState(Zero, q1);
Yordamın tamamı şimdi şöyle görünür:
operation TestBellState(count : Int, initial : Result) : (Int, Int) {
mutable numOnes = 0;
use (q0, q1) = (Qubit(), Qubit());
for test in 1..count {
SetQubitState(initial, q0);
SetQubitState(Zero, q1);
H(q0);
CNOT(q0,q1);
let res = M(q0);
// Count the number of ones we saw:
if res == One {
set numOnes += 1;
}
}
SetQubitState(Zero, q0);
SetQubitState(Zero, q1);
// Return number of times we saw a |0> and number of times we saw a |1>
return (count-numOnes, numOnes);
}
Bunu çalıştıracaksanız daha önce elde edilen 50-50 sonuçla tam olarak aynı sonucu elde edesin. Ancak ilginç olan kısım ise ikinci kubitin ilk kubitin ölçülebilir duruma nasıl tepki gösterdiğidir. Bu istatistik, yeni bir işlem sürümüyle TestBellState birlikte eklenir:
operation TestBellState(count : Int, initial : Result) : (Int, Int, Int) {
mutable numOnes = 0;
mutable agree = 0;
use (q0, q1) = (Qubit(), Qubit());
for test in 1..count {
SetQubitState(initial, q0);
SetQubitState(Zero, q1);
H(q0);
CNOT(q0, q1);
let res = M(q0);
if M(q1) == res {
set agree += 1;
}
// Count the number of ones we saw:
if res == One {
set numOnes += 1;
}
}
SetQubitState(Zero, q0);
SetQubitState(Zero, q1);
// Return times we saw |0>, times we saw |1>, and times measurements agreed
Message("Test results (# of 0s, # of 1s, # of agreements)");
return (count-numOnes, numOnes, agree);
}
Yeni dönüş değeri (agree), ilk kubitten gelen ölçümün ikinci kubitin ölçümüyle her eşleşmesinin kaydını tutar.
Kodun çalıştırarak şu sonuçlar elde olur:
dotnet run --count 1000 --initial One
(505, 495, 1000)
dotnet run --count 1000 --initial Zero
Test results (# of 0s, # of 1s, # of agreements)
(507, 493, 1000)
Genel bakışta belirtildiği gibi, ilk kubitin istatistikleri değişmemiştir (0 veya 1 için 50-50 şans), ancak şimdi ikinci kubit ölçtüğnde ilk kubit için her zaman aynı olur çünkü bunlar doıktır!
Sonraki adımlar
Grover araması öğreticisi, en popüler kuantum bilişim algoritmalarından biri olan Grover aramasını derleme ve çalıştırmayı gösterir ve kuantum bilişimi ile gerçek sorunları çözmek için kullanılan bir programın güzel bir örneğini Q# sunar.
Bu Azure Quantum, öğrenmenin ve kuantum programlamanın daha Q# fazla yolu önerilmez.