Gemini Logical Device API for Post processing.

[weinbe58]

This Issue supersedes #643.

In order to support the QEC use cases we need to have some way of specifying the post processing of the physical measurements from the logical execution. Here I propose that we just pass the post processing function when submitting the tasks to the QPU that way we do not need to explicitly analyze the users kernel to figure out what is post processing and what is QPU logic.

Add a callback function to future

In many cases with future objects you can specify a callback function that should be executed on the results of the future. We can barrow that logic here at the task level:

post_processed_results = (
    device.task(quantum_kernel).run_async(*args, **kwargs)
    .callback(post_processing).get_result()
)

in terms of the signatures here we have:

class Device:
    def task(kernel: ir.Method[Args, Return]) -> Task[Args, Return]:
        ...


class Task(Generic[Args, Return]):
    def run_async(self, *args: Args.args, **kwargs: Args.kwargs) -> Future[Return]:
        ...


class Future(Generic[Return]):
    def callback(self, callback: ir.Method[[Return],T]) -> Future[T]:
        ...

    def get_result() -> Return:
        ...

[david-pl]

@weinbe58 I agree with the overall workflow here. Just to make sure: the intention is to have the post-processing run locally, correct? If so, how do you propose we execute the callback? Since it's a kernel, it will need an interpreter to run. What dialects are allowed here and what interpreter should that be?

I'd suggest to just have something like this then:

class Future(Generic[Return]):
    _callback: ir.Method[[Return],T] | None = None

    def callback(self, callback: ir.Method[[Return],T]) -> Future[T]:
        self._callback = callback

    def result() -> Return:
        physical_results = ....  # get from API
        if self._callback is not None:
            return self._execute_callback(physical_results)
        return physical_results

The question from above is then essentially just how precisely we'll implement the self._execute_callback method.

[david-pl]

After discussion with @weinbe58 elsewhere:

The callback should run locally and should, at least for now, just be a python callable kernel, i.e. the concrete interpreter can run it.