mqt-core 3.3.2__cp313-cp313t-win_amd64.whl

mqt/core/include/mqt-core/ir/Register.hpp

@@ -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
+ */
+
+#pragma once
+
+#include "Definitions.hpp"
+
+#include <cstddef>
+#include <functional>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+namespace qc {
+
+template <typename BitType> class Register {
+public:
+  Register(const BitType regStartIndex, const std::size_t regSize,
+           std::string regName)
+      : startIndex(regStartIndex), size(regSize), name(std::move(regName)) {}
+  virtual ~Register() = default;
+
+  [[nodiscard]] const std::string& getName() const noexcept { return name; }
+  [[nodiscard]] std::size_t getSize() const noexcept { return size; }
+  [[nodiscard]] std::size_t& getSize() noexcept { return size; }
+  [[nodiscard]] BitType getStartIndex() const noexcept { return startIndex; }
+  [[nodiscard]] BitType& getStartIndex() noexcept { return startIndex; }
+  [[nodiscard]] BitType getEndIndex() const noexcept {
+    return static_cast<BitType>(startIndex + size - 1);
+  }
+
+  [[nodiscard]] bool operator==(const Register& other) const {
+    return name == other.name && size == other.size;
+  }
+  [[nodiscard]] bool operator!=(const Register& other) const {
+    return !(*this == other);
+  }
+
+  [[nodiscard]] bool contains(const BitType index) const {
+    return startIndex <= index && index < startIndex + size;
+  }
+
+  [[nodiscard]] BitType getLocalIndex(const BitType globalIndex) const {
+    if (!contains(globalIndex)) {
+      throw std::out_of_range("Index out of range");
+    }
+    return globalIndex - startIndex;
+  }
+
+  [[nodiscard]] BitType getGlobalIndex(const BitType localIndex) const {
+    if (localIndex >= size) {
+      throw std::out_of_range("Index out of range");
+    }
+    return startIndex + localIndex;
+  }
+
+  [[nodiscard]] std::string toString(const BitType globalIndex) const {
+    return name + "[" + std::to_string(getLocalIndex(globalIndex)) + "]";
+  }
+
+  [[nodiscard]] BitType operator[](const BitType localIndex) const {
+    return getGlobalIndex(localIndex);
+  }
+
+private:
+  BitType startIndex;
+  std::size_t size;
+  std::string name;
+};
+
+class QuantumRegister final : public Register<Qubit> {
+public:
+  QuantumRegister(const Qubit regStartIndex, const std::size_t regSize,
+                  const std::string& regName = "")
+      : Register(regStartIndex, regSize,
+                 regName.empty() ? generateName() : regName) {}
+
+protected:
+  static std::string generateName() {
+    static std::size_t counter = 0;
+    return "q" + std::to_string(counter++);
+  }
+};
+
+using QubitIndexToRegisterMap =
+    std::unordered_map<Qubit, std::pair<const QuantumRegister&, std::string>>;
+
+class ClassicalRegister final : public Register<Bit> {
+public:
+  ClassicalRegister(const Bit regStartIndex, const std::size_t regSize,
+                    const std::string& regName = "")
+      : Register(regStartIndex, regSize,
+                 regName.empty() ? generateName() : regName) {}
+
+protected:
+  static std::string generateName() {
+    static std::size_t counter = 0;
+    return "c" + std::to_string(counter++);
+  }
+};
+
+using BitIndexToRegisterMap =
+    std::unordered_map<Bit, std::pair<const ClassicalRegister&, std::string>>;
+
+} // namespace qc
+
+template <> struct std::hash<qc::QuantumRegister> {
+  std::size_t operator()(const qc::QuantumRegister& reg) const noexcept {
+    return qc::combineHash(reg.getStartIndex(), reg.getSize());
+  }
+};
+
+template <> struct std::hash<qc::ClassicalRegister> {
+  std::size_t operator()(const qc::ClassicalRegister& reg) const noexcept {
+    return qc::combineHash(reg.getStartIndex(), reg.getSize());
+  }
+};

mqt/core/include/mqt-core/ir/mqt_core_ir_export.h

@@ -0,0 +1,43 @@
+
+#ifndef MQT_CORE_IR_EXPORT_H
+#define MQT_CORE_IR_EXPORT_H
+
+#ifdef MQT_CORE_IR_STATIC_DEFINE
+#  define MQT_CORE_IR_EXPORT
+#  define MQT_CORE_IR_NO_EXPORT
+#else
+#  ifndef MQT_CORE_IR_EXPORT
+#    ifdef mqt_core_ir_EXPORTS
+        /* We are building this library */
+#      define MQT_CORE_IR_EXPORT __declspec(dllexport)
+#    else
+        /* We are using this library */
+#      define MQT_CORE_IR_EXPORT __declspec(dllimport)
+#    endif
+#  endif
+
+#  ifndef MQT_CORE_IR_NO_EXPORT
+#    define MQT_CORE_IR_NO_EXPORT 
+#  endif
+#endif
+
+#ifndef MQT_CORE_IR_DEPRECATED
+#  define MQT_CORE_IR_DEPRECATED __declspec(deprecated)
+#endif
+
+#ifndef MQT_CORE_IR_DEPRECATED_EXPORT
+#  define MQT_CORE_IR_DEPRECATED_EXPORT MQT_CORE_IR_EXPORT MQT_CORE_IR_DEPRECATED
+#endif
+
+#ifndef MQT_CORE_IR_DEPRECATED_NO_EXPORT
+#  define MQT_CORE_IR_DEPRECATED_NO_EXPORT MQT_CORE_IR_NO_EXPORT MQT_CORE_IR_DEPRECATED
+#endif
+
+/* NOLINTNEXTLINE(readability-avoid-unconditional-preprocessor-if) */
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef MQT_CORE_IR_NO_DEPRECATED
+#    define MQT_CORE_IR_NO_DEPRECATED
+#  endif
+#endif
+
+#endif /* MQT_CORE_IR_EXPORT_H */

mqt/core/include/mqt-core/ir/operations/AodOperation.hpp

@@ -0,0 +1,92 @@
+/*
+ * 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
+ */
+
+#pragma once
+
+#include "ir/Definitions.hpp"
+#include "ir/Register.hpp"
+#include "ir/operations/Control.hpp"
+#include "ir/operations/OpType.hpp"
+#include "ir/operations/Operation.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace na {
+
+enum class Dimension : std::uint8_t { X = 0, Y = 1 };
+struct SingleOperation {
+  Dimension dir;
+  qc::fp start;
+  qc::fp end;
+
+  SingleOperation(const Dimension d, const qc::fp s, const qc::fp e)
+      : dir(d), start(s), end(e) {}
+
+  [[nodiscard]] std::string toQASMString() const;
+};
+class AodOperation final : public qc::Operation {
+  std::vector<SingleOperation> operations;
+
+  static std::vector<Dimension>
+  convertToDimension(const std::vector<uint32_t>& dirs);
+
+public:
+  AodOperation() = default;
+  AodOperation(qc::OpType s, std::vector<qc::Qubit> qubits,
+               const std::vector<Dimension>& dirs,
+               const std::vector<qc::fp>& starts,
+               const std::vector<qc::fp>& ends);
+  AodOperation(qc::OpType s, std::vector<qc::Qubit> qubits,
+               const std::vector<uint32_t>& dirs,
+               const std::vector<qc::fp>& starts,
+               const std::vector<qc::fp>& ends);
+  AodOperation(const std::string& typeName, std::vector<qc::Qubit> qubits,
+               const std::vector<uint32_t>& dirs,
+               const std::vector<qc::fp>& starts,
+               const std::vector<qc::fp>& ends);
+  AodOperation(qc::OpType s, std::vector<qc::Qubit> qubits,
+               const std::vector<std::tuple<Dimension, qc::fp, qc::fp>>& ops);
+  AodOperation(qc::OpType type, std::vector<qc::Qubit> targets,
+               std::vector<SingleOperation> operations);
+
+  [[nodiscard]] std::unique_ptr<Operation> clone() const override {
+    return std::make_unique<AodOperation>(*this);
+  }
+
+  void addControl([[maybe_unused]] qc::Control c) override {}
+  void clearControls() override {}
+  void removeControl([[maybe_unused]] qc::Control c) override {}
+  qc::Controls::iterator
+  removeControl(const qc::Controls::iterator it) override {
+    return controls.erase(it);
+  }
+
+  [[nodiscard]] std::vector<qc::fp> getEnds(Dimension dir) const;
+
+  [[nodiscard]] std::vector<qc::fp> getStarts(Dimension dir) const;
+
+  [[nodiscard]] qc::fp getMaxDistance(Dimension dir) const;
+
+  [[nodiscard]] std::vector<qc::fp> getDistances(Dimension dir) const;
+
+  void dumpOpenQASM(std::ostream& of,
+                    const qc::QubitIndexToRegisterMap& qubitMap,
+                    const qc::BitIndexToRegisterMap& bitMap, std::size_t indent,
+                    bool openQASM3) const override;
+
+  void invert() override;
+};
+} // namespace na

mqt/core/include/mqt-core/ir/operations/CompoundOperation.hpp

@@ -0,0 +1,212 @@
+/*
+ * 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
+ */
+
+#pragma once
+
+#include "Control.hpp"
+#include "Operation.hpp"
+#include "ir/Definitions.hpp"
+#include "ir/Permutation.hpp"
+#include "ir/Register.hpp"
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <ostream>
+#include <set>
+#include <vector>
+
+namespace qc {
+
+class CompoundOperation final : public Operation {
+public:
+  using iterator = std::vector<std::unique_ptr<Operation>>::iterator;
+  using const_iterator =
+      std::vector<std::unique_ptr<Operation>>::const_iterator;
+
+private:
+  std::vector<std::unique_ptr<Operation>> ops;
+  bool customGate;
+
+public:
+  explicit CompoundOperation(bool isCustom = false);
+
+  explicit CompoundOperation(
+      std::vector<std::unique_ptr<Operation>>&& operations,
+      bool isCustom = false);
+
+  CompoundOperation(const CompoundOperation& co);
+
+  CompoundOperation& operator=(const CompoundOperation& co);
+
+  [[nodiscard]] std::unique_ptr<Operation> clone() const override;
+
+  [[nodiscard]] size_t getNqubits() const override;
+
+  [[nodiscard]] bool isCompoundOperation() const noexcept override;
+
+  [[nodiscard]] bool isNonUnitaryOperation() const override;
+
+  [[nodiscard]] bool isSymbolicOperation() const override;
+
+  [[nodiscard]] bool isCustomGate() const noexcept;
+
+  [[nodiscard]] bool isGlobal(size_t nQubits) const noexcept override;
+
+  [[nodiscard]] bool isClifford() const override;
+
+  void addControl(Control c) override;
+
+  void clearControls() override;
+
+  void removeControl(Control c) override;
+
+  Controls::iterator removeControl(Controls::iterator it) override;
+
+  [[nodiscard]] bool equals(const Operation& op, const Permutation& perm1,
+                            const Permutation& perm2) const override;
+  [[nodiscard]] bool equals(const Operation& operation) const override;
+
+  std::ostream& print(std::ostream& os, const Permutation& permutation,
+                      std::size_t prefixWidth,
+                      std::size_t nqubits) const override;
+
+  [[nodiscard]] bool actsOn(Qubit i) const override;
+
+  void addDepthContribution(std::vector<std::size_t>& depths) const override;
+
+  void dumpOpenQASM(std::ostream& of, const QubitIndexToRegisterMap& qubitMap,
+                    const BitIndexToRegisterMap& bitMap, std::size_t indent,
+                    bool openQASM3) const override;
+
+  std::vector<std::unique_ptr<Operation>>& getOps() noexcept { return ops; }
+
+  [[nodiscard]] auto getUsedQubitsPermuted(const Permutation& perm) const
+      -> std::set<Qubit> override;
+
+  [[nodiscard]] auto commutesAtQubit(const Operation& other,
+                                     const Qubit& qubit) const -> bool override;
+
+  /**
+   * This refines the inherited method because the inherited method leads to
+   * false negatives
+   */
+  [[nodiscard]] auto isInverseOf(const Operation& other) const -> bool override;
+
+  void invert() override;
+
+  void apply(const Permutation& permutation) override;
+
+  /**
+   * @brief Merge another compound operation into this one.
+   * @details This transfers ownership of the operations from the other compound
+   * operation to this one. The other compound operation will be empty after
+   * this operation.
+   * @param op the compound operation to merge into this one
+   */
+  void merge(CompoundOperation& op);
+
+  /**
+   * @brief Check whether this operation can be collapsed into a single
+   * operation.
+   * @return true if this operation can be collapsed into a single operation,
+   * false otherwise
+   */
+  [[nodiscard]] bool isConvertibleToSingleOperation() const;
+
+  /**
+   * @brief Collapse this operation into a single operation.
+   * @details This operation must be convertible to a single operation.
+   * @return the collapsed operation
+   */
+  [[nodiscard]] std::unique_ptr<Operation> collapseToSingleOperation();
+
+  /**
+   * Pass-Through
+   */
+
+  // Iterators (pass-through)
+  auto begin() noexcept { return ops.begin(); }
+  [[nodiscard]] auto begin() const noexcept { return ops.begin(); }
+  [[nodiscard]] auto cbegin() const noexcept { return ops.cbegin(); }
+  auto end() noexcept { return ops.end(); }
+  [[nodiscard]] auto end() const noexcept { return ops.end(); }
+  [[nodiscard]] auto cend() const noexcept { return ops.cend(); }
+  auto rbegin() noexcept { return ops.rbegin(); }
+  [[nodiscard]] auto rbegin() const noexcept { return ops.rbegin(); }
+  [[nodiscard]] auto crbegin() const noexcept { return ops.crbegin(); }
+  auto rend() noexcept { return ops.rend(); }
+  [[nodiscard]] auto rend() const noexcept { return ops.rend(); }
+  [[nodiscard]] auto crend() const noexcept { return ops.crend(); }
+
+  // Capacity (pass-through)
+  [[nodiscard]] bool empty() const noexcept { return ops.empty(); }
+  [[nodiscard]] std::size_t size() const noexcept { return ops.size(); }
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  [[nodiscard]] std::size_t max_size() const noexcept { return ops.max_size(); }
+  [[nodiscard]] std::size_t capacity() const noexcept { return ops.capacity(); }
+
+  void reserve(const std::size_t newCap) { ops.reserve(newCap); }
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  void shrink_to_fit() { ops.shrink_to_fit(); }
+
+  // Modifiers (pass-through)
+  void clear() noexcept { ops.clear(); }
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  void pop_back() { ops.pop_back(); }
+  void resize(const std::size_t count) { ops.resize(count); }
+  iterator erase(const const_iterator pos) { return ops.erase(pos); }
+  iterator erase(const const_iterator first, const const_iterator last) {
+    return ops.erase(first, last);
+  }
+
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  template <class T, class... Args> void emplace_back(Args&&... args) {
+    ops.emplace_back(std::make_unique<T>(std::forward<Args>(args)...));
+  }
+
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  template <class T> void emplace_back(std::unique_ptr<T>& op) {
+    ops.emplace_back(std::move(op));
+  }
+
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  template <class T> void emplace_back(std::unique_ptr<T>&& op) {
+    ops.emplace_back(std::move(op));
+  }
+
+  template <class T, class... Args>
+  iterator insert(const_iterator iter, Args&&... args) {
+    return ops.insert(iter, std::make_unique<T>(std::forward<Args>(args)...));
+  }
+  template <class T>
+  iterator insert(const_iterator iter, std::unique_ptr<T>& op) {
+    return ops.insert(iter, std::move(op));
+  }
+  template <class T> iterator insert(const_iterator iter, T&& op) {
+    return ops.insert(iter, std::forward<decltype(op)>(op));
+  }
+
+  // Element access (pass-through)
+  [[nodiscard]] const auto& at(const std::size_t i) const { return ops.at(i); }
+  [[nodiscard]] auto& operator[](const std::size_t i) { return ops[i]; }
+  [[nodiscard]] const auto& operator[](const std::size_t i) const {
+    return ops[i];
+  }
+  [[nodiscard]] auto& front() { return ops.front(); }
+  [[nodiscard]] const auto& front() const { return ops.front(); }
+  [[nodiscard]] auto& back() { return ops.back(); }
+  [[nodiscard]] const auto& back() const { return ops.back(); }
+};
+} // namespace qc
+
+template <> struct std::hash<qc::CompoundOperation> {
+  std::size_t operator()(const qc::CompoundOperation& co) const noexcept;
+}; // namespace std

mqt/core/include/mqt-core/ir/operations/Control.hpp

@@ -0,0 +1,142 @@
+/*
+ * 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
+ */
+
+/** @file
+ * @brief Defines a type for control qubits and some related functionality.
+ */
+
+#pragma once
+
+#include "ir/Definitions.hpp"
+
+#include <cstddef>
+#include <functional>
+#include <set>
+#include <sstream>
+#include <string>
+
+namespace qc {
+/// Represents a control qubit as a qubit index and a control type.
+struct Control {
+  /// The polarity of the control.
+  enum class Type : bool {
+    /// Positive controls trigger on \f$\ket{1}\f$.
+    Pos = true,
+    /// Negative controls trigger on \f$\ket{0}\f$.
+    Neg = false
+  };
+
+  /// The qubit that acts as a control.
+  Qubit qubit{};
+  /// The type of the control.
+  Type type = Type::Pos;
+
+  /// Get a string representation of the control.
+  [[nodiscard]] std::string toString() const {
+    std::ostringstream oss{};
+    oss << "Control(qubit=" << qubit << ", type_=\"";
+    if (type == Type::Pos) {
+      oss << "Pos";
+    } else {
+      oss << "Neg";
+    }
+    oss << "\")";
+    return oss.str();
+  }
+
+  // Explicitly allow implicit conversion from `Qubit` to `Control`
+  // NOLINTBEGIN(google-explicit-constructor)
+  /**
+   * @brief Construct a control qubit.
+   * @param q The qubit that acts as a control.
+   * @param t The type of the control. Defaults to `Type::Pos`.
+   * @note This constructor is not `explicit` to allow implicit conversion from
+   *       `Qubit` to `Control`.
+   */
+  Control(const Qubit q = {}, const Type t = Type::Pos) : qubit(q), type(t) {}
+  // NOLINTEND(google-explicit-constructor)
+};
+
+/// Defines the order of controls based on their qubit index and type.
+inline bool operator<(const Control& lhs, const Control& rhs) {
+  return lhs.qubit < rhs.qubit ||
+         (lhs.qubit == rhs.qubit && lhs.type < rhs.type);
+}
+
+/// operator== overload for `Control`
+inline bool operator==(const Control& lhs, const Control& rhs) {
+  return lhs.qubit == rhs.qubit && lhs.type == rhs.type;
+}
+
+/// operator!= overload for `Control`
+inline bool operator!=(const Control& lhs, const Control& rhs) {
+  return !(lhs == rhs);
+}
+
+/// Allows a set of @ref Control to be indexed by a `Qubit`
+struct CompareControl {
+  using is_transparent [[maybe_unused]] = void;
+
+  bool operator()(const Control& lhs, const Control& rhs) const {
+    return lhs < rhs;
+  }
+
+  bool operator()(const Qubit lhs, const Control& rhs) const {
+    return lhs < rhs.qubit;
+  }
+
+  bool operator()(const Control& lhs, const Qubit rhs) const {
+    return lhs.qubit < rhs;
+  }
+};
+
+/// Type alias for a set of control qubits.
+using Controls = std::set<Control, CompareControl>;
+
+/**
+ * @brief Inline namespace for control literals.
+ * @details Use `using namespace qc::literals` to enable the literals.
+ */
+inline namespace literals {
+// User-defined literals require unsigned long long int
+// NOLINTBEGIN(google-runtime-int)
+
+/**
+ * @brief User-defined literal for positive control qubits.
+ * @details This literal allows to create a positive control qubit from an
+ *          unsigned integer, for example as `0_pc`.
+ * @param q Index of the qubit that acts as a control.
+ * @return A positive control qubit.
+ */
+inline Control operator""_pc(const unsigned long long int q) {
+  return {static_cast<Qubit>(q)};
+}
+
+/**
+ * @brief User-defined literal for negative control qubits.
+ * @details This literal allows to create a negative control qubit from an
+ *          unsigned integer, for example as `0_nc`.
+ * @param q Index of the qubit that acts as a control.
+ * @return A negative control qubit.
+ */
+inline Control operator""_nc(const unsigned long long int q) {
+  return {static_cast<Qubit>(q), Control::Type::Neg};
+}
+// NOLINTEND(google-runtime-int)
+} // namespace literals
+} // namespace qc
+
+/// Hash function for `Control`
+template <> struct std::hash<qc::Control> {
+  std::size_t operator()(const qc::Control& c) const noexcept {
+    return std::hash<qc::Qubit>{}(c.qubit) ^
+           std::hash<qc::Control::Type>{}(c.type);
+  }
+};