mqt-core 3.3.2__cp314-cp314t-macosx_11_0_arm64.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/NonUnitaryOperation.hpp

@@ -0,0 +1,118 @@
+/*
+ * 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/Control.hpp"
+#include "ir/operations/OpType.hpp"
+#include "ir/operations/Operation.hpp"
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <ostream>
+#include <set>
+#include <stdexcept>
+#include <vector>
+
+namespace qc {
+
+class NonUnitaryOperation final : public Operation {
+public:
+  // Measurement constructor
+  NonUnitaryOperation(std::vector<Qubit> qubitRegister,
+                      std::vector<Bit> classicalRegister);
+  NonUnitaryOperation(Qubit qubit, Bit cbit);
+
+  // General constructor
+  explicit NonUnitaryOperation(Targets qubits, OpType op = Reset);
+
+  [[nodiscard]] std::unique_ptr<Operation> clone() const override {
+    return std::make_unique<NonUnitaryOperation>(*this);
+  }
+
+  [[nodiscard]] bool isUnitary() const override { return false; }
+
+  [[nodiscard]] bool isNonUnitaryOperation() const override { return true; }
+
+  [[nodiscard]] const std::vector<Bit>& getClassics() const { return classics; }
+  std::vector<Bit>& getClassics() { return classics; }
+  [[nodiscard]] std::size_t getNclassics() const { return classics.size(); }
+
+  void addDepthContribution(std::vector<std::size_t>& depths) const override;
+
+  void addControl(const Control /*c*/) override {
+    throw std::runtime_error("Cannot add control to non-unitary operation.");
+  }
+
+  void clearControls() override {
+    throw std::runtime_error(
+        "Cannot clear controls from non-unitary operation.");
+  }
+
+  void removeControl(const Control /*c*/) override {
+    throw std::runtime_error(
+        "Cannot remove controls from non-unitary operation.");
+  }
+
+  Controls::iterator removeControl(const Controls::iterator /*it*/) override {
+    throw std::runtime_error(
+        "Cannot remove controls from non-unitary operation.");
+  }
+
+  [[nodiscard]] bool equals(const Operation& op, const Permutation& perm1,
+                            const Permutation& perm2) const override;
+  [[nodiscard]] bool equals(const Operation& operation) const override {
+    return equals(operation, {}, {});
+  }
+
+  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(
+        "Inverting a non-unitary operation is not supported.");
+  }
+
+  void apply(const Permutation& permutation) override;
+
+protected:
+  std::vector<Bit> classics; // vector for the classical bits to measure into
+
+  static void printMeasurement(std::ostream& os, const std::vector<Qubit>& q,
+                               const std::vector<Bit>& c,
+                               const Permutation& permutation,
+                               std::size_t nqubits);
+  void printReset(std::ostream& os, const std::vector<Qubit>& q,
+                  const Permutation& permutation, std::size_t nqubits) const;
+};
+} // namespace qc
+
+template <> struct std::hash<qc::NonUnitaryOperation> {
+  std::size_t operator()(qc::NonUnitaryOperation const& op) const noexcept {
+    std::size_t seed = 0U;
+    qc::hashCombine(seed, op.getType());
+    for (const auto& q : op.getTargets()) {
+      qc::hashCombine(seed, q);
+    }
+    for (const auto& c : op.getClassics()) {
+      qc::hashCombine(seed, c);
+    }
+    return seed;
+  }
+};

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

@@ -0,0 +1,120 @@
+/*
+ * 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 <cstdint>
+#include <istream>
+#include <ostream>
+#include <string>
+#include <string_view>
+
+namespace qc {
+
+enum OpTypeFlags : uint8_t {
+  OpTypeNone = 0b00,
+  OpTypeInv = 0b01,
+  OpTypeDiag = 0b10,
+};
+
+constexpr static unsigned NUM_OP_TYPE_FLAG_BITS = 2;
+
+// Natively supported operations of the MQT Core library
+enum OpType : std::uint8_t {
+#define HANDLE_OP_TYPE(N, id, flags, repr)                                     \
+  id = ((N) << (NUM_OP_TYPE_FLAG_BITS)) | (flags),
+#define LAST_OP_TYPE(N) OpTypeEnd = (N) << (NUM_OP_TYPE_FLAG_BITS),
+#include "OpType.inc"
+
+#undef HANDLE_OP_TYPE
+#undef LAST_OP_TYPE
+};
+
+std::string toString(OpType opType);
+
+/**
+ * @brief Gives a short name for the given OpType (at most 3 characters)
+ * @param opType OpType to get the short name for
+ * @return Short name for the given OpType
+ */
+std::string shortName(OpType opType);
+
+[[nodiscard]] constexpr bool isTwoQubitGate(const OpType opType) {
+  switch (opType) {
+  case SWAP:
+  case iSWAP:
+  case iSWAPdg:
+  case Peres:
+  case Peresdg:
+  case DCX:
+  case ECR:
+  case RXX:
+  case RYY:
+  case RZZ:
+  case RZX:
+  case XXminusYY:
+  case XXplusYY:
+    return true;
+  default:
+    return false;
+  }
+}
+
+/**
+ * @brief Checks if given OpType is a single qubit gate
+ */
+[[nodiscard]] constexpr bool isSingleQubitGate(const OpType type) {
+  switch (type) {
+  case I:
+  case U:
+  case U2:
+  case P:
+  case X:
+  case Y:
+  case Z:
+  case H:
+  case S:
+  case Sdg:
+  case T:
+  case SX:
+  case SXdg:
+  case Tdg:
+  case V:
+  case Vdg:
+  case RX:
+  case RY:
+  case RZ:
+  case R:
+    return true;
+  default:
+    return false;
+  }
+}
+
+inline std::ostream& operator<<(std::ostream& out, const OpType opType) {
+  return out << toString(opType);
+}
+
+[[nodiscard]] OpType opTypeFromString(std::string_view opType);
+
+inline std::istream& operator>>(std::istream& in, OpType& opType) {
+  std::string opTypeStr;
+  in >> opTypeStr;
+
+  if (opTypeStr.empty()) {
+    in.setstate(std::istream::failbit);
+    return in;
+  }
+
+  opType = opTypeFromString(opTypeStr);
+  return in;
+}
+
+} // namespace qc

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

@@ -0,0 +1,76 @@
+/*
+ * 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
+ */
+
+HANDLE_OP_TYPE(0, None, 0, "none")
+
+// Standard Operations
+HANDLE_OP_TYPE(1, GPhase, 0, "gphase")
+HANDLE_OP_TYPE(2, I, OpTypeDiag, "i")
+HANDLE_OP_TYPE(3, Barrier, OpTypeDiag, "barrier")
+HANDLE_OP_TYPE(4, H, OpTypeNone, "h")
+HANDLE_OP_TYPE(5, X, OpTypeNone, "x")
+HANDLE_OP_TYPE(6, Y, OpTypeNone, "y")
+HANDLE_OP_TYPE(7, Z, OpTypeDiag, "z")
+HANDLE_OP_TYPE(8, S, OpTypeDiag, "s")
+HANDLE_OP_TYPE(8, Sdg, OpTypeDiag | OpTypeInv, "sdg")
+HANDLE_OP_TYPE(9, T, OpTypeDiag, "t")
+HANDLE_OP_TYPE(9, Tdg, OpTypeDiag | OpTypeInv, "tdg")
+HANDLE_OP_TYPE(10, V, OpTypeNone, "v")
+HANDLE_OP_TYPE(10, Vdg, OpTypeInv, "vdg")
+HANDLE_OP_TYPE(11, U, OpTypeNone, "u")
+HANDLE_OP_TYPE(12, U2, OpTypeNone, "u2")
+HANDLE_OP_TYPE(13, P, OpTypeDiag, "p")
+HANDLE_OP_TYPE(14, SX, OpTypeNone, "sx")
+HANDLE_OP_TYPE(14, SXdg, OpTypeInv, "sxdg")
+HANDLE_OP_TYPE(15, RX, OpTypeNone, "rx")
+HANDLE_OP_TYPE(16, RY, OpTypeNone, "ry")
+HANDLE_OP_TYPE(17, RZ, OpTypeDiag, "rz")
+HANDLE_OP_TYPE(41, R, OpTypeNone, "r")
+HANDLE_OP_TYPE(18, SWAP, OpTypeNone, "swap")
+HANDLE_OP_TYPE(19, iSWAP, OpTypeNone, "iswap")
+HANDLE_OP_TYPE(19, iSWAPdg, OpTypeInv, "iswapdg")
+HANDLE_OP_TYPE(20, Peres, OpTypeNone, "peres")
+HANDLE_OP_TYPE(20, Peresdg, OpTypeInv, "peresdg")
+HANDLE_OP_TYPE(21, DCX, OpTypeNone, "dcx")
+HANDLE_OP_TYPE(22, ECR, OpTypeNone, "ecr")
+HANDLE_OP_TYPE(23, RXX, OpTypeNone, "rxx")
+HANDLE_OP_TYPE(24, RYY, OpTypeNone, "ryy")
+HANDLE_OP_TYPE(25, RZZ, OpTypeDiag, "rzz")
+HANDLE_OP_TYPE(26, RZX, OpTypeNone, "rzx")
+HANDLE_OP_TYPE(27, XXminusYY, OpTypeNone, "xx_minus_yy")
+HANDLE_OP_TYPE(28, XXplusYY, OpTypeNone, "xx_plus_yy")
+
+// Compound Operation
+HANDLE_OP_TYPE(29, Compound, OpTypeNone, "compound")
+
+// Non Unitary Operations
+HANDLE_OP_TYPE(30, Measure, OpTypeNone, "measure")
+HANDLE_OP_TYPE(31, Reset, OpTypeNone, "reset")
+
+// Control flow operations
+HANDLE_OP_TYPE(32, IfElse, OpTypeNone, "if_else")
+
+// Noise operations
+HANDLE_OP_TYPE(33, ATrue, 0, "a_true")
+HANDLE_OP_TYPE(34, AFalse, 0, "a_false")
+HANDLE_OP_TYPE(35, MultiATrue, 0, "multi_a_true")
+HANDLE_OP_TYPE(36, MultiAFalse, 0, "multi_a_false")
+
+// Neutral atom shuttling operations
+HANDLE_OP_TYPE(37, Move, 0, "move")
+HANDLE_OP_TYPE(38, AodActivate, 0, "aod_activate")
+HANDLE_OP_TYPE(39, AodDeactivate, 0, "aod_deactivate")
+HANDLE_OP_TYPE(40, AodMove, 0, "aod_move")
+
+LAST_OP_TYPE(42)
+
+
+#undef OpTypeInv
+#undef OpTypeDiag