From c6eae3cb51867d1de4da62b7a9ed5bc7a0d17fce Mon Sep 17 00:00:00 2001 From: Yaroslav Kharkov Date: Thu, 6 Jun 2024 17:13:24 -0400 Subject: [PATCH 1/7] Add cheat sheet for GenAI applications --- doc/genai_cheat_sheet.md | 490 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 490 insertions(+) create mode 100644 doc/genai_cheat_sheet.md diff --git a/doc/genai_cheat_sheet.md b/doc/genai_cheat_sheet.md new file mode 100644 index 000000000..ae0092dab --- /dev/null +++ b/doc/genai_cheat_sheet.md @@ -0,0 +1,490 @@ +# Braket CheatSheet + + + +**Circuits** + +***Import Braket modules:*** +``` +from braket.circuits import Circuit, Gate, Instruction +from braket.circuits.observables import X, Y, Z +from braket.circuits.gates import Rx, Ry, Rz, CNot, Unitary, CCNot +from braket.circuits.instruction import Instruction +``` + +***Create an empty circuit (default constructor):*** + +`circuit = Circuit()` + +***Create an circuit with arbitrary number of qubits. Note that number of qubits is not passed as an argument to the circuit constructor:*** + +`circuit = Circuit()` + +***Add X gate to circuit at qubit 0:*** + +`circuit.x(0)` + +***Add Rx gate to qubit 1 with a float angle 1.234 angle = 1.234:*** + +`circuit.rx(1, angle)` + +***Add cnot gate to pair of qubits:*** + +`circuit.cnot(0, 1)` + +***Add gates sequentially: X gate, Rx gate, cnot gate:*** + +`circuit.x(0).rx(1, 1.23).cnot(0, 1)` + +***Get the list of available gates:*** + +`[attr for attr in dir(Gate) if attr[0].isupper()]` + +***Create a single qubit gate from unitary matrix:*** + +``` +matrix = np.eye(2) +G = Unitary(matrix) +``` + +***Get the circuit unitary:*** +`circuit.to_unitary()` + +***Add a probability result type to qubit 0 (will return exact probabilities, corresponds to shots=0 case when running on a simulator):*** + +`circuit.probability(0)` + +***Add probability result type to all qubits. Add probability result type only when measuring exact probabilities:*** + +``` +for i in range(len(circuit.qubits)): + circuit.probability(i) +``` + +***Show all result types attached to the circuit:*** + +`print(circuit._result_types)` + +Get circuit depth: + +`circuit.depth` + +Attach Expectation result type to measure both qubits [0, 1] in X basis. +The expectation method allows to pass an arbitrary tensor product of Pauli operators applied to each qubit, e.g. X() @ Y() @ Z(): + +``` +circuit.expectation(X() @ X(), target=[0, 1]); +circuit.expectation(X() @ Y() @ Z(), target=[0, 1, 2]); +``` + +List of the available result types +adjoint_gradient, amplitude, density_matrix, expectation, probability, sample, state_vector, variance: + +`print(circuit._result_types)` + +Append a circuit (new_circuit) to a given circuit: + +`circuit.add_circuit(new_circuit)` + +Wrap a new_circuit to a verbatim box and append to a circuit: + +`circuit.add_verbatim_box(new_circuit)` + +Wrap a circuit to a verbatim box (will be executed without as is without modifications): + +`Circuit().add_verbatim_box(circuit)` + +Gate modifiers (conditional gates with control and target qubits). +Gate modifiers allow to specify a fractional power applied to a gate: + +`circuit.x(0, control=[1, 2], control_state=[0, 1], power=-0.5)` + +Print a circuit: + +`print(circuit)` + +Create circuit from OpenQASM3 string: + +`Circuit.from_ir(source=qasm_str)` + +Export to OpenQASM3: + +`Circuit.to_ir("OPENQASM")` + +Create an instruction from a gate: + +`inst = Instruction(Gate.CPhaseShift(1.23), target=[0, 1])` + +Add an instruction to the circuit: + +`circuit.add(inst)` + +Sample random pairs of indexes (i, j) to generate random circuit: +``` +(control, target) = random.sample(range(num_qubits), 2) +instruction = Instruction(CNot(), target=[target], control=[control]) +circuit.add(instruction) +``` + +**FreeParameters (parametric gates)** + +Imports + +`from braket.circuits import FreeParameter` + +Create a FreeParameter (symbolic parameter): + +`alpha = FreeParameter(“alpha”)` + +Use FreeParameters: + +`circuit.rx(0, alpha+1)` + +Bind a FreeParameter to a specific value: + +`circuit.make_bound_circuit({“alpha”: 0.1})` + +Get the list of unbound FreeParameters: + +`circuit.parameters` + +Run circuit on a device with parametric compilation enabled. + +`device.run(circuit, inputs={“alpha”: 0.1})` + +**Tasks** + +Imports: + +`from braket.aws import AwsSession, AwsQuantumTask` + +Create a quantum task by executing a circuit on a device: + +`task = device.run(circuit)` + +Disable qubit rewiring (forces trivial mapping between logical and physical qubits on QPU): + +`device.run(circuit, disable_qubit_rewiring=True)` + +Instantiate an AwsSession: +`session = AwsSession(...)` + +Re-create a previously created quantum task from ARN: +`task = AwsQuantumTask(arn[, aws_session])` + +Task Queue position: +`task.queue_position()` + +Quantum Task batching: + +``` +n_batch = 5 # define circuit batch size +circuits = [circuit for _ in range(n_batch)] # Create a list of circuits in the batch +batch = device.run_batch(circuits, s3_folder, shots=100) # Submit batch of circuits +print(batch.results()[0].measurement_counts) # The result of the first quantum task in the batch +``` + +Attach tag to a Quantum Task: + +``` +task = device.run( + circuit, + shots=100, + tags={"MyTag": "MyValue"} +) +``` + +**Quantum Task attributes:** + +Cancel task: `task.cancel()` +Task metadata: `task.metadata()` +Task state (CREATED, COMPLETED, CANCELED, FAILED): `task.state()` +Task position in the queue: `task.queue_position()` +Get Task result dicitonary: `task.result()` + +**Results** + +Retrieve task results: + +`result = task.result()` + +Get measurement counts: + +`result.measurement_counts` + +Get measurement probabilities (for Probability Result Type): + +`result.measurement_probabilities` + +Get measured qubits: + +`result.measured_qubits` + +Get compiled circuit: + +`result.get_compiled_circuit()` + +**Device** + +Imports + +``` +from braket.aws import AwsDevice +from braket.devices import Devices +``` + +Instantiate a device: + +`AwsDevice("")` + +Device alias (use in place of string ARN): + +`Devices.Rigetti.AspenM3` + +QuantumTask Queue depth: + +`device.queue_depth()` + +Gate pulse implementation: + +`device.gate_calibrations` + +SV1 Simulator ARN: + +“arn:aws:braket:::device/quantum-simulator/amazon/sv1” + +TN1 Simulator ARN (Tensor Network simulator): + +“arn:aws:braket:::device/quantum-simulator/amazon/tn1” + +DM1 Simulator ARN (density matrix simulator): + +“arn:aws:braket:::device/quantum-simulator/amazon/dm1” + +Rydberg atom devices Aquila (AHS device from QuEra): + +“arn:aws:braket:us-east-1::device/qpu/quera/Aquila” + +Rigetti Aspen M3 device "arn:aws:braket:us-west-1::device/qpu/rigetti/Aspen-M-3" + +IQM Garnet device (20 qubits): + +"arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet" + +**Device Properties** + +Connectivity graph +device.properties.paradigm.connectivity + +Fidelities dictionary: +`device.properties.provider.specs` + +Native gate set: + +`device.properties.paradigm.nativeGateSet` + +Cost and availability: + +`device.properties.service` + +Pulse properties: +`device.properties.pulse` + +Actions properties: +`action_properties = device.properties.action['braket.ir.openqasm.program']` + +Supported gates: + +`action_properties.supportedOperations` + +Get 2Q gate fidelitis for a qubit pair (i, j): + +`device.properties.dict()["provider"]["specs"]["2Q"][f"{i}-{j}"]` + + +**Pricing** + +Imports: +`from braket.tracking import Tracker` + +Start the cost tracker: +`tracker=Tracker().start()` + +Print costs: +``` +tracker.qpu_tasks_cost() +tracker.simulator_tasks_cost() +``` + +Cost summary: + +`tracker.quantum_tasks_statistics()` + + + +**Hybrid Jobs** + +Imports +`from braket.aws import AwsQuantumJob` + +Create a job +``` +job = AwsQuantumJob.create(arn, source_module="algorithm_script.py", entry_point="algorithm_script:start_here", wait_until_complete=True) +``` + +AwsQuantumJob Queue position: + +`job.queue_position()` + +Job decorator (local mode): + +`@hybrid_job(device=None, local=True)` + +Records Braket Hybrid Job metrics (will be displayed on Hybrid Jobbs concole metrics log): + +`log_metric(metric_name=metric_name, value=value, iteration_number=iteration_number)` + + +**Simulator** + +Imports +from braket.devices import LocalSimulator + +Instantiate the local simulator +local_sim = LocalSimulator() + +**Noise Simulation** + +Imports: + +`from braket.circuits import Noise` + +Apply Depolarizing noise: + +`circuit.depolarizing(0, 0.1)` + +Apply a Kraus operator: + +`circuit.kraus([0,2], [E0, E1])` + +Phase dampling channel: + +`noise = Noise.PhaseDamping(0.1)` + +Apply a noise channel to an individual X gate + +`circuit.apply_gate_noise(noise, Gate.X)` + + + +**Low-Level Device Control** + +Imports +``` +from braket.pulse import PulseSequence, Frame +from braket.pulse.waveforms import * +``` + +Create a new pulse sequence: + +`pulse_sequence = PulseSequence()` + +Predefined ports: + +`device.ports` + +Predefined frames: + +`device.frames` + +Create a frame: + +`Frame(port, frequency[, phase])` + +Predefined waveforms: + +``` +ConstantWaveform(length, iq) +GaussianWaveform(length, width, amplitude, zero_at_edges) +DragGaussianWaveform(length, width, amplitude, beta, zero_at_edges) +``` + +Play a waveform: + +`pulse_sequence.play(frame, waveform)` + +Add a delay: + +`pulse_sequence.delay(frame, delay)` + +Set frequency: + +`pulse_sequence.set_frequency(frame, frequency)` + +Shift frequency: + +`pulse_sequence.shift_frequency(frame, detuning)` + +`Set phase:` +pulse_sequence.set_phase(frame, phase) + +`Shift phase:` + +pulse_sequence.shift_phase(frame, phi) + +Get the time series: + +`pulse_sequence.to_time_traces()` + + +**Analog Hamiltonian Simulation** + +Imports: +`from braket.ahs import AtomArrangement, DrivingField, AnalogHamiltonianSimulation` + +Atom arrangement: + +`register = AtomArrangement()` + +Add an atom with (x, y) coordinates (in meters): + +`register.add((5.7e-6, 5.7e-6))` + +Add atoms in square lattice with lattice spacing a + +``` +a = 5e-6 +for i in range(nx): + for j in range(ny): + register.add((i*a, j*a)) +``` + +Get atom coordinates along x-axis: + +`register.coordinate_list(0)` + +Get atom coordinates along y-axis: + +`register.coordinate_list(1)` + +Create a driving field: + +`DrivingField(amplitude, phase, detuning)` + +Create an AHS program: + +`ahs_program = AnalogHamiltonianSimulation(register, drive)` + +Run an AHS program: + +`device.run(ahs_program)` + +**Error Mitigation** + +Debias: + +`device.run(circuit, shots=2500, device_parameters={"errorMitigation": Debias()})` + +Sharpening (if debiasing used): + +`result.additional_metadata.ionqMetadata.sharpenedProbabilities` \ No newline at end of file From 384ab55348d083a61f7ba9c2f4bd0087924d3ff9 Mon Sep 17 00:00:00 2001 From: Yaroslav Kharkov Date: Sat, 8 Jun 2024 15:10:06 -0400 Subject: [PATCH 2/7] Update cheat sheet --- doc/genai_cheat_sheet.md | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/doc/genai_cheat_sheet.md b/doc/genai_cheat_sheet.md index ae0092dab..fa7e9ae24 100644 --- a/doc/genai_cheat_sheet.md +++ b/doc/genai_cheat_sheet.md @@ -4,7 +4,7 @@ **Circuits** -***Import Braket modules:*** +Import Braket modules: ``` from braket.circuits import Circuit, Gate, Instruction from braket.circuits.observables import X, Y, Z @@ -12,56 +12,57 @@ from braket.circuits.gates import Rx, Ry, Rz, CNot, Unitary, CCNot from braket.circuits.instruction import Instruction ``` -***Create an empty circuit (default constructor):*** +Create an empty circuit (default constructor): `circuit = Circuit()` -***Create an circuit with arbitrary number of qubits. Note that number of qubits is not passed as an argument to the circuit constructor:*** +Create an circuit with arbitrary number of qubits. Note that number of qubits is not passed as an argument to the circuit constructor: `circuit = Circuit()` -***Add X gate to circuit at qubit 0:*** +Add X gate to circuit at qubit 0: `circuit.x(0)` -***Add Rx gate to qubit 1 with a float angle 1.234 angle = 1.234:*** +Add Rx gate to qubit 1 with a float angle 1.234 angle = 1.234: `circuit.rx(1, angle)` -***Add cnot gate to pair of qubits:*** +Add cnot gate to pair of qubits: `circuit.cnot(0, 1)` -***Add gates sequentially: X gate, Rx gate, cnot gate:*** +Add gates sequentially: X gate, Rx gate, cnot gate: `circuit.x(0).rx(1, 1.23).cnot(0, 1)` -***Get the list of available gates:*** +Get the list of available gates: `[attr for attr in dir(Gate) if attr[0].isupper()]` -***Create a single qubit gate from unitary matrix:*** +Create a single qubit gate from unitary matrix: ``` matrix = np.eye(2) G = Unitary(matrix) ``` -***Get the circuit unitary:*** +Get the circuit unitary: + `circuit.to_unitary()` -***Add a probability result type to qubit 0 (will return exact probabilities, corresponds to shots=0 case when running on a simulator):*** +Add a probability result type to qubit 0 (will return exact probabilities, corresponds to shots=0 case when running on a simulator): `circuit.probability(0)` -***Add probability result type to all qubits. Add probability result type only when measuring exact probabilities:*** +Add probability result type to all qubits. Add probability result type only when measuring exact probabilities: ``` for i in range(len(circuit.qubits)): circuit.probability(i) ``` -***Show all result types attached to the circuit:*** +Show all result types attached to the circuit: `print(circuit._result_types)` @@ -180,7 +181,7 @@ Quantum Task batching: ``` n_batch = 5 # define circuit batch size circuits = [circuit for _ in range(n_batch)] # Create a list of circuits in the batch -batch = device.run_batch(circuits, s3_folder, shots=100) # Submit batch of circuits +batch = device.run_batch(circuits, s3_folder, shots=100) # Submit batch of circuits with 100 shots print(batch.results()[0].measurement_counts) # The result of the first quantum task in the batch ``` @@ -483,7 +484,7 @@ Run an AHS program: Debias: -`device.run(circuit, shots=2500, device_parameters={"errorMitigation": Debias()})` +`device.run(circuit, shots=1000, device_parameters={"errorMitigation": Debias()})` Sharpening (if debiasing used): From 3ec22ac56ef3d03ac07235c916512f66fc761454 Mon Sep 17 00:00:00 2001 From: Yaroslav Kharkov Date: Sat, 8 Jun 2024 15:26:40 -0400 Subject: [PATCH 3/7] Update cheat sheet --- doc/genai_cheat_sheet.md | 35 ++++++++++++++++++----------------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/doc/genai_cheat_sheet.md b/doc/genai_cheat_sheet.md index fa7e9ae24..969fc505c 100644 --- a/doc/genai_cheat_sheet.md +++ b/doc/genai_cheat_sheet.md @@ -252,30 +252,32 @@ Gate pulse implementation: SV1 Simulator ARN: -“arn:aws:braket:::device/quantum-simulator/amazon/sv1” +`“arn:aws:braket:::device/quantum-simulator/amazon/sv1”` TN1 Simulator ARN (Tensor Network simulator): -“arn:aws:braket:::device/quantum-simulator/amazon/tn1” +`“arn:aws:braket:::device/quantum-simulator/amazon/tn1”` DM1 Simulator ARN (density matrix simulator): -“arn:aws:braket:::device/quantum-simulator/amazon/dm1” +`“arn:aws:braket:::device/quantum-simulator/amazon/dm1”` Rydberg atom devices Aquila (AHS device from QuEra): -“arn:aws:braket:us-east-1::device/qpu/quera/Aquila” +`“arn:aws:braket:us-east-1::device/qpu/quera/Aquila”` -Rigetti Aspen M3 device "arn:aws:braket:us-west-1::device/qpu/rigetti/Aspen-M-3" +Rigetti Aspen M3 device: +`"arn:aws:braket:us-west-1::device/qpu/rigetti/Aspen-M-3"` IQM Garnet device (20 qubits): -"arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet" +`"arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet"` **Device Properties** -Connectivity graph -device.properties.paradigm.connectivity +Connectivity graph: + +`device.properties.paradigm.connectivity` Fidelities dictionary: `device.properties.provider.specs` @@ -348,11 +350,13 @@ Records Braket Hybrid Job metrics (will be displayed on Hybrid Jobbs concole met **Simulator** -Imports -from braket.devices import LocalSimulator +Imports: + +`from braket.devices import LocalSimulator` + +Instantiate the local simulator : -Instantiate the local simulator -local_sim = LocalSimulator() +`local_sim = LocalSimulator()` **Noise Simulation** @@ -380,7 +384,8 @@ Apply a noise channel to an individual X gate **Low-Level Device Control** -Imports +Imports: + ``` from braket.pulse import PulseSequence, Frame from braket.pulse.waveforms import * @@ -485,7 +490,3 @@ Run an AHS program: Debias: `device.run(circuit, shots=1000, device_parameters={"errorMitigation": Debias()})` - -Sharpening (if debiasing used): - -`result.additional_metadata.ionqMetadata.sharpenedProbabilities` \ No newline at end of file From f0c47551db6ac2e19219de2de8a3f0e4d8111696 Mon Sep 17 00:00:00 2001 From: Yaroslav Kharkov Date: Tue, 11 Jun 2024 10:13:48 -0400 Subject: [PATCH 4/7] Prompt engineering: genai cheat sheet --- doc/genai_cheat_sheet.md | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/doc/genai_cheat_sheet.md b/doc/genai_cheat_sheet.md index 969fc505c..555b86723 100644 --- a/doc/genai_cheat_sheet.md +++ b/doc/genai_cheat_sheet.md @@ -1,6 +1,10 @@ # Braket CheatSheet - +Installing Amazon Braket SDK: +`pip install amazon-braket-sdk` + +To import modules from braket: +`from braket import ...` **Circuits** @@ -20,6 +24,9 @@ Create an circuit with arbitrary number of qubits. Note that number of qubits is `circuit = Circuit()` +Please DO NOT pass number of qubits to the `Circuit()` constructor. + + Add X gate to circuit at qubit 0: `circuit.x(0)` @@ -203,6 +210,13 @@ Task state (CREATED, COMPLETED, CANCELED, FAILED): `task.state()` Task position in the queue: `task.queue_position()` Get Task result dicitonary: `task.result()` +**QAOA circuits** + +Decomposition of the ZZ gate (cost Hamiltonian) to Cnot: +`ZZ(alpha, [i, j]) -> Cnot(i, j) Rz(alpha) Cnot(i, j)` + +The QAOA circuit consits of alternating layers of single qubit RX rotations (mixer term) and two-qubit ZZ gates (cost term). + **Results** Retrieve task results: From 728ec21d70b788f5424782e4b1f8de12fe734907 Mon Sep 17 00:00:00 2001 From: Yaroslav Kharkov Date: Wed, 19 Jun 2024 13:38:44 -0400 Subject: [PATCH 5/7] Update gen_ai cheat sheet --- doc/genai_cheat_sheet.md | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/doc/genai_cheat_sheet.md b/doc/genai_cheat_sheet.md index 555b86723..724185301 100644 --- a/doc/genai_cheat_sheet.md +++ b/doc/genai_cheat_sheet.md @@ -134,6 +134,21 @@ instruction = Instruction(CNot(), target=[target], control=[control]) circuit.add(instruction) ``` + +Create a random circuit: + +``` +from braket.experimental.auxiliary_functions import random_circuit + +# Code here +local_simulator = LocalSimulator() +gate_set = [CNot, Rx, Rz, CPhaseShift, XY] +circuit = random_circuit(num_qubits=5, + num_gates=30, + gate_set=gate_set, + seed=42) +``` + **FreeParameters (parametric gates)** Imports @@ -283,7 +298,7 @@ Rydberg atom devices Aquila (AHS device from QuEra): Rigetti Aspen M3 device: `"arn:aws:braket:us-west-1::device/qpu/rigetti/Aspen-M-3"` -IQM Garnet device (20 qubits): +IQM Garnet device (20 qubits, superconducting QPU): `"arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet"` From a43a52f05136ac8849866b03e74cb041f3134085 Mon Sep 17 00:00:00 2001 From: Yaroslav Kharkov Date: Wed, 26 Jun 2024 08:59:44 -0400 Subject: [PATCH 6/7] Update genai cheat sheet --- doc/genai_cheat_sheet.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/genai_cheat_sheet.md b/doc/genai_cheat_sheet.md index 724185301..b3c2d3c64 100644 --- a/doc/genai_cheat_sheet.md +++ b/doc/genai_cheat_sheet.md @@ -3,7 +3,7 @@ Installing Amazon Braket SDK: `pip install amazon-braket-sdk` -To import modules from braket: +To import modules from Braket: `from braket import ...` **Circuits** From 02b1440904090b7b83b0c0f375e8ef7966f9a02f Mon Sep 17 00:00:00 2001 From: Yaroslav Kharkov Date: Wed, 26 Jun 2024 10:17:57 -0400 Subject: [PATCH 7/7] Update genai cheat sheet --- doc/genai_cheat_sheet.md | 44 +++++++++++++++++++++++----------------- 1 file changed, 25 insertions(+), 19 deletions(-) diff --git a/doc/genai_cheat_sheet.md b/doc/genai_cheat_sheet.md index b3c2d3c64..025eb134a 100644 --- a/doc/genai_cheat_sheet.md +++ b/doc/genai_cheat_sheet.md @@ -31,13 +31,18 @@ Add X gate to circuit at qubit 0: `circuit.x(0)` +Add H (Hadamard) gate to circuit at qubit 0: + +`circuit.h(0)` + Add Rx gate to qubit 1 with a float angle 1.234 angle = 1.234: `circuit.rx(1, angle)` Add cnot gate to pair of qubits: -`circuit.cnot(0, 1)` +`circuit.cnot(0, 1)`. +DO NOT use `cx` gate for CNot operation, always use `cnot` gate instead. Add gates sequentially: X gate, Rx gate, cnot gate: @@ -127,18 +132,11 @@ Add an instruction to the circuit: `circuit.add(inst)` -Sample random pairs of indexes (i, j) to generate random circuit: -``` -(control, target) = random.sample(range(num_qubits), 2) -instruction = Instruction(CNot(), target=[target], control=[control]) -circuit.add(instruction) -``` - - Create a random circuit: ``` from braket.experimental.auxiliary_functions import random_circuit +from braket.circuits.gates import CNot, Rx, Rz, CPhaseShift, XY # Code here local_simulator = LocalSimulator() @@ -231,6 +229,7 @@ Decomposition of the ZZ gate (cost Hamiltonian) to Cnot: `ZZ(alpha, [i, j]) -> Cnot(i, j) Rz(alpha) Cnot(i, j)` The QAOA circuit consits of alternating layers of single qubit RX rotations (mixer term) and two-qubit ZZ gates (cost term). +The initial layer should rotate qubits to |+> state by applying H (Hadamard) gate to all qubits. **Results** @@ -259,11 +258,17 @@ Get compiled circuit: Imports ``` +from braket.devices import LocalSimulator from braket.aws import AwsDevice from braket.devices import Devices ``` -Instantiate a device: +Instantiate Local simulator: + +`local_sim = LocalSimulator()`. +Local simulator does not have ARN. + +Instantiate a device from ARN: `AwsDevice("")` @@ -279,28 +284,29 @@ Gate pulse implementation: `device.gate_calibrations` -SV1 Simulator ARN: +SV1 Simulator: -`“arn:aws:braket:::device/quantum-simulator/amazon/sv1”` +`AwsDevice(“arn:aws:braket:::device/quantum-simulator/amazon/sv1”)` -TN1 Simulator ARN (Tensor Network simulator): +TN1 Simulator (Tensor Network simulator): -`“arn:aws:braket:::device/quantum-simulator/amazon/tn1”` +`AwsDevice(“arn:aws:braket:::device/quantum-simulator/amazon/tn1”)` -DM1 Simulator ARN (density matrix simulator): +DM1 Simulator (density matrix simulator): -`“arn:aws:braket:::device/quantum-simulator/amazon/dm1”` +`AwsDevice(“arn:aws:braket:::device/quantum-simulator/amazon/dm1”)` Rydberg atom devices Aquila (AHS device from QuEra): -`“arn:aws:braket:us-east-1::device/qpu/quera/Aquila”` +`AwsDevice(“arn:aws:braket:us-east-1::device/qpu/quera/Aquila”)` Rigetti Aspen M3 device: -`"arn:aws:braket:us-west-1::device/qpu/rigetti/Aspen-M-3"` + +`AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Aspen-M-3")` IQM Garnet device (20 qubits, superconducting QPU): -`"arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet"` +`AwsDevice("arn:aws:braket:eu-north-1::device/qpu/iqm/Garnet")` **Device Properties**