Q# Struktur program

  • Artikel

Artikel ini mengeksplorasi komponen umum yang membentuk Q# program. Perhatikan bahwa program yang Q# ditulis dalam Jupyter Notebooks tidak menggunakan beberapa komponen ini - perbedaan ini dijelaskan di setiap bagian.

Pertimbangkan perintah Q# berikut:

namespace Superposition {

    @EntryPoint()
    operation MeasureOneQubit() : Result {
        // Allocate a qubit, by default it is in zero state      
        use q = Qubit();  
        // We apply a Hadamard operation H to the state
        // It now has a 50% chance of being measured 0 or 1  
        H(q);      
        // Now we measure the qubit in Z-basis.
        let result = M(q);
        // We reset the qubit before releasing it.
        Reset(q);
        // Finally, we return the result of the measurement.
        return result;
    }
}

Dengan hanya membaca komentar (//), Anda dapat mengetahui bahwa program ini mengalokasikan qubit, menerapkan operasi untuk menempatkannya dalam superposisi, mengukur status qubit, lalu mengatur ulang dan mengembalikan hasilnya.

Untuk menjalankan program ini di Visual Studio Code, lihat Mulai menggunakan Q# program dan Visual Studio Code.

Namespace pengguna

Q# program biasanya dimulai dengan namespace layanan bernama pengguna, seperti

namespace Superposition {
    // Your code goes here.
}

Kumpulan nama XML membantu Anda mengatur fungsionalitas terkait. Namespace diberi nama pengguna, dan hanya boleh ada satu namespace per file qsharp (*.qs).

Q# Pustaka standar memiliki namespace yang telah ditentukan sebelumnya yang berisi fungsi dan operasi yang dapat Anda gunakan dalam program kuantum. Untuk informasi selengkapnya, lihat Namespace bawaan.

Jupyter Notebooks tidak menggunakan namespace pengguna.

EntryPoint()

Atribut @EntryPoint() memberi tahu pengkompilasi Q# tempat untuk mulai mengeksekusi program. Dalam program dengan beberapa definisi fungsi dan operasi, @EntryPoint() dapat ditempatkan sebelum salah satu fungsi atau operasi dan alur program dimulai dari sana dan berlanjut secara berurutan.

    ...
    @EntryPoint()
    operation MeasureOneQubit() : Result {
        ...

Jupyter Notebooks tidak menggunakan titik masuk.

Perintah %%qsharp

Secara default, Q# program di Jupyter Notebooks menggunakan kernel Python ipykernel . Untuk menambahkan Q# kode ke sel buku catatan, Anda perlu menggunakan %%qsharp perintah , yang diaktifkan dengan qsharp paket Python. Misalnya, kode sampel sebelumnya di Jupyter Notebook terlihat seperti ini:

import qsharp

%%qsharp

    operation MeasureOneQubit() : Result {
        // Allocate a qubit, by default it is in zero state      
        use q = Qubit();  
        // We apply a Hadamard operation H to the state
        // It now has a 50% chance of being measured 0 or 1  
        H(q);      
        // Now we measure the qubit in Z-basis.
        let result = M(q);
        // We reset the qubit before releasing it.
        Reset(q);
        // Display the result
        Message($"Result is {result}");
        // Finally, we return the result of the measurement.
        return result;
    
    }
    MeasureOneQubit();

Perhatikan tidak adanya namespace layanan pengguna atau @EntryPoint(), yang tidak diperlukan untuk Jupyter Notebooks. Alih-alih titik masuk, operasi dipanggil langsung di baris terakhir. Perhatikan juga bahwa Message pernyataan ditambahkan ke kode Jupyter Notebook untuk menampilkan hasilnya. Saat Anda menjalankan program sebelumnya Q# di Visual Studio Code, simulator bawaan menampilkan hasilnya secara default.

Saat menggunakan %%qsharp perintah:

  • Anda harus menjalankan import qsharp terlebih dahulu untuk mengaktifkan %%qsharp perintah.
  • Perintah %%qsharp dilingkup ke seluruh sel tempat perintah muncul.
  • Kode Q# yang mengikuti perintah harus mematuhi sintaks pengkodean standar Q# . Misalnya, Anda menunjukkan komentar menggunakan // alih-alih # dalam %%qsharp sel, dan baris kode harus diakhapi dengan titik koma ;.
  • Perintah %%qsharp tidak dapat didahului oleh atau diikuti oleh pernyataan Python di dalam selnya.

Untuk contoh bekerja dengan program Jupyter Notebook, lihat Mulai menggunakan Q# program dan Visual Studio Code.

Jenis

Q#menyediakan banyak jenis bawaan yang umum untuk sebagian besar bahasa, termasuk Int, , DoubleBool, dan String, bersama dengan jenis yang khusus untuk komputasi kuantum. Misalnya, Result jenis mewakili hasil pengukuran kubit apa pun dan dapat memiliki salah satu dari dua kemungkinan nilai yang ditentukan: One dan Zero. Dalam program contoh, operasi MeasureOneQubit() mengharapkan jenis Result pengembalian dan M operasi mengukur qubit dan mengembalikan Result.

...
// operation definition expecting a return type of Result
operation MeasureOneQubit() : Result {
    ...
    // Now we measure the qubit in Z-basis, returning a Result type
    let result = M(q);
    ...
}

Q# juga menyediakan jenis yang menentukan rentang, array, dan tuple. Anda bahkan dapat menentukan jenis kustom Anda sendiri.

Mengalokasikan qubit

Pada Q#, qubit dialokasikan melalui kata kunci use.

Contoh kami mendefinisikan satu qubit:

// Allocate a qubit.
use q = Qubit();
...

tetapi Anda juga dapat mengalokasikan beberapa qubit dan mengakses masing-masing melalui indeksnya:

...
use qubits = Qubit[2];
X(qubits[1]);
H(qubits[0]);
...

Secara default, setiap qubit yang Anda alokasikan dengan kata kunci use dimulai dalam keadaan nol. Setiap qubit harus direset kembali status nol sebelum dirilis di akhir program. Gagal mengatur ulang qubit memicu kesalahan runtime.

// Reset a qubit.
Reset(q);
...

Operasi kuantum

Setelah dialokasikan, qubit dapat diteruskan ke operasi dan fungsi, juga disebut sebagai callables. Operasi adalah blok bangunan dasar dari sebuah program Q#. Operasi Q# adalah subrutinitas kuantum. Artinya, ini adalah rutinitas callable yang berisi operasi kuantum yang memodifikasi keadaan register qubit.

Untuk menentukan operasi Q#, Anda menentukan nama untuk operasi bersama dengan input dan outputnya. Dalam contoh kami, operasi tunggal pada dasarnya adalah seluruh program. Tidak memerlukan parameter dan mengharapkan jenis pengembalian dari Result:

operation MeasureOneQubit() : Result {
    ...
}

Berikut adalah contoh dasar yang tidak mengambil parameter dan tidak mengharapkan nilai yang dikembalikan. Nilainya Unit setara dengan NULL dalam bahasa lain.

operation SayHelloQ() : Unit {
    Message("Hello quantum world!");
}

Q# Pustaka standar juga menyediakan operasi yang dapat Anda gunakan dalam program Anda, misalnya Hadamard atau H operasi yang digunakan dalam program contoh. Mengingat qubit berdasarkan Z, H operasi menempatkan qubit ke dalam superposisi yang merata . Setelah berada dalam superposisi, qubit memiliki peluang 50% untuk diukur sebagai nol atau satu.

Mengukur kubit

Ada banyak jenis pengukuran kuantum, tetapi Q# berfokus pada pengukuran proyektif pada qubit tunggal, juga dikenal sebagai pengukuran Pauli. Setelah pengukuran dalam basis tertentu (misalnya, dasar komputasi $\ket{0},\ket{1}$) status qubit diproyeksikan ke status dasar mana pun yang diukur, sehingga menghancurkan superposisi apa pun di antara keduanya.

Program contoh kami menggunakan M operasi , yang melakukan pengukuran satu qubit dalam basis Pauli Z dan mengembalikan Result jenis .

Namespace bawaan

Pustaka standar Q# menggunakan namespace bawaan yang berisi fungsi dan operasi yang dapat Anda gunakan dalam program kuantum. Misalnya, namespace Microsoft.Quantum.Intrinsic berisi operasi dan fungsi yang umum digunakan seperti M, untuk mengukur hasil dan Message, untuk menampilkan pesan pengguna di mana saja dalam program.

Anda dapat memanggil fungsi atau operasi dengan menentukan namespace lengkap, atau menggunakan open pernyataan untuk membuat semua fungsi dan operasi untuk namespace tersebut tersedia, dan untuk membuat kode Anda lebih mudah dibaca. Kedua contoh ini memanggil operasi yang sama:

 Microsoft.Quantum.Intrinsic.Message("Hello quantum world!");

open Microsoft.Quantum.Intrinsic;
Message("Hello quantum world!");

Perhatikan dalam contoh program, tidak open ada pernyataan atau panggilan dengan namespace lengkap. Itu karena Q# lingkungan pengembangan secara otomatis memuat dua namespace secara default - Microsoft.Quantum.Core dan Microsoft.Quantum.Intrinsic - yang berisi fungsi dan operasi yang umum digunakan.

Anda dapat memanfaatkan Microsoft.Quantum.Measurement namespace layanan dan menggunakan MResetZ operasi untuk mengoptimalkan kode dalam program contoh. MResetZ menggabungkan pengukuran dan mengatur ulang operasi menjadi satu langkah, seperti dalam contoh berikut:

namespace Superposition {

    // open the namespace for the MResetZ operation
    open Microsoft.Quantum.Measurement;

    @EntryPoint()
    operation MeasureOneQubit() : Result {
        // Allocate a qubit, by default it is in zero state      
        use q = Qubit();  
        // We apply a Hadamard operation H to the state
        // It now has a 50% chance of being measured 0 or 1  
        H(q);   
        // Measure and reset the qubit, and return the result value   
        return MResetZ(q);
    }
    
}