mqt-core 3.3.2__cp314-cp314t-macosx_11_0_arm64.whl

mqt/core/include/mqt-core/na/operations/MoveOp.hpp

@@ -0,0 +1,66 @@
+/*
+ * 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 class for representing move operations.
+ */
+
+#pragma once
+
+#include "na/entities/Atom.hpp"
+#include "na/entities/Location.hpp"
+#include "na/operations/ShuttlingOp.hpp"
+
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a move operation in the NAComputation.
+class MoveOp final : public ShuttlingOp {
+protected:
+  /// The target locations to move the atoms to.
+  std::vector<Location> targetLocations_;
+
+public:
+  /// Creates a new move operation with the given atoms and target locations.
+  /// @param atoms The atoms to move.
+  /// @param targetLocations The target locations to move the atoms to.
+  MoveOp(std::vector<const Atom*> atoms, std::vector<Location> targetLocations)
+      : ShuttlingOp(std::move(atoms)),
+        targetLocations_(std::move(targetLocations)) {
+    if (atoms_.size() != targetLocations_.size()) {
+      throw std::invalid_argument(
+          "Number of atoms and target locations must be equal.");
+    }
+  }
+
+  /// Creates a new move operation with the given atom and target location.
+  /// @param atom The atom to move.
+  /// @param targetLocation The target location to move the atom to.
+  MoveOp(const Atom& atom, const Location& targetLocation)
+      : MoveOp({&atom}, {targetLocation}) {}
+
+  /// Returns whether the move operation has target locations set.
+  [[nodiscard]] auto hasTargetLocations() const -> bool override {
+    return true;
+  }
+
+  /// Returns the target locations of the move operation.
+  [[nodiscard]] auto getTargetLocations() const -> const
+      decltype(targetLocations_)& override {
+    return targetLocations_;
+  }
+
+  /// Returns a string representation of the operation.
+  [[nodiscard]] auto toString() const -> std::string override;
+};
+} // namespace na

mqt/core/include/mqt-core/na/operations/Op.hpp

@@ -0,0 +1,62 @@
+/*
+ * 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 the base class for all operations in the NAComputation.
+ */
+
+#pragma once
+
+#include <ostream>
+#include <string>
+
+namespace na {
+/// This is the base class for all operations in the NAComputation.
+class Op {
+public:
+  /// Default constructor.
+  Op() = default;
+
+  /// Virtual destructor.
+  virtual ~Op() = default;
+
+  /// Returns a string representation of the operation.
+  [[nodiscard]] virtual auto toString() const -> std::string = 0;
+
+  /// Prints the operation to the given output stream.
+  /// @param os The output stream to print the operation to.
+  /// @param obj The operation to print.
+  /// @return The output stream after printing the operation.
+  friend auto operator<<(std::ostream& os, const Op& obj) -> std::ostream& {
+    return os << obj.toString(); // Using toString() method
+  }
+
+  /// Checks if the operation is of the given type.
+  /// @tparam T The type to check for.
+  /// @return True if the operation is of the given type, false otherwise.
+  template <class T> [[nodiscard]] auto is() const -> bool {
+    return dynamic_cast<const T*>(this) != nullptr;
+  }
+
+  /// Casts the operation to the given type.
+  /// @tparam T The type to cast to.
+  /// @return A reference to the operation as the given type.
+  template <class T> [[nodiscard]] auto as() -> T& {
+    return dynamic_cast<T&>(*this);
+  }
+
+  /// Casts the operation to the given type.
+  /// @tparam T The type to cast to.
+  /// @return A const reference to the operation as the given type.
+  template <class T> [[nodiscard]] auto as() const -> const T& {
+    return dynamic_cast<const T&>(*this);
+  }
+};
+} // namespace na

mqt/core/include/mqt-core/na/operations/ShuttlingOp.hpp

@@ -0,0 +1,51 @@
+/*
+ * 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 base class for representing shuttling operations.
+ */
+
+#pragma once
+
+#include "na/entities/Atom.hpp"
+#include "na/entities/Location.hpp"
+#include "na/operations/Op.hpp"
+
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a shuttling operation in the NAComputation.
+/// @details A shuttling operation is the super class for all shuttling-related
+/// operations, i.e., load, store, and move operations.
+class ShuttlingOp : public Op {
+protected:
+  /// The atoms the operation is applied to.
+  std::vector<const Atom*> atoms_;
+
+  /// Creates a new shuttling operation with the given atoms.
+  /// @param atoms The atoms the operation is applied to.
+  explicit ShuttlingOp(std::vector<const Atom*> atoms)
+      : atoms_(std::move(atoms)) {}
+
+public:
+  ShuttlingOp() = delete;
+
+  /// Returns the atoms the operation is applied to.
+  [[nodiscard]] auto getAtoms() const -> auto& { return atoms_; }
+
+  /// Returns whether the shuttling operation has target locations set.
+  [[nodiscard]] virtual auto hasTargetLocations() const -> bool = 0;
+
+  /// Returns the target locations of the shuttling operation.
+  [[nodiscard]] virtual auto getTargetLocations() const
+      -> const std::vector<Location>& = 0;
+};
+} // namespace na

mqt/core/include/mqt-core/na/operations/StoreOp.hpp

@@ -0,0 +1,87 @@
+/*
+ * 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 class for representing store operations.
+ */
+
+#pragma once
+
+#include "na/entities/Atom.hpp"
+#include "na/entities/Location.hpp"
+#include "na/operations/ShuttlingOp.hpp"
+
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace na {
+/// Represents a store operation in the NAComputation.
+class StoreOp final : public ShuttlingOp {
+protected:
+  /// The target locations to store the atoms to.
+  std::optional<std::vector<Location>> targetLocations_ = std::nullopt;
+
+public:
+  /// Creates a new store operation with the given atoms and target locations.
+  /// @details The target locations can be used if the store operation
+  /// incorporates some offset.
+  /// @param atoms The atoms to store.
+  /// @param targetLocations The target locations to store the atoms to.
+  StoreOp(std::vector<const Atom*> atoms, std::vector<Location> targetLocations)
+      : ShuttlingOp(std::move(atoms)),
+        targetLocations_(std::move(targetLocations)) {
+    if (atoms_.size() != targetLocations_->size()) {
+      throw std::invalid_argument(
+          "Number of atoms and target locations must be equal.");
+    }
+  }
+
+  /// Creates a new store operation with the given atoms and target locations.
+  /// @details Here, the target locations are not used, i.e., this store does
+  /// not contain any offset.
+  /// @param atoms The atoms to store.
+  explicit StoreOp(std::vector<const Atom*> atoms)
+      : ShuttlingOp(std::move(atoms)) {}
+
+  /// Creates a new store operation with the given atom and target location.
+  /// @details The target location can be used if the store operation
+  /// incorporates some offset.
+  /// @param atom The atom to store.
+  /// @param targetLocation The target location to store the atom to.
+  StoreOp(const Atom& atom, const Location& targetLocation)
+      : StoreOp({&atom}, {targetLocation}) {}
+
+  /// Creates a new store operation with the given atom and target locations.
+  /// @details Here, the target locations are not used, i.e., this store does
+  /// not contain any offset.
+  /// @param atom The atom to store.
+  explicit StoreOp(const Atom& atom) : StoreOp({&atom}) {}
+
+  /// Returns whether the store operation has target locations set.
+  [[nodiscard]] auto hasTargetLocations() const -> bool override {
+    return targetLocations_.has_value();
+  }
+
+  /// Returns the target locations of the store operation.
+  [[nodiscard]] auto getTargetLocations() const
+      -> const std::vector<Location>& override {
+    if (!targetLocations_.has_value()) {
+      throw std::logic_error("Operation has no target locations set.");
+    }
+    return *targetLocations_;
+  }
+
+  /// Returns a string representation of the operation.
+  [[nodiscard]] auto toString() const -> std::string override;
+};
+} // namespace na

mqt/core/include/mqt-core/qasm3/Exception.hpp

@@ -0,0 +1,85 @@
+/*
+ * 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 "Statement.hpp"
+
+#include <exception>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <utility>
+
+namespace qasm3 {
+class CompilerError final : public std::exception {
+public:
+  std::string message;
+  std::shared_ptr<DebugInfo> debugInfo;
+  mutable std::string cachedMessage;
+
+  CompilerError(std::string msg, std::shared_ptr<DebugInfo> debug)
+      : message(std::move(msg)), debugInfo(std::move(debug)) {}
+
+  [[nodiscard]] std::string toString() const {
+    std::stringstream ss{};
+    ss << debugInfo->toString();
+
+    auto parentDebugInfo = debugInfo->parent;
+    while (parentDebugInfo != nullptr) {
+      ss << "\n  (included from " << parentDebugInfo->toString() << ")";
+      parentDebugInfo = parentDebugInfo->parent;
+    }
+
+    ss << ":\n" << message;
+
+    return ss.str();
+  }
+
+  [[nodiscard]] const char* what() const noexcept override {
+    cachedMessage = toString();
+    return cachedMessage.c_str();
+  }
+};
+
+class ConstEvalError final : public std::exception {
+public:
+  std::string message;
+  mutable std::string cachedMessage;
+
+  explicit ConstEvalError(std::string msg) : message(std::move(msg)) {}
+
+  [[nodiscard]] std::string toString() const {
+    return "Constant Evaluation: " + message;
+  }
+
+  [[nodiscard]] const char* what() const noexcept override {
+    cachedMessage = toString();
+    return cachedMessage.c_str();
+  }
+};
+
+class TypeCheckError final : public std::exception {
+public:
+  std::string message;
+  mutable std::string cachedMessage;
+
+  explicit TypeCheckError(std::string msg) : message(std::move(msg)) {}
+
+  [[nodiscard]] std::string toString() const {
+    return "Type Check Error: " + message;
+  }
+
+  [[nodiscard]] const char* what() const noexcept override {
+    cachedMessage = toString();
+    return cachedMessage.c_str();
+  }
+};
+} // namespace qasm3

mqt/core/include/mqt-core/qasm3/Gate.hpp

@@ -0,0 +1,65 @@
+/*
+ * 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 "Statement_fwd.hpp"
+#include "ir/operations/OpType.hpp"
+
+#include <cstddef>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace qasm3 {
+struct GateInfo {
+  size_t nControls;
+  size_t nTargets;
+  size_t nParameters;
+  qc::OpType type;
+};
+
+struct Gate {
+  virtual ~Gate() = default;
+
+  virtual size_t getNControls() = 0;
+  virtual size_t getNTargets() = 0;
+  virtual size_t getNParameters() = 0;
+};
+
+struct StandardGate final : Gate {
+  GateInfo info;
+
+  explicit StandardGate(const GateInfo& gateInfo) : info(gateInfo) {}
+
+  size_t getNControls() override { return info.nControls; }
+
+  size_t getNTargets() override { return info.nTargets; }
+  size_t getNParameters() override { return info.nParameters; }
+};
+
+struct CompoundGate final : Gate {
+  std::vector<std::string> parameterNames;
+  std::vector<std::string> targetNames;
+  std::vector<std::shared_ptr<QuantumStatement>> body;
+
+  explicit CompoundGate(
+      std::vector<std::string> parameters, std::vector<std::string> targets,
+      std::vector<std::shared_ptr<QuantumStatement>> bodyStatements)
+      : parameterNames(std::move(parameters)), targetNames(std::move(targets)),
+        body(std::move(bodyStatements)) {}
+
+  size_t getNControls() override { return 0; }
+
+  size_t getNTargets() override { return targetNames.size(); }
+  size_t getNParameters() override { return parameterNames.size(); }
+};
+} // namespace qasm3

mqt/core/include/mqt-core/qasm3/Importer.hpp

@@ -0,0 +1,192 @@
+/*
+ * 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 "qasm3/InstVisitor.hpp"
+#include "qasm3/NestedEnvironment.hpp"
+#include "qasm3/Statement_fwd.hpp"
+#include "qasm3/passes/ConstEvalPass.hpp"
+#include "qasm3/passes/TypeCheckPass.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <iosfwd>
+#include <map>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+#include <utility>
+#include <variant>
+#include <vector>
+
+// forward declarations
+namespace qc {
+enum ComparisonKind : std::uint8_t;
+class ClassicalRegister;
+struct Control;
+class QuantumRegister;
+class Operation;
+class QuantumComputation;
+using QuantumRegisterMap = std::unordered_map<std::string, QuantumRegister>;
+} // namespace qc
+namespace qasm3 {
+class Statement;
+struct Gate;
+
+class Importer final : public InstVisitor {
+public:
+  /**
+   * Imports a QASM3 file into a @ref qc::QuantumComputation instance
+   * @param filename The path to the QASM3 file to import
+   * @return The imported @ref qc::QuantumComputation instance
+   */
+  [[nodiscard]] static auto importf(const std::string& filename)
+      -> qc::QuantumComputation;
+
+  /**
+   * Imports a QASM3 program from a string into a @ref qc::QuantumComputation
+   * @param qasm The QASM3 program to import
+   * @return The imported @ref qc::QuantumComputation instance
+   */
+  [[nodiscard]] static auto imports(const std::string& qasm)
+      -> qc::QuantumComputation;
+
+  /**
+   * Imports a QASM3 program from a stream into a @ref qc::QuantumComputation
+   * @param is The input stream to read the QASM3 program from
+   * @return The imported @ref qc::QuantumComputation instance
+   */
+  [[nodiscard]] static auto import(std::istream& is) -> qc::QuantumComputation;
+
+private:
+  /**
+   * @brief Construct a new instance for importing QASM3 code
+   * @param quantumComputation The @ref qc::QuantumComputation to import the
+   * QASM3 code into.
+   */
+  explicit Importer(qc::QuantumComputation& quantumComputation);
+
+  /**
+   * @brief Import the given QASM3 program into the @ref qc::QuantumComputation
+   * @param program The parsed QASM3 program AST
+   */
+  void visitProgram(const std::vector<std::shared_ptr<Statement>>& program);
+
+  const_eval::ConstEvalPass constEvalPass;
+  type_checking::TypeCheckPass typeCheckPass;
+
+  NestedEnvironment<std::shared_ptr<DeclarationStatement>> declarations;
+  qc::QuantumComputation* qc{};
+
+  std::map<std::string, std::shared_ptr<Gate>> gates;
+
+  bool openQASM2CompatMode{false};
+
+  qc::Permutation initialLayout;
+  qc::Permutation outputPermutation;
+
+  static std::map<std::string, std::pair<const_eval::ConstEvalValue,
+                                         type_checking::InferredType>>
+  initializeBuiltins();
+
+  void translateGateOperand(const std::shared_ptr<GateOperand>& gateOperand,
+                            std::vector<qc::Qubit>& qubits,
+                            const qc::QuantumRegisterMap& qregs,
+                            const std::shared_ptr<DebugInfo>& debugInfo) const;
+
+  void translateBitOperand(
+      const std::shared_ptr<IndexedIdentifier>& indexedIdentifier,
+      std::vector<qc::Bit>& bits,
+      const std::shared_ptr<DebugInfo>& debugInfo) const;
+
+  /**
+   * @brief Translates a condition expression
+   * @param condition The condition expression to translate.
+   * @param debugInfo The debug information of the condition expression.
+   * @return Either a pair of a bit and a boolean value, or a triple of a
+   * classical register, a comparison kind, and an integer value.
+   * @throws CompilerError If the condition is neither of the expected types.
+   */
+  [[nodiscard]] std::variant<
+      std::pair<qc::Bit, bool>,
+      std::tuple<qc::ClassicalRegister, qc::ComparisonKind, uint64_t>>
+  translateCondition(const std::shared_ptr<Expression>& condition,
+                     const std::shared_ptr<DebugInfo>& debugInfo) const;
+
+  static uint64_t
+  evaluatePositiveConstant(const std::shared_ptr<Expression>& expr,
+                           const std::shared_ptr<DebugInfo>& debugInfo,
+                           uint64_t defaultValue = 0);
+
+  void visitVersionDeclaration(
+      std::shared_ptr<VersionDeclaration> versionDeclaration) override;
+
+  void visitDeclarationStatement(
+      std::shared_ptr<DeclarationStatement> declarationStatement) override;
+
+  void visitAssignmentStatement(
+      std::shared_ptr<AssignmentStatement> assignmentStatement) override;
+
+  void visitInitialLayout(std::shared_ptr<InitialLayout> layout) override;
+
+  void visitOutputPermutation(
+      std::shared_ptr<OutputPermutation> permutation) override;
+
+  void
+  visitGateStatement(std::shared_ptr<GateDeclaration> gateStatement) override;
+
+  void visitGateCallStatement(
+      std::shared_ptr<GateCallStatement> gateCallStatement) override;
+
+  auto
+  evaluateGateCall(const std::shared_ptr<GateCallStatement>& gateCallStatement,
+                   const std::string& identifier,
+                   const std::vector<std::shared_ptr<Expression>>& parameters,
+                   std::vector<std::shared_ptr<GateOperand>> targets,
+                   const qc::QuantumRegisterMap& qregs)
+      -> std::unique_ptr<qc::Operation>;
+
+  static std::shared_ptr<Gate>
+  getMcGateDefinition(const std::string& identifier, size_t operandSize,
+                      const std::shared_ptr<DebugInfo>& debugInfo);
+
+  auto applyQuantumOperation(const std::shared_ptr<Gate>& gate,
+                             const qc::Targets& targetBits,
+                             const std::vector<qc::Control>& controlBits,
+                             const std::vector<qc::fp>& evaluatedParameters,
+                             bool invertOperation,
+                             const std::shared_ptr<DebugInfo>& debugInfo)
+      -> std::unique_ptr<qc::Operation>;
+
+  void visitMeasureAssignment(
+      const std::shared_ptr<IndexedIdentifier>& indexedIdentifier,
+      const std::shared_ptr<MeasureExpression>& measureExpression,
+      const std::shared_ptr<DebugInfo>& debugInfo);
+
+  void visitBarrierStatement(
+      std::shared_ptr<BarrierStatement> barrierStatement) override;
+
+  void
+  visitResetStatement(std::shared_ptr<ResetStatement> resetStatement) override;
+
+  void visitIfStatement(std::shared_ptr<IfStatement> ifStatement) override;
+
+  [[nodiscard]] auto translateBlockOperations(
+      const std::vector<std::shared_ptr<Statement>>& statements)
+      -> std::unique_ptr<qc::Operation>;
+
+  std::pair<std::string, size_t>
+  parseGateIdentifierCompatMode(const std::string& identifier);
+};
+} // namespace qasm3