Quantum Control for Superconducting Qubits

Ramsey with Frequency Tuning

Fig. 2. The Ramsey interference sequence for measuring \(T_2^*\) and \(f_{01}\) of the qubit. Three nested loops are used, and \(t_{\mathrm{wait}}\) and \(\Delta f\) are scanned over. The top part of the figure corresponds to the state of the qubit on the Bloch sphere during the sequence, before and after each gate operation. During the free evolution stage, the phase acquired drifts between different iterations, reflected as smearing in Y’s sinusoidal variation and in the Bloch vector component.

The program consists of 3 nested for-loops (Fig 2). The first is an external averaging loop. The second one loops over the frequency, which is updated to a new value when we call update_frequency('qubit1', f_sweep) in line 26, and the third one loops over the wait time between the two pulses.

We play two \(Y/2\) pulses in each iteration, here generated in QUA with the statement play('pi_op_qubit1' * amp(0.5), 'qubit1') in lines 27 and 29. This statement plays a \(\pi\)-pulse as defined in the program configuration and scales its amplitude by half. The program configuration, which is not shown here for the sake of brevity, is where all the static information, including waveform samples, output frequencies, and state discriminators, is stored. Between the pulses, we wait for a time corresponding to the QUA variable free_time. Then, in the measure statement on line 31, we perform the following sequence:
Send a drive pulse to the readout resonator, wait for a fixed amount of time, acquire the output from the readout resonator, demodulate it, and store the demodulated result in the QUA variables I and Q. We can then either send the results back to the PC using the save statements in lines 34 or 35 or use the IQ values inside the QUA program for whatever we choose.

The process is repeated for different qubit offset frequencies and wait times. As explained above, for a given frequency offset, we observe oscillations with a period that corresponds to \(1/\Delta f\), which gives the characteristic lineshapes shown in Fig. 3. The visibility of these lineshapes decays uniformly as time progresses. The run time of this program, including data acquisition, was approximately 10 minutes.

A crucial ingredient in the program is the reset_qubit1 method. This method is a simple yet illustrative example of an active reset sequence demonstrating how easy it is to perform feedback operations on the OPX+. All that is needed is to store the measurement result into a QUA variable and then use this variable in a while loop to perform a conditioned \(\pi\)-pulse operation!

from qm.qua import *


def reset_qubit1():
    qv = declare(fixed)
    align('res', 'qubit1')
    measure('meas_op_res', 'res', None, demod.full('integ_w_s', qv))

    # qv is the discriminating IQ variable.
    with while_(qv > -0.005):
        play('pi_op_qubit1', 'qubit1')
        measure('meas_op_res', 'res', None, demod.full('integ_w_s', qv))


with program() as prog:
    f_sweep = declare(int)
    I = declare(fixed)
    Q = declare(fixed)
    n = declare(int)
    free_time = declare(int)

    with for_(n, 0, n < 1000, n + 1):
        with for_(f_sweep, 99e6, f_sweep < 101e6, f_sweep + 0.01e6):
            with for_(free_time, 20, free_time < 8000, free_time + 10):
                reset_qubit1()
                update_frequency('qubit1', f_sweep)
                play('pi_op_qubit1' * amp(0.5), 'qubit1')
                wait(free_time, 'qubit1')
                play('pi_op_qubit1' * amp(0.5), 'qubit1')
                align('qubit1', 'res')
                measure('meas_op_res', 'res', None,
                        demod.full('integ_w_c', I),
                        demod.full('integ_w_s', Q))
                save(I, 'I')
                save(Q, 'Q')

Ramsey Sequence

Fig. 3 The expectation value of \(\langle S_z \rangle\) for different wait times and frequency detuning values. The oscillation period is \(1 / \Delta f\). The visibility of the interference oscillations decays with wait time, from which the \(T_2^*\) coherence time of the qubit can be inferred. This measurement took about 10 minutes with the OPX+.

Fig. 4 Decaying oscillations for real frequency detuning of 0.251MHz (yellow line), showing asymmetry, and for a virtual Z rotation which allows us to accumulate a phase equal to \(2\pi \Delta f t_{\mathrm{wait}}\) during the free evolution stage.

from qm.qua import *

free_time_step = 20
offset_freq = 0.251e6  # the artificial offset frequency added during free evolution time only

# factor of 4 is due to free time being in units of 4nsec
rot_angle = free_time_step * 4 * offset_freq * 1e-9

with program() as ramsey_1d:
    I = declare(fixed)
    Q = declare(fixed)
    n = declare(int)
    free_time = declare(int)
    total_angle = declare(fixed, value=0)

    with for_(n, 0, n < 1000, n + 1):
        assign(total_angle, 0)
        with for_(free_time, free_time_step, free_time < 4000, free_time + free_time_step):
            reset_qubit1()
            assign(total_angle, total_angle + rot_angle)
            play('pi_op_qubit1' * amp(0.5), 'qubit1')
            wait(free_time, 'qubit1')
            frame_rotation_2pi(total_angle, "qubit1")
            play('pi_op_qubit1' * amp(0.5), 'qubit1')
            align('qubit1', 'res')
            measure('meas_op_res', 'res', None, demod.full('integ_w_c', I), demod.full('integ_w_s', Q))

            save(I, 'I')
            save(Q, 'Q')

The parity measurements can be done by employing two more ancilla qubits initialized in the \(|0\rangle\) state before every measurement sequence, as shown in Figure 2. To measure the parity of a pair of qubits, say qubit 1 and 2, one CNOT gate is applied to qubit 1, and the ancilla qubit, and one CNOT gate is applied to qubit 2 and the same ancilla. This entangles the parity of the two qubits with the state of the ancilla, which can then be measured to determine the parity.

Fig. 2. Circuit for a 3-qubit error correction code. Two ancilla qubits are used to enable both error detection and correction. \(|\psi\rangle_L \) is the logical qubit, expressed in the extended Hilbert space.

From the control perspective, running such a protocol is very demanding since it requires:

• Fast real-time processing: to manage the error tracking in every iteration of the Repeated Error Tracking stage. Faster than the desired duration of the iteration, which is typically 100s of ns in superconducting circuits [M. Reed et al., Realization of three-qubit quantum error correction with superconducting circuits, Nature 482, 382–385 (2012)]