mqt-core 3.0.1__cp311-cp311-win_amd64.whl → 3.1.0__cp311-cp311-win_amd64.whl

mqt/core/include/mqt-core/dd/RealNumber.hpp

@@ -21,18 +21,16 @@
 namespace dd {
 /**
  * @brief A struct for representing real numbers as part of the DD package.
- * @details Consists of a floating point number (the value), a next pointer
- * (used for chaining entries), and a reference count.
+ * @details Consists of a floating point number (the value) and a next pointer
+ * (used for chaining entries). Numbers are marked for garbage collection via
+ * the second least significant bit of pointers referencing them.
  * @note Due to the way the sign of the value is encoded, special care has to
  * be taken when accessing the value. The static functions in this struct
  * provide safe access to the value of a RealNumber* pointer.
  */
 struct RealNumber final : LLBase {
-
   /// Getter for the next object.
-  [[nodiscard]] RealNumber* next() const noexcept {
-    return reinterpret_cast<RealNumber*>(next_);
-  }
+  [[nodiscard]] RealNumber* next() const noexcept;
 
   /**
    * @brief Check whether the number points to the zero number.
@@ -65,15 +63,6 @@ struct RealNumber final : LLBase {
    */
   [[nodiscard]] static fp val(const RealNumber* e) noexcept;
 
-  /**
-   * @brief Get the reference count of the number.
-   * @param num A pointer to the number to get the reference count for.
-   * @returns The reference count of the number.
-   * @note This function accounts for the sign of the number embedded in the
-   * memory address of the number.
-   */
-  [[nodiscard]] static RefCount refCount(const RealNumber* num) noexcept;
-
   /**
    * @brief Check whether two floating point numbers are approximately equal.
    * @details This function checks whether two floating point numbers are
@@ -115,42 +104,6 @@ struct RealNumber final : LLBase {
    */
   [[nodiscard]] static bool approximatelyZero(const RealNumber* e) noexcept;
 
-  /**
-   * @brief Indicates whether a given number needs reference count updates.
-   * @details This function checks whether a given number needs reference count
-   * updates. A number needs reference count updates if the pointer to it is
-   * not the null pointer, if it is not one of the special numbers (zero,
-   * one, 1/sqrt(2)), and if the reference count has saturated.
-   * @param num Pointer to the number to check.
-   * @returns Whether the number needs reference count updates.
-   * @note This function assumes that the pointer to the number is aligned.
-   */
-  [[nodiscard]] static bool noRefCountingNeeded(const RealNumber* num) noexcept;
-
-  /**
-   * @brief Increment the reference count of a number.
-   * @details This function increments the reference count of a number. If the
-   * reference count has saturated (i.e. reached the maximum value of RefCount)
-   * the reference count is not incremented.
-   * @param num A pointer to the number to increment the reference count of.
-   * @returns Whether the reference count was incremented.
-   * @note Typically, you do not want to call this function directly. Instead,
-   * use the RealNumberUniqueTable::incRef(RelNumber*) function.
-   */
-  [[nodiscard]] static bool incRef(const RealNumber* num) noexcept;
-
-  /**
-   * @brief Decrement the reference count of a number.
-   * @details This function decrements the reference count of a number. If the
-   * reference count has saturated (i.e. reached the maximum value of RefCount)
-   * the reference count is not decremented.
-   * @param num A pointer to the number to decrement the reference count of.
-   * @returns Whether the reference count was decremented.
-   * @note Typically, you do not want to call this function directly. Instead,
-   * use the RealNumberUniqueTable::decRef(RelNumber*) function.
-   */
-  [[nodiscard]] static bool decRef(const RealNumber* num) noexcept;
-
   /**
    * @brief Write a binary representation of the number to a stream.
    * @param e The number to write.
@@ -195,13 +148,6 @@ struct RealNumber final : LLBase {
   [[nodiscard]] static RealNumber*
   getNegativePointer(const RealNumber* e) noexcept;
 
-  /**
-   * @brief Check whether the number is a negative pointer.
-   * @param e The number to check.
-   * @returns Whether the number is a negative pointer.
-   */
-  [[nodiscard]] static bool isNegativePointer(const RealNumber* e) noexcept;
-
   /**
    * @brief Flip the sign of the number pointer.
    * @param e The number to flip the sign of.
@@ -214,6 +160,48 @@ struct RealNumber final : LLBase {
   [[nodiscard]] static RealNumber*
   flipPointerSign(const RealNumber* e) noexcept;
 
+  /**
+   * @brief Mark @p e for garbage collection.
+   * @details Sets the 2nd least significant bit of the next_ pointer.
+   * @param e The number to mark.
+   */
+  static void mark(RealNumber* e) noexcept;
+
+  /**
+   * @brief Unmark @p e after garbage collection.
+   * @details Unsets the 2nd least significant bit of the next_ pointer.
+   * @param e The number to unmark.
+   */
+  static void unmark(RealNumber* e) noexcept;
+
+  /**
+   * @brief Immortalize @p e.
+   * @details Sets the 3rd least significant bit of the next_ pointer.
+   * @param e The number to immortalize.
+   */
+  static void immortalize(RealNumber* e) noexcept;
+
+  /**
+   * @brief Check whether the number is flagged as negative.
+   * @param e The number to check.
+   * @returns Whether the number is negative.
+   */
+  [[nodiscard]] static bool isNegativePointer(const RealNumber* e) noexcept;
+
+  /**
+   * @brief Check whether the number is flagged as marked.
+   * @param e The number to check.
+   * @returns Whether the number is marked.
+   */
+  [[nodiscard]] static bool isMarked(const RealNumber* e) noexcept;
+
+  /**
+   * @brief Check whether the number is flagged as immortal.
+   * @param e The number to check.
+   * @returns Whether the number is immortal.
+   */
+  [[nodiscard]] static bool isImmortal(const RealNumber* e) noexcept;
+
   /**
    * @brief The value of the number.
    * @details The value of the number is a floating point number. The sign of
@@ -224,19 +212,14 @@ struct RealNumber final : LLBase {
    */
   fp value{};
 
-  /**
-   * @brief The reference count of the number.
-   * @details The reference count is used to determine whether a number is
-   * still in use. If the reference count is zero, the number is not in use
-   * and can be garbage collected.
-   */
-  RefCount ref{};
-
   /// numerical tolerance to be used for floating point values
   // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
   static inline fp eps = std::numeric_limits<dd::fp>::epsilon() * 1024;
 };
 
+static_assert(sizeof(RealNumber) == 16);
+static_assert(alignof(RealNumber) == 8);
+
 namespace constants {
 // NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables)
 /// The constant zero.

mqt/core/include/mqt-core/dd/RealNumberUniqueTable.hpp

@@ -23,6 +23,14 @@ namespace dd {
 
 struct RealNumber;
 
+/**
+ * @brief Immortal numbers that will never be garbage collected.
+ */
+namespace immortals {
+constexpr std::array<fp, 1> get() { return {.5}; }
+constexpr std::size_t size() { return get().size(); }
+} // namespace immortals
+
 /**
  * @brief A unique table for real numbers.
  * @details A hash table that stores real numbers. The hash table is implemented
@@ -93,28 +101,6 @@ public:
    */
   [[nodiscard]] RealNumber* lookup(fp val);
 
-  /**
-   * @brief Increment the reference count of a number.
-   * @details This is a pass-through function that calls the increment function
-   * of the number. It additionally keeps track of the number of active entries
-   * in the table (entries with a reference count greater than zero). Reference
-   * counts saturate at the maximum value of RefCount.
-   * @param num A pointer to the number to increase the reference count of.
-   * @see RealNumber::incRef(RealNumber*)
-   */
-  void incRef(RealNumber* num) noexcept;
-
-  /**
-   * @brief Decrement the reference count of a number.
-   * @details This is a pass-through function that calls the decrement function
-   * of the number. It additionally keeps track of the number of active entries
-   * in the table (entries with a reference count greater than zero). Reference
-   * counts saturate at the maximum value of RefCount.
-   * @param num A pointer to the number to decrease the reference count of.
-   * @see RealNumber::decRef(RealNumber*)
-   */
-  void decRef(RealNumber* num) noexcept;
-
   /**
    * @brief Check whether the table possibly needs garbage collection.
    * @returns Whether the number of entries in the table has reached the garbage
@@ -126,9 +112,9 @@ public:
    * @brief Perform garbage collection.
    * @details This function performs garbage collection. It first checks whether
    * garbage collection is necessary. If not, it does nothing. Otherwise, it
-   * iterates over all entries in the table and returns all entries with a
-   * reference count of zero to the available list. If the force flag is set,
-   * garbage collection is performed even if it is not necessary.
+   * iterates over all entries in the table and removes all numbers whose
+   * pointers are unmarked. If the force flag is set, garbage collection is
+   * performed even if it is not strictly necessary.
    * Based on how many entries are returned to the available list, the garbage
    * collection limit is dynamically adjusted.
    * @param force Whether to force garbage collection.
@@ -156,6 +142,9 @@ public:
    */
   std::ostream& printBucketDistribution(std::ostream& os = std::cout);
 
+  /// Count the marked entries in the table
+  [[nodiscard]] std::size_t countMarkedEntries() const noexcept;
+
 private:
   /// Typedef for a bucket in the table.
   using Bucket = RealNumber*;

mqt/core/include/mqt-core/dd/StateGeneration.hpp

@@ -0,0 +1,143 @@
+/*
+ * 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 "dd/Node.hpp"
+#include "dd/Package.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace dd {
+/**
+ * @brief Construct the all-zero state \f$|0...0\rangle\f$
+ * @param n The number of qubits.
+ * @param dd The DD package to use for making the vector DD.
+ * @param start The starting qubit index. Default is 0.
+ * @throws `std::invalid_argument`, if `dd.qubits() < n`.
+ * @return A vector DD for the all-zero state.
+ */
+VectorDD makeZeroState(std::size_t n, Package& dd, std::size_t start = 0);
+
+/**
+ * @brief Construct a computational basis state \f$|b_{n-1}...b_0\rangle\f$
+ * @param n The number of qubits.
+ * @param state The state to construct.
+ * @param dd The DD package to use for making the vector DD.
+ * @param start The starting qubit index. Default is 0.
+ * @throws `std::invalid_argument`, if `dd.qubits() < n` or `size(state) < n`.
+ * @return A vector DD for the computational basis state.
+ */
+VectorDD makeBasisState(std::size_t n, const std::vector<bool>& state,
+                        Package& dd, std::size_t start = 0);
+
+/**
+ * @brief Construct a product state out of
+ *        \f$\{0, 1, +, -, R, L\}^{\otimes n}\f$.
+ * @param n The number of qubits
+ * @param state The state to construct.
+ * @param dd The DD package to use for making the vector DD.
+ * @param start The starting qubit index. Default is 0.
+ * @throws `std::invalid_argument`, if `dd.qubits() < n` or `size(state) < n`.
+ * @return A vector DD for the product state.
+ */
+VectorDD makeBasisState(std::size_t n, const std::vector<BasisStates>& state,
+                        Package& dd, std::size_t start = 0);
+
+/**
+ * @brief Construct a GHZ state \f$|0...0\rangle + |1...1\rangle\f$.
+ * @param n The number of qubits.
+ * @param dd The DD package to use for making the vector DD.
+ * @throws `std::invalid_argument`, if `dd.qubits() < n`.
+ * @return A vector DD for the GHZ state.
+ */
+VectorDD makeGHZState(std::size_t n, Package& dd);
+
+/**
+ * @brief Construct a W state.
+ * @details The W state is defined as
+ * \f[
+ * |0...01\rangle + |0...10\rangle + |10...0\rangle
+ * \f]
+ * @param n The number of qubits.
+ * @param dd The DD package to use for making the vector DD.
+ * @throws `std::invalid_argument`, if `dd.qubits() < n` or the number of qubits
+ * and currently set tolerance would lead to an underflow.
+ * @return A vector DD for the W state.
+ */
+VectorDD makeWState(std::size_t n, Package& dd);
+
+/**
+ * @brief Construct a decision diagram from an arbitrary state vector.
+ * @param vec The state vector to convert to a DD.
+ * @param dd The DD package to use for making the vector DD.
+ * @throws `std::invalid_argument`, if `vec.size()` is not a power of two or
+ * `dd.qubits() < log2(vec.size()) - 1`.
+ * @return A vector DD representing the state.
+ */
+VectorDD makeStateFromVector(const CVec& vec, Package& dd);
+
+/// @brief The strategy to wire two layers.
+enum GenerationWireStrategy : std::uint8_t {
+  ROUNDROBIN, // Choose nodes in the next layer in a round-robin fashion.
+  RANDOM      // Randomly choose nodes in the next layer.
+};
+
+/**
+ * @brief Generate exponentially large vector DD.
+ * @param levels The number of levels in the vector DD.
+ * @param dd The DD package to use for generating the vector DD.
+ * @throws `std::invalid_argument`, if `dd.qubits() < levels`.
+ * @return The exponentially large vector DD.
+ */
+VectorDD generateExponentialState(std::size_t levels, Package& dd);
+
+/**
+ * @brief Generate exponentially large vector DD. Use @p seed for randomization.
+ * @param levels The number of levels in the vector DD.
+ * @param dd The DD package to use for generating the vector DD.
+ * @param seed The seed used for randomization.
+ * @throws `std::invalid_argument`, if `dd.qubits() < levels`.
+ * @return The exponentially large vector DD.
+ */
+VectorDD generateExponentialState(std::size_t levels, Package& dd,
+                                  std::size_t seed);
+
+/**
+ * @brief Generate random vector DD.
+ * @param levels The number of levels in the vector DD.
+ * @param nodesPerLevel The number of nodes per level.
+ * @param strategy The strategy to wire two layers.
+ * @param dd The DD package to use for generating the vector DD.
+ * @throws `std::invalid_argument`, if `dd.qubits() < levels`.
+ * @return The random vector DD.
+ */
+VectorDD generateRandomState(std::size_t levels,
+                             const std::vector<std::size_t>& nodesPerLevel,
+                             GenerationWireStrategy strategy, Package& dd);
+
+/**
+ * @brief Generate random vector DD. Use @p seed for randomization.
+ * @param levels The number of levels in the vector DD.
+ * @param nodesPerLevel The number of nodes per level.
+ * @param strategy The strategy to wire two layers.
+ * @param dd The DD package to use for generating the vector DD.
+ * @param seed The seed used for randomization.
+ * @throws `std::invalid_argument`, if `dd.qubits() < levels`, `levels <= 0`, or
+ * `nodesPerLevel.size() != levels`.
+ * @return The random vector DD.
+ */
+VectorDD generateRandomState(std::size_t levels,
+                             const std::vector<std::size_t>& nodesPerLevel,
+                             GenerationWireStrategy strategy, Package& dd,
+                             std::size_t seed);
+}; // namespace dd

mqt/core/include/mqt-core/dd/UnaryComputeTable.hpp

@@ -29,11 +29,13 @@ namespace dd {
  * @tparam OperandType type of the operation's operand
  * @tparam ResultType type of the operation's result
  */
-template <class OperandType, class ResultType, std::size_t NBUCKET = 32768>
-class UnaryComputeTable {
+template <class OperandType, class ResultType> class UnaryComputeTable {
 public:
+  /// Default number of buckets for the compute table
+  static constexpr std::size_t DEFAULT_NUM_BUCKETS = 32768U;
+
   /// Default constructor
-  explicit UnaryComputeTable(const size_t numBuckets = 32768U) {
+  explicit UnaryComputeTable(const size_t numBuckets = DEFAULT_NUM_BUCKETS) {
     // numBuckets must be a power of two
     if ((numBuckets & (numBuckets - 1)) != 0) {
       throw std::invalid_argument("Number of buckets must be a power of two.");
@@ -106,7 +108,7 @@ public:
    * @brief Clear the compute table
    * @details Sets all entries to invalid.
    */
-  void clear() { valid = std::vector(NBUCKET, false); }
+  void clear() { valid = std::vector(stats.numBuckets, false); }
 
 private:
   /// The actual table storing the entries

mqt/core/include/mqt-core/dd/UniqueTable.hpp

@@ -96,10 +96,8 @@ public:
     }
   }
 
-  // lookup a node in the unique table for the appropriate variable; insert it,
-  // if it has not been found NOTE: reference counting is to be adjusted by
-  // function invoking the table lookup and only normalized nodes shall be
-  // stored.
+  // Lookup a node in the unique table for the appropriate variable and insert
+  // it if it has not been found. Only normalized nodes shall be stored.
   template <class Node> [[nodiscard]] Node* lookup(Node* p) {
     static_assert(std::is_base_of_v<NodeBase, Node>,
                   "Node must be derived from NodeBase");
@@ -144,42 +142,19 @@ public:
   /// Get the total number of entries
   [[nodiscard]] std::size_t getNumEntries() const noexcept;
 
-  /// Get the total number of active entries
-  [[nodiscard]] std::size_t getNumActiveEntries() const noexcept;
+  /// Count the number of marked entries
+  [[nodiscard]] std::size_t countMarkedEntries() const noexcept;
 
-  /// Get the peak total number of active entries
-  [[nodiscard]] std::size_t getPeakNumActiveEntries() const noexcept;
-
-  /**
-   * @brief Increment the reference count of a node.
-   * @details This is a pass-through function that calls the increment function
-   * of the node. It additionally keeps track of the number of active entries
-   * in the table (entries with a reference count greater than zero). Reference
-   * counts saturate at the maximum value of RefCount.
-   * @param p A pointer to the node to increase the reference count of.
-   * @returns Whether the reference count was increased.
-   * @see Node::incRef(Node*)
-   */
-  [[nodiscard]] bool incRef(NodeBase* p) noexcept;
   /**
-   * @brief Decrement the reference count of a node.
-   * @details This is a pass-through function that calls the decrement function
-   * of the node. It additionally keeps track of the number of active entries
-   * in the table (entries with a reference count greater than zero). Reference
-   * counts saturate at the maximum value of RefCount.
-   * @param p A pointer to the node to decrease the reference count of.
-   * @returns Whether the reference count was decreased.
-   * @see Node::decRef(Node*)
+   * @brief Determine whether the table possibly requires garbage collection.
    */
-  [[nodiscard]] bool decRef(NodeBase* p) noexcept;
-
   [[nodiscard]] bool possiblyNeedsCollection() const;
 
   std::size_t garbageCollect(bool force = false);
 
   void clear();
 
-  template <class Node> void print() {
+  template <class Node> void print() const {
     static_assert(std::is_base_of_v<NodeBase, Node>,
                   "Node must be derived from NodeBase");
     auto q = cfg.nVars - 1U;
@@ -194,8 +169,8 @@ public:
         }
 
         while (p != nullptr) {
-          std::cout << "\t\t" << std::hex << reinterpret_cast<std::uintptr_t>(p)
-                    << std::dec << " " << p->ref << std::hex;
+          std::cout << "\t\t" << std::hex
+                    << reinterpret_cast<std::uintptr_t>(p);
           for (const auto& e : p->e) {
             std::cout << " p" << reinterpret_cast<std::uintptr_t>(e.p) << "(r"
                       << reinterpret_cast<std::uintptr_t>(e.w.r) << " i"
@@ -235,12 +210,11 @@ private:
   std::vector<UniqueTableStatistics> stats;
 
   /**
-  Searches for a node in the hash table with the given key.
-  @param p The node to search for.
-  @param key The hashed value used to search the table.
-  @return The Edge<Node> found in the hash table or Edge<Node>::zero if not
-  found.
-  **/
+   * @brief Search for a node in the hash table with the given key.
+   * @param p The node to search for.
+   * @param key The hashed value used to search the table.
+   * @returns A pointer to the node if found or Node::getTerminal() otherwise.
+   */
   template <class Node>
   [[nodiscard]] Node* searchTable(Node& p, const std::size_t& key) {
     static_assert(std::is_base_of_v<NodeBase, Node>,

mqt/core/include/mqt-core/dd/statistics/PackageStatistics.hpp

@@ -20,13 +20,14 @@ namespace dd {
 
 /**
  * @brief Computes an estimate for the memory usage of active DDs.
- * @details The estimate is based on the number of active entries in the
- * respective unique tables. It accounts for the memory used by DD nodes, DD
- * edges, and real numbers.
+ * @details The estimate is based on the number of active entries which are
+ * computed by temporarily marking all nodes reachable from the current root
+ * set and subsequently counting them in the unique tables. It accounts for the
+ * memory used by DD nodes, DD edges, and real numbers.
  * @param package The package instance
  * @return The estimated memory usage in MiB
  */
-[[nodiscard]] double computeActiveMemoryMiB(const Package& package);
+[[nodiscard]] double computeActiveMemoryMiB(Package& package);
 
 /**
  * @brief Computes an estimate for the peak memory usage of DDs.
@@ -39,7 +40,7 @@ namespace dd {
 [[nodiscard]] double computePeakMemoryMiB(const Package& package);
 
 [[nodiscard]] nlohmann::basic_json<>
-getStatistics(const Package& package, bool includeIndividualTables = false);
+getStatistics(Package& package, bool includeIndividualTables = false);
 
 /**
  * @brief Get some key statistics about data structures used by the DD package
@@ -47,8 +48,8 @@ getStatistics(const Package& package, bool includeIndividualTables = false);
  */
 [[nodiscard]] nlohmann::basic_json<> getDataStructureStatistics();
 
-[[nodiscard]] std::string getStatisticsString(const Package& package);
+[[nodiscard]] std::string getStatisticsString(Package& package);
 
-void printStatistics(const Package& package, std::ostream& os = std::cout);
+void printStatistics(Package& package, std::ostream& os = std::cout);
 
 } // namespace dd

mqt/core/include/mqt-core/dd/statistics/UniqueTableStatistics.hpp

@@ -18,19 +18,9 @@
 namespace dd {
 /// \brief A class for storing statistics of a unique table
 struct UniqueTableStatistics : public TableStatistics {
-  /**
-   * @brief The total number of active entries
-   * @details An entry is considered active if it has a non-zero reference count
-   */
-  std::size_t numActiveEntries = 0U;
-  /// The peak number of active entries in the table
-  std::size_t peakNumActiveEntries = 0U;
   /// The number of garbage collection runs
   std::size_t gcRuns = 0U;
 
-  /// Track a new active entry
-  void trackActiveEntry() noexcept;
-
   /// Reset all statistics (except for the peak values)
   void reset() noexcept override;
 

mqt/core/include/mqt-core/ir/QuantumComputation.hpp

@@ -124,6 +124,9 @@ public:
   [[nodiscard]] decltype(mt)& getGenerator() noexcept { return mt; }
 
   [[nodiscard]] fp getGlobalPhase() const noexcept { return globalPhase; }
+  [[nodiscard]] bool hasGlobalPhase() const noexcept {
+    return std::abs(getGlobalPhase()) > 0;
+  }
 
   [[nodiscard]] const std::unordered_set<sym::Variable>&
   getVariables() const noexcept {

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

@@ -48,6 +48,8 @@ public:
 
   [[nodiscard]] std::unique_ptr<Operation> clone() const override;
 
+  [[nodiscard]] size_t getNqubits() const override;
+
   [[nodiscard]] bool isCompoundOperation() const noexcept override;
 
   [[nodiscard]] bool isNonUnitaryOperation() const override;

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

@@ -68,8 +68,8 @@ public:
   [[nodiscard]] virtual std::size_t getNcontrols() const {
     return controls.size();
   }
-  [[nodiscard]] std::size_t getNqubits() const {
-    return getUsedQubits().size();
+  [[nodiscard]] virtual std::size_t getNqubits() const {
+    return getNcontrols() + getNtargets();
   }
 
   [[nodiscard]] const std::vector<fp>& getParameter() const {

mqt/core/plugins/__init__.py

@@ -7,11 +7,3 @@
 # Licensed under the MIT License
 
 """Plugins for the core package."""
-
-from __future__ import annotations
-
-from . import qiskit
-
-__all__ = [
-    "qiskit",
-]

mqt/core/plugins/qiskit/qiskit_to_mqt.py

@@ -150,6 +150,7 @@ _NATIVELY_SUPPORTED_GATES = frozenset({
     "sxdg",
     "csx",
     "mcx",
+    # we keep the "mcx_*" variants here for compatibility with Qiskit 1.x
     "mcx_gray",
     "mcx_recursive",
     "mcx_vchain",
@@ -207,6 +208,8 @@ def _emplace_operation(
     if name in {"i", "id", "iden"}:
         return _add_operation(qc, OpType.i, qargs, params, qubit_map)
 
+    # we keep "mcx_gray" here for compatibility reasons with older Qiskit versions, e.g., 1.0.0 where "noancilla"
+    # is the default for the argument "mode" which leads to the gate name "gray_code"
     if name in {"x", "cx", "ccx", "mcx", "mcx_gray"}:
         return _add_operation(qc, OpType.x, qargs, params, qubit_map)
 
@@ -234,6 +237,9 @@ def _emplace_operation(
     if name in {"sx", "csx"}:
         return _add_operation(qc, OpType.sx, qargs, params, qubit_map)
 
+    if name == "sxdg":
+        return _add_operation(qc, OpType.sxdg, qargs, params, qubit_map)
+
     if name == "mcx_recursive":
         if len(qargs) <= 5:
             return _add_operation(qc, OpType.x, qargs, params, qubit_map)