mqt-core 3.2.0__cp314-cp314-win_amd64.whl

mqt/core/ir/registers.pyi

@@ -0,0 +1,91 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+__all__ = ["ClassicalRegister", "QuantumRegister"]
+
+class QuantumRegister:
+    """A class to represent a collection of qubits.
+
+    Args:
+        start: The starting index of the quantum register.
+        size: The number of qubits in the quantum register.
+        name: The name of the quantum register. A name will be generated if not provided.
+    """
+
+    def __init__(self, start: int, size: int, name: str = "") -> None: ...
+    @property
+    def start(self) -> int:
+        """The index of the first qubit in the quantum register."""
+
+    @property
+    def end(self) -> int:
+        """Index of the last qubit in the quantum register."""
+
+    @property
+    def size(self) -> int:
+        """The number of qubits in the quantum register."""
+
+    @property
+    def name(self) -> str:
+        """The name of the quantum register."""
+
+    def __eq__(self, other: object) -> bool:
+        """Check if the quantum register is equal to another quantum register."""
+
+    def __ne__(self, other: object) -> bool:
+        """Check if the quantum register is not equal to another quantum register."""
+
+    def __hash__(self) -> int:
+        """Return the hash of the quantum register."""
+
+    def __getitem__(self, key: int) -> int:
+        """Get the qubit at the specified index."""
+
+    def __contains__(self, qubit: int) -> bool:
+        """Check if the quantum register contains a qubit."""
+
+class ClassicalRegister:
+    """A class to represent a collection of classical bits.
+
+    Args:
+        start: The starting index of the classical register.
+        size: The number of bits in the classical register.
+        name: The name of the classical register. A name will be generated if not provided.
+    """
+
+    def __init__(self, start: int, size: int, name: str = "") -> None: ...
+    @property
+    def start(self) -> int:
+        """The index of the first bit in the classical register."""
+
+    @property
+    def end(self) -> int:
+        """Index of the last bit in the classical register."""
+
+    @property
+    def size(self) -> int:
+        """The number of bits in the classical register."""
+
+    @property
+    def name(self) -> str:
+        """The name of the classical register."""
+
+    def __eq__(self, other: object) -> bool:
+        """Check if the classical register is equal to another classical register."""
+
+    def __ne__(self, other: object) -> bool:
+        """Check if the classical register is not equal to another classical register."""
+
+    def __hash__(self) -> int:
+        """Return the hash of the classical register."""
+
+    def __getitem__(self, key: int) -> int:
+        """Get the bit at the specified index."""
+
+    def __contains__(self, bit: int) -> bool:
+        """Check if the classical register contains a bit."""

mqt/core/ir/symbolic.pyi

@@ -0,0 +1,177 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+from collections.abc import Iterator, Mapping, Sequence
+from typing import overload
+
+__all__ = ["Expression", "Term", "Variable"]
+
+class Variable:
+    """A symbolic variable.
+
+    Args:
+        name: The name of the variable.
+
+    Note:
+        Variables are uniquely identified by their name, so if a variable with the same name already exists,
+        the existing variable will be returned.
+    """
+
+    def __eq__(self, arg0: object) -> bool: ...
+    def __gt__(self, arg0: Variable) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __init__(self, name: str = "") -> None: ...
+    def __lt__(self, arg0: Variable) -> bool: ...
+    def __ne__(self, arg0: object) -> bool: ...
+    @property
+    def name(self) -> str:
+        """The name of the variable."""
+
+class Term:
+    """A symbolic term which consists of a variable with a given coefficient.
+
+    Args:
+        variable: The variable of the term.
+        coefficient: The coefficient of the term.
+    """
+
+    def __eq__(self, arg0: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __init__(self, variable: Variable, coefficient: float = 1.0) -> None: ...
+    def __mul__(self, arg0: float) -> Term: ...
+    def __ne__(self, arg0: object) -> bool: ...
+    def __rmul__(self, arg0: float) -> Term: ...
+    def __rtruediv__(self, arg0: float) -> Term: ...
+    def __truediv__(self, arg0: float) -> Term: ...
+    def add_coefficient(self, coeff: float) -> None:
+        """Add a coefficient to the coefficient of this term.
+
+        Args:
+            coeff: The coefficient to add.
+        """
+
+    def evaluate(self, assignment: Mapping[Variable, float]) -> float:
+        """Evaluate the term with a given variable assignment.
+
+        Args:
+            assignment: The variable assignment.
+
+        Returns:
+            The evaluated value of the term.
+        """
+
+    def has_zero_coefficient(self) -> bool:
+        """Check if the coefficient of the term is zero."""
+
+    @property
+    def coefficient(self) -> float:
+        """The coefficient of the term."""
+
+    @property
+    def variable(self) -> Variable:
+        """The variable of the term."""
+
+class Expression:
+    r"""A symbolic expression which consists of a sum of terms and a constant.
+
+    The expression is of the form :math:`constant + term_1 + term_2 + \dots + term_n`.
+
+    Args:
+        terms: The list of terms.
+        constant: The constant.
+
+    Alternatively, an expression can be created with a single term and a constant or just a constant.
+    """
+
+    constant: float
+    """
+    The constant of the expression.
+    """
+
+    @overload
+    def __add__(self, arg0: Expression) -> Expression: ...
+    @overload
+    def __add__(self, arg0: Term) -> Expression: ...
+    @overload
+    def __add__(self, arg0: float) -> Expression: ...
+    def __eq__(self, arg0: object) -> bool: ...
+    def __getitem__(self, idx: int) -> Term: ...
+    def __hash__(self) -> int: ...
+    @overload
+    def __init__(self, terms: Sequence[Term], constant: float = 0.0) -> None:
+        """Create an expression with a given list of terms and a constant.
+
+        Args:
+            terms: The list of terms.
+            constant: The constant.
+        """
+
+    @overload
+    def __init__(self, term: Term, constant: float = 0.0) -> None:
+        """Create an expression with a given term and a constant.
+
+        Args:
+            term: The term.
+            constant: The constant.
+        """
+
+    @overload
+    def __init__(self, constant: float = 0.0) -> None:
+        """Create an expression with a given constant.
+
+        Args:
+            constant: The constant.
+        """
+
+    def __iter__(self) -> Iterator[Term]: ...
+    def __len__(self) -> int: ...
+    def __mul__(self, arg0: float) -> Expression: ...
+    def __ne__(self, arg0: object) -> bool: ...
+    @overload
+    def __radd__(self, arg0: Term) -> Expression: ...
+    @overload
+    def __radd__(self, arg0: float) -> Expression: ...
+    def __rmul__(self, arg0: float) -> Expression: ...
+    @overload
+    def __rsub__(self, arg0: Term) -> Expression: ...
+    @overload
+    def __rsub__(self, arg0: float) -> Expression: ...
+    def __rtruediv__(self, arg0: float) -> Expression: ...
+    @overload
+    def __sub__(self, arg0: Expression) -> Expression: ...
+    @overload
+    def __sub__(self, arg0: Term) -> Expression: ...
+    @overload
+    def __sub__(self, arg0: float) -> Expression: ...
+    def __truediv__(self, arg0: float) -> Expression: ...
+    def evaluate(self, assignment: Mapping[Variable, float]) -> float:
+        """Evaluate the expression with a given variable assignment.
+
+        Args:
+            assignment: The variable assignment.
+
+        Returns:
+            The evaluated value of the expression.
+        """
+
+    def is_constant(self) -> bool:
+        """Check if the expression is a constant."""
+
+    def is_zero(self) -> bool:
+        """Check if the expression is zero."""
+
+    def num_terms(self) -> int:
+        """The number of terms in the expression."""
+
+    @property
+    def terms(self) -> list[Term]:
+        """The terms of the expression."""
+
+    @property
+    def variables(self) -> set[Variable]:
+        """The variables in the expression."""

mqt/core/plugins/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+"""Plugins for the core package."""

mqt/core/plugins/qiskit/__init__.py

@@ -0,0 +1,19 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+"""MQT Qiskit Plugin."""
+
+from __future__ import annotations
+
+from .mqt_to_qiskit import mqt_to_qiskit
+from .qiskit_to_mqt import qiskit_to_mqt
+
+__all__ = [
+    "mqt_to_qiskit",
+    "qiskit_to_mqt",
+]

mqt/core/plugins/qiskit/mqt_to_qiskit.py

@@ -0,0 +1,354 @@
+# Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+# Copyright (c) 2025 Munich Quantum Software Company GmbH
+# All rights reserved.
+#
+# SPDX-License-Identifier: MIT
+#
+# Licensed under the MIT License
+
+"""Functionality for translating from the MQT to Qiskit."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from qiskit.circuit import AncillaRegister, ClassicalRegister, Clbit, QuantumCircuit, QuantumRegister, Qubit
+from qiskit.circuit.library import (
+    DCXGate,
+    ECRGate,
+    HGate,
+    IGate,
+    PhaseGate,
+    RXGate,
+    RXXGate,
+    RYGate,
+    RYYGate,
+    RZGate,
+    RZXGate,
+    RZZGate,
+    SdgGate,
+    SGate,
+    SwapGate,
+    SXdgGate,
+    SXGate,
+    TdgGate,
+    TGate,
+    U2Gate,
+    U3Gate,
+    XGate,
+    XXMinusYYGate,
+    XXPlusYYGate,
+    YGate,
+    ZGate,
+    iSwapGate,
+)
+from qiskit.transpiler.layout import Layout, TranspileLayout
+
+from ...ir import Permutation
+from ...ir.operations import (
+    ClassicControlledOperation,
+    CompoundOperation,
+    Control,
+    NonUnitaryOperation,
+    Operation,
+    OpType,
+    StandardOperation,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from qiskit.circuit.singleton import SingletonGate
+
+    from ...ir import QuantumComputation
+
+__all__ = ["mqt_to_qiskit"]
+
+
+def __dir__() -> list[str]:
+    return __all__
+
+
+def _translate_controls(controls: set[Control], qubit_map: Mapping[int, Qubit]) -> tuple[list[Qubit], str]:
+    """Translate a set of :class:`~mqt.core.ir.operations.Control` to Qiskit.
+
+    Args:
+        controls: The controls to translate.
+        qubit_map: A mapping from qubit indices to Qiskit :class:`~qiskit.circuit.Qubit`.
+
+    Returns:
+        A tuple containing the translated qubits and control states.
+    """
+    qubits: list[Qubit] = []
+    ctrl_state: str = ""
+    for control in controls:
+        qubit = qubit_map[control.qubit]
+        qubits.append(qubit)
+        # MSB to the left
+        ctrl_state = "1" + ctrl_state if control.type_ == Control.Type.Pos else "0" + ctrl_state
+    return qubits, ctrl_state
+
+
+def _translate_targets(targets: Sequence[int], qubit_map: Mapping[int, Qubit]) -> list[Qubit]:
+    """Translate a sequence of target qubit indices to a list of Qiskit :class:`~qiskit.circuit.Qubit`.
+
+    Args:
+        targets: The target qubit indices to translate.
+        qubit_map: A mapping from qubit indices to Qiskit :class:`~qiskit.circuit.Qubit`.
+
+    Returns:
+        The translated qubits.
+    """
+    return [qubit_map[target] for target in targets]
+
+
+def _add_standard_operation(circ: QuantumCircuit, op: StandardOperation, qubit_map: Mapping[int, Qubit]) -> None:
+    """Add a :class:`~mqt.core.ir.operations.StandardOperation`.
+
+    Args:
+        circ: The Qiskit circuit to add the operation to.
+        op: The MQT operation to add.
+        qubit_map: A mapping from qubit indices to Qiskit :class:`~qiskit.circuit.Qubit`.
+
+    Raises:
+        TypeError: If the operation type is not supported.
+    """
+    targets = _translate_targets(op.targets, qubit_map)
+
+    if op.type_ == OpType.barrier:
+        circ.barrier(targets)
+        return
+
+    controls, ctrl_state = _translate_controls(op.controls, qubit_map)
+
+    gate_map_singleton: dict[OpType, SingletonGate] = {
+        OpType.i: IGate(),
+        OpType.x: XGate(),
+        OpType.y: YGate(),
+        OpType.z: ZGate(),
+        OpType.h: HGate(),
+        OpType.s: SGate(),
+        OpType.sdg: SdgGate(),
+        OpType.t: TGate(),
+        OpType.tdg: TdgGate(),
+        OpType.sx: SXGate(),
+        OpType.sxdg: SXdgGate(),
+        OpType.dcx: DCXGate(),
+        OpType.ecr: ECRGate(),
+        OpType.swap: SwapGate(),
+        OpType.iswap: iSwapGate(),
+    }
+
+    if op.type_ in gate_map_singleton:
+        gate = gate_map_singleton[op.type_]
+        if len(controls) == 0:
+            circ.append(gate, targets)
+        else:
+            circ.append(gate.control(len(controls), ctrl_state=ctrl_state), [*controls, *targets])
+        return
+
+    gate_map_single_param: dict[OpType, type] = {
+        OpType.rx: RXGate,
+        OpType.ry: RYGate,
+        OpType.rz: RZGate,
+        OpType.p: PhaseGate,
+        OpType.rxx: RXXGate,
+        OpType.ryy: RYYGate,
+        OpType.rzz: RZZGate,
+        OpType.rzx: RZXGate,
+    }
+
+    if op.type_ in gate_map_single_param:
+        gate = gate_map_single_param[op.type_]
+        parameter = op.parameter[0]
+        if len(controls) == 0:
+            circ.append(gate(parameter), targets)
+        else:
+            circ.append(gate(parameter).control(len(controls), ctrl_state=ctrl_state), [*controls, *targets])
+        return
+
+    gate_map_two_param: dict[OpType, type] = {
+        OpType.u2: U2Gate,
+        OpType.xx_plus_yy: XXPlusYYGate,
+        OpType.xx_minus_yy: XXMinusYYGate,
+    }
+
+    if op.type_ in gate_map_two_param:
+        gate = gate_map_two_param[op.type_]
+        parameter1, parameter2 = op.parameter
+        if len(controls) == 0:
+            circ.append(gate(parameter1, parameter2), targets)
+        else:
+            circ.append(
+                gate(parameter1, parameter2).control(len(controls), ctrl_state=ctrl_state), [*controls, *targets]
+            )
+        return
+
+    gate_map_three_param: dict[OpType, type] = {
+        OpType.u: U3Gate,
+    }
+
+    if op.type_ in gate_map_three_param:
+        gate = gate_map_three_param[op.type_]
+        parameter1, parameter2, parameter3 = op.parameter
+        if len(controls) == 0:
+            circ.append(gate(parameter1, parameter2, parameter3), targets)
+        else:
+            circ.append(
+                gate(parameter1, parameter2, parameter3).control(len(controls), ctrl_state=ctrl_state),
+                [*controls, *targets],
+            )
+        return
+
+    msg = f"Unsupported operation type: {op.type_}"
+    raise TypeError(msg)
+
+
+def _add_non_unitary_operation(
+    circ: QuantumCircuit, op: NonUnitaryOperation, qubit_map: Mapping[int, Qubit], clbit_map: Mapping[int, Clbit]
+) -> None:
+    """Add a :class:`~mqt.core.ir.operations.NonUnitaryOperation`.
+
+    Args:
+        circ: The Qiskit circuit to add the operation to.
+        op: The MQT operation to add.
+        qubit_map: A mapping from qubit indices to Qiskit :class:`~qiskit.circuit.Qubit`.
+        clbit_map: A mapping from classical bit indices to Qiskit :class:`~qiskit.circuit.Clbit`.
+    """
+    if op.type_ == OpType.measure:
+        for qubit, clbit in zip(op.targets, op.classics):
+            circ.measure(qubit_map[qubit], clbit_map[clbit])
+        return
+
+    if op.type_ == OpType.reset:
+        for qubit in op.targets:
+            circ.reset(qubit_map[qubit])
+        return
+
+
+def _add_compound_operation(
+    circ: QuantumCircuit, op: CompoundOperation, qubit_map: Mapping[int, Qubit], clbit_map: Mapping[int, Clbit]
+) -> None:
+    """Add a :class:`~mqt.core.ir.operations.CompoundOperation`.
+
+    Args:
+        circ: The Qiskit circuit to add the operation to.
+        op: The MQT operation to add.
+        qubit_map: A mapping from qubit indices to Qiskit :class:`~qiskit.circuit.Qubit`.
+        clbit_map: A mapping from classical bit indices to Qiskit :class:`~qiskit.circuit.Clbit`.
+    """
+    inner_circ = QuantumCircuit(*circ.qregs, *circ.cregs)
+    for inner_op in op:
+        _add_operation(inner_circ, inner_op, qubit_map, clbit_map)
+    circ.append(inner_circ.to_instruction(), circ.qubits, circ.clbits)
+
+
+def _add_operation(
+    circ: QuantumCircuit, op: Operation, qubit_map: Mapping[int, Qubit], clbit_map: Mapping[int, Clbit]
+) -> None:
+    """Add an operation to a Qiskit circuit.
+
+    Args:
+        circ: The Qiskit circuit to add the operation to.
+        op: The MQT operation to add.
+        qubit_map: A mapping from qubit indices to Qiskit :class:`~qiskit.circuit.Qubit`.
+        clbit_map: A mapping from classical bit indices to Qiskit :class:`~qiskit.circuit.Clbit`.
+
+    Raises:
+        TypeError: If the operation type is not supported.
+        NotImplementedError: If the operation type is not yet supported.
+    """
+    if isinstance(op, StandardOperation):
+        _add_standard_operation(circ, op, qubit_map)
+    elif isinstance(op, NonUnitaryOperation):
+        _add_non_unitary_operation(circ, op, qubit_map, clbit_map)
+    elif isinstance(op, CompoundOperation):
+        _add_compound_operation(circ, op, qubit_map, clbit_map)
+    elif isinstance(op, ClassicControlledOperation):
+        msg = "Conversion of classic-controlled operations to Qiskit is not yet supported."
+        raise NotImplementedError(msg)
+    else:
+        msg = f"Unsupported operation type: {type(op)}"
+        raise TypeError(msg)
+
+
+def mqt_to_qiskit(qc: QuantumComputation, *, set_layout: bool = False) -> QuantumCircuit:
+    """Convert a :class:`~mqt.core.ir.QuantumComputation` to a Qiskit :class:`~qiskit.circuit.QuantumCircuit`.
+
+    Args:
+        qc: The MQT circuit to convert.
+        set_layout: If true, the :attr:`~qiskit.circuit.QuantumCircuit.layout` property is populated with the
+                    initial layout and output permutation of the MQT circuit.
+
+    Returns:
+        The converted circuit.
+
+    Raises:
+        NotImplementedError: If the MQT circuit contains variables.
+    """
+    if not qc.is_variable_free():
+        msg = "Converting symbolic circuits with variables to Qiskit is not yet supported."
+        raise NotImplementedError(msg)
+
+    circ = QuantumCircuit()
+
+    if qc.name is not None:
+        circ.name = qc.name
+
+    qregs = sorted((qc.qregs | qc.ancregs).values(), key=lambda reg: reg.start)
+    qubit_map: dict[int, Qubit] = {}
+    for qreg in qregs:
+        qiskit_reg = (
+            QuantumRegister(size=qreg.size, name=qreg.name)
+            if qreg.name in qc.qregs
+            else AncillaRegister(size=qreg.size, name=qreg.name)
+        )
+        circ.add_register(qiskit_reg)
+        for i, qubit in enumerate(qiskit_reg):
+            qubit_map[qreg.start + i] = qubit
+
+    cregs = sorted(qc.cregs.values(), key=lambda reg: reg.start)
+    clbit_map: dict[int, Clbit] = {}
+    for creg in cregs:
+        qiskit_creg = ClassicalRegister(size=creg.size, name=creg.name)
+        circ.add_register(qiskit_creg)
+        for i, clbit in enumerate(qiskit_creg):
+            clbit_map[creg.start + i] = clbit
+
+    for op in qc:
+        _add_operation(circ, op, qubit_map, clbit_map)
+
+    if not set_layout:
+        return circ
+
+    # create a list of physical qubits initialized to none, but with the correct length
+    p2v: list[Qubit | None] = [None] * len(circ.qubits)
+    # fill the list with the correct virtual qubits
+    for virtual, physical in qc.initial_layout.items():
+        p2v[virtual] = qubit_map[physical]
+    initial_layout = Layout().from_qubit_list(p2v, *circ.qregs)
+
+    # reconstruct the final layout, which is the permutation between the initial layout and the output permutation
+    permutation = Permutation()
+    for physical, virtual in qc.output_permutation.items():
+        # find the virtual qubit in the initial layout and store the corresponding physical qubit
+        for p, v in qc.initial_layout.items():
+            if v == virtual:
+                permutation[p] = physical
+                continue
+
+    p2v = [None] * len(circ.qubits)
+    # fill the list with the correct virtual qubits
+    for physical, virtual in permutation.items():
+        p2v[virtual] = qubit_map[physical]
+    final_layout = Layout().from_qubit_list(p2v, *circ.qregs)
+
+    circ._layout = TranspileLayout(  # noqa: SLF001
+        initial_layout=initial_layout,
+        input_qubit_mapping={qubit: idx for idx, qubit in qubit_map.items()},
+        final_layout=final_layout,
+        _input_qubit_count=qc.num_qubits,
+        _output_qubit_list=list(final_layout.get_virtual_bits()),
+    )
+
+    return circ