Anpassen der target Parameter des Ressourcenstimators

Artikel
05/23/2024

In diesem Artikel wird gezeigt, wie Sie die target Parameter der Azure Quantum Resource Estimator an die Computermerkmale anpassen, die Sie als Ziel festlegen. Der Resource Estimator verwendet diese Parameter, um die ressourcen zu schätzen, die zum Ausführen eines Quantenalgorithmus auf einem Quantencomputer erforderlich sind.

Hinweis

Wenn beim Arbeiten mit der Ressourcenschätzung probleme auftreten, lesen Sie die Seite "Problembehandlung".

Voraussetzungen

Eine Python-Umgebung mit installiertem Python und Pip.
Die neueste Version von Visual Studio Code oder öffnen Sie VS Code im Web.
VS Code mit installierten Azure Quantum Development Kit-, Python- und Jupyter-Erweiterungen .

Die neuesten Azure Quantum qsharp und qsharp-widgets Pakete.

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

Target-Parameter

Der Ressourcen-Estimator berechnet die Abschätzung von Ressourcen, z. B. die Anzahl der Qubits und die Laufzeit, die erforderlich wäre, um einen bestimmten Quantenalgorithmus mithilfe einer bestimmten Qubit-Technologie und mit einer festen Reihe von architekturtechnischen Entscheidungen zu implementieren.

Daher verwendet der Ressourcen-Estimator eine Reihe von Eingaben mit vordefinierten Werten, um Ihnen die ersten Schritte zu erleichtern:

Ein physisches Qubit-Modell, das die Eigenschaften der zugrunde liegenden physischen Qubits definiert.
Ein Quantum Error Correction (QEC)-Schema, das das angenommene Quantenfehlerkorrektur-Schema ist.
Ein Fehlerbudget, bei dem es sich um den insgesamt zulässigen Fehler handelt, d. h. die Anzahl der Wiederholungen, mit denen das Programm nicht ausgeführt werden kann.
Einschränkungen auf Komponentenebene, die Anzahl der logischen Zyklen und die Anzahl der T-Factorykopien.
Destillationseinheiten zur Angabe von T-Fabriken destillationsalgorithmen.
Pareto frontier estimate to run multiple estimates of number of qubits and runtime for the same algorithm.

Tipp

Wenn Sie bereits einige vorab berechnete Schätzungen für einen Vorgang kennen, können Sie sie auch integrieren und die Ausführung des Ressourcenstimators optimieren. Weitere Informationen finden Sie unter Verwendung bekannter Schätzungen mit dem Ressourcen-Estimator.

Physische Qubit-Parameter

Wenn der Ressourcen-Estimator die physischen Qubit-Annahmen modelliert, verwendet es zwei verschiedene physikalische Anweisungssätze, um die Qubits zu bedienen. Der physische Anweisungssatz kann entweder gatterbasiert oder Majorana sein. Ein gatterbasierter Befehlssatz ermöglicht Messungen für einzelne Qubits, Gatter für einzelne Qubits (einschließlich T-Gatter) und Gatter für zwei Qubit. Ein Majorana-Anweisungssatz bietet ein physisches T-Gatter, Messungen für einzelne Qubits und gemeinsame Messungen für zwei Qubits.

Sie können aus sechs vordefinierten Qubitparametern wählen, von denen vier über gatterbasierte Anweisungssätze und zwei über einen Majorana-Anweisungssatz verfügen. Diese Qubitmodelle decken verschiedene Betriebszeiten und Fehlerraten ab und ermöglichen eine ausreichende Untersuchung der Ressourcenkosten für praktische Quantenanwendungen.

Qubit-Parameter	Python-API-Klasse	Beschreibung
`"qubit_gate_ns_e3"` , `"qubit_gate_ns_e4"`	`GATE_NS_E3` , `GATE_NS_E4`	Betriebszeiten und Fidelitäten können zukünftigen Versionen von transkonduktierenden Transmon qubits oder Spin qubits entsprechen, die in der Regel Betriebszeiten im Nanosekunden-Regime haben. Für diese Qubits wird davon ausgegangen, dass tor- und messtechnische Vorgänge jeweils 50 n und 100 n nehmen. Ein-Qubit- und Zwei-Qubit-Gate-Fehlerraten werden als realistische target10^{-3}$ angenommen, und 10^{-4}$ als optimistisch target für ein skaliertes System.
`"qubit_gate_us_e3"` , `"qubit_gate_us_e4"`	`GATE_US_E3` , `GATE_US_E4`	Betriebszeiten und Fidelitäten können zukünftigen Versionen von Qubits basierend auf Ionen entsprechen, die in der Regel Betriebszeiten im Mikrosekunden-Regime aufweisen. Ausgehend von typischen Annahmen für Ionen qubits werden Tor- und Messvorgänge angenommen, 100 μs zu nehmen. Fehlerrate für Single-Qubit Clifford Gates ist $10^{-3}$ als realistisch target und $10^{-4}$ als optimistisch target, während die Fehlerrate für single-qubit non-Clifford Gates (T Gate) $10^{-6}$ beträgt. Bei Zwei-Qubit-Gates beträgt die Fehlerrate 10^{-3}$ als realistisch target und 10^{-4}$ als optimistisch target.
`"qubit_maj_ns_e4"` , `"qubit_maj_ns_e6"`	`MAJ_NS_E4` , `MAJ_NS_E6`	Betriebszeiten und Fidelitäten können zukünftigen verbesserten Versionen von Majorana-Qubits entsprechen. Für diese Qubits werden Tor- und Messvorgänge angenommen, 100 ns zu nehmen. Um den topologischen Schutz in der Hardware zu berücksichtigen, werden single-qubit und two-qubit joint measurement error rates (Clifford Error Rates) als{-4} realistisch targetangenommen, und $10^{-6}$ als optimistisch target. Nicht-Clifford-Operationen in dieser Architektur haben keinen topologischen Schutz, Fehlerrate für nicht-Clifford physische T-Tore beträgt 5%.

Hinweis

Sofern kein anderer Wert angegeben ist, lautet "qubit_gate_ns_e3"der Standardwert für das Qubit-Modell .

Parameter für vordefinierte Qubit-Parameter

Als Referenz gelten die vollständigen vordefinierten Qubit-Parameter wie folgt:

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

Übergeben vordefinierter Qubit-Parameter

Es gibt zwei Möglichkeiten, vordefinierte Qubit-Parameter programmgesteuert anzugeben. Sie können den Qubit-Modellnamen für die qubitParams Klasse auswählen, wenn sie ausgeführt wird qsharp.estimate. Wenn Sie beispielsweise den Qubit-Parameter auswählen möchten "qubit_maj_ns_e6" , schreiben Sie Folgendes:

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

Sie können auch die Qubit-Parameter mithilfe QubitParamsder Klasse an die EstimatorParams Klasse übergeben. Wenn Sie beispielsweise den Qubit-Parameter auswählen möchten MAJ_NS_E6 , schreiben Sie Folgendes:

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)

Anpassen vordefinierter Qubit-Parameter

Sie können vordefinierte Qubit-Parameter anpassen, indem Sie den Namen angeben und dann einen der anderen Werte aktualisieren. Um beispielsweise die Fehlerrate der Zwei-Qubit-Gelenkmessung in "qubit_maj_ns_e4" zu verringern, schreiben Sie:

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

Oder Sie können die Anweisungen in Form einer Liste übergeben.

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

Qubit-Parameter für Gate-basierte Qubits

Python-Bezeichner	Datentyp	Beschreibung
`name`	string	Name für das Qubit-Modell
`instruction_set`	"gate_based"	Zugrunde liegende Qubit-Technologie
`one_qubit_measurement_time`	Zeitzeichenfolge	Betriebszeit für die Einzel-Qubit-Messung ($t_{\rm meas}$) in ns
`one_qubit_gate_time`	Zeitzeichenfolge	Betriebszeit für single-qubit gate ($t_{\rm gate}$) in ns
`two_qubit_gate_time`	Zeitzeichenfolge	Betriebszeit für zwei Qubit-Gate in ns
`t_gate_time`	Zeitzeichenfolge	Betriebszeit für single-qubit non-Clifford gate in ns
`one_qubit_measurement_error_rate`	float	Fehlerrate für Einzel-Qubit-Messung
`one_qubit_gate_error_rate`	float	Fehlerrate für single-qubit Clifford Gate ($p$)
`two_qubit_gate_error_rate`	float	Fehlerrate für zwei Qubit Clifford Gate
`t_gate_error_rate`	float	Fehlerrate zum Vorbereiten des Nicht-Clifford-Zustands ($p_T$)
`idle_error_rate`	float	Fehlerrate, die dem Leerlauf entspricht

Der folgende Code zeigt, wie benutzerdefinierte Qubit-Parameter für einen gate-basierten Anweisungssatz angegeben werden:

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

Hinweis

Wenn sie nicht angegeben ist, werden die Werte für two_qubit_gate_time und Standardwerte one_qubit_gate_time, die Werte für two_qubit_gate_error_rate und t_gate_error_rate Standardwerte one_qubit_gate_error_ratesowie der Wert für idle_error_rate Standardwerte auf one_qubit_measurement_error_ratet_gate_time .

Qubit-Parameter für Majorana-Qubits

Python-Bezeichner	Datentyp	Beschreibung
`name`	string	Name für das Qubit-Modell
`instruction_set`	"majorana"	Zugrunde liegende Qubit-Technologie
`one_qubit_measurement_time`	Zeitzeichenfolge	Betriebszeit für die Einzel-Qubit-Messung ($t_{\rm meas}$) in ns
`two-qubit_joint_measurement_time`	Zeitzeichenfolge	Betriebszeit für zwei Qubit-Messungen in ns
`t_gate_time`	Zeitzeichenfolge	Betriebszeit für single-qubit non-Clifford gate in ns
`one_qubit_measurement_error_rate`	float	Fehlerrate für Einzel-Qubit-Messung
`two_qubit_joint_measurement_error_rate`	float	Fehlerrate für zwei Qubit-Messungen
`t_gate_error_rate`	float	Fehlerrate zum Vorbereiten des Nicht-Clifford-Zustands ($p_T$)
`idle_error_rate`	float	Fehlerrate, die dem Leerlauf entspricht

Eine Mindestvorlage für majorana-basierte Anweisungssätze mit allen erforderlichen Werten lautet:

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

Hinweis

Wenn sie nicht angegeben ist, werden die Werte für two_qubitJointMeasurementTime und Standardwerte one_qubit_measurement_time, die Werte für two_qubit_joint_measurement_error_rate und t_gate_error_rate Standardwerte one_qubit_measurement_error_ratesowie der Wert für idle_error_rate Standardwerte auf one_qubit_measurement_error_ratet_gate_time .

Für one_qubit_measurement_error_rate und two_qubit_joint_measurement_error_rate, können Sie die Fehlerraten für Messlesevorgänge, readoutund Die Messverarbeitung angeben. process Diese Werte können Zahlen <double> oder Zahlenpaare sein. Zum Beispiel:

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

Hinweis

Wenn Sie einen einzelnen numerischen Wert für Einzel-Qubit- und Zwei-Qubit-Fehlerraten in der Majorana-Qubit-Messung angeben, können sowohl Lese- als auch Prozessfehlerraten gleich sein.

Wichtig

Alle werte, die nicht angegeben werden, nehmen z. B. einen Standardwert an, der angibt "qubit": {"oneQubitGateTime":"200 ns"} , modellieren ein gate-basiertes Qubit, in dem sowohl die Zwei-Qubit-Gatezeit als auch die One-Qubit-Gate-Zeit 200 ns sind. Für Einheiten müssen Sie Zeitzeichenfolgen angeben, bei denen es sich um Gleitkommazahlen mit doppelter Genauigkeit handelt, gefolgt von einem Leerzeichen und der Zeiteinheit für solche Werte, bei denen mögliche Zeitsuffixe sind ns, ( µs oder us), msund s.

Schemas zur Quantenfehlerkorrektur

Um praktische Quantenanwendungen auszuführen, sollten Quantenoperationen niedrige Fehlerraten aufweisen. Diese Fehlerrate targets geht in der Regel über die Funktionen von rohen physischen Qubits hinaus. Um diese Einschränkung zu überwinden, sind die Quantenfehlerkorrektur (Quantum Error Correction, QEC) und fehlertolerante Berechnung zwei wichtige Techniken, die die Bausteine großer Quantencomputer bilden. Zunächst ermöglicht uns QEC, mehrere fehleranfällige physische Qubits zu erstellen und einen zuverlässigeren logischen Qubit zu erstellen, der Quanteninformationen besser als die zugrunde liegenden physischen Qubits bewahrt.

Die Ressourcenschätzung verwendet die folgende Formel zum Modellieren logischer Fehlerraten mithilfe eines exponentiellen Modells.

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

wenn $a$ ein Überquerungsfaktor ist, ist $d$ der Codeabstand, $p$ ist die physische Fehlerrate, und $p^*$ ist der Schwellenwert für die Quantenfehlerkorrektur. Die kreuzende Vorfaktor-$a$ kann numerisch für Simulationen extrahiert werden.

Der Codeabstand $d$ ist ein Parameter, der die Anzahl der Fehler steuert, die korrigiert werden können. Daher definiert der Codeabstand die Fehlerrate der logischen Qubits und die Anzahl der physischen Qubits, die zum Codieren erforderlich sind. Sowohl genauigkeit als auch die Anzahl der physischen Qubits erhöhen sich mit Codeabstand. Ziel eines QEC-Schemas ist es, den mindesten Codeabstand zu finden, der die für eine bestimmte Anwendung festgelegte erforderliche Fehlerrate erreichen kann.

Die physische Fehlerrate $p$ wird aus den Qubit-Parametern extrahiert, da die Fehlerrate aller physischen Clifford-Vorgänge, die im Gerät ausgeführt werden, im schlimmsten Fall auftritt. Insbesondere $p = {}$ max(one_qubit_measurement_error_rate, one_qubit_gate_error_rate, two_qubit_gate_error_rate) für Qubit-Parameter mit einem gate-basierten Anweisungssatz und $p = {}$ max(one_qubit_measurement_error_rate, two_qubit_joint_measurement_error_rate) für Qubit-Parameter mit einem Majorana-Anweisungssatz. QEC-Schemas weisen in der Regel einen Fehlerratenschwellenwert $p^*$ auf, unter dem Fehlerkorrektur Fehler unterdrückt werden.

Der Azure Quantum Resource Estimator unterstützt zwei vordefinierte QEC-Schemas: einen Oberflächencode und einen Floquet-Code.

QEC-Protokoll	Python-API-Klasse	Beschreibung
"`surface_code`"	`SURFACE_CODE`	Der Gate-basierte Oberflächencode basiert auf arXiv:1208.0928 und arXiv:1009.3686. Der Majorana-Oberflächencode basiert auf arXiv:1909.03002 und arXiv:2007.00307.
"`floquet_code`"	`FLOQUET_CODE`	Nur für Majorana-Qubits. Der Floquet-Code basiert auf arXiv:2202.11829.

Hinweis

Sofern kein anderer Wert angegeben ist, lautet der Standardwert für das QEC-Schema "surface_code".

Parameter für vordefinierte QEC-Schemas

Die genauen Parameter für jedes vordefinierte QEC-Schema sind die folgenden:

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

Übergeben vordefinierter QEC-Schemas

Es gibt zwei Möglichkeiten zum Angeben vordefinierter QEC-Schemas. Sie können den QEC-Modellnamen für die "qecScheme" Klasse auswählen, wenn sie ausgeführt wird qsharp.estimate. Wenn Sie z. B. den Floquet-Code auswählen möchten, schreiben Sie Folgendes:

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

Sie können auch eine Liste der Schätzungsparameter mithilfe der Klasse an die QECSchemeEstimatorParams Klasse übergeben. Wenn Sie z. B. den Floquet-Code auswählen möchten, schreiben Sie Folgendes:

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)

Anpassen vordefinierter QEC-Schemas

Sie können vordefinierte QEC-Schemas anpassen, indem Sie den Namen angeben und dann einen der anderen Werte aktualisieren. Wenn Sie z. B. den Überquerungsvorfaktor im Floquet-Code erhöhen möchten, schreiben Sie Folgendes:

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

Hinweis

Wenn nicht angegeben, werden die Werte für "logicalCycleTime" und Standardwerte "oneQubitMeasurementTime", der Wert für "errorCorrectionThreshold" Standardwerte 0.01auf , und der Wert für "crossingPrefactor" Standardwerte auf 0.03"physicalQubitsPerLogicalQubit" .

Anpassen ihrer QEC-Schemas

Die Ressourcenschätzung kann ein benutzerdefiniertes QEC-Schema basierend auf der obigen Formel abstrahiert, indem Werte für die "crossingPrefactor" $a$ und die "errorCorrectionThreshold" $p^*$angegeben werden. Darüber hinaus müssen Sie die "logicalCycleTime"Zeit zum Ausführen eines einzelnen logischen Vorgangs angeben, der von der Codeabstände und den physischen Betriebszeitabnahmen der zugrunde liegenden physischen Qubits abhängt. Schließlich berechnet eine zweite Formel die "physicalQubitsPerLogicalQubit"Anzahl der physischen Qubits, die zum Codieren eines logischen Qubits auf der Grundlage des Codeabstands erforderlich sind.

Sie können den folgenden Code als Vorlage für QEC-Schemas verwenden:

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

Innerhalb der Formeln können Sie die Variablen one_qubit_gate_time, two_qubit_gate_time, , one_qubit_measurement_timeund two_qubit_joint_measurement_time, deren Werte aus dem entsprechenden Feld aus den physikalischen Qubit-Parametern sowie die Variable eccDistance für den für den logischen Qubit berechneten Codeabstand, basierend auf den physischen Qubit-Eigenschaften, dem Fehlerkorrekturschwellenwert und dem Kreuzvorfaktor, verwendet werden. Die Zeitvariablen und eccDistance können zum Beschreiben der logicalCycleTime Formel verwendet werden. Nur für die Formel physicalQubitsPerLogicalQubit kann dies eccDistance verwendet werden.

Fehlerbudget

Das Gesamtfehlerbudget $\epsilon$ legt den gesamt tolerierten Fehler für den Algorithmus fest, d. h. die zulässige Fehlerwahrscheinlichkeit des Algorithmus. Der globale Wert muss zwischen 0 und 1 sein, und der Standardwert ist 0,001, was 0,1 % entspricht. Mit anderen Worten, der Algorithmus darf maximal einmal in 1000 Ausführungen fehlschlagen. Dieser Parameter ist äußerst anwendungsspezifisch.

Wenn Sie z. B. den Shor-Algorithmus für die Faktorierung ganzzahliger Zahlen ausführen, kann ein großer Wert für das Fehlerbudget toleriert werden, da man überprüfen kann, ob die Ausgaben tatsächlich die wichtigsten Faktoren der Eingabe sind. Andererseits kann ein kleineres Fehlerbudget für einen Algorithmus erforderlich sein, der ein Problem mit einer Lösung löst, das nicht so einfach überprüft werden kann.

Das Fehlerbudget entspricht der Summe von drei Teilen:

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

Die logischen Fehler $\epsilon_{\log}$ sind der Fehler bei der Implementierung logischer Qubits, der T-Zustandsfehler $\epsilon_{\rm dis}$ ist der Fehler beim Erzeugen von T-Zuständen durch Destillation, und der Drehungstorfehler $\epsilon_{\rm syn}$ ist der Fehler beim Synthesieren von Drehtoren mit beliebigen Winkeln.

Hinweis

Sofern kein anderer Wert angegeben ist, wird das Fehlerbudget "$\epsilon$" einheitlich zwischen dem logischen Fehler, dem T-Zustandsfehler und dem Drehungsgate-Fehler verteilt.

Beachten Sie, dass für die Destillation und Drehungssynthese die entsprechenden Fehlerbudgets $\epsilon_{\rm dis}$ und $\epsilon_{\rm syn}$ einheitlich auf alle erforderlichen T-Zustände und alle erforderlichen Drehtore verteilt werden. Wenn im Eingabealgorithmus keine Drehtore vorhanden sind, wird das Fehlerbudget einheitlich auf logische Fehler und T-Zustandsfehler verteilt.

Fehlerbudget wird übergeben

Es gibt zwei Möglichkeiten, das Fehlerbudget anzugeben, indem eine Zahl zwischen 0 und 1 festgelegt wird. Sie können das Fehlerbudget beim Ausführen qsharp.estimateübergeben. Wenn Sie beispielsweise ein Fehlerbudget von 1/3 auswählen möchten, schreiben Sie Folgendes:

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

Sie können auch die Fehlerbudgetparameter an die EstimatorParams Klasse übergeben.

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)

Außerdem können Sie jede Komponente des Fehlerbudgets einzeln angeben. Die Summe aller Werte ist das Gesamtfehlerbudget und muss zwischen 0 und 1 sein. Wenn ein Quantenalgorithmus keine T-Zustände oder Drehungen enthält, sind die Werte t_states rotations 0 bzw. 0.

Der folgende Code zeigt, wie Sie den Fehlerbudgetparameter mit T-Zuständen und Drehungen angeben:

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

Einschränkungen

Sie können die "constraints" Klasse verwenden, um Einschränkungen auf der T-Factorykomponentesebene anzuwenden. Durch das Anpassen der Einschränkungen können Sie die Schätzungen optimieren, um die Anzahl der Qubits oder die Laufzeit zu reduzieren.

Parameter	Datentyp	Beschreibung
`logical_depth_factor`	float	Steuern sie die Ausführungszeit. Wenn ein Wert größer als 1 ist, wird die anfängliche Anzahl der logischen Zyklen, auch als logische Tiefe bezeichnet, mit dieser Zahl multipliziert. Durch die Reduzierung `logical_depth_factor`können Sie die Anzahl der Aufrufe der T-Fabrik in einem bestimmten Zeitraum erhöhen, was zu weniger T-Werkskopien führt, die erforderlich sind, um dieselbe Anzahl von T-Zuständen herzustellen. Wenn Sie die Anzahl der T-Factorykopien verringern, erhöht sich die Algorithmuslaufzeit entsprechend. Der Skalierungsfaktor für die Gesamtlaufzeit kann größer sein, da die erforderliche logische Fehlerrate aufgrund der zusätzlichen Anzahl von Zyklen steigt.
`max_t_factories`	integer	Maximale Anzahl von T Factory-Kopien. Die Ressourcenschätzung bestimmt die erforderlichen Ressourcen, indem die optimale Anzahl von T-Factorykopien ausgewählt wird, die die Anzahl der verwendeten physischen Qubits minimieren, ohne den Zeitaufwand zu berücksichtigen. Der `max_t_factories` Parameter beschränkt die maximale Anzahl von Kopien und passt daher die Anzahl der logischen Zyklen entsprechend an. Weitere Informationen finden Sie unter T factory physical estimation.
`max_duration`	Zeitzeichenfolge	Maximale Laufzeit für den Algorithmus. Die Ressourcenschätzung akzeptiert jeweils nur eine oder `max_duration` `max_physical_qubits` zwei Einschränkungen. Wenn `max_duration` angegeben, versucht der Ressourcen-Estimator, die beste Schätzung für `max_physical_qubits` lösungen zu finden, die durch die angegebene maximal angegebene Zahl eingeschränkt sind.
`max_physical_qubits`	integer	Maximale Anzahl physischer Qubits für den Algorithmus. Die Ressourcenschätzung akzeptiert jeweils nur eine oder `max_duration` `max_physical_qubits` zwei Einschränkungen. Wenn `max_physical_qubits` angegeben, versucht der Ressourcen-Estimator, die beste Schätzung für `max_duration` lösungen zu finden, die durch die angegebene maximal angegebene Zahl eingeschränkt sind.

Der folgende Code zeigt, wie Die Einschränkungen für einen Quantenalgorithmus angegeben werden:

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

Hinweis

Wenn der angegebene max_duration Wert zu klein ist, max_physical_qubits um eine machbare Lösung zu finden, gibt der Ressourcen-Estimator einen Fehler zurück. Wenn weder max_duration max_physical_qubits noch Einschränkungen angegeben werden, zielt der Ressourcen-Estimator darauf ab, eine Lösung mit der kürzesten Zeit zu finden.

Tipp

Sie können den Lösungsraum verwenden max_duration und max_physical_qubits beeinflussen, um Lösungen mit längerer Laufzeit zu finden, aber eine kleinere Anzahl von Qubits im Vergleich zu Lösungen ohne diese Einschränkungen. Es gibt einen Kompromiss zwischen Laufzeit und Anzahl von Qubits, und dieser Kompromiss kann für einige Algorithmen effizient verwaltet werden, mit unterschiedlichen Auswirkungen auf verschiedene Algorithmen. Tabelle IV in [arXiv:2211.07629] veranschaulicht die effektive Nutzung des Ausgleichs zwischen der Anzahl der Qubits und der Laufzeit für Quantendynamikalgorithmen. Weitere Informationen finden Sie unter Quantum resource estimation with time or number of qubits constraints sample.

Destillationseinheiten

Sie können Spezifikationen für T-Fabriken destillationsalgorithmen mit der DistillationUnitSpecification Klasse bereitstellen. Die Spezifikation kann entweder vordefiniert oder benutzerdefinierter sein. Sie können eine vordefinierte Spezifikation angeben, indem Sie den Namen der Destillationseinheit auswählen: 15-1 RM oder 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 beiden Fällen steht die Notation 15-1 für 15 T-Eingangszustände und einen T-Ausgabezustand. Die 15-1 space-efficient-Destillationseinheit verwendet weniger Qubits als 15-1 RM, erfordert jedoch mehr Laufzeit. Weitere Informationen finden Sie in Tabelle VI.

Tipp

Die Verwendung vordefinierter Destillationseinheiten bietet einen besseren Leistungsvergleich mit benutzerdefinierten Einheiten.

Anpassen der Destillationseinheiten

Sie können Ihre eigenen Destillationseinheiten anpassen. Die genauen Parameter für die Destillationseinheiten sind die folgenden.

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

Es wird erwartet, dass alle numerischen Parameter positiv sind. Dies displayName gibt an, wie die Destillationseinheit in Ausgabeergebnissen angezeigt wird.

Der folgende Code zeigt, wie Die Destillationseinheitsparameter für einen Quantenalgorithmus mithilfe der DistillationUnitSpecification Klasse und der ProtocolSpecificDistillationUnitSpecification Klasse angegeben werden.

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

Die Formeln für failure_probability_formula und output_error_rate_formula sind benutzerdefinierte Formeln mit grundlegenden arithmetischen Operationen, Konstanten und nur drei Parametern:

clifford_error_rate, auch als .c
readout_error_rate, auch als .r
input_error_rate, auch als .z

Sehen Sie sich die folgenden Beispiele für benutzerdefinierte Formeln mit langer und kurzer Schreibweise an. Diese Beispiele veranschaulichen Formeln, die standardmäßig in der Standardimplementierung verwendet werden.

Parameter	Lange Formel	Kurze 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"

Mindestens einer der Parameter physical_qubit_specification oder logical_qubit_specification sollte bereitgestellt werden. Wenn nur der erste bereitgestellt wird, kann die Destillationseinheit auf physische Qubits angewendet werden. Wenn nur letzteres bereitgestellt wird, kann die Destillationseinheit auf logische Qubits angewendet werden. Wenn beide bereitgestellt werden, kann die Destillationseinheit auf beide Arten von Qubits angewendet werden.

Der Parameter logical_qubit_specification_first_round_override kann nur angegeben werden, wenn logical_qubit_specification er angegeben ist. Ist dies der Fall, überschreibt sie werte, falls logical_qubit_specification sie bei der ersten Destillationsrunde angewendet werden. Der wert <protocol specific parameters> , für logical_qubit_specification_first_round_override den erforderlich ist, sollte dem Schema folgen:

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

Schätzung der Pareto-Grenze

Bei der Schätzung der Ressourcen eines Algorithmus ist es wichtig, den Kompromiss zwischen der Anzahl der physischen Qubits und der Laufzeit des Algorithmus zu berücksichtigen. Sie könnten die Zuordnung von so vielen physischen Qubits wie möglich in Betracht ziehen, um die Laufzeit des Algorithmus zu reduzieren. Die Anzahl der physischen Qubits ist jedoch durch die Anzahl der physischen Qubits begrenzt, die in der Quantenhardware verfügbar sind. Das Verständnis des Kompromisses zwischen Laufzeit und Systemmaßstab ist einer der wichtigeren Aspekte der Ressourcenschätzung.

Die Schätzung der Pareto-Grenze liefert mehrere Schätzungen für denselben Algorithmus, wobei jeweils Kompromisse zwischen der Anzahl der Qubits und der Laufzeit angezeigt werden.

Hinweis

Wenn Sie den Ressourcen-Estimator in Visual Studio Code mit der Q#Option "Ressourcenschätzungen berechnen" ausführen, ist die Schätzung der Grenzen von Pareto standardmäßig aktiviert.

Wenn Sie den Resource Estimator in Python ausführen, müssen Sie den "estimateType" Parameter als "frontier"angeben.

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

Wenn Sie die Ergebnisse der Pareto-Grenzschätzung visualisieren möchten, können Sie die EstimatesOverview Funktion verwenden. Diese Funktionen zeigen die Ergebnisse der Grenzschätzung in der Tabelle und ein Raumzeitdiagramm an. Weitere Informationen finden Sie unter Raumzeitdiagramm.

from qsharp_widgets import EstimatesOverview

EstimatesOverview(result)

Hinweis

Wenn beim Arbeiten mit der Ressourcenschätzung probleme auftreten, schauen Sie sich die Seite "Problembehandlung" an, oder wenden Sie sich an den Kontakt AzureQuantumInfo@microsoft.com.

Freigeben über

Anpassen der target Parameter des Ressourcenstimators

Voraussetzungen

Target-Parameter

Physische Qubit-Parameter

Parameter für vordefinierte Qubit-Parameter

Übergeben vordefinierter Qubit-Parameter

Anpassen vordefinierter Qubit-Parameter

Qubit-Parameter für Gate-basierte Qubits

Qubit-Parameter für Majorana-Qubits

Schemas zur Quantenfehlerkorrektur

Parameter für vordefinierte QEC-Schemas

Übergeben vordefinierter QEC-Schemas

Anpassen vordefinierter QEC-Schemas

Anpassen ihrer QEC-Schemas

Fehlerbudget

Fehlerbudget wird übergeben

Einschränkungen

Destillationseinheiten

Anpassen der Destillationseinheiten

Schätzung der Pareto-Grenze

Nächste Schritte

Feedback

Zusätzliche Ressourcen