Support any two qubit gates

include/Mapper.hpp

@@ -152,13 +152,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 controlled 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, qc::StandardOperation* 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 insertFlippedGate(const Edge& edge, qc::StandardOperation* op);
+
   /**
    * @brief performs optimizations on the circuit before mapping
    *

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 {

mqt/qmap/bindings.cpp

@@ -240,7 +240,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",

src/Mapper.cpp

@@ -280,18 +280,17 @@ void Mapper::countGates(decltype(qcMapped.cbegin())      it,
       if (g->getType() == qc::SWAP) {
         if (architecture.bidirectional()) {
           info.gates += GATES_OF_BIDIRECTIONAL_SWAP;
-          info.cnots += GATES_OF_BIDIRECTIONAL_SWAP;
+          info.twoQubitGates += GATES_OF_BIDIRECTIONAL_SWAP;
         } else {
           info.gates += GATES_OF_UNIDIRECTIONAL_SWAP;
-          info.cnots += GATES_OF_BIDIRECTIONAL_SWAP;
+          info.twoQubitGates += GATES_OF_BIDIRECTIONAL_SWAP;
           info.singleQubitGates += GATES_OF_DIRECTION_REVERSE;
         }
       } else if (g->getControls().empty()) {
         ++info.singleQubitGates;
         ++info.gates;
       } else {
-        assert(g->getType() == qc::X);
-        ++info.cnots;
+        ++info.twoQubitGates;
         ++info.gates;
       }
       continue;
@@ -303,3 +302,45 @@ void Mapper::countGates(decltype(qcMapped.cbegin())      it,
     }
   }
 }
+std::size_t Mapper::insertGate(const Edge& edge, qc::StandardOperation* op) {
+  qcMapped.emplace_back<qc::StandardOperation>(
+      qcMapped.getNqubits(), qc::Control{static_cast<qc::Qubit>(edge.first)},
+      edge.second, op->getType(), op->getParameter().at(0),
+      op->getParameter().at(1), op->getParameter().at(2));
+  return 1;
+}
+
+std::size_t Mapper::insertFlippedGate(const Edge&            edge,
+                                      qc::StandardOperation* op) {
+  int swapType = -1;
+  switch (op->getType()) {
+  case qc::X:
+    swapType = 1;
+    break;
+  case qc::Z:
+    swapType = 0;
+    break;
+  default:
+    swapType = -1;
+  }
+
+  if (swapType == 0) {
+    // no additional gates required to reverse direction
+    return insertGate(edge, op);
+  }
+  if (swapType == 1) {
+    // four hadamard gates to reverse direction
+    qcMapped.h(edge.first);
+    qcMapped.h(edge.second);
+    auto tmp = insertGate(edge, op);
+    qcMapped.h(edge.first);
+    qcMapped.h(edge.second);
+    return tmp + 4;
+  }
+
+  // in all other cases, swap gates are used to reverse direction
+  qcMapped.swap(edge.first, edge.second);
+  auto tmp = insertGate(edge, op);
+  qcMapped.swap(edge.second, edge.first);
+  return 2 + tmp;
+}

src/exact/ExactMapper.cpp

@@ -275,38 +275,33 @@ void ExactMapper::map(const Configuration& settings) {
             op->getParameter().at(0), op->getParameter().at(1),
             op->getParameter().at(2));
       } else {
-        const Edge cnot = {locations.at(static_cast<std::size_t>(gate.control)),
-                           locations.at(gate.target)};
+        const Edge controlledGate = {
+            locations.at(static_cast<std::size_t>(gate.control)),
+            locations.at(gate.target)};
 
-        if (architecture.getCouplingMap().find(cnot) ==
+        if (architecture.getCouplingMap().find(controlledGate) ==
             architecture.getCouplingMap().end()) {
-          const Edge reverse = {cnot.second, cnot.first};
+          const Edge reverse = {controlledGate.second, controlledGate.first};
           if (architecture.getCouplingMap().find(reverse) ==
               architecture.getCouplingMap().end()) {
-            throw QMAPException(
-                "Invalid CNOT: " + std::to_string(reverse.first) + "-" +
-                std::to_string(reverse.second));
+            throw QMAPException("Invalid controlled gate " + op->getName() +
+                                ": " + std::to_string(reverse.first) + "-" +
+                                std::to_string(reverse.second));
           }
           if (settings.verbose) {
-            std::cout
-                << i
-                << ": Added (direction-reversed) cnot with control and target: "
-                << cnot.first << " " << cnot.second << std::endl;
+            std::cout << i << ": Added (direction-reversed) controlled gate "
+                      << op->getName()
+                      << " with control and target: " << controlledGate.first
+                      << " " << controlledGate.second << std::endl;
           }
-          qcMapped.h(reverse.first);
-          qcMapped.h(reverse.second);
-          qcMapped.x(reverse.second,
-                     qc::Control{static_cast<qc::Qubit>(reverse.first)});
-          qcMapped.h(reverse.second);
-          qcMapped.h(reverse.first);
+          insertFlippedGate(reverse, op);
         } else {
           if (settings.verbose) {
-            std::cout << i
-                      << ": Added cnot with control and target: " << cnot.first
-                      << " " << cnot.second << std::endl;
+            std::cout << i << ": Added controlled gate " << op->getName()
+                      << " with control and target: " << controlledGate.first
+                      << " " << controlledGate.second << std::endl;
           }
-          qcMapped.x(cnot.second,
-                     qc::Control{static_cast<qc::Qubit>(cnot.first)});
+          insertGate(controlledGate, op);
         }
       }
     }
@@ -354,7 +349,7 @@ void ExactMapper::map(const Configuration& settings) {
 
   // 10) re-count gates
   results.output.singleQubitGates = 0U;
-  results.output.cnots            = 0U;
+  results.output.twoQubitGates    = 0U;
   results.output.gates            = 0U;
   countGates(qcMapped, results.output);
 
@@ -762,9 +757,9 @@ number of variables: (|L|-1) * m!
     // quickly determine cost
     choiceResults.output.singleQubitGates =
         choiceResults.input.singleQubitGates;
-    choiceResults.output.cnots = choiceResults.input.cnots;
-    choiceResults.output.gates =
-        choiceResults.output.singleQubitGates + choiceResults.output.cnots;
+    choiceResults.output.twoQubitGates = choiceResults.input.twoQubitGates;
+    choiceResults.output.gates         = choiceResults.output.singleQubitGates +
+                                 choiceResults.output.twoQubitGates;
     assert(choiceResults.output.swaps == 0U);
     assert(choiceResults.output.directionReverse == 0U);
     // swaps

src/heuristic/HeuristicMapper.cpp

@@ -94,31 +94,22 @@ void HeuristicMapper::map(const Configuration& configuration) {
           gateidx++;
         }
       } else {
-        const Edge cnot = {
+        const Edge controlledGate = {
             locations.at(static_cast<std::uint16_t>(gate.control)),
             locations.at(gate.target)};
-        if (architecture.getCouplingMap().find(cnot) ==
+        if (architecture.getCouplingMap().find(controlledGate) ==
             architecture.getCouplingMap().end()) {
-          const Edge reverse = {cnot.second, cnot.first};
+          const Edge reverse = {controlledGate.second, controlledGate.first};
           if (architecture.getCouplingMap().find(reverse) ==
               architecture.getCouplingMap().end()) {
-            throw QMAPException(
-                "Invalid CNOT: " + std::to_string(reverse.first) + "-" +
-                std::to_string(reverse.second));
+            throw QMAPException("Invalid controlled gate " + op->getName() +
+                                ": " + std::to_string(reverse.first) + "-" +
+                                std::to_string(reverse.second));
           }
-          qcMapped.h(reverse.first);
-          qcMapped.h(reverse.second);
-          qcMapped.x(reverse.second,
-                     qc::Control{static_cast<qc::Qubit>(reverse.first)});
-          qcMapped.h(reverse.second);
-          qcMapped.h(reverse.first);
-
+          gateidx += insertFlippedGate(reverse, op);
           results.output.directionReverse++;
-          gateidx += 5;
         } else {
-          qcMapped.x(cnot.second,
-                     qc::Control{static_cast<qc::Qubit>(cnot.first)});
-          gateidx++;
+          gateidx += insertGate(controlledGate, op);
         }
       }
     }