Simulator kuantum jarang

Simulator jarang menggunakan representasi jarang dari vektor keadaan kuantum. Status kuantum jarang adalah keadaan di mana sebagian besar koefisien amplitudo adalah nol. Representasi sparse memungkinkan simulator sparse untuk meminimalkan jejak memori yang diperlukan untuk mewakili keadaan kuantum, yang memungkinkan simulasi dengan jumlah qubit yang lebih besar. Simulator jarang yang efisien untuk program dengan status kuantum yang jarang pada basis komputasi. Simulator langka memungkinkan pengguna menjelajahi aplikasi yang lebih besar daripada simulator status penuh karena simulator status penuh membuang memori dan waktu pada sejumlah eksponensial amplitudo nol.

Untuk informasi selengkapnya tentang simulator spar, lihat Jaques dan Häner (arXiv:2105.01533).

Memanggil simulator pemrosesan jarang

Simulator sparse adalah simulator lokal default di ekstensi MicrosoftQuantum Development Kit (QDK) untuk Visual Studio Code (VS Code). Cara menggunakan simulator jarang tergantung pada lingkungan pengembangan Anda.

Lingkungan pengembangan	Cara menggunakan simulator sparse
Dalam suatu Q# atau OpenQASM program di VS Code	Jalankan Q# file atau OpenQASM
Dalam program Python dengan pustaka qdk	qsharp.run atau openqasm.run atau qiskit.QSharpBackend
%%qsharp Dalam sel buku catatan	Panggil operasi entri program, misalnya: Main()

Menambahkan Pauli kebisingan ke simulator jarang di VS Code

Simulator sparse mendukung penambahan kebisingan Pauli dengan ekstensi VS Code pada simulasi program Q# Anda. Fitur ini memungkinkan Anda untuk mensimulasikan efek kebisingan pada operasi dan pengukuran kuantum. Untuk menentukan model kebisingan dalam program AndaQ#, gunakan fungsi .ConfigurePauliNoise Fungsi menetapkan probabilitas untuk operator Pauli, X, dan Y, kebisingan terjadi pada Z. Anda juga dapat mengonfigurasi model kebisingan global di pengaturan ekstensi.

Tambahkan Pauli kebisingan menggunakan pengaturan VS Code

Untuk mengatur kebisingan global Pauli untuk Q# program di VS Code, konfigurasikan Q#> pengaturan Simulasi:Pauli Pengguna kebisingan untuk QDK ekstensi.

Pengaturan kebisingan berlaku untuk hasil histogram dari semua gerbang, pengukuran, dan qubit dalam semua program Q# di VS Code.

Misalnya, histogram untuk program sampel GHz berikut tanpa kebisingan yang sudah dikonfigurasi menunjukkan hasil $\ket{00000}$ untuk sekitar setengah pengukuran dan $\ket{11111}$ untuk setengah sisanya.

import Std.Diagnostics.*;
import Std.Measurement.*;

operation Main() : Result []{
    let num = 5;
    return GHzSample(num);
}
operation GHzSample(n: Int) : Result[] {
    use qs = Qubit[n];
    H(qs[0]);
    ApplyCNOTChain(qs);
    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Jika Anda menambahkan bahkan tingkat kebisingan bit-flip 1%, hasilnya mulai menyebar. Dengan 25% kebisingan bit-flip, histogram tidak dapat dibedakan dari kebisingan murni.

Menambahkan Pauli kebisingan ke program individual Q#

ConfigurePauliNoise Gunakan fungsi untuk mengatur atau mengubah model kebisingan untuk masing-masing Q# program. Fungsi ini ConfigurePauliNoise memberi Anda kontrol atas kapan dan di mana kebisingan terjadi dalam program Anda Q# .

Nota

Jika Anda mengonfigurasi kebisingan dalam pengaturan VS Code, kebisingan tersebut diterapkan ke semua program Q#. Namun, fungsi ini ConfigurePauliNoise mengambil alih pengaturan kebisingan VS Code untuk program yang memanggil fungsi.

Misalnya, di program sebelumnya Anda dapat menambahkan kebisingan segera setelah alokasi kubit.

operation GHzSample(n: Int) : Result[] {
    use qs = Qubit[n];

     // 5% bit-flip noise applies to all operations
    ConfigurePauliNoise(0.05, 0.0, 0.0);

    H(qs[0]);
    ApplyCNOTChain(qs);
    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Atau, Anda dapat menambahkan kebisingan hanya ke operasi pengukuran.

operation GHzSample(n: Int) : Result[] {
    use qs = Qubit[n];
    H(qs[0]);
    ApplyCNOTChain(qs);

    // Noise applies to only the measurement operation
    ConfigurePauliNoise(0.05, 0.0, 0.0);

    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Untuk mengubah atau menghapus konfigurasi kebisingan di titik yang berbeda dalam program Anda, panggil ConfigurePauliNoise beberapa kali. Misalnya, Anda dapat mengatur kebisingan bit-flip sebesar 5% pada gerbang Hadamard dan kemudian mengatur tanpa kebisingan untuk sisa program.

operation GHzSample(n: Int) : Result[] {
    use qs = Qubit[n];

    // Noise applies to the H operation
    ConfigurePauliNoise(0.05, 0.0, 0.0);
    
    H(qs[0]);

     // Clear the noise settings
    ConfigurePauliNoise(0.0, 0.0, 0.0);
    
    ApplyCNOTChain(qs);
    let results = MeasureEachZ(qs);
    ResetAll(qs);
    return results;
}

Fungsi kebisingan lainnya Q#

Fungsi ConfigureNoiseFunction ini cukup untuk memodelkan segala jenis kebisingan Pauli dalam program Anda, tetapi Q# memiliki fungsi kebisingan lain yang juga dapat Anda gunakan. Fungsi berikut tersedia di Std.Diagnostics pustaka untuk mengonfigurasi kebisingan dalam Q# program:

Function	Description	Example
ConfigurePauliNoise	Mengonfigurasi kebisingan Pauli untuk eksekusi simulator. Parameter mewakili probabilitas kebisingan gerbang Pauli X, Y, dan Z. Konfigurasi kebisingan berlaku untuk semua gerbang, pengukuran, dan qubit berikutnya dalam suatu Q# program. Mengganti pengaturan kebisingan ekstensi VS Code. Panggilan berikutnya ke ConfigurePauliNoise akan menggantikan kebisingan yang telah ditetapkan oleh panggilan sebelumnya.	ConfigurePauliNoise(0.1, 0.0, 0.5) atau ConfigurePauliNoise(BitFlipNoise(0.1))
BitFlipNoise	Mengonfigurasi hanya kebisingan gerbang X dengan probabilitas yang ditentukan.	10% kebisingan bit-flip: ConfigurePauliNoise(BitFlipNoise(0.1)) $\equiv$ ConfigurePauliNoise(0.1, 0.0, 0.0)
PhaseFlipNoise	Mengonfigurasi kebisingan gerbang Z saja dengan probabilitas yang ditentukan.	10% kebisingan flip fase: ConfigurePauliNoise(PhaseFlipNoise(0.1)) $\equiv$ ConfigurePauliNoise(0.0, 0.0, 0.1)
DepolarizingNoise	Mengonfigurasi kebisingan menjadi gerbang X, Y, atau Z dengan probabilitas yang sama.	6% mendespolarisasi kebisingan: ConfigurePauliNoise(DepolarizingNoise(0.06)) $\equiv$ ConfigurePauliNoise(0.2, 0.2, 0.2)
NoNoise	Mengatur ulang model kebisingan agar tidak memiliki kebisingan.	ConfigurePauliNoise(NoNoise()) $\equiv$ ConfigurePauliNoise(0.0, 0.0, 0.0)
ApplyIdleNoise	Menerapkan kebisingan yang dikonfigurasi ke satu qubit selama simulasi.	... use q = Qubit[2]; ConfigurePauliNoise(0.1, 0.0, 0.0); ApplyIdleNoise(q[0]); ...