With the Quantum Orchestration Platform for quantum control, there’s no limit to the span of experiments you can run. Find out how to supercharge your quantum dots research with these real-world use cases.

Quantum Orchestration for

In quantum dot (QD) – based qubits, charge and spin are controlled in precise ways in a solid-state device. There are various ways to create suitable quantum dots, define qubits from them, and different methods to control them and readout their state [Floris A. Zwanenbur et al., Silicon quantum electronics. *Reviews Of Modern Physics*, *85*(3), 961-1019 (2013)]. As a concrete example, we consider the system developed in [C. Yang, A. S. Dzurak, et al, Operation of a silicon quantum processor unit cell above one kelvin. *Nature*, *580*(7803), 350–354 (2020)], which demonstrates a fully functional unit cell of a Si QDs – based quantum processor operating above 1 Kelvin, an important milestone towards scaling up of Si QDs – based quantum computers.

In this work, two electrons are placed in adjacent potential wells, *QD1* and *QD2*, defined in a silicon-metal-oxide (Si-MOS) device by lithographically fabricated gate electrodes shown in Fig. 1. The electrodes labeled G1 and G2 control the depth of these wells, and the electrode labeled J controls the coupling strength between the wells. A fixed magnetic gradient placed across the wells allows a line carrying a microwave (MW) signal to directly control the spin of one of the qubits via electrically driven spin-resonance (EDSR). The system has both tunable coupling and controls for state preparation. For readout, a single-electron transistor (SET) is placed adjacent to one of the qubits. The SET is a sensitive charge sensor that changes its conductance in response to changes in the quantum dots’ charge configuration.

**detuning**, \(\epsilon\). The detuning is defined as the linear combination of the voltages on G1 and G2 that controls the tilt of the double-well potential towards the (2, 0) charge configuration (for positive detuning) or (1, 1) charge configuration (for negative detuning). This is usually done at DC, as shown in Figure 2, but can also be modulated as shown below.

The preparation of the system in a well-defined state involves setting the detuning such that both electrons are forced into the same dot, i.e. the (2, 0) state. After enough time in this charge configuration, the system settles into a singlet spin state. The detuning is then sweeped again to bring the system into the (1, 1) state. Thus, the system is prepared in a singlet state with one electron in each dot. Another step, which involves controlling the inter-dot interaction using J, can be used to prepare the system in the state \(|\downarrow \downarrow \rangle\). After the preparation, coherent control over each spin can be achieved by driving it at its resonant frequency. Moreover, a CZ gate can be performed by turning on the interaction between the spins via J again.

Finally, the readout is performed by tilting the double-well potential, using the detuning, to a point where the resulting charge configuration is highly dependent on the electrons’ relative spin alignment, due to a spin blockade. At this detuning, if the spins are anti-aligned, the electron from QD1 will tunnel to QD2, and the system will be at the (0, 2) charge configuration. However, if the spins are aligned, then the electron will not tunnel due to the Pauli exclusion principle and the system will remain in (1, 1). Thus, by reading the SET current, we can determine whether the spins are aligned (even parity) or anti-aligned (odd parity).

In QUA, repeated sections can be implemented by writing macros. For example, the preparation stage involves placing the two elements at some fixed value and then performing an adiabatic ramp onto the evolution stage. A readout stage can be defined in very similar terms. The code snippet below shows these macros which we reuse in the experiments you’ll see in the following sections.

```
```def prep_state():
play(‘prep’, ‘G1’)
play(‘prep’, ‘G2’)
play(‘ramp-down-evolve’, ‘G1’)
play(‘ramp-up-evolve’, ‘G2’)
def readout_state():
play(‘ramp-up-evolve’, ‘G1’)
play(‘ramp-down-evolve’, ‘G2’)
play(‘readout’, ‘G1’)
play(‘readout’, ‘G2’)

The pulses applied to the G1, G2 elements at the preparation, evolution, and readout stages and the difference between them, \(\epsilon\), are shown below.

One of the most visually appealing basic characterization experiments one can perform on a qubit is generating a Rabi Chevron. Here the system is initialized in a singlet (odd spin parity) state, and the MW drive duration and frequency are scanned. The QUA code below demonstrates how easily we can achieve this with the Quantum Orchestration Platform (QOP). No waveforms need to be precomputed and uploaded since it’s now possible to update the duration and frequency of pulses in real-time. We implement this with nested `for`

loops, where the outermost loop is used for averaging. The measurement statement is used to integrate the SET current for a duration set by the `measurement_pulse`

. Integration is implemented as a weighted sum whose weights are defined by a weights vector `w`

.

```
```

`with for_(n,0,n`

The time saving due to no waveforms being uploaded to the QOP between runs allowed the Rabi chevron measurement in Figure 4, to be taken in **just 4 minutes! **

A more precise way to calibrate the resonant frequency of the Pi pulse is to perform a Ramsey spectroscopy sequence. This essentially generates a “beating” signal between the qubit drive frequency and the qubit’s true resonant frequency and can therefore resolve small differences. The Ramsey sequence is composed of an outermost averaging loop, containing an additional `for`

loop controlling the delay time between the pi/2 pulses of the sequence. As you can see below, this is very simple to write in QUA.

```
```

`with for_(n,0,n`

The trace you see in Figure 5 shows the resulting beating of a QD qubit intentionally detuned from its drive.

Calibration of a pi pulse, obtained by performing the Rabi and Ramsey measurements is crucial for any advanced experimental sequence. Once we achieve this, a natural first step is to measure the rates of decoherence and decay. A Hahn echo sequence, originally used in NMR experiments, is a basic sequence used to characterize the rate of decoherence of a qubit. It can be supplemented by more elaborate pulse sequences such as CPMG or XY-n sequences.

The Hahn echo experiment splits the free evolution duration of the Ramsey experiment in two and adds a pi pulse in the middle. This serves to reverse the sense of phase accumulation of the qubit and provide some protection from high-frequency noise components. This reversal indicates an echo in the excited state population after a time 2d (see QUA code snippet below). The decay rate of this echo gives a measure of the low-frequency decoherence rate of the qubit. By modifying the previous code, we can easily describe the experiment in QUA.

```
```

`with for_(n,0,n`

QOP’s real-time computational capabilities can be harnessed for a variety of feedback operations. A particularly compelling example of this is employing Bayesian estimation techniques for metrology or, as in this case, estimating the environment of a qubit to extend the coherence time one can achieve.

To demonstrate this, we move to consider another example from [Shulman, M. D. et al, Suppressing qubit dephasing using real-time Hamiltonian estimation, *Nature Communications*, *5*(May), 1–6 (2014)]. In this example, the system comprises an S-T0 qubit residing in a pair of coupled quantum dots in GaAs/AlGaAs. The qubit’s state is controlled by the **detuning**, \(\epsilon\), which controls the relative depth of the two potential wells and the coupling between the wells, J.

An external magnetic field is applied (by a superconducting electromagnet) to energetically separate the T+ and T- states from the computational subspace. In addition, the qubits experience a magnetic field due to the orientation of the nuclear spins in the substrate. By manipulating the qubit state, it is possible to polarize the substrate (so-called “pumping”), thus minimizing the fluctuations, but this has limited effect as there are residual fluctuations. The residual fluctuations are slow in the sense that for each experimental realization the magnetic field will be constant. However, for different realizations its direction is arbitrary and there will therefore be a magnetic gradient across the qubits. This gradient \(\Delta B_z\) drives a rotation around the x-axis of the S-T0 Bloch sphere shown in Figure 7. Because the magnetic gradient contribution is quasi-static, the system can be operated in sync with the rotation rate it induces. In this work, this is done by using real-time Bayesian estimation to determine the magnetic field gradient, \(\Delta B_z \), and thus the associated precession frequency.

Bayesian estimation uses a prior postulate by which all magnetic field values in some range are equally probable and uses Bayes theorem to update the (posterior) distribution repeatedly. The final distribution’s most probable field is assumed to be the external field for the experiment’s duration.

To perform Bayesian estimation, first, we must perform a single-shot state evaluation. This is done in the first row of the snippet below. The state is measured by measuring the reflection of an RF signal from a Quantum Point Contact (QPC) near the double-dot. The reflected signal is demodulated, and the demodulated value is saved to a variable. We accomplish all this with just a single statement.

The following expression then needs to be repeatedly evaluated (in real-time) for each possible value of the magnetic field:

\(P(m_k | \Delta B_z) = \frac{1}{2} [1+r_k (\alpha + \beta cos(2\pi \Delta B_z t_k)]\)This is done in the first `for`

loop. Note the usage of casting and trigonometric functions which are efficiently implemented on the QOP processor. The second `for`

loop is a normalization of the resulting probability distribution.

```
```

```
measure(‘measure’, ‘RF-QPC’, None, demod.full(‘integQ1’, I)
assign(state[k - 1], I > 0)
save(state[k - 1], satet_str)
assign(rk, Cast.to_fixed(state[k - 1]) - 0.5)
with for_(fB, fB_min, fB < fB_max, fB + dfB):
assign(C, Math.cos2pi(Cast.mul_fixed_by_int(fB, t_samp * k)))
assign(Pf[ins1], (0.5 + rk * (alpha + beta * C)) * Pf[ind1])
assign(ind1, ind1 +1)
assign(norm, 1 / Math.sum(Pf))
with for_(ind, 0, ind1
```

This mathematically clear set of operations is not trivial to implement from scratch on an FPGA which is what was originally demonstrated in this paper. With the QOP, however, no FPGA development skills are required.

TRY IT FOR YOURSELF, WITH OUR

Do you have a challenging, interesting, or complex experiment you wish to run? Our team has a deep understanding of Quantum Dots-based experiments. Shoot us an email, let’s talk about it.