target Menyesuaikan parameter Estimator Sumber Daya

Artikel
05/23/2024

Artikel ini memperlihatkan cara menyesuaikan target parameter Azure Quantum Resource Estimator agar sesuai dengan karakteristik mesin yang Anda targetkan. Estimator Sumber Daya menggunakan parameter ini untuk memperkirakan sumber daya yang diperlukan untuk menjalankan algoritma kuantum pada komputer kuantum.

Catatan

Jika Anda mengalami masalah saat bekerja dengan Estimator Sumber Daya, lihat halaman Pemecahan Masalah.

Prasyarat

Lingkungan Python dengan Python dan Pip terinstal.
Versi terbaru Visual Studio Code atau buka VISUAL Code di Web.
Visual Studio Code dengan ekstensi Azure Quantum Development Kit, Python, dan Jupyter terinstal.

Azure Quantum qsharp dan qsharp-widgets paket terbaru.

python -m pip install --upgrade qsharp qsharp-widgets

Parameter Target

Estimator Sumber Daya menghitung estimasi sumber daya, seperti jumlah qubit dan waktu proses, yang akan diperlukan untuk menerapkan algoritma kuantum tertentu menggunakan teknologi kubit tertentu dan dengan serangkaian pilihan arsitektur tetap.

Oleh karena itu, Estimator Sumber Daya mengambil serangkaian input, dengan nilai yang telah ditentukan sebelumnya untuk dengan mudah membuat Anda memulai:

Model qubit fisik, yang mendefinisikan properti dari qubit fisik yang mendasar.
Skema Koreksi Kesalahan Quantum (QEC), yang merupakan skema koreksi kesalahan kuantum yang diasumsikan.
Anggaran kesalahan, yang merupakan kesalahan yang diizinkan secara keseluruhan, yaitu, berapa kali program diizinkan untuk tidak berhasil.
Batasan pada tingkat komponen, yang merupakan jumlah siklus logis dan jumlah salinan pabrik T.
Unit penyulingan untuk menentukan algoritma distilasi pabrik T.
Estimasi perbatasan Pareto untuk menjalankan beberapa perkiraan jumlah kubit dan runtime untuk algoritma yang sama.

Tip

Jika Anda sudah mengetahui beberapa perkiraan yang telah dihitung sebelumnya untuk operasi, Anda juga dapat menggabungkannya dan mengoptimalkan eksekusi Estimator Sumber Daya. Untuk informasi selengkapnya, lihat Cara menggunakan perkiraan yang diketahui dengan Estimator Sumber Daya.

Parameter kubit fisik

Ketika Estimator Sumber Daya memodelkan asumsi qubit fisik, ia menggunakan dua set instruksi fisik yang berbeda untuk mengoperasikan qubit. Set instruksi fisik dapat berbasis gerbang atau Majorana. Set instruksi berbasis gerbang menyediakan pengukuran qubit tunggal, gerbang qubit tunggal (termasuk gerbang T), dan gerbang dua qubit. Set instruksi Majorana menyediakan gerbang T fisik, pengukuran kubit tunggal, dan operasi pengukuran bersama dua qubit.

Anda dapat memilih dari enam parameter kubit yang telah ditentukan sebelumnya, empat di antaranya memiliki set instruksi berbasis gerbang dan dua dengan set instruksi Majorana. Model qubit ini mencakup berbagai waktu operasi dan tingkat kesalahan, memungkinkan eksplorasi yang cukup dari biaya sumber daya yang diperlukan untuk mengaktifkan aplikasi kuantum praktis.

Parameter qubit	Kelas API Python	Deskripsi
`"qubit_gate_ns_e3"` , `"qubit_gate_ns_e4"`	`GATE_NS_E3` , `GATE_NS_E4`	Waktu operasi dan keakuratan dapat sesuai dengan versi masa depan dari kualitas transmon superkonduktif, atau qubit spin, yang biasanya memiliki waktu operasi dalam rezim nanodetik. Untuk qubit ini, gerbang dan operasi pengukuran diasumsikan untuk mengambil masing-masing 50 ns dan 100 ns. Tingkat kesalahan single-qubit dan two-qubit gate diasumsikan $10^{-3}$ sebagai realistis target, dan $10^{-4}$ sebagai optimis target untuk sistem peningkatan skala.
`"qubit_gate_us_e3"` , `"qubit_gate_us_e4"`	`GATE_US_E3` , `GATE_US_E4`	Waktu operasi dan keakuratan dapat sesuai dengan versi kubit di masa mendatang berdasarkan ion, yang biasanya memiliki waktu operasi dalam rezim mikrodetik. Berdasarkan asumsi umum untuk qubit ion, gerbang dan operasi pengukuran diasumsikan untuk mengambil 100 μs. Tingkat kesalahan untuk gerbang Clifford qubit tunggal adalah $10^{-3}$ sebagai realistis target dan $10^{-4}$ sebagai optimis target, sementara tingkat kesalahan untuk gerbang non-Clifford qubit tunggal (gerbang T) adalah $10^{-6}$. Untuk gerbang dua kubit, tingkat kesalahan adalah $10^{-3}$ sebagai realistis target dan $10^{-4}$ sebagai optimis target.
`"qubit_maj_ns_e4"` , `"qubit_maj_ns_e6"`	`MAJ_NS_E4` , `MAJ_NS_E6`	Waktu operasi dan keakuratan dapat sesuai dengan versi qubit Majorana yang ditingkatkan di masa mendatang. Untuk qubit ini, operasi gerbang dan pengukuran diasumsikan membutuhkan waktu 100 ns. Untuk memperhitungkan perlindungan topologis dalam perangkat keras, tingkat kesalahan pengukuran bersama qubit tunggal dan dua kubit (tingkat kesalahan Clifford) diasumsikan $10^{-4}$ sebagai realistis target, dan $10^{-6}$ sebagai optimis target. Operasi Non-Clifford dalam arsitektur ini tidak memiliki perlindungan topologis, tingkat kesalahan untuk gerbang T fisik non-Clifford adalah 5%.

Catatan

Kecuali nilai lain ditentukan, nilai default untuk model qubit adalah "qubit_gate_ns_e3".

Parameter untuk parameter kubit yang telah ditentukan sebelumnya

Sebagai referensi, parameter kubit lengkap yang telah ditentukan adalah sebagai berikut:

{
    "qubitParams": {
        "name": "qubit_gate_ns_e3",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 ns",
        "oneQubitGateTime": "50 ns",
        "twoQubitGateTime": "50 ns",
        "tGateTime": "50 ns",
        "oneQubitMeasurementErrorRate": 1e-3,
        "oneQubitGateErrorRate": 1e-3,
        "twoQubitGateErrorRate": 1e-3,
        "tGateErrorRate": 1e-3
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_ns_e4",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 ns",
        "oneQubitGateTime": "50 ns",
        "twoQubitGateTime": "50 ns",
        "tGateTime": "50 ns",
        "oneQubitMeasurementErrorRate": 1e-4,
        "oneQubitGateErrorRate": 1e-4,
        "twoQubitGateErrorRate": 1e-4,
        "tGateErrorRate": 1e-4
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_us_e3",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 µs",
        "oneQubitGateTime": "100 µs",
        "twoQubitGateTime": "100 µs",
        "tGateTime": "100 µs",
        "oneQubitMeasurementErrorRate": 1e-3,
        "oneQubitGateErrorRate": 1e-3,
        "twoQubitGateErrorRate": 1e-3,
        "tGateErrorRate": 1e-6
    }
}

{
    "qubitParams": {
        "name": "qubit_gate_us_e4",
        "instructionSet": "GateBased",
        "oneQubitMeasurementTime": "100 µs",
        "oneQubitGateTime": "100 µs",
        "twoQubitGateTime": "100 µs",
        "tGateTime": "100 µs",
        "oneQubitMeasurementErrorRate": 1e-4,
        "oneQubitGateErrorRate": 1e-4,
        "twoQubitGateErrorRate": 1e-4,
        "tGateErrorRate": 1e-6
    }
}

{
    "qubitParams": {
        "name": "qubit_maj_ns_e4",
        "instructionSet": "Majorana",
        "oneQubitMeasurementTime": "100 ns",
        "twoQubitJointMeasurementTime": "100 ns",
        "tGateTime": "100 ns",
        "oneQubitMeasurementErrorRate": 1e-4,
        "twoQubitJointMeasurementErrorRate": 1e-4,
        "tGateErrorRate": 0.05
    }
}

{
    "qubitParams": {
        "name": "qubit_maj_ns_e6",
        "instructionSet": "Majorana",
        "oneQubitMeasurementTime": "100 ns",
        "twoQubitJointMeasurementTime": "100 ns",
        "tGateTime": "100 ns",
        "oneQubitMeasurementErrorRate": 1e-6,
        "twoQubitJointMeasurementErrorRate": 1e-6,
        "tGateErrorRate": 0.01
    }
}

Meneruskan parameter kubit yang telah ditentukan sebelumnya

Ada dua cara untuk menentukan parameter kubit yang telah ditentukan sebelumnya secara terprogram. Anda dapat memilih nama model qubit untuk qubitParams kelas saat menjalankan qsharp.estimate. Misalnya, untuk memilih "qubit_maj_ns_e6" parameter qubit, tulis:

qsharp.estimate("RunProgram()", params=
                {"qubitParams": {
                        "name": "qubit_maj_ns_e6"
                    },
                })

Anda juga dapat meneruskan parameter qubit ke EstimatorParams kelas menggunakan QubitParams. Misalnya, untuk memilih MAJ_NS_E6 parameter qubit, tulis:

from qsharp.estimator import EstimatorParams, QubitParams

params = EstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E6 # qubit_maj_ns_e6 qubit parameter

qsharp.estimate("RunProgram()", params=params)

Mengkustomisasi parameter kubit yang telah ditentukan sebelumnya

Anda dapat menyesuaikan parameter kubit yang telah ditentukan sebelumnya dengan menentukan nama lalu memperbarui salah satu nilai lainnya. Misalnya, untuk mengurangi tingkat kesalahan pengukuran gabungan dua kubit dalam "qubit_maj_ns_e4", tulis:

qsharp.estimate("RunProgram()", params=
                {"qubitParams": {
                        "name": "qubit_maj_ns_e4",
                        "twoQubitJointMeasurementErrorRate": 1e-5,
                    },
                })

Atau, Anda dapat meneruskan instruksi dalam bentuk daftar.

from qsharp.estimator import EstimatorParams, QubitParams

params = MicrosoftEstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E4
params.qubit_params.two_qubit_joint_measurement_error_rate = 1e-5

Parameter qubit untuk qubit berbasis Gerbang

Pengidentifikasi Python	Jenis data	Deskripsi
`name`	string	Nama untuk model qubit
`instruction_set`	"gate_based"	Teknologi qubit yang mendasar
`one_qubit_measurement_time`	string waktu	Waktu operasi untuk pengukuran kubit tunggal ($t_{\rm meas}$) dalam ns
`one_qubit_gate_time`	string waktu	Waktu operasi untuk gerbang qubit tunggal ($t_{\rm gate}$) dalam ns
`two_qubit_gate_time`	string waktu	Waktu operasi untuk gerbang dua qubit dalam ns
`t_gate_time`	string waktu	Waktu operasi untuk gerbang non-Clifford qubit tunggal dalam ns
`one_qubit_measurement_error_rate`	float	Tingkat kesalahan untuk pengukuran kubit tunggal
`one_qubit_gate_error_rate`	float	Tingkat kesalahan untuk gerbang Clifford qubit tunggal ($p$)
`two_qubit_gate_error_rate`	float	Tingkat kesalahan untuk gerbang Clifford dua-qubit
`t_gate_error_rate`	float	Tingkat kesalahan untuk menyiapkan status non-Clifford quifford tunggal ($p_T$)
`idle_error_rate`	float	Tingkat kesalahan yang sesuai dengan idling

Kode berikut menunjukkan cara menentukan parameter kubit kustom untuk set instruksi berbasis gerbang:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()

params.qubit_params.name = "your_custom_name"
params.qubit_params.instruction_set = "gate_based"
params.qubit_params.t_gate_error_rate = 0.03
params.qubit_params.t_gate_time = "10 ns"
params.qubit_params.idle_error_rate = 0.02

Catatan

Ketika tidak ditentukan, nilai untuk dan default ke one_qubit_gate_time, nilai untuk two_qubit_gate_error_rate dan t_gate_error_rate default ke one_qubit_gate_error_rate, dan nilai untuk idle_error_rate default ke one_qubit_measurement_error_rate.t_gate_time two_qubit_gate_time

Parameter qubit untuk kubit Majorana

Pengidentifikasi Python	Jenis data	Deskripsi
`name`	string	Nama untuk model qubit
`instruction_set`	"majorana"	Teknologi qubit yang mendasar
`one_qubit_measurement_time`	string waktu	Waktu operasi untuk pengukuran kubit tunggal ($t_{\rm meas}$) dalam ns
`two-qubit_joint_measurement_time`	string waktu	Waktu operasi untuk pengukuran dua kubit dalam ns
`t_gate_time`	string waktu	Waktu operasi untuk gerbang non-Clifford qubit tunggal dalam ns
`one_qubit_measurement_error_rate`	float	Tingkat kesalahan untuk pengukuran kubit tunggal
`two_qubit_joint_measurement_error_rate`	float	Tingkat kesalahan untuk pengukuran dua kubit
`t_gate_error_rate`	float	Tingkat kesalahan untuk menyiapkan status non-Clifford quifford tunggal ($p_T$)
`idle_error_rate`	float	Tingkat kesalahan yang sesuai dengan idling

Templat minimum untuk set instruksi berbasis Majorana dengan semua nilai yang diperlukan adalah:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()

params.qubit_params.name = "your_custom_name"
params.qubit_params.instruction_set = "majorana"
params.qubit_params.one_qubit_measurement_time = "10 ns"
params.qubit_params.one_qubit_measurement_error_rate = 0.01

Catatan

Ketika tidak ditentukan, nilai untuk dan default ke one_qubit_measurement_time, nilai untuk two_qubit_joint_measurement_error_rate dan t_gate_error_rate default ke one_qubit_measurement_error_rate, dan nilai untuk idle_error_rate default ke one_qubit_measurement_error_rate.t_gate_time two_qubitJointMeasurementTime

Untuk one_qubit_measurement_error_rate dan two_qubit_joint_measurement_error_rate, Anda dapat menentukan tingkat kesalahan yang sesuai dengan pembacaan pengukuran, readout, dan pemrosesan pengukuran, process. Nilai-nilai ini dapat berupa <double> angka atau pasangan angka. Contoh:

params.qubit_params.two_qubit_joint_measurement_error_rate = \
    MeasurementErrorRate(process=0.00005, readout=0.00007)

Catatan

Jika Anda menentukan nilai numerik tunggal untuk tingkat kesalahan qubit tunggal dan dua kubit dalam pengukuran kubit Majorana, tingkat kesalahan baca-baca dan proses mungkin sama.

Penting

Semua nilai yang tidak ditentukan akan mengambil nilai default, misalnya, menentukan akan memodelkan "qubit": {"oneQubitGateTime":"200 ns"} qubit berbasis gerbang di mana waktu gerbang dua qubit dan waktu gerbang satu qubit adalah 200 ns. Untuk unit, Anda perlu menentukan string waktu, yang merupakan angka titik mengambang presisi ganda, diikuti oleh spasi dan unit waktu untuk nilai tersebut, di mana akhiran waktu yang mungkin adalah ns, µs (atau us), ms, dan s.

Skema koreksi kesalahan quantum

Untuk menjalankan aplikasi kuantum skala praktis, operasi kuantum harus memiliki tingkat kesalahan yang rendah. Tingkat targets kesalahan ini biasanya di luar kemampuan qubit fisik mentah. Untuk mengatasi keterbatasan ini, koreksi kesalahan kuantum (QEC) dan komputasi toleran terhadap kesalahan adalah dua teknik penting yang membentuk blok bangunan komputer kuantum skala besar. Pertama, QEC memungkinkan kita untuk menyusun beberapa qubit fisik yang rawan kesalahan dan membangun qubit logis yang lebih andal yang mempertahankan informasi kuantum lebih baik daripada qubit fisik yang mendasarinya.

Estimator Sumber Daya menggunakan rumus berikut untuk memodelkan tingkat kesalahan logis menggunakan model eksponensial,

$$ P = a\left(\frac{p}{p^*}\right)^{\frac{d+1}{2}} $$

di mana $a$ adalah pra-faktor persimpangan, $d$ adalah jarak kode, $p$ adalah tingkat kesalahan fisik, dan $p^*$ adalah ambang koreksi kesalahan kuantum. Prafaktor penyeberangan $a$ dapat diekstraksi secara numerik untuk simulasi.

Jarak kode $d$ adalah parameter yang mengontrol jumlah kesalahan yang dapat dikoreksi. Dengan demikian, jarak kode mendefinisikan tingkat kesalahan qubit logis dan jumlah qubit fisik yang diperlukan untuk mengodekannya. Akurasi dan jumlah qubit fisik meningkat dengan jarak kode. Tujuan dari skema QEC adalah untuk menemukan jarak kode minimum yang dapat mencapai tingkat kesalahan yang diperlukan yang ditetapkan untuk aplikasi tertentu.

Tingkat kesalahan fisik $p$ diekstrak dari parameter qubit sebagai tingkat kesalahan terburuk dari setiap operasi Clifford fisik yang dilakukan di perangkat. Secara khusus, $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) untuk parameter qubit dengan set instruksi berbasis gerbang, dan $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) untuk parameter qubit dengan set instruksi Majorana. Skema QEC biasanya memiliki ambang batas tingkat kesalahan $p^*$ di bawah koreksi kesalahan yang menekan kesalahan.

Azure Quantum Resource Estimator mendukung dua skema QEC yang telah ditentukan sebelumnya: kode permukaan dan kode floquet.

Protokol QEC	Kelas API Python	Deskripsi
"`surface_code`"	`SURFACE_CODE`	Kode permukaan berbasis gerbang didasarkan pada arXiv:1208.0928 dan arXiv:1009.3686. Kode permukaan Majorana didasarkan pada arXiv:1909.03002 dan arXiv:2007.00307.
"`floquet_code`"	`FLOQUET_CODE`	Hanya untuk mayorana qubit. Kode floquet didasarkan pada arXiv:2202.11829.

Catatan

Kecuali nilai lain ditentukan, nilai default untuk skema QEC adalah "surface_code".

Parameter untuk skema QEC yang telah ditentukan sebelumnya

Parameter yang tepat untuk setiap skema QEC yang telah ditentukan sebelumnya adalah sebagai berikut.

{
    "qubitParams": {
        "instructionSet": "GateBased",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.03,
        "logicalCycleTime": "(4 * twoQubitGateTime + 2 * oneQubitMeasurementTime) * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "surface_code",
        "errorCorrectionThreshold": 0.0015,
        "crossingPrefactor": 0.08,
        "logicalCycleTime": "20 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "2 * codeDistance * codeDistance"
    }
}

{
    "qubitParams": {
        "instructionSet": "Majorana",
    }
    "qecScheme": {
        "name": "floquet_code",
        "errorCorrectionThreshold": 0.01,
        "crossingPrefactor": 0.07,
        "logicalCycleTime": "3 * oneQubitMeasurementTime * codeDistance",
        "physicalQubitsPerLogicalQubit": "4 * codeDistance * codeDistance + 8 * (codeDistance - 1)"
    }
}

Meneruskan skema QEC yang telah ditentukan sebelumnya

Ada dua cara untuk menentukan skema QEC yang telah ditentukan sebelumnya. Anda dapat memilih nama model QEC untuk "qecScheme" kelas saat menjalankan qsharp.estimate. Misalnya, untuk memilih kode floquet, tulis:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code"
                    }
                })

Anda juga dapat meneruskan daftar parameter estimasi ke EstimatorParams kelas menggunakan QECScheme kelas . Misalnya, untuk memilih kode floquet, tulis:

from qsharp.estimator import EstimatorParams, QubitParams, QECScheme,

params = EstimatorParams()
params.items.qec_scheme.name = QECScheme.FLOQUET_CODE # floquet code QEC scheme

qsharp.estimate("RunProgram()", params=params)

Menyesuaikan skema QEC yang telah ditentukan sebelumnya

Anda dapat menyesuaikan skema QEC yang telah ditentukan sebelumnya dengan menentukan nama lalu memperbarui salah satu nilai lainnya. Misalnya, untuk meningkatkan pra-faktor persimpangan dalam kode floquet, tulis:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "name": "floquet_code",
                        "crossingPrefactor": 0.07,
                    }
                })

Catatan

Ketika tidak ditentukan, nilai untuk "logicalCycleTime" dan default ke "oneQubitMeasurementTime", nilai untuk "errorCorrectionThreshold" default ke 0.01, dan nilai untuk "crossingPrefactor" default ke 0.03"physicalQubitsPerLogicalQubit" .

Menyesuaikan skema QEC Anda

Estimator Sumber Daya dapat mengabstraksi skema QEC yang disesuaikan berdasarkan rumus di atas dengan menyediakan nilai untuk "crossingPrefactor" $a$ dan "errorCorrectionThreshold" $p^*$. Selanjutnya, Anda perlu menentukan "logicalCycleTime", yaitu, waktu untuk menjalankan satu operasi logis, yang tergantung pada jarak kode dan asumsi waktu operasi fisik dari kubit fisik yang mendasar. Terakhir, rumus kedua menghitung "physicalQubitsPerLogicalQubit", yaitu, jumlah qubit fisik yang diperlukan untuk mengodekan satu kubit logis berdasarkan jarak kode.

Anda dapat menggunakan kode berikut sebagai templat untuk skema QEC:

qsharp.estimate("RunProgram()", params=
                {"qecScheme": {
                        "crossingPrefactor": <double>,
                        "errorCorrectionThreshold": <double>,
                        "logicalCycleTime": <formula string>,
                        "physicalQubitsPerLogicalQubit": <formula string>
                    }
                })

Di dalam rumus, Anda dapat menggunakan variabel one_qubit_gate_time, , two_qubit_gate_time, one_qubit_measurement_timedan two_qubit_joint_measurement_time, yang nilainya diambil dari bidang yang sesuai dari parameter kubit fisik, serta variabel eccDistance untuk jarak kode yang dihitung untuk kubit logis, berdasarkan properti kubit fisik, ambang koreksi kesalahan, dan prefaktor persimpangan. Variabel waktu dan eccDistance dapat digunakan untuk menjelaskan logicalCycleTime rumus. Untuk rumus physicalQubitsPerLogicalQubit hanya yang eccDistance dapat digunakan.

Anggaran kesalahan

Total anggaran kesalahan $\epsilon$ menetapkan kesalahan yang ditoleransi secara keseluruhan untuk algoritma, yaitu, probabilitas kegagalan yang diizinkan dari algoritma. Nilai globalnya harus antara 0 dan 1, dan nilai defaultnya adalah 0,001, yang sesuai dengan 0,1%. Dengan kata lain, algoritma diizinkan untuk gagal maksimum sekali dalam 1000 eksekusi. Parameter ini sangat spesifik untuk aplikasi.

Misalnya, jika Anda menjalankan algoritma Shor untuk memperhitungkan bilangan bulat, nilai besar untuk anggaran kesalahan dapat ditoleransi karena seseorang dapat memeriksa bahwa output memang merupakan faktor utama input. Di sisi lain, anggaran kesalahan yang lebih kecil mungkin diperlukan untuk algoritma yang memecahkan masalah dengan solusi, yang tidak dapat diverifikasi secara efisien.

Anggaran kesalahan sesuai dengan jumlah tiga bagian:

$$ \epsilon = \epsilon_{\log} + \epsilon_{\rm dis} + \epsilon_{\rm syn} $$

Kesalahan logis $\epsilon_{\log}$ adalah kesalahan penerapan qubit logis, kesalahan status T $\epsilon_{\rm dis}$ adalah kesalahan memproduksi status T melalui distilasi, dan kesalahan gerbang rotasi $\epsilon_{\rm syn}$ adalah kesalahan mensintesis gerbang rotasi dengan sudut arbitrer.

Catatan

Kecuali nilai lain ditentukan, anggaran kesalahan $\epsilon$ didistribusikan secara seragam di antara kesalahan logis, kesalahan status T, dan kesalahan gerbang rotasi.

Perhatikan bahwa untuk penyulingan dan sintesis rotasi, anggaran kesalahan masing-masing $\epsilon_{\rm dis}$ dan $\epsilon_{\rm syn}$ didistribusikan secara seragam di antara semua status T yang diperlukan dan masing-masing semua gerbang rotasi yang diperlukan. Jika tidak ada gerbang rotasi dalam algoritma input, anggaran kesalahan didistribusikan secara seragam ke kesalahan logis dan kesalahan status T.

Meneruskan anggaran kesalahan

Ada dua cara untuk menentukan anggaran kesalahan dengan mengatur angka antara 0 dan 1. Anda dapat meneruskan anggaran kesalahan saat menjalankan qsharp.estimate. Misalnya, untuk memilih anggaran kesalahan 1/3, tulis:

qsharp.estimate("RunProgram()", params=
                {'errorBudget': 0.333
                })

Anda juga dapat meneruskan parameter anggaran kesalahan ke EstimatorParams kelas .

from qsharp.estimator import EstimatorParams, QubitParams, QECScheme,

params = EstimatorParams()
params.items.error_budget = 0.333 # error budget of 1/3

qsharp.estimate("RunProgram()", params=params)

Selain itu, Anda dapat menentukan setiap komponen anggaran kesalahan secara individual. Jumlah semua nilai adalah total anggaran kesalahan dan harus antara 0 dan 1. Jika algoritma kuantum tidak berisi status atau rotasi T, maka nilai t_states dan rotations mungkin masing-masing 0.

Kode berikut menunjukkan cara menentukan parameter anggaran kesalahan dengan status dan rotasi T:

from qsharp.estimator import EstimatorParams, QubitParams,

params = EstimatorParams()
params.error_budget.logical = 0.01
params.error_budget.t_states = 0.02
params.error_budget.rotations = 0.03

Kendala

Anda dapat menggunakan "constraints" kelas untuk menerapkan batasan pada tingkat komponen pabrik T. Dengan menyesuaikan batasan, Anda dapat mengoptimalkan perkiraan untuk mengurangi jumlah kubit atau mengurangi runtime.

Parameter	Jenis data	Deskripsi
`logical_depth_factor`	float	Mengontrol waktu eksekusi. Jika memiliki nilai yang lebih besar dari 1, jumlah awal siklus logis, juga disebut kedalaman logis, dikalikan dengan angka ini. Dengan mengurangi `logical_depth_factor`, Anda dapat meningkatkan jumlah pemanggilan pabrik T dalam waktu tertentu, sehingga menghasilkan lebih sedikit salinan pabrik T yang diperlukan untuk menghasilkan jumlah status T yang sama. Ketika Anda mengurangi jumlah salinan pabrik T, runtime algoritma meningkat sesuai. Faktor penskalaan untuk total runtime mungkin lebih besar, karena tingkat kesalahan logis yang diperlukan meningkat karena jumlah siklus tambahan.
`max_t_factories`	Integer	Jumlah maksimum salinan pabrik T. Estimator Sumber Daya menentukan sumber daya yang diperlukan dengan memilih jumlah optimal salinan pabrik T yang meminimalkan jumlah qubit fisik yang digunakan, tanpa mempertimbangkan overhead waktu. Parameter `max_t_factories` membatasi jumlah maksimum salinan, dan karena itu sesuaikan jumlah siklus logis yang sesuai. Untuk informasi selengkapnya, lihat Estimasi fisik pabrik T.
`max_duration`	string waktu	Runtime maksimum untuk algoritma. Estimator Sumber Daya hanya menerima salah `max_duration` satu atau `max_physical_qubits` batasan pada saat itu tetapi bukan dua. Jika `max_duration` ditentukan, Estimator Sumber Daya mencoba menemukan perkiraan terbaik untuk `max_physical_qubits` di antara solusi yang dibatasi oleh angka maksimal yang ditentukan.
`max_physical_qubits`	Integer	Jumlah maksimum kubit fisik untuk algoritma. Estimator Sumber Daya hanya menerima salah `max_duration` satu atau `max_physical_qubits` batasan pada saat itu tetapi bukan dua. Jika `max_physical_qubits` ditentukan, Estimator Sumber Daya mencoba menemukan perkiraan terbaik untuk `max_duration` di antara solusi yang dibatasi oleh angka maksimal yang ditentukan.

Kode berikut menunjukkan cara menentukan batasan untuk algoritma kuantum:

from qsharp.estimator import EstimatorParams

params = EstimatorParams()

params.constraints.max_duration = "1 s"
params.constraints.logical_depth_factor = 1.5
params.constraints.max_t_factories = 10

Catatan

Jika nilai yang diberikan kepada max_duration atau max_physical_qubits terlalu kecil untuk menemukan solusi yang layak, Estimator Sumber Daya mengembalikan kesalahan. Jika tidak ada max_duration batasan atau max_physical_qubits batasan yang ditentukan, Estimator Sumber Daya bertujuan untuk menemukan solusi dengan waktu terpendek.

Tip

Anda dapat menggunakan max_duration dan max_physical_qubits untuk memengaruhi ruang solusi, berpotensi menemukan solusi dengan runtime yang lebih lama tetapi jumlah qubit yang lebih kecil dibandingkan dengan solusi tanpa batasan ini. Ada trade-off antara runtime dan jumlah qubit, dan trade-off ini dapat dikelola secara efisien untuk beberapa algoritma, dengan berbagai efek pada algoritma yang berbeda. Tabel IV di [arXiv:2211.07629] menggambarkan pemanfaatan efektif trade-off antara jumlah kubit dan runtime untuk algoritma dinamika kuantum. Untuk informasi selengkapnya, lihat Estimasi sumber daya Kuantum dengan sampel batasan waktu atau jumlah kubit .

Unit penyulingan

Anda dapat memberikan spesifikasi untuk algoritma penyulingan pabrik T dengan DistillationUnitSpecification kelas . Spesifikasinya dapat ditentukan sebelumnya atau kustom. Anda dapat menentukan spesifikasi yang telah ditentukan sebelumnya dengan memilih nama unit distilasi: 15-1 RM atau 15-1 space-efficient.

from qsharp.estimator import EstimatorParams, DistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.name = "15-1 RM" # predefined distillation unit

params.distillation_unit_specifications.append(unit)

Dalam kedua kasus, notasi 15-1 adalah singkatan dari 15 status T input dan 1 status T output. Unit 15-1 space-efficient penyulingan menggunakan lebih sedikit qubit daripada 15-1 RM tetapi membutuhkan lebih banyak runtime. Untuk informasi selengkapnya, lihat Tabel VI.

Tip

Menggunakan unit distilasi yang telah ditentukan sebelumnya memberikan performa yang lebih baik dibandingkan dengan yang kustom.

Menyesuaikan unit penyulingan Anda

Anda dapat menyesuaikan unit penyulingan Anda sendiri. Parameter yang tepat untuk unit penyulingan adalah sebagai berikut.

qsharp.estimate("RunProgram()", params=
                    {"distillationUnitSpecifications": {
                        "displayName": <string>, 
                        "numInputTs": <int>,
                        "numOutputTs": <int>,
                        "failureProbabilityFormula": <string>,
                        "outputErrorRateFormula": <string>,
                        "physicalQubitSpecification": <protocol specific parameters>, 
                        "logicalQubitSpecification": <protocol specific parameters>, 
                        "logicalQubitSpecificationFirstRoundOverride": <protocol specific parameters>, # Only if "logicalQubitSpecification"
                        }
                })

Semua parameter numerik diharapkan positif. displayName menentukan bagaimana unit penyulingan akan ditampilkan dalam hasil output.

Kode berikut menunjukkan cara menentukan parameter unit distilasi untuk algoritma kuantum menggunakan DistillationUnitSpecification kelas dan ProtocolSpecificDistillationUnitSpecification kelas .

from qsharp.estimator import EstimatorParams, DistillationUnitSpecification, ProtocolSpecificDistillationUnitSpecification

params = EstimatorParams()
unit = DistillationUnitSpecification()
unit.display_name = "T"
unit.failure_probability_formula = "c"
unit.output_error_rate_formula = "r"
unit.num_input_ts = 1
unit.num_output_ts = 2

physical_qubit_specification = ProtocolSpecificDistillationUnitSpecification()
physical_qubit_specification.num_unit_qubits = 1
physical_qubit_specification.duration_in_qubit_cycle_time = 2
unit.physical_qubit_specification = physical_qubit_specification

Rumus untuk failure_probability_formula dan output_error_rate_formula adalah rumus kustom dengan operasi aritmatika dasar, konstanta, dan hanya tiga parameter:

clifford_error_rate, juga ditandai sebagai c.
readout_error_rate, juga ditandai sebagai r.
input_error_rate, juga ditandai sebagai z.

Lihat contoh rumus kustom berikut menggunakan notasi panjang dan pendek. Contoh-contoh ini menggambarkan rumus yang digunakan secara default dalam implementasi standar.

Parameter	Rumus panjang	Rumus pendek
`failure_probability_formula`	"15,0 * input_error_rate + 356,0 * clifford_error_rate"	"15,0 * z + 356,0 * c"
`output_error_rate_formula`	"35,0 * input_error_rate ^ 3 + 7,1 * clifford_error_rate"	"35,0 * z ^ 3 + 7,1 * c"

Setidaknya salah satu parameter physical_qubit_specification atau logical_qubit_specification harus disediakan. Jika hanya yang pertama yang disediakan, unit penyulingan dapat diterapkan pada kubit fisik. Jika hanya yang terakhir yang disediakan, unit penyulingan dapat diterapkan ke kubit logis. Jika keduanya disediakan, unit penyulingan dapat diterapkan ke kedua jenis qubit.

Parameter logical_qubit_specification_first_round_override hanya dapat disediakan jika logical_qubit_specification ditentukan. Jika demikian, ini akan mengambil alih nilai logical_qubit_specification jika diterapkan pada putaran pertama penyulingan. Nilai <protocol specific parameters> yang diperlukan untuk logical_qubit_specification_first_round_override harus mengikuti skema:

{
    "numUnitQubits": <int>,
    "durationInQubitCycleTime": <double>
}

Estimasi perlahan Pareto

Saat memperkirakan sumber daya algoritma, penting untuk mempertimbangkan tradeoff antara jumlah kubit fisik dan runtime algoritma. Anda dapat mempertimbangkan alokasi kubit fisik sebanyak mungkin untuk mengurangi runtime algoritma. Namun, jumlah qubit fisik dibatasi oleh jumlah kubit fisik yang tersedia di perangkat keras kuantum. Memahami tradeoff antara runtime dan skala sistem adalah salah satu aspek estimasi sumber daya yang lebih penting.

Estimasi perbatasan Pareto memberikan beberapa perkiraan untuk algoritma yang sama, masing-masing menunjukkan tradeoff antara jumlah qubit dan runtime.

Catatan

Jika Anda menjalankan Estimator Sumber Daya di Visual Studio Code menggunakan Q#opsi : Hitung Perkiraan Sumber Daya, estimasi perbatasan Pareto diaktifkan secara default.

Jika Anda menjalankan Estimator Sumber Daya di Python, Anda perlu menentukan "estimateType" parameter sebagai "frontier".

result = qsharp.estimate("RunProgram()", params=
                    {"qubitParams": { "name": "qubit_maj_ns_e4" },
                    "qecScheme": { "name": "surface_code" },
                    "estimateType": "frontier", # Pareto frontier estimation
                    }
                )

Jika Anda ingin memvisualisasikan hasil estimasi perbatasan Pareto, Anda dapat menggunakan fungsi .EstimatesOverview Fungsi ini menampilkan hasil estimasi frontier dalam tabel dan diagram ruang-waktu. Untuk informasi selengkapnya, lihat Diagram Space-time.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Catatan

Jika Anda mengalami masalah saat bekerja dengan Estimator Sumber Daya, lihat halaman Pemecahan Masalah, atau hubungi AzureQuantumInfo@microsoft.com.

Bagikan melalui

target Menyesuaikan parameter Estimator Sumber Daya

Prasyarat

Parameter Target

Parameter kubit fisik

Parameter untuk parameter kubit yang telah ditentukan sebelumnya

Meneruskan parameter kubit yang telah ditentukan sebelumnya

Mengkustomisasi parameter kubit yang telah ditentukan sebelumnya

Parameter qubit untuk qubit berbasis Gerbang

Parameter qubit untuk kubit Majorana

Skema koreksi kesalahan quantum

Parameter untuk skema QEC yang telah ditentukan sebelumnya

Meneruskan skema QEC yang telah ditentukan sebelumnya

Menyesuaikan skema QEC yang telah ditentukan sebelumnya

Menyesuaikan skema QEC Anda

Anggaran kesalahan

Meneruskan anggaran kesalahan

Kendala

Unit penyulingan

Menyesuaikan unit penyulingan Anda

Estimasi perlahan Pareto

Langkah berikutnya

Saran dan Komentar

Sumber Daya Tambahan: