qoro-divi 0.2.0b1__py3-none-any.whl

divi/qasm.py

@@ -0,0 +1,220 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import re
+from functools import partial
+from itertools import product
+from typing import Optional
+from warnings import warn
+
+import cirq
+import numpy as np
+import pennylane as qml
+from pennylane.tape import QuantumScript
+from pennylane.wires import Wires
+from sympy import Symbol
+
+from divi.exp.cirq import cirq_circuit_from_qasm
+from divi.qem import QEMProtocol
+
+OPENQASM_GATES = {
+    "CNOT": "cx",
+    "CZ": "cz",
+    "U3": "u3",
+    "U2": "u2",
+    "U1": "u1",
+    "Identity": "id",
+    "PauliX": "x",
+    "PauliY": "y",
+    "PauliZ": "z",
+    "Hadamard": "h",
+    "S": "s",
+    "Adjoint(S)": "sdg",
+    "T": "t",
+    "Adjoint(T)": "tdg",
+    "RX": "rx",
+    "RY": "ry",
+    "RZ": "rz",
+    "CRX": "crx",
+    "CRY": "cry",
+    "CRZ": "crz",
+    "SWAP": "swap",
+    "Toffoli": "ccx",
+    "CSWAP": "cswap",
+    "PhaseShift": "u1",
+}
+
+
+def _ops_to_qasm(operations, precision, wires):
+    # create the QASM code representing the operations
+    qasm_str = ""
+
+    for op in operations:
+        try:
+            gate = OPENQASM_GATES[op.name]
+        except KeyError as e:
+            raise ValueError(
+                f"Operation {op.name} not supported by the QASM serializer"
+            ) from e
+
+        wire_labels = ",".join([f"q[{wires.index(w)}]" for w in op.wires.tolist()])
+        params = ""
+
+        if op.num_params > 0:
+            # If the operation takes parameters, construct a string
+            # with parameter values.
+            if precision is not None:
+                params = (
+                    "(" + ",".join([f"{p:.{precision}}" for p in op.parameters]) + ")"
+                )
+            else:
+                # use default precision
+                params = "(" + ",".join([str(p) for p in op.parameters]) + ")"
+
+        qasm_str += f"{gate}{params} {wire_labels};\n"
+
+    return qasm_str
+
+
+def to_openqasm(
+    main_qscript,
+    measurement_groups: list[list[qml.measurements.ExpectationMP]],
+    measure_all: bool = True,
+    precision: Optional[int] = None,
+    return_measurements_separately: bool = False,
+    symbols: list[Symbol] = None,
+    qem_protocol: Optional[QEMProtocol] = None,
+) -> list[str] | tuple[str, list[str]]:
+    """
+    Serialize the circuit as an OpenQASM 2.0 program.
+
+    A modified version of PennyLane's function that is more compatible with having
+    several measurements and incorporates modifications introduced by splitting transforms,
+    as well as error mitigation through folding.
+
+    The measurement outputs can be restricted to only those specified in the script by
+    setting ``measure_all=False``.
+
+    .. note::
+
+        The serialized OpenQASM program assumes that gate definitions
+        in ``qelib1.inc`` are available.
+
+    Args:
+        main_qscript (QuantumScript): the quantum circuit to be converted, as a QuantumScript/QuantumTape object.
+        measurement_groups (list[list]): A list of list of commuting observables, generated by the grouping Pennylane transformation.
+        measure_all (bool): whether to perform a computational basis measurement on all qubits
+            or just those specified in the script
+        precision (int): decimal digits to display for parameters
+        return_measurements_separately (bool): whether to not append the measurement instructions
+            and their diagonalizations to the main circuit QASM code and return separately.
+        symbols (list): Sympy symbols present in the circuit. Needed for some QEM routines.
+        qem_protocol (QEMProtocol): An optional QEMProtocol object for error mitigation, which may modify the circuit.
+
+    Returns:
+        list[str] or tuple[str, list[str]]: OpenQASM serialization of the circuit
+    """
+
+    if qem_protocol and symbols is None:
+        raise ValueError(
+            "When passing a QEMProtocol instance, the Sympy symbols in the circuit should be provided for the openqasm 3 conversion."
+        )
+
+    wires = main_qscript.wires
+
+    _to_qasm = partial(_ops_to_qasm, precision=precision, wires=wires)
+
+    # Add the QASM headers
+    main_qasm_str = (
+        'OPENQASM 3.0;\ninclude "stdgates.inc";\n'
+        if qem_protocol
+        else 'OPENQASM 2.0;\ninclude "qelib1.inc";\n'
+    )
+
+    if main_qscript.num_wires == 0:
+        # empty circuit
+        return main_qasm_str
+
+    if qem_protocol:
+        for symbol in symbols:
+            main_qasm_str += f"input angle[32] {str(symbol)};\n"
+
+    # create the quantum and classical registers
+    main_qasm_str += (
+        f"qubit[{len(wires)}] q;\n" if qem_protocol else f"qreg q[{len(wires)}];\n"
+    )
+    main_qasm_str += (
+        f"bit[{len(wires)}] c;\n" if qem_protocol else f"creg c[{len(wires)}];\n"
+    )
+
+    # Wrapping Sympy Symbols in a numpy object to bypass
+    # Pennylane's sanitization
+    for op in main_qscript.operations:
+        if qml.math.get_interface(*op.data) == "sympy":
+            op.data = np.array(op.data)
+
+    [transformed_tape], _ = qml.transforms.convert_to_numpy_parameters(main_qscript)
+    operations = transformed_tape.operations
+
+    # Decompose the queue
+    just_ops = QuantumScript(operations)
+    [decomposed_tape], _ = qml.transforms.decompose(
+        just_ops, gate_set=lambda obj: obj.name in OPENQASM_GATES
+    )
+
+    main_qasm_str += _to_qasm(decomposed_tape.operations)
+
+    main_qasm_strs = []
+    if qem_protocol:
+        for circ in qem_protocol.modify_circuit(cirq_circuit_from_qasm(main_qasm_str)):
+            # Convert back to QASM2.0 code, with the symbolic parameters
+            qasm_str = cirq.qasm(circ)
+            # Remove redundant newlines
+            qasm_str = re.sub(r"\n+", "\n", qasm_str)
+            # Remove comments
+            qasm_str = re.sub(r"^//.*\n?", "", qasm_str, flags=re.MULTILINE)
+            # Add missing classical reg
+            qasm_str = re.sub(r"qreg q\[(\d+)\];", r"qreg q[\1];creg c[\1];", qasm_str)
+
+            main_qasm_strs.append(qasm_str)
+    else:
+        main_qasm_strs.append(main_qasm_str)
+
+    qasm_circuits = []
+    measurement_qasms = []
+
+    # Create a copy of the program for every measurement that we have
+    for meas_group in measurement_groups:
+        curr_diag_qasm_str = (
+            _to_qasm(diag_ops)
+            if (diag_ops := QuantumScript(measurements=meas_group).diagonalizing_gates)
+            else ""
+        )
+
+        measure_qasm_str = ""
+        if measure_all:
+            for wire in range(len(wires)):
+                measure_qasm_str += f"measure q[{wire}] -> c[{wire}];\n"
+        else:
+            measured_wires = Wires.all_wires(
+                [m.wires for m in main_qscript.measurements]
+            )
+
+            for w in measured_wires:
+                wire_indx = main_qscript.wires.index(w)
+                measure_qasm_str += f"measure q[{wire_indx}] -> c[{wire_indx}];\n"
+
+        measurement_qasms.append(curr_diag_qasm_str + measure_qasm_str)
+
+    if not return_measurements_separately:
+        qasm_circuits.extend(product(main_qasm_strs, measurement_qasms))
+
+    if len(measurement_groups) == 0:
+        warn(
+            "No measurement groups provided. Returning the QASM of the circuit operations only."
+        )
+        qasm_circuits.extend(np.atleast_1d(main_qasm_strs).tolist())
+        return qasm_circuits
+
+    return qasm_circuits or (np.atleast_1d(main_qasm_strs).tolist(), measurement_qasms)

divi/qem.py

@@ -0,0 +1,191 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Sequence
+from functools import partial
+
+from cirq.circuits.circuit import Circuit
+from mitiq.zne import combine_results, construct_circuits
+from mitiq.zne.inference import Factory
+
+
+class QEMProtocol(ABC):
+    """
+    Abstract Base Class for Quantum Error Mitigation (QEM) protocols.
+
+    All concrete QEM protocols should inherit from this class and implement
+    the abstract methods and properties. This ensures a consistent interface
+    across different mitigation techniques.
+    """
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    @abstractmethod
+    def modify_circuit(self, cirq_circuit: Circuit) -> Sequence[Circuit]:
+        """
+        Modifies a given Cirq circuit into one or more new circuits
+        required by the QEM protocol.
+
+        For example, a Zero Noise Extrapolation (ZNE) protocol might
+        produce multiple scaled versions of the input circuit. A simple
+        mitigation protocol might return the original circuit unchanged.
+
+        Args:
+            cirq_circuit (cirq.Circuit): The input quantum circuit to be modified.
+
+        Returns:
+            Sequence[cirq.Circuit]: A sequence (e.g., list or tuple) of
+                                    Cirq circuits to be executed.
+        """
+        pass
+
+    @abstractmethod
+    def postprocess_results(self, results: Sequence[float]) -> float:
+        """
+        Applies post-processing (e.g., extrapolation, filtering) to the
+        results obtained from executing the modified circuits.
+
+        This method takes the raw output from quantum circuit executions
+        (typically a sequence of expectation values or probabilities) and
+        applies the core error mitigation logic to produce a single,
+        mitigated result.
+
+        Args:
+            results (Sequence[float]): A sequence of floating-point results,
+                                       corresponding to the executions of the
+                                       circuits returned by `modify_circuit`.
+
+        Returns:
+            float: The single, mitigated result after post-processing.
+        """
+        pass
+
+
+class _NoMitigation(QEMProtocol):
+    """
+    A dummy default mitigation protocol.
+    """
+
+    @property
+    def name(self) -> str:
+        return "NoMitigation"
+
+    def modify_circuit(self, cirq_circuit: Circuit) -> Sequence[Circuit]:
+        # Identity, do nothing
+        return [cirq_circuit]
+
+    def postprocess_results(self, results: Sequence[float]) -> float:
+        """
+        Returns the single result provided, ensuring only one result is given.
+
+        If multiple results are provided, it raises a RuntimeError, as this
+        protocol expects a single measurement outcome for its input circuit.
+
+        Args:
+            results (Sequence[float]): A sequence containing a single floating-point result.
+
+        Returns:
+            float: The single result from the sequence.
+
+        Raises:
+            RuntimeError: If more than one result is provided.
+        """
+        if len(results) > 1:
+            raise RuntimeError("NoMitigation class received multiple partial results.")
+
+        return results[0]
+
+
+class ZNE(QEMProtocol):
+    """
+    Implements the Zero Noise Extrapolation (ZNE) quantum error mitigation protocol.
+
+    This protocol uses `Mitiq`'s functionalities to construct noise-scaled
+    circuits and then extrapolate to the zero-noise limit based on the
+    obtained results.
+    """
+
+    def __init__(
+        self,
+        scale_factors: Sequence[float],
+        folding_fn: Callable,
+        extrapolation_factory: Factory,
+    ):
+        """
+        Initializes a ZNE protocol instance.
+
+        Args:
+            scale_factors (Sequence[float]): A sequence of noise scale factors
+                                             to be applied to the circuits. These
+                                             factors typically range from 1.0 upwards.
+            folding_fn (Callable): A callable (e.g., a `functools.partial` object)
+                                   that defines how the circuit should be "folded"
+                                   to increase noise. This function must accept
+                                   a `cirq.Circuit` and a `float` (scale factor)
+                                   as its first two arguments.
+            extrapolation_factory (mitiq.zne.inference.Factory): An instance of
+                                                                `Mitiq`'s `Factory`
+                                                                class, which provides
+                                                                the extrapolation method.
+
+        Raises:
+            ValueError: If `scale_factors` is not a sequence of numbers,
+                        `folding_fn` is not callable, or `extrapolation_factory`
+                        is not an instance of `mitiq.zne.inference.Factory`.
+        """
+        if (
+            not isinstance(scale_factors, Sequence)
+            or not all(isinstance(elem, (int, float)) for elem in scale_factors)
+            or not all(elem >= 1.0 for elem in scale_factors)
+        ):
+            raise ValueError(
+                "scale_factors is expected to be a sequence of real numbers >=1."
+            )
+
+        if not isinstance(folding_fn, partial):
+            raise ValueError(
+                "folding_fn is expected to be of type partial with all parameters "
+                "except for the circuit object and the scale factor already set."
+            )
+
+        if not isinstance(extrapolation_factory, Factory):
+            raise ValueError("extrapolation_fn is expected to be of Factory.")
+
+        self._scale_factors = scale_factors
+        self._folding_fn = folding_fn
+        self._extrapolation_factory = extrapolation_factory
+
+    @property
+    def name(self) -> str:
+        return "zne"
+
+    @property
+    def scale_factors(self) -> Sequence[float]:
+        return self._scale_factors
+
+    @property
+    def folding_fn(self):
+        return self._folding_fn
+
+    @property
+    def extrapolation_factory(self):
+        return self._extrapolation_factory
+
+    def modify_circuit(self, cirq_circuit: Circuit) -> Sequence[Circuit]:
+        return construct_circuits(
+            cirq_circuit,
+            scale_factors=self._scale_factors,
+            scale_method=self._folding_fn,
+        )
+
+    def postprocess_results(self, results: Sequence[float]) -> float:
+        return combine_results(
+            scale_factors=self._scale_factors,
+            results=results,
+            extrapolation_method=self._extrapolation_factory.extrapolate,
+        )

divi/qlogger.py

@@ -0,0 +1,119 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+import shutil
+import sys
+
+
+def _is_jupyter():
+    """
+    Checks if the code is running inside a Jupyter Notebook or IPython environment.
+    """
+    try:
+        from IPython import get_ipython
+
+        # Check if get_ipython() returns a shell instance (not None)
+        # and if the shell class is 'ZMQInteractiveShell' for Jupyter notebooks/qtconsole
+        # or 'TerminalInteractiveShell' for IPython console.
+        shell = get_ipython().__class__.__name__
+        if shell == "ZMQInteractiveShell":
+            return True  # Jupyter notebook or qtconsole
+        elif shell == "TerminalInteractiveShell":
+            return False  # IPython terminal
+        else:
+            return False  # Other IPython environment (less common for typical Jupyter detection)
+    except NameError:
+        return False  # Not running in IPython
+    except ImportError:
+        return False  # IPython is not installed
+
+
+class OverwriteStreamHandler(logging.StreamHandler):
+    def __init__(self, stream=None):
+        super().__init__(stream)
+
+        self._last_record = ""
+        self._last_message = ""
+
+        # Worst case: 2 complex emojis (8 chars each) + buffer = 21 extra chars
+        self._emoji_buffer = 21
+
+        self._is_jupyter = _is_jupyter()
+
+    def emit(self, record):
+        msg = self.format(record)
+
+        if record.message.startswith(r"\c"):
+            sep = r"\c"
+            msg = f"{msg.split(sep)[0]}{self._last_record} [{record.message[2:-2]}]\r"
+
+        if msg.endswith("\r\n"):
+            overwrite_and_newline = True
+            clean_msg = msg[:-2]
+
+            if not record.message.startswith("\c"):
+                self._last_record = record.message[:-2]
+        elif msg.endswith("\r"):
+            overwrite_and_newline = False
+            clean_msg = msg[:-1]
+
+            if not record.message.startswith(r"\c"):
+                self._last_record = record.message[:-1]
+        else:
+            # Normal message - no overwriting
+            self.stream.write(msg + "\n")
+            self.stream.flush()
+            return
+
+        # Clear previous line if needed
+        if len(self._last_message) > 0:
+            if self._is_jupyter:
+                clear_length = len(self._last_message) + self._emoji_buffer + 50
+            else:
+                clear_length = min(
+                    len(self._last_message) + self._emoji_buffer,
+                    shutil.get_terminal_size().columns,
+                )
+
+            self.stream.write("\r" + " " * clear_length + "\r")
+            self.stream.flush()
+
+        # Write message with appropriate ending
+        if overwrite_and_newline:
+            self.stream.write(clean_msg + "\n")
+            self._last_message = ""
+        else:
+            self.stream.write(clean_msg + "\r")
+            self._last_message = self._strip_ansi(clean_msg)
+
+        self.stream.flush()
+
+    def _strip_ansi(self, text):
+        """Remove ANSI escape sequences for accurate length calculation"""
+        import re
+
+        ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+        return ansi_escape.sub("", text)
+
+
+def enable_logging(level=logging.INFO):
+    root_logger = logging.getLogger(__name__.split(".")[0])
+
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+
+    handler = OverwriteStreamHandler(sys.stdout)
+    handler.setFormatter(formatter)
+
+    root_logger.setLevel(level)
+    root_logger.handlers.clear()
+    root_logger.addHandler(handler)
+
+
+def disable_logging():
+    root_logger = logging.getLogger(__name__.split(".")[0])
+    root_logger.handlers.clear()
+    root_logger.setLevel(logging.CRITICAL + 1)