QuEra

Aquila

Aquila is QuEra's 256-qubit neutral-atom quantum computer. It operates as an analog Hamiltonian simulator on a user-configurable architecture, executing programmable coherent quantum dynamics on up to 256 neutral-atom qubits.

Backend

Company	Processor	Qubits	Framework	Processors
QuEra	Aquila	256	Braket	braket.aquila, arn:aws:braket:us-east-1::device/qpu/quera/Aquila

Disclaimer: This list of backends is subject to change at any time.

Availability

Check the status through the Strangeworks Braket SDK. First make sure SDK is installed:

pip install -U pip && pip install strangeworks-braket

Then check the status of the device:

from strangeworks_braket import StrangeworksDevice
device = StrangeworksDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila")
if device.status == "ONLINE":
    solver = "braket.aquila"
else:
    raise Exception(
    """
    Device is not online, 
    visit https://www.quera.com/aquila for availability.
    """
    )

Day	Time
Monday	01:00:00 - 23:59:59 UTC
Tuesday	00:00:00 - 12:00:00 UTC
Wednesday	00:00:00 - 12:00:00 UTC
Friday	00:00:00 - 23:59:59 UTC
Saturday	00:00:00 - 23:59:59 UTC
Sunday	00:00:00 - 12:00:00 UTC

See QuEra for the most up-to-date availability

Analog Hamiltonian Simulation

Authenticate via the Strangeworks SDK with your api-key taken from the Portal homepage

Amazon Braket: Aquila

import strangeworks as sw
from strangeworks_braket import StrangeworksDevice
from braket.timings.time_series import TimeSeries
from braket.ahs.driving_field import DrivingField
import numpy as np
from strangeworks_braket.utils.ahs_utils import rabi_pulse, constant_time_series
from braket.ahs.atom_arrangement import AtomArrangement
from braket.ahs.hamiltonian import Hamiltonian
from braket.ahs.analog_hamiltonian_simulation import AnalogHamiltonianSimulation

sw.authenticate(api_key)

# Initialize Device
device = StrangeworksDevice("arn:aws:braket:us-east-1::device/qpu/quera/Aquila")

# Create Driving Parameters
rydberg = device.properties.paradigm.rydberg
omega_const = 1.5e7   # rad / s
rabi_pulse_area = np.pi/np.sqrt(3) # rad
omega_slew_rate_max = float(rydberg.rydbergGlobal.rabiFrequencySlewRateMax) # rad/s^2

time_points, amplitude_values = rabi_pulse(rabi_pulse_area, omega_const, 0.2 * omega_slew_rate_max)

amplitude = TimeSeries()
for t, v in zip(time_points, amplitude_values):
    amplitude.put(t, v)

detuning = constant_time_series(amplitude, 0.0) 
phase = constant_time_series(amplitude, 0.0) 

drive = DrivingField(
    amplitude=amplitude, 
    detuning=detuning, 
    phase=phase
)

# Create Register
separation = 5e-6
block_separation = 15e-6
k_max = 5
m_max = 5

register = AtomArrangement()
for k in range(k_max):
    for m in range(m_max):
        register.add((block_separation*m, block_separation*k + separation/np.sqrt(3)))
        register.add((block_separation*m-separation/2, block_separation*k - separation/(2*np.sqrt(3))))
        register.add((block_separation*m+separation/2, block_separation*k - separation/(2*np.sqrt(3))))   

# Combine to create Analogue Hamiltonian
ahs_program = AnalogHamiltonianSimulation(
    register=register, 
    hamiltonian=drive
)
discrete_program = ahs_program.discretize(device)

# Execute the circuit
print("\n🤖 Executing Circuit...\n")

n_shots = 100
task = device.run(discrete_program, n_shots)

# At this point, the job is running on the Strangeworks Platform.
# You can check the status of the job in the Portal.
print(f"⏳ Job {task.id} submitted!\n")

# Lots of good info in here
result = task.result()

🥳 Success! You may view your job in the portal.

😅 Something went wrong? Find us in Slack!

Optimization Backend

Aquila is also compatible with the Strangeworks Optimization Service, where it can be used to solve unit disk graph (UDG) problems.

A unit disk graph is a type of geometric graph where each vertex represents a disk of unit radius in a plane, and there is an edge between two vertices if and only if their corresponding disks intersect or overlap. This method of graph construction is often used in wireless networking to model the possible connections between nodes (such as transmitters or devices) with limited communication range.

Solver

Model	Backend
AquilaNDArray	braket.aquila

AquilaNDArray

First, you must convert the coordinates of each node in your graph into a NumPy array. The AquilaNDArray model is a representation of a graph in the form of a NumPy array. Each row in the array represents the possition of each node in the graph.

import numpy as np
from strangeworks_optimization_models.problem_models import AquilaNDArray

model = AquilaNDArray(np.array([[1, 2], [0, 0], [1, 0], [1, 1], [2, 0], [2, 1]]))

Unit Disk Graph

First make sure the Strangeworks Optimization SDK is installed:

pip install -U pip && pip install strangeworks-optimization

Then submit the job to the Optimization Service to solve the problem:

import strangeworks as sw
from strangeworks_optimization import StrangeworksOptimizer
from strangeworks_optimization_models.problem_models import AquilaNDArray
from strangeworks_optimization_models.parameter_models import AquilaParameterModel
import numpy as np

sw.authenticate(api_key)

model = AquilaNDArray(np.array([[1, 2], [0, 0], [1, 0], [1, 1], [2, 0], [2, 1]]))
options = AquilaParameterModel(unit_disk_radius=1.68, shots=1000)
solver = "braket.aquila"

so = StrangeworksOptimizer(
    model=model, 
    solver=solver, 
    options=options)
sw_job = so.run()

print(f"Job slug: {sw_job.slug}")

Then check the status and results of the job:

print(f"Job status: {so.status(sw_job.slug)}")

results = so.results(sw_job.slug)

Parameters

from strangeworks_optimization_models.parameter_models import AquilaParameterModel

options = AquilaParameterModel(.....)

Solvers

• braket.aquila

Parameter	Description	Default	Values
unit_disk_radius	Radius of interactions for specified graph	1.68	float
shots	Number of shots to run	1000	int