mqt-core 3.1.0__cp313-cp313-win_arm64.whl

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

@@ -0,0 +1,118 @@
+/*
+ * 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 <cstddef>
+#include <functional>
+#include <memory>
+#include <ostream>
+#include <set>
+#include <stdexcept>
+#include <vector>
+
+namespace qc {
+
+class NonUnitaryOperation final : public Operation {
+public:
+  // Measurement constructor
+  NonUnitaryOperation(std::vector<Qubit> qubitRegister,
+                      std::vector<Bit> classicalRegister);
+  NonUnitaryOperation(Qubit qubit, Bit cbit);
+
+  // General constructor
+  explicit NonUnitaryOperation(Targets qubits, OpType op = Reset);
+
+  [[nodiscard]] std::unique_ptr<Operation> clone() const override {
+    return std::make_unique<NonUnitaryOperation>(*this);
+  }
+
+  [[nodiscard]] bool isUnitary() const override { return false; }
+
+  [[nodiscard]] bool isNonUnitaryOperation() const override { return true; }
+
+  [[nodiscard]] const std::vector<Bit>& getClassics() const { return classics; }
+  std::vector<Bit>& getClassics() { return classics; }
+  [[nodiscard]] std::size_t getNclassics() const { return classics.size(); }
+
+  void addDepthContribution(std::vector<std::size_t>& depths) const override;
+
+  void addControl(const Control /*c*/) override {
+    throw std::runtime_error("Cannot add control to non-unitary operation.");
+  }
+
+  void clearControls() override {
+    throw std::runtime_error(
+        "Cannot clear controls from non-unitary operation.");
+  }
+
+  void removeControl(const Control /*c*/) override {
+    throw std::runtime_error(
+        "Cannot remove controls from non-unitary operation.");
+  }
+
+  Controls::iterator removeControl(const Controls::iterator /*it*/) override {
+    throw std::runtime_error(
+        "Cannot remove controls from non-unitary operation.");
+  }
+
+  [[nodiscard]] bool equals(const Operation& op, const Permutation& perm1,
+                            const Permutation& perm2) const override;
+  [[nodiscard]] bool equals(const Operation& operation) const override {
+    return equals(operation, {}, {});
+  }
+
+  std::ostream& print(std::ostream& os, const Permutation& permutation,
+                      std::size_t prefixWidth,
+                      std::size_t nqubits) const override;
+
+  void dumpOpenQASM(std::ostream& of, const QubitIndexToRegisterMap& qubitMap,
+                    const BitIndexToRegisterMap& bitMap, std::size_t indent,
+                    bool openQASM3) const override;
+
+  void invert() override {
+    throw std::runtime_error(
+        "Inverting a non-unitary operation is not supported.");
+  }
+
+  void apply(const Permutation& permutation) override;
+
+protected:
+  std::vector<Bit> classics; // vector for the classical bits to measure into
+
+  static void printMeasurement(std::ostream& os, const std::vector<Qubit>& q,
+                               const std::vector<Bit>& c,
+                               const Permutation& permutation,
+                               std::size_t nqubits);
+  void printReset(std::ostream& os, const std::vector<Qubit>& q,
+                  const Permutation& permutation, std::size_t nqubits) const;
+};
+} // namespace qc
+
+template <> struct std::hash<qc::NonUnitaryOperation> {
+  std::size_t operator()(qc::NonUnitaryOperation const& op) const noexcept {
+    std::size_t seed = 0U;
+    qc::hashCombine(seed, op.getType());
+    for (const auto& q : op.getTargets()) {
+      qc::hashCombine(seed, q);
+    }
+    for (const auto& c : op.getClassics()) {
+      qc::hashCombine(seed, c);
+    }
+    return seed;
+  }
+};

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

@@ -0,0 +1,115 @@
+/*
+ * 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 <istream>
+#include <ostream>
+#include <string>
+
+namespace qc {
+
+enum OpTypeFlags : uint8_t {
+  OpTypeNone = 0b00,
+  OpTypeInv = 0b01,
+  OpTypeDiag = 0b10,
+};
+
+constexpr static unsigned NUM_OP_TYPE_FLAG_BITS = 2;
+
+// Natively supported operations of the MQT Core library
+enum OpType : std::uint8_t {
+#define HANDLE_OP_TYPE(N, id, flags, repr)                                     \
+  id = ((N) << (NUM_OP_TYPE_FLAG_BITS)) | (flags),
+#define LAST_OP_TYPE(N) OpTypeEnd = (N) << (NUM_OP_TYPE_FLAG_BITS),
+#include "OpType.inc"
+
+#undef HANDLE_OP_TYPE
+#undef LAST_OP_TYPE
+};
+
+std::string toString(OpType opType);
+
+/**
+ * @brief Gives a short name for the given OpType (at most 3 characters)
+ * @param opType OpType to get the short name for
+ * @return Short name for the given OpType
+ */
+std::string shortName(OpType opType);
+
+[[nodiscard]] constexpr bool isTwoQubitGate(const OpType opType) {
+  switch (opType) {
+  case SWAP:
+  case iSWAP:
+  case iSWAPdg:
+  case Peres:
+  case Peresdg:
+  case DCX:
+  case ECR:
+  case RXX:
+  case RYY:
+  case RZZ:
+  case RZX:
+  case XXminusYY:
+  case XXplusYY:
+    return true;
+  default:
+    return false;
+  }
+}
+
+[[nodiscard]] constexpr bool isSingleQubitGate(const OpType type) {
+  switch (type) {
+  case I:
+  case U:
+  case U2:
+  case P:
+  case X:
+  case Y:
+  case Z:
+  case H:
+  case S:
+  case Sdg:
+  case T:
+  case SX:
+  case SXdg:
+  case Tdg:
+  case V:
+  case Vdg:
+  case RX:
+  case RY:
+  case RZ:
+    return true;
+  default:
+    return false;
+  }
+}
+
+inline std::ostream& operator<<(std::ostream& out, const OpType opType) {
+  return out << toString(opType);
+}
+
+[[nodiscard]] OpType opTypeFromString(const std::string& opType);
+
+inline std::istream& operator>>(std::istream& in, OpType& opType) {
+  std::string opTypeStr;
+  in >> opTypeStr;
+
+  if (opTypeStr.empty()) {
+    in.setstate(std::istream::failbit);
+    return in;
+  }
+
+  opType = opTypeFromString(opTypeStr);
+  return in;
+}
+
+} // namespace qc

mqt/core/include/mqt-core/ir/operations/OpType.inc

@@ -0,0 +1,75 @@
+/*
+ * 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
+ */
+
+HANDLE_OP_TYPE(0, None, 0, "none")
+
+// Standard Operations
+HANDLE_OP_TYPE(1, GPhase, 0, "gphase")
+HANDLE_OP_TYPE(2, I, OpTypeDiag, "i")
+HANDLE_OP_TYPE(3, Barrier, OpTypeDiag, "barrier")
+HANDLE_OP_TYPE(4, H, OpTypeNone, "h")
+HANDLE_OP_TYPE(5, X, OpTypeNone, "x")
+HANDLE_OP_TYPE(6, Y, OpTypeNone, "y")
+HANDLE_OP_TYPE(7, Z, OpTypeDiag, "z")
+HANDLE_OP_TYPE(8, S, OpTypeDiag, "s")
+HANDLE_OP_TYPE(8, Sdg, OpTypeDiag | OpTypeInv, "sdg")
+HANDLE_OP_TYPE(9, T, OpTypeDiag, "t")
+HANDLE_OP_TYPE(9, Tdg, OpTypeDiag | OpTypeInv, "tdg")
+HANDLE_OP_TYPE(10, V, OpTypeNone, "v")
+HANDLE_OP_TYPE(10, Vdg, OpTypeInv, "vdg")
+HANDLE_OP_TYPE(11, U, OpTypeNone, "u")
+HANDLE_OP_TYPE(12, U2, OpTypeNone, "u2")
+HANDLE_OP_TYPE(13, P, OpTypeDiag, "p")
+HANDLE_OP_TYPE(14, SX, OpTypeNone, "sx")
+HANDLE_OP_TYPE(14, SXdg, OpTypeInv, "sxdg")
+HANDLE_OP_TYPE(15, RX, OpTypeNone, "rx")
+HANDLE_OP_TYPE(16, RY, OpTypeNone, "ry")
+HANDLE_OP_TYPE(17, RZ, OpTypeDiag, "rz")
+HANDLE_OP_TYPE(18, SWAP, OpTypeNone, "swap")
+HANDLE_OP_TYPE(19, iSWAP, OpTypeNone,   "iswap")
+HANDLE_OP_TYPE(19, iSWAPdg, OpTypeInv, "iswapdg")
+HANDLE_OP_TYPE(20, Peres, OpTypeNone, "peres")
+HANDLE_OP_TYPE(20, Peresdg, OpTypeInv, "peresdg")
+HANDLE_OP_TYPE(21, DCX, OpTypeNone, "dcx")
+HANDLE_OP_TYPE(22, ECR, OpTypeNone, "ecr")
+HANDLE_OP_TYPE(23, RXX, OpTypeNone, "rxx")
+HANDLE_OP_TYPE(24, RYY, OpTypeNone, "ryy")
+HANDLE_OP_TYPE(25, RZZ, OpTypeDiag, "rzz")
+HANDLE_OP_TYPE(26, RZX, OpTypeNone, "rzx")
+HANDLE_OP_TYPE(27, XXminusYY, OpTypeNone, "xx_minus_yy")
+HANDLE_OP_TYPE(28, XXplusYY, OpTypeNone, "xx_plus_yy")
+
+// Compound Operation
+HANDLE_OP_TYPE(29, Compound, OpTypeNone, "compound")
+
+// Non Unitary Operations
+HANDLE_OP_TYPE(30, Measure, OpTypeNone, "measure")
+HANDLE_OP_TYPE(31, Reset, OpTypeNone, "reset")
+
+// Classically-controlled Operation
+HANDLE_OP_TYPE(32, ClassicControlled, OpTypeNone, "classic_controlled")
+
+// Noise operations
+HANDLE_OP_TYPE(33, ATrue, 0, "a_true")
+HANDLE_OP_TYPE(34, AFalse, 0, "a_false")
+HANDLE_OP_TYPE(35, MultiATrue, 0, "multi_a_true")
+HANDLE_OP_TYPE(36, MultiAFalse, 0, "multi_a_false")
+
+// Neutral atom shuttling operations
+HANDLE_OP_TYPE(37, Move, 0, "move")
+HANDLE_OP_TYPE(38, AodActivate, 0, "aod_activate")
+HANDLE_OP_TYPE(39, AodDeactivate, 0, "aod_deactivate")
+HANDLE_OP_TYPE(40, AodMove, 0, "aod_move")
+
+LAST_OP_TYPE(41)
+
+
+#undef OpTypeInv
+#undef OpTypeDiag

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

@@ -0,0 +1,245 @@
+/*
+ * 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 isClassicControlledOperation() 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(); }
+
+  /**
+   * @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,138 @@
+/*
+ * 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;
+
+  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