Personalizzare i target parametri dello strumento di stima delle risorse

Questo articolo illustra come personalizzare i target parametri di input dello strumento di stima delle risorse Microsoft Quantum in modo che corrispondano alle caratteristiche del computer di destinazione. Lo strumento di stima delle risorse usa questi parametri per stimare le risorse necessarie per eseguire un algoritmo quantistico in un computer quantistico.

Prerequisiti

• Un ambiente Python con Python e Pip installati.

• La versione più recente di Visual Studio Code (VS Code) o aprire VS Code per il Web.

• VS Code con installate le estensioni Microsoft Quantum Development Kit (QDK), Python e Jupyter.

• La libreria Python più recente qdk con l'aggiunta jupyter .

  python -m pip install --upgrade "qdk[jupyter]"
  

Parametri di destinazione

Lo strumento di stima delle risorse calcola la stima delle risorse, ad esempio il numero di qubit e il tempo di esecuzione, che sarebbe necessario implementare un determinato algoritmo quantistico in un computer quantistico con una determinata tecnologia qubit e un set fisso di scelte architetturali.

Lo strumento di stima delle risorse accetta un set di input, con valori predefiniti per iniziare facilmente:

• Modello di qubit fisico, che definisce le proprietà dei qubit fisici sottostanti.
• Schema QEC (Quantum Error Correction), che è lo schema di correzione degli errori quantistici presunto.
• Un budget di errore, ovvero l'errore complessivo consentito, definito come numero di volte in cui il programma può avere esito negativo.
• Vincoli a livello di componente, ovvero il numero di cicli logici e il numero di copie T della fabbrica.
• Unità di distillazione per specificare algoritmi di distillazione della fabbrica T.
• Stima della frontiera Pareto per eseguire più stime per il numero di qubit e il tempo di esecuzione per lo stesso algoritmo.

Parametri qubit fisici

Quando lo strumento di stima delle risorse modella i presupposti del qubit fisico, usa due diversi set di istruzioni fisiche per operare sui qubit. Il set di istruzioni fisiche può essere basato su porte logiche o su Majorana. Un set di istruzioni basato su gate fornisce la misurazione di qubit singolo, le porte a qubit singolo (incluse le porte T) e le porte a due qubit. Un set di istruzioni Majorana fornisce un gate T fisico, una misura a qubit singolo e operazioni di misurazione congiunta a due qubit.

È possibile scegliere tra sei parametri qubit predefiniti, quattro dei quali hanno un set di istruzioni basato su gate e due con un set di istruzioni Majorana. Questi modelli di qubit coprono un intervallo di tempi di funzionamento e percentuali di errore, in modo da poter esplorare sufficientemente i costi delle risorse necessari per eseguire applicazioni quantistice pratiche.

Parametri per qubit predefiniti

Per riferimento, i parametri qubit predefiniti completi sono i seguenti:

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

Trasmettere parametri predefiniti dei qubit

Esistono due modi per specificare parametri qubit predefiniti a livello di codice. Un modo consiste nel selezionare il nome del modello qubit per la qubitParams classe quando si esegue qsharp.estimate. Ad esempio, per selezionare il parametro qubit "qubit_maj_ns_e6" per un programma Q# che utilizza l'operazione RunProgram() per eseguire il tuo algoritmo, esegui il seguente codice Python:

from qdk import qsharp

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

Un altro modo consiste nel passare i parametri qubit alla EstimatorParams classe con QubitParams. Ad esempio, per selezionare il MAJ_NS_E6 parametro qubit, eseguire il codice seguente:

from qdk import qsharp
from qdk.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)

Personalizzare i parametri qubit predefiniti

Per personalizzare i parametri qubit predefiniti. specificare il nome e gli altri valori da modificare. Ad esempio, per ridurre il tasso di errore delle misurazioni congiunte di due qubit in qubit_maj_ns_e4, eseguire il codice seguente:

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

In alternativa, è possibile passare le istruzioni sotto forma di elenco.

from qsharp.estimator import EstimatorParams, QubitParams

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

Parametri dei qubit per qubit basati su porte

Il codice seguente illustra come specificare parametri qubit personalizzati per un set di istruzioni basato su gate:

from qdk.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

Parametri dei qubit di Majorana

Un modello minimo per un set di istruzioni Majorana con tutti i valori obbligatori è:

from qdk.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

Per one_qubit_measurement_error_rate e two_qubit_joint_measurement_error_rate, è possibile specificare le percentuali di errore che corrispondono alle letture delle misurazioni, readoute all'elaborazione delle misurazioni, process. Questi valori possono essere <double> numeri o coppie di numeri. Ad esempio:

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

Tutti i valori non specificati accettano un valore predefinito. Ad esempio, se si specifica "qubit": {"oneQubitGateTime":"200 ns"}, lo strumento di stima delle risorse modella un qubit basato su gate in cui sia il tempo di gate a due qubit che il tempo di gate a un qubit sono 200 ns. Per le unità, è necessario specificare stringhe temporali, ovvero numeri a virgola mobile a precisione doppia seguiti da uno spazio e dall'unità temporale per tali valori. I suffissi time supportati sono ns, µs (o us), mse s.

Schemi di correzione degli errori quantistici

Per eseguire applicazioni quantistice su scala pratica, le operazioni quantistico devono avere frequenze di errore basse. Queste velocità targets di errore sono in genere superiori alle funzionalità dei qubit fisici non elaborati. Per superare questa limitazione, la correzione degli errori quantistici (QEC) e il calcolo a tolleranza di errore sono due tecniche cruciali che costituiscono i blocchi predefiniti dei computer quantistici su larga scala. Gli schemi QEC creano qubit logici a tolleranza di errore da gruppi più grandi di singoli qubit fisici soggetti a errori. I qubit logici mantengono le informazioni quantistiche migliori rispetto ai qubit fisici sottostanti.

Lo strumento di stima delle risorse usa la formula esponenziale seguente per modellare le percentuali di errore logiche,

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

dove $a$ è un pre-fattore di attraversamento, $d$ è la distanza di codice, $k$ è una potenza del coefficiente di distanza (in genere impostata su 0), $p$ è la frequenza di errore fisica e $p^*$ è la soglia di correzione degli errori quantistici. È possibile estrarre numericamente il pre-fattore $a$ per l'uso nelle simulazioni.

La distanza di codice $d$ è un parametro che controlla il numero di errori che possono essere corretti. La distanza del codice definisce la frequenza di errore dei qubit logici e il numero di qubit fisici necessari per codificare i qubit logici. Sia l'accuratezza che il numero di qubit fisici aumentano con la distanza del codice. L'obiettivo di uno schema QEC è trovare la distanza minima del codice che può raggiungere la frequenza di errore necessaria impostata per una determinata applicazione.

La frequenza di errore fisica $p$ viene estratta dai parametri qubit come percentuale di errori peggiore di qualsiasi operazione Clifford fisica eseguita nel dispositivo. In particolare, $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) per i parametri qubit con un set di istruzioni basato su gate e $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) per i parametri qubit con un set di istruzioni Majorana. Gli schemi QEC hanno in genere una soglia di frequenza degli errori $p^*$ al di sotto della quale la correzione degli errori elimina gli errori.

Lo strumento di stima delle risorse Microsoft Quantum supporta due schemi QEC predefiniti: un codice di superficie e un codice floquet.

Parametri per schemi QEC predefiniti

I parametri esatti per ogni schema QEC predefinito sono i seguenti:

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

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

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

Passaggio di schemi QEC predefiniti

Esistono due modi per specificare schemi QEC predefiniti. È possibile selezionare il nome del modello QEC per la "qecScheme" classe quando si esegue qsharp.estimate. Ad esempio, per selezionare il codice floquet, eseguire il codice seguente:

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

È anche possibile passare un elenco di parametri di stima alla EstimatorParams classe con la QECScheme classe . Ad esempio, per selezionare il codice floquet, eseguire il codice seguente:

from qdk import qsharp
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)

Personalizzare gli schemi QEC predefiniti

Per personalizzare schemi QEC predefiniti, specificare il nome e gli altri valori da modificare. Ad esempio, per aumentare il pre-fattore di attraversamento nel codice floquet, eseguire il codice seguente:

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

Personalizzare gli schemi QEC

Lo strumento di stima delle risorse può astrarre uno schema QEC personalizzato basato sulla formula precedente fornendo valori per il "crossingPrefactor" $a$, il distanceCoefficientPower $k$e il "errorCorrectionThreshold" $p^*$. È anche necessario specificare "logicalCycleTime", ovvero il tempo necessario per eseguire una singola operazione logica e che dipende dalla distanza del codice e dai presupposti del tempo dell'operazione fisica dei qubit fisici sottostanti. Un'altra formula calcola "physicalQubitsPerLogicalQubit", ovvero il numero di qubit fisici necessari per codificare un qubit logico in base alla distanza del codice.

È possibile usare il codice seguente come modello per gli schemi QEC:

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

All'interno delle formule è possibile usare le variabili one_qubit_gate_time, two_qubit_gate_time, one_qubit_measurement_timee two_qubit_joint_measurement_time. I valori di queste variabili provengono dai campi corrispondenti dai parametri del qubit fisico, nonché dalla variabile eccDistance per la distanza di codice calcolata per il qubit logico, dalla soglia di correzione degli errori e dal prefactoring di incrocio. Le variabili di ora e eccDistance possono essere usate per descrivere la logicalCycleTime formula. Per la formula physicalQubitsPerLogicalQubit, è possibile usare solo il eccDistance.

Budget di errore

Il budget totale degli errori $\epsilon$ imposta l'errore complessivo tollerato per l'algoritmo, ovvero la probabilità di errore consentita dell'algoritmo. Il valore globale deve essere compreso tra 0 e 1 e il valore predefinito è 0,001, che corrisponde allo 0,1%. In altre parole, l'algoritmo può non riuscire al massimo una volta in 1000 esecuzioni. Questo parametro è estremamente specifico dell'applicazione.

Ad esempio, se si esegue l'algoritmo di Shor per considerare numeri interi di grandi dimensioni, è possibile tollerare un valore elevato per il budget degli errori perché è possibile verificare se gli output sono i fattori primi dell'input. D'altra parte, potrebbe essere necessario un budget di errore inferiore per un algoritmo che risolve un problema con una soluzione che non è possibile verificare in modo efficiente.

Il budget degli errori corrisponde alla somma di tre parti:

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

Gli errori logici $\epsilon_{\log}$ sono l'errore di implementazione di qubit logici, l'errore di stato T $\epsilon_{\rm dis}$ è l'errore di produzione di stati T tramite la distillazione e l'errore del gate di rotazione $\epsilon_{\rm syn}$ è l'errore di sintesi dei cancelli di rotazione con angoli arbitrari.

Per la distillazione e la sintesi della rotazione, i rispettivi budget di errore $\epsilon_{\rm dis}$ e $\epsilon_{\rm syn}$ vengono distribuiti in modo uniforme tra tutti gli stati T obbligatori e tutti i gate di rotazione necessari, rispettivamente. Se nell'algoritmo di input non sono presenti controlli di rotazione, il budget degli errori viene distribuito in modo uniforme agli errori logici e agli errori di stato T.

Superare il limite degli errori

Esistono due modi per specificare il budget degli errori. Un modo consiste nel passare il budget degli errori quando si esegue qsharp.estimate. Ad esempio, per selezionare un budget di errore di 1/3, eseguire il codice seguente:

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

È anche possibile passare i parametri del budget degli errori alla classe .

from qdk import qsharp
from qdk.estimator import EstimatorParams, QubitParams, QECScheme

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

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

Inoltre, è possibile specificare singolarmente ogni componente del budget degli errori. La somma di tutti i valori è il budget totale degli errori e deve essere compresa tra 0 e 1. Se un algoritmo quantistico non contiene stati O rotazioni T, i valori di t_states e rotations possono essere rispettivamente 0.

Il codice seguente illustra come specificare il parametro budget degli errori con stati T e rotazioni:

from qdk.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

Vincoli

È possibile usare l'attributo constraints della EstimatorParams classe per applicare vincoli al livello del componente della factory T . Quando si modificano i vincoli, è possibile ottimizzare le stime per ridurre il numero di qubit, ma aumentare il tempo di esecuzione o ridurre il tempo di esecuzione, ma aumentare il numero di qubit.

Il codice seguente illustra come specificare i vincoli per un algoritmo quantistico:

from qdk.estimator import EstimatorParams

params = EstimatorParams()

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

Se il valore specificato per max_duration o max_physical_qubits è troppo piccolo per trovare una soluzione fattibile, lo strumento di stima delle risorse restituisce un errore. Se non si specifica un valore per max_duration o max_physical_qubits, lo strumento di stima delle risorse assegna priorità alle stime ottimizzate per il tempo di esecuzione più breve.

Unità di distillazione

È possibile fornire le specifiche per gli algoritmi di distillazione della fabbrica T con la DistillationUnitSpecification classe. La specifica può essere predefinita o personalizzata. Per specificare una specifica predefinita, utilizzare il nome 15-1 RM dell'unità di distillazione o 15-1 space-efficient. Ad esempio, vedere il codice seguente:

from qdk.estimator import EstimatorParams, DistillationUnitSpecification

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

params.distillation_unit_specifications.append(unit)

In entrambi i casi, 15-1 indica 15 stati T di input e 1 stato T di output. L'unità di distillazione 15-1 space-efficient utilizza meno qubit rispetto a 15-1 RM, ma richiede un tempo di esecuzione più lungo. Per altre informazioni, vedi Tabella VI.

Personalizza le unità di distillazione

È possibile personalizzare le proprie unità distillazione. I parametri esatti per le unità di distillazione sono i seguenti:

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

Tutti i parametri numerici devono essere positivi. displayName Specifica come l'unità di distillazione viene visualizzata nei risultati dell'output.

Il codice seguente illustra come specificare i parametri dell'unità di convalida per un algoritmo quantistico con la DistillationUnitSpecification classe e la ProtocolSpecificDistillationUnitSpecification classe .

from qdk.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

Le formule per failure_probability_formula e output_error_rate_formula sono formule personalizzate con operazioni aritmetiche e costanti di base. Queste formule hanno solo i parametri seguenti:

• clifford_error_rate, indicato anche come c.
• readout_error_rate, indicato anche come r.
• input_error_rate, indicato anche come z.

Vedere gli esempi seguenti di formule personalizzate in notazione lunga e breve. Questi esempi sono le formule predefinite usate dall'implementazione standard.

Specificare i valori per almeno uno dei parametri, physical_qubit_specification o logical_qubit_specification. Se si specifica solo failure_probability_formula, allora l'unità di distillazione viene applicata ai qubit fisici. Se si fornisce solo output_error_rate_formula, la distillazione viene applicata ai qubit logici. Se si specificano entrambi i parametri, l'unità di distillazione viene applicata a entrambi i tipi di qubit.

È possibile specificare un valore solo per il logical_qubit_specification_first_round_override parametro quando si specifica anche un valore per il logical_qubit_specification parametro . Il parametro logical_qubit_specification_first_round_override sovrascrive il valore di logical_qubit_specification quando applicato al primo round di distillazione. Il valore <protocol specific parameters> è obbligatorio per logical_qubit_specification_first_round_overridee deve avere lo schema seguente:

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

Stima della frontiera Pareto

Eseguire una stima della frontiera Pareto

Quando si stimano le risorse necessarie per eseguire un algoritmo, è importante considerare il compromesso tra il numero di qubit fisici e il runtime dell'algoritmo. Se si usano più qubit, è probabile che sia possibile ridurre il runtime dell'algoritmo. Tuttavia, il numero di qubit fisici che è possibile usare è limitato dalla progettazione hardware.

La stima della frontiera Pareto fornisce più stime per lo stesso algoritmo. Ogni stima mostra i compromessi tra il numero di qubit e il tempo di esecuzione.

Per eseguire lo strumento di stima delle risorse in Python, è necessario specificare il "estimateType" parametro come "frontier".

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

Per visualizzare i risultati della stima della frontiera Pareto, è possibile usare la EstimatesOverview funzione . Queste funzioni visualizzano i risultati della stima della frontiera in una tabella e in un diagramma spazio-tempo. Per altre informazioni, vedere Diagramma spazio-tempo.

from qdk.widgets import EstimatesOverview

EstimatesOverview(result)

Passaggi successivi

• Informazioni sui risultati dello strumento di stima delle risorse
• Eseguire la prima stima delle risorse
• Modi diversi per eseguire lo strumento di stima delle risorse
• Gestire programmi di grandi dimensioni con lo strumento di stima delle risorse
• Esercitazione: Stimare le risorse di un problema di chimica quantistica