Personalizzare i target parametri dello strumento di stima delle risorse

  • Articolo

Questo articolo illustra come personalizzare i target parametri dello strumento di stima delle risorse di Azure Quantum in modo che targetcorrispondano alle caratteristiche del computer in uso. Resource Estimator usa questi parametri per stimare le risorse necessarie per eseguire un algoritmo quantistico in un computer quantistico.

Nota

Se si verificano problemi durante l'uso di Resource Estimator, vedere la pagina Risoluzione dei problemi.

Prerequisiti

Parametri relativi alla destinazione

Resource Estimator calcola la stima delle risorse, ad esempio il numero di qubit e il tempo di esecuzione, che sarebbe necessario implementare un algoritmo quantistico specifico usando una determinata tecnologia qubit e con un set fisso di scelte architetturali.

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

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 i qubit. Il set di istruzioni fisiche può essere basato sull'attività di controllo o Majorana. Un set di istruzioni basato sull'attività di controllo fornisce la misurazione a qubit singolo, le attività a qubit singole (inclusi le attività T) e le attività T a due qubit. Un set di istruzioni Majorana fornisce un controllo T fisico, una misurazione a qubit singolo e operazioni di misurazione congiunta a due qubit.

È possibile scegliere tra sei parametri qubit predefiniti, quattro dei quali hanno set di istruzioni basati su gate e due con un set di istruzioni Majorana. Questi modelli qubit coprono una serie di tempi di funzionamento e percentuali di errore, consentendo un'esplorazione sufficiente dei costi delle risorse necessari per abilitare applicazioni quantistice pratiche.

Parametro Qubit Classe API Python Descrizione
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" GATE_NS_E3 , GATE_NS_E4 I tempi e le fidelità delle operazioni possono corrispondere alle versioni future dei qubit transconduttori o dei qubit di rotazione, che in genere hanno tempi operativi nel regime nanosecondo. Per questi qubit, si presuppone che le operazioni di controllo e misurazione prendano rispettivamente 50 ns e 100 ns. Si presuppone che i tassi di errore di gate a qubit e a due qubit siano $10^{-3}$ come realistico targete $10^{-4}$ come ottimista target per un sistema con scalabilità orizzontale.
"qubit_gate_us_e3" , "qubit_gate_us_e4" GATE_US_E3 , GATE_US_E4 I tempi e le fidelità delle operazioni possono corrispondere alle versioni future dei qubit in base agli ioni, che in genere hanno tempi operativi nel regime del microsecondo. In base ai presupposti tipici per i qubit di ion, si presuppone che le operazioni di controllo e misurazione prendano 100 μs. La frequenza di errore per i cancelli Clifford a qubit singolo è $10^{-3}$ come realistica target e $10^{-4}$ come ottimistica target, mentre la frequenza di errore per i gate non Clifford a qubit singolo (T gate) è $10^{-6}$. Per i gate a due qubit, la velocità di errore è $10^{-3}$ come realistica target e $10^{-4}$ come ottimistica target.
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" MAJ_NS_E4 , MAJ_NS_E6 I tempi e le fidelità delle operazioni possono corrispondere alle versioni future migliorate dei qubit Majorana. Per questi qubit, si presuppone che le operazioni di controllo e misurazione prendano 100 ns. Per tenere conto della protezione topologica nell'hardware, si presuppone che i tassi di errore di misurazione congiunta a singolo qubit e a due qubit (tasso di errore Clifford) siano $10^{-4}$ come realistico targete $10^{-6}$ come ottimistico target. Le operazioni non Clifford in questa architettura non hanno protezione topologica, la frequenza di errore per i cancelli T fisici non Clifford è del 5%.

Nota

A meno che non venga specificato un altro valore, il valore predefinito per il modello qubit è "qubit_gate_ns_e3".

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

Passaggio di parametri qubit predefiniti

Esistono due modi per specificare parametri qubit predefiniti a livello di codice. È possibile selezionare il nome del modello qubit per la classe durante l'esecuzione qubitParams di qsharp.estimate. Ad esempio, per selezionare "qubit_maj_ns_e6" il parametro qubit, scrivere:

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

È anche possibile passare i parametri qubit alla EstimatorParams classe usando QubitParams. Ad esempio, per selezionare MAJ_NS_E6 il parametro qubit, scrivere:

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)

Personalizzare i parametri qubit predefiniti

È possibile personalizzare i parametri qubit predefiniti specificando il nome e quindi aggiornando uno qualsiasi degli altri valori. Ad esempio, per ridurre la frequenza di errore della misurazione congiunta a due qubit in "qubit_maj_ns_e4", scrivere:

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 = MicrosoftEstimatorParams()
params.qubit_params.name = QubitParams.MAJ_NS_E4
params.qubit_params.two_qubit_joint_measurement_error_rate = 1e-5

Parametri qubit per qubit basati su Gate

Identificatore Python Tipo di dati Descrizione
name string Nome del modello qubit
instruction_set "gate_based" Tecnologia qubit sottostante
one_qubit_measurement_time stringa di tempo Tempo dell'operazione per la misurazione a qubit singolo ($t_{\rm meas}$) in ns
one_qubit_gate_time stringa di tempo Tempo dell'operazione per il gate a qubit singolo ($t_{\rm gate}$) in ns
two_qubit_gate_time stringa di tempo Tempo di operazione per il gate a due qubit in ns
t_gate_time stringa di tempo Tempo operativo per il gate non Clifford a qubit singolo in ns
one_qubit_measurement_error_rate float Frequenza di errore per la misurazione a qubit singolo
one_qubit_gate_error_rate float Frequenza di errore per il gate Clifford a qubit singolo ($p$)
two_qubit_gate_error_rate float Frequenza di errore per il gate Clifford a due qubit
t_gate_error_rate float Frequenza di errore per preparare lo stato non Clifford a qubit singolo ($p_T$)
idle_error_rate float Frequenza degli errori corrispondente all'inattività

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

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

Nota

Se non specificato, i valori per two_qubit_gate_time e t_gate_time per impostazione predefinita sono one_qubit_gate_time, i valori per e per two_qubit_gate_error_rate impostazione t_gate_error_rate predefinita sono e il valore per idle_error_rate l'impostazione predefinita one_qubit_gate_error_rateè one_qubit_measurement_error_rate.

Parametri qubit per qubit Majorana

Identificatore Python Tipo di dati Descrizione
name string Nome del modello qubit
instruction_set "majorana" Tecnologia qubit sottostante
one_qubit_measurement_time stringa di tempo Tempo dell'operazione per la misurazione a qubit singolo ($t_{\rm meas}$) in ns
two-qubit_joint_measurement_time stringa di tempo Tempo di operazione per la misurazione a due qubit in ns
t_gate_time stringa di tempo Tempo operativo per il gate non Clifford a qubit singolo in ns
one_qubit_measurement_error_rate float Frequenza di errore per la misurazione a qubit singolo
two_qubit_joint_measurement_error_rate float Frequenza di errore per la misurazione a due qubit
t_gate_error_rate float Frequenza di errore per preparare lo stato non Clifford a qubit singolo ($p_T$)
idle_error_rate float Frequenza degli errori corrispondente all'inattività

Un modello minimo per il set di istruzioni basato su Majorana con tutti i valori obbligatori è:

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

Nota

Se non specificato, i valori per two_qubitJointMeasurementTime e t_gate_time per impostazione predefinita sono one_qubit_measurement_time, i valori per e per two_qubit_joint_measurement_error_rate impostazione t_gate_error_rate predefinita sono e il valore per idle_error_rate l'impostazione predefinita one_qubit_measurement_error_rateè one_qubit_measurement_error_rate.

Per one_qubit_measurement_error_rate e two_qubit_joint_measurement_error_rate, è possibile specificare le percentuali di errore corrispondenti ai readout di misurazione, 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)

Nota

Se si specifica un singolo valore numerico per la frequenza di errore a qubit singolo e a due qubit nella misura del qubit Majorana, le percentuali di errore di lettura e processo possono essere uguali.

Importante

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

Schemi di correzione degli errori quantistici

Per eseguire applicazioni quantistice su scala pratica, le operazioni quantistice devono avere basse percentuali di errore. Queste velocità targets di errore superano in genere le 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 di computer quantistici su larga scala. Prima di tutto, QEC consente di comporre più qubit fisici soggetti a errori e creare un qubit logico più affidabile che mantenga le informazioni quantistiche meglio dei qubit fisici sottostanti.

La distanza del codice di correzione degli errori (o semplicemente la distanza del codice per brevità) è un parametro che controlla il numero di errori che possono essere corretti. Di conseguenza, la frequenza di errore dei qubit logici e il numero di qubit fisici necessari per codificarli. Sia l'accuratezza che il numero di qubit fisici aumentano con la distanza del codice. L'obiettivo è trovare la distanza minima del codice in grado di raggiungere la frequenza di errore richiesta impostata per una determinata applicazione.

Resource Estimator usa la formula seguente per la modellazione delle frequenze di errore logiche usando un modello esponenziale.

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

dove $d$ è la distanza del codice, $p$ è la frequenza degli errori fisici e $p^*$ è la soglia di correzione degli errori quantistici. La frequenza degli errori fisici $p$ viene estratta dai parametri qubit come percentuale di errori peggiore qualsiasi operazione fisica Clifford 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.

Protocollo QEC Classe API Python Descrizione
"surface_code" SURFACE_CODE Il codice superficie basato su gate è basato su arXiv:1208.0928 e arXiv:1009.3686. Il codice surface majorana si basa su arXiv:1909.03002 e arXiv:2007.00307.
"floquet_code" FLOQUET_CODE Solo per i qubit Majorana. Il codice floquet è basato su arXiv:2202.11829.

Nota

A meno che non venga specificato un altro valore, il valore predefinito per lo schema QEC è "surface_code".

Di seguito sono riportati i parametri esatti per ogni schema QEC predefinito (incluso un cross-factor $a$, che può essere estratto numericamente per le simulazioni).

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

Passaggio di schemi QEC predefiniti

Esistono due modi per specificare schemi QEC predefiniti. È possibile selezionare il nome del modello QEC per la classe durante l'esecuzione "qecScheme" di qsharp.estimate. Ad esempio, per selezionare il codice floquet, scrivere:

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

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

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 schemi QEC predefiniti

È possibile personalizzare schemi QEC predefiniti specificando il nome e quindi aggiornando uno qualsiasi degli altri valori. Ad esempio, per aumentare il pre-fattore di attraversamento nel codice floquet, scrivere:

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

Nota

Se non specificato, i valori per "logicalCycleTime" e "physicalQubitsPerLogicalQubit" per impostazione predefinita sono "oneQubitMeasurementTime", il valore per "errorCorrectionThreshold" l'impostazione predefinita 0.01è e il valore per "crossingPrefactor" l'impostazione predefinita è 0.03.

Personalizzare gli schemi QEC

Resource Estimator può astrarre uno schema QEC personalizzato basato sulla formula precedente specificando i valori per il "crossingPrefactor" $a$ e il "errorCorrectionThreshold" $p^*$. È inoltre necessario specificare , "logicalCycleTime"ovvero il tempo necessario per eseguire una singola operazione logica, che dipende dalla distanza del codice e dai presupposti del tempo dell'operazione fisica dei qubit fisici sottostanti. Infine, una seconda 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>,
                        "logicalCycleTime": <formula string>,
                        "physicalQubitsPerLogicalQubit": <formula string>
                    }
                })

All'interno delle formule è possibile usare le variabili one_qubit_gate_time, , one_qubit_measurement_timetwo_qubit_gate_timee two_qubit_joint_measurement_time, i cui valori vengono ricavati dal campo corrispondente dai parametri del qubit fisico, nonché la variabile eccDistance per la distanza di codice calcolata per il qubit logico, in base alle proprietà del qubit fisico, alla soglia di correzione degli errori e al prefactoring di incrocio. Le variabili temporali e eccDistance possono essere usate per descrivere la logicalCycleTime formula. Per la formula physicalQubitsPerLogicalQubit è possibile utilizzare solo .eccDistance

Budget di errore

Il budget di errore totale $\epsilon$ imposta l'errore tollerato complessivo 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 è altamente specifico dell'applicazione.

Ad esempio, se si esegue l'algoritmo di Shor per i numeri interi di fattorizzazione, è possibile tollerare un valore elevato per il budget degli errori perché è possibile verificare che gli output siano effettivamente 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 può essere verificato in modo efficiente.

Il budget degli errori corrisponde alla somma di tre parti:

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

Se non viene specificato ulteriormente, il budget di errore $\epsilon$ viene distribuito in modo uniforme e si applica agli errori $\epsilon_{\log}$ per implementare qubit logici, il budget degli errori $\epsilon_{\rm dis}$ produce stati T tramite la codifica e un budget di errore $\epsilon_{\rm syn}$ per sintetizzare i gate di rotazione con angoli arbitrari.

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

Superamento del budget degli errori

Esistono due modi per specificare il budget degli errori impostando un numero compreso tra 0 e 1. È possibile passare il budget degli errori durante l'esecuzione di qsharp.estimate. Ad esempio, per selezionare un budget di errore di 1/3, scrivere:

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

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

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)

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 T o rotazioni, i valori di t_states e rotations possono essere 0 rispettivamente.

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

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

Vincoli

È possibile usare la "constraints" classe per applicare vincoli a livello di componente della factory T . Modificando i vincoli, è possibile ottimizzare le stime per ridurre il numero di qubit o ridurre il runtime.

Parametro Tipo di dati Descrizione
logical_depth_factor float Controllare il tempo di esecuzione. Se ha un valore maggiore di 1, il numero iniziale di cicli logici, detto anche profondità logica, viene moltiplicato per questo numero. logical_depth_factorRiducendo , è possibile aumentare il numero di chiamate della factory T in un determinato momento, con conseguente minor numero di copie della factory T necessarie per produrre lo stesso numero di stati T. Quando si riduce il numero di copie factory T, il runtime dell'algoritmo aumenta di conseguenza. Il fattore di ridimensionamento per il runtime totale può essere maggiore, perché la frequenza di errore logica richiesta aumenta a causa del numero aggiuntivo di cicli.
max_t_factories numero intero Numero massimo di copie factory T. Lo strumento di stima delle risorse determina le risorse necessarie selezionando il numero ottimale di copie della factory T che riduce al minimo il numero di qubit fisici usati, senza considerare il sovraccarico del tempo. Il max_t_factories parametro limita il numero massimo di copie e quindi regola il numero di cicli logici di conseguenza. Per altre informazioni, vedere Stima fisica della fabbrica T.
max_duration stringa di tempo Runtime massimo per l'algoritmo. Resource Estimator accetta solo uno dei max_duration vincoli o max_physical_qubits al momento, ma non due. Se max_duration viene specificato, lo strumento di stima delle risorse tenta di trovare la stima migliore per max_physical_qubits tra le soluzioni vincolate dal numero massimo specificato.
max_physical_qubits numero intero Numero massimo di qubit fisici per l'algoritmo. Resource Estimator accetta solo uno dei max_duration vincoli o max_physical_qubits al momento, ma non due. Se max_physical_qubits viene specificato, lo strumento di stima delle risorse tenta di trovare la stima migliore per max_duration tra le soluzioni vincolate dal numero massimo specificato.

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

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

Nota

Se il valore fornito a max_duration o max_physical_qubits è troppo piccolo per trovare una soluzione fattibile, Lo strumento di stima delle risorse restituisce un errore. Se non vengono specificati né max_durationmax_physical_qubits vincoli, Lo strumento di stima delle risorse mira a trovare una soluzione con il tempo più breve.

Suggerimento

È possibile usare max_duration e max_physical_qubits per influenzare lo spazio della soluzione, potenzialmente trovare soluzioni con runtime più lungo, ma un numero inferiore di qubit rispetto alle soluzioni senza questi vincoli. Esiste un compromesso tra runtime e il numero di qubit e questo compromesso può essere gestito in modo efficiente per alcuni algoritmi, con effetti variabili su algoritmi diversi. La tabella IV in [arXiv:2211.07629] illustra l'utilizzo effettivo del compromesso tra il numero di qubit e il runtime per gli algoritmi di dinamica quantistica. Per altre informazioni, vedere Stima delle risorse quantistiche con il tempo o il numero di vincoli di qubit .

Unità di crittografia

È possibile specificare le specifiche per gli algoritmi di crittografia T factory con la DistillationUnitSpecification classe . La specifica può essere predefinita o personalizzata. È possibile specificare una specifica predefinita selezionando il nome dell'unità di crittografia: 15-1 RM o 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)

In entrambi i casi, la notazione 15-1 indica 15 stati T di input e 1 stato T di output. L'unità 15-1 space-efficient di crittografia usa meno qubit rispetto a 15-1 RM ma richiede più runtime. Per altre informazioni, vedi Tabella VI.

Suggerimento

L'uso di unità di diagnostica predefinite offre prestazioni migliori rispetto a quelle personalizzate.

Personalizzare le unità di personalizzazione

È possibile personalizzare le proprie unità di compilazione. Di seguito sono riportati i parametri esatti per le unità di simulazione.

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 dovrebbero essere positivi. displayName Specifica la modalità di visualizzazione dell'unità di compilazione nei risultati di output.

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

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

Le formule per failure_probability_formula e output_error_rate_formula sono formule personalizzate con operazioni aritmetiche di base, costanti e solo tre parametri:

  • 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 che usano la notazione long e short. Questi esempi illustrano le formule usate per impostazione predefinita nell'implementazione standard.

Parametro Formula lunga Formula breve
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"

È necessario specificare almeno uno dei parametri physical_qubit_specification o logical_qubit_specification . Se viene fornito solo il primo, l'unità di diagnostica può essere applicata ai qubit fisici. Se viene fornito solo quest'ultimo, l'unità di diagnostica può essere applicata ai qubit logici. Se vengono forniti entrambi, l'unità di diagnostica può essere applicata a entrambi i tipi di qubit.

Il parametro logical_qubit_specification_first_round_override può essere fornito solo se logical_qubit_specification è specificato. In tal caso, esegue l'override dei valori di logical_qubit_specification nel caso se applicato al primo round di topologia. Il valore <protocol specific parameters> necessario per logical_qubit_specification_first_round_override deve seguire lo schema:

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

Stima delle frontiere Pareto

Quando si stimano le risorse di un algoritmo, è importante considerare il compromesso tra il numero di qubit fisici e il runtime dell'algoritmo. È possibile considerare l'allocazione del maggior numero possibile di qubit fisici per ridurre il runtime dell'algoritmo. Tuttavia, il numero di qubit fisici è limitato dal numero di qubit fisici disponibili nell'hardware quantistico. Comprendere il compromesso tra runtime e scalabilità di sistema è uno degli aspetti più importanti della stima delle risorse.

La stima di frontiera Pareto fornisce più stime per lo stesso algoritmo, ognuna delle quali mostra compromessi tra il numero di qubit e il runtime.

Nota

Se si esegue Lo strumento di stima delle risorse in Visual Studio Code usando l'opzione Q#: Calculate Resource Estimates , la stima della frontiera Pareto è abilitata per impostazione predefinita.

Se si esegue Resource Estimator 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
                    }
                )

Se si desidera visualizzare i risultati della stima delle frontiere Pareto, è possibile usare la EstimatesOverview funzione . Queste funzioni visualizzano i risultati della stima delle frontiere nella tabella e in un diagramma spazio-tempo. Per altre informazioni, vedere Diagramma spazio-tempo.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Nota

Se si verificano problemi durante l'utilizzo di Resource Estimator, consultare la pagina Risoluzione dei problemi o contattare AzureQuantumInfo@microsoft.com.

Passaggi successivi