Aracılığıyla paylaş

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

  • Makale

Bu öğreticide, tek tek kubitler üzerinde çalışan temel bir kuantum programının nasıl yazıldığını ve simülasyonunu nasıl gerçekleştirdiğiniz gösterilir.

Öncelikle büyük ölçekli kuantum programları için ü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 alt 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 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üşümlerinin tamamı, devre olarak aşağıdaki 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 bakı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 sorular sorabilirsiniz.

Önkoşullar

  • Visual Studio Code'un en son sürümü veya Vs Code'un Web'de açılması.

  • Azure Quantum Development Kit uzantısının en son sürümü. Yükleme ayrıntıları için bkz . VS Code'da QDK'yi yükleme.

  • Jupyter Notebooks'u kullanmak istiyorsanız Python ve Jupyter uzantılarını ve en son qsharp Python paketini de yüklemeniz gerekir. Bunu yapmak için bir terminal açın ve aşağıdaki komutu çalıştırın:

    $ pip install --upgrade  qsharp

Yeni Q# dosya oluşturma

  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ımlamaktırQ#. 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 son 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 faydalanması 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 bağımsız değişken almaz ve Python'da C# veya boş bir tanımlama grubu Tuple[()]döndürmeye void benzer bir Unit nesne döndürür. Daha sonra, bir ölçüm sonuçları dizisi döndürmek için işlemi değiştireceksiniz.

Kubitleri ayırma

İşlemin içinde Q# anahtar sözcüğüyle use üç kubitin bir kaydını ayırın. ile use, kubitler 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 kubit Q# 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 denetimli işlemleri uygulama

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

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

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

Bir yazmaçtan belirli bir kubite işlem uygulamak için (örneğin, bir dizideki Qubit[]tek Qubit bir işlem), standart dizin gösterimini kullanın. Bu nedenle, kaydın H ilk kubitine qs işlemi uygulamak ş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ürme 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 Controlledbaşlanır ve 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>))

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

QFT'deki denetlenen işlemler, ilk kubit üzerinde işlem gerçekleştiren (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, döndürmeleri pi radyan açısından tanımlamak için kullanılır.

SWAP işlemi uygulama

İkinci ve üçüncü kubitlere ilgili H işlemleri ve kontrollü 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, devreyi 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 bu gereklidir, bu nedenle değiştirme işlemleri alt düğümün daha büyük algoritmalarla sorunsuz tümleştirilmesine olanak sağlar.

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 açıkça $\ket{0}$ olarak sıfırlanması zorunluluğu, diğer işlemlerin Q#aynı kubitleri (kıt 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 olmamasını sağlar. Ayırma bloğunun use sonunda sıfırlama gerçekleştirilmezse çalışma zamanı hatası oluşturulabilir.

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

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

ResetAll(qs); // deallocate qubits

Tam QFT işlemi

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 devresini ç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 işlemi değiştirerek bir ölçüm sonuçları dizisi (Result[] döndüreceksiniz).

  1. Bir Q# programı çalıştırırken, dosyaya Q# bir EntryPoint 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 Sınırsız 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$-qubit sisteminin olası durumları, her biri ilgili 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 ve her ikili basamağı tek bir kubite karşılık gelen $n$ uzunluğundaki tüm olası ikili dizelere 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ı, temel durum vektörünün ikili gösteriminde $\ket{i}$, kubit 2 durumunun en soldaki basamağı ifade ettiğini gösterir. Örneğin, $\ket{6} = \ket{110}$ kubitleri 2 ve 1 hem $\ket$ hem de $\ket{1}{0}$ içindeki kubitleri 0 içerir.

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

  • |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 grafiksel gösterimi.
  • [ 0.0000 rad ]: Fazın sayısal değeri (radyan cinsinden).

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

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

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

kullanıcısı

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

bu, 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 tavsiye edilir.

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

İşlevden DumpMachine alınan görüntüde işlemin sonuçları gösterildi, 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ı belirtiyor. Bunun yerine, bilgiler ölçümler aracılığıyla ayıklanır ve genel olarak tam kuantum durumu hakkında bilgi sağlanmaz, aynı zamanda sistemin kendisini önemli ölçüde değiştirebilir.

Birçok tür kuantum ölçümü vardır, ancak buradaki örnek en temel ölçümlere odaklanır: tek kubitlerdeki yansıtıcı ölçümler. Belirli bir temelde ölçüldükten 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 tür döndüren Result işlemi kullanınM.

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

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];

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

Döngüde for ölçümler 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]);
}

Bir 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 forM(qs[i]) kullanılır. Ölçülen Result her tür ( Zero veya One) bir update-and-reassign deyimiyle içindeki ilgili dizin konumuna resultArray 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önmek resultArray

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

return resultArray;

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

Şimdi işlevlerin yerleşimini DumpMachine değiştirerek ölçümlerden önceki ve sonraki durumu çıkış olarak belirleyin. 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 koda 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 en altındaki QIR: Temel düğmesine tıklayın ve açılan menüden Sınırsız'ı seçin. target Profil Sınırsız 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çümle DumpMachinekarşılaştırılması, QFT sonrası süper pozisyonu temel durumlara göre açıkça göstermez. Ölçüm, sistemin dalga işlevindeki bu durumun genliği tarafından belirlenen bir olasılıkla yalnızca tek bir temel durum döndürür.
  2. Ölçüm DumpMachinesonrası durumundan ölçümün durumu değiştirdiğini ve bunu temel durumlar üzerinden 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 her çekimde rastgele bir sonuca neden olan QFT sonrası durumunun eşit ağırlıklı süper konumunu göstermeye başladığı görürsünüz. Ancak, verimsiz ve hala kusurlu olmasını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 bir 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 kullanın

Girişte belirtildiği gibi, 'nin gücünün Q#çoğu, bireysel kubitlerle ilgilenme endişelerini soyutlamanıza olanak sağlaması gerçeğinde durmektedir. Aslında, 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 SWAP her şeyi şu şekilde 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 dağınıklığı konusunda endişelenmenize gerek kalmadan, belirli sayıda kubit için uygun QFT'yi uygulayabilirsiniz.

İlgili içerik

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