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)
```