✨ OpenQASM 3.0 support

CMakeLists.txt

@@ -76,3 +76,7 @@ if(BUILD_MQT_CORE_TESTS)
   include(GoogleTest)
   add_subdirectory(test)
 endif()
+
+# TODO: remove before merging
+add_executable(main-test src/main.cpp)
+target_link_libraries(main-test PUBLIC MQT::qfr)

README.md

@@ -24,7 +24,7 @@ The MQT Core library forms the backbone of the quantum software tools developed
 - [MQT DDVis](https://github.com/cda-tum/mqt-ddvis): A Web-Application visualizing Decision Diagrams for Quantum Computing.
 - [MQT SyReC](https://github.com/cda-tum/mqt-syrec): A Tool for Synthesis of Reversible Circuits/Quantum Computing Oracles.
 
-For a full list of tools and libraries, please visit the [MQT website](https://mqt.readthedocs.io/).
+For a full list of tools and libraries, please run the [MQT website](https://mqt.readthedocs.io/).
 
 <p align="center">
   <a href="https://mqt.readthedocs.io/projects/core">

docs/index.md

@@ -9,7 +9,7 @@ The MQT Core library forms the backbone of the quantum software tools developed
 - [MQT DDVis](https://github.com/cda-tum/mqt-ddvis): A Web-Application visualizing Decision Diagrams for Quantum Computing.
 - {doc}`MQT SyReC <syrec:index>`: A Tool for Synthesis of Reversible Circuits/Quantum Computing Oracles.
 
-For a full list of tools and libraries, please visit the {doc}`MQT website <mqt:index>`.
+For a full list of tools and libraries, please run the {doc}`MQT website <mqt:index>`.
 
 ```{include} ../README.md
 :start-after: <!-- SPHINX-START -->

include/Definitions.hpp

@@ -52,12 +52,16 @@ static constexpr fp PI_2 = static_cast<fp>(
     1.570796326794896619231321691639751442098584699687552910487L);
 static constexpr fp PI_4 = static_cast<fp>(
     0.785398163397448309615660845819875721049292349843776455243L);
+static constexpr fp TAU = static_cast<fp>(
+    6.283185307179586476925286766559005768394338798750211641950L);
+static constexpr fp E = static_cast<fp>(
+    2.718281828459045235360287471352662497757247093699959574967L);
 
 // forward declaration
 class Operation;
 
 // supported file formats
-enum class Format { Real, OpenQASM, GRCS, TFC, QC, Tensor };
+enum class Format { Real, OpenQASM, OpenQASM3, GRCS, TFC, QC, Tensor };
 
 using DAG = std::vector<std::deque<std::unique_ptr<Operation>*>>;
 using DAGIterator = std::deque<std::unique_ptr<Operation>*>::iterator;

include/QuantumComputation.hpp

@@ -54,6 +54,7 @@
   std::unordered_set<sym::Variable> occuringVariables;
 
   void importOpenQASM(std::istream& is);
+  void importOpenQASM3(std::istream& is);
   void importReal(std::istream& is);
   int readRealHeader(std::istream& is);
   void readRealGateDescriptions(std::istream& is, int line);
@@ -70,7 +71,7 @@
   template <class RegisterType>
   static void printSortedRegisters(const RegisterMap<RegisterType>& regmap,
                                    const std::string& identifier,
-                                   std::ostream& of) {
+                                   std::ostream& of, bool openQASM3 = false) {
     // sort regs by start index
     std::map<decltype(RegisterType::first),
              std::pair<std::string, RegisterType>>
@@ -80,8 +81,13 @@
     }
 
     for (const auto& reg : sortedRegs) {
-      of << identifier << " " << reg.second.first << "["
-         << reg.second.second.second << "];" << std::endl;
+      if (openQASM3) {
+        of << identifier << "[" << reg.second.second.second << "] "
+           << reg.second.first << ";" << std::endl;
+      } else {
+        of << identifier << " " << reg.second.first << "["
+           << reg.second.second.second << "];" << std::endl;
+      }
     }
   }
   template <class RegisterType>
@@ -746,7 +752,7 @@
     dump(std::move(of), format);
   }
   virtual void dump(std::ostream&& of, Format format);
-  virtual void dumpOpenQASM(std::ostream& of);
+  virtual void dumpOpenQASM(std::ostream& of, bool openQASM3 = false);
 
   // this convenience method allows to turn a circuit into a compound operation.
   std::unique_ptr<CompoundOperation> asCompoundOperation() {

include/operations/ClassicControlledOperation.hpp

@@ -6,20 +6,33 @@
 
 namespace qc {
 
+enum ComparisonKind {
+  Eq,
+  Neq,
+  Lt,
+  Leq,
+  Gt,
+  Geq,
+};
+
+std::ostream& operator<<(std::ostream& os, const ComparisonKind& kind);
+
 class ClassicControlledOperation final : public Operation {
 private:
   std::unique_ptr<Operation> op;
   ClassicalRegister controlRegister{};
   std::uint64_t expectedValue = 1U;
+  ComparisonKind comparisonKind = ComparisonKind::Eq;
 
 public:
   // Applies operation `_op` if the creg starting at index `control` has the
   // expected value
   ClassicControlledOperation(std::unique_ptr<qc::Operation>& operation,
                              ClassicalRegister controlReg,
-                             std::uint64_t expectedVal = 1U)
+                             std::uint64_t expectedVal = 1U,
+                             ComparisonKind kind = ComparisonKind::Eq)
       : op(std::move(operation)), controlRegister(std::move(controlReg)),
-        expectedValue(expectedVal) {
+        expectedValue(expectedVal), comparisonKind(kind) {
     nqubits = op->getNqubits();
     name = "c_" + shortName(op->getType());
     parameter.reserve(3);
@@ -108,7 +121,8 @@
         return false;
       }
 
-      if (expectedValue != classic->expectedValue) {
+      if (expectedValue != classic->expectedValue ||
+          comparisonKind != classic->comparisonKind) {
         return false;
       }
 
@@ -124,10 +138,23 @@
                     const RegisterNames& creg) const override {
     of << "if(";
     of << creg[controlRegister.first].first;
-    of << " == " << expectedValue << ") ";
+    of << " " << comparisonKind << " " << expectedValue << ") ";
     op->dumpOpenQASM(of, qreg, creg);
   }
 
+  void dumpOpenQASM3(std::ostream& of, const RegisterNames& qreg,
+                     const RegisterNames& creg,
+                     uint32_t indent = 0) const override {
+    for (uint32_t i = 0; i < indent; ++i) {
+      of << "  ";
+    }
+    of << "if (";
+    of << creg[controlRegister.first].first;
+    of << " " << comparisonKind << " " << expectedValue << ") {\n";
+    op->dumpOpenQASM3(of, qreg, creg, indent + 1);
+    of << "}\n";
+  }
+
   void invert() override { op->invert(); }
 };
 } // namespace qc

include/operations/CompoundOperation.hpp

@@ -156,6 +156,14 @@
     }
   }
 
+  void dumpOpenQASM3(std::ostream& of, const RegisterNames& qreg,
+                     const RegisterNames& creg,
+                     uint32_t indent = 0) const override {
+    for (const auto& op : ops) {
+      op->dumpOpenQASM3(of, qreg, creg, indent);
+    }
+  }
+
   /**
    * Pass-Through
    */

include/operations/NonUnitaryOperation.hpp

@@ -78,6 +78,9 @@ class NonUnitaryOperation final : public Operation {
   void dumpOpenQASM(std::ostream& of, const RegisterNames& qreg,
                     const RegisterNames& creg) const override;
 
+  void dumpOpenQASM3(std::ostream& of, const RegisterNames& qreg,
+                     const RegisterNames& creg, uint32_t indent) const override;
+
   void invert() override {
     throw QFRException("Inverting a non-unitary operation is not supported.");
   }

include/operations/Operation.hpp

@@ -179,6 +179,10 @@
   virtual void dumpOpenQASM(std::ostream& of, const RegisterNames& qreg,
                             const RegisterNames& creg) const = 0;
 
+  virtual void dumpOpenQASM3(std::ostream& of, const RegisterNames& qreg,
+                             const RegisterNames& creg,
+                             uint32_t indent = 0) const = 0;
+
   virtual void invert() = 0;
 
   virtual bool operator==(const Operation& rhs) const { return equals(rhs); }

include/operations/StandardOperation.hpp

@@ -104,7 +104,9 @@
 
   void dumpOpenQASM(std::ostream& of, const RegisterNames& qreg,
                     const RegisterNames& creg) const override;
-
+  void dumpOpenQASM3(std::ostream& of, const RegisterNames& qreg,
+                     const RegisterNames& creg,
+                     uint32_t indent = 0) const override;
   void invert() override;
 };
 

include/operations/SymbolicOperation.hpp

@@ -137,6 +137,10 @@
   [[noreturn]] void dumpOpenQASM(std::ostream& of, const RegisterNames& qreg,
                                  const RegisterNames& creg) const override;
 
+  [[noreturn]] void dumpOpenQASM3(std::ostream& of, const RegisterNames& qreg,
+                                  const RegisterNames& creg,
+                                  uint32_t indent = 0) const override;
+
   [[nodiscard]] StandardOperation
   getInstantiatedOperation(const VariableAssignment& assignment) const;
 

include/parsers/qasm3_parser/Gate.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include "NestedEnvironment.hpp"
+#include "QuantumComputation.hpp"
+#include "Statement.hpp"
+
+namespace qasm3 {
+struct GateInfo {
+public:
+  size_t nControls;
+  size_t nTargets;
+  size_t nParameters;
+  qc::OpType type;
+};
+
+struct Gate {
+public:
+  virtual ~Gate() = default;
+
+  virtual size_t getNControls() = 0;
+  virtual size_t getNTargets() = 0;
+  virtual size_t getNParameters() = 0;
+};
+
+struct StandardGate : public Gate {
+public:
+  GateInfo info;
+
+  explicit StandardGate(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 : public Gate {
+public:
+  std::vector<std::string> parameterNames;
+  std::vector<std::string> targetNames;
+  std::vector<std::shared_ptr<GateCallStatement>> body;
+
+  explicit CompoundGate(
+      std::vector<std::string> parameters, std::vector<std::string> targets,
+      std::vector<std::shared_ptr<GateCallStatement>> 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