Recent tests have shown that the Q-CTRL cloud architecture allows complex optimization tasks to run ~9x faster than on a standalone machine, reducing compute time from nearly an hour to just a few minutes. Q-CTRL provides the performance you need and the convenience you deserve.

Quantum control is growing in importance as quantum computing systems become more complex, new error sources appear, and customers demand ever increasing performance from hardware.

Numerical optimization provides amazing capabilities when it comes to developing error-robust controls used to implement the logic in a quantum computer. For instance, we’ve previously demonstrated machine-learning-optimized operations validated to simultaneously suppress two kinds of error in an operation about five times shorter than comparable analytically defined protocols.

These were created and output directly from BLACK OPAL . BLACK OPAL is a hardware-agnostic software suite which works with every qubit to reduce decoherence and errors at the physical layer.

Q-CTRL provides a number of advanced numerical optimization tools in our BOULDER OPAL professional grade product. We favor robust control optimization - tolerant of small changes in the assumptions going into the numeric optimization, but also provide optimal control solutions which can efficiently be used to navigate a complex interacting system.

You access these techniques via the Python programming language, ensuring full integration with other numeric packages and even cloud-based hardware systems like IBM Q.

Of course, Python provides users with a lot of choice when it comes to available numerical packages. So in areas of overlap why should a customer use a Q-CTRL solution?

One answer is speed.

Q-CTRL has built our software packages with a focus on leveraging the most modern cloud compute infrastructure available for your benefit. And it shows.

What this means for our customers is enhanced performance in computationally complex tasks.

In a demanding optimization using Robust Control on two interacting superconducting qubits, we showed an average reduction in computational runtime of approximately nine times through use of our cloud compute engine vs a local Python installation.

This took a complex calculation to create an error-robust iSWAP gate down to an average of just four minutes, suitable for frequent automated optimization.

“At Q-CTRL, we’re always looking for ways to improve how we provide value to our customers. High performing, secure and reliable solutions are aspects we are constantly obsessing over,” said Lead Back-End Engineer Kevin Nguyen.

There’s no need to build or access local high-performance-computing infrastructure; we take care of it all for you. And if you need more computational capacity, we can provide access to customized back-end resources tailored exactly to your needs.

That’s something you just can’t get by running a local package on your desktop.

But wait, there’s more!

Q-CTRL also provides totally new capabilities in our numerical optimization routines that you won’t find elsewhere. Take for instance the ability to incorporate arbitrary linear-time-invariant filters into a control optimization, ensuring solutions will match the real constraints of your hardware, like bandwidth limits in transmission lines. Or the use of multi-dimensional filter functions which given an intuitive picture of how a control exhibits robustness to noise.

BOULDER OPAL is the most powerful and flexible tool for quantum control R&D. It’s perfect for professional researchers as well as engineers seeking streamlined implementation of control in their own hardware. Learn more about BOULDER OPAL or contact us for more details.

Run Number Q-CTRL Cloud Local Instance
  Time (min) Cost Time (min) Cost
1 4.35 0.0001075229722 43.42 0.00392226
2 4.5 0.0275341595271 40.87 0.00030144
3 4.65 0.0028625244451 42.28 0.0010311
4 4.68 0.00079048 35.8 0.00600469
5 4.63 0.00053189 43.7 0.00742207
6 4.78 0.00277739 43.55 0.00051428
7 4.75 0.0076129 36.98 0.03288244
8 4.57 0.00072786 33.7 0.02412227
9 4.62 0.0028191 33.68 0.00233133
10 4.57 0.01925559 33.75 0.01998404
Average Performance 4.61 0.00493074 38.77 0.00985159
import numpy as np
from qctrl import Qctrl

TOKEN = 'your_qctrl_token'
qctrl = Qctrl(TOKEN)

# Define standard matrices

identity = np.array([[1., 0.],[0., 1.]], dtype=np.complex)
sigma_z = np.array([[1., 0.],[0., -1.]], dtype=np.complex)
sigma_m = np.array([[0., 0.],[1., 0.]], dtype=np.complex)
iswap = np.array(
    [[1.,0.,0.,0.],
     [0.,0.,1j,0.],
     [0.,1j,0.,0.],
     [0.,0.,0.,1.]], dtype=np.complex)

# Define physical constants

nu_a = 1 * np.pi #MHz
nu_b = 0 * np.pi #MHz
omega_max = 5 * np.pi #MHz
lambda_max = 0.5 * np.pi #MHz
delta_max = 5 * np.pi #MHz
t = 4 #us
segments = 5

# Define controls

microwave_a = dict(
    type='drive',
    name='Microwave A',
    operator=np.kron(sigma_m,identity),
    upper_bound=omega_max,
    fixed_modulus=False)

microwave_b = dict(
    type='drive',
    name='Microwave B',
    operator=np.kron(identity,sigma_m),
    upper_bound=omega_max,
    fixed_modulus=False)

coupling = dict(
    type='drive',
    name='Coupling',
    operator=np.kron(sigma_m,sigma_m.T),
    upper_bound=omega_max,
    fixed_modulus=False)

clock_a = dict(
    type='shift',
    name='Clock A',
    operator=np.kron(sigma_z,identity),
    upper_bound=delta_max,
    fixed_modulus=False)

clock_b = dict(
    type='shift',
    name='Clock B',
    operator=np.kron(identity,sigma_z),
    upper_bound=delta_max,
    fixed_modulus=False)

fixed_frequencies = dict(
    type='drift',
    name='Fixed Frequencies',
    operator=nu_a*np.kron(sigma_z,identity) + nu_b*np.kron(sigma_z,identity))

controls = [microwave_a,microwave_b,coupling,clock_a,clock_b,fixed_frequencies,]

# Define noises

dephasing_a = dict(
    type='additive',
    name='Dephasing',
    operator=np.kron(sigma_z,identity))

dephasing_b = dict(
    type='additive',
    name='Dephasing',
    operator=np.kron(identity,sigma_z))

noises = [dephasing_a,dephasing_b]

# Define target

target = dict(
    unitary_operator=iswap,
    projection_operator=np.kron(identity,identity))

# Define configuration

configuration = dict(
    name='iSWAP Gate',
    controls=controls,
    noises=noises,
    target=target,
    duration=t,
    segment_count=segments)

optimized_system = qctrl.robust_optimization.create(configuration)
optimized_cost = qctrl.dump(optimized_system)['cost']
optimized_controls = qctrl.dump(optimized_system)['controls']

print(optimized_cost)