QESEM: Eine Qiskit-Funktion von Qedma

Siehe API-Referenz

• Paketversionen

  Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt. Wir empfehlen, diese Versionen oder neuere zu verwenden.

  qiskit[all]~=2.5.0
  qiskit-ibm-runtime~=0.47.0
  

Übersicht

Obwohl Quantenprozessoren in den letzten Jahren erheblich verbessert wurden, stellen Fehler aufgrund von Rauschen und Unvollkommenheiten in der vorhandenen Hardware nach wie vor eine zentrale Herausforderung für Entwickler von Quantenalgorithmen dar. Da sich das Gebiet zunehmend mit Quantenberechnungen im Versorgungsmaßstab befasst, die klassisch nicht verifiziert werden können, gewinnen Lösungen zur Unterdrückung von Rauschen mit garantierter Genauigkeit zunehmend an Bedeutung. Um diese Herausforderung zu bewältigen, hat Qedma Quantum Error Mitigation (QESEM) entwickelt, das nahtlos als Qiskit-Funktion in IBM Quantum Platform integriert ist.

Mit QESEM können Anwender ihre Quantenschaltungen auf verrauschten QPUs ausführen, um hochpräzise, fehlerfreie Ergebnisse mit äußerst effizienten QPU-Zeitaufwänden zu erzielen, die nahe an den fundamentalen Grenzen liegen. Um dies zu erreichen, nutzt QESEM eine Reihe von eigens von Qedma entwickelten Methoden zur Charakterisierung und Fehlerreduzierung. Zu den Techniken zur Fehlerreduzierung zählen die Gate-Optimierung, die rauschbewusste Transpilierung, die Fehlerunterdrückung (ES) und die unvoreingenommene Fehlerminderung (EM). Durch die Kombination dieser charakterisierungsbasierten Methoden können Anwender zuverlässige, fehlerfreie Ergebnisse für generische Quanten-Schaltkreise mit großem Volumen erzielen und damit Anwendungen erschließen, die auf andere Weise nicht realisierbar wären.

Eine vollständige Beschreibung der zugrunde liegenden Komponenten sowie eine Demonstration im Versorgungsmaßstab finden Sie in dem Artikel „Reliable high-accuracy error mitigation for utility-scale quantum circuits” (Zuverlässige, hochpräzise Fehlerkorrektur für Quanten-Schaltkreise im Versorgungsmaßstab).

Beschreibung

Mit der QESEM-Funktion von Qedma können Sie auf einfache Weise Ihre Schaltungen mit Fehlerunterdrückung und -minderung abschätzen und ausführen und so größere Schaltungsvolumina und höhere Genauigkeiten erreichen. Für die Verwendung von QESEM benötigen Sie einen Quantenschaltkreis, eine Reihe von zu messenden Messgrößen, eine angestrebte statistische Genauigkeit für jede Messgröße und eine ausgewählte QPU. Bevor Sie die Schaltung mit der angestrebten Genauigkeit ausführen, können Sie die erforderliche QPU-Zeit auf der Grundlage einer analytischen Berechnung schätzen, die keine Ausführung der Schaltung erfordert. Wenn Sie mit der QPU-Zeitabschätzung zufrieden sind, können Sie die Schaltung mit QESEM ausführen.

Wenn Sie eine Schaltung ausführen, führt QESEM ein auf Ihre Schaltung zugeschnittenes Protokoll zur Gerätecharakterisierung durch und erstellt so ein zuverlässiges Rauschmodell für die in der Schaltung auftretenden Fehler. Basierend auf der Charakterisierung implementiert QESEM zunächst eine rauschbewusste Transpilation, um die Eingabeschaltung auf eine Reihe physikalischer Qubits und Gatter abzubilden, wodurch das Rauschen, das die Zielobservable beeinflusst, minimiert wird. Dazu gehören die nativ verfügbaren Gatter (CX/CZ auf Geräten mit IBM® ) sowie zusätzliche, von QESEM optimierte Gatter, die den erweiterten Gatter-Satz von QESEM bilden. QESEM führt dann eine Reihe von charakterisierungsbasierten ES- und EM-Schaltungen auf der QPU aus und sammelt deren Messergebnisse. Diese werden dann klassisch nachbearbeitet, um einen unverzerrten Erwartungswert und einen Fehlerbalken für jede Beobachtungsgröße zu erhalten, entsprechend der geforderten Genauigkeit.

QESEM liefert nachweislich hochpräzise Ergebnisse für eine Vielzahl von Quantenanwendungen und für die größten Schaltkreisvolumina, die heute möglich sind. QESEM bietet die folgenden benutzerseitigen Funktionen, die im folgenden Abschnitt über Benchmarks vorgestellt werden:

• Garantierte Genauigkeit: QESEM liefert unverzerrte Schätzungen für Erwartungswerte von Observablen. Die EM-Methode verfügt über theoretische Garantien, die – zusammen mit der hochmodernen Charakterisierung von Qedma – sicherstellen, dass die Dämpfung bis zur vom Benutzer festgelegten Genauigkeit mit der rauschfreien Schaltungsausgabe konvergiert. Im Gegensatz zu vielen heuristischen EM-Methoden, die anfällig für systematische Fehler oder Verzerrungen sind, ist die garantierte Genauigkeit von QESEM unerlässlich, um zuverlässige Ergebnisse in generischen Quantenschaltungen und Observablen zu gewährleisten.
• Skalierbarkeit auf große QPUs: Die QPU-Zeit von QESEM hängt vom Schaltungsvolumen ab, ist aber ansonsten unabhängig von der Anzahl der Qubits. Qedma hat QESEM auf den derzeit größten verfügbaren Quantencomputern demonstriert, darunter die Geräte „ IBM Quantum “ mit 127 Qubits („Eagle“) und 133 Qubits („Heron“).
• Anwendungsunabhängig: QESEM hat sich in einer Vielzahl von Anwendungen bewährt, darunter Hamilton-Simulation, VQE, QAOA und Amplitudenschätzung. Die Benutzer können beliebige Quantenschaltungen und Beobachtungsgrößen eingeben, die gemessen werden sollen, und erhalten genaue, fehlerfreie Ergebnisse. Die einzigen Grenzen werden durch die Hardwarespezifikationen und die zugewiesene QPU-Zeit gesetzt, die das zugängliche Schaltungsvolumen und die Ausgabegenauigkeit bestimmen. Im Gegensatz dazu sind viele Lösungen zur Fehlerreduzierung anwendungsspezifisch oder beinhalten unkontrollierte Heuristiken, so dass sie für generische Quantenschaltungen und -anwendungen nicht anwendbar sind.
• Erweitertes Gate-Set: QESEM unterstützt Fractional-Angle-Gates und bietet Qedma-optimierte Fractional-Angle- $Rzz(\theta)$ -Gates auf IBM Quantum Heron und Eagle-Geräten. Dieses erweiterte Gate-Set ermöglicht eine effizientere Kompilierung und erschließt Schaltungsvolumina, die um bis zu 2 Mal größer sind als bei der Standard-CX/CZ-Kompilierung.
• Mehrbasige Observablen: QESEM unterstützt Eingangsobservablen, die aus vielen nicht-kommutierenden Pauli-Strings bestehen, wie z.B. generische Hamiltonianer. Die Auswahl der Messgrundlagen und die Optimierung der QPU-Ressourcenzuweisung (Schüsse und Schaltkreise) werden dann automatisch von QESEM durchgeführt, um die erforderliche QPU-Zeit für die gewünschte Genauigkeit zu minimieren. Durch diese Optimierung, die die Hardware-Treue und die Ausführungsraten berücksichtigt, können Sie tiefere Schaltungen ausführen und höhere Genauigkeiten erzielen.

Benchmarks

QESEM wurde in einer Vielzahl von Anwendungsfällen und Applikationen getestet. Die folgenden Beispiele können Ihnen helfen, zu beurteilen, welche Arten von Workloads Sie mit QESEM ausführen können.

Eine wichtige Kennzahl für die Quantifizierung der Härte sowohl der Fehlerminderung als auch der klassischen Simulation für eine bestimmte Schaltung und eine bestimmte Messgröße ist das aktive Volumen : die Anzahl der CNOT-Gatter, die die Messgröße in der Schaltung beeinflussen. Das aktive Volumen hängt von der Tiefe und Breite des Schaltkreises, vom Gewicht des Beobachtungsobjekts und von der Schaltkreisstruktur ab, die den Lichtkegel des Beobachtungsobjekts bestimmt. Weitere Einzelheiten finden Sie in dem Vortrag auf dem Quantengipfel 2024 IBM. QESEM bietet einen besonders hohen Wert im Bereich hoher Volumina und liefert zuverlässige Ergebnisse für allgemeine Schaltungen und Beobachtungsgrößen.

Die Genauigkeit wird hier relativ zum Idealwert der Messgröße gemessen: $\frac{\langle O \rangle_{ideal} - \epsilon}{\langle O \rangle_{ideal}}$ dabei ist " $\epsilon$ " die absolute Genauigkeit der Abschwächung (die durch die Benutzereingabe festgelegt wird) und " $\langle O \rangle_{ideal}$ " ist die Beobachtungsgröße im geräuschlosen Kreislauf. die "Laufzeitnutzung" misst die Nutzung des Benchmarks im Batch-Modus (Summe der Nutzung der einzelnen Jobs), während die "Gesamtzeit" die Nutzung im Sitzungsmodus (Experiment-Wall-Time) misst, die zusätzliche klassische und Kommunikationszeiten umfasst. QESEM kann in beiden Modi ausgeführt werden, so dass die Benutzer ihre verfügbaren Ressourcen optimal nutzen können.

Die 28-Qubit-Kicked-Ising-Schaltungen simulieren den zeitdiskreten Quasikristall, der von Shinjo et al. untersucht wurde (siehe arXiv 2403.16718 und Q2B24 Tokyo ) auf drei verbundenen Schleifen von ibm_kawasaki. Die Schaltungsparameter sind hier $(\theta_x, \theta_z) = (0.9 \pi, 0)$, mit einem ferromagnetischen Anfangszustand $| \psi_0 \rangle = | 0 \rangle ^{\otimes n}$. Die gemessene Observable ist der Absolutwert der Magnetisierung $M = |\frac{1}{28} \sum_{i=0}^{27} \langle Z_i \rangle|$. Das Utility-Scale Kicked Ising-Experiment wurde mit den 136 besten Qubits von ibm_fez durchgeführt; dieser spezielle Benchmark wurde mit dem Clifford-Winkel $(\theta_x, \theta_z) = (\pi, 0)$ durchgeführt, bei dem das aktive Volumen langsam mit der Schaltungstiefe wächst, was - zusammen mit den hohen Bauteiltreuegraden - hohe Genauigkeit bei kurzer Laufzeit ermöglicht.

Die trotterisierten Hamilton-Simulationsschaltungen gelten für ein Transversalfeld-Ising-Modell bei gebrochenen Winkeln: $(\theta_{zz}, \theta_x) = (\pi / 4, \pi /8)$ und $(\theta_{zz}, \theta_x) = (\pi / 6, \pi / 8)$ (siehe Q2B24 Tokyo ). Die Utility-Scale-Schaltung wurde mit den 119 besten Qubits von ibm_brisbane betrieben, während das 40-Qubit-Experiment mit der besten verfügbaren Kette durchgeführt wurde. Die Genauigkeit wird für die Magnetisierung angegeben; hochpräzise Ergebnisse wurden auch für schwerere Observablen erzielt.

Die VQE-Schaltung wurde gemeinsam mit Forschern des Zentrums für Quantentechnologie und Anwendungen am Deutschen Elektronen-Synchrotron (DESY) entwickelt. Die Zielobservable war hier ein Hamiltonian, der aus einer großen Anzahl von nicht-kommutierenden Pauli-Strings besteht, was die optimierte Leistung von QESEM für Multibasenobservablen unterstreicht. Die Abschwächung wurde auf einen klassisch optimierten Ansatz angewandt; obwohl diese Ergebnisse noch unveröffentlicht sind, werden Ergebnisse von gleicher Qualität für andere Schaltungen mit ähnlichen strukturellen Eigenschaften erzielt werden.

Erste Schritte

Melden Sie sich mit Ihrem API-Schlüssel von „ IBM Quantum Platform “ an und wählen Sie die QESEM-Qiskit-Funktion wie folgt aus. (In diesem Codeausschnitt wird davon ausgegangen, dass Sie Ihr Konto bereits in Ihrer lokalen Umgebung gespeichert haben.)

import qiskit
from qiskit_ibm_catalog import QiskitFunctionsCatalog

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# verify that you have access to the function
catalog.list()

# load the function
qesem_function = catalog.load("qedma/qesem")

Beispiele

Beispiel für einen Auftrag zur Zeitaufwandsschätzung

backend_nameDer Auftrag zur Zeitschätzung ist nützlich, um die für ein gegebenes pub und erforderliche QPU-Zeit abzuschätzen. fake_fez``backend_name kann auch auf ein beliebiges Simulator-Backend eingestellt werden; zum Beispiel.

QESEM verwendet eine quasi-probabilistische, charakterisierungsbasierte EM-Methode. Diese Methode verursacht einen QPU-Zeitaufwand, der in etwa wie folgt skaliert:

$T_{QPU} = a \frac{e^{\alpha IF\cdot V_a}}{\epsilon^2} + b$

Dabei ist $V_a$ das aktive Volumen des Schaltkreises, $\epsilon$ die angestrebte Genauigkeit und $IF$ die Ungenauigkeit der nativen Gatter.

Beachten Sie, dass "estimate_time_only": "empirical" einige Minuten QPU-Zeit benötigt, um die für den Auftrag erforderliche Zeit zu schätzen (sofern es sich bei dem Backend um ein echtes Gerät handelt; handelt es sich um einen Simulator, wird keine QPU-Zeit verbraucht). Das dauert in der Regel etwa 5 Minuten, höchstens jedoch 10 Minuten. Sollte sich die Auslastung zwischen dem empirischen Zeitaufwandsschätzungslauf und dem Optimierungslauf drastisch ändern, wird sich auch die QPU-Zeit drastisch ändern.

Probieren Sie zunächst dieses einfache Beispiel aus, um die erforderliche QPU-Zeit für die Ausführung von QESEM für eine bestimmte pub zu schätzen:

backend_name = "fake_fez"

circ = qiskit.QuantumCircuit(5)
circ.cx(0, 1)
circ.cx(2, 3)
circ.cx(1, 2)
circ.cx(3, 4)

avg_magnetization = qiskit.quantum_info.SparsePauliOp.from_sparse_list(
    [("Z", [q], 1 / 5) for q in range(5)], num_qubits=5
)
other_observable = qiskit.quantum_info.SparsePauliOp.from_sparse_list(
    [("ZZ", [0, 1], 1.0), ("XZ", [1, 4], 0.5)], num_qubits=5
)

time_estimation_job = qesem_function.run(
    pubs=[(circ, [avg_magnetization, other_observable])],
    options={
        "estimate_time_only": "empirical",
    },
    backend_name=backend_name,  # example: "fake_fez", "ibm_fez"
)

time_estimate_result = (
    time_estimation_job.result()
)  # a list of results per pub (circuit)

Der folgende Codeausschnitt beschreibt, wie verschiedene Ausführungsmetriken aus dem Job zur Zeitschätzung abgerufen werden können (estimate_time_only ist gesetzt):

pub_result = time_estimate_result[0]

print(
    f"The estimated QPU time for mitigation for this PUB is: {pub_result.metadata['time_estimation_sec']}"
)
print(
    f"The QPU time that this time estimation job took is (here it is 0 because we used fake_fez): {pub_result.metadata['total_qpu_time']}"
)
print(
    f"Gates fidelity measured during the experiment: {pub_result.metadata['gate_fidelities']}"
)
print(f"Total shots: {pub_result.metadata['total_shots']}")
print(f"Resource usage breakdown: {pub_result.metadata['resource_usage']}")

Output:

The estimated QPU time for mitigation for this PUB is: 300
The QPU time that this time estimation job took is (here it is 0 because we used fake_fez): 0
Gates fidelity measured during the experiment: {'CZ': 0.9951354916722668, 'ID1Q': 0.9991246627329172}
Total shots: 220000
Resource usage breakdown: {'RUNNING: MAPPING': {'CPU_TIME': 33.6066133165732, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 184.53575124032795, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: EXECUTING_QPU': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}}

Wenn die empirische Zeitschätzung aktiviert ist, führt QESEM eine kleine Anzahl von Schaltkreisen aus, um eine genauere Zeitschätzung für die QPU zu erhalten. Die Ergebnisse der Risikominderung für diese Schaltkreise sind im empirical_estimation_mitigation_results Feld des Auftrags verfügbar.

Da diese Ergebnisse auf einer begrenzten Stichprobe von Schaltungen basieren, sind sie deutlich ungenauer als die Endergebnisse, die im Rahmen des vollständigen QESEM-Mitigationsprozesses erzielt wurden. Ist die Schaltung jedoch klein oder die angestrebte Genauigkeit gering, kann die bei der empirischen Zeitschätzung durchgeführte Fehlerminderung ausreichen, um die gewünschte Genauigkeit zu erreichen, sodass die vollständige Fehlerminderung möglicherweise nicht erforderlich ist.

Das empirical_estimation_mitigation_results Feld ist eine Liste von PrimitiveResult Objekten pro Eingabeparameter. Wenn der Schaltkreis nicht parametrisiert ist, hat die Liste die Länge 1.

empirical_estimation_mitigation_results = time_estimate_result[0].metadata[
    "empirical_estimation_mitigation_results"
][0]  # a list per parameter

print("Partial results for the observables:")

print(
    f"    Mitigated expectation values: {empirical_estimation_mitigation_results.data.evs}"
)
print(
    f"    Mitigated error bars: {empirical_estimation_mitigation_results.data.stds}"
)
print(
    f"    Number of shots used for mitigation: {empirical_estimation_mitigation_results.metadata['mitigation_shots']}"
)
transpiled_circ = empirical_estimation_mitigation_results.metadata[
    "transpiled_circ"
]
print(f"    Qubit mapping: {transpiled_circ['qubit_maps']}")
print(
    f"    Number of measurement bases: {transpiled_circ['num_measurement_bases']}\n"
)

# results per obs
emp_obs_results = empirical_estimation_mitigation_results.metadata["results"][
    0
]
# print(f"Results for each observable: {results}")
print("Results for each observable:")

for i, (obs_array, result_dict) in enumerate(emp_obs_results):
    # obs_array, result_dict = results
    print(f"Observable {i+1}: {obs_array}")
    print(
        f"    QESEM mitigated value: {result_dict['qesem']['value']} \u00b1 {result_dict['qesem']['error_bar']}"
    )

Output:

Partial results for the observables:
    Mitigated expectation values: [1.00347302 1.00693905]
    Mitigated error bars: [0.00304061 0.00714276]
    Number of shots used for mitigation: 180000
    Qubit mapping: [[[0, 136], [1, 143], [2, 142], [3, 141], [4, 140]]]
    Number of measurement bases: 2

Results for each observable:
Observable 1: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
    QESEM mitigated value: 1.003473015776871 ± 0.0030406128032204015
Observable 2: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
    QESEM mitigated value: 1.0069390542613554 ± 0.0071427606736885925

Beispiel für einen QESEM-Maßnahmenplan

Das folgende Beispiel führt einen QESEM-Auftrag aus:

sample_job = qesem_function.run(
    pubs=[(circ, [avg_magnetization, other_observable])],
    backend_name=backend_name,  # example: "ibm_fez"
    # options = {
    #     "estimate_time_only": "empirical",
    #     "default_precision": 0.2,  # Default precision is applied to all pubs that don't have a precision specified, see API reference for more details
    #     "max_execution_time": 3600,  # You can specify a maximum QPU time in seconds, see API reference for more details
    #     "transpilation_level": "standard",  # "minimal_with_layout_opt" for minimal transpilation, see API reference for more details
    #     "parallel_execution": True,  # True for parallel execution, see API reference for more details
    # },
)

Eine ausführliche Beschreibung der einzelnen Eingabefelder und Optionen finden Sie in der QESEM-API-Referenz.

Sie können die vertrauten Qiskit Serverless-APIs verwenden, um den Status Ihrer Qiskit Function-Workloads zu überprüfen oder Ergebnisse zurückzugeben:

# Print the ID so you can use it later, if necessary
print(sample_job.job_id)
print(sample_job.status())
sample_result = sample_job.result()

Output:

3ac6b2df-15b0-4dc0-8f48-cf14bd20a1c8
DONE

Der folgende Codeausschnitt veranschaulicht, wie die Ergebnisse der Risikominderung und die Ausführungsmetriken abgerufen werden können. Diese enthalten wichtige Daten, die ein tieferes Verständnis dafür ermöglichen, wie sich verschiedene Parameter auf die Durchführung der QESEM-Messung auswirken. Dies kann auch beim Verfassen einer wissenschaftlichen Arbeit auf der Grundlage Ihrer Forschungsergebnisse von Bedeutung sein.

for pub_idx, pub_result in enumerate(
    sample_result
):  # each element in the list is a result for a different pub, here we sent only one pub
    print(f"\nPUB {pub_idx}:")
    print(
        f"  The QPU time that this job took is (here it is 0 because we used fake_fez): {pub_result.metadata['total_qpu_time']}"
    )
    print(
        f"  Gates fidelity measured during the experiment: {pub_result.metadata['gate_fidelities']}"
    )
    print(f"  Total shots: {pub_result.metadata['total_shots']}")
    print(
        f"  Number of shots used for mitigation: {pub_result.metadata['mitigation_shots']}"
    )
    print(
        f"  Resource usage breakdown: {pub_result.metadata['resource_usage']}"
    )

Output:

PUB 0:
  The QPU time that this job took is (here it is 0 because we used fake_fez): 0.0
  Gates fidelity measured during the experiment: {'CZ': 0.9953704216147041, 'ID1Q': 0.9991834123567518}
  Total shots: 446000
  Number of shots used for mitigation: 194000
  Resource usage breakdown: {'RUNNING: MAPPING': {'CPU_TIME': 32.52745003718883, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 257.850521848537, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: EXECUTING_QPU': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}, 'RUNNING: POST_PROCESSING': {'CPU_TIME': 0.0, 'GPU_TIME': 0.0, 'QPU_TIME': 0.0}}

In metadata["results"] werden die Ergebnisse zunächst nach Schaltungsinstanz und anschließend nach Messgröße gruppiert.

print("Full QESEM mitigation results:")

for pub_idx, pub_result in enumerate(sample_result):
    print(f"\nPUB {pub_idx}:")

    print(f"  Mitigated expectation values: {pub_result.data.evs}")
    print(f"  Mitigated error bars: {pub_result.data.stds}")
    noisy_results = pub_result.metadata.get("noisy_results")
    print(f"  Unmitigated expectation values: {noisy_results.evs}")
    print(f"  Unmitigated error bars: {noisy_results.stds}")

    print("  Transpiled circuits:")
    for circ_idx, transpiled_circ in enumerate(
        pub_result.metadata["transpiled_circs"]
    ):
        print(f"    Circuit {circ_idx}:")
        # print(f"      Circuit: \n {transpiled_circ['circuit']}") # not printing it because it's long but you can see the transpiled circuit itself
        print(f"      Qubit mapping: {transpiled_circ['qubit_maps']}")
        print(
            f"      Measurement bases: {transpiled_circ['num_measurement_bases']}"
        )

    print("  Results for each observable:")
    for circ_idx, circ_results in enumerate(pub_result.metadata["results"]):
        print(f"    Circuit {circ_idx}:")
        for obs_idx, (obs_array, result_dict) in enumerate(circ_results):
            print(f"      Observable {obs_idx}: {obs_array}")
            print(
                f"        QESEM mitigated value: {result_dict['qesem']['value']} ± {result_dict['qesem']['error_bar']}"
            )
            print(
                f"        Unmitigated value: {result_dict['unmitigated']['value']} ± {result_dict['unmitigated']['error_bar']}"
            )

Output:

Full QESEM mitigation results:

PUB 0:
  Mitigated expectation values: [1.00648343 1.00636289]
  Mitigated error bars: [0.00253812 0.00693586]
  Unmitigated expectation values: [0.98031429 0.96357143]
  Unmitigated error bars: [0.00124128 0.00578812]
  Transpiled circuits:
    Circuit 0:
      Qubit mapping: [[[0, 140], [1, 141], [2, 142], [3, 143], [4, 136]]]
      Measurement bases: 2
  Results for each observable:
    Circuit 0:
      Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
        QESEM mitigated value: 1.0064834305181962 ± 0.002538119914534849
        Unmitigated value: 0.9803142857142859 ± 0.0012412835813609938
      Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
        QESEM mitigated value: 1.0063628870614818 ± 0.006935859820870656
        Unmitigated value: 0.9635714285714285 ± 0.005788121870526659

Aufschlüsselung der wichtigsten Ergebnisse:

• mitigated: der vollständig gemilderte QESEM-Erwartungswert.
• unmitigated: das rohe Ergebnis des physikalischen Rauschens ohne Fehlerminderung.

Ergebnisse der heuristischen Extrapolation mit QESEM

Bei einem Standard-QESEM-Durchlauf mit einem einzelnen precision Float enthalten die Ergebnisse zudem automatisch verfügbare Rauschskalierungspunkte, die für die QESEM-Heuristik verwendet werden. Diese Punkte werden ohne zusätzliche QPU-Ressourcen berechnet.

Die Skala 1.0 stellt den Rauschpegel des physikalischen Geräts mit Ausleserauschunterdrückung (REM) dar, während die Skala 2.0 den komplementären, rauschverstärkten Punkt ebenfalls mit REM angibt. Aus diesen Punkten wird das qesem_heuristic Ergebnis ermittelt.

• qesem_heuristic: eine Schätzung im ZNE-Stil, die aus den verfügbaren, rauschskalierten Daten berechnet wurde. Derzeit wird hierfür eine exponentielle Extrapolation verwendet.
• noise_scaling.results_with_REM: Erwartungswerte bei verschiedenen Rauschskalen, jeweils mit Ausleserauschminderung (REM).

Ein subtiles, aber wichtiges Detail ist, dass das Skalierungsergebnis 1.0 nicht mit dem unmitigated Ergebnis übereinstimmt. Beide Werte entsprechen dem Rauschpegel des physikalischen Geräts, doch der Skalenpunkt 1.0 berücksichtigt die Auslesungsdämpfung, während unmitigated dies nicht tut.

print("QESEM heuristic results:")

for pub_idx, pub_result in enumerate(sample_result):
    print(f"\nPUB {pub_idx}:")
    for circ_idx, circ_results in enumerate(pub_result.metadata["results"]):
        print(f"  Circuit {circ_idx}:")
        for obs_idx, (obs_array, result_dict) in enumerate(circ_results):
            print(f"    Observable {obs_idx}: {obs_array}")
            qesem_heuristic = result_dict["qesem_heuristic"][0]
            print("      QESEM heuristic:")
            print(
                f"        Value: {qesem_heuristic['value']} ± {qesem_heuristic['error_bar']}"
            )
            print(
                f"        Extrapolation: {qesem_heuristic['extrapolation']}"
            )
            print(
                f"        Scale factors: {qesem_heuristic['scale_factors']}"
            )
            noise_scaling = result_dict["noise_scaling"]
            print("      Noise scaling results:")
            print(
                f"        Scaling method: {noise_scaling['scaling_method']}"
            )
            print("        Results with Readout mitigation (REM):")
            for rem_result in sorted(
                (
                    item
                    for item in noise_scaling["results_with_REM"]
                    if item["scale"] != 0.0
                ),
                key=lambda item: item["scale"],
            ):
                print(
                    f"          Scale factor {rem_result['scale']}: {rem_result['value']} ± {rem_result['error_bar']}"
                )

Output:

QESEM heuristic results:

PUB 0:
  Circuit 0:
    Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
      QESEM heuristic:
        Value: 1.0008161638888535 ± 0.0038859458884403964
        Extrapolation: exponential
        Scale factors: [1.0, 2.0]
      Noise scaling results:
        Scaling method: QESEM
        Results with Readout mitigation (REM):
          Scale factor 1.0: 0.9918395459270772 ± 0.0012565417579355634
          Scale factor 2.0: 0.982943441922748 ± 0.0028919278067695018
    Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
      QESEM heuristic:
        Value: 0.9960853148925298 ± 0.013811635038961175
        Extrapolation: exponential
        Scale factors: [1.0, 2.0]
      Noise scaling results:
        Scaling method: QESEM
        Results with Readout mitigation (REM):
          Scale factor 1.0: 0.9902860583785115 ± 0.005921236914723409
          Scale factor 2.0: 0.984520565414274 ± 0.006909522262347639

Beispiel für eine parametrisierte Schaltung

Viele Algorithmen berechnen dieselbe Schaltung bei verschiedenen Parameterwerten. Durch das Senden der parametrisierten Schaltung als einen einzigen QESEM-Auftrag kann QESEM die Charakterisierung und Kalibrierung auf alle Schaltungsinstanzen anwenden, was im Vergleich zur Ausführung separater Aufträge den QPU-Zeitaufwand reduzieren kann.

Um eine parametrisierte Schaltung einzureichen, muss die "minimal_with_layout_opt" Transpilationsebene verwendet werden. Auf dieser Ebene eingereichte Schaltkreise sollten – je nach Backend – bereits unter Verwendung der Basisgatter des Backends ausgedrückt sein. Auf dieser Ebene hält QESEM die eingereichte Struktur so nah wie möglich an der Eingangsschaltung, berücksichtigt Barrieren bei der Schichtung (Gruppierung von Operationen in Schichten paralleler Zwei-Qubit-Gatter) und übernimmt dennoch automatisch die Hardware-Zuordnung zu hochpräzisen Qubits sowie die Verbindung der Bausteine.

In der Praxis bedeutet dies, dass Sie Schaltkreise vor der Einreichung in die Basisgatter des Ziel-Backends transpilieren sollten. Nachfolgend ist ein einfaches Beispiel für die Transpilierung eines Basis-Gates dargestellt.

QESEM unterstützt derzeit nur eine Messgröße pro Parametersatz. other_observable``avg_magnetizationDie beiden folgenden Parameterzeilen sind mit den beiden Observables verknüpft: Die erste Zeile wird mit gemessen, die zweite Zeile mit.

# Transpile to the backend basis gates only. With minimal_with_layout_opt, QESEM handles hardware mapping/connectivity and observable layout internally.
from qiskit_ibm_runtime.fake_provider import FakeFez

backend = FakeFez()
basis = backend.operation_names
print(basis)

param0 = qiskit.circuit.Parameter("param0")
param1 = qiskit.circuit.Parameter("param1")
parametrized_circ = qiskit.QuantumCircuit(5)
parametrized_circ.rx(param0, 0)
parametrized_circ.rx(param1, 1)
parametrized_circ.cx(0, 1)
parametrized_circ.cx(2, 3)
parametrized_circ.cx(1, 2)
parametrized_circ.cx(3, 4)

parametrized_circ = qiskit.transpile(
    parametrized_circ, basis_gates=basis, optimization_level=1
)
parametrized_parameter_values = [[0.5, 0.1], [0.0, 0.6]]
parametrized_observables = [avg_magnetization, other_observable]

parametrized_job = qesem_function.run(
    pubs=[
        (
            parametrized_circ,
            parametrized_observables,
            parametrized_parameter_values,
            0.1,
        )
    ],
    backend_name=backend_name,
    options={
        "max_execution_time": 300,
        "transpilation_level": "minimal_with_layout_opt",
    },
)

print(parametrized_job.job_id)
print(parametrized_job.status())

Output:

d1b0e29b-196c-4896-aec6-44a268ebd874
DONE

parametrized_result = parametrized_job.result()

print("Parameterized circuit QESEM results:")

for pub_idx, pub_result in enumerate(parametrized_result):
    print(f"\nPUB {pub_idx}:")
    print(f"  Mitigated expectation values: {pub_result.data.evs}")
    print(f"  Mitigated error bars: {pub_result.data.stds}")
    noisy_results = pub_result.metadata["noisy_results"]
    print(f"  Unmitigated expectation values: {noisy_results.evs}")
    print(f"  Unmitigated error bars: {noisy_results.stds}")
    print("  Results for each parameter value:")
    for param_idx, param_results in enumerate(pub_result.metadata["results"]):
        print(
            f"    Parameter set {param_idx}: {parametrized_parameter_values[param_idx]}"
        )
        for obs_idx, (obs_array, result_dict) in enumerate(param_results):
            print(f"      Observable {obs_idx}: {obs_array}")
            print(
                f"        QESEM mitigated value: {result_dict['qesem']['value']} ± {result_dict['qesem']['error_bar']}"
            )
            print(
                f"        Unmitigated value: {result_dict['unmitigated']['value']} ± {result_dict['unmitigated']['error_bar']}"
            )

Output:

Parameterized circuit QESEM results:

PUB 0:
  Mitigated expectation values: [0.92392021 0.82517653]
  Mitigated error bars: [0.00565281 0.00616016]
  Unmitigated expectation values: [0.9028     0.78771429]
  Unmitigated error bars: [0.00335142 0.00925413]
  Results for each parameter value:
    Parameter set 0: [0.5, 0.1]
      Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
        QESEM mitigated value: 0.923920210615709 ± 0.005652811570890183
        Unmitigated value: 0.9028 ± 0.0033514176105045447
    Parameter set 1: [0.0, 0.6]
      Observable 0: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
        QESEM mitigated value: 0.8251765289285893 ± 0.006160161743353999
        Unmitigated value: 0.7877142857142858 ± 0.009254130564027902

Beispiel mit mehreren Pubs

Die Ausführung über mehrere Pubs ist nützlich, wenn Sie mehrere miteinander verbundene Schaltkreise in einem QESEM-Job ausführen möchten. Ähnlich wie bei der parametrisierten Ausführung lässt sich dadurch der Overhead reduzieren, da QESEM die Charakterisierung und Kalibrierung auf verschiedene Schaltungsinstanzen verteilen kann, anstatt sie in separaten Jobs zu wiederholen.

Dies ist besonders nützlich für Schaltkreise mit einer gemeinsamen Schichtstruktur, wie beispielsweise bei Workloads vom Typ Trotter, bei denen verschiedene Schaltkreise dieselben eindeutigen Schichten wiederverwenden. In diesem Fall lassen sich durch die gemeinsame Durchführung die Charakterisierungskosten im Vergleich zu einzelnen QESEM-Aufträgen senken.

"transpilation_level": "minimal_with_layout_opt"Für Aufträge, die mehrere Pubs betreffen, ist Folgendes erforderlich:. Wie im parametrisierten Beispiel sollten die Schaltungen vor der Übermittlung in die Basisgatter des Ziel-Backends transpiliert werden. QESEM übernimmt dann intern die Anbindung der Bausteine, das Layout und die Zuordnung zu hochpräzisen Qubits.

Jedes der unten aufgeführten „ PUB “ enthält eine Schaltung und dieselben beiden Observablen, die zuvor im Notebook verwendet wurden, sodass das zurückgegebene PrimitiveResult Ergebnis ein „“ PubResult pro Eingangsschaltung enthält.

Im folgenden Beispiel werden zwei einfache Trotter-Schaltungen mit demselben Schichtmuster verwendet: circ_a verfügt über eine Trotter-Schicht, und circ_b wiederholt dasselbe Schichtmuster zweimal. Dadurch wird die gemeinsame Struktur deutlich gemacht.

def make_trotter_circuit(num_qubits, num_layers, zz_angle=0.2, x_angle=0.1):
    trotter_circ = qiskit.QuantumCircuit(num_qubits)
    for _ in range(num_layers):
        for q in range(num_qubits):
            trotter_circ.rx(x_angle, q)
        trotter_circ.barrier()
        for q in range(0, num_qubits - 1, 2):
            trotter_circ.rzz(zz_angle, q, q + 1)
        trotter_circ.barrier()
        for q in range(1, num_qubits - 1, 2):
            trotter_circ.rzz(zz_angle, q, q + 1)
        trotter_circ.barrier()
    return trotter_circ


circ_a = make_trotter_circuit(num_qubits=5, num_layers=1)
circ_b = make_trotter_circuit(num_qubits=5, num_layers=2)

multi_pubs = [
    (
        qiskit.transpile(qci, basis_gates=basis, optimization_level=1),
        [avg_magnetization, other_observable],
    )
    for qci in [circ_a, circ_b]
]

multi_circ_job = qesem_function.run(
    pubs=multi_pubs,
    backend_name=backend_name,
    options={
        "max_execution_time": 300,
        "transpilation_level": "minimal_with_layout_opt",
        "default_precision": 0.1,
    },
)

print(multi_circ_job.job_id)
print(multi_circ_job.status())

Output:

e34565b8-7262-4133-a120-de42ce624a99
DONE

multi_circ_result = multi_circ_job.result()

print("Multi-pub QESEM results:")

for pub_idx, pub_result in enumerate(multi_circ_result):
    print(f"\nPUB {pub_idx}:")
    print(f"  Mitigated expectation values: {pub_result.data.evs}")
    print(f"  Mitigated error bars: {pub_result.data.stds}")
    noisy_results = pub_result.metadata["noisy_results"]
    print(f"  Unmitigated expectation values: {noisy_results.evs}")
    print(f"  Unmitigated error bars: {noisy_results.stds}")
    print("  Results for each observable:")
    for circ_idx, circ_results in enumerate(pub_result.metadata["results"]):
        print(f"    Circuit {circ_idx}:")
        for obs_idx, (obs_array, result_dict) in enumerate(circ_results):
            print(f"      Observable {obs_idx}: {obs_array}")
            print(
                f"        QESEM mitigated value: {result_dict['qesem']['value']} ± {result_dict['qesem']['error_bar']}"
            )
            print(
                f"        Unmitigated value: {result_dict['unmitigated']['value']} ± {result_dict['unmitigated']['error_bar']}"
            )

Output:

Multi-pub QESEM results:

PUB 0:
  Mitigated expectation values: [0.99502406 1.02209332]
  Mitigated error bars: [0.00483819 0.00707488]
  Unmitigated expectation values: [0.96934286 0.97271429]
  Unmitigated error bars: [0.00124855 0.00617294]
  Results for each observable:
    Circuit 0:
      Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
        QESEM mitigated value: 0.9950240647925642 ± 0.004838188086259301
        Unmitigated value: 0.9693428571428573 ± 0.0012485470362492692
      Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
        QESEM mitigated value: 1.0220933230604674 ± 0.007074884384355636
        Unmitigated value: 0.9727142857142859 ± 0.006172939375512439

PUB 1:
  Mitigated expectation values: [0.98850017 1.02555188]
  Mitigated error bars: [0.0077912  0.01672652]
  Unmitigated expectation values: [0.93682857 0.95371429]
  Unmitigated error bars: [0.00156245 0.00665735]
  Results for each observable:
    Circuit 0:
      Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
        QESEM mitigated value: 0.988500171577252 ± 0.007791203181151346
        Unmitigated value: 0.9368285714285716 ± 0.001562451883089579
      Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
        QESEM mitigated value: 1.02555188098689 ± 0.016726524388086233
        Unmitigated value: 0.9537142857142858 ± 0.006657345655544263

Beispiel für Quasi-probabilistische Fehlerkorrektur (QET)

Beim Quasi-probabilistischen Fehlerausgleich (QET) werden Erwartungswerte bei ausgewählten Rauschskalenfaktoren abgefragt. Dies ist nützlich für benutzerdefinierte Untersuchungen zur Rauschskalierung und für Arbeitsabläufe zur rauschfreien Extrapolation. „Scale“ 1.0 bezeichnet den physikalischen Geräuschpegel; Werte zwischen 0.0 und 1.0 reduzieren das Geräusch teilweise, während Werte über 1.0 das Geräusch verstärken.

Um QET mit der Qiskit-Funktion zu verwenden, übergeben Sie ein Wörterbuch als Präzision für „ PUB “. Das Wörterbuch ordnet jede abgefragte Rauschskala ihrer Zielgenauigkeit zu. Die zurückgegebenen Skalierungsfaktor-Ergebnisse werden in noise_scaling.results_with_REM gespeichert und berücksichtigen die Auslesekorrektur. Der Skalenwert 1.0 ist daher nicht mit dem unkorrigierten Wert identisch, da 1.0 die Auslesekorrektur berücksichtigt, während unmitigated dies nicht der Fall ist.

Wenn eine Skala angefordert wird, gibt QESEM auch die komplementäre Skala um 1.0 herum zurück, ohne dass dabei zusätzliche QPU-Ressourcen beansprucht werden. 0.7``1.5Beispielsweise kann die Abfrage 0.5 von auch zurückgeben, und die Abfrage von 1.3 kann ebenfalls zurückgeben. Die Genauigkeit der komplementären Skala kann nicht garantiert werden.

noise_scale_precision = {0.5: 0.15, 1.3: 0.2}

qet_job = qesem_function.run(
    pubs=[
        (
            circ,
            [avg_magnetization, other_observable],
            None,
            noise_scale_precision,
        )
    ],
    backend_name=backend_name,
    options={"max_execution_time": 300},
)

print(qet_job.job_id)
print(qet_job.status())

Output:

8195fa58-f037-4651-8715-36ce1cdc5521
DONE

qet_result = qet_job.result()

print("QET noise-scaling results:")

for pub_idx, pub_result in enumerate(qet_result):
    print(f"\nPUB {pub_idx}:")
    noisy_results = pub_result.metadata["noisy_results"]
    print(f"  Unmitigated expectation values: {noisy_results.evs}")
    print(f"  Unmitigated error bars: {noisy_results.stds}")
    print("  Results for each observable:")
    for circ_idx, circ_results in enumerate(pub_result.metadata["results"]):
        print(f"    Circuit {circ_idx}:")
        for obs_idx, (obs_array, result_dict) in enumerate(circ_results):
            print(f"      Observable {obs_idx}: {obs_array}")
            noise_scaling = result_dict["noise_scaling"]
            print(
                f"        Scaling method: {noise_scaling['scaling_method']}"
            )
            print("        Results with Readout mitigation (REM):")
            for rem_result in sorted(
                (
                    item
                    for item in noise_scaling["results_with_REM"]
                    if item["scale"] != 0.0
                ),
                key=lambda item: item["scale"],
            ):
                print(
                    f"          Scale factor {rem_result['scale']}: {rem_result['value']} ± {rem_result['error_bar']}"
                )

Output:

QET noise-scaling results:

PUB 0:
  Unmitigated expectation values: [0.97822857 0.96171429]
  Unmitigated error bars: [0.00123812 0.00672958]
  Results for each observable:
    Circuit 0:
      Observable 0: ObservablesArray({'IIIIZ': 0.2, 'IIIZI': 0.2, 'IIZII': 0.2, 'IZIII': 0.2, 'ZIIII': 0.2}, shape=())
        Scaling method: QESEM
        Results with Readout mitigation (REM):
          Scale factor 0.5: 0.9938730340199383 ± 0.0032116907357568275
          Scale factor 0.7: 0.9963976191853445 ± 0.00036300258869586616
          Scale factor 1.0: 0.9898115079506586 ± 0.0012525947426560995
          Scale factor 1.3: 0.9864667065580341 ± 0.002633221613518526
          Scale factor 1.5: 0.9838755527197551 ± 0.002948417797996015
      Observable 1: ObservablesArray({'IIIZZ': 1.0, 'ZIIXI': 0.5}, shape=())
        Scaling method: QESEM
        Results with Readout mitigation (REM):
          Scale factor 0.5: 1.0006538544450332 ± 0.002121742014777343
          Scale factor 0.7: 1.0004159801523036 ± 0.0021671375357823794
          Scale factor 1.0: 0.9898058846339917 ± 0.00690183710903159
          Scale factor 1.3: 0.9948946719997267 ± 0.002146532859610311
          Scale factor 1.5: 0.9927220368192772 ± 0.0020875057190323882

Fehlermeldungen abrufen

Wenn der Status Ihres Workloads „ERROR“ lautet, rufen job.result() Sie die Fehlermeldung wie folgt ab:

# Get the result and truncate for readability
result = sample_job.result()
result_str = str(result)
max_length = 500  # Adjust this value as necessary

if len(result_str) > max_length:
    truncated = (
        result_str[:max_length]
        + f"... (truncated {len(result_str) - max_length} characters)"
    )
else:
    truncated = result_str

print(truncated)

Output:

PrimitiveResult([PubResult(data=DataBin(evs=np.ndarray(<shape=(2,), dtype=float64>), stds=np.ndarray(<shape=(2,), dtype=float64>), shape=(2,)), metadata={'gate_fidelities': {'CZ': 0.9979444718552628, 'ID1Q': 0.9991994239814883}, 'total_shots': 498600, 'mitigation_shots': 223400, 'transpiled_circs': [{'circuit': 'OPENQASM 3.0;\ninclude "stdgates.inc";\nbit[76] c0;\nqubit[76] q0;\nrx(0) q0[54];\nrx(0) q0[59];\nrx(0) q0[75];\nrz(pi/2) q0[54];\nrz(pi/2) q0[59];\nrz(pi/2) q0[75];\nrx(pi/2) q0[54];\nr... (truncated 3771 characters)

Unterstützung anfordern

Das Qedma-Supportteam ist für Sie da! Wenn Sie Probleme oder Fragen zur Verwendung der QESEM Qiskit-Funktion haben, zögern Sie bitte nicht, uns zu kontaktieren. Unsere sachkundigen und freundlichen Support-Mitarbeiter sind bereit, Ihnen bei allen technischen Fragen und Problemen zu helfen.

Sie können uns per E-Mail unter [email protected] um Hilfe bitten. Bitte beschreiben Sie Ihr Problem so genau wie möglich, damit wir Ihnen schnell und präzise antworten können. Sie können sich auch per E-Mail oder Telefon an Ihren zuständigen Qedma POC-Vertreter wenden.

Damit wir Ihnen besser helfen können, bitten wir Sie, die folgenden Informationen anzugeben, wenn Sie uns kontaktieren:

• Eine detaillierte Beschreibung des Problems
• Die Job-ID.
• Alle relevanten Fehlermeldungen oder Codes

Wir sind bestrebt, Ihnen prompte und effektive Unterstützung zu bieten, um sicherzustellen, dass Sie die bestmögliche Erfahrung mit unserer Qiskit-Funktion machen.

Wir sind stets bemüht, unser Produkt zu verbessern, und freuen uns über Ihre Vorschläge! Wenn Sie Ideen haben, wie wir unsere Dienstleistungen verbessern können, oder Funktionen wünschen, senden Sie uns bitte Ihre Vorschläge an [email protected].

Nächste Schritte