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
    *

src/Mapper.cpp

@@ -302,3 +302,44 @@ 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

@@ -294,26 +294,14 @@ void ExactMapper::map(const Configuration& settings) {
                       << " with control and target: " << controlledGate.first
                       << " " << controlledGate.second << std::endl;
           }
-          qcMapped.h(reverse.first);
-          qcMapped.h(reverse.second);
-          qcMapped.emplace_back<qc::StandardOperation>(
-              qcMapped.getNqubits(),
-              qc::Control{static_cast<qc::Qubit>(reverse.first)},
-              reverse.second, op->getType(), op->getParameter().at(0),
-              op->getParameter().at(1), op->getParameter().at(2));
-          qcMapped.h(reverse.second);
-          qcMapped.h(reverse.first);
+          insertFlippedGate(reverse, op);
         } else {
           if (settings.verbose) {
             std::cout << i << ": Added controlled gate " << op->getName()
                       << " with control and target: " << controlledGate.first
                       << " " << controlledGate.second << std::endl;
           }
-          qcMapped.emplace_back<qc::StandardOperation>(
-              qcMapped.getNqubits(),
-              qc::Control{static_cast<qc::Qubit>(controlledGate.first)},
-              controlledGate.second, op->getType(), op->getParameter().at(0),
-              op->getParameter().at(1), op->getParameter().at(2));
+          insertGate(controlledGate, op);
         }
       }
     }

src/heuristic/HeuristicMapper.cpp

@@ -106,25 +106,10 @@ void HeuristicMapper::map(const Configuration& configuration) {
                                 ": " + std::to_string(reverse.first) + "-" +
                                 std::to_string(reverse.second));
           }
-          qcMapped.h(reverse.first);
-          qcMapped.h(reverse.second);
-          qcMapped.emplace_back<qc::StandardOperation>(
-              qcMapped.getNqubits(),
-              qc::Control{static_cast<qc::Qubit>(reverse.first)},
-              reverse.second, op->getType(), op->getParameter().at(0),
-              op->getParameter().at(1), op->getParameter().at(2));
-          qcMapped.h(reverse.second);
-          qcMapped.h(reverse.first);
-
+          gateidx += insertFlippedGate(reverse, op);
           results.output.directionReverse++;
-          gateidx += 5;
         } else {
-          qcMapped.emplace_back<qc::StandardOperation>(
-              qcMapped.getNqubits(),
-              qc::Control{static_cast<qc::Qubit>(controlledGate.first)},
-              controlledGate.second, op->getType(), op->getParameter().at(0),
-              op->getParameter().at(1), op->getParameter().at(2));
-          gateidx++;
+          gateidx += insertGate(controlledGate, op);
         }
       }
     }