Bagikan melalui

Pengantar bahasa pemrograman kuantum Q#

  • Artikel

Q#adalah bahasa pemrograman sumber terbuka tingkat tinggi untuk mengembangkan dan menjalankan algoritma kuantum. Q# termasuk dalam Quantum Development Kit (QDK). Untuk informasi selengkapnya, lihat Menyiapkan Kit Pengembangan Quantum.

Sebagai bahasa pemrograman kuantum, Q# memenuhi persyaratan bahasa, kompilator, dan runtime berikut:

  • Agnostik perangkat keras: Qubit dalam algoritma kuantum tidak terkait dengan perangkat keras atau tata letak kuantum tertentu. Kompilator Q# dan runtime menangani pemetaan dari qubit program ke qubit fisik.
  • Mengintegrasikan komputasi kuantum dan klasik: Kemampuan untuk melakukan komputasi klasik dan kuantum sangat penting dalam komputer kuantum universal.
  • Menghormati hukum fisika:Q# dan algoritma kuantum mengikuti aturan fisika kuantum. Misalnya, Anda tidak dapat langsung menyalin atau mengakses status qubit di Q#.

Q# Struktur program

Sebelum Anda mulai menulis program kuantum, penting untuk memahami struktur dan komponennya. Pertimbangkan program berikut Q# yang membuat status superposisi:

namespace Superposition {
    @EntryPoint()
    operation MeasureOneQubit() : Result {
        // Allocate a qubit. By default, it's in the 0 state.  
        use q = Qubit();  
        // Apply the Hadamard operation, H, to the state.
        // It now has a 50% chance of being measured as 0 or 1.
        H(q);      
        // Measure the qubit in the Z-basis.
        let result = M(q);
        // Reset the qubit before releasing it.
        Reset(q);
        // Return the result of the measurement.
        return result;
    }
}

Berdasarkan komentar (//), Superposition program pertama-tama mengalokasikan qubit, menerapkan operasi untuk menempatkan qubit dalam superposisi, mengukur status qubit, mengatur ulang qubit, dan akhirnya mengembalikan hasilnya. Mari kita uraikan program ini menjadi komponennya.

Namespace pengguna

Q#program dapat secara opsional dimulai dengan namespace yang ditentukan pengguna, seperti:

namespace Superposition {
    // Your code goes here.
}

Namespace dapat membantu Anda mengatur fungsionalitas terkait. Setiap Q# program hanya dapat memiliki satu namespace. Jika namespace tidak ditentukan, pengkompilasi Q# menggunakan nama file sebagai namespace. Misalnya, Superposition program dapat ditulis sebagai:

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

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.

Titik masuk

Secara default, Q# pengkompilasi mulai menjalankan program dari Main() operasi, jika tersedia, yang dapat terletak di mana saja dalam program. Secara opsional, Anda dapat menggunakan @EntryPoint() atribut untuk menentukan operasi apa pun dalam program sebagai titik eksekusi.

Superposition Dalam program, operasi yang lebih deskriptif MeasureOneQubit() adalah titik masuk program.

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

Namun, program ini juga dapat ditulis tanpa @EntryPoint() atribut dengan mengganti nama MeasureOneQubit() operasi menjadi Main():

// The Q# compiler automatically detects the Main() operation as the entry point. 

operation Main() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Jenis

Q#menyediakan jenis bawaan yang umum untuk sebagian besar bahasa, termasuk Intjenis , , DoubleBool, dan String, dan yang khusus untuk komputasi kuantum. Misalnya, jenis mewakili Result hasil pengukuran kubit dan dapat memiliki salah satu dari dua nilai: Zero atau One.

Superposition Dalam program, MeasureOneQubit() operasi mengembalikan Result jenis, yang sesuai dengan jenis M pengembalian operasi. Hasil pengukuran disimpan dalam variabel baru yang ditentukan menggunakan let pernyataan :

// The operation definition returns a Result type.
operation MeasureOneQubit() : Result {
    ...
    // Measure the qubit in the 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

Di Q#, Anda mengalokasikan qubit menggunakan use kata kunci. Qubit selalu dialokasikan dalam $\ket{0}$ status .

Program ini Superposition mendefinisikan satu qubit:

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

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

use qubits = Qubit[2]; // Allocate two qubits.
H(qubits[0]); // Apply H to the first qubit.
X(qubits[1]); // Apply X to the second qubit.

Untuk informasi selengkapnya, lihat Pernyataan penggunaan.

Operasi kuantum

Setelah mengalokasikan qubit, Anda dapat meneruskannya ke operasi dan fungsi, juga dikenal sebagai callables. Operasi adalah blok bangunan dasar dari sebuah program Q#. Q# Operasi adalah subroutine kuantum, atau rutinitas yang dapat dipanggil yang berisi operasi kuantum yang mengubah status register qubit.

Untuk menentukan Q# operasi, Anda menentukan nama untuk operasi, inputnya, dan outputnya. Superposition Dalam program, MeasureOneQubit() operasi pada dasarnya adalah seluruh program. Tidak memerlukan parameter dan mengembalikan Result jenis:

operation MeasureOneQubit() : Result {
    ...
}

Berikut adalah contoh dasar yang tidak mengambil parameter dan tidak mengharapkan nilai pengembalian. Nilai Unit ini 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 kuantum, seperti operasi Hadamard, H, dalam Superposition program. Mengingat qubit dalam basis Z, H menempatkan qubit ke dalam superposisi yang merata, di mana ia memiliki peluang 50% untuk diukur sebagai Zero atau One.

Mengukur kubit

Meskipun ada banyak jenis pengukuran kuantum, Q# berfokus pada pengukuran proyektif pada qubit tunggal, juga dikenal sebagai pengukuran Pauli.

Dalam Q#, Measure operasi mengukur satu atau beberapa qubit dalam basis Pauli yang ditentukan, yang dapat berupa PauliX, , PauliYatau PauliZ. MeasureResult mengembalikan jenis dari salah satu Zero atau One.

Untuk menerapkan pengukuran dalam basis komputasi $\lbrace\ket{0},\ket{1}\rbrace$, Anda juga dapat menggunakan M operasi, yang mengukur qubit dalam basis Pauli Z. Ini membuat M setara dengan Measure([PauliZ], [qubit]).

Program ini Superposition menggunakan M operasi:

// Measure the qubit in the Z-basis.
let result = M(q);

Mengatur ulang kubit

Dalam Q#, qubit harus dalam $\ket{0}$ status ketika dirilis. Reset Gunakan operasi untuk mengatur ulang setiap kubit ke $\ket{0}$ status sebelum merilisnya di akhir program. Kegagalan untuk mengatur ulang kubit menghasilkan kesalahan runtime.

// Reset a qubit.
Reset(q);

Namespace bawaan

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

Untuk memanggil fungsi atau operasi, Anda dapat menentukan namespace lengkap atau menggunakan import pernyataan, yang membuat semua fungsi dan operasi untuk namespace tersebut tersedia dan membuat kode Anda lebih mudah dibaca. Contoh berikut memanggil operasi yang sama:

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

// imports all functions and operations from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.*;
Message("Hello quantum world!");

// imports just the `Message` function from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.Message;
Message("Hello quantum world!");

// namespaces in the standard library may be imported using `Std` instead of `Microsoft.Quantum`. 
import Std.Intrinsic.*;
Message("Hello quantum world!");

Program Superposition ini tidak memiliki pernyataan atau panggilan dengan import namespace lengkap. Itu karena Q# lingkungan pengembangan secara otomatis memuat dua namespace: Microsoft.Quantum.Core dan Microsoft.Quantum.Intrinsic, yang berisi fungsi dan operasi yang umum digunakan.

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

// Import the namespace for the MResetZ operation.
import Microsoft.Quantum.Measurement.*;

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.      
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1. 
    H(q);   
    // Measure and reset the qubit, and then return the result value.
    return MResetZ(q);
}

Mengembangkan program kuantum dengan Q# dan Azure Quantum

Q# dan Azure Quantum adalah kombinasi yang kuat untuk mengembangkan dan menjalankan program kuantum. Dengan Q# dan Azure Quantum, Anda dapat menulis program kuantum, mensimulasikan perilaku mereka, memperkirakan persyaratan sumber daya, dan menjalankannya pada perangkat keras kuantum nyata. Integrasi ini memungkinkan Anda untuk mengeksplorasi potensi komputasi kuantum dan mengembangkan solusi inovatif untuk masalah yang kompleks. Baik Anda adalah pengembang kuantum pemula atau berpengalaman, Q# dan Azure Quantum menyediakan alat dan sumber daya yang Anda butuhkan untuk membuka kekuatan komputasi kuantum.

Diagram berikut menunjukkan tahapan di mana program kuantum lulus saat Anda mengembangkannya dengan Q# dan Azure Quantum. Program Anda dimulai dengan lingkungan pengembangan dan berakhir dengan pengajuan pekerjaan ke perangkat keras kuantum nyata.

Diagram memperlihatkan alur kerja pengembangan pemrograman kuantum.

Mari kita uraikan langkah-langkah dalam diagram.

Memilih lingkungan pengembangan Anda

Jalankan program kuantum Anda di lingkungan pengembangan pilihan Anda. Anda dapat menggunakan editor kode online di situs web Azure Quantum, Jupyter Notebooks yang dihosting di ruang kerja Azure Quantum Anda di portal Azure, atau lingkungan pengembangan lokal dengan Visual Studio Code. Untuk informasi selengkapnya, lihat Berbagai cara untuk menjalankan Q# program.

Menulis program kuantum Anda

Anda dapat menulis program kuantum dalam Q# menggunakan Quantum Development Kit (QDK). Untuk memulai, lihat Mulai Cepat: Membuat program pertama Q# Anda.

Q#Selain itu, QDK menawarkan dukungan untuk bahasa lain untuk komputasi kuantum, seperti Qiskit dan Cirq.

Integrasikan dengan Python

Anda dapat menggunakan Q# dengan sendirinya atau bersama dengan Python di berbagai IDEs. Misalnya, Anda dapat menggunakan Q# proyek dengan program host Python untuk memanggil Q# operasi. Anda juga dapat berintegrasi Q# dengan Python di Jupyter Notebooks. Untuk informasi selengkapnya, lihat Berbagai cara untuk menjalankan Q# program.

Perintah %%qsharp

Secara default, Q# program di Jupyter Notebooks menggunakan ipykernel paket Python. Untuk menambahkan Q# kode ke sel buku catatan, gunakan %%qsharp perintah , yang diaktifkan dengan qsharp paket Python, diikuti oleh kode Anda Q# .

Saat menggunakan %%qsharp, ingatlah hal berikut:

  • Anda harus terlebih dahulu menjalankan import qsharp untuk mengaktifkan %%qsharp.
  • %%qsharp cakupan ke sel buku catatan tempat sel tersebut muncul dan mengubah tipe sel dari Python ke Q#.
  • Anda tidak dapat meletakkan pernyataan Python sebelum atau sesudah %%qsharp.
  • Q# kode berikut %%qsharp harus mematuhi Q# sintaksis. Misalnya, gunakan // alih-alih # untuk menunjukkan komentar dan ; untuk mengakhiri baris kode.

Catatan

Notebook Azure di portal Azure menyertakan versi terbaru paket qsharp Python dan azure-quantum , sehingga Anda tidak perlu menginstal apa pun. Untuk informasi selengkapnya, lihat Mulai menggunakan Q# dan notebook Azure Quantum.

Memperkirakan sumber daya

Sebelum menjalankan perangkat keras kuantum nyata, Anda harus mencari tahu apakah program Anda dapat berjalan pada perangkat keras yang ada, dan berapa banyak sumber daya yang akan digunakannya.

Azure Quantum Resource Estimator memungkinkan Anda menilai keputusan arsitektur, membandingkan teknologi qubit, dan menentukan sumber daya yang diperlukan untuk menjalankan algoritma kuantum tertentu. Anda dapat memilih dari protokol toleran terhadap kesalahan yang telah ditentukan sebelumnya dan menentukan asumsi model kubit fisik yang mendasarinya.

Untuk informasi selengkapnya, lihat Menjalankan perkiraan sumber daya pertama Anda.

Catatan

Estimator Sumber Daya Azure Quantum gratis dan tidak memerlukan akun Azure.

Jalankan program Anda dalam simulasi

Ketika Anda mengkompilasi dan menjalankan program kuantum, QDK membuat instans simulator kuantum dan meneruskan Q# kode ke dalamnya. Simulator menggunakan kode Q# untuk membuat qubit (simulasi partikel kuantum) dan menerapkan transformasi untuk memodifikasi kondisi mereka. Hasil operasi kuantum di simulator kemudian dikembalikan ke program. Mengisolasi kode Q# di simulator memastikan bahwa algoritma mengikuti hukum fisika kuantum dan dapat berjalan dengan benar pada komputer kuantum.

Kirim program Anda ke perangkat keras kuantum nyata

Anda dapat mengirimkan program Anda Q# (juga dikenal sebagai pekerjaan) ke Azure Quantum melalui lingkungan pengembangan pilihan Anda, baik secara lokal maupun online. Untuk informasi selengkapnya, lihat cara mengirimkan Q# pekerjaan. Anda juga dapat menjalankan dan mengirimkan sirkuit kuantum yang ditulis dalam bahasa Qiskit dan Cirq.

Azure Quantum menawarkan beberapa perangkat keras kuantum paling menarik dan beragam yang tersedia saat ini dari para pemimpin industri. Lihat Penyedia komputasi Quantum untuk daftar penyedia perangkat keras yang didukung saat ini.

Catatan

Target Emulator Quantinuum H-Series berbasis cloud tersedia tanpa akun Azure. Untuk mengirimkan pekerjaan ke penyedia Azure Quantum lainnya, Anda memerlukan akun Azure dan ruang kerja kuantum. Jika Anda tidak memiliki ruang kerja kuantum, lihat Membuat ruang kerja Azure Quantum.

Diagram berikut menunjukkan alur kerja dasar setelah Anda mengirimkan pekerjaan Anda:

Diagram memperlihatkan alur kerja setelah pengiriman pekerjaan ke Azure Quantum.

Konten terkait