`log` statements

[jon-wurtz]

Debugging features for (any?) squin kernel. Like print statements to extract from the execution post-hoc.

Inspired by Guppy's result and state_result https://docs.quantinuum.com/guppy/guppylang/examples/state_results.html

@kernel
def main(x):
    y = x + 1
    result(key="y",val = y)
    qbs = squin.qubit.new(3)
    # do quantum gates
    quantum_result(key="psi0", val = [qbs[0], qbs[3]])
    # do other quantum gates
    quantum_result(key="psi0", val = [qbs[1], qbs[2]])
    return z

task = emulator.task(main)
result = task.run()
records = task.records() # a dictionary of {"y": ##, "psi0": QuantumState, "psi1": QuantumState}

[david-pl]

As of bloqade-circuit, we have kirin's debug dialect added to squin (previoulsy you had to add it yourself).

You can do something like this:

from bloqade import squin
from bloqade.pyqrack import StackMemorySimulator

from kirin.dialects import debug

@squin.kernel
def main(x):
    y = x + 1
    debug.info("This is y", y)
    qbs = squin.qubit.new(3)
    # do quantum gates
    # quantum_result(key="psi0", val = [qbs[0], qbs[3]])
    debug.info("Initial qubit state", qbs)
    # do other quantum gates
    debug.info("Final qubit state", qbs)


emulator = StackMemorySimulator(min_qubits=3)
result = emulator.run(main, args=(1,))

This will print some very helpful debugging info.

As for obtaining the values: you can just return whatever you need form the kernel.

@jon-wurtz does this suffice for your use-case?

[jon-wurtz]

No; it would be useful to return the results as an object/dictionary for further analysis as well: the task.records() (or similar?) method. Also would debug.info("...", qbs) return the pointers to the qubits, or the QuantumState? It might have to be some object like debug.info("psi0", debug.qstate(qbs))

[david-pl]

Why? What exactly are you trying to do / debug that cannot be achieved with the current debug capabilities?

[jon-wurtz]

a) get a copy of the (mixed) state of the qubits at the time quantum_result is evoked
b) If the method is called as part of a larger function, I cannot modify the return (without having some extraordinary janky dict that follows around every function call and is appended to every return). But I still might want those values (as python objects) to analyze later.

[david-pl]

a) get a copy of the (mixed) state of the qubits at the time quantum_result is evoked

To do what?

But I still might want those values (as python objects) to analyze later.

This doesn't sound very concrete. Is there anything you are working on right now that cannot be covered by printing out the debug info?

[jon-wurtz]

The key here is further analysis-- computing intermediate overlap with a target state computed elsewhere, estimating the number of repetitions in a RUS protocol, scanning noise levels to compute code thresholds, and so forth. These things live outside of bloqade, but nonetheless, these sorts of "debugging" tools are a core component of algorithm development to better understand the action of an algorithm. Extracting values and quantum state is the use case.

For example:

@kernel
def main():
    # Do something
    result(key="error_rate",val=errs)
    quantum_result(key="intermediate_state1",val = [qbs[0], qbs[3]] + qbs[4::])
    return some_other_thing

data1 = []
data2 = []
noise_ = np.linspace(0,1,101)
target_state:QuantumState = make_target()
for noise in noise_:
    emulator = NoisyEmulator(noise_level=noise)
    job = emulator.run(main)
    data1.append(job.records()["error_rate"])
    overlap = target_state.overlap(job.records()["intermediate_state1"])
    data2.append(overlap)

plt.plot(noise_, data1)
plt.plot(noise_, data2)

[jon-wurtz]

And to be more explicit in why return alone doesn't suffice, suppose that data is collected in a subroutine. I can't otherwise extract y.

@kernel
def subroutine(x):
    y, z = ... #f(x)
    result(key="foo",bar = y)
    return z

@kernel
def main():
    z = subroutine(1)
    return f(z)

[david-pl]

Yes, fair enough, collecting data for debugging can be improved.