Make a Blueqat backend ~ Part 1

Blueqat library for easy quantum programming

Is developing. https://github.com/Blueqat/Blueqat

Blueqat backend?

Blueqat has a numpy simulator,

――I want to run a faster simulator ――I want to move the actual machine instead of the simulator ――I want to do something different --Get the unitary matrix of the circuit --Output the circuit in OpenQ ASM format

It is designed so that functions can be added in the form of "back end" so that it can be used for such purposes.

In some cases, such as "I made a simulator myself, but it is troublesome to make an interface", it may be convenient to make an appropriate backend.

This time, I will explain how to create a backend for a simulator that can accept OpenQ ASM input. OpenQASM input may be rarely accepted, but if possible, backend creation will be significantly easier.

A backend that takes OpenQASM input and returns the result

If your own simulator accepts OpenQ ASM input, this is the easiest way to create it. Just pass the function that receives OpenQASM and returns the result to the blueqat.backends.qasm_parser_backend_generator.generate_backend function.

Let's take a look at the IBM Q backend, which creates the backend that way. https://github.com/Blueqat/Blueqat/blob/master/blueqat/backends/ibmq_backend.py

First of all, take a quick look at everything

def _qasm_runner_qiskit(qasm, qiskit_backend=None, shots=None, returns=None, **kwargs):
    if returns is None:
        returns = "shots"
    elif returns not in ("shots", "draw", "_exception",
                         "qiskit_circuit", "qiskit_job", "qiskit_result"):
        raise ValueError("`returns` shall be None, 'shots', 'draw', " +
                         "'qiskit_circuit', 'qiskit_job', 'qiskit_result' or '_exception'")

    import_error = None
    try:
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            from qiskit import Aer, QuantumCircuit, execute
    except Exception as e:
        import_error = e

    if import_error:
        if returns == "_exception":
            return e
        if isinstance(import_error, ImportError):
            raise ImportError("Cannot import qiskit. To use this backend, please install qiskit." +
                              " `pip install qiskit`.")
        else:
            raise ValueError("Unknown error raised when importing qiskit. To get exception, " +
                             'run this backend with arg `returns="_exception"`')
    else:
        if returns == "_exception":
            return None
        qk_circuit = QuantumCircuit.from_qasm_str(qasm)
        if returns == "qiskit_circuit":
            return qk_circuit
        if returns == "draw":
            return qk_circuit.draw(**kwargs)
        if shots is None:
            shots = 1024
        if qiskit_backend is None:
            qiskit_backend = Aer.get_backend("qasm_simulator")
        job = execute(qk_circuit, backend=qiskit_backend, shots=shots, **kwargs)
        if returns == "qiskit_job":
            return job
        result = job.result()
        if returns == "qiskit_result":
            return result
        counts = Counter({bits[::-1]: val for bits, val in result.get_counts().items()})
        return counts

ibmq_backend = generate_backend(_qasm_runner_qiskit)

If you write like Circuit (). h [0] .m [:] .run (backend ='ibmq', qiskit_backend = ..., ...), it is _qasm_runner_qiskit (the circuit is converted to OpenQASM). , qiskit_backend = ..., ...) is called. Let's see how it behaves when called.

    if returns is None:
        returns = "shots"
    elif returns not in ("shots", "draw", "_exception",
                         "qiskit_circuit", "qiskit_job", "qiskit_result"):
        raise ValueError("`returns` shall be None, 'shots', 'draw', " +
                         "'qiskit_circuit', 'qiskit_job', 'qiskit_result' or '_exception'")

This area is processing the received arguments. Blueqat backends often accept an argument called returns, where you can specify what type of result you want to return.

In the default numpy backend, you can select the state vector or the measurement result, and in ibmq, you can get the measurement result, the circuit in Qiskit, the Job object, and so on. You can also return an object that is used internally for debugging. However, it is highly recommended to provide the default behavior so that it works without returns.

    import_error = None
    try:
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            from qiskit import Aer, QuantumCircuit, execute
    except Exception as e:
        import_error = e

    if import_error:
        if returns == "_exception":
            return e
        if isinstance(import_error, ImportError):
            raise ImportError("Cannot import qiskit. To use this backend, please install qiskit." +
                              " `pip install qiskit`.")
        else:
            raise ValueError("Unknown error raised when importing qiskit. To get exception, " +
                             'run this backend with arg `returns="_exception"`')

Above, in order to make Blueqat itself work even if qiskit is not installed, I am trying to import it when calling a function. Also, for a while, when I imported qiskit, a warning was issued, so I am also working to suppress it.

    else:
        if returns == "_exception":
            return None
        qk_circuit = QuantumCircuit.from_qasm_str(qasm)
        if returns == "qiskit_circuit":
            return qk_circuit
        if returns == "draw":
            return qk_circuit.draw(**kwargs)
        if shots is None:
            shots = 1024
        if qiskit_backend is None:
            qiskit_backend = Aer.get_backend("qasm_simulator")

While preparing to run the Qiskit simulator, some returns are returning results before running the simulator.

        job = execute(qk_circuit, backend=qiskit_backend, shots=shots, **kwargs)
        if returns == "qiskit_job":
            return job

I'm running a Qiskit simulator. If you specified returns to return a Qiskit job, it will return the job.

        result = job.result()
        if returns == "qiskit_result":
            return result
        counts = Counter({bits[::-1]: val for bits, val in result.get_counts().items()})
        return counts

It takes the result from the job, formats it into the format used by other Blueqat backends, and returns the result.

ibmq_backend = generate_backend(_qasm_runner_qiskit)

Pass in the function we saw above to create the backend.

Backend registration and use

The created backend cannot be used with Blueqat unless it is registered.

Backend registration

from blueqat import BlueqatGlobalSetting
# BlueqatGlobalSetting.register_backend(Backend name,Back end)
BlueqatGlobalSetting.register_backend(”myibmq”, ibmq_backend)

I was able to register a backend with the name myibmq.

Use the back end

Circuit().h[0].m[:].run_with_myibmq()
#Or
Circuit().h[0].m[:].run(backend=”myibmq”)

You can use the one registered in the form of run_with_ backend name ().

Set the backend to default

BlueqatGlobalSetting.set_default_backend(”myibmq”)

I was able to set the registered backend as the default.

Summary

It turns out that a simulator that accepts OpenQASM as input can support Blueqat quite easily.

Blueqat can be implemented with a little effort even if it is not. We will look at that in the future.