Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # Schaltkreise im SDK konstruieren Dieser Abschnitt enthält Beispiele für das Definieren eines Schaltkreises, das Anzeigen verfügbarer Gatter, das Erweitern eines Schaltkreises und das Anzeigen von Gates, die jedes Gerät unterstützt. Er enthält auch Anweisungen zur manuellen Zuweisung, zur Anweisung an den Compilerqubits, Ihre Schaltungen exakt wie definiert auszuführen, und zur Erstellung von verrauschten Schaltungen mit einem Geräuschsimulator. Sie können in Braket auch auf Pulsebene für verschiedene Gatter mit bestimmten Werten arbeiten. QPUs Weitere Informationen finden Sie unter [Pulse Control auf Amazon Braket](braket-pulse-control.md). **Topics** + [Tore und Stromkreise](#braket-gates) + [Programmsätze](#braket-program-set) + [Teilweise Messung](#braket-partial-measurement) + [Manuelle Zuweisung qubit](#manual-qubit-allocation) + [Wörtliche Zusammenstellung](#verbatim-compilation) + [Simulation von Geräuschen](#noise-simulation) ## Tore und Stromkreise Quantengatter und -schaltungen sind in der [https://github.com/aws/amazon-braket-sdk-python/blob/main/src/braket/circuits/circuit.py](https://github.com/aws/amazon-braket-sdk-python/blob/main/src/braket/circuits/circuit.py)Klasse des Amazon Braket Python SDK definiert. Über das SDK können Sie ein neues Circuit-Objekt instanziieren, indem Sie es aufrufen. `Circuit()` **Beispiel: Definieren Sie einen Schaltkreis** Das Beispiel beginnt mit der Definition eines Beispielschaltkreises mit vier qubits (mit,, und beschriftet`q3`) `q0` `q1``q2`, der aus standardmäßigen Single-Qubit-Hadamard-Gattern und Zwei-Qubit-CNOT-Gattern besteht. Sie können diesen Schaltkreis visualisieren, indem Sie die Funktion aufrufen, wie das folgende Beispiel zeigt. `print` ``` # Import the circuit module from braket.circuits import Circuit # Define circuit with 4 qubits my_circuit = Circuit().h(range(4)).cnot(control=0, target=2).cnot(control=1, target=3) print(my_circuit) ``` ``` T : │ 0 │ 1 │ ┌───┐ q0 : ─┤ H ├───●───────── └───┘ │ ┌───┐ │ q1 : ─┤ H ├───┼─────●─── └───┘ │ │ ┌───┐ ┌─┴─┐ │ q2 : ─┤ H ├─┤ X ├───┼─── └───┘ └───┘ │ ┌───┐ ┌─┴─┐ q3 : ─┤ H ├───────┤ X ├─ └───┘ └───┘ T : │ 0 │ 1 │ ``` **Beispiel: Definieren Sie einen parametrisierten Schaltkreis** In diesem Beispiel definieren wir einen Schaltkreis mit Gattern, die von freien Parametern abhängen. Wir können die Werte dieser Parameter angeben, um eine neue Schaltung zu erstellen oder, wenn wir die Schaltung einreichen, sie als Quantenaufgabe auf bestimmten Geräten laufen zu lassen. ``` from braket.circuits import Circuit, FreeParameter # Define a FreeParameter to represent the angle of a gate alpha = FreeParameter("alpha") # Define a circuit with three qubits my_circuit = Circuit().h(range(3)).cnot(control=0, target=2).rx(0, alpha).rx(1, alpha) print(my_circuit) ``` Sie können aus einem parametrisierten Schaltkreis einen neuen, nicht parametrisierten Schaltkreis erstellen, indem Sie entweder einzelne Argumente `float` (das ist der Wert, den alle freien Parameter annehmen) oder Schlüsselwortargumente angeben, die den Wert jedes Parameters für den Schaltkreis wie folgt angeben. ``` my_fixed_circuit = my_circuit(1.2) my_fixed_circuit = my_circuit(alpha=1.2) print(my_fixed_circuit) ``` Beachten Sie, dass er unverändert `my_circuit` ist, sodass Sie ihn verwenden können, um viele neue Schaltungen mit festen Parameterwerten zu instanziieren. **Beispiel: Ändern Sie Gates in einem Schaltkreis** Das folgende Beispiel definiert einen Schaltkreis mit Gattern, die Steuerungs- und Leistungsmodifikatoren verwenden. Sie können diese Änderungen verwenden, um neue Tore zu erstellen, z. B. das gesteuerte `Ry` Tor. ``` from braket.circuits import Circuit # Create a bell circuit with a controlled x gate my_circuit = Circuit().h(0).x(control=0, target=1) # Add a multi-controlled Ry gate of angle .13 my_circuit.ry(angle=.13, target=2, control=(0, 1)) # Add a 1/5 root of X gate my_circuit.x(0, power=1/5) print(my_circuit) ``` Tormodifikatoren werden nur im lokalen Simulator unterstützt. **Beispiel: Alle verfügbaren Gates anzeigen** Das folgende Beispiel zeigt, wie Sie sich alle verfügbaren Gates in Amazon Braket ansehen können. ``` from braket.circuits import Gate # Print all available gates in Amazon Braket gate_set = [attr for attr in dir(Gate) if attr[0].isupper()] print(gate_set) ``` Die Ausgabe dieses Codes listet alle Gates auf. ``` ['CCNot', 'CNot', 'CPhaseShift', 'CPhaseShift00', 'CPhaseShift01', 'CPhaseShift10', 'CSwap', 'CV', 'CY', 'CZ', 'ECR', 'GPhase', 'GPi', 'GPi2', 'H', 'I', 'ISwap', 'MS', 'PRx', 'PSwap', 'PhaseShift', 'PulseGate', 'Rx', 'Ry', 'Rz', 'S', 'Si', 'Swap', 'T', 'Ti', 'U', 'Unitary', 'V', 'Vi', 'X', 'XX', 'XY', 'Y', 'YY', 'Z', 'ZZ'] ``` Jedes dieser Gatter kann an einen Schaltkreis angehängt werden, indem die Methode für diesen Schaltungstyp aufgerufen wird. Rufen Sie beispielsweise auf`circ.h(0)`, um dem ersten ein Hadamard-Gate hinzuzufügen. qubit **Anmerkung** Gatter werden an der richtigen Stelle angefügt, und im folgenden Beispiel werden alle im vorherigen Beispiel aufgelisteten Gatter demselben Schaltkreis hinzugefügt. ``` circ = Circuit() # toffoli gate with q0, q1 the control qubits and q2 the target. circ.ccnot(0, 1, 2) # cnot gate circ.cnot(0, 1) # controlled-phase gate that phases the |11> state, cphaseshift(phi) = diag((1,1,1,exp(1j*phi))), where phi=0.15 in the examples below circ.cphaseshift(0, 1, 0.15) # controlled-phase gate that phases the |00> state, cphaseshift00(phi) = diag([exp(1j*phi),1,1,1]) circ.cphaseshift00(0, 1, 0.15) # controlled-phase gate that phases the |01> state, cphaseshift01(phi) = diag([1,exp(1j*phi),1,1]) circ.cphaseshift01(0, 1, 0.15) # controlled-phase gate that phases the |10> state, cphaseshift10(phi) = diag([1,1,exp(1j*phi),1]) circ.cphaseshift10(0, 1, 0.15) # controlled swap gate circ.cswap(0, 1, 2) # swap gate circ.swap(0,1) # phaseshift(phi)= diag([1,exp(1j*phi)]) circ.phaseshift(0,0.15) # controlled Y gate circ.cy(0, 1) # controlled phase gate circ.cz(0, 1) # Echoed cross-resonance gate applied to q0, q1 circ = Circuit().ecr(0,1) # X rotation with angle 0.15 circ.rx(0, 0.15) # Y rotation with angle 0.15 circ.ry(0, 0.15) # Z rotation with angle 0.15 circ.rz(0, 0.15) # Hadamard gates applied to q0, q1, q2 circ.h(range(3)) # identity gates applied to q0, q1, q2 circ.i([0, 1, 2]) # iswap gate, iswap = [[1,0,0,0],[0,0,1j,0],[0,1j,0,0],[0,0,0,1]] circ.iswap(0, 1) # pswap gate, PSWAP(phi) = [[1,0,0,0],[0,0,exp(1j*phi),0],[0,exp(1j*phi),0,0],[0,0,0,1]] circ.pswap(0, 1, 0.15) # X gate applied to q1, q2 circ.x([1, 2]) # Y gate applied to q1, q2 circ.y([1, 2]) # Z gate applied to q1, q2 circ.z([1, 2]) # S gate applied to q0, q1, q2 circ.s([0, 1, 2]) # conjugate transpose of S gate applied to q0, q1 circ.si([0, 1]) # T gate applied to q0, q1 circ.t([0, 1]) # conjugate transpose of T gate applied to q0, q1 circ.ti([0, 1]) # square root of not gate applied to q0, q1, q2 circ.v([0, 1, 2]) # conjugate transpose of square root of not gate applied to q0, q1, q2 circ.vi([0, 1, 2]) # exp(-iXX theta/2) circ.xx(0, 1, 0.15) # exp(i(XX+YY) theta/4), where theta=0.15 in the examples below circ.xy(0, 1, 0.15) # exp(-iYY theta/2) circ.yy(0, 1, 0.15) # exp(-iZZ theta/2) circ.zz(0, 1, 0.15) # IonQ native gate GPi with angle 0.15 applied to q0 circ.gpi(0, 0.15) # IonQ native gate GPi2 with angle 0.15 applied to q0 circ.gpi2(0, 0.15) # IonQ native gate MS with angles 0.15, 0.15, 0.15 applied to q0, q1 circ.ms(0, 1, 0.15, 0.15, 0.15) ``` Neben dem vordefinierten Gattersatz können Sie dem Schaltkreis auch selbstdefinierte einheitliche Gatter zuweisen. Dabei kann es sich um Single-Qubit-Gates (wie im folgenden Quellcode gezeigt) oder um Multi-Qubit-Gates handeln, die auf die durch den Parameter definierten Gates angewendet werden. qubits `targets` ``` import numpy as np # Apply a general unitary my_unitary = np.array([[0, 1],[1, 0]]) circ.unitary(matrix=my_unitary, targets=[0]) ``` **Beispiel: Erweitern Sie bestehende Schaltungen** Sie können bestehende Schaltungen erweitern, indem Sie Anweisungen hinzufügen. An `Instruction` ist eine Quantenrichtlinie, die die Quantenaufgabe beschreibt, die auf einem Quantengerät ausgeführt werden muss. `Instruction`Operatoren schließen `Gate` nur Objekte des Typs ein. ``` # Import the Gate and Instruction modules from braket.circuits import Gate, Instruction # Add instructions directly. circ = Circuit([Instruction(Gate.H(), 4), Instruction(Gate.CNot(), [4, 5])]) # Or with add_instruction/add functions instr = Instruction(Gate.CNot(), [0, 1]) circ.add_instruction(instr) circ.add(instr) # Specify where the circuit is appended circ.add_instruction(instr, target=[3, 4]) circ.add_instruction(instr, target_mapping={0: 3, 1: 4}) # Print the instructions print(circ.instructions) # If there are multiple instructions, you can print them in a for loop for instr in circ.instructions: print(instr) # Instructions can be copied new_instr = instr.copy() # Appoint the instruction to target new_instr = instr.copy(target=[5, 6]) new_instr = instr.copy(target_mapping={0: 5, 1: 6}) ``` **Beispiel: Sehen Sie sich die Gates an, die jedes Gerät unterstützt** Simulatoren unterstützen alle Gates im Braket-SDK, aber QPU-Geräte unterstützen eine kleinere Teilmenge. Sie finden die unterstützten Gates eines Geräts in den Geräteeigenschaften. Das Folgende zeigt ein Beispiel mit einem IonQ-Gerät: ``` # Import the device module from braket.aws import AwsDevice device = AwsDevice("arn:aws:braket:us-east-1::device/qpu/ionq/Aria-1") # Get device name device_name = device.name # Show supportedQuantumOperations (supported gates for a device) device_operations = device.properties.dict()['action']['braket.ir.openqasm.program']['supportedOperations'] print('Quantum Gates supported by {}:\n {}'.format(device_name, device_operations)) ``` ``` Quantum Gates supported by Aria 1: ['x', 'y', 'z', 'h', 's', 'si', 't', 'ti', 'v', 'vi', 'rx', 'ry', 'rz', 'cnot', 'swap', 'xx', 'yy', 'zz'] ``` Unterstützte Gates müssen möglicherweise zu nativen Gates kompiliert werden, bevor sie auf Quantenhardware laufen können. Wenn Sie eine Schaltung einreichen, führt Amazon Braket diese Kompilierung automatisch durch. **Beispiel: Rufen Sie programmgesteuert die Genauigkeit systemeigener Gates ab, die von einem Gerät unterstützt werden** Sie können die Genauigkeitsinformationen auf der **Geräteseite** der Braket-Konsole einsehen. Manchmal ist es hilfreich, programmgesteuert auf dieselben Informationen zuzugreifen. Der folgende Code zeigt, wie die qubit Zwei-Gate-Treue zwischen zwei Gates einer QPU extrahiert wird. ``` # Import the device module from braket.aws import AwsDevice device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3") # Specify the qubits a=10 b=11 edge_properties_entry = device.properties.standardized.twoQubitProperties['10-11'].twoQubitGateFidelity gate_name = edge_properties_entry[0].gateName fidelity = edge_properties_entry[0].fidelity print(f"Fidelity of the {gate_name} gate between qubits {a} and {b}: {fidelity}") ``` ## Programmsätze Programmsätze steuern effizient mehrere Quantenschaltkreise in einer einzigen Quantenaufgabe. In dieser einen Aufgabe können Sie bis zu 100 Quantenschaltungen oder einen einzelnen parametrischen Schaltkreis mit bis zu 100 verschiedenen Parametersätzen einreichen. Dieser Vorgang minimiert die Zeit zwischen aufeinanderfolgenden Schaltungsausführungen und reduziert den Verarbeitungsaufwand für Quantenaufgaben. Derzeit werden Programmpakete auf Amazon Braket Local Simulator und anderen AQT Rigetti Geräten unterstützt. IQM **Definition eines ProgramSet** Das folgende erste Codebeispiel zeigt, wie Sie eine erstellen, `ProgramSet` indem Sie sowohl parametrisierte Schaltungen als auch Schaltungen ohne Parameter verwenden. ``` from braket.aws import AwsDevice from braket.circuits import Circuit, FreeParameter from braket.program_sets.circuit_binding import CircuitBinding from braket.program_sets import ProgramSet # Initialize the quantum device device = AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet") # Define circuits circ1 = Circuit().h(0).cnot(0, 1) circ2 = Circuit().rx(0, 0.785).ry(1, 0.393).cnot(1, 0) circ3 = Circuit().t(0).t(1).cz(0, 1).s(0).cz(1, 2).s(1).s(2) parameterize_circuit = Circuit().rx(0, FreeParameter("alpha")).cnot(0, 1).ry(1, FreeParameter("beta")) # Create circuit bindings with different parameters circuit_binding = CircuitBinding( circuit=parameterize_circuit, input_sets={ 'alpha': (0.10, 0.11, 0.22, 0.34, 0.45), 'beta': (1.01, 1.01, 1.03, 1.04, 1.04), }) # Creating the program set program_set_1 = ProgramSet([ circ1, circ2, circ3, circuit_binding, ]) ``` Dieses Programmset enthält vier einzigartige Programme:`circ1`, `circ2``circ3`, und. `circuit_binding` Das `circuit_binding` Programm wird mit fünf verschiedenen Parameterbindungen ausgeführt, wodurch fünf ausführbare Dateien erstellt werden. Die anderen drei parameterfreien Programme erstellen jeweils eine ausführbare Datei. Dies führt zu insgesamt acht ausführbaren Dateien, wie in der folgenden Abbildung dargestellt. ![ProgramSet Struktur mit vier Schaltkreisen, wobei c4 CircuitBinding für die Verarbeitung fünf Eingabesätze verwendet.](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/program_set1.png) Das folgende zweite Codebeispiel zeigt, wie die `product()` Methode verwendet wird, um denselben Satz von Observablen an jede ausführbare Datei der Programmgruppe anzuhängen. ``` from braket.circuits.observables import I, X, Y, Z observables = [Z(0) @ Z(1), X(0) @ X(1), Z(0) @ X(1), X(0) @ Z(1)] program_set_2 = ProgramSet.product( circuits=[circ1, circ2, circuit_binding], observables=observables ) ``` Bei Programmen ohne Parameter wird jedes Observable für jeden Schaltkreis gemessen. Bei parametrischen Programmen wird jedes Observable für jeden Eingangssatz gemessen, wie in der folgenden Abbildung dargestellt. ![ProgramSet.produkt, das die parallel Ausführung von drei Schaltungen zeigt, wobei CircuitBinding c3 fünf Eingabesätze mit jeweils fünf Observablen verarbeitet.](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/program_set2.png) Das folgende dritte Codebeispiel zeigt, wie die `zip()` Methode verwendet wird, um einzelne Observablen mit bestimmten Parametersätzen in der zu verbinden. `ProgramSet` ``` program_set_3 = ProgramSet.zip( circuits=circuit_binding, observables=observables + [Y(0) @ Y(1)] ) ``` ![ProgramSet.zip mit der CircuitBinding Demonstration von fünf parallel Ausführungen unter Verwendung einer gemeinsamen Schaltung mit individuellen Observables pro Eingabesatz.](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/program_set3.png) Stattdessen können Sie direkt eine Liste von `CircuitBinding()` Observablen mit einer Liste von Schaltungen und Eingabesätzen komprimieren. ``` program_set_4 = ProgramSet.zip( circuits=[circ1, circ2, circ3], input_sets=[{}, {}, {}], observables=observables[:3] ) ``` ![ProgramSet.zip zeigt die parallel Ausführung von sieben Schaltungen mit ihren entsprechenden individuellen Eingabesätzen und einzelnen Observablen.](http://docs.aws.amazon.com/de_de/braket/latest/developerguide/images/program_set4.png) Weitere Informationen und Beispiele zu Programmgruppen finden Sie im [Ordner Program Set](https://github.com/amazon-braket/amazon-braket-examples/tree/main/examples/braket_features/program_sets) auf Github. amazon-braket-examples **Untersuchen Sie ein Programmset auf einem Gerät und führen Sie es aus** Die Anzahl der ausführbaren Dateien eines Programmsatzes entspricht der Anzahl der eindeutigen parametergebundenen Schaltungen. Berechnen Sie die Gesamtzahl der ausführbaren Dateien und Shots von Schaltkreisen anhand des folgenden Codebeispiels. ``` # Number of shots per executable shots = 10 num_executables = program_set_1.total_executables # Calculate total number of shots across all executables total_num_shots = shots*num_executables ``` **Anmerkung** Bei Programmsätzen zahlen Sie eine einzige Gebühr pro Aufgabe und eine Gebühr pro Schuss, die auf der Gesamtzahl der Aufnahmen aller Schaltungen in einem Programmsatz basiert. Verwenden Sie das folgende Codebeispiel, um den Programmsatz auszuführen. ``` # Run the program set task = device.run( program_set_1, shots=total_num_shots, ) ``` Wenn Sie Rigetti Geräte verwenden, kann es sein, dass Ihre Programmgruppe den `RUNNING` Status beibehält, während Aufgaben teilweise abgeschlossen und teilweise in die Warteschlange gestellt werden. Um schnellere Ergebnisse zu erzielen, sollten Sie erwägen, Ihr Programmset als [Hybrid-Job](braket-jobs-first.md) einzureichen. **Analysieren der Ergebnisse** Führen Sie den folgenden Code aus, um die Ergebnisse der ausführbaren Dateien in a zu analysieren und zu messen. `ProgramSet` ``` # Get the results from a program set result = task.result() # Get the first executbable first_program = result[0] first_executable = first_program[0] # Inspect the results of the first executable measurements_from_first_executable = first_executable.measurements print(measurements_from_first_executable) ``` ## Teilweise Messung Anstatt alle Qubits in einem Quantenschaltkreis zu messen, verwenden Sie Teilmessungen, um einzelne Qubits oder eine Teilmenge von Qubits zu messen. **Anmerkung** Zusätzliche Funktionen wie Messungen in der Mitte des Schaltkreises und Feed-Forward-Operationen sind als experimentelle Funktionen verfügbar. Weitere Informationen finden Sie unter [Zugriff auf](braket-experimental-capabilities.md#braket-access-dynamic-circuits) dynamische Schaltungen auf IQM-Geräten. **Beispiel: Messen Sie eine Teilmenge von Qubits** Das folgende Codebeispiel zeigt eine Teilmessung, bei der nur Qubit 0 in einem Bell-State-Stromkreis gemessen wird. ``` from braket.devices import LocalSimulator from braket.circuits import Circuit # Use the local state vector simulator device = LocalSimulator() # Define an example bell circuit and measure qubit 0 circuit = Circuit().h(0).cnot(0, 1).measure(0) # Run the circuit task = device.run(circuit, shots=10) # Get the results result = task.result() # Print the circuit and measured qubits print(circuit) print() print("Measured qubits: ", result.measured_qubits) ``` ## Manuelle Zuweisung qubit Wenn Sie einen Quantenschaltkreis auf Quantencomputern von aus ausführenRigetti, können Sie optional die manuelle qubit Zuordnung verwenden, um zu steuern, welche für Ihren Algorithmus verwendet qubits werden. Die [Amazon Braket-Konsole](https://console.aws.amazon.com/braket/home) und das [Amazon Braket-SDK](https://github.com/aws/amazon-braket-sdk-python) helfen Ihnen dabei, die neuesten Kalibrierungsdaten Ihres ausgewählten QPU-Geräts (Quantum Processing Unit) zu überprüfen, sodass Sie das Beste qubits für Ihr Experiment auswählen können. Durch die manuelle qubit Zuordnung können Sie Schaltungen mit höherer Genauigkeit ausführen und einzelne Eigenschaften untersuchen. qubit Forscher und fortgeschrittene Anwender optimieren ihr Schaltungsdesign auf der Grundlage der neuesten Gerätekalibrierungsdaten und können genauere Ergebnisse erzielen. Das folgende Beispiel zeigt, wie eine qubits explizite Zuordnung vorgenommen wird. ``` # Import the device module from braket.aws import AwsDevice device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3") circ = Circuit().h(0).cnot(0, 7) # Indices of actual qubits in the QPU # Set up S3 bucket (where results are stored) my_bucket = "amazon-braket-s3-demo-bucket" # The name of the bucket my_prefix = "your-folder-name" # The name of the folder in the bucket s3_location = (my_bucket, my_prefix) my_task = device.run(circ, s3_location, shots=100, disable_qubit_rewiring=True) ``` Weitere Informationen finden Sie in [den Amazon Braket-Beispielen auf GitHub](https://github.com/aws/amazon-braket-examples) oder genauer gesagt in diesem Notizbuch: [Zuweisen von Qubits auf](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Allocating_Qubits_on_QPU_Devices.ipynb) QPU-Geräten. ## Wörtliche Zusammenstellung Wenn Sie eine Quantenschaltung auf Gate-basierten Quantencomputern ausführen, können Sie den Compiler anweisen, Ihre Schaltungen ohne Änderungen exakt so auszuführen, wie sie definiert sind. Mithilfe der wörtlichen Kompilierung können Sie entweder festlegen, dass ein ganzer Schaltkreis exakt wie spezifiziert erhalten bleibt oder dass nur bestimmte Teile davon erhalten bleiben (nur unterstützt von). Rigetti Bei der Entwicklung von Algorithmen für Hardware-Benchmarking- oder Fehlerminimierungsprotokolle müssen Sie die Möglichkeit haben, die Gates und Schaltkreislayouts, die auf der Hardware ausgeführt werden, genau zu spezifizieren. Die wörtliche Kompilierung gibt Ihnen direkte Kontrolle über den Kompilierungsprozess, indem Sie bestimmte Optimierungsschritte ausschalten und so sicherstellen, dass Ihre Schaltungen genau so laufen, wie sie entworfen wurden. Die Verbatim-Kompilierung wird auf den Rigetti GerätenAQT, IonQIQM, und unterstützt und erfordert die Verwendung systemeigener Gatter. Bei der wörtlichen Kompilierung empfiehlt es sich, die Topologie des Geräts zu überprüfen, um sicherzustellen, dass die Gates aufgerufen qubits und verbunden sind und dass die Schaltung die systemeigenen Gatter verwendet, die von der Hardware unterstützt werden. Das folgende Beispiel zeigt, wie Sie programmgesteuert auf die Liste der systemeigenen Gates zugreifen können, die von einem Gerät unterstützt werden. ``` device.properties.paradigm.nativeGateSet ``` Denn die Rigetti qubit Neuverkabelung muss durch die Einstellung `disableQubitRewiring=True` für die Verwendung mit wörtlicher Kompilierung ausgeschaltet werden. Wenn diese `disableQubitRewiring=False` Option gesetzt ist, wenn in einer Kompilierung wörtliche Boxen verwendet werden, schlägt der Quantenschaltkreis bei der Validierung fehl und kann nicht ausgeführt werden. Wenn die wörtliche Kompilierung für eine Schaltung aktiviert ist und auf einer QPU ausgeführt wird, die sie nicht unterstützt, wird ein Fehler generiert, der darauf hinweist, dass ein nicht unterstützter Vorgang zum Fehlschlagen der Aufgabe geführt hat. Da immer mehr Quantenhardware Compilerfunktionen nativ unterstützt, wird diese Funktion um diese Geräte erweitert. Geräte, die die wörtliche Kompilierung unterstützen, schließen sie als unterstützten Vorgang ein, wenn sie mit dem folgenden Code abgefragt werden. ``` from braket.aws import AwsDevice from braket.device_schema.device_action_properties import DeviceActionType device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3") device.properties.action[DeviceActionType.OPENQASM].supportedPragmas ``` Mit der verbatim-Kompilierung sind keine zusätzlichen Kosten verbunden. Ihnen werden weiterhin Quantenaufgaben, die auf Braket QPU-Geräten, Notebook-Instances und On-Demand-Simulatoren ausgeführt werden, auf der Grundlage der aktuellen Tarife berechnet, die auf der Seite mit den [Amazon Braket-Preisen](https://aws.amazon.com/braket/pricing/) angegeben sind. Weitere Informationen finden Sie im Beispiel-Notizbuch zur [Verbatim-Kompilierung](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Verbatim_Compilation.ipynb). **Anmerkung** Wenn Sie OpenQASM verwenden, um Ihre Schaltungen für die AQT IonQ AND-Geräte zu schreiben, und Sie Ihre Schaltung direkt den physikalischen Qubits zuordnen möchten, müssen Sie das verwenden, `#pragma braket verbatim` da das `disableQubitRewiring` Flag von OpenQASM ignoriert wird. ## Simulation von Geräuschen Um den lokalen Geräuschsimulator zu instanziieren, können Sie das Backend wie folgt ändern. ``` # Import the device module from braket.aws import AwsDevice device = LocalSimulator(backend="braket_dm") ``` Sie können geräuschbehaftete Schaltungen auf zwei Arten aufbauen: 1. Baue den lauten Stromkreis von unten nach oben auf. 1. Nehmen Sie einen vorhandenen, rauschfreien Stromkreis und fügen Sie überall Rauschen ein. Das folgende Beispiel zeigt die Ansätze, bei denen ein einfacher Schaltkreis mit depolarisierendem Rauschen und ein benutzerdefinierter Kraus-Kanal verwendet werden. ``` import scipy.stats import numpy as np # Bottom up approach # Apply depolarizing noise to qubit 0 with probability of 0.1 circ = Circuit().x(0).x(1).depolarizing(0, probability=0.1) # Create an arbitrary 2-qubit Kraus channel E0 = scipy.stats.unitary_group.rvs(4) * np.sqrt(0.8) E1 = scipy.stats.unitary_group.rvs(4) * np.sqrt(0.2) K = [E0, E1] # Apply a two-qubit Kraus channel to qubits 0 and 2 circ = circ.kraus([0, 2], K) ``` ``` from braket.circuits import Noise # Inject noise approach # Define phase damping noise noise = Noise.PhaseDamping(gamma=0.1) # The noise channel is applied to all the X gates in the circuit circ = Circuit().x(0).y(1).cnot(0, 2).x(1).z(2) circ_noise = circ.copy() circ_noise.apply_gate_noise(noise, target_gates=Gate.X) ``` Das Ausführen einer Schaltung bietet dieselbe Benutzererfahrung wie zuvor, wie in den folgenden beiden Beispielen gezeigt. **Beispiel 1** ``` task = device.run(circ, shots=100) ``` Oder **Beispiel 2** ``` task = device.run(circ_noise, shots=100) ``` Weitere Beispiele finden Sie [im einführenden Beispiel für einen Geräuschsimulator in Braket](https://github.com/aws/amazon-braket-examples/blob/main/examples/braket_features/Simulating_Noise_On_Amazon_Braket.ipynb)