Dela via

Anpassa parametrarna för target Resource Estimator

  • Artikel

Den här artikeln visar hur du anpassar parametrarna target för Azure Quantum Resource Estimator så att de matchar de datoregenskaper som du targetanvänder. Resource Estimator använder dessa parametrar för att uppskatta de resurser som krävs för att köra en kvantalgoritm på en kvantdator.

Kommentar

Om du stöter på problem när du arbetar med resursberäknaren kan du gå till sidan Felsökning.

Förutsättningar

Målparametrar

Resource Estimator beräknar uppskattningen av resurser, till exempel antalet kvantbitar och körningstiden, vilket skulle krävas för att implementera en viss kvantalgoritm med hjälp av en viss kvantbitsteknik och med en fast uppsättning arkitekturval.

Därför tar Resource Estimator en uppsättning indata med fördefinierade värden för att enkelt komma igång:

  • En fysisk qubitmodell som definierar egenskaperna för de underliggande fysiska kvantbitarna.
  • Ett QEC-schema (Quantum Error Correction), som är det antagna kvantfelkorrigeringsschemat.
  • En felbudget, vilket är det övergripande tillåtna felet, dvs. antalet gånger programmet tillåts att inte få någon information.
  • Begränsningar på komponentnivå, som är antalet logiska cykler och antalet T-fabrikskopior.
  • Destillationsenheter för att ange algoritmer för destillation av T-fabriker.
  • Pareto Frontier-uppskattning för att köra flera uppskattningar av antalet kvantbitar och körning för samma algoritm.

Fysiska qubitparametrar

När Resource Estimator modellerar de fysiska kvantbitsantagandena använder den två olika fysiska instruktionsuppsättningar för att använda kvantbitarna. Den fysiska instruktionsuppsättningen kan vara antingen grindbaserad eller Majorana. En gatebaserad instruktionsuppsättning ger en kvantbitsmätning, enstaka qubitgrindar (inklusive T-portar) och två qubitgrindar. En Majorana-instruktionsuppsättning ger en fysisk T-grind, en kvantbitsmätning och två qubits gemensamma måttåtgärder.

Du kan välja mellan sex fördefinierade qubitparametrar, varav fyra har gatebaserade instruktionsuppsättningar och två med en Majorana-instruktionsuppsättning. De här kvantbitsmodellerna täcker en mängd olika driftstider och felfrekvenser, vilket möjliggör tillräcklig utforskning av de resurskostnader som behövs för att möjliggöra praktiska kvantprogram.

Qubit-parameter Python API-klass beskrivning
"qubit_gate_ns_e3" , "qubit_gate_ns_e4" GATE_NS_E3 , GATE_NS_E4 Drifttider och fidelities kan motsvara framtida versioner av supraledande transmon qubits, eller spin qubits, som vanligtvis har driftstider i nanosekondregimen. För dessa kvantbitar antas grind- och mätåtgärderna ta 50 ns respektive 100 ns. Felfrekvenser med en kvantbit och två kvantbitar antas vara $10^{-3}$ som realistiska targetoch $10^{-4}$ som optimistiska target för ett uppskalat system.
"qubit_gate_us_e3" , "qubit_gate_us_e4" GATE_US_E3 , GATE_US_E4 Drifttider och fidelities kan motsvara framtida versioner av kvantbitar baserade på joner, som vanligtvis har driftstider i mikrosekundersregimen. Baserat på typiska antaganden för jon qubits antas grind- och mätåtgärder ta 100 μs. Felfrekvensen för Clifford-portar med en kvantbit är $10^{-3}$ som en realistisk target och $10^{-4}$ som optimistisk target, medan felfrekvensen för icke-Clifford-portar (T-gate) är $10^{-6}$. För två qubit-portar är felfrekvensen $10^{-3}$ som en realistisk target och $10^{-4}$ som optimistisk target.
"qubit_maj_ns_e4" , "qubit_maj_ns_e6" MAJ_NS_E4 , MAJ_NS_E6 Drifttider och fidelities kan motsvara framtida förbättrade versioner av Majorana qubits. För dessa kvantbitar antas gate- och mätåtgärderna ta 100 ns. För att ta hänsyn till topologiskt skydd i maskinvaran antas felfrekvensen för enkel qubit och två kvantbitar (Clifford-felfrekvenser) vara $10^{-4}$ som en realistisk targetoch $10^{-6}$ som optimistisk target. Icke-Clifford-åtgärder i den här arkitekturen har inte topologiskt skydd, felfrekvensen för icke-Clifford fysiska T-portar är 5 %.

Kommentar

Om inget annat värde anges är "qubit_gate_ns_e3"standardvärdet för qubit-modellen .

Parametrar för fördefinierade kvantbitsparametrar

Som referens är de fullständiga fördefinierade kvantbitsparametrarna följande:

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

Skicka fördefinierade kvantbitsparametrar

Det finns två sätt att programmatiskt ange fördefinierade kvantbitsparametrar. Du kan välja qubitmodellnamnet för qubitParams klassen när du kör qsharp.estimate. Om du till exempel vill välja "qubit_maj_ns_e6" qubitparameter skriver du:

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

Du kan också skicka kvantbitsparametrarna till EstimatorParams klassen med hjälp av QubitParams. Om du till exempel vill välja MAJ_NS_E6 qubitparameter skriver du:

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)

Anpassa fördefinierade kvantbitsparametrar

Du kan anpassa fördefinierade kvantbitsparametrar genom att ange namnet och sedan uppdatera något av de andra värdena. Om du till exempel vill minska felfrekvensen för sammätning med två kvantbitar i "qubit_maj_ns_e4" skriver du:

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

Eller så kan du skicka instruktionerna i form av en lista.

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

Qubitparametrar för Gate-baserade kvantbitar

Python-identifierare Datatyp beskrivning
name sträng Namn på qubitmodellen
instruction_set "gate_based" Underliggande kvantbitsteknik
one_qubit_measurement_time tidssträng Åtgärdstid för mätning med en qubit ($t_{\rm meas}$) i ns
one_qubit_gate_time tidssträng Åtgärdstid för en qubit-grind ($t_{\rm gate}$) i ns
two_qubit_gate_time tidssträng Drifttid för två qubitsgrind i ns
t_gate_time tidssträng Drifttid för en qubit som inte är Clifford-grind i ns
one_qubit_measurement_error_rate flyttal Felfrekvens för enstaka kvantbitsmätning
one_qubit_gate_error_rate flyttal Felfrekvens för En qubit Clifford-grind ($p$)
two_qubit_gate_error_rate flyttal Felfrekvens för cliffordport med två qubit
t_gate_error_rate flyttal Felfrekvens för att förbereda icke-Clifford-tillstånd med en enda qubit ($p_T$)
idle_error_rate flyttal Felfrekvens som motsvarar tomgång

Följande kod visar hur du anger anpassade qubitparametrar för en gatebaserad instruktionsuppsättning:

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

Kommentar

När det inte anges är värdena för two_qubit_gate_time och t_gate_time standardvärdet one_qubit_gate_time, värdena för two_qubit_gate_error_rate och t_gate_error_rate standardvärdet , one_qubit_gate_error_rateoch värdet för idle_error_rate standardvärdet till one_qubit_measurement_error_rate.

Qubitparametrar för Majorana-kvantbitar

Python-identifierare Datatyp beskrivning
name sträng Namn på qubitmodellen
instruction_set "majorana" Underliggande kvantbitsteknik
one_qubit_measurement_time tidssträng Åtgärdstid för mätning med en qubit ($t_{\rm meas}$) i ns
two-qubit_joint_measurement_time tidssträng Drifttid för mätning med två kvantbitar i ns
t_gate_time tidssträng Drifttid för en qubit som inte är Clifford-grind i ns
one_qubit_measurement_error_rate flyttal Felfrekvens för enstaka kvantbitsmätning
two_qubit_joint_measurement_error_rate flyttal Felfrekvens för mätning med två kvantbitar
t_gate_error_rate flyttal Felfrekvens för att förbereda icke-Clifford-tillstånd med en enda qubit ($p_T$)
idle_error_rate flyttal Felfrekvens som motsvarar tomgång

En minsta mall för Majorana-baserad instruktionsuppsättning med alla nödvändiga värden är:

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

Kommentar

När det inte anges är värdena för two_qubitJointMeasurementTime och t_gate_time standardvärdet one_qubit_measurement_time, värdena för two_qubit_joint_measurement_error_rate och t_gate_error_rate standardvärdet , one_qubit_measurement_error_rateoch värdet för idle_error_rate standardvärdet till one_qubit_measurement_error_rate.

För one_qubit_measurement_error_rate och two_qubit_joint_measurement_error_ratekan du ange de felfrekvenser som motsvarar mätningsläsningar, readout, och mätningsbearbetning, process. Dessa värden kan vara antingen <double> tal eller par med tal. Till exempel:

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

Kommentar

Om du anger ett enda numeriskt värde för felfrekvenser med en qubit och två qubit i Qubit-mätningen i Majorana kan både avläsnings- och processfelfrekvensen vara lika med.

Viktigt!

Alla värden som inte har angetts tar ett standardvärde, till exempel att ange kommer att modellera "qubit": {"oneQubitGateTime":"200 ns"} en grindbaserad qubit där både två-qubit gate-tiden och en qubit gate-tiden är 200 ns. För enheter måste du ange tidssträngar, som är flyttal med dubbel precision, följt av ett blanksteg och tidsenheten för sådana värden, där möjliga tidssuffix är ns, µs (eller us), msoch s.

Korrigeringsscheman för kvantfel

För att köra kvantprogram i praktisk skala bör kvantåtgärder ha låga felfrekvenser. Dessa felfrekvenser targets ligger vanligtvis utanför funktionerna i råa fysiska kvantbitar. För att övervinna den här begränsningen är kvantfelkorrigering (QEC) och feltolerant beräkning två viktiga tekniker som utgör byggstenarna för storskaliga kvantdatorer. För det första gör QEC att vi kan skapa flera felbenägna fysiska kvantbitar och skapa en mer tillförlitlig logisk kvantbit som bevarar kvantinformation bättre än de underliggande fysiska kvantbitarna.

Resursberäknaren använder följande formel för att modellera logiska felfrekvenser med hjälp av en exponentiell modell.

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

där $a$ är en korsningsförfaktor är $d$ kodavståndet, $p$ är den fysiska felfrekvensen och $p^*$ är tröskelvärdet för kvantfelkorrigering. Korsningsförfaktorn $a$ kan extraheras numeriskt för simuleringar.

Kodavståndet $d$ är en parameter som styr antalet fel som kan korrigeras. Därför definierar kodavstånd felfrekvensen för de logiska kvantbitarna och antalet fysiska kvantbitar som krävs för att koda dem. Både noggrannhet och antalet fysiska kvantbitar ökar med kodavstånd. Målet med ett QEC-schema är att hitta det minsta kodavstånd som kan uppnå den felfrekvens som krävs för ett visst program.

Den fysiska felfrekvensen $p$ extraheras från kvantbitsparametrarna som den värsta felfrekvensen för alla fysiska Clifford-åtgärder som utförs på enheten. I synnerhet $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) för qubitparametrar med en gatebaserad instruktionsuppsättning och $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) för qubitparametrar med en Majorana-instruktionsuppsättning. QEC-scheman har vanligtvis ett tröskelvärde för felfrekvens $p^*$ under vilket felkorrigering undertrycker fel.

Azure Quantum Resource Estimator stöder två fördefinierade QEC-scheman: en ytkod och en floquet-kod.

QEC-protokoll Python API-klass beskrivning
"surface_code" SURFACE_CODE Den grindbaserade ytkoden baseras på arXiv:1208.0928 och arXiv:1009.3686. Majorana-ytkoden baseras på arXiv:1909.03002 och arXiv:2007.00307.
"floquet_code" FLOQUET_CODE Endast för Majorana-kvantbitar. Floquet-koden baseras på arXiv:2202.11829.

Kommentar

Om inget annat värde anges är standardvärdet för QEC-schemat "surface_code".

Parametrar för fördefinierade QEC-scheman

De exakta parametrarna för varje fördefinierat QEC-schema är följande.

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

Skicka fördefinierade QEC-scheman

Det finns två sätt att ange fördefinierade QEC-scheman. Du kan välja QEC-modellnamnet för "qecScheme" klassen när du kör qsharp.estimate. Om du till exempel vill välja floquet-koden skriver du:

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

Du kan också skicka en lista över uppskattningsparametrar till klassen med hjälp avQECSchemeklassen.EstimatorParams Om du till exempel vill välja floquet-koden skriver du:

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)

Anpassa fördefinierade QEC-scheman

Du kan anpassa fördefinierade QEC-scheman genom att ange namnet och sedan uppdatera något av de andra värdena. Om du till exempel vill öka korsningsförfaktorn i floquet-koden skriver du:

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

Kommentar

När det inte anges anges värdena för "logicalCycleTime" och "physicalQubitsPerLogicalQubit" standardvärdet "oneQubitMeasurementTime"till , värdet för "errorCorrectionThreshold" standardvärdet till 0.01och värdet för "crossingPrefactor" standardvärdet till 0.03.

Anpassa dina QEC-scheman

Resursberäknaren kan abstrahera ett anpassat QEC-schema baserat på formeln ovan genom att ange värden för "crossingPrefactor" $a$ och "errorCorrectionThreshold" $p^*$. Dessutom måste du ange , det vill s.v.s "logicalCycleTime". tiden för att köra en enda logisk åtgärd, som beror på kodavståndet och antagandena om den fysiska driftstiden för underliggande fysiska kvantbitar. Slutligen beräknar "physicalQubitsPerLogicalQubit"en andra formel det antal fysiska kvantbitar som krävs för att koda en logisk qubit baserat på kodavståndet.

Du kan använda följande kod som en mall för QEC-scheman:

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

I formler kan du använda variablerna one_qubit_gate_time, , one_qubit_measurement_timetwo_qubit_gate_time, och two_qubit_joint_measurement_time, vars värden hämtas från motsvarande fält från de fysiska kvantbitsparametrarna, samt variabeln eccDistance för kodavståndet som beräknas för den logiska kvantbiten, baserat på de fysiska kvantbitsegenskaperna, tröskelvärdet för felkorrigering och korsande prefaktor. Tidsvariablerna och eccDistance kan användas för att beskriva formeln logicalCycleTime . För formeln physicalQubitsPerLogicalQubit kan endast eccDistance användas.

Felbudget

Den totala felbudgeten $\epsilon$ anger det övergripande tolererade felet för algoritmen, d.v.s. algoritmens tillåtna felsannolikhet. Det globala värdet måste vara mellan 0 och 1 och standardvärdet är 0,001, vilket motsvarar 0,1 %. Med andra ord tillåts algoritmen att misslyckas högst en gång i 1 000 körningar. Den här parametern är mycket programspecifik.

Om du till exempel kör Shor-algoritmen för att räkna ut heltal kan ett stort värde för felbudgeten tolereras eftersom man kan kontrollera att utdata verkligen är de främsta faktorerna för indata. Å andra sidan kan en mindre felbudget behövas för en algoritm som löser ett problem med en lösning, som inte kan verifieras effektivt.

Felbudgeten motsvarar summan av tre delar:

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

De logiska felen $\epsilon_{\log}$ är felet med att implementera logiska kvantbitar, T-tillståndsfelet $\epsilon_{\rm dis}$ är felet att producera T-tillstånd genom destillation och rotationsgrindsfelet $\epsilon_{\rm syn}$ är felet att syntetisera rotationsportar med godtyckliga vinklar.

Kommentar

Om inget annat värde anges fördelas felbudgeten $\epsilon$ jämnt mellan det logiska felet, T-tillståndsfelet och rotationsgrindsfelet.

Observera att för destillation och rotationssyntes är respektive felbudgetar $\epsilon_{\rm dis}$ och $\epsilon_{\rm syn}$ jämnt fördelade mellan alla nödvändiga T-tillstånd respektive alla nödvändiga rotationsportar. Om det inte finns rotationsportar i indataalgoritmen distribueras felbudgeten jämnt till logiska fel och T-tillståndsfel.

Skicka felbudget

Det finns två sätt att ange felbudgeten genom att ange ett tal mellan 0 och 1. Du kan skicka felbudgeten när du kör qsharp.estimate. Om du till exempel vill välja en felbudget på 1/3 skriver du:

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

Du kan också skicka felbudgetparametrarna till EstimatorParams klassen.

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)

Du kan också ange varje komponent i felbudgeten individuellt. Summan av alla värden är den totala felbudgeten och måste vara mellan 0 och 1. Om en kvantalgoritm inte innehåller T-tillstånd eller rotationer kan värdena t_states för respektive rotations 0 vara 0.

Följande kod visar hur du anger felbudgetparametern med T-tillstånd och rotationer:

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

Krav

Du kan använda "constraints" klassen för att tillämpa begränsningar på T-fabrikskomponentnivån . Genom att justera begränsningar kan du optimera uppskattningarna för att minska antalet kvantbitar eller minska körningen.

Parameter Datatyp beskrivning
logical_depth_factor flyttal Kontrollera körningstiden. Om det har ett värde som är större än 1 multipliceras det inledande antalet logiska cykler, även kallat logiskt djup, med det här talet. Genom att minska logical_depth_factorkan du öka antalet anrop av T-fabriken under en viss tid, vilket resulterar i färre T-fabrikskopior som behövs för att producera samma antal T-tillstånd. När du minskar antalet T-fabrikskopior ökar algoritmkörningen i enlighet med detta. Skalningsfaktorn för den totala körningen kan vara större eftersom den obligatoriska logiska felfrekvensen ökar på grund av det ytterligare antalet cykler.
max_t_factories integer Maximalt antal T-fabrikskopior. Resursberäknaren avgör vilka resurser som krävs genom att välja det optimala antalet T-fabrikskopior som minimerar antalet fysiska kvantbitar som används, utan att ta hänsyn till tidskostnaderna. Parametern max_t_factories begränsar det maximala antalet kopior och justerar därför antalet logiska cykler i enlighet med detta. Mer information finns i Fysisk uppskattning av T-fabriken.
max_duration tidssträng Maximal körning för algoritmen. Resource Estimator accepterar bara en av max_duration eller max_physical_qubits begränsningar vid den tidpunkten, men inte två. Om max_duration anges försöker Resource Estimator hitta den bästa uppskattningen för max_physical_qubits bland lösningar som begränsas av det maximala antalet angivna.
max_physical_qubits integer Maximalt antal fysiska kvantbitar för algoritmen. Resource Estimator accepterar bara en av max_duration eller max_physical_qubits begränsningar vid den tidpunkten, men inte två. Om max_physical_qubits anges försöker Resource Estimator hitta den bästa uppskattningen för max_duration bland lösningar som begränsas av det maximala antalet angivna.

Följande kod visar hur du anger begränsningarna för en kvantalgoritm:

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

Kommentar

Om värdet som anges till max_duration eller max_physical_qubits är för litet för att hitta en möjlig lösning returnerar Resource Estimator ett fel. Om varken max_duration eller max_physical_qubits begränsningar anges syftar Resource Estimator till att hitta en lösning med kortast tid.

Dricks

Du kan använda max_duration och max_physical_qubits påverka lösningsutrymmet och eventuellt hitta lösningar med längre körning, men ett mindre antal kvantbitar jämfört med lösningar utan dessa begränsningar. Det finns en kompromiss mellan körning och antalet kvantbitar, och den här kompromissen kan hanteras effektivt för vissa algoritmer, med varierande effekter på olika algoritmer. Tabell IV i [arXiv:2211.07629] illustrerar den effektiva användningen av kompromissen mellan antalet kvantbitar och körning för kvantdynamikalgoritmer. Mer information finns i Kvantresursuppskattning med tid eller antal qubits-begränsningar .

Destillationsenheter

Du kan ange specifikationer för T-fabrikers destillationsalgoritmer med DistillationUnitSpecification klassen . Specifikationen kan vara antingen fördefinierad eller anpassad. Du kan ange en fördefinierad specifikation genom att välja destillationsenhetens namn: 15-1 RM eller 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)

I båda fallen står notation 15-1 för 15 indata-T-tillstånd och 1 utdata-T-tillstånd. Destillationsenheten 15-1 space-efficient använder färre kvantbitar än 15-1 RM men kräver mer körning. Mer information finns i Tabell VI.

Dricks

Användning av fördefinierade destillationsenheter ger bättre prestanda jämfört med anpassade enheter.

Anpassa destillationsenheterna

Du kan anpassa dina egna destillationsenheter. De exakta parametrarna för destillationsenheterna är följande.

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

Alla numeriska parametrar förväntas vara positiva. displayName Anger hur destillationsenheten ska visas i utdataresultatet.

Följande kod visar hur du anger destillationsenhetens parametrar för en kvantalgoritm med hjälp av DistillationUnitSpecification klassen och ProtocolSpecificDistillationUnitSpecification klassen.

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

Formler för failure_probability_formula och output_error_rate_formula är anpassade formler med grundläggande aritmetiska åtgärder, konstanter och endast tre parametrar:

  • clifford_error_rate, även betecknad som c.
  • readout_error_rate, även betecknad som r.
  • input_error_rate, även betecknad som z.

Se följande exempel på anpassade formler med lång och kort notation. De här exemplen illustrerar formler som används som standard i standardimplementeringen.

Parameter Lång formel Kort formel
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"

Minst en av parametrarna physical_qubit_specification eller logical_qubit_specification bör anges. Om endast den förstnämnda tillhandahålls kan destillationsenheten tillämpas på fysiska kvantbitar. Om endast den senare tillhandahålls kan destillationsenheten tillämpas på logiska kvantbitar. Om båda tillhandahålls kan destillationsenheten tillämpas på båda typerna av kvantbitar.

Parametern logical_qubit_specification_first_round_override kan endast anges om logical_qubit_specification den har angetts. I så fall åsidosätter den värdena logical_qubit_specification för om de tillämpas vid den första destillationen. <protocol specific parameters> Värdet som krävs för logical_qubit_specification_first_round_override bör följa schemat:

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

Gränsuppskattning för Pareto

När du beräknar resurserna för en algoritm är det viktigt att överväga kompromissen mellan antalet fysiska kvantbitar och algoritmens körning. Du kan överväga allokering av så många fysiska kvantbitar som möjligt för att minska körningen av algoritmen. Antalet fysiska kvantbitar begränsas dock av antalet fysiska kvantbitar som är tillgängliga i kvantmaskinvaran. Att förstå kompromissen mellan körning och systemskala är en av de viktigaste aspekterna av resursuppskattning.

Gränsuppskattningen pareto tillhandahåller flera uppskattningar för samma algoritm, var och en visar kompromisser mellan antalet kvantbitar och körningen.

Kommentar

Om du kör Resource Estimator i Visual Studio Code med Q#alternativet : Calculate Resource Estimates (Beräkna resursuppskattningar ) aktiveras Pareto Frontier-uppskattningen som standard.

Om du kör resursestimatorn i Python måste du ange parametern "estimateType" som "frontier".

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

Om du vill visualisera resultatet av Gränsuppskattningen i Pareto kan du använda EstimatesOverview funktionen. Den här funktionen visar resultatet av gränsuppskattning i tabellen och ett tidsdiagram. Mer information finns i Diagram över tidsrymd.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Kommentar

Om du stöter på problem när du arbetar med Resursberäknaren kan du gå till sidan Felsökning eller kontakta AzureQuantumInfo@microsoft.com.

Nästa steg