mqt-core 3.3.2__cp314-cp314t-macosx_11_0_arm64.whl

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

@@ -0,0 +1,247 @@
+/*
+ * 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 <cstring>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+namespace qc {
+class Operation {
+protected:
+  Controls controls;
+  Targets targets;
+  std::vector<fp> parameter;
+
+  OpType type = None;
+  std::string name;
+
+  static constexpr size_t OUTPUT_INDENT_SIZE = 2;
+
+  static bool isWholeQubitRegister(const QubitIndexToRegisterMap& regMap,
+                                   const Qubit start, const Qubit end) {
+    const auto& startReg = regMap.at(start).first;
+    const auto& endReg = regMap.at(end).first;
+    return startReg == endReg && startReg.getStartIndex() == start &&
+           endReg.getEndIndex() == end;
+  }
+
+public:
+  Operation() = default;
+  Operation(const Operation& op) = default;
+  Operation(Operation&& op) noexcept = default;
+  Operation& operator=(const Operation& op) = default;
+  Operation& operator=(Operation&& op) noexcept = default;
+
+  // Virtual Destructor
+  virtual ~Operation() = default;
+
+  [[nodiscard]] virtual std::unique_ptr<Operation> clone() const = 0;
+
+  // Getters
+  [[nodiscard]] virtual const Targets& getTargets() const { return targets; }
+  virtual Targets& getTargets() { return targets; }
+  [[nodiscard]] virtual std::size_t getNtargets() const {
+    return targets.size();
+  }
+
+  [[nodiscard]] virtual const Controls& getControls() const { return controls; }
+  virtual Controls& getControls() { return controls; }
+  [[nodiscard]] virtual std::size_t getNcontrols() const {
+    return controls.size();
+  }
+  [[nodiscard]] virtual std::size_t getNqubits() const {
+    return getNcontrols() + getNtargets();
+  }
+
+  [[nodiscard]] const std::vector<fp>& getParameter() const {
+    return parameter;
+  }
+  std::vector<fp>& getParameter() { return parameter; }
+
+  [[nodiscard]] const std::string& getName() const { return name; }
+  [[nodiscard]] virtual OpType getType() const { return type; }
+
+  [[nodiscard]] virtual auto
+  getUsedQubitsPermuted(const Permutation& perm) const -> std::set<Qubit>;
+
+  [[nodiscard]] auto getUsedQubits() const -> std::set<Qubit>;
+
+  [[nodiscard]] std::unique_ptr<Operation> getInverted() const {
+    auto op = clone();
+    op->invert();
+    return op;
+  }
+
+  // Setter
+  virtual void setTargets(const Targets& t) { targets = t; }
+
+  virtual void setControls(const Controls& c) {
+    clearControls();
+    addControls(c);
+  }
+
+  virtual void addControl(Control c) = 0;
+
+  void addControls(const Controls& c) {
+    for (const auto& control : c) {
+      addControl(control);
+    }
+  }
+
+  virtual void clearControls() = 0;
+
+  virtual void removeControl(Control c) = 0;
+
+  virtual Controls::iterator removeControl(Controls::iterator it) = 0;
+
+  void removeControls(const Controls& c) {
+    for (auto it = c.begin(); it != c.end();) {
+      it = removeControl(it);
+    }
+  }
+
+  virtual void setGate(const OpType g) {
+    type = g;
+    name = toString(g);
+  }
+
+  virtual void setParameter(const std::vector<fp>& p) { parameter = p; }
+
+  virtual void apply(const Permutation& permutation);
+
+  [[nodiscard]] virtual bool isUnitary() const { return true; }
+
+  [[nodiscard]] virtual bool isStandardOperation() const { return false; }
+
+  [[nodiscard]] virtual bool isCompoundOperation() const noexcept {
+    return false;
+  }
+
+  [[nodiscard]] virtual bool isNonUnitaryOperation() const { return false; }
+
+  [[nodiscard]] virtual bool isIfElseOperation() const noexcept {
+    return false;
+  }
+
+  [[nodiscard]] virtual bool isSymbolicOperation() const { return false; }
+
+  [[nodiscard]] virtual auto isDiagonalGate() const -> bool {
+    // the second bit in the type is a flag that is set for diagonal gates
+    return (+type & OpTypeDiag) != 0;
+  }
+
+  [[nodiscard]] virtual auto isSingleQubitGate() const -> bool {
+    return !isControlled() && qc::isSingleQubitGate(type);
+  }
+
+  [[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.
+   * A CompoundOperation is global if all its sub-operations are
+   * StandardOperations of the same type with the same parameters acting on all
+   * qubits. The latter is what a QASM line like `ry(π) q;` is translated to in
+   * MQT Core. All other operations are not global.
+   * @return True if the operation is global, false otherwise.
+   */
+  [[nodiscard]] virtual bool isGlobal(size_t /* unused */) const {
+    return false;
+  }
+
+  [[nodiscard]] virtual bool actsOn(const Qubit i) const {
+    for (const auto& t : targets) {
+      if (t == i) {
+        return true;
+      }
+    }
+    return controls.count(i) > 0;
+  }
+
+  virtual void addDepthContribution(std::vector<std::size_t>& depths) const;
+
+  [[nodiscard]] virtual bool equals(const Operation& op,
+                                    const Permutation& perm1,
+                                    const Permutation& perm2) const;
+  [[nodiscard]] virtual bool equals(const Operation& op) const {
+    return equals(op, {}, {});
+  }
+
+  virtual std::ostream& printParameters(std::ostream& os) const;
+  std::ostream& print(std::ostream& os, const std::size_t nqubits) const {
+    return print(os, {}, 0, nqubits);
+  }
+  virtual std::ostream& print(std::ostream& os, const Permutation& permutation,
+                              std::size_t prefixWidth,
+                              std::size_t nqubits) const;
+
+  void dumpOpenQASM2(std::ostream& of, const QubitIndexToRegisterMap& qubitMap,
+                     const BitIndexToRegisterMap& bitMap) const {
+    dumpOpenQASM(of, qubitMap, bitMap, 0, false);
+  }
+  void dumpOpenQASM3(std::ostream& of, const QubitIndexToRegisterMap& qubitMap,
+                     const BitIndexToRegisterMap& bitMap) const {
+    dumpOpenQASM(of, qubitMap, bitMap, 0, true);
+  }
+  virtual void dumpOpenQASM(std::ostream& of,
+                            const QubitIndexToRegisterMap& qubitMap,
+                            const BitIndexToRegisterMap& bitMap, size_t indent,
+                            bool openQASM3) const = 0;
+
+  /// Checks whether operation commutes with other operation on a given qubit.
+  [[nodiscard]] virtual auto commutesAtQubit(const Operation& /*other*/,
+                                             const Qubit& /*qubit*/) const
+      -> bool {
+    return false;
+  }
+
+  [[nodiscard]] virtual auto isInverseOf(const Operation& /*other*/) const
+      -> bool;
+
+  virtual void invert() = 0;
+
+  virtual bool operator==(const Operation& rhs) const { return equals(rhs); }
+  bool operator!=(const Operation& rhs) const { return !(*this == rhs); }
+};
+} // namespace qc
+
+template <> struct std::hash<qc::Operation> {
+  std::size_t operator()(const qc::Operation& op) const noexcept {
+    std::size_t seed = 0U;
+    qc::hashCombine(seed, hash<qc::OpType>{}(op.getType()));
+    for (const auto& control : op.getControls()) {
+      qc::hashCombine(seed, hash<qc::Qubit>{}(control.qubit));
+      if (control.type == qc::Control::Type::Neg) {
+        seed ^= 1ULL;
+      }
+    }
+    for (const auto& target : op.getTargets()) {
+      qc::hashCombine(seed, hash<qc::Qubit>{}(target));
+    }
+    for (const auto& param : op.getParameter()) {
+      qc::hashCombine(seed, hash<qc::fp>{}(param));
+    }
+    return seed;
+  }
+};

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

@@ -0,0 +1,140 @@
+/*
+ * 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 <cmath>
+#include <cstddef>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace qc {
+class StandardOperation : public Operation {
+protected:
+  constexpr static fp PARAMETER_TOLERANCE = 1e-13;
+
+  static void checkInteger(fp& ld) {
+    const fp nearest = std::nearbyint(ld);
+    if (std::abs(ld - nearest) < PARAMETER_TOLERANCE) {
+      ld = nearest;
+    }
+  }
+
+  static void checkFractionPi(fp& ld) {
+    const fp div = PI / ld;
+    const fp nearest = std::nearbyint(div);
+    if (std::abs(div - nearest) < PARAMETER_TOLERANCE) {
+      ld = PI / nearest;
+    }
+  }
+
+  OpType parseU3(fp& theta, fp& phi, fp& lambda);
+  OpType parseU2(fp& phi, fp& lambda);
+  OpType parseU1(fp& lambda);
+
+  void checkUgate();
+  void setup();
+
+public:
+  StandardOperation() = default;
+
+  // Standard Constructors
+  StandardOperation(Qubit target, OpType g, std::vector<fp> params = {});
+  StandardOperation(const Targets& targ, OpType g, std::vector<fp> params = {});
+
+  StandardOperation(Control control, Qubit target, OpType g,
+                    const std::vector<fp>& params = {});
+  StandardOperation(Control control, const Targets& targ, OpType g,
+                    const std::vector<fp>& params = {});
+
+  StandardOperation(const Controls& c, Qubit target, OpType g,
+                    const std::vector<fp>& params = {});
+  StandardOperation(const Controls& c, const Targets& targ, OpType g,
+                    const std::vector<fp>& params = {});
+
+  // MCF (cSWAP), Peres, parameterized two target Constructor
+  StandardOperation(const Controls& c, Qubit target0, Qubit target1, OpType g,
+                    const std::vector<fp>& params = {});
+
+  [[nodiscard]] std::unique_ptr<Operation> clone() const override {
+    return std::make_unique<StandardOperation>(*this);
+  }
+
+  [[nodiscard]] bool isStandardOperation() const override { return true; }
+
+  [[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 " +
+                               std::to_string(c.qubit) +
+                               " to operation it already acts on the qubit.");
+    }
+
+    controls.emplace(c);
+  }
+
+  void clearControls() override { controls.clear(); }
+
+  void removeControl(const Control c) override {
+    if (controls.erase(c) == 0) {
+      throw std::runtime_error("Cannot remove control on qubit " +
+                               std::to_string(c.qubit) +
+                               " from operation as it is not a control.");
+    }
+  }
+
+  Controls::iterator removeControl(const Controls::iterator it) override {
+    return controls.erase(it);
+  }
+
+  [[nodiscard]] bool equals(const Operation& op, const Permutation& perm1,
+                            const Permutation& perm2) const override {
+    return Operation::equals(op, perm1, perm2);
+  }
+  [[nodiscard]] bool equals(const Operation& operation) const override {
+    return equals(operation, {}, {});
+  }
+
+  void dumpOpenQASM(std::ostream& of, const QubitIndexToRegisterMap& qubitMap,
+                    const BitIndexToRegisterMap& bitMap, size_t indent,
+                    bool openQASM3) const override;
+
+  [[nodiscard]] auto commutesAtQubit(const Operation& other,
+                                     const Qubit& qubit) const -> bool override;
+
+  void invert() override;
+
+protected:
+  void dumpOpenQASM2(std::ostream& of, std::ostringstream& op,
+                     const QubitIndexToRegisterMap& qubitMap) const;
+  void dumpOpenQASM3(std::ostream& of, std::ostringstream& op,
+                     const QubitIndexToRegisterMap& qubitMap) const;
+
+  void dumpGateType(std::ostream& of, std::ostringstream& op,
+                    const QubitIndexToRegisterMap& qubitMap) const;
+
+  void dumpControls(std::ostringstream& op) const;
+};
+
+} // namespace qc

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

@@ -0,0 +1,144 @@
+/*
+ * 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/Expression.hpp"
+#include "ir/operations/OpType.hpp"
+#include "ir/operations/Operation.hpp"
+#include "ir/operations/StandardOperation.hpp"
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <variant>
+#include <vector>
+
+namespace qc {
+
+class SymbolicOperation final : public StandardOperation {
+public:
+  SymbolicOperation() = default;
+
+  [[nodiscard]] SymbolOrNumber getParameter(std::size_t i) const;
+
+  [[nodiscard]] std::vector<SymbolOrNumber> getParameters() const;
+
+  void setSymbolicParameter(const Symbolic& par, const std::size_t i) {
+    symbolicParameter.at(i) = par;
+  }
+
+  // Standard Constructors
+  SymbolicOperation(Qubit target, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+  SymbolicOperation(const Targets& targ, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+
+  SymbolicOperation(Control control, Qubit target, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+  SymbolicOperation(Control control, const Targets& targ, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+
+  SymbolicOperation(const Controls& c, Qubit target, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+  SymbolicOperation(const Controls& c, const Targets& targ, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+
+  // MCF (cSWAP), Peres, parameterized two target Constructor
+  SymbolicOperation(const Controls& c, Qubit target0, Qubit target1, OpType g,
+                    const std::vector<SymbolOrNumber>& params = {});
+
+  [[nodiscard]] std::unique_ptr<Operation> clone() const override;
+
+  [[nodiscard]] bool isSymbolicOperation() const override;
+
+  [[nodiscard]] bool isStandardOperation() const override;
+
+  [[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, {}, {});
+  }
+
+  [[noreturn]] void dumpOpenQASM(std::ostream& of,
+                                 const QubitIndexToRegisterMap& qubitMap,
+                                 const BitIndexToRegisterMap& bitMap,
+                                 std::size_t indent,
+                                 bool openQASM3) const override;
+
+  [[nodiscard]] StandardOperation
+  getInstantiatedOperation(const VariableAssignment& assignment) const;
+
+  // Instantiates this Operation
+  // Afterwards casting to StandardOperation can be done if assignment is total
+  void instantiate(const VariableAssignment& assignment);
+
+  void invert() override;
+
+protected:
+  std::vector<std::optional<Symbolic>> symbolicParameter;
+
+  static OpType parseU3(const Symbolic& theta, fp& phi, fp& lambda);
+  static OpType parseU3(fp& theta, const Symbolic& phi, fp& lambda);
+  static OpType parseU3(fp& theta, fp& phi, const Symbolic& lambda);
+  static OpType parseU3(const Symbolic& theta, const Symbolic& phi, fp& lambda);
+  static OpType parseU3(const Symbolic& theta, fp& phi, const Symbolic& lambda);
+  static OpType parseU3(fp& theta, const Symbolic& phi, const Symbolic& lambda);
+
+  static OpType parseU2(const Symbolic& phi, const Symbolic& lambda);
+  static OpType parseU2(const Symbolic& phi, fp& lambda);
+  static OpType parseU2(fp& phi, const Symbolic& lambda);
+
+  static OpType parseU1(const Symbolic& lambda);
+
+  void checkSymbolicUgate();
+
+  void storeSymbolOrNumber(const SymbolOrNumber& param, std::size_t i);
+
+  [[nodiscard]] bool isSymbolicParameter(std::size_t i) const;
+
+  static bool isSymbol(const SymbolOrNumber& param);
+
+  static Symbolic& getSymbol(SymbolOrNumber& param);
+
+  static fp& getNumber(SymbolOrNumber& param);
+
+  void setup(const std::vector<SymbolOrNumber>& params);
+
+  [[nodiscard]] static fp
+  getInstantiation(const SymbolOrNumber& symOrNum,
+                   const VariableAssignment& assignment);
+
+  void negateSymbolicParameter(std::size_t index);
+
+  void addToSymbolicParameter(std::size_t index, fp value);
+};
+} // namespace qc
+
+template <> struct std::hash<qc::SymbolicOperation> {
+  std::size_t operator()(qc::SymbolicOperation const& op) const noexcept {
+    std::size_t seed = 0U;
+    qc::hashCombine(seed, std::hash<qc::Operation>{}(op));
+    for (const auto& param : op.getParameters()) {
+      if (std::holds_alternative<qc::fp>(param)) {
+        qc::hashCombine(seed, hash<qc::fp>{}(get<qc::fp>(param)));
+      } else {
+        qc::hashCombine(seed, hash<qc::Symbolic>{}(get<qc::Symbolic>(param)));
+      }
+    }
+    return seed;
+  }
+};