Generalize concept of removing OpTypes (#624)

cda-tum · Jun 5, 2024 · 86d93b5 · 86d93b5
1 parent 2782f37
commit 86d93b5
Show file tree

Hide file tree

Showing 3 changed files with 95 additions and 2 deletions.
diff --git a/include/mqt-core/CircuitOptimizer.hpp b/include/mqt-core/CircuitOptimizer.hpp
@@ -2,10 +2,12 @@
 
 #include "Definitions.hpp"
 #include "QuantumComputation.hpp"
+#include "operations/OpType.hpp"
 #include "operations/Operation.hpp"
 
 #include <cstddef>
 #include <memory>
+#include <unordered_set>
 
 namespace qc {
 
@@ -28,6 +30,10 @@ class CircuitOptimizer {
 
   static void removeIdentities(QuantumComputation& qc);
 
+  static void removeOperation(qc::QuantumComputation& qc,
+                              const std::unordered_set<OpType>& opTypes,
+                              size_t opSize);
+
   static void removeDiagonalGatesBeforeMeasure(QuantumComputation& qc);
 
   static void removeFinalMeasurements(QuantumComputation& qc);

diff --git a/src/CircuitOptimizer.cpp b/src/CircuitOptimizer.cpp
@@ -28,16 +28,25 @@
 namespace qc {
 void CircuitOptimizer::removeIdentities(QuantumComputation& qc) {
   // delete the identities from circuit
+  CircuitOptimizer::removeOperation(qc, {I}, 0);
+}
+
+void CircuitOptimizer::removeOperation(
+    qc::QuantumComputation& qc, const std::unordered_set<OpType>& opTypes,
+    const size_t opSize) {
+  // opSize = 0 means that the operation can have any number of qubits
   auto it = qc.ops.begin();
   while (it != qc.ops.end()) {
-    if ((*it)->getType() == I) {
+    if (opTypes.find((*it)->getType()) != opTypes.end() &&
+        (opSize == 0 || it->get()->getNqubits() == opSize)) {
       it = qc.ops.erase(it);
     } else if ((*it)->isCompoundOperation()) {
       auto* compOp = dynamic_cast<qc::CompoundOperation*>((*it).get());
       auto cit = compOp->cbegin();
       while (cit != compOp->cend()) {
         const auto* cop = cit->get();
-        if (cop->getType() == qc::I) {
+        if (opTypes.find(cop->getType()) != opTypes.end() &&
+            (opSize == 0 || cop->getNqubits() == opSize)) {
           cit = compOp->erase(cit);
         } else {
           ++cit;

diff --git a/test/unittests/test_qfr_functionality.cpp b/test/unittests/test_qfr_functionality.cpp
@@ -266,6 +266,84 @@ TEST_F(QFRFunctionality, eliminateCompoundOperation) {
   EXPECT_TRUE(qc.empty());
 }
 
+TEST_F(QFRFunctionality, removeIdentities) {
+  const std::size_t nqubits = 1;
+  QuantumComputation qc(nqubits);
+  qc.i(0);
+  qc.i(0);
+  qc.x(0);
+  qc.i(0);
+  qc.i(0);
+  std::cout << "-----------------------------\n";
+  qc.print(std::cout);
+  CircuitOptimizer::removeIdentities(qc);
+  std::cout << "-----------------------------\n";
+  qc.print(std::cout);
+  EXPECT_EQ(qc.getNops(), 1);
+}
+
+TEST_F(QFRFunctionality, removeSingleQubitGates) {
+  const std::size_t nqubits = 1;
+  QuantumComputation qc(nqubits);
+  qc.x(0);
+  qc.x(0);
+  qc.y(0);
+  qc.i(0);
+  std::cout << "-----------------------------\n";
+  qc.print(std::cout);
+  CircuitOptimizer::removeOperation(qc, {X, Y}, 1);
+  std::cout << "-----------------------------\n";
+  qc.print(std::cout);
+  EXPECT_EQ(qc.getNops(), 1);
+}
+
+TEST_F(QFRFunctionality, removeMultiQubitGates) {
+  const std::size_t nqubits = 2;
+  QuantumComputation qc(nqubits);
+  qc.x(0);
+  qc.cx(0, 1);
+  qc.cy(1, 1);
+  std::cout << "-----------------------------\n";
+  qc.print(std::cout);
+  CircuitOptimizer::removeOperation(qc, {X, Y}, 2);
+  std::cout << "-----------------------------\n";
+  qc.print(std::cout);
+  EXPECT_EQ(qc.getNops(), 2);
+}
+
+TEST_F(QFRFunctionality, removeMoves) {
+  const std::size_t nqubits = 2;
+  QuantumComputation qc(nqubits);
+  qc.x(0);
+  qc.move(0, 1);
+  qc.cy(1, 1);
+  std::cout << "-----------------------------\n";
+  qc.print(std::cout);
+  CircuitOptimizer::removeOperation(qc, {Move}, 0);
+  std::cout << "-----------------------------\n";
+  qc.print(std::cout);
+  EXPECT_EQ(qc.getNops(), 2);
+}
+
+TEST_F(QFRFunctionality, removeGateInCompoundOperation) {
+  const std::size_t nqubits = 1;
+  QuantumComputation qc(nqubits);
+  QuantumComputation compound(nqubits);
+  compound.x(0);
+  compound.y(0);
+  compound.z(0);
+  qc.emplace_back(compound.asOperation());
+  std::cout << "-----------------------------\n";
+  qc.print(std::cout);
+  CircuitOptimizer::removeOperation(qc, {Y}, 1);
+  std::cout << "-----------------------------\n";
+  qc.print(std::cout);
+  EXPECT_EQ(qc.getNops(), 1);
+  EXPECT_EQ(qc.front()->getType(), Compound);
+  auto* compoundOp = dynamic_cast<CompoundOperation*>(qc.front().get());
+  EXPECT_EQ(compoundOp->size(), 2);
+}
+
 TEST_F(QFRFunctionality, eliminateInverseInCompoundOperation) {
   const std::size_t nqubits = 1;
   QuantumComputation qc(nqubits);