Source code for pytket.extensions.qiskit.tket_backend

# Copyright 2020-2024 Cambridge Quantum Computing
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from typing import Optional, List, Union, Any
from qiskit.circuit.quantumcircuit import QuantumCircuit  # type: ignore
from qiskit.providers.backend import BackendV1 as QiskitBackend  # type: ignore
from qiskit.providers.models import QasmBackendConfiguration  # type: ignore
from qiskit.providers import Options  # type: ignore
from pytket.extensions.qiskit import AerStateBackend, AerUnitaryBackend
from pytket.extensions.qiskit.qiskit_convert import qiskit_to_tk, _gate_str_2_optype_rev
from pytket.extensions.qiskit.tket_job import TketJob, JobInfo
from pytket.backends import Backend
from pytket.passes import BasePass
from pytket.predicates import (
    NoClassicalControlPredicate,
    GateSetPredicate,
    CompilationUnit,
)
from pytket.architecture import FullyConnected


def _extract_basis_gates(backend: Backend) -> List[str]:
    for pred in backend.required_predicates:
        if type(pred) == GateSetPredicate:
            return [
                _gate_str_2_optype_rev[optype]
                for optype in pred.gate_set
                if optype in _gate_str_2_optype_rev.keys()
            ]
    return []


[docs]class TketBackend(QiskitBackend): """Wraps a :py:class:`Backend` as a :py:class:`qiskit.providers.BaseBackend` for use within the Qiskit software stack. Each :py:class:`qiskit.circuit.quantumcircuit.QuantumCircuit` passed in will be converted to a :py:class:`Circuit` object. If a :py:class:`BasePass` is provided for ``comp_pass``, this is applied to the :py:class:`Circuit`. Then it is processed by the :py:class:`Backend`, wrapping the :py:class:`ResultHandle` s in a :py:class:`TketJob`, retrieving the results when called on the job object. The required predicates of the :py:class:`Backend` are presented to the Qiskit transpiler to enable it to perform the compilation in many cases. This may not always be possible due to unsupported gatesets or additional constraints that cannot be captured in Qiskit's transpiler, in which case a custom :py:class:`qiskit.transpiler.TranspilationPass` should be used to map into a tket- compatible gateset and set ``comp_pass`` to compile for the backend. To compile with tket only, set ``comp_pass`` and just use Qiskit to map into a tket-compatible gateset. In Qiskit Aqua, you should wrap the :py:class:`TketBackend` in a :py:class:`qiskit.aqua.QuantumInstance`, providing a custom :py:class:`qiskit.transpiler.PassManager` with a :py:class:`qiskit.transpiler.passes.Unroller`. For examples, see the `user manual <https://tket.quantinuum.com/user-manual/manual_backend.html#embedding-into- qiskit>`_ or the `Qiskit integration example <ht tps://github.com/CQCL/pytket/blob/main/examples/qiskit_integration. ipynb>`_. """
[docs] def __init__(self, backend: Backend, comp_pass: Optional[BasePass] = None): """Create a new :py:class:`TketBackend` from a :py:class:`Backend`. :param backend: The device or simulator to wrap up :type backend: Backend :param comp_pass: The (optional) tket compilation pass to apply to each circuit before submitting to the :py:class:`Backend`, defaults to None :type comp_pass: Optional[BasePass], optional """ arch = backend.backend_info.architecture if backend.backend_info else None coupling: Optional[List[List[Any]]] if isinstance(arch, FullyConnected): coupling = [ [n1.index[0], n2.index[0]] for n1 in arch.nodes for n2 in arch.nodes if n1 != n2 ] else: coupling = ( [[n.index[0], m.index[0]] for n, m in arch.coupling] if arch else None ) config = QasmBackendConfiguration( backend_name=("statevector_" if backend.supports_state else "") + "pytket/" + str(type(backend)), backend_version="0.0.1", n_qubits=len(arch.nodes) if arch and arch.nodes else 40, basis_gates=_extract_basis_gates(backend), gates=[], local=False, simulator=False, conditional=not any( ( type(pred) == NoClassicalControlPredicate for pred in backend.required_predicates ) ), open_pulse=False, memory=backend.supports_shots, max_shots=10000, coupling_map=coupling, max_experiments=10000, ) super().__init__(configuration=config, provider=None) self._backend = backend self._comp_pass = comp_pass
@classmethod def _default_options(cls) -> Options: return Options(shots=None, memory=False)
[docs] def run( self, run_input: Union[QuantumCircuit, List[QuantumCircuit]], **options: Any ) -> TketJob: if isinstance(run_input, QuantumCircuit): run_input = [run_input] n_shots = options.get("shots", None) circ_list = [] jobinfos = [] for qc in run_input: tk_circ = qiskit_to_tk(qc) if isinstance(self._backend, (AerStateBackend, AerUnitaryBackend)): tk_circ.remove_blank_wires() circ_list.append(tk_circ) jobinfos.append(JobInfo(qc.name, tk_circ.qubits, tk_circ.bits, n_shots)) if self._comp_pass: final_maps = [] compiled_list = [] for c in circ_list: cu = CompilationUnit(c) self._comp_pass.apply(cu) compiled_list.append(cu.circuit) final_maps.append(cu.final_map) circ_list = compiled_list else: final_maps = [None] * len(circ_list) # type: ignore handles = self._backend.process_circuits(circ_list, n_shots=n_shots) return TketJob(self, handles, jobinfos, final_maps)