Tutorial: Menerapkan Transformasi Quantum Fourier di Q#

Artikel
01/13/2024

Catatan

Microsoft Quantum Development Kit (QDK Klasik) tidak akan lagi didukung setelah 30 Juni 2024. Jika Anda adalah pengembang QDK yang sudah ada, kami sarankan Anda beralih ke Azure Quantum Development Kit baru (Modern QDK) untuk terus mengembangkan solusi kuantum. Untuk informasi selengkapnya, lihat Memigrasikan kode Anda Q# ke QDK Modern.

Tutorial ini menunjukkan cara menulis dan mensimulasikan program kuantum dasar yang beroperasi pada qubit individu.

Meskipun Q# terutama dibuat sebagai bahasa pemrograman tingkat tinggi untuk program kuantum skala besar, itu juga dapat digunakan untuk menjelajahi tingkat yang lebih rendah dari pemrograman kuantum, yaitu, secara langsung menangani qubit tertentu. Secara khusus, tutorial ini melihat lebih dekat pada Quantum Fourier Transform (QFT), subroutine yang merupakan integral dari banyak algoritma kuantum yang lebih besar.

Dalam tutorial ini, Anda akan mempelajari cara:

Tentukan operasi kuantum di Q#.
Menulis sirkuit Quantum Fourier Transform
Simulasikan operasi kuantum dari alokasi kubit hingga output pengukuran.
Amati bagaimana sistem kuantum simulasi wavefunction berevolusi sepanjang operasi.

Catatan

Tampilan tingkat yang lebih rendah dari pemrosesan informasi kuantum ini sering dijelaskan dalam hal sirkuit kuantum, yang mewakili aplikasi berurutan gerbang, atau operasi, untuk qubit tertentu dari suatu sistem. Dengan demikian, operasi tunggal dan multi-qubit yang Anda terapkan secara berurutan dapat dengan mudah diwakili dalam diagram sirkuit. Misalnya, transformasi fourier kuantum tiga kuantum lengkap yang digunakan dalam tutorial ini memiliki representasi berikut sebagai sirkuit: Diagram sirkuit Quantum Fourier Transform.

Tip

Jika Anda ingin mempercepat perjalanan komputasi kuantum Anda, lihat Kode dengan Azure Quantum, fitur unik situs web Azure Quantum. Di sini, Anda dapat menjalankan sampel bawaan Q# atau program Anda sendiri Q# , menghasilkan kode baru Q# dari perintah Anda, membuka dan menjalankan kode Anda di Visual Studio Code untuk Web dengan satu klik, dan mengajukan pertanyaan apa pun tentang komputasi kuantum.

Prasyarat

Versi terbaru Visual Studio Code atau membuka Visual Studio Code di Web.
Versi terbaru ekstensi Azure Quantum Development Kit . Untuk detail penginstalan, lihat Menginstal QDK Modern di Visual Studio Code.
Jika Anda ingin menggunakan Jupyter Notebooks, Anda juga perlu menginstal ekstensi Python, dan Jupyter , dan paket Python terbaru qsharp . Untuk melakukannya, buka terminal dan jalankan perintah berikut:
```
$ pip install --upgrade  qsharp
```

Create file baru Q#

Di Visual Studio Code, pilih File > Teks Baru
Simpan file sebagai QFTcircuit.qs. File ini akan berisi Q# kode untuk program Anda.
Buka QFTcircuit.qs.

Menulis sirkuit QFT di Q#

Bagian pertama dari tutorial ini terdiri dari mendefinisikan Q# operasi Perform3qubitQFT, yang melakukan transformasi Fourier kuantum pada tiga qubit. Fungsi ini DumpMachine digunakan untuk mengamati bagaimana simulasi fungsi gelombang dari sistem tiga-qubit berkembang di seluruh operasi. Di bagian kedua tutorial, Anda akan menambahkan fungsionalitas pengukuran dan membandingkan status qubit sebelum dan sesudah pengukuran.

Anda akan membangun operasi selangkah demi selangkah. Salin dan tempel kode di bagian berikut ke dalam file QFTcircuit.qs .

Anda dapat melihat kode lengkap Q# untuk bagian ini sebagai referensi.

Namespaces layanan untuk mengakses operasi Q#lain

Di dalam file Q# Anda, tentukan namespace layanan NamespaceQFT, yang diakses oleh kompiler. Agar operasi ini dapat memanfaatkan operasi Q# yang ada, buka ruang nama layanan Microsoft.Quantum.*yang relevan.

namespace NamespaceQFT {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Diagnostics;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Arrays;

    // operations go here
}

Menentukan operasi dengan argumen dan pengembalian

Selanjutnya, tentukan operasi Perform3qubitQFT:

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

Untuk saat ini, operasi tidak mengambil argumen dan mengembalikan objek Unit yang analog dengan untuk mengembalikan void di C # atau tupel kosong, Tuple[()], dalam Python. Nanti, Anda akan memodifikasi operasi untuk mengembalikan larik hasil pengukuran.

Alokasikan qubit

Q# Dalam operasi, alokasikan register tiga qubit dengan use kata kunci . Dengan use, qubit secara otomatis dialokasikan dalam status $\ket{0}$.

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

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

Seperti dalam perhitungan kuantum nyata, Q# tidak memungkinkan Anda untuk langsung mengakses status qubit. Namun, DumpMachine operasi mencetak status target komputer saat ini, sehingga dapat memberikan wawasan berharga untuk penelusuran kesalahan dan pembelajaran ketika digunakan bersama dengan simulator status penuh.

Menerapkan operasi qubit tunggal dan terkontrol

Selanjutnya, Anda menerapkan operasi yang terdiri dari operasi itu Perform3qubitQFT sendiri. Q# sudah berisi ini dan banyak operasi kuantum dasar lainnya di namespace layanan Microsoft.Quantum.Intrinsic.

Operasi pertama yang diterapkan adalah H operasi (Hadamard) ke qubit pertama:

Diagram memperlihatkan sirkuit untuk tiga QFT qubit melalui Hadamard pertama.

Untuk menerapkan operasi ke qubit tertentu dari register (misalnya, satu Qubit dari array Qubit[]), gunakan notasi indeks standar. Jadi, menerapkan operasi H ke qubit pertama register qs mengambil formulir:

H(qs[0]);

Selain menerapkan operasi H untuk qubit individu, sirkuit QFT terutama terdiri dari kontrol R1. R1(θ, <qubit>) Operasi secara umum membuat komponen $\ket{0}$ dari kubit tidak berubah saat menerapkan rotasi $e^{i\theta}$ ke komponen $\ket{1}$.

Q# membuatnya mudah untuk mengkondisikan operasi pada satu, atau beberapa, qubit kontrol. Secara umum, panggilan diawali dengan Controlled, dan argumen operasi berubah sebagai berikut:

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

Perhatikan bahwa argumen qubit kontrol harus berupa array, meskipun untuk satu qubit.

Operasi terkontrol dalam QFT adalah R1 operasi yang bertindak pada kubit pertama (dan dikendalikan oleh kubit kedua dan ketiga):

Diagram memperlihatkan sirkuit untuk tiga qubit Quantum Fourier Transform melalui kubit pertama.

Dalam file Q# Anda, hubungi operasi ini dengan pernyataan ini:

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

Fungsi PI() ini digunakan untuk menentukan rotasi dalam hal pi radian.

Menerapkan operasi SWAP

Setelah menerapkan operasi yang relevan H dan rotasi terkontrol ke qubit kedua dan ketiga, sirkuit terlihat seperti ini:

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

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

Terakhir, Anda menerapkan SWAP operasi ke qubit pertama dan ketiga untuk menyelesaikan sirkuit. Ini diperlukan karena sifat transformasi Fourier kuantum menghasilkan qubit dalam urutan terbalik, sehingga swap memungkinkan integrasi subrutin tanpa batas ke dalam algoritma yang lebih besar.

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

Sekarang Anda telah selesai menulis operasi tingkat qubit dari Fourier kuantum fransformasi menjadi operasi Q# Anda :

Diagram memperlihatkan sirkuit untuk tiga qubit Quantum Fourier Transform.

Membatalkan alokasi qubits

Langkah terakhir adalah memanggil DumpMachine() lagi untuk melihat keadaan pasca operasi, dan untuk membatalkan alokasi qubit. Qubit berada dalam keadaan $\ket{0}$ ketika Anda mengalokasikannya dan perlu diatur ulang ke keadaan awal mereka menggunakan operasi ResetAll.

Mengharuskan semua qubit diatur ulang secara eksplisit ke $\ket{0}$ adalah fitur dasar dari Q#, karena memungkinkan operasi lain untuk mengetahui statusnya dengan tepat ketika mereka mulai menggunakan qubit yang sama (sumber daya yang langka). Selain itu, ini memastikan bahwa mereka tidak terjerat dengan qubit lain dalam sistem. Jika reset tidak dilakukan di akhir blok alokasiuse, kesalahan runtime bahasa umum mungkin akan dilemparkan.

Tambahkan baris berikut ke file Q# Anda :

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

ResetAll(qs); // deallocate qubits

Operasi QFT lengkap

Program Q# selesai. File QFTcircuit.qs Anda sekarang akan terlihat seperti ini:

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

    }
}

Menjalankan sirkuit QFT

Untuk saat ini, Perform3qubitQFT operasi tidak mengembalikan nilai apa pun - operasi mengembalikan Unit nilai. Nantinya, Anda akan memodifikasi operasi untuk mengembalikan array hasil pengukuran (Result[]).

Q# program mandiri
Jupyter Notebook

Saat menjalankan Q# program, Anda perlu menambahkan EntryPoint ke Q# file. Atribut ini memberi tahu pengkompilasi bahwa operasi ini adalah titik masuk ke program. Tambahkan baris berikut ke bagian atas file Anda Q# sebelum Perform3qubitQFT operasi :
```
@EntryPoint()
operation Perform3qubitQFT() : Unit {
```
Sebelum menjalankan program, Anda perlu mengatur profil ke targetTidak Dibatasi. Pilih Lihat -> Palet Perintah, cari QIR, pilih Q#: Atur profil QIR target Azure Quantum, lalu pilih Q#: tidak dibatasi.
Untuk menjalankan program Anda, pilih Jalankan Q# File dari menu drop-down ikon putar di kanan atas, atau tekan Ctrl+F5. Program menjalankan operasi atau fungsi yang ditandai dengan @EntryPoint() atribut pada simulator default.
Output Message dan DumpMachine muncul di konsol debug.

Catatan

target Jika profil tidak diatur ke Tidak Dibatasi, Anda akan mendapatkan kesalahan saat menjalankan program.

Di Visual Studio Code, pilih Tampilkan > Palet perintah dan pilih Create: Jupyter Notebook Baru.
Di sel pertama, impor qsharp paket dalam kode Python Anda:
```
import qsharp
```

Q# Tambahkan program dengan Perform3qubitQFT operasi. Untuk melakukannya, Anda menggunakan %%qhsarp perintah ajaib. Perhatikan bahwa %%qsharp perintah mengubah sel buku catatan dari jenis Python menjadi jenis Q#. Salin kode ini ke sel kedua.

%%qsharp
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

}

Terakhir, jalankan kode. Anda dapat menjalankan simulasi yang sama beberapa kali, secara independen. Setiap simulasi independen disebut "bidikan". Misalnya, mari kita jalankan simulasi, 10 kali.
```
results = qsharp.run("Perform3qubitQFT()", shots=10)
print(results)
```

Memahami output sirkuit QFT

Ketika dipanggil pada simulator keadaan lengkap, DumpMachine() menyediakan beberapa representasi dari fungsi gelombang keadaan kuantum. Keadaan yang mungkin dari sistem $n$-qubit dapat diwakili oleh keadaan dasar komputasi $2^n$, masing-masing dengan koefisien kompleks yang sesuai (amplitudo dan fase). Keadaan dasar komputasi sesuai dengan semua kemungkinan untai biner panjang $n$, yaitu, semua kemungkinan kombinasi qubit menyatakan $\ket{0}$ dan $\ket{1}$, setiap digit biner sesuai dengan qubit individu.

Baris pertama memberikan komentar dengan ID qubit yang sesuai dalam urutan signifikannya. Qubit 2 menjadi "yang paling signifikan" berarti bahwa dalam representasi biner vektor keadaan dasar $\ket{i}$, keadaan qubit 2 sesuai dengan digit paling kiri. Misalnya, $\ket{6} = \ket{110}$ terdiri dari qubit 2 dan 1 keduanya dalam $\ket{1}$ dan qubit 0 dalam $\ket{0}$.

Baris selanjutnya menggambarkan amplitudo peluang pengukuran vektor keadaan dasar $\ket{i}$ dalam format Cartesian dan kutub. Memeriksa baris pertama untuk status input $\ket{000}$:

|0>: Baris ini sesuai dengan 0 keadaan dasar komputasi (mengingat bahwa keadaan awal pasca-alokasi adalah $\ket{000}$, ini diharapkan menjadi satu-satunya keadaan dengan amplitudo peluang pada saat ini).
1.000000 + 0.000000 i: Amplitudo peluang dalam format Cartesian.
==: tanda equal memisahkan kedua representasi yang setara.
********************: Representasi grafis dari besarnya. Jumlah * sebanding dengan peluang mengukur vektor keadaan ini.
[ 1.000000 ]: Nilai numerik dari besarnya.
---: Representasi grafis dari fase amplitudo.
[ 0.0000 rad ]: Nilai numerik dari fase (dalam radian).

Baik besaran maupun fase ditampilkan dengan representasi grafis. Representasi besarnya mudah: ini menunjukkan batang * dan semakin tinggi peluang, semakin lama barnya.

Output yang ditampilkan menggambarkan bahwa operasi terprogram mengubah status dari

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

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

yang justru perilaku transformasi Fourier tiga qubit.

Jika Anda ingin tahu tentang bagaimana status input lainnya terpengaruh, Anda dianjurkan untuk bereksperimen dengan menerapkan operasi qubit lain sebelum transformasi.

Menambahkan pengukuran ke sirkuit QFT

Tampilan dari fungsi DumpMachine menunjukkan hasil operasi, tetapi sayangnya, landasan mekanika kuantum menyatakan bahwa sistem kuantum nyata tidak dapat memiliki seperti fungsi DumpMachine itu. Sebaliknya, informasi diekstraksi melalui pengukuran, yang secara umum tidak hanya gagal memberikan informasi tentang keadaan kuantum penuh, tetapi juga dapat secara drastis mengubah sistem itu sendiri.

Ada banyak jenis pengukuran kuantum, tetapi contoh di sini berfokus pada yang paling mendasar: pengukuran proyektif pada qubit tunggal. Setelah pengukuran dalam basis tertentu (misalnya, basis komputasi $ { \ket{0}, \ket{1} } $), keadaan qubit diproyeksikan ke keadaan dasar mana pun yang diukur, sehingga menghancurkan superposisi apa pun di antara keduanya.

Mengubah operasi QFT

Untuk menerapkan pengukuran dalam suatu program Q#, gunakan operasi M, yang mengembalikan jenis Result.

Pertama, memodifikasi operasi Perform3QubitQFT untuk mengembalikan array hasil pengukuran, Result[], bukan Unit.

operation Perform3QubitQFT() : Result[] {

Menentukan dan menginisialisasi array `Result[]`

Sebelum mengalokasikan qubit, deklarasikan dan ikat array tiga elemen (satu Result untuk setiap qubit):

mutable resultArray = [Zero, size = 3];

Kata kunci kata pengantar mutableresultArray memungkinkan variabel untuk dimodifikasi nanti dalam kode, misalnya, saat menambahkan hasil pengukuran Anda.

Melakukan pengukuran dalam satu perulangan `for` dan menambahkan hasil ke array

Setelah operasi transformasi QFT, masukkan kode berikut:

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

Fungsi IndexRange yang dipanggil pada array (misalnya, array qubit, qs) mengembalikan rentang atas indeks array. Di sini, digunakan dalam perulangan for untuk mengukur setiap qubit secara berurutan menggunakan pernyataan M(qs[i]). Setiap jenis Result yang diukur (baik Zero atau One) kemudian ditambahkan ke posisi indeks dalam resultArray yang sesuai dengan pernyataan pembaruan dan penetapan ulang.

Catatan

Sintaks pernyataan ini unik untuk Q#, tetapi sesuai dengan penugasan ulang variabel serupa yang resultArray[i] <- M(qs[i]) terlihat dalam bahasa lain seperti F # dan R.

Kata kunci set selalu digunakan untuk menetapkan kembali variabel yang terikat menggunakan mutable.

Mengembalikan `resultArray`

Dengan ketiga qubit diukur dan hasilnya ditambahkan ke resultArray, Anda aman untuk mengatur ulang dan batal alokasi qubit seperti sebelumnya. Untuk mengembalikan pengukuran, masukkan:

return resultArray;

Jalankan sirkuit QFT dengan pengukuran

Sekarang ubah penempatan fungsi DumpMachine untuk mengeluarkan status sebelum dan sesudah pengukuran. Kode Q# terakhir Anda akan terlihat seperti ini:

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;

    }
}

Tip

Ingat untuk menyimpan file Anda setiap kali Anda memperkenalkan perubahan pada kode sebelum menjalankannya lagi.

Q# program mandiri
Jupyter Notebook

EntryPoint Tambahkan sebelum Perform3qubitQFT operasi :

@EntryPoint()
operation Perform3qubitQFT() : Unit {

Atur profil ke targetTidak Dibatasi. Klik tombol QIR: Base di bagian bawah jendela Visual Studio Code dan pilih Tidak Dibatasi dari menu dropdown. target Jika profil tidak diatur ke Tidak Dibatasi, Anda akan mendapatkan kesalahan saat menjalankan program.
Untuk menjalankan program Anda, pilih Jalankan Q# file dari menu drop-down ikon putar di kanan atas, atau tekan Ctrl+5. Program menjalankan operasi atau fungsi yang ditandai dengan @EntryPoint() atribut pada simulator default.
Output Message dan DumpMachine muncul di konsol debug.

Output Anda akan terlihat mirip dengan output:

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]

Perbarui sel dengan Q# program untuk mengembalikan hasil pengukuran. Untuk melakukannya, salin kode berikut ke dalam sel kedua:

%%qsharp

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;

}

Jalankan kodenya.

results = qsharp.run("Perform3QubitQFT()", shots=10)
print(results)

Output ini menggambarkan beberapa hal yang berbeda:

Membandingkan hasil yang dikembalikan dengan pengukuran sebelumnya DumpMachine, jelas tidak menggambarkan superposisi pasca-QFT atas keadaan dasar. Pengukuran hanya mengembalikan keadaan dasar tunggal, dengan peluang ditentukan oleh amplitudo keadaan itu dalam fungsi gelombang sistem.
Dari pasca-pengukuran DumpMachine, Anda melihat bahwa pengukuran mengubah keadaan itu sendiri, memproyeksikannya dari superposisi awal atas status dasar ke keadaan dasar tunggal yang sesuai dengan nilai yang diukur.

Jika Anda mengulangi operasi ini berkali-kali, Anda akan melihat statistik hasil mulai menggambarkan superposisi berbobot sama dari status pasca-QFT yang memunculkan hasil acak pada setiap tembakan. Namun, selain tidak efisien dan masih tidak sempurna, ini hanya akan mereproduksi amplitudo relatif dari keadaan dasar, bukan fase relatif di antara mereka. Yang terakhir tidak menjadi masalah dalam contoh ini, tetapi Anda akan melihat fase relatif muncul jika diberikan input yang lebih kompleks ke QFT daripada $\ket{000}$.

Q# Gunakan operasi untuk menyederhanakan sirkuit QFT

Seperti disebutkan dalam pendahuluan, sebagian besar kekuatan Q# terletak pada kenyataan bahwa itu memungkinkan Anda untuk mengabstraksikan kekhawatiran berurusan dengan qubit individu. Memang, jika Anda ingin mengembangkan skala penuh, program kuantum yang berlaku, khawatir tentang apakah operasi H berjalan sebelum atau setelah rotasi tertentu hanya akan memperlambat Anda.

Namespace Q#Microsoft.Quantum.Canon berisi ApplyQFT operasi , yang dapat Anda gunakan dan terapkan untuk sejumlah qubit.

Untuk mengakses ApplyQFT operasi, tambahkan open pernyataan untuk Microsoft.Quantum.Canon namespace di awal Q# file:
```
open Microsoft.Quantum.Canon;
```
Ganti semuanya dari yang pertama H hingga diganti SWAP dengan:
```
ApplyQFT(qs);
```
Jalankan Q# program lagi dan perhatikan bahwa outputnya sama seperti sebelumnya.
Untuk melihat manfaat nyata menggunakan Q# operasi, ubah jumlah kubit menjadi sesuatu selain 3:

mutable resultArray = [Zero, size = 4];

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

Dengan demikian, Anda dapat menerapkan QFT yang tepat untuk sejumlah qubit tertentu, tanpa harus khawatir tentang kekacauan operasi H yang baru dan rotasi pada setiap qubit.

Langkah berikutnya

Jelajahi tutorial Q# lainnya:

Generator angka acak kuantum menunjukkan cara menulis Q# program yang menghasilkan angka acak dari qubit dalam superposisi.
Algoritma pencarian Grover menunjukkan cara menulis Q# program yang menggunakan algoritma pencarian Grover.
Entanglemen kuantum menunjukkan cara menulis Q# program yang memanipulasi dan mengukur qubit dan menunjukkan efek superposisi dan entanglemen.
Quantum Katas adalah tutorial dan latihan pemrograman mandiri yang bertujuan untuk mengajarkan elemen komputasi dan Q# pemrograman kuantum secara bersamaan.

Tutorial: Menerapkan Transformasi Quantum Fourier di Q#

Prasyarat

Create file baru Q#

Menulis sirkuit QFT di Q#

Namespaces layanan untuk mengakses operasi Q#lain

Menentukan operasi dengan argumen dan pengembalian

Alokasikan qubit

Menerapkan operasi qubit tunggal dan terkontrol

Menerapkan operasi SWAP

Membatalkan alokasi qubits

Operasi QFT lengkap

Menjalankan sirkuit QFT

Memahami output sirkuit QFT

Menambahkan pengukuran ke sirkuit QFT

Mengubah operasi QFT

Menentukan dan menginisialisasi array `Result[]`

Melakukan pengukuran dalam satu perulangan `for` dan menambahkan hasil ke array

Mengembalikan `resultArray`

Jalankan sirkuit QFT dengan pengukuran

Q# Gunakan operasi untuk menyederhanakan sirkuit QFT

Langkah berikutnya

Saran dan Komentar

Saran dan Komentar

Sumber Daya Tambahan:

Tutorial: Menerapkan Transformasi Quantum Fourier di Q#

Prasyarat

Create file baru Q#

Menulis sirkuit QFT di Q#

Namespaces layanan untuk mengakses operasi Q#lain

Menentukan operasi dengan argumen dan pengembalian

Alokasikan qubit

Menerapkan operasi qubit tunggal dan terkontrol

Menerapkan operasi SWAP

Membatalkan alokasi qubits

Operasi QFT lengkap

Menjalankan sirkuit QFT

Memahami output sirkuit QFT

Menambahkan pengukuran ke sirkuit QFT

Mengubah operasi QFT

Menentukan dan menginisialisasi array Result[]

Melakukan pengukuran dalam satu perulangan for dan menambahkan hasil ke array

Mengembalikan resultArray

Jalankan sirkuit QFT dengan pengukuran

Q# Gunakan operasi untuk menyederhanakan sirkuit QFT

Langkah berikutnya

Saran dan Komentar

Saran dan Komentar

Sumber Daya Tambahan:

Menentukan dan menginisialisasi array `Result[]`

Melakukan pengukuran dalam satu perulangan `for` dan menambahkan hasil ke array

Mengembalikan `resultArray`