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 NumberQ-CTRL CloudLocal Instance
 Time (min)CostTime (min)Cost
14.350.000107522972243.420.00392226
24.50.027534159527140.870.00030144
34.650.002862524445142.280.0010311
44.680.0007904835.80.00600469
54.630.0005318943.70.00742207
64.780.0027773943.550.00051428
74.750.007612936.980.03288244
84.570.0007278633.70.02412227
94.620.002819133.680.00233133
104.570.0192555933.750.01998404
Average Performance4.610.0049307438.770.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)