target Kaynak Tahmin Aracı parametrelerini özelleştirme

Makale
02/06/2024

Bu makalede, Azure Quantum Kaynak Tahmin Aracı'nın parametrelerinin, kullanmakta olduğunuz targetmakine özellikleriyle eşleşecek şekilde nasıl özelleştirileceği target gösterilmektedir. Kaynak Tahmin Aracı, kuantum bilgisayarda kuantum algoritması çalıştırmak için gereken kaynakları tahmin etmek için bu parametreleri kullanır.

Not

Kaynak Tahmin Aracı ile çalışırken herhangi bir sorunla karşılaşırsanız Sorun Giderme sayfasına göz atın.

Önkoşullar

Python ve Pip'in yüklü olduğu bir Python ortamı.
Visual Studio Code'nin en son sürümü veya Web'de VS Code'un açılması.
Azure Quantum Geliştirme Seti, Python ve Jupyter uzantılarının yüklü olduğu VS Code.

En son Azure Quantum qsharp ve qsharp-widgets paketleri.

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

Hedef parametreler

Kaynak Tahmin Aracı, belirli bir kubit teknolojisini kullanarak ve sabit bir mimari seçenek kümesiyle belirli bir kuantum algoritması uygulamak için gerekli olabilecek kubit sayısı ve çalışma süresi gibi kaynakların tahminini hesaplar.

Bu nedenle Kaynak Tahmin Aracı, kolayca çalışmaya başlamanızı sağlamak için önceden tanımlanmış değerlerle birlikte bir dizi giriş alır:

Temel alınan fiziksel kubitlerin özelliklerini tanımlayan fiziksel kubit modeli.
Varsayılan kuantum hata düzeltme düzeni olan Kuantum Hata Düzeltmesi (QEC) şeması.
Genel olarak izin verilen hata olan bir hata bütçesi, yani programın başarısız olması için izin verilen sayıdır.
Mantıksal döngü sayısı ve T fabrika kopyalarının sayısı olan bileşen düzeyindeki kısıtlamalar.
T fabrikaları damıtma algoritmalarını belirtmek için damıtma birimleri.
Aynı algoritma için birden fazla kubit ve çalışma zamanı tahmini çalıştırmak için Pareto sınır tahmini.

Fiziksel kubit parametreleri

Kaynak Tahmin Aracı fiziksel kubit varsayımlarını modellediğinde, kubitleri çalıştırmak için iki farklı fiziksel yönerge kümesi kullanır. Fiziksel yönerge kümesi , geçit tabanlı veya Majorana olabilir. Geçit tabanlı yönerge kümesi tek kubitli ölçüm, tek kubitli geçitler (T geçitleri dahil) ve iki kubitli geçitler sağlar. Majorana yönerge kümesi fiziksel T kapısı, tek kubitli ölçüm ve iki kubitli eklem ölçüm işlemleri sağlar.

Önceden tanımlanmış altı kubit parametresinden birini seçebilirsiniz. Bu parametrelerden dördü kapı tabanlı yönerge kümesine ve ikisi de Majorana yönerge kümesine sahiptir. Bu kubit modelleri çeşitli işlem sürelerini ve hata oranlarını kapsar ve pratik kuantum uygulamalarını etkinleştirmek için gereken kaynak maliyetlerinin araştırılmasını sağlar.

Qubit parametresi	Python API sınıfı	Description
`"qubit_gate_ns_e3"` , `"qubit_gate_ns_e4"`	`GATE_NS_E3` , `GATE_NS_E4`	İşlem süreleri ve aslına uygunluk, süper iletken transmon kubitlerinin gelecekteki sürümlerine veya genellikle nanosaniye rejiminde işlem sürelerine sahip olan spin kubitlerine karşılık gelebilir. Bu kubitler için geçit ve ölçüm işlemlerinin sırasıyla 50 ns ve 100 ns olduğu varsayılır. Tek kubitli ve iki kubitli kapı hata oranlarının gerçekçi targetolarak $10^{-3}$ ve ölçeği genişletilmiş bir sistem için iyimser target olarak $10^{-4}$ olduğu varsayılır.
`"qubit_gate_us_e3"` , `"qubit_gate_us_e4"`	`GATE_US_E3` , `GATE_US_E4`	İşlem süreleri ve aslına uygunlukları, genellikle mikrosaniye rejiminde operasyon süreleri olan iyonlara dayalı kubitlerin gelecekteki sürümlerine karşılık gelebilir. İyon kubitleri için tipik varsayımlara göre, geçit ve ölçüm işlemlerinin 100 μs olduğu varsayılır. Tek kubitli Clifford geçitleri için hata oranı gerçekçi target olarak $10^{-3}$ ve iyimser targetolarak $10^{-4}$ olurken, Tek kubitli Olmayan Clifford geçitleri (T kapısı) için hata oranı $10^{-6}$ olur. İki kubitli geçitler için hata oranı gerçekçi target olarak $10^{-3}$ ve iyimser olarak $10^{-4}$ olurtarget.
`"qubit_maj_ns_e4"` , `"qubit_maj_ns_e6"`	`MAJ_NS_E4` , `MAJ_NS_E6`	İşlem süreleri ve aslına uygunluk, Majorana kubitlerinin gelecekteki geliştirilmiş sürümlerine karşılık gelebilir. Bu kubitler için geçit ve ölçüm işlemlerinin 100 ns olduğu varsayılır. Donanımda topolojik korumayı hesaba katmak için, tek kubitli ve iki kubitli birleşik ölçüm hata oranlarının (Clifford hata oranları) gerçekçi targetolarak $10^{-4}$ ve iyimser targetolarak $10^{-6}$ olduğu varsayılır. Bu mimarideki Clifford dışı işlemlerin topolojik koruması yoktur, Clifford olmayan fiziksel T geçitleri için hata oranı %5'tir.

Not

Başka bir değer belirtilmediği sürece, kubit modelinin varsayılan değeri şeklindedir "qubit_gate_ns_e3".

Başvuru için, önceden tanımlanmış kubit parametrelerinin tamamı aşağıdaki gibidir:

{
    "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
    }
}

Önceden tanımlanmış kubit parametrelerini geçirme

Önceden tanımlanmış kubit parametrelerini program aracılığıyla belirtmenin iki yolu vardır. komutunu çalıştırırken qsharp.estimatesınıfı için qubitParams kubit modeli adını seçebilirsiniz. Örneğin, kubit parametresini seçmek "qubit_maj_ns_e6" için şunu yazın:

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

Ayrıca kullanarak kubit parametrelerini sınıfınaEstimatorParamsQubitParamsgeçirebilirsiniz. Örneğin, kubit parametresini seçmek MAJ_NS_E6 için şunu yazın:

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)

Önceden tanımlanmış kubit parametrelerini özelleştirme

Adı belirtip diğer değerlerden herhangi birini güncelleştirerek önceden tanımlanmış kubit parametrelerini özelleştirebilirsiniz. Örneğin, "qubit_maj_ns_e4" içinde iki kubitli eklem ölçümünün hata oranını azaltmak için şunu yazın:

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

İsterseniz, yönergeleri liste biçiminde de geçirebilirsiniz.

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

Geçit tabanlı kubitler için kubit parametreleri

Python tanımlayıcısı	Veri türü	Description
`name`	dize	Kubit modelinin adı
`instruction_set`	"gate_based"	Temel alınan kubit teknolojisi
`one_qubit_measurement_time`	zaman dizesi	Ns cinsinden tek kubitli ölçüm ($t_{\rm meas}$) için işlem süresi
`one_qubit_gate_time`	zaman dizesi	ns cinsinden tek kubitli kapı ($t_{\rm gate}$) için işlem süresi
`two_qubit_gate_time`	zaman dizesi	ns olarak iki kubitli kapı için işlem süresi
`t_gate_time`	zaman dizesi	Ns olarak Clifford olmayan tek kubitli kapı için işlem süresi
`one_qubit_measurement_error_rate`	float	Tek kubitli ölçüm için hata oranı
`one_qubit_gate_error_rate`	float	Tek kubitli Clifford kapısı ($p$) için hata oranı
`two_qubit_gate_error_rate`	float	İki kubitli Clifford kapısı için hata oranı
`t_gate_error_rate`	float	Tek kubitli Clifford olmayan durumu ($p_T$) hazırlamak için hata oranı
`idle_error_rate`	float	Rölantiye karşılık gelen hata oranı

Aşağıdaki kod, geçit tabanlı yönerge kümesi için özel kubit parametrelerinin nasıl belirtileceğini gösterir:

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

Not

Belirtilmediğinde, için ve varsayılan değerleri, için two_qubit_gate_error_rate ve t_gate_error_rate varsayılan one_qubit_gate_error_ratedeğerleri ile için varsayılan ve için idle_error_rate değeri varsayılan olarakdırone_qubit_measurement_error_rate.one_qubit_gate_timet_gate_timetwo_qubit_gate_time

Majorana kubitleri için kubit parametreleri

Python tanımlayıcısı	Veri türü	Description
`name`	dize	Kubit modelinin adı
`instruction_set`	"majorana"	Temel alınan kubit teknolojisi
`one_qubit_measurement_time`	zaman dizesi	Ns cinsinden tek kubitli ölçüm ($t_{\rm meas}$) için işlem süresi
`two-qubit_joint_measurement_time`	zaman dizesi	ns cinsinden iki kubitli ölçüm için işlem süresi
`t_gate_time`	zaman dizesi	Ns olarak Clifford olmayan tek kubitli kapı için işlem süresi
`one_qubit_measurement_error_rate`	float	Tek kubitli ölçüm için hata oranı
`two_qubit_joint_measurement_error_rate`	float	İki kubitli ölçüm için hata oranı
`t_gate_error_rate`	float	Tek kubitli Clifford olmayan durumu ($p_T$) hazırlamak için hata oranı
`idle_error_rate`	float	Rölantiye karşılık gelen hata oranı

Tüm gerekli değerleri içeren Majorana tabanlı yönerge kümesi için en düşük şablon:

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

Not

Belirtilmediğinde, için ve varsayılan değerleri, için two_qubit_joint_measurement_error_rate ve t_gate_error_rate varsayılan one_qubit_measurement_error_ratedeğerleri ile için varsayılan ve için idle_error_rate değeri varsayılan olarakdırone_qubit_measurement_error_rate.one_qubit_measurement_timet_gate_timetwo_qubitJointMeasurementTime

ve two_qubit_joint_measurement_error_rateiçinone_qubit_measurement_error_rate, ölçüm okumalarınareadout, ve ölçüm işlemeye processkarşılık gelen hata oranlarını belirtebilirsiniz. Bu değerler sayı veya <double> sayı çifti olabilir. Örnek:

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

Not

Majorana kubit ölçümünde tek kubit ve iki kubit hata oranları için tek bir sayısal değer belirtirseniz, hem okuma hem de işlem hata oranları eşit olabilir.

Önemli

Belirtilmeyen tüm değerler varsayılan bir değer alır, örneğin belirtmek "qubit": {"oneQubitGateTime":"200 ns"} , hem iki kubitli kapı saatinin hem de tek kubitli kapı süresinin 200 ns olduğu bir geçit tabanlı kubit modeller. Birimler için, çift duyarlıklı kayan nokta sayıları olan zaman dizelerini ve ardından bir boşluk ve bu değerler için zaman birimini belirtmeniz gerekir; burada olası zaman sonekleri , µs (veya us), msve solurns.

Kuantum hata düzeltme düzenleri

Pratik ölçekli kuantum uygulamalarını yürütmek için kuantum işlemlerinin düşük hata oranları olmalıdır. Bu hata oranı targets genellikle ham fiziksel kubitlerin özelliklerinin ötesindedir. Bu sınırlamayı aşmak için kuantum hata düzeltmesi (QEC) ve hataya dayanıklı hesaplama, büyük ölçekli kuantum bilgisayarların yapı taşları oluşturan iki önemli tekniktir. İlk olarak, QEC birden çok hataya açık fiziksel kubit oluşturmamıza ve temel alınan fiziksel kubitlerden daha iyi kuantum bilgilerini koruyan daha güvenilir bir mantıksal kubit oluşturmamıza olanak tanır.

Hata düzeltme kodu uzaklığı (veya yalnızca kısa kod uzaklığı) düzeltilebilen hata sayısını denetleen bir parametredir. Bu nedenle, mantıksal kubitlerin hata oranı ve bunları kodlamak için gereken fiziksel kubitlerin sayısı. Kod uzaklığı ile hem doğruluk hem de fiziksel kubit sayısı artar. Amaç, belirli bir uygulama için ayarlanan gerekli hata oranına ulaşabilecek minimum kod uzaklığı bulmaktır.

Kaynak Tahmin Aracı üstel bir model kullanarak mantıksal hata oranlarını modellemek için aşağıdaki formülü kullanır.

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

burada $d$ kod uzaklığıdır, $p$ fiziksel hata oranıdır ve $p^*$ kuantum hata düzeltme eşiğidir. Fiziksel hata oranı $p$ kubit parametrelerinden, cihazdaki herhangi bir fiziksel Clifford işlemi için en kötü durum hata oranı olarak ayıklanır.

Özellikle, geçit tabanlı yönerge kümesine sahip kubit parametreleri için $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate), two_qubit_gate_error_rateMajorana yönerge kümesine sahip kubit parametreleri için de $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) . QEC düzenleri genellikle hata düzeltmenin hataları gizlediği^*$ $p bir hata oranı eşiğine sahiptir.

QEC protokolü	Python API sınıfı	Description
"`surface_code`"	`SURFACE_CODE`	Kapı tabanlı yüzey kodu arXiv:1208.0928 ve arXiv:1009.3686'ya dayanır. Majorana yüzey kodu arXiv:1909.03002 ve arXiv:2007.00307'yi temel alır.
"`floquet_code`"	`FLOQUET_CODE`	Yalnızca Majorana kubitleri için. Floquet kodu arXiv:2202.11829'a dayanır.

Not

Başka bir değer belirtilmediği sürece, QEC şeması için varsayılan değer "surface_code" olur.

Önceden tanımlanmış her QEC şeması için tam parametreler (simülasyonlar için sayısal olarak ayıklanabilen çapraz ön faktör $a$ dahil) aşağıdaki gibidir.

{
    "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)"
    }
}

Önceden tanımlanmış QEC düzenlerini geçirme

Önceden tanımlanmış QEC düzenlerini belirtmenin iki yolu vardır. komutunu çalıştırırken qsharp.estimatesınıfı için "qecScheme" QEC modeli adını seçebilirsiniz. Örneğin, floquet kodunu seçmek için şunu yazın:

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

Ayrıca sınıfını kullanarakQECScheme sınıfa tahmin parametrelerinin EstimatorParams listesini geçirebilirsiniz. Örneğin, floquet kodunu seçmek için şunu yazın:

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)

Önceden tanımlanmış QEC düzenlerini özelleştirme

Adı belirtip diğer değerlerden herhangi birini güncelleştirerek önceden tanımlanmış QEC düzenlerini özelleştirebilirsiniz. Örneğin, floket kodunda geçiş ön faktörünü artırmak için şunu yazın:

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

Not

Belirtilmediğinde, için ve varsayılan değeri, için varsayılan değer "errorCorrectionThreshold"0.01olarak, değerinin değeri ise varsayılan olarakdır "crossingPrefactor"0.03."oneQubitMeasurementTime""physicalQubitsPerLogicalQubit""logicalCycleTime"

QEC şemalarınızı özelleştirme

Kaynak Tahmin Aracı, $a$ ve $p^*$ değerlerini "crossingPrefactor" sağlayarak yukarıdaki formüle göre özelleştirilmiş bir QEC şemasını "errorCorrectionThreshold" soyutlayabilir. Ayrıca, kod uzaklığı ve temel alınan fiziksel kubitlerin fiziksel işlem süresi varsayımlarına bağlı olarak tek bir mantıksal işlemi yürütme süresini belirtmeniz "logicalCycleTime"gerekir. Son olarak, ikinci bir formül, bir mantıksal kubiti kod uzaklığı temelinde kodlamak için gereken fiziksel kubit sayısını hesaplar "physicalQubitsPerLogicalQubit".

QEC düzenleri için şablon olarak aşağıdaki kodu kullanabilirsiniz:

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

Formüllerin içinde, değerleri fiziksel kubit parametrelerinden karşılık gelen alandan alınan , two_qubit_gate_timeone_qubit_measurement_time, ve two_qubit_joint_measurement_timedeğişkenlerinin one_qubit_gate_timeyanı sıra fiziksel kubit özelliklerine, hata düzeltme eşiğine ve geçiş ön düzenlemesine göre mantıksal kubit için hesaplanan kod uzaklığı değişkenini eccDistance kullanabilirsiniz. ve zaman değişkenleri eccDistance formülü açıklamak logicalCycleTime için kullanılabilir. Formül physicalQubitsPerLogicalQubit için yalnızca öğesini eccDistance kullanabilirsiniz.

Hata bütçesi

Toplam hata bütçesi $\epsilon$ algoritma için genel tolere edilen hatayı, yani algoritmanın izin verilen hata olasılığını ayarlar. Genel değeri 0 ile 1 arasında olmalı ve varsayılan değer %0,1'e karşılık gelen 0,001'dir. Başka bir deyişle algoritmanın 1000 yürütmede en fazla bir kez başarısız olmasına izin verilir. Bu parametre yüksek oranda uygulamaya özgüdür.

Örneğin, Shor'un tamsayıları çarpanlara ayırma algoritmasını çalıştırıyorsanız, çıkışların girişin en önemli faktörleri olup olmadığını denetleyebildiği için hata bütçesi için büyük bir değer tolere edilebilir. Öte yandan, etkili bir şekilde doğrulanabilen bir çözümle ilgili bir sorunu çözen bir algoritma için daha küçük bir hata bütçesi gerekebilir.

Hata bütçesi üç bölümün toplamına karşılık gelir:

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

Daha fazla belirtilmezse, $\epsilon$ hata bütçesi tekdüzen olarak dağıtılır ve mantıksal kubitleri uygulamak için $\epsilon_{\log}$ hatalarına uygulanır; $\epsilon_{\rm dis}$ hata bütçesi damıtma yoluyla T durumları üretir ve döndürme geçitlerini rastgele açılarla sentezlemek için $\epsilon_{\rm syn}$ hata bütçesi oluşturur.

Damıtma ve döndürme sentezi için ilgili hata bütçelerinin sırasıyla $\epsilon_{\rm dis}$ ve $\epsilon_{\rm syn}$ tüm gerekli T durumları ve tüm gerekli döndürme geçitleri arasında eşit olarak dağıtıldığını unutmayın. Giriş algoritmasında döndürme kapıları yoksa, hata bütçesi mantıksal hatalara ve T durumu hatalarına eşit olarak dağıtılır.

Hata bütçesini geçirme

0 ile 1 arasında bir sayı ayarlayarak hata bütçesini belirtmenin iki yolu vardır. komutunu çalıştırırken qsharp.estimatehata bütçesini geçirebilirsiniz. Örneğin, 1/3 hata bütçesini seçmek için şunu yazın:

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

Hata bütçesi parametrelerini sınıfınaEstimatorParams da geçirebilirsiniz.

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)

Ayrıca hata bütçesinin her bileşenini ayrı ayrı belirtebilirsiniz. Tüm değerlerin toplamı toplam hata bütçesidir ve 0 ile 1 arasında olmalıdır. Kuantum algoritması T durumları veya döndürmeleri içermiyorsa ve rotations değerleri t_states sırasıyla 0 olabilir.

Aşağıdaki kod, T durumları ve döndürmeleri ile hata bütçesi parametresinin nasıl belirtileceğini gösterir:

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

Kısıtlamalar

T fabrikası bileşen düzeyinde kısıtlamalar uygulamak için sınıfını kullanabilirsiniz"constraints". Kısıtlamaları ayarlayarak, kubit sayısını azaltmaya veya çalışma zamanını azaltmaya yönelik tahminleri iyileştirebilirsiniz.

Parametre	Veri türü	Açıklama
`logical_depth_factor`	float	Yürütme süresini denetleme. Değeri 1'den büyükse, mantıksal derinlik olarak da adlandırılan ilk mantıksal döngü sayısı bu sayı ile çarpılır. sayısını azaltarak `logical_depth_factor`, belirli bir süre içinde T fabrikasının çağrı sayısını artırarak aynı sayıda T durumu üretmek için gereken T fabrika kopyasının daha az olmasına neden olabilirsiniz. T fabrika kopyalarının sayısını azalttığınızda algoritma çalışma zamanı buna göre artar. Ek döngü sayısı nedeniyle gerekli mantıksal hata oranı arttığından toplam çalışma zamanı için ölçeklendirme faktörü daha büyük olabilir.
`max_t_factories`	tamsayı	En fazla T fabrika kopyası sayısı. Kaynak Tahmin Aracı, zaman ek yükünü dikkate almadan kullanılan fiziksel kubit sayısını en aza indiren en uygun T fabrika kopyası sayısını seçerek gereken kaynakları belirler. `max_t_factories` parametresi en fazla kopya sayısını sınırlar ve bu nedenle mantıksal döngü sayısını buna göre ayarlar. Daha fazla bilgi için bkz . T fabrika fiziksel tahmini.
`max_duration`	zaman dizesi	Algoritma için en yüksek çalışma zamanı. Kaynak Tahmin Aracı aynı anda yalnızca birini `max_duration` veya `max_physical_qubits` kısıtlamalarını kabul eder, ancak ikisini kabul etmemektedir. Belirtilirse `max_duration` , Kaynak Tahmin Aracı belirtilen maksimum sayı ile kısıtlanmış çözümler arasında için `max_physical_qubits` en iyi tahmini bulmaya çalışır.
`max_physical_qubits`	tamsayı	Algoritma için fiziksel kubit sayısı üst sınırı. Kaynak Tahmin Aracı aynı anda yalnızca birini `max_duration` veya `max_physical_qubits` kısıtlamalarını kabul eder, ancak ikisini kabul etmemektedir. Belirtilirse `max_physical_qubits` , Kaynak Tahmin Aracı belirtilen maksimum sayı ile kısıtlanmış çözümler arasında için `max_duration` en iyi tahmini bulmaya çalışır.

Aşağıdaki kod, kuantum algoritması için kısıtlamaların nasıl belirtileceğini gösterir:

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

Not

sağlanan veya max_physical_qubits için sağlanan max_duration değer uygun bir çözüm bulmak için çok küçükse, Kaynak Tahmin Aracı bir hata döndürür. Ne ne de max_durationmax_physical_qubits kısıtlamaları belirtilmezse, Kaynak Tahmin Aracı en kısa sürede bir çözüm bulmayı hedefler.

İpucu

Çözüm max_physical_qubits alanını etkileyip daha uzun çalışma zamanına sahip ancak bu kısıtlamalara sahip olmayan çözümlere kıyasla daha az sayıda kubite sahip çözümler bularak ve kullanabilirsinizmax_duration. Çalışma zamanı ile kubit sayısı arasında bir denge vardır ve bu dengeleme, farklı algoritmalar üzerindeki çeşitli etkilerle birlikte bazı algoritmalar için verimli bir şekilde yönetilebilir. [arXiv:2211.07629] içindeki Tablo IV, kuantum dinamiği algoritmaları için kubit sayısı ve çalışma zamanı arasındaki dengenin etkin kullanımını göstermektedir. Daha fazla bilgi için bkz . Zaman veya kubit sayısı kısıtlaması örneğiyle kuantum kaynağı tahmini .

Damıtma birimleri

sınıfıylaDistillationUnitSpecification T fabrikaları damıtma algoritmaları için belirtimler sağlayabilirsiniz. Belirtim önceden tanımlanmış veya özel olabilir. Damıtma birimi adını seçerek önceden tanımlanmış bir belirtim belirtebilirsiniz: 15-1 RM veya 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)

Her iki durumda da, 15-1 gösterimi 15 giriş T durumu ve 1 çıkış T durumu anlamına gelir. 15-1 space-efficient Damıtma birimi daha 15-1 RM az kubit kullanır ancak daha fazla çalışma zamanı gerektirir. Daha fazla bilgi için bkz . Tablo VI.

İpucu

Önceden tanımlanmış damıtma birimlerinin kullanılması, özel birimlerle karşılaştırıldığında daha iyi performans sağlar.

Damıtma birimlerinizi özelleştirme

Kendi damıtma birimlerinizi özelleştirebilirsiniz. Damıtma birimlerinin tam parametreleri aşağıdaki gibidir.

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"
                        }
                })

Tüm sayısal parametrelerin pozitif olması beklenir. , displayName damıtma biriminin çıkış sonuçlarında nasıl görüntüleneceğini belirtir.

Aşağıdaki kod, sınıfını ve ProtocolSpecificDistillationUnitSpecification sınıfını kullanarak kuantum algoritması için damıtma birimi parametrelerinin DistillationUnitSpecification nasıl belirtileceğini gösterir.

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

ve output_error_rate_formula formüllerifailure_probability_formula, temel aritmetik işlemler, sabitler ve yalnızca üç parametre içeren özel formüllerdir:

clifford_error_rateolarak da belirtilir c.
readout_error_rateolarak da belirtilir r.
input_error_rateolarak da belirtilir z.

Uzun ve kısa gösterimi kullanan aşağıdaki özel formül örneklerine bakın. Bu örnekler, standart uygulama içinde varsayılan olarak kullanılan formülleri gösterir.

Parametre	Uzun formül	Kısa formül
`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"

Parametrelerden physical_qubit_specification en az biri veya logical_qubit_specification sağlanmalıdır. Yalnızca önceki sağlanmışsa, damıtma birimi fiziksel kubitlere uygulanabilir. Yalnızca ikincisi sağlanmışsa, damıtma birimi mantıksal kubitlere uygulanabilir. Her ikisi de sağlanmışsa damıtma birimi her iki kubit türüne de uygulanabilir.

Parametresi logical_qubit_specification_first_round_override yalnızca belirtilirse logical_qubit_specification sağlanabilir. Bu durumda, damıtmanın ilk turunda uygulandığında değerini logical_qubit_specification geçersiz kılar. için logical_qubit_specification_first_round_override gereken değer <protocol specific parameters> şemaya uygun olmalıdır:

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

Pareto sınır tahmini

Bir algoritmanın kaynaklarını tahmin ederken, fiziksel kubit sayısı ile algoritmanın çalışma zamanı arasındaki dengeyi göz önünde bulundurmak önemlidir. Algoritmanın çalışma zamanını azaltmak için mümkün olduğunca çok fiziksel kubit ayırmayı düşünebilirsiniz. Ancak, fiziksel kubitlerin sayısı kuantum donanımında kullanılabilen fiziksel kubit sayısıyla sınırlıdır. Çalışma zamanı ve sistem ölçeği arasındaki dengeyi anlamak, kaynak tahmininin en önemli yönlerinden biridir.

Pareto sınır tahmini, aynı algoritma için her biri kubit sayısı ile çalışma zamanı arasındaki dengeleri gösteren birden çok tahmin sağlar.

Not

Kaynak Tahmin Aracı'nı Visual Studio Code'de : Kaynak Tahminlerini Hesapla seçeneğini kullanarakQ# çalıştırırsanız, Pareto sınır tahmini varsayılan olarak etkinleştirilir.

Python'da Kaynak Tahmin Aracı'nı çalıştırırsanız parametresini "estimateType" olarak "frontier"belirtmeniz gerekir.

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

Pareto sınır tahmininin sonuçlarını görselleştirmek istiyorsanız işlevini kullanabilirsiniz EstimatesOverview . Bu işlevler, tablodaki sınır tahmininin sonuçlarını ve bir uzay-zaman diyagramını görüntüler. Daha fazla bilgi için bkz . Uzay-zaman diyagramı.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Not

Kaynak Tahmin Aracı ile çalışırken herhangi bir sorunla karşılaşırsanız Sorun Giderme sayfasına göz atın veya ile iletişime geçin AzureQuantumInfo@microsoft.com.