Heralded Leakage Measurement

Quantinuum Helios supports a new and robust capability to determine leakage errors during real-time execution. This capability exploits D-state shelving to determine leakage error and converts into erasure error.

User specified ternary measurement allows the user to obtain a result of 0, 1, or L. In this case, each qubit state amplitude is mapped to different parts of the D\(_{\frac{5}{2}}\) manifold and any remaining population in the S\(_\frac{1}{2}\) population (representing leakage errors) is measured via induced fluorescence with the 493nm and 650nm lasers. Afterwards, a series of pulses independently maps each state amplitude back into the S\(_{\frac{1}{2}}\) and D\(_{\frac{3}{2}}\) manifolds allowing measurement of the qubit state (0 or 1). Furthermore, ternary and protected measure can be combined when an entire batch is measured.

Shown above is the Energy level diagram for \(_{137}\)Ba\(^{+}\) with S\(_{\frac{1}{2}}\) ground state manifold used for storage and quantum operations, and the D\(_{\frac{5}{2}}\) and D\(_{\frac{3}{2}}\) used during measurement.

Guppy provides a function to perform a ternary measurement on a qubit, guppylang.std.qsystem.measure_leaked(). This is a destructive operation on a qubit and deallocates the virtual qubit in the user program. The underlying ion can be reused by requesting another virtual qubit. The measure_leaked operation returns a guppylang.std.qsystem.MaybeLeaked instance.

The user program request for measure_leaked corresponds to a hardware native operation. This is detailed in the visual schematic below. In the user program, the MaybeLeaked instance contains instance methods to query the outcome of the measurement.

Trap operation to execute native leakage detection on the Ba-137 qubit. The qubit is shelved in the D manifold at least twice to determine leakage outside of the computational space.

Basic Usage

The measure_leaked function returns a MaybeLeaked instance. The code sample below calls MaybeLeaked.is_leaked() to determine if the qubit has leaked. The outcome of the instance method is Boolean.

If the qubit has leaked (True), then the MaybeLeaked instance needs to be deallocated with MaybeLeaked.discard().

If the qubit is sealed (not leaked), then the measurement result can be retrieved with another instance method, MaybeLeaked.to_result().unwrap(), which returns a Boolean. If the qubit has leaked the output of to_result() will be nothing.

from guppylang import guppy
from guppylang.std.builtins import result
from guppylang.std.angles import angle
from guppylang.std.quantum import qubit
from guppylang.std.qsystem import measure_leaked, zz_phase, measure

@guppy
def main() -> None:
    q0 = qubit()
    q1 = qubit()
    zz_phase(q0, q1, angle(-0.125))
    maybe_leaked = measure_leaked(q1)

    if maybe_leaked.is_leaked():
        q2 = qubit()
        zz_phase(q0, q2, angle(-0.125))
        b1 = measure(q2)
        maybe_leaked.discard()
    else:
        b1 = maybe_leaked.to_result().unwrap()
    result("q0", measure(q0))
    result("q1", b1)

hugr = main.compile()