Support any two qubit gates

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;

src/exact/ExactMapper.cpp

@@ -275,38 +275,45 @@ 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.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);
         } 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)});
+          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));
         }
       }
     }
@@ -354,7 +361,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 +769,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,30 +94,36 @@ 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.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);
 
           results.output.directionReverse++;
           gateidx += 5;
         } else {
-          qcMapped.x(cnot.second,
-                     qc::Control{static_cast<qc::Qubit>(cnot.first)});
+          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++;
         }
       }