Support any two qubit gates

include/Architecture.hpp

@@ -15,6 +15,7 @@
 #include <map>
 #include <regex>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
 
 constexpr std::uint8_t GATES_OF_BIDIRECTIONAL_SWAP  = 3U;
@@ -32,6 +33,8 @@ constexpr std::uint32_t COST_TELEPORTATION =
     2 * COST_CNOT_GATE + COST_MEASUREMENT + 4 * COST_SINGLE_QUBIT_GATE;
 constexpr std::uint32_t COST_DIRECTION_REVERSE = 4 * COST_SINGLE_QUBIT_GATE;
 
+enum class DirectionReversalStrategy { Identity, Hadamard, NotApplicable };
+
 class Architecture {
 public:
   class Properties {
@@ -242,7 +245,9 @@ class Architecture {
     return teleportationQubits;
   }
 
-  [[nodiscard]] const Matrix& getDistanceTable() const { return distanceTable; }
+  [[nodiscard]] const DistanceTable& getDistanceTable() const {
+    return distanceTable;
+  }
 
   [[nodiscard]] const Properties& getProperties() const { return properties; }
 
@@ -279,10 +284,19 @@ class Architecture {
     singleQubitFidelities.clear();
   }
 
-  [[nodiscard]] double distance(std::uint16_t control,
-                                std::uint16_t target) const {
+  [[nodiscard]] double distance(std::uint16_t control, std::uint16_t target,
+                                const qc::OpType opType) const {
     if (currentTeleportations.empty()) {
-      return distanceTable.at(control).at(target);
+      const auto& distanceEntry = distanceTable.at(control).at(target);
+      auto        dist          = distanceEntry.first;
+      if (distanceEntry.second && opType != qc::None) {
+        if (supportsDirectionReversal(opType)) {
+          dist += computeCostDirectionReverse(opType);
+        } else {
+          dist += 10000;
+        }
+      }
+      return dist;
     }
     return static_cast<double>(bfs(control, target, currentTeleportations));
   }
@@ -348,13 +362,19 @@ class Architecture {
 
   static void printCouplingMap(const CouplingMap& cm, std::ostream& os);
 
+  static DirectionReversalStrategy
+                       getDirectionReversalStrategy(qc::OpType opType);
+  static std::uint32_t computeCostDirectionReverse(qc::OpType opType);
+  static std::uint32_t computeGatesDirectionReverse(qc::OpType opType);
+  static bool          supportsDirectionReversal(qc::OpType opType);
+
 protected:
   std::string                                        name;
   std::uint16_t                                      nqubits               = 0;
   CouplingMap                                        couplingMap           = {};
   CouplingMap                                        currentTeleportations = {};
   bool                                               isBidirectional = true;
-  Matrix                                             distanceTable   = {};
+  DistanceTable                                      distanceTable   = {};
   std::vector<std::pair<std::int16_t, std::int16_t>> teleportationQubits{};
   Properties                                         properties            = {};
   Matrix                                             fidelityTable         = {};
@@ -363,21 +383,23 @@ class Architecture {
   void createDistanceTable();
   void createFidelityTable();
 
-  static double costHeuristicBidirectional(const Dijkstra::Node& node) {
+  static std::pair<double, bool>
+  costHeuristicBidirectional(const Dijkstra::Node& node) {
     auto length = node.cost - 1;
     if (node.containsCorrectEdge) {
-      return length * COST_BIDIRECTIONAL_SWAP;
+      return {length * COST_BIDIRECTIONAL_SWAP, false};
     }
     throw QMAPException("In a bidrectional architecture it should not happen "
                         "that a node does not contain the right edge.");
   }
 
-  static double costHeuristicUnidirectional(const Dijkstra::Node& node) {
+  static std::pair<double, bool>
+  costHeuristicUnidirectional(const Dijkstra::Node& node) {
     auto length = node.cost - 1;
     if (node.containsCorrectEdge) {
-      return length * COST_UNIDIRECTIONAL_SWAP;
+      return {length * COST_UNIDIRECTIONAL_SWAP, false};
     }
-    return length * COST_UNIDIRECTIONAL_SWAP + COST_DIRECTION_REVERSE;
+    return {length * COST_UNIDIRECTIONAL_SWAP, true};
   }
 
   // added for teleportation
@@ -390,10 +412,10 @@ class Architecture {
   static std::size_t findCouplingLimit(const CouplingMap& cm,
                                        std::uint16_t      nQubits);
   static std::size_t
-  findCouplingLimit(const CouplingMap& cm, std::uint16_t nQubits,
-                    const std::set<std::uint16_t>& qubitChoice);
-  static void
-  findCouplingLimit(std::uint16_t node, std::uint16_t curSum,
-                    const std::vector<std::vector<std::uint16_t>>& connections,
-                    std::vector<std::uint16_t>& d, std::vector<bool>& visited);
+              findCouplingLimit(const CouplingMap& cm, std::uint16_t nQubits,
+                                const std::set<std::uint16_t>& qubitChoice);
+  static void findCouplingLimit(
+      std::uint16_t node, std::uint16_t curSum,
+      const std::vector<std::unordered_set<std::uint16_t>>& connections,
+      std::vector<std::uint16_t>& d, std::vector<bool>& visited);
 };

include/Mapper.hpp

@@ -157,13 +157,33 @@ class Mapper {
     countGates(circuit.cbegin(), circuit.cend(), info);
   }
   /**
-   * @brief count number of elementary gates and cnots in circuit and save the
-   * results in `info.gates` and `info.cnots`
+   * @brief count number of elementary gates and two-qubit gates in circuit and
+   * save the results in `info.gates` and `info.twoQubitGates`
    */
   virtual void countGates(decltype(qcMapped.cbegin())      it,
                           const decltype(qcMapped.cend())& end,
                           MappingResults::CircuitInfo&     info);
 
+  /**
+   * @brief inserts a two qubit operation op along edge.
+   * @param edge the edge in the coupling graph that controls on which physical
+   * qubits the operation will act. The logical and physical direction are the
+   * same.
+   * @param op the operation which is inserted
+   * @return total number of inserted operations
+   */
+  std::size_t insertGate(const Edge& edge, const qc::Operation& op);
+
+  /**
+   * @brief inserts a two qubit operation op along a direction reversed edge.
+   * @param edge the edge in the coupling graph that controls on which physical
+   * qubits the operation will act. The logical direction of the operation is
+   * the reverse of the physical direction.
+   * @param op the operation which is inserted
+   * @return total number of inserted operations
+   */
+  std::size_t insertReversedGate(const Edge& edge, const qc::Operation& op);
+
   /**
    * @brief performs optimizations on the circuit before mapping
    *
@@ -234,6 +254,9 @@ class Mapper {
 
   virtual MappingResults& getResults() { return results; }
 
+  const qc::QuantumComputation& getMappedCircuit() const { return qcMapped; }
+  qc::QuantumComputation&       getMappedCircuit() { return qcMapped; }
+
   virtual nlohmann::json json() { return results.json(); }
 
   virtual std::string csv() { return results.csv(); }

include/MappingResults.hpp

@@ -19,7 +19,7 @@ struct MappingResults {
     std::uint16_t qubits           = 0;
     std::size_t   gates            = 0;
     std::size_t   singleQubitGates = 0;
-    std::size_t   cnots            = 0;
+    std::size_t   twoQubitGates    = 0;
     std::size_t   layers           = 0;
 
     // info in output circuit
@@ -62,14 +62,14 @@ struct MappingResults {
     circuit["qubits"]             = input.qubits;
     circuit["gates"]              = input.gates;
     circuit["single_qubit_gates"] = input.singleQubitGates;
-    circuit["cnots"]              = input.cnots;
+    circuit["cnots"]              = input.twoQubitGates;
 
     auto& mappedCirc                 = resultJSON["mapped_circuit"];
     mappedCirc["name"]               = output.name;
     mappedCirc["qubits"]             = output.qubits;
     mappedCirc["gates"]              = output.gates;
     mappedCirc["single_qubit_gates"] = output.singleQubitGates;
-    mappedCirc["cnots"]              = output.cnots;
+    mappedCirc["cnots"]              = output.twoQubitGates;
     if (!mappedCircuit.empty()) {
       mappedCirc["qasm"] = mappedCircuit;
     }
@@ -100,11 +100,11 @@ struct MappingResults {
   virtual std::string csv() {
     std::stringstream ss{};
     ss << input.name << ";" << input.qubits << ";" << input.gates << ";"
-       << input.singleQubitGates << ";" << input.cnots << ";" << architecture
-       << ";" << output.name << ";" << output.qubits << ";" << output.gates
-       << ";" << output.singleQubitGates << ";" << output.cnots << ";"
-       << output.swaps << ";" << output.directionReverse << ";"
-       << output.teleportations << ";";
+       << input.singleQubitGates << ";" << input.twoQubitGates << ";"
+       << architecture << ";" << output.name << ";" << output.qubits << ";"
+       << output.gates << ";" << output.singleQubitGates << ";"
+       << output.twoQubitGates << ";" << output.swaps << ";"
+       << output.directionReverse << ";" << output.teleportations << ";";
     if (timeout) {
       ss << "TO";
     } else {

include/heuristic/HeuristicMapper.hpp

@@ -179,19 +179,28 @@ class HeuristicMapper : public Mapper {
           continue;
         }
 
-        auto cost = arch.distance(
-            static_cast<std::uint16_t>(
-                locations.at(static_cast<std::uint16_t>(gate.control))),
-            static_cast<std::uint16_t>(locations.at(gate.target)));
+        auto cost =
+            arch.distance(static_cast<std::uint16_t>(locations.at(
+                              static_cast<std::uint16_t>(gate.control))),
+                          static_cast<std::uint16_t>(locations.at(gate.target)),
+                          gate.op->getType());
         auto fidelityCost = cost;
         if (admissibleHeuristic) {
           costHeur = std::max(costHeur, fidelityCost);
         } else {
           costHeur += fidelityCost;
         }
-        if (cost > COST_DIRECTION_REVERSE) {
-          done = false;
-          return;
+        if (Architecture::supportsDirectionReversal(gate.op->getType())) {
+          if (cost >
+              Architecture::computeCostDirectionReverse(gate.op->getType())) {
+            done = false;
+            return;
+          }
+        } else {
+          if (cost > COST_UNIDIRECTIONAL_SWAP * 2) {
+            done = false;
+            return;
+          }
         }
       }
     }
@@ -230,20 +239,22 @@ class HeuristicMapper : public Mapper {
    * @brief returns distance of the given logical qubit pair according to the
    * current mapping
    */
-  double distanceOnArchitectureOfLogicalQubits(std::uint16_t control,
-                                               std::uint16_t target) {
+  double distanceOnArchitectureOfLogicalQubits(std::uint16_t    control,
+                                               std::uint16_t    target,
+                                               const qc::OpType opType) {
     return architecture.distance(
         static_cast<std::uint16_t>(locations.at(control)),
-        static_cast<std::uint16_t>(locations.at(target)));
+        static_cast<std::uint16_t>(locations.at(target)), opType);
   }
 
   /**
    * @brief returns distance of the given physical qubit pair on the
    * architecture
    */
-  double distanceOnArchitectureOfPhysicalQubits(std::uint16_t control,
-                                                std::uint16_t target) {
-    return architecture.distance(control, target);
+  double distanceOnArchitectureOfPhysicalQubits(std::uint16_t    control,
+                                                std::uint16_t    target,
+                                                const qc::OpType opType) {
+    return architecture.distance(control, target, opType);
   }
 
   /**
@@ -254,7 +265,8 @@ class HeuristicMapper : public Mapper {
    * to `target`
    * @param target an unmapped logical qubit
    */
-  virtual void mapToMinDistance(std::uint16_t source, std::uint16_t target);
+  virtual void mapToMinDistance(std::uint16_t source, std::uint16_t target,
+                                const qc::OpType opType);
 
   /**
    * @brief gathers all qubits that are acted on by a 2-qubit-gate in the given

include/utils.hpp

@@ -20,10 +20,11 @@
 #include <unordered_set>
 #include <vector>
 
-using Matrix      = std::vector<std::vector<double>>;
-using Edge        = std::pair<std::uint16_t, std::uint16_t>;
-using CouplingMap = std::set<Edge>;
-using QubitSubset = std::set<std::uint16_t>;
+using Matrix        = std::vector<std::vector<double>>;
+using DistanceTable = std::vector<std::vector<std::pair<double, bool>>>;
+using Edge          = std::pair<std::uint16_t, std::uint16_t>;
+using CouplingMap   = std::set<Edge>;
+using QubitSubset   = std::set<std::uint16_t>;
 
 struct Exchange {
   Exchange(const std::uint16_t f, const std::uint16_t s, const qc::OpType type)
@@ -60,9 +61,10 @@ class Dijkstra {
     double                       cost                = -1.;
   };
 
-  static void buildTable(std::uint16_t n, const CouplingMap& couplingMap,
-                         Matrix& distanceTable,
-                         const std::function<double(const Node&)>& cost);
+  static void
+  buildTable(std::uint16_t n, const CouplingMap& couplingMap,
+             DistanceTable& distanceTable,
+             const std::function<std::pair<double, bool>(const Node&)>& cost);
 
 protected:
   static void dijkstra(const CouplingMap& couplingMap, std::vector<Node>& nodes,

mqt/qmap/bindings.cpp

@@ -241,7 +241,8 @@ PYBIND11_MODULE(pyqmap, m) {
       .def_readwrite("gates", &MappingResults::CircuitInfo::gates)
       .def_readwrite("single_qubit_gates",
                      &MappingResults::CircuitInfo::singleQubitGates)
-      .def_readwrite("cnots", &MappingResults::CircuitInfo::cnots)
+      .def_readwrite("two_qubit_gates",
+                     &MappingResults::CircuitInfo::twoQubitGates)
       .def_readwrite("layers", &MappingResults::CircuitInfo::layers)
       .def_readwrite("swaps", &MappingResults::CircuitInfo::swaps)
       .def_readwrite("direction_reverse",

pyproject.toml

@@ -107,8 +107,7 @@ log_cli_level = "INFO"
 xfail_strict = true
 filterwarnings = [
     "error",
-    # See https://github.com/Qiskit/rustworkx/pull/728
-    'ignore:RetworkxLoader.exec_module\(\) not found; falling back to load_module\(\):ImportWarning',
+    'ignore:__package__ != __spec__.parent:ImportWarning',
 ]
 [tool.coverage.run]
 source = ["mqt.qmap"]