mqt-core 3.2.1__cp310-cp310-win_amd64.whl → 3.3.1__cp310-cp310-win_amd64.whl

mqt/core/ir/__init__.pyi

@@ -1864,33 +1864,71 @@ class QuantumComputation(MutableSequence[Operation]):
         """
 
     @overload
-    def classic_controlled(
+    def if_else(
         self,
-        op: OpType,
+        then_operation: Operation,
+        else_operation: Operation | None,
+        control_register: ClassicalRegister,
+        expected_value: int = 1,
+        comparison_kind: ComparisonKind = ComparisonKind.eq,
+    ) -> None:
+        """Add an if-else operation to the circuit.
+
+        Args:
+            then_operation: The operation to apply if the condition is met
+            else_operation: The operation to apply if the condition is not met
+            control_register: The classical register to check against
+            expected_value: The expected value of the control register
+            comparison_kind: The kind of comparison to perform
+        """
+
+    @overload
+    def if_else(
+        self,
+        then_operation: Operation,
+        else_operation: Operation | None,
+        control_bit: int,
+        expected_value: int = 1,
+        comparison_kind: ComparisonKind = ComparisonKind.eq,
+    ) -> None:
+        """Add an if-else operation to the circuit.
+
+        Args:
+            then_operation: The operation to apply if the condition is met
+            else_operation: The operation to apply if the condition is not met
+            control_bit: The index of the classical bit to check against
+            expected_value: The expected value of the control bit
+            comparison_kind: The kind of comparison to perform
+        """
+
+    @overload
+    def if_(
+        self,
+        op_type: OpType,
         target: int,
-        creg: ClassicalRegister,
+        control_register: ClassicalRegister,
         expected_value: int = 1,
         comparison_kind: ComparisonKind = ComparisonKind.eq,
         params: Sequence[float] = (),
     ) -> None:
-        """Add a classic-controlled operation to the circuit.
+        """Add an if operartion to the circuit.
 
         Args:
-            op: The operation to apply
+            op_type: The operation to apply
             target: The target qubit
-            creg: The classical register
-            expected_value: The expected value of the classical register
+            control_register: The classical register to check against
+            expected_value: The expected value of the control register
             comparison_kind: The kind of comparison to perform
             params: The parameters of the operation
         """
 
     @overload
-    def classic_controlled(
+    def if_(
         self,
-        op: OpType,
+        op_type: OpType,
         target: int,
         control: Control | int,
-        creg: ClassicalRegister,
+        control_register: ClassicalRegister,
         expected_value: int = 1,
         comparison_kind: ComparisonKind = ComparisonKind.eq,
         params: Sequence[float] = (),
@@ -1898,22 +1936,22 @@ class QuantumComputation(MutableSequence[Operation]):
         """Add a classic-controlled operation to the circuit.
 
         Args:
-            op: The operation to apply
+            op_type: The operation to apply
             target: The target qubit
             control: The control qubit
-            creg: The classical register
-            expected_value: The expected value of the classical register
+            control_register: The classical register to check against
+            expected_value: The expected value of the control register
             comparison_kind: The kind of comparison to perform
-            params: The parameters of the operation
+            params: The parameters of the operation.
         """
 
     @overload
-    def classic_controlled(
+    def if_(
         self,
-        op: OpType,
+        op_type: OpType,
         target: int,
         controls: set[Control | int],
-        creg: ClassicalRegister,
+        control_register: ClassicalRegister,
         expected_value: int = 1,
         comparison_kind: ComparisonKind = ComparisonKind.eq,
         params: Sequence[float] = (),
@@ -1921,78 +1959,78 @@ class QuantumComputation(MutableSequence[Operation]):
         """Add a classic-controlled operation to the circuit.
 
         Args:
-            op: The operation to apply
+            op_type: The operation to apply
             target: The target qubit
             controls: The control qubits
-            creg: The classical register
-            expected_value: The expected value of the classical register
+            control_register: The classical register to check against
+            expected_value: The expected value of the control register
             comparison_kind: The kind of comparison to perform
-            params: The parameters of the operation
+            params: The parameters of the operation.
         """
 
     @overload
-    def classic_controlled(
+    def if_(
         self,
-        op: OpType,
+        op_type: OpType,
         target: int,
-        cbit: int,
-        expected_value: int = 1,
+        control_bit: int,
+        expected_value: bool = True,
         comparison_kind: ComparisonKind = ComparisonKind.eq,
         params: Sequence[float] = (),
     ) -> None:
         """Add a classic-controlled operation to the circuit.
 
         Args:
-            op: The operation to apply
+            op_type: The operation to apply
             target: The target qubit
-            cbit: The classical bit index
-            expected_value: The expected value of the classical register
+            control_bit: The index of the classical bit to check against
+            expected_value: The expected value of the control bit
             comparison_kind: The kind of comparison to perform
-            params: The parameters of the operation
+            params: The parameters of the operation.
         """
 
     @overload
-    def classic_controlled(
+    def if_(
         self,
-        op: OpType,
+        op_type: OpType,
         target: int,
         control: Control | int,
-        cbit: int,
-        expected_value: int = 1,
+        control_bit: int,
+        expected_value: bool = True,
         comparison_kind: ComparisonKind = ComparisonKind.eq,
         params: Sequence[float] = (),
     ) -> None:
         """Add a classic-controlled operation to the circuit.
 
         Args:
-            op: The operation to apply
+            op_type: The operation to apply
             target: The target qubit
             control: The control qubit
-            cbit: The classical bit index
-            expected_value: The expected value of the classical register
+            control_bit: The index of the classical bit to check against
+            expected_value: The expected value of the control bit
             comparison_kind: The kind of comparison to perform
-            params: The parameters of the operation
+            params: The parameters of the operation.
         """
 
     @overload
-    def classic_controlled(
+    def if_(
         self,
-        op: OpType,
+        op_type: OpType,
         target: int,
         controls: set[Control | int],
-        cbit: int,
-        expected_value: int = 1,
+        control_bit: int,
+        expected_value: bool = True,
         comparison_kind: ComparisonKind = ComparisonKind.eq,
         params: Sequence[float] = (),
     ) -> None:
         """Add a classic-controlled operation to the circuit.
 
         Args:
-            op: The operation to apply
+            op_type: The operation to apply
             target: The target qubit
             controls: The control qubits
-            cbit: The classical bit index
-            expected_value: The expected value of the classical register
+            control_bit: The index of the classical bit to check against
+            expected_value: The expected value of the control bit
             comparison_kind: The kind of comparison to perform
-            params: The parameters of the operation
+            params: The parameters of the operation.
         """

mqt/core/ir/operations.pyi

@@ -15,10 +15,10 @@ from .registers import ClassicalRegister
 from .symbolic import Expression, Variable
 
 __all__ = [
-    "ClassicControlledOperation",
     "ComparisonKind",
     "CompoundOperation",
     "Control",
+    "IfElseOperation",
     "NonUnitaryOperation",
     "OpType",
     "Operation",
@@ -81,14 +81,14 @@ class OpType(Enum):
     See Also:
         :meth:`mqt.core.ir.QuantumComputation.barrier`
     """
-    classic_controlled = ...
+    if_else = ...
     """
-    A classic controlled operation.
+    An if-else operation.
 
-    It is used to control the execution of an operation based on the value of a classical register.
+    Used to control the execution of an operation based on the value of a classical register.
 
     See Also:
-        :meth:`mqt.core.ir.QuantumComputation.classic_controlled`
+        :meth:`mqt.core.ir.QuantumComputation.if_else`
     """
     compound = ...
     """
@@ -439,11 +439,11 @@ class Operation(ABC):
             The set of qubits that are used by the operation.
         """
 
-    def is_classic_controlled_operation(self) -> bool:
-        """Check if the operation is a :class:`ClassicControlledOperation`.
+    def is_if_else_operation(self) -> bool:
+        """Check if the operation is a :class:`IfElseOperation`.
 
         Returns:
-            True if the operation is a :class:`ClassicControlledOperation`, False otherwise.
+            True if the operation is a :class:`IfElseOperation`, False otherwise.
         """
 
     def is_compound_operation(self) -> bool:
@@ -895,15 +895,15 @@ class ComparisonKind(Enum):
     geq = ...
     """Greater than or equal comparison."""
 
-class ClassicControlledOperation(Operation):
-    """Classic controlled quantum operation.
+class IfElseOperation(Operation):
+    """If-else quantum operation.
 
-    This class is used to represent quantum operations that are controlled by
-    the value of a classical register. The operation is only executed if the
-    value of the classical register matches the expected value.
+    This class is used to represent an if-else operation. The then operation is executed if the
+    value of the classical register matches the expected value. Otherwise, the else operation is executed.
 
     Args:
-        operation: The operation that is controlled.
+        then_operation: The operation that is executed if the condition is met.
+        else_operation: The operation that is executed if the condition is not met.
         control_register: The classical register that controls the operation.
         expected_value: The expected value of the classical register.
         comparison_kind: The kind of comparison (default is equality).
@@ -912,7 +912,8 @@ class ClassicControlledOperation(Operation):
     @overload
     def __init__(
         self,
-        operation: Operation,
+        if_operation: Operation,
+        else_operation: Operation | None,
         control_register: ClassicalRegister,
         expected_value: int = 1,
         comparison_kind: ComparisonKind = ...,
@@ -920,14 +921,19 @@ class ClassicControlledOperation(Operation):
     @overload
     def __init__(
         self,
-        operation: Operation,
+        if_operation: Operation,
+        else_operation: Operation | None,
         control_bit: int,
-        expected_value: int = 1,
+        expected_value: bool = True,
         comparison_kind: ComparisonKind = ...,
     ) -> None: ...
     @property
-    def operation(self) -> Operation:
-        """The operation that is classically controlled."""
+    def then_operation(self) -> Operation:
+        """The operation that is executed if the condition is met."""
+
+    @property
+    def else_operation(self) -> Operation | None:
+        """The operation that is executed if the condition is not met."""
 
     @property
     def control_register(self) -> ClassicalRegister | None:
@@ -938,22 +944,29 @@ class ClassicControlledOperation(Operation):
         """The classical bit that controls the operation."""
 
     @property
-    def expected_value(self) -> int:
+    def expected_value_register(self) -> int:
+        """The expected value of the classical register.
+
+        The then-operation is executed if the value of the classical register matches the expected value based on the
+        kind of comparison.
+        The expected value is an integer that is interpreted as a binary number, where the least significant bit is at
+        the start index of the classical register.
+        """
+
+    @property
+    def expected_value_bit(self) -> bool:
         """The expected value of the classical register.
 
-        The operation is only executed if the value of the classical register matches the expected value
-        based on the kind of comparison.
-        If the classical register is a single bit, the expected value is either 0 or 1.
-        Otherwise, the expected value is an integer that is interpreted as a binary number, where
-        the least significant bit is at the start index of the classical register.
+        The then-operation is executed if the value of the classical bit matches the expected value based on the
+        kind of comparison.
         """
 
     @property
     def comparison_kind(self) -> ComparisonKind:
         """The kind of comparison.
 
-        The operation is only executed if the value of the classical register matches the expected value
-        based on the kind of comparison.
+        The then-operation is executed if the value of the classical register matches the expected value based on the
+        kind of comparison.
         """
 
     def add_control(self, control: Control) -> None:

mqt/core/lib/pkgconfig/spdlog.pc

@@ -0,0 +1,13 @@
+prefix=C:/Users/runneradmin/AppData/Local/Temp/tmpcp2xmopi/wheel/platlib/mqt/core
+exec_prefix=${prefix}
+includedir=${prefix}/include
+libdir=${exec_prefix}/lib
+
+Name: libspdlog
+Description: Fast C++ logging library.
+URL: https://github.com/gabime/spdlog
+Version: 1.15.3
+CFlags: -I${includedir} -DSPDLOG_COMPILED_LIB
+Libs: -L${libdir} -lspdlog -pthread
+Requires: 
+

mqt/core/na/__init__.py

@@ -0,0 +1,12 @@
+# 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 Core NA - The MQT Core neutral atom module.
+
+This module contains all neutral atom related functionality of MQT Core.
+"""

mqt/core/na/fomac.pyi

@@ -0,0 +1,117 @@
+# 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
+
+"""Reconstruction of NADevice from QDMI's Device class."""
+
+from collections.abc import Iterable
+
+from ..fomac import Device as GenericDevice
+
+__all__ = ["Device"]
+
+class Device(GenericDevice):
+    """Represents a device with a lattice of traps."""
+
+    class Vector:
+        """Represents a 2D vector."""
+
+        x: int
+        """
+        The x-coordinate of the vector.
+        """
+        y: int
+        """
+        The y-coordinate of the vector.
+        """
+        def __eq__(self, other: object) -> bool: ...
+        def __ne__(self, other: object) -> bool: ...
+
+    class Region:
+        """Represents a region in the device."""
+
+        origin: Device.Vector
+        """
+        The origin of the region.
+        """
+
+        class Size:
+            """Represents the size of a region."""
+
+            width: int
+            """
+            The width of the region.
+            """
+            height: int
+            """
+            The height of the region.
+            """
+            def __eq__(self, other: object) -> bool: ...
+            def __ne__(self, other: object) -> bool: ...
+
+        size: Size
+        """
+        The size of the region.
+        """
+
+        def __eq__(self, other: object) -> bool: ...
+        def __ne__(self, other: object) -> bool: ...
+
+    class Lattice:
+        """Represents a lattice of traps in the device."""
+
+        lattice_origin: Device.Vector
+        """
+        The origin of the lattice.
+        """
+        lattice_vector_1: Device.Vector
+        """
+        The first lattice vector.
+        """
+        lattice_vector_2: Device.Vector
+        """
+        The second lattice vector.
+        """
+        sublattice_offsets: Iterable[Device.Vector]
+        """
+        The offsets of the sublattices.
+        """
+        extent: Device.Region
+        """
+        The extent of the lattice.
+        """
+        def __eq__(self, other: object) -> bool: ...
+        def __ne__(self, other: object) -> bool: ...
+
+    traps: Iterable[Device.Lattice]
+    """
+    The list of trap positions in the device.
+    """
+    t1: int
+    """
+    The T1 time of the device.
+    """
+    t2: int
+    """
+    The T2 time of the device.
+    """
+
+    @classmethod
+    def try_create_from_device(cls, device: GenericDevice) -> Device | None:
+        """Create NA FoMaC Device from generic FoMaC Device.
+
+        Args:
+            device: The generic FoMaC Device to convert.
+
+        Returns:
+            The converted NA FoMaC Device or None if the conversion is not possible.
+        """
+    def __eq__(self, other: object) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+
+def devices() -> Iterable[Device]:
+    """Returns a list of available devices."""