mqt-core 3.3.2__cp314-cp314t-macosx_11_0_x86_64.whl

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

@@ -0,0 +1,232 @@
+/*
+ * 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 "Gate.hpp"
+#include "ir/operations/OpType.hpp"
+
+#include <map>
+#include <memory>
+#include <string>
+
+namespace qasm3 {
+// Non-natively supported gates from
+// https://github.com/Qiskit/qiskit/blob/main/qiskit/qasm/libs/stdgates.inc
+const std::string STDGATES =
+    "// four parameter controlled-U gate with relative phase\n"
+    "gate cu(theta, phi, lambda, gamma) c, t { p(gamma) c; ctrl @ U(theta, "
+    "phi, lambda) c, t; }\n";
+
+// Non-natively supported gates from
+// https://github.com/Qiskit/qiskit/blob/main/qiskit/qasm/libs/qelib1.inc
+const std::string QE1LIB = "gate rccx a, b, c {\n"
+                           "  u2(0, pi) c; u1(pi/4) c; \n"
+                           "  cx b, c; u1(-pi/4) c; \n"
+                           "  cx a, c; u1(pi/4) c; \n"
+                           "  cx b, c; u1(-pi/4) c; \n"
+                           "  u2(0, pi) c; \n"
+                           "}\n"
+                           "gate rc3x a,b,c,d {\n"
+                           "  u2(0,pi) d; u1(pi/4) d; \n"
+                           "  cx c,d; u1(-pi/4) d; u2(0,pi) d; \n"
+                           "  cx a,d; u1(pi/4) d; \n"
+                           "  cx b,d; u1(-pi/4) d; \n"
+                           "  cx a,d; u1(pi/4) d; \n"
+                           "  cx b,d; u1(-pi/4) d; \n"
+                           "  u2(0,pi) d; u1(pi/4) d; \n"
+                           "  cx c,d; u1(-pi/4) d; \n"
+                           "  u2(0,pi) d; \n"
+                           "}\n";
+
+const std::map<std::string, std::shared_ptr<Gate>> STANDARD_GATES = {
+    // gates from which all other gates can be constructed.
+    {"gphase",
+     std::make_shared<StandardGate>(StandardGate({.nControls = 0,
+                                                  .nTargets = 0,
+                                                  .nParameters = 1,
+                                                  .type = qc::GPhase}))},
+    {"U",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 3, .type = qc::U}))},
+
+    // natively supported gates
+    {"p",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 1, .type = qc::P}))},
+    {"u1",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 1, .type = qc::P}))},
+    {"phase",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 1, .type = qc::P}))},
+    {"cphase",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 1, .nTargets = 1, .nParameters = 1, .type = qc::P}))},
+    {"cp",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 1, .nTargets = 1, .nParameters = 1, .type = qc::P}))},
+
+    {"id",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 0, .type = qc::I}))},
+    {"u2",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 2, .type = qc::U2}))},
+    {"u3",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 3, .type = qc::U}))},
+    {"u",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 3, .type = qc::U}))},
+
+    {"x",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 0, .type = qc::X}))},
+    {"cx",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 1, .nTargets = 1, .nParameters = 0, .type = qc::X}))},
+    {"CX",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 1, .nTargets = 1, .nParameters = 0, .type = qc::X}))},
+    {"ccx",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 2, .nTargets = 1, .nParameters = 0, .type = qc::X}))},
+    {"c3x",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 3, .nTargets = 1, .nParameters = 0, .type = qc::X}))},
+    {"c4x",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 4, .nTargets = 1, .nParameters = 0, .type = qc::X}))},
+
+    {"rx",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 1, .type = qc::RX}))},
+    {"crx",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 1, .nTargets = 1, .nParameters = 1, .type = qc::RX}))},
+
+    {"y",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 0, .type = qc::Y}))},
+    {"cy",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 1, .nTargets = 1, .nParameters = 0, .type = qc::Y}))},
+
+    {"ry",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 1, .type = qc::RY}))},
+    {"cry",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 1, .nTargets = 1, .nParameters = 1, .type = qc::RY}))},
+
+    {"z",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 0, .type = qc::Z}))},
+    {"cz",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 1, .nTargets = 1, .nParameters = 0, .type = qc::Z}))},
+
+    {"rz",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 1, .type = qc::RZ}))},
+    {"crz",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 1, .nTargets = 1, .nParameters = 1, .type = qc::RZ}))},
+
+    {"r",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 2, .type = qc::R}))},
+    {"prx",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 2, .type = qc::R}))},
+    {"cr",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 1, .nTargets = 1, .nParameters = 2, .type = qc::R}))},
+
+    {"h",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 0, .type = qc::H}))},
+    {"ch",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 1, .nTargets = 1, .nParameters = 0, .type = qc::H}))},
+
+    {"s",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 0, .type = qc::S}))},
+    {"sdg",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 0, .type = qc::Sdg}))},
+
+    {"t",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 0, .type = qc::T}))},
+    {"tdg",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 0, .type = qc::Tdg}))},
+
+    {"sx",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 0, .type = qc::SX}))},
+    {"sxdg",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 1, .nParameters = 0, .type = qc::SXdg}))},
+    {"c3sqrtx",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 3, .nTargets = 1, .nParameters = 0, .type = qc::SXdg}))},
+
+    {"swap",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 2, .nParameters = 0, .type = qc::SWAP}))},
+    {"cswap",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 1, .nTargets = 2, .nParameters = 0, .type = qc::SWAP}))},
+
+    {"iswap",
+     std::make_shared<StandardGate>(StandardGate({.nControls = 0,
+                                                  .nTargets = 2,
+                                                  .nParameters = 0,
+                                                  .type = qc::iSWAP}))},
+    {"iswapdg",
+     std::make_shared<StandardGate>(StandardGate({.nControls = 0,
+                                                  .nTargets = 2,
+                                                  .nParameters = 0,
+                                                  .type = qc::iSWAPdg}))},
+
+    {"rxx",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 2, .nParameters = 1, .type = qc::RXX}))},
+    {"ryy",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 2, .nParameters = 1, .type = qc::RYY}))},
+    {"rzz",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 2, .nParameters = 1, .type = qc::RZZ}))},
+    {"rzx",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 2, .nParameters = 1, .type = qc::RZX}))},
+    {"dcx",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 2, .nParameters = 0, .type = qc::DCX}))},
+    {"ecr",
+     std::make_shared<StandardGate>(StandardGate(
+         {.nControls = 0, .nTargets = 2, .nParameters = 0, .type = qc::ECR}))},
+    {"xx_minus_yy",
+     std::make_shared<StandardGate>(StandardGate({.nControls = 0,
+                                                  .nTargets = 2,
+                                                  .nParameters = 2,
+                                                  .type = qc::XXminusYY}))},
+    {"xx_plus_yy",
+     std::make_shared<StandardGate>(StandardGate({.nControls = 0,
+                                                  .nTargets = 2,
+                                                  .nParameters = 2,
+                                                  .type = qc::XXplusYY}))},
+};
+} // namespace qasm3

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

@@ -0,0 +1,198 @@
+/*
+ * 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 <cstddef>
+#include <cstdint>
+#include <iosfwd>
+#include <string>
+#include <utility>
+
+namespace qasm3 {
+
+struct Token {
+  enum class Kind : uint8_t {
+    None,
+
+    OpenQasm,
+    Include,
+    DefCalGrammar,
+    Def,
+    Cal,
+    DefCal,
+    Gate,
+    Opaque,
+    Extern,
+    Box,
+    Let,
+
+    Break,
+    Continue,
+    If,
+    Else,
+    End,
+    Return,
+    For,
+    While,
+    In,
+
+    Pragma,
+
+    // types
+    Input,
+    Output,
+    Const,
+    ReadOnly,
+    Mutable,
+
+    Qreg,
+    Qubit,
+
+    CReg,
+    Bool,
+    Bit,
+    Int,
+    Uint,
+    Float,
+    Angle,
+    Complex,
+    Array,
+    Void,
+
+    Duration,
+    Stretch,
+
+    // builtin identifiers
+    Gphase,
+    Inv,
+    Pow,
+    Ctrl,
+    NegCtrl,
+
+    Dim,
+
+    DurationOf,
+
+    Delay,
+    Reset,
+    Measure,
+    Barrier,
+
+    True,
+    False,
+
+    LBracket,
+    RBracket,
+    LBrace,
+    RBrace,
+    LParen,
+    RParen,
+
+    Colon,
+    Semicolon,
+    Eof,
+
+    Dot,
+    Comma,
+
+    Equals,
+    Arrow,
+    Plus,
+    DoublePlus,
+    Minus,
+    Asterisk,
+    DoubleAsterisk,
+    Slash,
+    Percent,
+    Pipe,
+    DoublePipe,
+    Ampersand,
+    DoubleAmpersand,
+    Caret,
+    At,
+    Tilde,
+    ExclamationPoint,
+
+    DoubleEquals,
+    NotEquals,
+    PlusEquals,
+    MinusEquals,
+    AsteriskEquals,
+    SlashEquals,
+    AmpersandEquals,
+    PipeEquals,
+    TildeEquals,
+    CaretEquals,
+    LeftShitEquals,
+    RightShiftEquals,
+    PercentEquals,
+    DoubleAsteriskEquals,
+
+    LessThan,
+    LessThanEquals,
+    GreaterThan,
+    GreaterThanEquals,
+    LeftShift,
+    RightShift,
+
+    Imag,
+
+    Underscore,
+
+    DoubleQuote,
+    SingleQuote,
+    BackSlash,
+
+    Identifier,
+
+    HardwareQubit,
+    StringLiteral,
+    IntegerLiteral,
+    FloatLiteral,
+    TimingLiteral,
+
+    Sin,
+    Cos,
+    Tan,
+    Exp,
+    Ln,
+    Sqrt,
+
+    InitialLayout,
+    OutputPermutation,
+  };
+
+  Kind kind = Kind::None;
+  size_t line = 0;
+  size_t col = 0;
+  size_t endLine = 0;
+  size_t endCol = 0;
+  int64_t val{};
+  bool isSigned{false};
+  double valReal{};
+  std::string str;
+
+  Token(const size_t l, const size_t c)
+      : line(l), col(c), endLine(l), endCol(c) {}
+  Token(const Kind k, const size_t l, const size_t c)
+      : kind(k), line(l), col(c), endLine(l), endCol(c) {}
+  Token(const Kind k, const size_t l, const size_t c, std::string s)
+      : kind(k), line(l), col(c), endLine(l), endCol(c), str(std::move(s)) {}
+
+  static std::string kindToString(Kind kind);
+
+  [[nodiscard]] std::string toString() const;
+
+  friend std::ostream& operator<<(std::ostream& os, const Kind& k);
+
+  friend std::ostream& operator<<(std::ostream& os, const Token& t);
+};
+} // namespace qasm3

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

@@ -0,0 +1,238 @@
+/*
+ * 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 "InstVisitor.hpp"
+#include "Types_fwd.hpp" // IWYU pragma: export
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <stdexcept>
+#include <string>
+
+namespace qasm3 {
+
+template <typename T> class Type {
+public:
+  virtual ~Type() = default;
+
+  [[nodiscard]] virtual bool operator==(const Type<T>& other) const = 0;
+  [[nodiscard]] bool operator!=(const Type<T>& other) const {
+    return !(*this == other);
+  }
+  [[nodiscard]] virtual bool allowsDesignator() const = 0;
+
+  virtual void setDesignator(T /*designator*/) {
+    throw std::runtime_error("Type does not allow designator");
+  }
+
+  [[nodiscard]] virtual T getDesignator() = 0;
+
+  virtual std::shared_ptr<ResolvedType> accept(TypeVisitor<T>* visitor) = 0;
+
+  virtual bool isBool() { return false; }
+  virtual bool isNumber() { return false; }
+  virtual bool isFP() { return false; }
+  virtual bool isUint() { return false; }
+  virtual bool isBit() { return false; }
+
+  virtual bool isConvertibleToBool() { return isBool(); }
+  virtual bool fits(const Type& other) { return *this == other; }
+
+  virtual std::string toString() = 0;
+};
+
+enum DesignatedTy : uint8_t {
+  Qubit,
+  Bit,
+  Int,
+  Uint,
+  Float,
+  Angle,
+};
+
+template <typename T> class DesignatedType final : public Type<T> {
+public:
+  ~DesignatedType() override = default;
+
+  DesignatedTy type;
+
+  T designator;
+
+  DesignatedType(const DesignatedTy ty, T design)
+      : type(ty), designator(std::move(design)) {}
+
+  explicit DesignatedType(DesignatedTy ty);
+
+  bool operator==(const Type<T>& other) const override {
+    if (const auto* o = dynamic_cast<const DesignatedType<T>*>(&other)) {
+      return type == o->type && designator == o->designator;
+    }
+    return false;
+  }
+
+  [[nodiscard]] bool allowsDesignator() const override { return true; }
+
+  static std::shared_ptr<DesignatedType> getQubitTy(T designator) {
+    return std::make_shared<DesignatedType>(Qubit, designator);
+  }
+  static std::shared_ptr<DesignatedType> getBitTy(T designator) {
+    return std::make_shared<DesignatedType>(Bit, designator);
+  }
+  static std::shared_ptr<DesignatedType> getIntTy(T designator) {
+    return std::make_shared<DesignatedType>(Int, designator);
+  }
+  static std::shared_ptr<DesignatedType> getUintTy(T designator) {
+    return std::make_shared<DesignatedType>(Uint, designator);
+  }
+  static std::shared_ptr<DesignatedType> getFloatTy(T designator) {
+    return std::make_shared<DesignatedType>(Float, designator);
+  }
+  static std::shared_ptr<DesignatedType> getAngleTy(T designator) {
+    return std::make_shared<DesignatedType>(Angle, designator);
+  }
+
+  void setDesignator(T d) override { this->designator = std::move(d); }
+
+  T getDesignator() override { return designator; }
+
+  std::shared_ptr<ResolvedType> accept(TypeVisitor<T>* visitor) override {
+    return visitor->visitDesignatedType(this);
+  }
+
+  bool isNumber() override {
+    return type == Int || type == Uint || type == Bit || type == Float;
+  }
+
+  bool isUint() override { return type == Uint; }
+
+  bool isBit() override { return type == Bit; }
+
+  bool isFP() override { return type == Float; }
+
+  bool isConvertibleToBool() override {
+    if constexpr (std::is_integral_v<T>) {
+      return type == Bit && designator == 1;
+    } else {
+      return false;
+    }
+  }
+
+  bool fits(const Type<T>& other) override;
+
+  std::string toString() override {
+    switch (type) {
+    case Qubit:
+      return "qubit[" + designatorToString() + "]";
+    case Bit:
+      return "bit[" + designatorToString() + "]";
+    case Int:
+      return "int[" + designatorToString() + "]";
+    case Uint:
+      return "uint[" + designatorToString() + "]";
+    case Float:
+      return "float[" + designatorToString() + "]";
+    case Angle:
+      return "angle[" + designatorToString() + "]";
+    }
+    throw std::runtime_error("Unhandled type");
+  }
+
+  std::string designatorToString();
+};
+
+enum UnsizedTy : uint8_t { Bool, Duration };
+
+template <typename T> class UnsizedType final : public Type<T> {
+public:
+  ~UnsizedType() override = default;
+
+  UnsizedTy type;
+
+  explicit UnsizedType(const UnsizedTy ty) : type(ty) {}
+
+  bool operator==(const Type<T>& other) const override {
+    if (const auto* o = dynamic_cast<const UnsizedType*>(&other)) {
+      return type == o->type;
+    }
+    return false;
+  }
+  [[nodiscard]] bool allowsDesignator() const override { return false; }
+
+  static std::shared_ptr<Type<T>> getBoolTy() {
+    return std::make_shared<UnsizedType>(Bool);
+  }
+  static std::shared_ptr<Type<T>> getDurationTy() {
+    return std::make_shared<UnsizedType>(Duration);
+  }
+
+  T getDesignator() override {
+    throw std::runtime_error("Unsized types do not have designators");
+  }
+
+  std::shared_ptr<ResolvedType> accept(TypeVisitor<T>* visitor) override {
+    return visitor->visitUnsizedType(this);
+  }
+
+  bool isBool() override { return type == Bool; }
+
+  std::string toString() override {
+    switch (type) {
+    case Bool:
+      return "bool";
+    case Duration:
+      return "duration";
+    }
+    throw std::runtime_error("Unhandled type");
+  }
+};
+
+template <typename T> class ArrayType final : public Type<T> {
+public:
+  std::shared_ptr<Type<T>> type;
+  T size;
+
+  ArrayType(std::shared_ptr<Type<T>> ty, T sz)
+      : type(std::move(ty)), size(sz) {}
+  ~ArrayType() override = default;
+
+  bool operator==(const Type<T>& other) const override {
+    if (const auto* o = dynamic_cast<const ArrayType*>(&other)) {
+      return *type == *o->type && size == o->size;
+    }
+    return false;
+  }
+  [[nodiscard]] bool allowsDesignator() const override { return true; }
+
+  T getDesignator() override { return size; }
+
+  std::shared_ptr<ResolvedType> accept(TypeVisitor<T>* visitor) override {
+    return visitor->visitArrayType(this);
+  }
+
+  bool fits(const Type<T>& other) override {
+    if (const auto* o = dynamic_cast<const ArrayType*>(&other)) {
+      return type->fits(*o->type) && size == o->size;
+    }
+    return false;
+  }
+
+  std::string toString() override {
+    if constexpr (std::is_same_v<T, size_t>) {
+      return type->toString() + "[" + std::to_string(size) + "]";
+    } else {
+      return type->toString() + "[<expression>]";
+    }
+  }
+};
+
+} // namespace qasm3

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

@@ -0,0 +1,22 @@
+/*
+ * 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 <memory>
+
+namespace qasm3 {
+class Expression;
+
+template <typename T> class Type;
+using TypeExpr = Type<std::shared_ptr<Expression>>;
+using ResolvedType = Type<uint64_t>;
+} // namespace qasm3