mqt-core 3.1.0__cp313-cp313-win_arm64.whl

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

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

@@ -0,0 +1,145 @@
+/*
+ * 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 <cstdint>
+#include <memory>
+#include <stdexcept>
+
+namespace qasm3 {
+
+class InstVisitor {
+public:
+  virtual void
+  visitGateStatement(std::shared_ptr<GateDeclaration> gateStatement) = 0;
+  virtual void visitVersionDeclaration(
+      std::shared_ptr<VersionDeclaration> versionDeclaration) = 0;
+  virtual void visitDeclarationStatement(
+      std::shared_ptr<DeclarationStatement> declarationStatement) = 0;
+  virtual void
+  visitInitialLayout(std::shared_ptr<InitialLayout> initialLayout) = 0;
+  virtual void visitOutputPermutation(
+      std::shared_ptr<OutputPermutation> outputPermutation) = 0;
+  virtual void visitGateCallStatement(
+      std::shared_ptr<GateCallStatement> gateCallStatement) = 0;
+  virtual void visitAssignmentStatement(
+      std::shared_ptr<AssignmentStatement> assignmentStatement) = 0;
+  virtual void
+  visitBarrierStatement(std::shared_ptr<BarrierStatement> barrierStatement) = 0;
+  virtual void
+  visitResetStatement(std::shared_ptr<ResetStatement> resetStatement) = 0;
+  virtual void visitIfStatement(std::shared_ptr<IfStatement> ifStatement) = 0;
+
+  virtual ~InstVisitor() = default;
+};
+
+class DefaultInstVisitor : public InstVisitor {
+public:
+  void visitGateStatement(
+      std::shared_ptr<GateDeclaration> /*gateStatement*/) override {}
+  void visitVersionDeclaration(
+      std::shared_ptr<VersionDeclaration> /*versionDeclaration*/) override {}
+  void visitDeclarationStatement(
+      std::shared_ptr<DeclarationStatement> /*declarationStatement*/) override {
+  }
+  void visitInitialLayout(
+      std::shared_ptr<InitialLayout> /*initialLayout*/) override {}
+  void visitOutputPermutation(
+      std::shared_ptr<OutputPermutation> /*outputPermutation*/) override {}
+  void visitGateCallStatement(
+      std::shared_ptr<GateCallStatement> /*gateCallStatement*/) override {}
+  void visitAssignmentStatement(
+      std::shared_ptr<AssignmentStatement> /*assignmentStatement*/) override {}
+  void visitBarrierStatement(
+      std::shared_ptr<BarrierStatement> /*barrierStatement*/) override {}
+  void visitResetStatement(
+      std::shared_ptr<ResetStatement> /*resetStatement*/) override {}
+  void visitIfStatement(std::shared_ptr<IfStatement> /*ifStatement*/) override {
+  }
+};
+
+template <typename T> class ExpressionVisitor {
+public:
+  virtual T
+  visitBinaryExpression(std::shared_ptr<BinaryExpression> binaryExpression) = 0;
+  virtual T
+  visitUnaryExpression(std::shared_ptr<UnaryExpression> unaryExpression) = 0;
+  virtual T visitConstantExpression(std::shared_ptr<Constant> constant) = 0;
+  virtual T visitIdentifierExpression(
+      std::shared_ptr<IdentifierExpression> identifierExpression) = 0;
+  virtual T
+  visitIdentifierList(std::shared_ptr<IdentifierList> identifierList) = 0;
+  virtual T visitIndexedIdentifier(
+      std::shared_ptr<IndexedIdentifier> indexedIdentifier) = 0;
+  virtual T visitMeasureExpression(
+      std::shared_ptr<MeasureExpression> measureExpression) = 0;
+
+  // A manually implemented visitor function with a templated return type.
+  // This is impossible as a virtual function in expression, which is why
+  // we define it manually.
+  T visit(const std::shared_ptr<Expression>& expression) {
+    if (expression == nullptr) {
+      throw std::runtime_error("Expression is null");
+    }
+    if (const auto binaryExpression =
+            std::dynamic_pointer_cast<BinaryExpression>(expression)) {
+      return visitBinaryExpression(binaryExpression);
+    }
+    if (const auto unaryExpression =
+            std::dynamic_pointer_cast<UnaryExpression>(expression)) {
+      return visitUnaryExpression(unaryExpression);
+    }
+    if (const auto constantInt =
+            std::dynamic_pointer_cast<Constant>(expression)) {
+      return visitConstantExpression(constantInt);
+    }
+    if (const auto identifierExpression =
+            std::dynamic_pointer_cast<IdentifierExpression>(expression)) {
+      return visitIdentifierExpression(identifierExpression);
+    }
+    if (const auto identifierList =
+            std::dynamic_pointer_cast<IdentifierList>(expression)) {
+      return visitIdentifierList(identifierList);
+    }
+    if (const auto indexedIdentifier =
+            std::dynamic_pointer_cast<IndexedIdentifier>(expression)) {
+      return visitIndexedIdentifier(indexedIdentifier);
+    }
+    if (const auto measureExpression =
+            std::dynamic_pointer_cast<MeasureExpression>(expression)) {
+      return visitMeasureExpression(measureExpression);
+    }
+    throw std::runtime_error("Unhandled expression type.");
+  }
+
+  virtual ~ExpressionVisitor() = default;
+};
+
+template <typename T> class Type;
+using ResolvedType = Type<uint64_t>;
+template <typename T> class DesignatedType;
+template <typename T> class UnsizedType;
+template <typename T> class ArrayType;
+
+template <typename T> class TypeVisitor {
+public:
+  virtual ~TypeVisitor() = default;
+
+  virtual std::shared_ptr<ResolvedType>
+  visitDesignatedType(DesignatedType<T>* designatedType) = 0;
+  virtual std::shared_ptr<ResolvedType>
+  visitUnsizedType(UnsizedType<T>* unsizedType) = 0;
+  virtual std::shared_ptr<ResolvedType>
+  visitArrayType(ArrayType<T>* arrayType) = 0;
+};
+} // namespace qasm3

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

@@ -0,0 +1,41 @@
+/*
+ * 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 <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace qasm3 {
+template <typename T> class NestedEnvironment {
+  std::vector<std::map<std::string, T>> env{};
+
+public:
+  NestedEnvironment() { env.emplace_back(); };
+
+  void push() { env.emplace_back(); }
+
+  void pop() { env.pop_back(); }
+
+  std::optional<T> find(std::string key) {
+    for (auto it = env.rbegin(); it != env.rend(); ++it) {
+      auto found = it->find(key);
+      if (found != it->end()) {
+        return found->second;
+      }
+    }
+    return std::nullopt;
+  }
+
+  void emplace(std::string key, T value) { env.back().emplace(key, value); }
+};
+} // namespace qasm3

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

@@ -0,0 +1,170 @@
+/*
+ * 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
+ */
+
+/*
+ * This file is part of MQT QFR library which is released under the MIT license.
+ * See file README.md or go to https://www.cda.cit.tum.de/research/quantum/ for
+ * more information.
+ */
+
+#pragma once
+
+#include "Scanner.hpp"
+#include "Statement_fwd.hpp"
+#include "Token.hpp"
+#include "Types_fwd.hpp"
+
+#include <istream>
+#include <memory>
+#include <optional>
+#include <stack>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace qc {
+// forward declarations
+class Permutation;
+} // namespace qc
+
+namespace qasm3 {
+class Parser final {
+  struct ScannerState {
+  private:
+    std::unique_ptr<std::istream> is;
+
+  public:
+    Token last{0, 0};
+    Token t{0, 0};
+    Token next{0, 0};
+    std::unique_ptr<Scanner> scanner;
+    std::optional<std::string> filename;
+    bool isImplicitInclude;
+
+    bool scan() {
+      last = t;
+      t = next;
+      next = scanner->next();
+
+      return t.kind != Token::Kind::Eof;
+    }
+
+    explicit ScannerState(
+        std::istream* in,
+        std::optional<std::string> debugFilename = std::nullopt,
+        const bool implicitInclude = false)
+        : scanner(std::make_unique<Scanner>(in)),
+          filename(std::move(debugFilename)),
+          isImplicitInclude(implicitInclude) {
+      scan();
+    }
+
+    explicit ScannerState(
+        std::unique_ptr<std::istream> in,
+        std::optional<std::string> debugFilename = std::nullopt,
+        const bool implicitInclude = false)
+        : is(std::move(in)), scanner(std::make_unique<Scanner>(is.get())),
+          filename(std::move(debugFilename)),
+          isImplicitInclude(implicitInclude) {
+      scan();
+    }
+  };
+
+  std::stack<ScannerState> scanner;
+  std::shared_ptr<DebugInfo> includeDebugInfo{nullptr};
+
+  [[noreturn]] void error(const Token& token, const std::string& msg);
+
+  [[nodiscard]] Token last() const;
+
+  [[nodiscard]] Token current() const;
+
+  [[nodiscard]] Token peek() const;
+
+  Token expect(const Token::Kind& expected,
+               const std::optional<std::string>& context = std::nullopt);
+
+public:
+  explicit Parser(std::istream& is, bool implicitlyIncludeStdgates = true);
+
+  ~Parser() = default;
+
+  std::shared_ptr<VersionDeclaration> parseVersionDeclaration();
+
+  std::vector<std::shared_ptr<Statement>> parseProgram();
+
+  std::shared_ptr<Statement> parseStatement();
+
+  std::shared_ptr<QuantumStatement> parseQuantumStatement();
+
+  void parseInclude();
+
+  std::shared_ptr<AssignmentStatement> parseAssignmentStatement();
+
+  std::shared_ptr<AssignmentStatement> parseMeasureStatement();
+
+  std::shared_ptr<ResetStatement> parseResetStatement();
+
+  std::shared_ptr<BarrierStatement> parseBarrierStatement();
+
+  std::shared_ptr<Statement> parseDeclaration(bool isConst);
+
+  std::shared_ptr<GateDeclaration> parseGateDefinition();
+
+  std::shared_ptr<GateDeclaration> parseOpaqueGateDefinition();
+
+  std::shared_ptr<GateCallStatement> parseGateCallStatement();
+
+  std::shared_ptr<GateModifier> parseGateModifier();
+
+  std::shared_ptr<IndexOperator> parseIndexOperator();
+
+  std::shared_ptr<IndexedIdentifier> parseIndexedIdentifier();
+
+  std::shared_ptr<GateOperand> parseGateOperand();
+
+  std::shared_ptr<DeclarationExpression> parseDeclarationExpression();
+
+  std::shared_ptr<MeasureExpression> parseMeasureExpression();
+
+  std::shared_ptr<Expression> exponentiation();
+
+  std::shared_ptr<Expression> factor();
+
+  std::shared_ptr<Expression> term();
+
+  std::shared_ptr<Expression> comparison();
+
+  std::shared_ptr<Expression> parseExpression();
+
+  std::shared_ptr<IdentifierList> parseIdentifierList();
+
+  std::pair<std::shared_ptr<Type<std::shared_ptr<Expression>>>, bool>
+  parseType();
+
+  std::shared_ptr<Expression> parseTypeDesignator();
+
+  static qc::Permutation parsePermutation(std::string s);
+
+  void scan();
+
+  std::shared_ptr<DebugInfo> makeDebugInfo(Token const& begin,
+                                           Token const& /*end*/);
+
+  std::shared_ptr<DebugInfo> makeDebugInfo(Token const& token);
+
+  [[nodiscard]] bool isAtEnd() const {
+    return current().kind == Token::Kind::Eof;
+  }
+  std::shared_ptr<IfStatement> parseIfStatement();
+  std::vector<std::shared_ptr<Statement>> parseBlockOrStatement();
+};
+
+} // namespace qasm3