Amazon Braket supported devices - Amazon Braket

Amazon Braket supported devices

In Amazon Braket, a device represents a QPU or simulator that you can call to run quantum tasks. That is, a device refers to a set of circuits for gate-based quantum computing, or it refers to an annealing problem for a quantum annealer device.

Amazon Braket provides access to four QPU devices—​from D-Wave, IonQ, and Rigetti—​and three simulator devices. For all devices, you can find further device properties, such as device topology, calibration data, and native gate sets in the Amazon Braket console in the Devices tab or by means of the GetDevice API.

If you are working with the Amazon Braket SDK, you have access to device properties as shown in the following code example:

from import AwsDevice from braket.devices import LocalSimulator device = AwsDevice('arn:aws:braket:::device/quantum-simulator/amazon/sv1') #SV1 # device = LocalSimulator() #Local Simulator # device = AwsDevice('arn:aws:braket:::device/quantum-simulator/amazon/tn1') #TN1 # device = AwsDevice('arn:aws:braket:::device/qpu/d-wave/DW_2000Q_6') #D-Wave 2000Q # device = AwsDevice('arn:aws:braket:::device/qpu/d-wave/Advantage_system1') #D-Wave Advantage_system # device = AwsDevice('arn:aws:braket:::device/qpu/ionq/ionQdevice') #IonQ # device = AwsDevice('arn:aws:braket:::device/qpu/rigetti/Aspen-8') #Aspen-8 # get device properties

Supported QPUs:

  • IonQ

  • Rigetti Aspen-8

  • D-Wave 2000Q

  • D-Wave Advantage_system

Supported Simulators:

  • Local simulator ('Default Simulator')

  • State vector simulator (SV1)

  • Tensor network simulator (TN1)


To view the available AWS Regions for each device, you can scroll the following table horizontally toward the right.

Amazon Braket devices
Provider Device Name Paradigm Type Device ARN Region



quantum annealer






quantum annealer




















N/A (local simulator in Braket SDK)







All Regions where Amazon Braket is available.






us-west-2 and us-east-1

To view additional details about the QPUs you can use with Amazon Braket, see Amazon Braket Hardware Providers.


IonQ offers a gate-based QPU based on ion trap technology. IonQ’s trapped ion QPUs are built on a chain of trapped 171Yb+ ions, spatially confined by means of a microfabricated surface electrode trap within a vacuum chamber.

Quantum gates supported by the IonQ device:

'x', 'y', 'z', 'rx', 'ry', 'rz', 'h', 'cnot', 's', 'si', 't', 'ti', 'v', 'vi', 'xx', 'yy', 'zz', 'swap', 'i'


Rigetti quantum processors are universal, gate-model machines based on all-tunable superconducting qubits. The Rigetti Aspen-8 system is based on scalable 32-qubit node technology.

Quantum gates supported by the Aspen-8 device:

'cz', 'xy', 'ccnot', 'cnot', 'cphaseshift', 'cphaseshift00', 'cphaseshift01', 'cphaseshift10', 'cswap', 'h', 'i', 'iswap', 'phaseshift', 'pswap', 'rx', 'ry', 'rz', 's', 'si', 'swap', 't', 'ti', 'x', 'y', 'z'


D-Wave offers quantum annealers based on superconducting qubits. Quantum annealing processors naturally return low-energy solutions. This type of QPU is a specific-purpose machine, designed and best suited to solve problems belonging to the class of Quadratic Unconstrained Optimization (QUBO) problems, such as optimization problems and probabilistic sampling problems.

Quantum annealers do not have to meet the strict engineering requirements that universal gate-based machines have to meet. Already today this technology features approximately 5000 superconducting qubits, compared to less than 100 qubits on gate-model quantum computers. Amazon Braket offers access to the superconducting quantum annealers provided by D-Wave Systems that can be programmed using the high-level, open source tool suite called Ocean.

For more information, see the quantum annealing example notebooks.

Local simulator

The local simulator ("DefaultSimulator") is part of the Amazon Braket SDK that runs locally in your environment. It is well-suited for rapid prototyping on small circuits, up to 25 qubits, depending on the hardware specifications of your Braket notebook instance or your local environment.

Simulators support all gates in the Amazon Braket SDK, but QPU devices support a smaller subset. You can find the supported gates of a device in the device properties.

For more information about how to work with simulators, see the Amazon Braket examples.

State vector simulator (SV1)

SV1 is a fully-managed, high-performance, universal state vector simulator. It can simulate circuits of up to 34 qubits. You can expect a 34-qubit, dense, and square circuit (circuit depth = 34) to take approximately 1 to 2 hours to complete, depending on the type of gates used and other factors. Circuits with all-to-all gates are well suited for SV1. It returns results in forms such as a full state vector or an array of amplitudes.

SV1 has a maximum runtime of 6 hours. It has a default of 35 concurrent tasks, and a maximum of 50 concurrent tasks.

SV1 Results

SV1 can provide the following results, given the specified number of shots:

  • Sample: Shots > 0

  • Expectation: Shots >= 0

  • Variance: Shots >= 0

  • Probability: Shots > 0

  • Amplitude: Shots = 0

For more about results, see Result types.

SV1 is always available, it executes your circuits on demand, and it can run multiple circuits in parallel. To learn more, visit Compare simulators.

Simulators support all gates in the Braket SDK, but QPU devices support a smaller subset. You can find the supported gates of a device in the device properties.

Tensor network simulator (TN1)

TN1 is a fully-managed, high-performance, tensor network simulator. TN1 can simulate certain circuit types with up to 50 qubits, and a circuit depth of 100 or smaller. TN1 is particularly powerful for sparse circuits, circuits with local gates, and other circuits with special structure — for example, quantum Fourier transform (QFT) circuits. TN1 operates in two phases. First, the rehearsal phase attempts to identify an efficient computational path for your circuit, so TN1 can estimate the runtime of the next stage, which is called the contraction phase. If the estimated contraction time exceeds the TN1 simulation runtime limit, TN1 does not attempt contraction.

TN1 has a runtime limit of 6 hours. It is limited to a maximum of 10 concurrent tasks.

TN1 Results

The contraction phase consists of a series of matrix multiplications. The series of multiplications continues, until a result is reached, or until it is determined that a result cannot be reached.

Note: Shots must be > 0 for the TN1 simulator.

Result types include:

  • Sample

  • Expectation

  • Variance

For more about results, see Result types.

TN1 is always available, it executes your circuits on demand, and it can run multiple circuits in parallel. To learn more, visit Compare simulators.

Simulators support all gates in the Braket SDK, but QPU devices support a smaller subset. You can find the supported gates of a device in the device properties.

Visit the Amazon Braket GitHub repository for a TN1 example notebook to help you get started with TN1.

Best practices for working with the TN1 simulator

  • Avoid all-to-all circuits.

  • Test a new circuit or class of circuits with a small number of shots, to learn the circuit’s "hardness" for TN1.

  • Split large shot simulations over multiple tasks.

Compare simulators

This section helps you select the Amazon Braket simulator that’s best suited for your task, by describing some concepts, limitations, and use cases.

What is a state vector simulator?

The Amazon Braket state vector simulator (SV1) is a universal state vector simulator. It stores the full wave function of the quantum state and sequentially applies gate operations to the state. It stores all possibilities, even the extremely unlikely ones. The SV1 simulator’s run time for a task increases linearly, with the number of gates in the circuit.

What is a tensor network simulator? 

The Amazon Braket tensor network simulator (TN1) encodes quantum circuits into a structured graph. 

  • The nodes of the graph consist of quantum gates, or qubits.

  • The edges of the graph represent connections between gates.

As a result of this structure, TN1 can find simulated solutions for relatively large and complex quantum circuits.

The TN1 simulator requires two phases

Typically, TN1 operates in a two-phase approach to simulating quantum computation.

  • The rehearsal phase: In this phase, TN1 comes up with a way to traverse the graph in an efficient manner, which involves visiting every node, so that you can obtain the measurement you desire. As a customer, you do not see this phase because TN1 performs both phases together for you. It completes the first phase and determines whether to perform the second phase, on its own, based on practical constraints. You have no input into that decision after the simulation has begun.

  • The contraction phase: This phase is analogous to the execution phase of a computation in a classical computer. The phase consists of a series of matrix multiplications. The order of these multiplications has a great effect on the difficulty of the computation. Therefore, the rehearsal phase is accomplished first, to find the most effective computation paths across the graph. After it finds the contraction path during the rehearsal phase, TN1 contracts together the gates of your circuit to produce the results of the simulation.

TN1 Concept: It’s like reading a map

Metaphorically, you can compare the underlying TN1 graph to the streets of a city. In a city with a planned grid, it is easy to find a route to your destination using a map. In a city with unplanned streets, duplicate street names, and so forth, it can be difficult to find a route to your destination by looking at a map.

If TN1 did not perform the rehearsal phase, it would be like walking around the streets of the city to find your destination,  instead of looking at a map first. It can really pay off in terms of walking time to spend more time looking at the map. Similarly, the rehearsal phase provides valuable information.

You might say that the TN1 has a certain “awareness” of the structure of the underlying circuit that it traverses. It gains this awareness during the rehearsal phase.

Types of problems best suited for each of these types of simulators

For SV1, any class of problems that rely primarily on having a certain number of qubits and gates is well-suited. The number of qubits and gates matters most. Generally, the time required grows linearly with the number of gates, and it does not depend on the number of shots. SV1 is generally faster than TN1 for circuits under 28 qubits.

The SV1 simulator can be slower for higher qubit numbers, because it actually simulates all possibilities, even the extremely unlikely ones. It has no way to determine which outcomes are likely. Thus, for a 30-qubit evaluation, SV1 must calculate 2^30 configurations. The limit of 34 qubits for the Amazon Braket SV1 simulator is a practical constraint due to memory and storage limitations. You can think of it like this: Each time you add a qubit to the SV1 simulator, the problem becomes twice as hard.

For many classes of problems, the TN1 simulator can evaluate much larger circuits in realistic time than the SV1 simulator, because TN1 takes advantage of the structure of the graph. It essentially tracks the evolution of solutions from its starting place, and it retains only the configurations that contribute to an efficient traversal; that is, it saves the configurations to create an ordering of matrix multiplication that results in a simpler evaluation process.

For TN1, the number of qubits and gates matters, but the structure of the graph matters a lot more. For example, TN1 is very good at evaluating circuits (graphs) in which the gates are short-range (that is, each qubit is connected by gates only to its nearest neighbour qubits), and circuits (graphs) in which the connections (or gates) have similar range, for example, if each qubit talks only to other qubits that are 5 qubits away. If most of the structure can be decomposed into simpler relationships such as these, which can be represented in more, smaller, or more uniform matrices, TN1 performs the evaluation easily.

Limitations of the TN1 simulator

The TN1 simulator can be slower than the SV1 simulator, depending on the graph’s structural complexity. For certain graphs, TN1 terminates the simulation after the rehearsal stage, and shows a status of FAILED, for either of these two reasons:

  • Cannot find a path — If the graph is too complex, it is too difficult to find a good traversal path, and you can give up on the computation, practically speaking. TN1 cannot perform the contraction. You may see an error message similar to this one: No viable contraction path found.

  • Contraction stage is too difficult — In some graphs, TN1 can find a traversal path, but it is very long, and extremely time-consuming to evaluate. In this case, the contraction is so expensive that the cost would be prohibitive. Instead, TN1 exits after the rehearsal phase. You may see an error message similar to this one: Predicted runtime based on best contraction path found exceeds TN1 limit.

Note: You are billed for the rehearsal stage of TN1 even if contraction is not performed and you see a FAILED status.

The predicted runtime also depends on the shot count. In worst-case scenarios, TN1 contraction time depends linearly on the shot count. The circuit may be contractable with fewer shots. For example, you might submit a task with 100 shots, which TN1 decides is uncontractable, but if you resubmit with only 10, the contraction proceeds. In this situation, to attain 100 samples, you could submit 10 tasks of 10 shots for the same circuit, combining the results in the end.

As a best practice, we recommend that you always test your circuit or circuit class with a few shots (for example, 10) to find out how hard your circuit is for TN1, before you proceed with a higher number of shots.

A note for the curious: The series of multiplications that forms the contraction phase begins with small, NxN matrices. For example, a 2-qubit gate requires a 4x4 matrix. The intermediate matrices required during a contraction that is adjudged to be too difficult are gigantic. Such a computation would require days to complete. That’s why Amazon Braket does not attempt extremely complex contractions.


  • The SV1 simulator can perform a default of 35 tasks concurrently, and a maximum of 50 tasks concurrently.

  • The TN1 simulator can perform a default (and a maximum number) of 10 tasks concurrently.

More information is available on the Quotas page.

Example notebooks

Amazon Braket provides a variety of example notebooks showing the types of circuits that can either work well for, or challenge, the TN1 and SV1 simulators, such as the quantum Fourier transformation (QFT).