mqt-core 3.2.0__cp312-cp312-win_amd64.whl → 3.3.0__cp312-cp312-win_amd64.whl

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

@@ -0,0 +1,169 @@
+/*
+ * 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/Permutation.hpp"
+#include "ir/Register.hpp"
+#include "ir/operations/Operation.hpp"
+
+#include <memory>
+#include <optional>
+
+namespace qc {
+
+enum ComparisonKind : std::uint8_t {
+  Eq,
+  Neq,
+  Lt,
+  Leq,
+  Gt,
+  Geq,
+};
+
+ComparisonKind getInvertedComparisonKind(ComparisonKind kind);
+
+std::string toString(const ComparisonKind& kind);
+
+std::ostream& operator<<(std::ostream& os, const ComparisonKind& kind);
+
+class IfElseOperation final : public Operation {
+public:
+  IfElseOperation(std::unique_ptr<Operation>&& thenOp,
+                  std::unique_ptr<Operation>&& elseOp,
+                  const ClassicalRegister& controlRegister,
+                  std::uint64_t expectedValue = 1U, ComparisonKind kind = Eq);
+
+  IfElseOperation(std::unique_ptr<Operation>&& thenOp,
+                  std::unique_ptr<Operation>&& elseOp, Bit controlBit,
+                  bool expectedValue = true, ComparisonKind kind = Eq);
+
+  IfElseOperation(const IfElseOperation& op);
+
+  IfElseOperation& operator=(const IfElseOperation& op);
+
+  [[nodiscard]] std::unique_ptr<Operation> clone() const override {
+    return std::make_unique<IfElseOperation>(*this);
+  }
+
+  void apply(const Permutation& permutation) override;
+
+  [[nodiscard]] bool isUnitary() const override { return false; }
+
+  [[nodiscard]] bool isNonUnitaryOperation() const override { return true; }
+
+  [[nodiscard]] bool isIfElseOperation() const noexcept override {
+    return true;
+  }
+
+  [[nodiscard]] bool isControlled() const override { return false; }
+
+  [[nodiscard]] auto getThenOp() const { return thenOp.get(); }
+
+  [[nodiscard]] auto getElseOp() const { return elseOp.get(); }
+
+  [[nodiscard]] const auto& getControlRegister() const noexcept {
+    return controlRegister;
+  }
+
+  [[nodiscard]] const auto& getControlBit() const noexcept {
+    return controlBit;
+  }
+
+  [[nodiscard]] auto getExpectedValueRegister() const noexcept {
+    return expectedValueRegister;
+  }
+
+  [[nodiscard]] bool getExpectedValueBit() const noexcept {
+    return expectedValueBit;
+  }
+
+  [[nodiscard]] auto getComparisonKind() const noexcept {
+    return comparisonKind;
+  }
+
+  [[nodiscard]] bool equals(const Operation& op, const Permutation& perm1,
+                            const Permutation& perm2) const override;
+  [[nodiscard]] bool equals(const Operation& op) const override {
+    return equals(op, {}, {});
+  }
+
+  virtual std::ostream& print(std::ostream& os, const Permutation& permutation,
+                              std::size_t prefixWidth,
+                              std::size_t nqubits) const override;
+
+  void dumpOpenQASM(std::ostream& of, const QubitIndexToRegisterMap& qubitMap,
+                    const BitIndexToRegisterMap& bitMap, std::size_t indent,
+                    bool openQASM3) const override;
+
+  void invert() override {
+    throw std::runtime_error("An IfElseOperation cannot be inverted.");
+  }
+
+  // Override invalid Operation setters
+  void setTargets(const Targets&) override {
+    throw std::runtime_error("An IfElseOperation does not have a target.");
+  }
+
+  void setControls(const Controls&) override {
+    throw std::runtime_error("An IfElseOperation cannot be controlled.");
+  }
+  void addControl(Control) override {
+    throw std::runtime_error("An IfElseOperation cannot be controlled.");
+  }
+  void clearControls() override {
+    throw std::runtime_error("An IfElseOperation cannot be controlled.");
+  }
+  void removeControl(Control) override {
+    throw std::runtime_error("An IfElseOperation cannot be controlled.");
+  }
+  Controls::iterator removeControl(Controls::iterator) override {
+    throw std::runtime_error("An IfElseOperation cannot be controlled.");
+  }
+
+  void setGate(const OpType) override {
+    throw std::runtime_error(
+        "Cannot set operation type of an IfElseOperation.");
+  }
+
+  void setParameter(const std::vector<fp>&) override {
+    throw std::runtime_error("An IfElseOperation cannot be parameterized.");
+  }
+
+private:
+  std::unique_ptr<Operation> thenOp;
+  std::unique_ptr<Operation> elseOp;
+  std::optional<ClassicalRegister> controlRegister;
+  std::optional<Bit> controlBit;
+  std::uint64_t expectedValueRegister = 1U;
+  bool expectedValueBit = true;
+  ComparisonKind comparisonKind = Eq;
+
+  /**
+   * @brief Canonicalizes the IfElseOperation
+   * @details Ensures if an else block is present, the then block is also
+   * present. If only the else block is present, it is moved to the then block
+   * and the else block is set to null with the condition inverted.
+   * Furthermore, non-equality constraints on single bits are converted to
+   * equality constraints with inverted expected value.
+   * Finally, if both then and else blocks are present, any equality constraint
+   * on a single bit with expected value false is converted to an equality
+   * constraint with expected value true with then and else blocks swapped.
+   */
+  void canonicalize();
+};
+} // namespace qc
+
+namespace std {
+template <> struct hash<qc::IfElseOperation> {
+  std::size_t operator()(qc::IfElseOperation const& op) const noexcept;
+};
+} // namespace std

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

@@ -66,6 +66,9 @@ std::string shortName(OpType opType);
   }
 }
 
+/**
+ * @brief Checks if given OpType is a single qubit gate
+ */
 [[nodiscard]] constexpr bool isSingleQubitGate(const OpType type) {
   switch (type) {
   case I:

mqt/core/include/mqt-core/ir/operations/OpType.inc

@@ -53,8 +53,8 @@ HANDLE_OP_TYPE(29, Compound, OpTypeNone, "compound")
 HANDLE_OP_TYPE(30, Measure, OpTypeNone, "measure")
 HANDLE_OP_TYPE(31, Reset, OpTypeNone, "reset")
 
-// Classically-controlled Operation
-HANDLE_OP_TYPE(32, ClassicControlled, OpTypeNone, "classic_controlled")
+// Control flow operations
+HANDLE_OP_TYPE(32, IfElse, OpTypeNone, "if_else")
 
 // Noise operations
 HANDLE_OP_TYPE(33, ATrue, 0, "a_true")

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

@@ -138,7 +138,7 @@ public:
 
   [[nodiscard]] virtual bool isNonUnitaryOperation() const { return false; }
 
-  [[nodiscard]] virtual bool isClassicControlledOperation() const noexcept {
+  [[nodiscard]] virtual bool isIfElseOperation() const noexcept {
     return false;
   }
 
@@ -155,6 +155,8 @@ public:
 
   [[nodiscard]] virtual bool isControlled() const { return !controls.empty(); }
 
+  [[nodiscard]] virtual bool isClifford() const { return false; }
+
   /**
    * @brief Checks whether a gate is global.
    * @details A StandardOperation is global if it acts on all qubits.

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

@@ -82,6 +82,8 @@ public:
 
   [[nodiscard]] bool isGlobal(size_t nQubits) const override;
 
+  [[nodiscard]] bool isClifford() const override;
+
   void addControl(const Control c) override {
     if (actsOn(c.qubit)) {
       throw std::runtime_error("Cannot add control on qubit " +