Öğretici: Q 'da qubit düzeyi programları yazma ve benzetimini yapma#
Her bir qubit üzerinde çalışan temel bir hisse dili programını yazma ve benzetimi yapma hakkında hisse geliştirme seti (QDK) öğreticisine hoş geldiniz.
Q#Büyük ölçekli hisse programları için öncelikli olarak yüksek düzeyde bir programlama dili olarak oluşturulsa da, daha düşük hisse düzeyi programlarının düzeyini araştırmak için kolayca kullanılabilir. ' Nin esnekliği, Q# kullanıcıların her türlü soyutlama düzeyinden elde etmesine izin verir ve bu öğreticide, qubits 'e de yaklaşıyoruz.
Özellikle, bu öğretici, çok büyük hisse algoritmalarından integral olan bir altyordam olan hisse
Hisse senedi bilgi işlemenin bu alt düzey görünümünün genellikle, bir sistemin belirli qugeler için sıralı uygulamayı temsil eden "hisse devreleri" bakımından açıklandığına bakın.
Bu nedenle, ardışık olarak uygulanan tek ve Multi-qubit işlemleri "devre diyagramı" içinde kolayca temsil edilebilir. Bu durumda, Q# aşağıdaki gösterimi bir devre olarak bulunan tam üç qubit hisse Fourier dönüşümünü gerçekleştirmeye yönelik bir işlem tanımlayacaksınız:
Önkoş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.
Bu öğreticide aşağıdakilerin nasıl yapılacağını öğreneceksiniz:
- İçinde hisse işlemleri tanımlayın Q#
- Q#İşlemleri doğrudan komut isteminden veya klasik ana bilgisayar programını kullanarak çağırma
- Ölçüm çıkışına qubit ayırmayı bir hisse alma işlemi benzetimi yap
- Hisse sisteminin sanal dalga işlevinin işlem boyunca nasıl gelişdiğini gözlemleyin
QDK ile bir hisse programın çalıştırılması genellikle iki bölümden oluşur:
- Programın kendisi, Q# hisse dili programlama dili kullanılarak uygulanır ve ardından hisse bir bilgisayar veya hisse Benzetici üzerinde çalışmak üzere çağırılır. Bunlardan oluşur
- Q# işlemler: hisse kayıtları için davranan alt yordamlar ve
- Q# işlevler: hisse algoritması içinde kullanılan klasik alt yordamlar.
- Hisse programını çağırmak ve üzerinde çalıştırılması gereken hedef makineyi belirtmek için kullanılan giriş noktası. Bu işlem doğrudan komut isteminden veya Python veya C# gibi bir klasik programlama dilinde yazılmış bir konak programı aracılığıyla yapılabilir. Bu öğretici, tercih ettiğiniz yönteme ilişkin yönergeleri içerir.
Qubits ayırın ve hisse alma işlemlerini tanımlayın
Bu öğreticinin ilk bölümü, Q# Perform3qubitQFT üç qubit üzerinde hisse Fourier dönüşümünü gerçekleştiren işlemi tanımlamayı içerir.
Ayrıca, işlevi, DumpMachine üç qubit sistemimizin benzetilen dalga işlevinin işlem genelinde geliştikçe gözlemlemek için kullanılacaktır.
İlk adım, Q# projenizi ve dosyanızı oluşturmaktır. Bunun adımları programı çağırmak için kullanacağınız ortama bağlıdır ve ilgili yükleme kılavuzlarındakiayrıntıları bulabilirsiniz.
Bu öğreticide, dosyadaki adım adım yönergeler sunulmaktadır, ancak kod aşağıdaki tam bir blok olarak da kullanılabilir.
Diğer işlemlere erişmek için ad alanları Q#
Dosya içinde, önce NamespaceQFT derleyici tarafından erişilecek ad alanını tanımlayın.
Bu işlemin mevcut işlemleri kullanmasını sağlamak için Q# ilgili Microsoft.Quantum.<> ad alanlarını açın.
namespace NamespaceQFT {
open Microsoft.Quantum.Intrinsic;
open Microsoft.Quantum.Diagnostics;
open Microsoft.Quantum.Math;
open Microsoft.Quantum.Arrays;
// operations go here
}
Bağımsız değişkenlerle işlemleri tanımlama ve geri dönüş
Sonra, işlemi tanımlayın Perform3qubitQFT :
operation Perform3qubitQFT() : Unit {
// do stuff
}
Şimdilik işlem herhangi bir bağımsız değişken almaz ve bu durumda---hiçbir şey döndürmez; bu durumda, Unit void Python 'Da C# veya boş bir tanımlama alanı olan bir nesneyi döndüren bir nesne döndürür Tuple[()] .
Daha sonra, bir ölçüm sonuçları dizisi döndürecek şekilde değiştirilecek ve bu noktada Unit Değiştirilecek Result[] .
İle qubit ayırın use
İşlem içinde Q# , üç qubit anahtar sözcüğüyle bir kayıt ayırın use :
use qs = Qubit[3];
Message("Initial state |000>:");
DumpMachine();
İle use , qubits $ \ket $ durumunda otomatik olarak ayrılır {0} . Bunu Message(<string>) ve kullanarak DumpMachine() , bir dizeyi ve sistemin geçerli durumunu konsola yazdırmanızı sağlayabilirsiniz.
Not
Message(<string>)Ve DumpMachine() işlevleri ( Microsoft.Quantum.Intrinsic ve Microsoft.Quantum.Diagnostics sırasıyla), her ikisi de doğrudan konsola yazdırılır.
Tıpkı gerçek bir hisse hesaplamasına benzer şekilde, Q# qubit durumlarına doğrudan erişememize izin vermez.
Ancak, DumpMachine hedef makinenin geçerli durumunu yazdırdığından, tam durum simülatörü ile birlikte kullanıldığında hata ayıklama ve öğrenimi için değerli öngörüler sağlayabilir.
Tek qubit ve denetimli kapıları uygulama
Sonra, işlemin kendisini oluşturan kapıları uygulayın. Q# , ad alanında işlem olarak birçok temel hisse kapısı zaten içeriyor Microsoft.Quantum.Intrinsic ve bunlar özel durum değildir.
Bir işlem içinde, Q# callables çağıran deyimler, tabii ki sıralı sırayla çalıştırılır.
Bu nedenle, uygulanacak ilk kapı H ilk qubit 'e (Hadamard) sahiptir:
Bir kayıttaki belirli bir qubit 'e bir işlem uygulamak için (örneğin, bir diziden tek bir Qubit Qubit[] ) standart dizin gösterimi kullanıyoruz.
Bu nedenle, H kayıt yaptığımız ilk qubit 'e uygulamak şu qs biçimdedir:
H(qs[0]);
H(Hadamard) geçidini tek bir qubits 'e uygulamanın yanı sıra, QFT devresi öncelikle denetlenen döndürmeler ' i içerir R1 .
R1(θ, <qubit>)Genel içindeki bir işlem {0} , qubit 'in $ \ket $ bileşenini $ \ket $ bileşenine bir $e dönüşü uygulanırken, aynı şekilde değişmeden bırakır {1} .
Denetlenen işlemler
Q# bir veya birden fazla denetim qubit üzerinde bir işlemin çalıştırılmasına son derece kolay hale getirir.
Genel olarak, çağrı yalnızca ile önceden başlar Controlled ve işlem bağımsız değişkenleri şu şekilde değişir:
Op(<normal args>) $ -$ Controlled Op([<control qubits>], (<normal args>)) .
Tek bir qubit olsa bile denetim qubits 'in bir dizi olarak sağlanması gerektiğini unutmayın.
Sonrasında H , sonraki kapıların R1 ilk qubit üzerinde hareket eden kapıları vardır (ve ikinci/üçüncü tarafından denetlenir):
Şunları ile çağırabilirsiniz:
Controlled R1([qs[1]], (PI()/2.0, qs[0]));
Controlled R1([qs[2]], (PI()/4.0, qs[0]));
PI() Microsoft.Quantum.Math Ad alanındaki işlevin, Pi radyan cinsinden ifade tanımlamak için kullanıldığını unutmayın.
Ayrıca, kodlar bir Double 2.0 tamsayı ile bölmek bir tür hatası oluşturduğundan bir (örneğin,) tarafından bölünür 2 .
İpucu
R1(π/2) ve R1(π/4) , S ve T işlemlerine eşdeğerdir (Ayrıca içinde Microsoft.Quantum.Intrinsic ).
Hİkinci ve üçüncü qubits 'e ilgili işlemler ve denetlenen döndürmeler uygulandıktan sonra:
//second qubit:
H(qs[1]);
Controlled R1([qs[2]], (PI()/2.0, qs[1]));
//third qubit:
H(qs[2]);
SWAPDevresini tamamlayabilmeniz için yalnızca bir geçit uygulamanız gerekir:
SWAP(qs[2], qs[0]);
Bu gereklidir çünkü, bu işlem, bu, boyut ve alt yordamın daha büyük algoritmalara sorunsuz bir şekilde tümleştirilmesini sağlar.
Bu nedenle, size hisse ait qubit düzeyi işlemleri yazmak için Q# işlem işleminizi tamamladınız:
Ancak, qubits, ayrıldığımızda $ \ket {0} $ durumunda olduğundan, ilk durumu sıfırlamak için bunları serbest bırakın.
Qubit serbest bırakma
DumpMachine()İşlem sonrası durumunu görmek için yeniden çağırın ve son olarak, ResetAll işlemi tamamlamadan önce qubits 'i $ \tus$ ile sıfırlamak için qubit kayıt için geçerli {0} :
Message("After:");
DumpMachine();
ResetAll(qs);
Tüm serbest bırakılmış qubits 'in, {0} Q# aynı qubit (bir nadir kaynağı) ile çalışmaya başladıklarında durumlarını tam olarak öğrenmesini sağlayan temel bir özelliğidir.
Buna ek olarak, bu, sistemdeki diğer qubits ile zenginler olmasını sağlar.
Bir ayırma bloğunun sonunda sıfırlama gerçekleştirildiyse use , bir çalışma zamanı hatası oluşabilir.
Tam Q# dosyanız şu şekilde görünmelidir:
namespace NamespaceQFT {
open Microsoft.Quantum.Intrinsic;
open Microsoft.Quantum.Diagnostics;
open Microsoft.Quantum.Math;
open Microsoft.Quantum.Arrays;
operation Perform3qubitQFT() : Unit {
use qs = Qubit[3];
Message("Initial state |000>:");
DumpMachine();
//QFT:
//first qubit:
H(qs[0]);
Controlled R1([qs[1]], (PI()/2.0, qs[0]));
Controlled R1([qs[2]], (PI()/4.0, qs[0]));
//second qubit:
H(qs[1]);
Controlled R1([qs[2]], (PI()/2.0, qs[1]));
//third qubit:
H(qs[2]);
SWAP(qs[2], qs[0]);
Message("After:");
DumpMachine();
ResetAll(qs);
}
}
Q#Dosya ve işlem tamamlandıktan sonra, hisse dosyası, ve simülasyonu için hazırlanmaktadır.
Programı çalıştırma
Q#İşlemi bir .qs dosyada tanımladığınıza göre, şimdi bu işlemi çağırmanız ve döndürülen klasik verileri gözlemlemek gerekir. Şimdilik, döndürülen hiçbir şey yok (daha sonra işlem tarafından tanımlanan işlemin döndürdüğü geri çek Unit ), ancak daha sonra Q# işlemi bir ölçüm sonuçları dizisi döndürecek şekilde değiştirdiğinizde, Result[] Bu durum adreslenebilir.
Program, Q# Bu işlemi çağırmak için kullanılan ortamlarda bizden gerçekleşirken, bunu yapmanın yolu da farklılık gösterir. Bu nedenle, kuruluma karşılık gelen sekmedeki yönergeleri izlemeniz yeterlidir: Q# uygulamadan çalışma veya Python ya da C# ' de bir konak programı kullanma.
Q#Programı komut isteminden çalıştırmak, dosyada yalnızca küçük bir değişiklik yapılmasını gerektirir Q# .
@EntryPoint()İşlem tanımından önceki bir satıra eklemeniz yeterlidir:
@EntryPoint()
operation Perform3qubitQFT() : Unit {
// ...
Programı çalıştırmak için, terminali projenizin klasöründe açın ve şunu girin
dotnet run
Tamamlandıktan sonra, Message DumpMachine aşağıda ve aşağıdaki çıktıları konsolunuza görmeniz gerekir.
Initial state |000>:
# wave function for qubits with ids (least to most significant): 0;1;2
|0>: 1.000000 + 0.000000 i == ******************** [ 1.000000 ] --- [ 0.00000 rad ]
|1>: 0.000000 + 0.000000 i == [ 0.000000 ]
|2>: 0.000000 + 0.000000 i == [ 0.000000 ]
|3>: 0.000000 + 0.000000 i == [ 0.000000 ]
|4>: 0.000000 + 0.000000 i == [ 0.000000 ]
|5>: 0.000000 + 0.000000 i == [ 0.000000 ]
|6>: 0.000000 + 0.000000 i == [ 0.000000 ]
|7>: 0.000000 + 0.000000 i == [ 0.000000 ]
After:
# wave function for qubits with ids (least to most significant): 0;1;2
|0>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|1>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|2>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|3>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|4>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|5>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|6>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|7>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
Tam durum simülatörü üzerinde çağrıldığında, DumpMachine() hisse Eyaleti 'nin dalga işlevinin bu çoklu sunumlarını sağlar.
Bir $n $-qubit sisteminin olası durumları, her biri karşılık gelen bir karmaşık katsayı (yalnızca genliği ve bir aşama) olan $2 ^ n $ hesaplama tabanlı durumlar ile temsil edilebilir.
Hesaplama tabanlı durumlar, {0} {1} her ikili basamağın tek bir qubit 'e karşılık geldiği, qubit durumlarının $ \tus$ ve $ \ket $ ' nin olası tüm birleşimleri olan $n $---uzunluğunun tüm olası ikili dizelerine karşılık gelir.
İlk satır, karşılık gelen qubits kimlikleri için önemli sırayla bir açıklama sağlar.
2"En önemli" olan qubit, taban durum vektörü $ \ket{i} $ öğesinin ikili gösteriminde, qubit durumunun 2 en soldaki basamağa karşılık geldiğini gösterir.
Örneğin, $ \ket {6} = \ket $, qubit ve her ikisi de $ \gre$ ' da $ {110} 2 1 {1} \gre$ ve qubit ' te 0 {0} .
Satırların geri kalanı, hem Kartezyen hem de kutupsal biçimlerdeki temel eyalet vektörü $ \ket{i} $ ölçgenin olasılığını anlatmaktadır. Giriş durumunun ilk satırı için ayrıntı olarak $ \ket {000} $:
|0>:Bu satır,0Hesaplama esası durumuna karşılık gelir (ilk durum ayırma sonrası $ \ket {000} $ olur, bunun için bu noktada olasılık genliği olan tek durum olması beklenir).1.000000 + 0.000000 i: Kartezyen biçiminde olasılık genliği.==:equalişaret, her iki eşdeğer temsili de ayırır.********************: Büyüklük grafik gösterimi, sayısı*Bu durum vektörünü ölçme olasılığının müşterinizin istekleriyle orantılı.[ 1.000000 ]: büyüklük sayısal değeri---: Genin aşamasının grafik gösterimi.[ 0.0000 rad ]: aşamanın sayısal değeri (radyan cinsinden).
Büyüklük ve aşama bir grafik gösterimiyle birlikte görüntülenir. Büyüklük temsili basittir: bir çubuğu gösterir * ve olasılık arttıkça, çubuk ne kadar büyük olur. Aşama için bkz. test ve hata ayıklama: açı aralıklarına dayanan olası sembol temsilleri için döküm işlevleri.
Bu nedenle, yazdırılan çıktı, programlanmış kapıları durumumuzu dönüştürdüğünü gösterir
$ $ \ket{\psı} _ {Initial} = \ket {000} $ $
kullanıcısı
$ $ \begin{hizalaması} \ket{\psı} _ {final} &= \frac {\sqrt} \left (\ket + \tus+ \tus+ \tus+ \tus+ \ket {1} {8} {000} {001} {010} {011} {100} {101} + \ket {110} + \ ayraç {111} \ sağ) \ \ &= \frac {1} {\sqrt{2 ^ n}} \sum _ {j = 0} ^ {2 ^ n-1} \ket{j}, \end{hizalaması} $ $
Bu, 3-qubit Fourier dönüştürmesinin kesin bir davranıştır.
Diğer giriş durumlarının nasıl etkilendiğini merak ediyorsanız, dönüşümden önce qubit işlemleri uygulamayla birlikte oynamanızı öneririz.
Ölçümler ekleme
Ne yazık ki hisse kuyadan oluşan bir temel taş, gerçek bir hisse sisteminin böyle bir işleve sahip olmadığını bize söyler DumpMachine .
Bunun yerine, bilgiler ölçümler aracılığıyla ayıklanır, bu da genel olarak yalnızca bize tam hisse alım durumunu sağlamayacaktır, ancak sistemin kendisini büyük ölçüde değiştirebilir.
Birçok hisse ölçüm ölçümü vardır ancak tek bir qubit üzerinde en temel: çoklu ölçümler üzerinde odaklanacağız.
Belirli bir temelde ölçümde (örneğin, hesaplama tabanlı $ { \demet {0} , {1} } \tus$), qubit durumu, bu nedenle ikisi arasındaki herhangi bir üst konuma yok edilirken, her bir temel durumun ölçüldüğü bir şekilde yansıtılmıştır---.
Bir program içindeki ölçümleri uygulamak için Q# , M Microsoft.Quantum.Intrinsic bir türü döndüren işlemi (from) kullanın Result .
İlk olarak, Perform3QubitQFT işlemi yerine ölçüm sonuçlarının bir dizisini döndürecek şekilde değiştirin Result[] Unit .
operation Perform3QubitQFT() : Result[] {
Diziyi tanımlama ve başlatma Result[]
Qubit ayırarak (örneğin, use deyimden önce), bu length 3 diziyi bildirin ve bağlayın ( Result her bir qubit için bir tane):
mutable resultArray = new Result[3];
Kullanım mutable öncesi anahtar sözcüğü, resultArray değişkenin kod içinde daha sonra yeniden bağlanmasını sağlar---örneğin ölçüm sonuçlarımızı eklerken.
Ölçümleri bir döngüde gerçekleştirin for ve sonuçları diziye ekleyin
Fourier dönüştürme işlemleri tamamlandıktan sonra aşağıdaki kodu ekleyin:
for i in IndexRange(qs) {
set resultArray w/= i <- M(qs[i]);
}
IndexRangeBir dizide çağrılan işlev (örneğin, qubits dizimiz qs ) dizinin dizinlerinin üzerinde bir Aralık döndürür.
Burada,, for her bir qubit ifadesini kullanarak sırayla ölçmek için döngüsünde kullanılır M(qs[i]) .
Her ölçülen Result tür ( Zero ya da One ), resultArray bir Update ve-yeniden atama ifadesiyle ilgili dizin konumuna eklenir.
Not
Bu deyimin sözdizimi, için benzersizdir Q# , ancak resultArray[i] <- M(qs[i]) F # ve R gibi diğer dillerde görülen benzer değişken yeniden atamaya karşılık gelir.
Anahtar sözcüğü, set kullanarak değişkenlerin bağlanmasını yeniden atamak için her zaman kullanılır mutable .
Döndürülmesini resultArray
Üç qubit ölçülmüş ve sonuçları öğesine eklendiğinde resultArray , qubits 'i daha önce olduğu gibi sıfırlamak ve serbest bırakmak güvenlidir. Ölçümleri döndürmek için şunu ekleyin:
return resultArray;
Ölçümün etkilerini anlama
DumpMachineÖlçümlere daha önce ve sonra durum çıkarmak için işlevlerimizin yerleşimini değiştirelim.
Son işlem kodu şöyle görünmelidir:
operation Perform3QubitQFT() : Result[] {
mutable resultArray = new Result[3];
use qs = Qubit[3];
//QFT:
//first qubit:
H(qs[0]);
Controlled R1([qs[1]], (PI()/2.0, qs[0]));
Controlled R1([qs[2]], (PI()/4.0, qs[0]));
//second qubit:
H(qs[1]);
Controlled R1([qs[2]], (PI()/2.0, qs[1]));
//third qubit:
H(qs[2]);
SWAP(qs[2], qs[0]);
Message("Before measurement: ");
DumpMachine();
for i in IndexRange(qs) {
set resultArray w/= i <- M(qs[i]);
}
Message("After measurement: ");
DumpMachine();
ResetAll(qs);
return resultArray;
}
Komut isteminden çalışıyorsanız, döndürülen dizi yalnızca, çalıştırma sonunda konsola doğrudan görüntülenir. Aksi takdirde, döndürülen diziyi işlemek için ana bilgisayar programınızı güncelleştirin.
Konsolda yazdırılacak döndürülen diziyi daha fazla anlamak için, şu Message Q# deyimden hemen önce dosyaya bir tane ekleyebilirsiniz return :
Message("Post-QFT measurement results [qubit0, qubit1, qubit2]: ");
return resultArray;
Projeyi çalıştırın ve çıktımızda aşağıdakine benzer görünmelidir:
Before measurement:
# wave function for qubits with ids (least to most significant): 0;1;2
|0>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|1>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|2>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|3>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|4>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|5>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|6>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
|7>: 0.353553 + 0.000000 i == *** [ 0.125000 ] --- [ 0.00000 rad ]
After measurement:
# wave function for qubits with ids (least to most significant): 0;1;2
|0>: 0.000000 + 0.000000 i == [ 0.000000 ]
|1>: 0.000000 + 0.000000 i == [ 0.000000 ]
|2>: 0.000000 + 0.000000 i == [ 0.000000 ]
|3>: 1.000000 + 0.000000 i == ******************** [ 1.000000 ] --- [ 0.00000 rad ]
|4>: 0.000000 + 0.000000 i == [ 0.000000 ]
|5>: 0.000000 + 0.000000 i == [ 0.000000 ]
|6>: 0.000000 + 0.000000 i == [ 0.000000 ]
|7>: 0.000000 + 0.000000 i == [ 0.000000 ]
Post-QFT measurement results [qubit0, qubit1, qubit2]:
[One,One,Zero]
Bu çıktı birkaç farklı şeyi gösterir:
- Döndürülen sonucu ön ölçüyle karşılaştıran
DumpMachine, bu durum, temel olarak son olarak QFT üst konumunu göstermez. Ölçüm, sistemin dalga işlevindeki bu durumun genliğini tespit eden bir olasılık ile yalnızca tek bir temel durum döndürür. - Ölçüm sonrası
DumpMachine, ölçümün durumunun kendisini değiştirmekte olduğunu görüyoruz ve bu ölçüyü, ilk üst konumdan temel durumlar üzerinden, ölçülen değere karşılık gelen tek başına duruma yansıdık.
Bu işlemi birçok kez tekrarlamanız durumunda sonuç istatistiklerinin, her bir görüntüsündeki rastgele sonuca artmaya yönelik QFT durumunun eşit ağırlıklı konumunu göstermeye başladığından emin olursunuz. Ancak, verimsiz olmasının yanı sıra yine de, bu, aralarındaki göreli aşamalara göre değil, yalnızca temel durumların göreli bir şekilde yeniden oluşturulmasını ister. İkincisi bu örnekteki bir sorun değildir, ancak QFT 'ye $ \ket $ ' den daha karmaşık bir giriş verildiyse, göreli aşamalar görüntülenir {000} .
Kısmi ölçümler
Kaydın yalnızca bazı qubits 'in sistem durumunu nasıl etkileyebileceğini öğrenmek için, for ölçüm satırından sonra, döngünün içine aşağıdakileri eklemeyi deneyin:
let iString = IntAsString(i);
Message("After measurement of qubit " + iString + ":");
DumpMachine();
Eklemeniz gereken işleve erişmek için IntAsString
open Microsoft.Quantum.Convert;
diğer ad alanı open deyimleriyle.
Sonuçta elde edilen çıktıda, her bir qubit ölçülerek dereceli projeksiyonları alt boşluklara görürsünüz.
Kitaplıkları kullanma Q#
Giriş bölümünde belirtildiği gibi, dünyanın çoğu, Q# bireysel qubits ile ilgilenme dünyadan yararlanın.
Gerçekten de, tam ölçekli, uygun hisse programları geliştirmek istiyorsanız, H belirli bir dönüşten önce veya sonra bir işlemin, yalnızca sizi yavaşlatıp yavaşlamadığını endişelenmeniz gerekir.
Q#Kitaplıklar, herhangi bir sayıda qubit için uygulayabileceğiniz ve uygulayabileceğiniz QFT işlemini içerir.
Denemek için, Q# dosyanızda aynı içeriğe sahip olan Perform3QubitQFT , ancak ilk H SWAP yerine iki kolay satıra sahip olan her şeyi içeren yeni bir işlem tanımlayın:
let register = BigEndian(qs); //from Microsoft.Quantum.Arithmetic
QFT(register); //from Microsoft.Quantum.Canon
İlk satır yalnızca, BigEndian qs QFT işleminin bağımsız değişken olarak aldığı bir qubit dizisinin ayrılmış dizisinin bir ifadesini oluşturur.
Bu, kayıttaki qubits 'in Dizin sıralamasına karşılık gelir.
Bu işlemlere erişebilmek için, open dosyanın başlangıcında ilgili ad alanları için deyimler ekleyin Q# :
open Microsoft.Quantum.Canon;
open Microsoft.Quantum.Arithmetic;
Şimdi, ana bilgisayar programınızı yeni işleminizi (ör.) çağırmak için ayarlayın PerformIntrinsicQFT ve bir yanıt verin.
Kitaplık işlemlerini kullanmanın gerçek avantajını görmek için Q# qubits sayısını şundan farklı bir şekilde değiştirin 3 :
mutable resultArray = new Result[4];
use qs = Qubit[4];
//...
Bu nedenle, H her bir qubit üzerinde yeni işlemler ve döndürmeler hakkında endişelenmenize gerek kalmadan, belirli sayıda qubit için uygun QFT 'leri uygulayabilirsiniz.
Hisse senedi simülatörü, gerçek hisse donanımı için neden ilerletireceğiz kesin olarak---, tam olarak çalışır şekilde daha fazla zaman kaplar!