Bagikan melalui

Pengantar bahasa pemrograman kuantum Q#

  • Artikel

adalah bahasa pemrograman sumber terbuka tingkat tinggi untuk dikembangkan oleh Microsoft untuk menulis program kuantum. Q# termasuk dalam Quantum Development Kit (QDK). Untuk informasi selengkapnya, lihat Menyiapkan Kit Pengembangan Quantum.

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

  • Agnostik perangkat keras: Qubit dalam algoritma kuantum tidak terkait dengan perangkat keras atau tata letak kuantum tertentu. Pengkompilasi Q# dan runtime menangani pemetaan dari qubit program ke kubit fisik, memungkinkan kode yang sama berjalan pada prosesor kuantum yang berbeda.
  • Integrasi kuantum dan komputasi klasik:Q# memungkinkan integrasi komputasi kuantum dan klasik, yang penting untuk komputasi kuantum universal.
  • manajemen Qubit:Q# menyediakan operasi dan fungsi bawaan untuk mengelola kubit, termasuk membuat status superposisi, menjerat kubit, dan melakukan pengukuran kuantum.
  • Menghormati hukum fisika: algoritmaQ# dan kuantum harus mengikuti aturan fisika kuantum. Misalnya, Anda tidak dapat langsung menyalin atau mengakses status qubit di Q#.

Untuk informasi selengkapnya tentang asal-usul Q#, lihat posting blog Mengapa kita perlu Q#?.

Q# Struktur program

Sebelum Anda mulai menulis program Q#, penting untuk memahami struktur dan komponennya. Pertimbangkan program Q# berikut, bernama Superposition, 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 (//), Q# program pertama-tama mengalokasikan qubit, menerapkan operasi untuk menempatkan qubit dalam superposisi, mengukur status qubit, mengatur ulang qubit, dan akhirnya mengembalikan hasilnya.

Mari kita pecahkan program Q# 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. Namespace adalah optionaL dalam program Q#, yang berarti Anda dapat menulis program tanpa menentukan namespace.

Misalnya, program Superposisi dari contoh juga dapat ditulis tanpa namespace 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;
}

Catatan

Setiap Q# program hanya dapat memiliki satu namespace. Jika Anda tidak menentukan sebuah namespace, pengompilasi Q# menggunakan nama file sebagai namespace.

Titik masuk

Setiap program Q# harus memiliki titik masuk, yang merupakan titik awal program. 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.

Misalnya, dalam program Superposisi , operasi adalah titik masuk program karena memiliki atribut sebelum definisi operasi:

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

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

// 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

Jenis sangat penting dalam bahasa pemrograman apa pun karena menentukan data yang dapat digunakan program. menyediakan jenis bawaan yang umum untuk sebagian besar bahasa, termasuk , , , dan , dan jenis yang menentukan rentang, array, dan tuple.

Q# juga menyediakan jenis yang khusus untuk komputasi kuantum. Misalnya, jenis Result mewakili hasil pengukuran kubit dan dapat memiliki dua nilai: Zero atau One.

Dalam program Superposisi, operasi MeasureOneQubit() mengembalikan jenis Result, yang sesuai dengan jenis pengembalian operasi M. 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);
    ...
}

Contoh lain dari jenis khusus kuantum adalah jenis Qubit, yang mewakili bit kuantum.

Q# juga memungkinkan Anda menentukan jenis kustom Anda sendiri. Untuk informasi selengkapnya, lihat deklarasi jenis .

Mengalokasikan qubit

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

Misalnya, program Superposisi menentukan satu qubit dan menyimpannya dalam variabel :

// 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. 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. Dalam program Superposisi , operasi tidak mengambil parameter dan mengembalikan 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. Measure Result 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]).

Misalnya, program Superposisi menggunakan operasi :

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

Mengatur ulang kubit

Dalam Q#, qubit harus berada dalam status $\ket{0}$ saat dirilis untuk menghindari kesalahan dalam perangkat keras kuantum. Anda dapat mengatur ulang qubit ke status $\ket{0}$ menggunakan operasi Reset di akhir program. Kegagalan untuk mengatur ulang kubit menghasilkan kesalahan runtime.

// Reset a qubit.
Reset(q);

Namespace perpustakaan standar

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!");

Catatan

Program Superposisi tidak memiliki pernyataan atau panggilan import dengan 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 namespace dengan menggunakan operasi untuk mengoptimalkan program Superposisi . 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);
}

Pelajari cara 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 Q# pertama 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 proyek Q# dengan program host Python untuk memanggil operasi Q# atau mengintegrasikan Q# dengan Python di Jupyter Notebooks. Untuk informasi selengkapnya, lihat Integrasi dan Q# dengan Python.

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.

Memperkirakan sumber daya

Sebelum berjalan pada perangkat keras kuantum nyata, Anda perlu 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 Q# Anda ke Azure Quantum untuk dijalankan pada perangkat keras kuantum nyata. Anda juga dapat menjalankan dan mengirimkan sirkuit kuantum yang ditulis dalam bahasa Qiskit dan Cirq. Saat menjalankan program kuantum di Azure Quantum, Anda membuat dan menjalankan pekerjaan . Untuk informasi selengkapnya, lihat cara mengirimkan program Q# ke Azure Quantum.

xref:microsoft.quantum.work-with-jobs

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

Untuk mengirimkan pekerjaan ke penyedia Azure Quantum, Anda memerlukan akun Azure dan ruang kerja kuantum. Jika Anda tidak memiliki ruang kerja kuantum, lihat Membuat ruang kerja Azure Quantum.

Setelah Anda mengirimkan pekerjaan Anda, Azure Quantum mengelola siklus hidup pekerjaan, termasuk penjadwalan pekerjaan, eksekusi, dan pemantauan. Anda dapat melacak status pekerjaan Anda dan melihat hasilnya di portal Azure Quantum. Untuk informasi selengkapnya, lihat Bekerja dengan pekerjaan Azure Quantum.

Konten terkait