target Kaynak Tahmin Aracı'nın parametrelerini özelleştirme

Bu makalede, Azure Quantum Kaynak Tahmin Aracı'nın parametrelerini hedeflediğiniz makine özellikleriyle eşleşecek şekilde nasıl özelleştirebileceğiniz 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.

Önkoşullar

• Python ve Pip'in yüklü olduğu bir Python ortamı.

• Visual Studio Code'un en son sürümü veya Vs Code'un Web'de 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 
  

Target Parametre

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

Bu nedenle Kaynak Tahmin Aracı, kolayca kullanmaya başlamanızı sağlamak için önceden tanımlanmış değerler içeren 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 süre.
• 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 kubit sayısı ve çalışma zamanı için birden fazla tahmin ç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 ortak ölçüm işlemleri sağlar.

Dört tane kapı tabanlı yönerge kümesi ve ikisi Majorana yönerge kümesine sahip olmak üzere önceden tanımlanmış altı kubit parametresi arasından seçim yapabilirsiniz. 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 yeterince araştırılmasını sağlar.

Önceden tanımlanmış kubit parametreleri için parametreler

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

Program aracılığıyla önceden tanımlanmış kubit parametrelerini 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ına EstimatorParams QubitParamsgeç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

Önceden tanımlanmış kubit parametrelerini, adı belirtip diğer değerlerden herhangi birini güncelleştirerek özelleştirebilirsiniz. Örneğin, "qubit_maj_ns_e4" içinde iki kubitli birleştirme ö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

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

Majorana kubitleri için kubit parametreleri

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

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 sayı çifti olabilir <double> . Örneğin:

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

Kuantum hata düzeltme düzenleri

Pratik ölçekli kuantum uygulamalarını yürütmek için kuantum işlemleri düşük hata oranlarına sahip 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 kuantum bilgilerini temel alınan fiziksel kubitlerden daha iyi koruyan daha güvenilir bir mantıksal kubit oluşturmamıza olanak tanı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 $a$ bir geçiş ön faktörüdür, $d$ kod uzaklığıdır, $p$ fiziksel hata oranıdır ve $p^*$ kuantum hata düzeltme eşiğidir. Çapraz ön faktör $a$ simülasyonlar için sayısal olarak ayıklanabilir.

$d$ kod uzaklığı, düzeltilebilen hata sayısını denetleen bir parametredir. Bu nedenle, kod uzaklığı mantıksal kubitlerin hata oranını ve bunları kodlamak için gereken fiziksel kubit sayısını tanımlar. Kod uzaklığı ile hem doğruluk hem de fiziksel kubit sayısı artar. QEC şemasının amacı, belirli bir uygulama için ayarlanan gerekli hata oranına ulaşabilecek en düşük kod uzaklığı bulmaktır.

$p$ fiziksel hata oranı, kubit parametrelerinden, cihazda gerçekleştirilen fiziksel Clifford işleminin 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_rate), Majorana yönerge kümesine sahip kubit parametreleri için $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.

Azure Quantum Kaynak Tahmin Aracı önceden tanımlanmış iki QEC şemasını destekler: bir yüzey kodu ve bir floquet kodu.

Önceden tanımlanmış QEC düzenleri için parametreler

Önceden tanımlanmış her QEC şeması için tam parametreler şunlardır.

{
    "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. ç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ı kullanarak tahmin parametrelerinin listesini sınıfına EstimatorParams QECScheme 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

Önceden tanımlanmış QEC düzenlerini, adı belirtip diğer değerlerden herhangi birini güncelleştirerek özelleştirebilirsiniz. Örneğin, floquet 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,
                    }
                })

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şlem 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şkenlerininone_qubit_gate_time yanı 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 eccDistance öğesini 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ıdır 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, çıktıların gerçekten girişin en önemli faktörleri olup olmadığını denetleyebildiği için hata bütçesi için büyük bir değere tolerans gösterilebilir. Ö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} $$

Mantıksal hatalar $\epsilon_{\log}$ mantıksal kubit uygulama hatasıdır, T durumu hatası $\epsilon_{\rm dis}$ damıtma yoluyla T durumları oluşturma hatasıdır ve döndürme kapısı hatası $\epsilon_{\rm syn}$ döndürme geçitlerini rastgele açılarla sentezleme hatasıdır.

Distilasyon ve döndürme sentezi için ilgili $\epsilon_{\rm dis}$ ve $\epsilon_{\rm syn}$ hata bütçelerinin sırasıyla 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ına EstimatorParamsda 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

Sınırlamalar

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.

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

Damıtma birimleri

Sınıfıyla DistillationUnitSpecificationT 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.

Damıtma birimlerinizi özelleştirme

Kendi damıtma birimlerinizi özelleştirebilirsiniz. Damıtma birimleri için tam parametreler şunlardır.

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 distilasyon biriminin çıkış sonuçlarında nasıl görüntüleneceğini belirtir.

Aşağıdaki kod, sınıfını ve sınıfını kullanarak bir kuantum algoritması için distilasyon birimi parametrelerinin DistillationUnitSpecificationProtocolSpecificDistillationUnitSpecification 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.

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

Parametre logical_qubit_specification_first_round_override yalnızca belirtilirse logical_qubit_specification sağlanabilir. Bu durumda, distilasyonun logical_qubit_specification ilk turunda uygulanıp uygulanmaması durumunda değerlerini 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 bulunan fiziksel kubit sayısıyla sınırlıdır. Çalışma zamanı ile 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.

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)

Sonraki adımlar

• Kaynak Tahmin Aracı'nın sonuçlarını anlama
• İlk kaynak tahmininizi çalıştırma
• Kaynak Tahmin Aracı'nı çalıştırmanın farklı yolları
• Kaynak Tahmin Aracı ile büyük programları işleme
• Öğretici: Kuantum kimyası sorununun kaynaklarını tahmin edin