Share via

Öğretici: Içinde Quantum Fourier Dönüşümünü Uygulama Q#

  • Makale

Not

Microsoft Quantum Development Kit (Klasik QDK) artık 30 Haziran 2024'e kadar desteklenmeyecektir. Mevcut bir QDK geliştiricisiyseniz kuantum çözümleri geliştirmeye devam etmek için yeni Azure'a Quantum Development Kit (Modern QDK) geçmenizi öneririz. Daha fazla bilgi için bkz. Kodunuzu Modern QDK'ye geçirmeQ#.

Bu öğreticide, tek tek kubitler üzerinde çalışan temel bir kuantum programının nasıl yazılıp benzetimini yaptığınız gösterilmektedir.

Büyük ölçekli kuantum programları için öncelikli olarak üst düzey bir programlama dili olarak oluşturulmuş olsa Q# da, kuantum programlamanın alt düzeyini, yani belirli kubitleri doğrudan ele almak için de kullanılabilir. Özellikle, bu öğretici birçok büyük kuantum algoritmasının ayrılmaz bir parçası olan Quantum Fourier Dönüşümü'ne (QFT) daha yakından bakar.

Bu öğreticide aşağıdakilerin nasıl yapılacağını öğreneceksiniz:

  • içinde Q#kuantum işlemlerini tanımlayın.
  • Quantum Fourier Dönüşüm devresini yazma
  • Kubit ayırmadan ölçüm çıkışına kadar kuantum işleminin benzetimini yap.
  • Kuantum sisteminin simülasyon dalga işlevinin işlem boyunca nasıl geliştiğini gözlemleyin.

Not

Kuantum bilgi işlemenin bu alt düzey görünümü genellikle bir sistemin belirli kubitlerine geçitlerin veya işlemlerin sıralı uygulamasını temsil eden kuantum devreleri açısından açıklanmaktadır. Bu nedenle, sırayla uyguladığınız tek ve çok kubitli işlemler devre diyagramlarında kolayca temsil edilebilir. Örneğin, bu öğreticide kullanılan üç kubitli kuantum Fourier dönüşümünün tamamı, devre olarak şu gösterime sahiptir: Quantum Fourier Dönüşüm devresinin diyagramı.

İpucu

Kuantum bilişim yolculuğunuzu hızlandırmak istiyorsanız Azure Quantum web sitesinin benzersiz bir özelliği olan Azure Quantum ile kod bölümüne göz atın. Burada yerleşik Q# örnekleri veya kendi Q# programlarınızı çalıştırabilir, istemlerinizden yeni Q# kod oluşturabilir, kodunuzu tek tıklamayla Web için VS Code'da açıp çalıştırabilir ve Copilot'a kuantum bilişimi hakkında herhangi bir soru sorabilirsiniz.

Önkoşullar

Yeni Q# bir dosya İçerik Oluşturucu

  1. VS Code'da Dosya > Yeni Metin Dosyası'na tıklayın
  2. Dosyayı QFTcircuit.qs olarak kaydedin. Bu dosya, programınızın kodunu içerir Q# .
  3. QFTcircuit.qs dosyasını açın.

içinde QFT bağlantı hattı yazma Q#

Bu öğreticinin ilk bölümü, üç kubit üzerinde kuantum Fourier dönüşümünü gerçekleştiren işlemini Perform3qubitQFTtanımlamaktan Q# oluşur. DumpMachine işlevi, üç kubitli sistemin simülasyon dalga işlevinin işlem genelinde nasıl geliştiğini gözlemlemek için kullanılır. Öğreticinin ikinci bölümünde ölçüm işlevselliği ekleyecek ve kubitlerin ölçüm öncesi ve sonrası durumlarını karşılaştıracaksınız.

İşlemi adım adım oluşturacaksınız. Aşağıdaki bölümlerde yer alan kodu kopyalayıp QFTcircuit.qs dosyasına yapıştırın.

Bu bölümün tam Q# kodunu başvuru olarak görüntüleyebilirsiniz.

Diğer Q# işlemlere erişmek için ad alanları

Dosyanızın Q# içinde, derleyici tarafından erişilen ad alanını NamespaceQFTtanımlayın. Bu işlemin mevcut Q# işlemlerden yararlanması için 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şkenler ve dönüşlerle işlemleri tanımlama

Ardından işlemi tanımlayın Perform3qubitQFT :

operation Perform3qubitQFT() : Unit {
    // do stuff
}

Şimdilik işlem hiçbir bağımsız değişken almaz ve Python'da C# dilinde veya boş bir tanımlama grubunda Tuple[()]döndürmeye void benzer bir nesne döndürürUnit. Daha sonra, bir ölçüm sonuçları dizisi döndürmek için işlemi değiştireceksiniz.

Kubit ayırma

İşlemin içinde Q# , anahtar sözcüğüyle üç kubitin bir yazmaçını use ayırın. ile usekubitler otomatik olarak $\ket{0}$ durumunda ayrılır.

use qs = Qubit[3]; // allocate three qubits

Message("Initial state |000>:");
DumpMachine();

Gerçek kuantum hesaplamalarında olduğu gibi, Q# kubit durumlarına doğrudan erişmenize izin vermez. DumpMachine Ancak, işlem makinenin geçerli durumunu yazdırırtarget, böylece tam durum simülatörüyle birlikte kullanıldığında hata ayıklama ve öğrenme için değerli içgörüler sağlayabilir.

Tek kubitli ve denetlenen işlemleri uygulama

Ardından, işlemin kendisini oluşturan Perform3qubitQFT işlemleri uygularsınız. Q# ad alanında Microsoft.Quantum.Intrinsic bunları ve diğer birçok temel kuantum işlemini zaten içerir.

Uygulanan ilk işlem, ilk kubite (Hadamard) işlemidir H :

İlk Hadamard'a kadar üç kubit QFT bağlantı hattını gösteren diyagram.

Bir yazmaçtan belirli bir kubite (örneğin, bir diziden Qubit[]tek Qubit bir) işlem uygulamak için standart dizin gösterimini kullanın. Bu nedenle, kayıt işleminin Hqs ilk kubitine uygulanması şu şekilde olur:

H(qs[0]);

QFT devresi, işlemi tek tek kubitlere uygulamanın H yanı sıra öncelikli olarak kontrollü R1 döndürmelerden oluşur. Genel olarak bir R1(θ, <qubit>) işlem, $\ket{0}$ bileşenine $e^{i\theta}$ döndürmesi uygularken kubitin $\ket{1}$ bileşenini değiştirmeden bırakır.

Q# bir işlemin çalışmasını bir veya birden çok denetim kubitine göre koşula bağlamayı kolaylaştırır. Genel olarak, çağrısı ile başlanır Controlledve işlem bağımsız değişkenleri aşağıdaki gibi değişir:

Op(<normal args>) $\to$ Controlled Op([<control qubits>], (<normal args>))

Denetim kubiti bağımsız değişkeninin tek bir kubit için olsa bile bir dizi olması gerektiğini unutmayın.

QFT'deki denetlenen işlemler, ilk kubit üzerinde işlem (ve ikinci ve üçüncü kubitler tarafından denetlenen) işlemlerdir R1 :

İlk kubit aracılığıyla üç kubit Quantum Fourier Dönüşümü için bir bağlantı hattını gösteren diyagram.

Dosyanızda Q# bu işlemleri şu deyimlerle çağırarak:

Controlled R1([qs[1]], (PI()/2.0, qs[0]));
Controlled R1([qs[2]], (PI()/4.0, qs[0]));

PI() işlevi, pi radyan cinsinden döndürmeleri tanımlamak için kullanılır.

SWAP işlemi uygulama

İkinci ve üçüncü kubitlere ilgili H işlemleri ve denetimli döndürmeleri uyguladıktan sonra bağlantı hattı şöyle görünür:

//second qubit:
H(qs[1]);
Controlled R1([qs[2]], (PI()/2.0, qs[1]));

//third qubit:
H(qs[2]);

Son olarak, bağlantı hattını tamamlamak için birinci ve üçüncü kubitlere bir SWAP işlem uygularsınız. Kuantum Fourier dönüşümünün doğası kubitleri ters sırada çıkardığından, değiştirme işlemleri alt yordamların daha büyük algoritmalarla sorunsuz bir şekilde tümleştirilmesine olanak sağladığından bu gereklidir.

SWAP(qs[2], qs[0]);

Şimdi kuantum Fourier dönüşümünün kubit düzeyindeki işlemlerini işleminize yazmayı tamamladınız Q# :

Üç kubit Quantum Fourier Dönüşümü için bir bağlantı hattını gösteren diyagram.

Kubitleri serbest bırakma

Son adım, işlem sonrası durumunu görmek ve kubitleri serbest bırakmak için yeniden çağırmaktır DumpMachine() . Kubitleri ayırdığınızda $\ket{0}$ durumundaydı ve işlemi kullanarak ResetAll ilk durumlarına sıfırlanması gerekiyor.

Tüm kubitlerin $\ket{0}$ olarak açıkça sıfırlanması, diğer işlemlerin Q#aynı kubitleri (kıt bir kaynak) kullanmaya başladığında durumlarını tam olarak bilmesini sağladığından temel bir özelliğidir. Ayrıca bu, sistemdeki diğer kubitlerle dolanık olmadıklarını da garanti eder. Sıfırlama bir use ayırma bloğunun sonunda gerçekleştirilmezse, bir çalışma zamanı hatası oluşturulabilir.

Dosyanıza Q# aşağıdaki satırları ekleyin:

Message("After:");
DumpMachine();

ResetAll(qs); // deallocate qubits

QFT işleminin tamamı

Program Q# tamamlandı. QFTcircuit.qs 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]; // allocate three qubits

        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); // deallocate qubits

    }
}

QFT bağlantı hattını çalıştırma

Şimdilik işlem Perform3qubitQFT herhangi bir değer döndürmez, işlem değer döndürür Unit . Daha sonra, bir ölçüm sonuçları dizisi (Result[] döndürecek şekilde işlemi değiştireceksiniz.

  1. Bir Q# programı çalıştırırken dosyaya bir EntryPointQ# eklemeniz gerekir. Bu öznitelik, derleyiciye bu işlemin programın giriş noktası olduğunu bildirir. İşlemden önce Perform3qubitQFT dosyanızın Q# en üstüne aşağıdaki satırı ekleyin:

    @EntryPoint()
operation Perform3qubitQFT() : Unit {

  2. Programı çalıştırmadan önce profili Sınırsız olarak ayarlamanız target gerekir. Görünüm -> Komut Paleti'ni seçin, QIR'yi arayın, öğesini seçinQ#: Azure Quantum QIR target profilini ayarlayın ve ardından : sınırsız'ı seçinQ#.

  3. Programınızı çalıştırmak için sağ üstteki yürütme simgesi açılan listesinden Dosyayı Çalıştır'ı Q# seçin veya Ctrl+F5 tuşlarına basın. Program, varsayılan simülatörde @EntryPoint() özniteliğiyle işaretlenmiş işlemi veya işlevi çalıştırır.

  4. Message ve DumpMachine çıkışları hata ayıklama konsolunda görünür.

Not

target Profil Kısıtlanmamış olarak ayarlanmamışsa, programı çalıştırdığınızda bir hata alırsınız.

QFT bağlantı hattının çıkışını anlama

Tam durum simülatöründe çağrıldığında, DumpMachine() kuantum durumunun dalga işlevinin bu birden çok gösterimini sağlar. bir $n$-kubit sisteminin olası durumları, her biri karşılık gelen karmaşık katsayıya (genlik ve faz) sahip $2^n$ hesaplama temel durumları ile temsil edilebilir. Hesaplama temel durumları, $\ket$ ve $\ket{0}{1}$ kubit durumlarının olası tüm birleşimleri olan $n$ uzunluğundaki tüm olası ikili dizelere karşılık gelir ve burada her ikili rakam tek bir kubite karşılık gelir.

İlk satır, ilgili kubitlerin kimliklerini önemli sırasıyla içeren bir açıklama sağlar. Kubitin 2 "en önemli" olması, $\ket{i}$ temel durum vektörünün ikili gösteriminde kubitin 2 durumunun en soldaki rakama karşılık geldiğini gösterir. Örneğin, $\ket{6} = \ket{110}$ kubitleri 2 ve 1 $\ket$ içinde hem de $\ket{1}{0}$ içindeki kubitleri 0 içerir.

Satırların geri kalanı, hem Kartezyen hem de kutupsal biçimlerde $\ket{i}$ temel durum vektörünün ölçülme olasılığının genliğini açıklar. $\ket{000}$ giriş durumu için ilk satır incelenerek:

  • |0>: Bu satır, hesaplama temeli durumuna karşılık gelir 0 (ilk ayırma sonrası durumunun $\ket{000}$ olduğu düşünüldüğünde, bu noktada olasılık genliği olan tek durum olması beklenir).
  • 1.000000 + 0.000000 i: Kartezyen biçimindeki olasılık genliği.
  • ==: işareti her equal iki eşdeğer gösterimi de ayırır.
  • ********************: Büyüklüğün grafiksel gösterimi. sayısı * , bu durum vektörünün ölçülme olasılığıyla orantılıdır.
  • [ 1.000000 ]: Büyüklüğün sayısal değeri.
  • ---: Genlik fazının grafik gösterimi.
  • [ 0.0000 rad ]: Fazın sayısal değeri (radyan cinsinden).

Hem büyüklük hem de aşama grafik bir gösterimle görüntülenir. Büyük gösterim basittir: bir çubuk * gösterir ve olasılık ne kadar yüksek olursa çubuk o kadar uzun olur.

Görüntülenen çıkış, programlanmış işlemlerin durumu

$$ \ket{\psi}_{initial} = \ket{000} $$

kullanıcısı

$$ \begin{align} \ket{\psi}_{final} &= \frac{1}{\sqrt{8}} \left( \ket{000} + \ket + \ket{010}{001} + \ket{011} + \ket + \ket + \ket{101}{100} ket{110} + \ket{111} \right) \\ &= \frac{1}{\sqrt{2^n}}\sum_{j=0}^{2^n-1} \ket{j}, \end{align} $$

bu da tam olarak üç kubitli Fourier dönüşümünün davranışıdır.

Diğer giriş durumlarının nasıl etkilendiğini merak ediyorsanız, dönüştürmeden önce diğer kubit işlemlerini uygulamayı denemeniz teşvik edilir.

QFT bağlantı hattına ölçüm ekleme

işlevinin DumpMachine görüntüsü işlemin sonuçlarını gösterdi, ancak ne yazık ki kuantum mekaniğinin bir köşe taşı, gerçek bir kuantum sisteminin böyle bir DumpMachine işleve sahip olamayacağını belirtir. Bunun yerine, bilgiler ölçümler aracılığıyla ayıklanır ve bu ölçümler genel olarak yalnızca tam kuantum durumu hakkında bilgi sağlayamaz, aynı zamanda sistemin kendisini önemli ölçüde değiştirebilir.

Birçok kuantum ölçümü türü vardır, ancak buradaki örnek en temele odaklanır: tek kubitlerde yansıtıcı ölçümler. Belirli bir temelde ölçüm yapıldıktan sonra (örneğin, hesaplama temeli $ { \ket{0}, \ket{1} } $), kubit durumu ölçülen temel duruma yansıtılır ve bu nedenle ikisi arasındaki süper konum yok edilir.

QFT işlemini değiştirme

Bir Q# program içinde ölçümler uygulamak için, bir Result tür döndüren işlemini kullanınM.

İlk olarak, işlemi değiştirerek yerine bir ölçü sonuçları Result[]Unitdizisi döndürebilirsinizPerform3QubitQFT.

operation Perform3QubitQFT() : Result[] {

Dizi tanımlama ve başlatma Result[]

Kubitleri ayırmadan önce üç öğeli bir dizi (her kubit için bir tane Result ) bildirin ve bağlayın:

mutable resultArray = [Zero, size = 3];

Anahtar mutable sözcük önceden tanımlama resultArray , değişkenin kodda daha sonra değiştirilmesini sağlar, örneğin ölçüm sonuçlarınızı eklerken.

Döngüde for ölçüm yapma ve diziye sonuç ekleme

QFT dönüştürme işlemlerden sonra aşağıdaki kodu ekleyin:

for i in IndexRange(qs) {
    set resultArray w/= i <- M(qs[i]);
}

IndexRange Dizide çağrılan işlev (örneğin, kubit dizisi), qsdizinin dizinleri üzerinde bir aralık döndürür. Burada, deyimini kullanarak her kubiti sıralı olarak ölçmek için döngüde M(qs[i]) kullanılırfor. Ölçülen Result her tür ( Zero veya One) içinde karşılık gelen dizin konumuna resultArray bir update-and-reassign deyimiyle eklenir.

Not

Bu deyimin söz dizimi için Q#benzersizdir, ancak F# ve R gibi diğer dillerde görülen benzer değişken yeniden atamasına resultArray[i] <- M(qs[i]) karşılık gelir.

anahtar sözcüğü set her zaman kullanarak mutablebağlı değişkenleri yeniden atamak için kullanılır.

Dönüş resultArray

Üç kubitin de ölçülmüş olması ve sonuçların resultArrayöğesine eklenmesiyle, kubitleri daha önce olduğu gibi sıfırlayabilir ve serbest bırakabilirsiniz. Ölçümleri döndürmek için şunu ekleyin:

return resultArray;

QFT devresini ölçümlerle çalıştırma

Şimdi ölçülerden DumpMachine önceki ve sonraki durumu çıkarmak için işlevlerin yerleşimini değiştirin. Son Q# kodunuz ş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() : Result[] {

        mutable resultArray = [Zero, size = 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);
        Message("Post-QFT measurement results [qubit0, qubit1, qubit2]: ");
        return resultArray;

    }
}

İpucu

Yeniden çalıştırmadan önce kodda her değişiklik eklediğinizde dosyanızı kaydetmeyi unutmayın.

  1. İşlemden Perform3qubitQFT önce bir EntryPoint ekleyin:

    @EntryPoint()
operation Perform3qubitQFT() : Unit {

  2. target Profili Sınırsız olarak ayarlayın. VS Code penceresinin alt kısmındaki QIR: Temel düğmesine tıklayın ve açılan menüden Sınırsız'ı seçin. target Profil Kısıtlanmamış olarak ayarlanmamışsa, programı çalıştırdığınızda bir hata alırsınız.

  3. Programınızı çalıştırmak için sağ üstteki yürütme simgesi açılan listesinden Dosyayı çalıştır'ı Q# seçin veya Ctrl+5 tuşlarına basın. Program, varsayılan simülatörde @EntryPoint() özniteliğiyle işaretlenmiş işlemi veya işlevi çalıştırır.

  4. Message ve DumpMachine çıkışları hata ayıklama konsolunda görünür.

Çıkışınız çıkışa 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 çıkış birkaç farklı şeyi gösterir:

  1. Döndürülen sonucun ön ölçüm DumpMachineile karşılaştırılması, QFT sonrası süper pozisyonu temel durumlara göre açıkça göstermez. Ölçüm, sistemin dalga işlevindeki o durumun genliği tarafından belirlenen bir olasılıkla yalnızca tek bir temel durum döndürür.
  2. Ölçüm DumpMachinesonrasında ölçümün durumu değiştirdiğini ve bunu temel durumlar üzerindeki ilk süper pozisyondan ölçülen değere karşılık gelen tek temel duruma yansıttığını görürsünüz.

Bu işlemi birçok kez tekrarlarsanız, sonuç istatistiklerinin QFT sonrası durumunun her çekimde rastgele bir sonuca neden olan eşit ağırlıklı süper konumunu göstermeye başlayacağını görürsünüz. Ancak, verimsiz ve hala kusurlu olmanın yanı sıra, bu yine de aralarındaki göreli aşamaları değil, yalnızca temel durumların göreli genliklerini yeniden üretir. İkincisi bu örnekte sorun değildir, ancak QFT'ye $\ket{000}$ değerinden daha karmaşık bir giriş verildiğinde göreli aşamaların göründüğünü görürsünüz.

QFT devresini Q# basitleştirmek için işlemleri kullanma

Giriş bölümünde belirtildiği gibi, güçlerinin büyük bölümü Q#, bireysel kubitlerle ilgilenme endişelerini soyutlamanıza olanak sağlaması gerçeğinden bağımsızdır. Gerçekten de, tam ölçekli, geçerli kuantum programları geliştirmek istiyorsanız, bir işlemin belirli bir H döndürmeden önce mi yoksa sonra mı geçeceği konusunda endişelenmeniz sizi yalnızca yavaşlatır.

Ad Q# alanı Microsoft.Quantum.Canon , istediğiniz sayıda kubit için kullanabileceğiniz ve uygulayabileceğiniz işlemi içerir ApplyQFT .

  1. İşleme erişmek ApplyQFT için Microsoft.Quantum.Canon dosyanın başına ad alanının deyimini Q# ekleyinopen:

    open Microsoft.Quantum.Canon;

  2. İlkinden H değiştirilene kadar olan her şeyi şununla SWAP değiştirin:

    ApplyQFT(qs);

  3. Q# Programı yeniden çalıştırın ve çıkışın öncekiyle aynı olduğuna dikkat edin.

  4. İşlemleri kullanmanın Q# gerçek avantajını görmek için kubit sayısını dışında 3bir şeyle değiştirin:

mutable resultArray = [Zero, size = 4];

use qs = Qubit[4];
//...

Böylece, her kubitte yeni H işlemlerin ve döndürmelerin karmaşıklığı konusunda endişelenmenize gerek kalmadan, belirli sayıda kubit için uygun QFT'yi uygulayabilirsiniz.

Sonraki adımlar

Diğer Q# öğreticileri keşfedin: