mqt-core 3.2.1__cp311-cp311-win_amd64.whl → 3.3.0__cp311-cp311-win_amd64.whl

mqt/core/__init__.py

@@ -12,14 +12,14 @@ from __future__ import annotations
 
 
 # start delvewheel patch
-def _delvewheel_patch_1_11_0():
+def _delvewheel_patch_1_11_2():
     import os
     if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir, 'mqt_core.libs'))):
         os.add_dll_directory(libs_dir)
 
 
-_delvewheel_patch_1_11_0()
-del _delvewheel_patch_1_11_0
+_delvewheel_patch_1_11_2()
+del _delvewheel_patch_1_11_2
 # end delvewheel patch
 
 import os

mqt/core/_commands.py

@@ -23,7 +23,7 @@ def include_dir() -> Path:
     """
     try:
         dist = distribution("mqt-core")
-        located_include_dir = Path(dist.locate_file("mqt/core/include/mqt-core"))
+        located_include_dir = Path(str(dist.locate_file("mqt/core/include/mqt-core")))
         if located_include_dir.exists() and located_include_dir.is_dir():
             return located_include_dir
         msg = "mqt-core include files not found."
@@ -42,7 +42,7 @@ def cmake_dir() -> Path:
     """
     try:
         dist = distribution("mqt-core")
-        located_cmake_dir = Path(dist.locate_file("mqt/core/share/cmake"))
+        located_cmake_dir = Path(str(dist.locate_file("mqt/core/share/cmake")))
         if located_cmake_dir.exists() and located_cmake_dir.is_dir():
             return located_cmake_dir
         msg = "mqt-core CMake files not found."

mqt/core/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '3.2.1'
-__version_tuple__ = version_tuple = (3, 2, 1)
+__version__ = version = '3.3.0'
+__version_tuple__ = version_tuple = (3, 3, 0)
+
+__commit_id__ = commit_id = 'ga354ba3d0'

mqt/core/dd.pyi

@@ -10,13 +10,12 @@
 
 from collections.abc import Iterable
 from enum import Enum
-from typing import Any
 
 import numpy as np
 import numpy.typing as npt
 
 from .ir import Permutation, QuantumComputation
-from .ir.operations import ClassicControlledOperation, Control, NonUnitaryOperation, Operation
+from .ir.operations import Control, IfElseOperation, NonUnitaryOperation, Operation
 
 __all__ = [
     "BasisStates",
@@ -289,7 +288,7 @@ class DDPackage:
             The resulting state is guaranteed to have its reference count increased.
         """
 
-    def from_vector(self, state: npt.NDArray[(Any,), np.cdouble]) -> VectorDD:
+    def from_vector(self, state: npt.NDArray[np.cdouble]) -> VectorDD:
         """Create a DD from a state vector.
 
         Args:
@@ -361,10 +360,10 @@ class DDPackage:
             The input DD must have a non-zero reference count.
         """
 
-    def apply_classic_controlled_operation(
+    def apply_if_else_operation(
         self,
         vec: VectorDD,
-        operation: ClassicControlledOperation,
+        operation: IfElseOperation,
         measurements: list[bool],
         permutation: Permutation = ...,
     ) -> VectorDD:
@@ -374,8 +373,7 @@ class DDPackage:
             vec: The input DD.
             operation: The classically controlled operation.
             measurements: A list of bits with stored measurement outcomes.
-            permutation: The permutation of the qubits.
-                         Defaults to the identity permutation.
+            permutation: The permutation of the qubits. Defaults to the identity permutation.
 
         Returns:
             The resulting DD after the operation.

mqt/core/fomac.pyi

@@ -0,0 +1,125 @@
+# 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 Iterable
+from enum import Enum
+
+__all__ = [
+    "Device",
+    "devices",
+]
+
+class Device:
+    """A device represents a quantum device with its properties and capabilities."""
+    class Status(Enum):
+        offline = ...
+        idle = ...
+        busy = ...
+        error = ...
+        maintenance = ...
+        calibration = ...
+
+    class Site:
+        """A site represents a potential qubit location on a quantum device."""
+        def index(self) -> int:
+            """Returns the index of the site."""
+        def t1(self) -> int | None:
+            """Returns the T1 coherence time of the site."""
+        def t2(self) -> int | None:
+            """Returns the T2 coherence time of the site."""
+        def name(self) -> str | None:
+            """Returns the name of the site."""
+        def x_coordinate(self) -> int | None:
+            """Returns the x coordinate of the site."""
+        def y_coordinate(self) -> int | None:
+            """Returns the y coordinate of the site."""
+        def z_coordinate(self) -> int | None:
+            """Returns the z coordinate of the site."""
+        def is_zone(self) -> bool | None:
+            """Returns whether the site is a zone."""
+        def x_extent(self) -> int | None:
+            """Returns the x extent of the site."""
+        def y_extent(self) -> int | None:
+            """Returns the y extent of the site."""
+        def z_extent(self) -> int | None:
+            """Returns the z extent of the site."""
+        def module_index(self) -> int | None:
+            """Returns the index of the module the site belongs to."""
+        def submodule_index(self) -> int | None:
+            """Returns the index of the submodule the site belongs to."""
+        def __eq__(self, other: object) -> bool:
+            """Checks if two sites are equal."""
+        def __ne__(self, other: object) -> bool:
+            """Checks if two sites are not equal."""
+
+    class Operation:
+        """An operation represents a quantum operation that can be performed on a quantum device."""
+        def name(self, sites: Iterable[Device.Site] = ..., params: Iterable[float] = ...) -> str:
+            """Returns the name of the operation."""
+        def qubits_num(self, sites: Iterable[Device.Site] = ..., params: Iterable[float] = ...) -> int | None:
+            """Returns the number of qubits the operation acts on."""
+        def parameters_num(self, sites: Iterable[Device.Site] = ..., params: Iterable[float] = ...) -> int:
+            """Returns the number of parameters the operation has."""
+        def duration(self, sites: Iterable[Device.Site] = ..., params: Iterable[float] = ...) -> int | None:
+            """Returns the duration of the operation."""
+        def fidelity(self, sites: Iterable[Device.Site] = ..., params: Iterable[float] = ...) -> float | None:
+            """Returns the fidelity of the operation."""
+        def interaction_radius(self, sites: Iterable[Device.Site] = ..., params: Iterable[float] = ...) -> int | None:
+            """Returns the interaction radius of the operation."""
+        def blocking_radius(self, sites: Iterable[Device.Site] = ..., params: Iterable[float] = ...) -> int | None:
+            """Returns the blocking radius of the operation."""
+        def idling_fidelity(self, sites: Iterable[Device.Site] = ..., params: Iterable[float] = ...) -> float | None:
+            """Returns the idling fidelity of the operation."""
+        def is_zoned(self, sites: Iterable[Device.Site] = ..., params: Iterable[float] = ...) -> bool | None:
+            """Returns whether the operation is zoned."""
+        def sites(
+            self, sites: Iterable[Device.Site] = ..., params: Iterable[float] = ...
+        ) -> Iterable[Device.Site] | None:
+            """Returns the list of sites the operation can be performed on."""
+        def mean_shuttling_speed(self, sites: Iterable[Device.Site] = ..., params: Iterable[float] = ...) -> int | None:
+            """Returns the mean shuttling speed of the operation."""
+        def __eq__(self, other: object) -> bool:
+            """Checks if two operations are equal."""
+        def __ne__(self, other: object) -> bool:
+            """Checks if two operations are not equal."""
+
+    def name(self) -> str:
+        """Returns the name of the device."""
+    def version(self) -> str:
+        """Returns the version of the device."""
+    def status(self) -> Device.Status:
+        """Returns the current status of the device."""
+    def library_version(self) -> str:
+        """Returns the version of the library used to define the device."""
+    def qubits_num(self) -> int:
+        """Returns the number of qubits available on the device."""
+    def sites(self) -> Iterable[Site]:
+        """Returns the list of sites available on the device."""
+    def operations(self) -> Iterable[Operation]:
+        """Returns the list of operations supported by the device."""
+    def coupling_map(self) -> Iterable[tuple[Site, Site]] | None:
+        """Returns the coupling map of the device as a list of site pairs."""
+    def needs_calibration(self) -> int | None:
+        """Returns whether the device needs calibration."""
+    def length_unit(self) -> str | None:
+        """Returns the unit of length used by the device."""
+    def length_scale_factor(self) -> float | None:
+        """Returns the scale factor for length used by the device."""
+    def duration_unit(self) -> str | None:
+        """Returns the unit of duration used by the device."""
+    def duration_scale_factor(self) -> float | None:
+        """Returns the scale factor for duration used by the device."""
+    def min_atom_distance(self) -> int | None:
+        """Returns the minimum atom distance on the device."""
+    def __eq__(self, other: object) -> bool:
+        """Checks if two devices are equal."""
+    def __ne__(self, other: object) -> bool:
+        """Checks if two devices are not equal."""
+
+def devices() -> Iterable[Device]:
+    """Returns a list of available devices."""

mqt/core/include/mqt-core/circuit_optimizer/CircuitOptimizer.hpp

@@ -93,6 +93,19 @@ public:
    */
   static void collectBlocks(QuantumComputation& qc, std::size_t maxBlockSize);
 
+  /**
+   * @brief Collects all Clifford blocks in the circuit.
+   * @details The circuit is traversed and all operations that are part of a
+   * Clifford block are collected into a compound operation with a certain
+   * maximum block size. All non-Clifford operations remain untouched.
+   * Light optimizations are applied to the blocks, such as removing identity
+   * gates.
+   * @param qc the quantum circuit
+   * @param maxBlockSize the maximum size of a block
+   */
+  static void collectCliffordBlocks(QuantumComputation& qc,
+                                    std::size_t maxBlockSize);
+
   /**
    * @brief Elide permutations by propagating them through the circuit.
    * @details The circuit is traversed and any SWAP gate is eliminated by

mqt/core/include/mqt-core/dd/CachedEdge.hpp

@@ -160,6 +160,13 @@ template <typename Node> struct CachedEdge {
   }
 };
 
+// Deduction guide for constructor: CachedEdge(Node*, const ComplexValue&)
+template <class Node>
+CachedEdge(Node*, const ComplexValue&) -> CachedEdge<Node>;
+
+// Deduction guide for constructor: CachedEdge(Node*, const Complex&)
+template <class Node> CachedEdge(Node*, const Complex&) -> CachedEdge<Node>;
+
 } // namespace dd
 
 template <class Node> struct std::hash<dd::CachedEdge<Node>> {

mqt/core/include/mqt-core/dd/Operations.hpp

@@ -15,8 +15,8 @@
 #include "dd/Package.hpp"
 #include "ir/Definitions.hpp"
 #include "ir/Permutation.hpp"
-#include "ir/operations/ClassicControlledOperation.hpp"
 #include "ir/operations/Control.hpp"
+#include "ir/operations/IfElseOperation.hpp"
 #include "ir/operations/NonUnitaryOperation.hpp"
 #include "ir/operations/OpType.hpp"
 #include "ir/operations/Operation.hpp"
@@ -181,16 +181,15 @@ VectorDD applyReset(const qc::NonUnitaryOperation& op, VectorDD in, Package& dd,
                     const qc::Permutation& permutation = {});
 
 /**
- * @brief Apply a classic controlled operation to a given DD.
+ * @brief Apply an if-else operation to a given DD.
  *
- * @details This is a convenience function that realizes the classic controlled
- * operation @p op on @p in. It applies the underlying operation if the actual
- * value stored in the measurement results matches the expected value according
- * to the comparison kind. The function correctly accounts for the permutation
- * of the operation's qubits as well as automatically handles reference
- * counting.
+ * @details This is a convenience function that realizes the if-else operation
+ * @p op on @p in. It applies the underlying operation if the actual value
+ * stored in the measurement results matches the expected value according to the
+ * comparison kind. The function correctly accounts for the permutation of the
+ * operation's qubits as well as automatically handles reference counting.
  *
- * @param op The classic controlled operation to apply
+ * @param op The if-else operation to apply
  * @param in The input DD
  * @param dd The DD package to use
  * @param measurements The vector of measurement results
@@ -198,11 +197,10 @@ VectorDD applyReset(const qc::NonUnitaryOperation& op, VectorDD in, Package& dd,
  * empty permutation marks the identity permutation.
  * @return The output DD
  */
-VectorDD
-applyClassicControlledOperation(const qc::ClassicControlledOperation& op,
-                                const VectorDD& in, Package& dd,
-                                const std::vector<bool>& measurements,
-                                const qc::Permutation& permutation = {});
+VectorDD applyIfElseOperation(const qc::IfElseOperation& op, const VectorDD& in,
+                              Package& dd,
+                              const std::vector<bool>& measurements,
+                              const qc::Permutation& permutation = {});
 
 /**
  * @brief Check whether @p op is virtually executable.