♻️ optimize isDynamic check and move to QuantumComputation class

include/mqt-core/circuit_optimizer/CircuitOptimizer.hpp

@@ -40,8 +40,6 @@ class CircuitOptimizer {
 
   static void deferMeasurements(QuantumComputation& qc);
 
-  static bool isDynamicCircuit(QuantumComputation& qc);
-
   static void flattenOperations(QuantumComputation& qc,
                                 bool customGatesOnly = false);
 

include/mqt-core/ir/QuantumComputation.hpp

@@ -344,10 +344,16 @@ class QuantumComputation {
 
   [[nodiscard]] std::string getQubitRegister(Qubit physicalQubitIndex) const;
   [[nodiscard]] std::string getClassicalRegister(Bit classicalIndex) const;
-  static Qubit getHighestLogicalQubitIndex(const Permutation& permutation);
+  [[nodiscard]] static Qubit
+  getHighestLogicalQubitIndex(const Permutation& permutation);
   [[nodiscard]] Qubit getHighestLogicalQubitIndex() const {
     return getHighestLogicalQubitIndex(initialLayout);
   };
+  [[nodiscard]] static Qubit
+  getHighestPhysicalQubitIndex(const Permutation& permutation);
+  [[nodiscard]] Qubit getHighestPhysicalQubitIndex() const {
+    return getHighestPhysicalQubitIndex(initialLayout);
+  };
   [[nodiscard]] std::pair<std::string, Qubit>
   getQubitRegisterAndIndex(Qubit physicalQubitIndex) const;
   [[nodiscard]] std::pair<std::string, Bit>
@@ -880,6 +886,16 @@ class QuantumComputation {
    */
   void reorderOperations();
 
+  /**
+   * @brief Check whether the quantum computation contains dynamic circuit
+   * primitives
+   * @details Dynamic circuit primitives are mid-circuit measurements, resets,
+   * or classical control flow operations. This method traverses the whole
+   * circuit once until it finds a dynamic operation.
+   * @return Whether the quantum computation contains dynamic circuit primitives
+   */
+  [[nodiscard]] bool isDynamic() const;
+
   /**
    * Pass-Through
    */

src/circuit_optimizer/CircuitOptimizer.cpp

@@ -75,12 +75,7 @@ void CircuitOptimizer::removeOperation(
 }
 
 void CircuitOptimizer::swapReconstruction(QuantumComputation& qc) {
-  Qubit highestPhysicalQubit = 0;
-  for (const auto& q : qc.initialLayout) {
-    highestPhysicalQubit = std::max(q.first, highestPhysicalQubit);
-  }
-
-  auto dag = DAG(highestPhysicalQubit + 1);
+  auto dag = DAG(qc.getHighestPhysicalQubitIndex() + 1);
 
   for (auto& it : qc) {
     if (!it->isStandardOperation()) {
@@ -161,12 +156,7 @@ void CircuitOptimizer::swapReconstruction(QuantumComputation& qc) {
 }
 
 DAG CircuitOptimizer::constructDAG(QuantumComputation& qc) {
-  Qubit highestPhysicalQubit = 0;
-  for (const auto& q : qc.initialLayout) {
-    highestPhysicalQubit = std::max(q.first, highestPhysicalQubit);
-  }
-
-  auto dag = DAG(highestPhysicalQubit + 1);
+  auto dag = DAG(qc.getHighestPhysicalQubitIndex() + 1);
 
   for (auto& op : qc) {
     addToDag(dag, &op);
@@ -181,12 +171,7 @@ void CircuitOptimizer::singleQubitGateFusion(QuantumComputation& qc) {
       {qc::Sdg, qc::S},   {qc::T, qc::Tdg},   {qc::Tdg, qc::T},
       {qc::SX, qc::SXdg}, {qc::SXdg, qc::SX}, {qc::Barrier, qc::Barrier}};
 
-  Qubit highestPhysicalQubit = 0;
-  for (const auto& q : qc.initialLayout) {
-    highestPhysicalQubit = std::max(q.first, highestPhysicalQubit);
-  }
-
-  auto dag = DAG(highestPhysicalQubit + 1);
+  auto dag = DAG(qc.getHighestPhysicalQubitIndex() + 1);
 
   for (auto& it : qc) {
     // not a single-qubit operation
@@ -928,66 +913,6 @@ void CircuitOptimizer::deferMeasurements(QuantumComputation& qc) {
   qc.initializeIOMapping();
 }
 
-bool isDynamicCircuit(std::unique_ptr<Operation>* op,
-                      std::vector<bool>& measured, DAG& dag) {
-  assert(op != nullptr);
-  auto& it = *op;
-  // whenever a classic-controlled or a reset operation are encountered
-  // the circuit has to be dynamic.
-  if (it->getType() == Reset || it->isClassicControlledOperation()) {
-    return true;
-  }
-
-  if (it->isStandardOperation()) {
-    // Whenever a qubit has already been measured, the circuit is dynamic
-    const auto& usedQubits = it->getUsedQubits();
-    for (const auto& q : usedQubits) {
-      if (measured[q]) {
-        return true;
-      }
-    }
-    addToDag(dag, op);
-    return false;
-  }
-
-  if (it->isNonUnitaryOperation()) {
-    assert(it->getType() == qc::Measure);
-    for (const auto& b : it->getTargets()) {
-      dag.at(b).push_back(op);
-      measured[b] = true;
-    }
-    return false;
-  }
-
-  assert(it->isCompoundOperation());
-  auto* compOp = dynamic_cast<CompoundOperation*>(it.get());
-  for (auto& g : *compOp) {
-    if (isDynamicCircuit(&g, measured, dag)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool CircuitOptimizer::isDynamicCircuit(QuantumComputation& qc) {
-  Qubit highestPhysicalQubit = 0;
-  for (const auto& q : qc.initialLayout) {
-    highestPhysicalQubit = std::max(q.first, highestPhysicalQubit);
-  }
-
-  auto dag = DAG(highestPhysicalQubit + 1);
-
-  // marks whether a qubit in the DAG has been measured
-  std::vector<bool> measured(highestPhysicalQubit + 1, false);
-
-  for (auto& it : qc) {
-    if (::qc::isDynamicCircuit(&it, measured, dag)) {
-      return true;
-    }
-  }
-  return false;
-}
-
 void CircuitOptimizer::printDAG(const DAG& dag) {
   for (const auto& qubitDag : dag) {
     std::cout << " - ";
@@ -1054,12 +979,7 @@ void CircuitOptimizer::flattenOperations(QuantumComputation& qc,
 }
 
 void CircuitOptimizer::cancelCNOTs(QuantumComputation& qc) {
-  Qubit highestPhysicalQubit = 0;
-  for (const auto& q : qc.initialLayout) {
-    highestPhysicalQubit = std::max(q.first, highestPhysicalQubit);
-  }
-
-  auto dag = DAG(highestPhysicalQubit + 1U);
+  auto dag = DAG(qc.getHighestPhysicalQubitIndex() + 1U);
 
   for (auto& it : qc) {
     if (!it->isStandardOperation()) {

src/ir/QuantumComputation.cpp

@@ -870,6 +870,15 @@ Qubit QuantumComputation::getHighestLogicalQubitIndex(
   return maxIndex;
 }
 
+Qubit QuantumComputation::getHighestPhysicalQubitIndex(
+    const Permutation& permutation) {
+  Qubit maxIndex = 0;
+  for (const auto& [physical, logical] : permutation) {
+    maxIndex = std::max(maxIndex, physical);
+  }
+  return maxIndex;
+}
+
 bool QuantumComputation::physicalQubitIsAncillary(
     const Qubit physicalQubitIndex) const {
   return std::any_of(ancregs.cbegin(), ancregs.cend(),
@@ -1220,4 +1229,43 @@ void QuantumComputation::reorderOperations() {
   std::move(newOps.begin(), newOps.end(), std::back_inserter(ops));
 }
 
+bool isDynamicCircuit(const std::unique_ptr<Operation>* op,
+                      std::vector<bool>& measured) {
+  assert(op != nullptr);
+  const auto& it = *op;
+  // whenever a classic-controlled or a reset operation are encountered
+  // the circuit has to be dynamic.
+  if (it->getType() == Reset || it->isClassicControlledOperation()) {
+    return true;
+  }
+
+  if (it->isStandardOperation()) {
+    // Whenever a qubit has already been measured, the circuit is dynamic
+    const auto& usedQubits = it->getUsedQubits();
+    return std::any_of(usedQubits.cbegin(), usedQubits.cend(),
+                       [&measured](const auto& q) { return measured[q]; });
+  }
+
+  if (it->getType() == qc::Measure) {
+    for (const auto& b : it->getTargets()) {
+      measured[b] = true;
+    }
+    return false;
+  }
+
+  assert(it->isCompoundOperation());
+  auto* compOp = dynamic_cast<CompoundOperation*>(it.get());
+  return std::any_of(
+      compOp->cbegin(), compOp->cend(),
+      [&measured](const auto& g) { return isDynamicCircuit(&g, measured); });
+}
+
+bool QuantumComputation::isDynamic() const {
+  // marks whether a qubit in the DAG has been measured
+  std::vector<bool> measured(getHighestPhysicalQubitIndex() + 1, false);
+  return std::any_of(cbegin(), cend(), [&measured](const auto& op) {
+    return ::qc::isDynamicCircuit(&op, measured);
+  });
+}
+
 } // namespace qc

test/algorithms/CMakeLists.txt

@@ -1,5 +1,5 @@
-if(TARGET MQT::CoreAlgo)
+if(TARGET MQT::CoreAlgorithms)
   file(GLOB_RECURSE ALGO_TEST_SOURCES *.cpp)
-  package_add_test(mqt-core-algo-test MQT::CoreAlgo ${ALGO_TEST_SOURCES})
-  target_link_libraries(mqt-core-algo-test PRIVATE MQT::CoreDD MQT::CoreCircuitOptimizer)
+  package_add_test(mqt-core-algorithms-test MQT::CoreAlgorithms ${ALGO_TEST_SOURCES})
+  target_link_libraries(mqt-core-algorithms-test PRIVATE MQT::CoreDD MQT::CoreCircuitOptimizer)
 endif()

test/circuit_optimizer/test_defer_measurements.cpp

@@ -31,13 +31,13 @@ TEST(DeferMeasurements, basicTest) {
   qc.classicControlled(qc::X, 1, {0, 1U}, 1U);
   std::cout << qc << "\n";
 
-  EXPECT_TRUE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_TRUE(qc.isDynamic());
 
   EXPECT_NO_THROW(CircuitOptimizer::deferMeasurements(qc););
 
   std::cout << qc << "\n";
 
-  EXPECT_FALSE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_FALSE(qc.isDynamic());
 
   ASSERT_EQ(qc.getNqubits(), 2);
   ASSERT_EQ(qc.getNindividualOps(), 3);
@@ -96,13 +96,13 @@ TEST(DeferMeasurements, measurementBetweenMeasurementAndClassic) {
   qc.classicControlled(qc::X, 1, {0, 1U}, 1U);
   std::cout << qc << "\n";
 
-  EXPECT_TRUE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_TRUE(qc.isDynamic());
 
   EXPECT_NO_THROW(CircuitOptimizer::deferMeasurements(qc););
 
   std::cout << qc << "\n";
 
-  EXPECT_FALSE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_FALSE(qc.isDynamic());
 
   ASSERT_EQ(qc.getNqubits(), 2);
   ASSERT_EQ(qc.getNindividualOps(), 4);
@@ -172,13 +172,13 @@ TEST(DeferMeasurements, twoClassic) {
 
   std::cout << qc << "\n";
 
-  EXPECT_TRUE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_TRUE(qc.isDynamic());
 
   EXPECT_NO_THROW(CircuitOptimizer::deferMeasurements(qc););
 
   std::cout << qc << "\n";
 
-  EXPECT_FALSE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_FALSE(qc.isDynamic());
 
   ASSERT_EQ(qc.getNqubits(), 2);
   ASSERT_EQ(qc.getNindividualOps(), 5);
@@ -253,13 +253,13 @@ TEST(DeferMeasurements, correctOrder) {
   qc.classicControlled(qc::X, 1, {0, 1U}, 1U);
   std::cout << qc << "\n";
 
-  EXPECT_TRUE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_TRUE(qc.isDynamic());
 
   EXPECT_NO_THROW(CircuitOptimizer::deferMeasurements(qc););
 
   std::cout << qc << "\n";
 
-  EXPECT_FALSE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_FALSE(qc.isDynamic());
 
   ASSERT_EQ(qc.getNqubits(), 2);
   ASSERT_EQ(qc.getNindividualOps(), 4);
@@ -328,13 +328,13 @@ TEST(DeferMeasurements, twoClassicCorrectOrder) {
   qc.classicControlled(qc::Z, 1, {0, 1U}, 1U);
   std::cout << qc << "\n";
 
-  EXPECT_TRUE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_TRUE(qc.isDynamic());
 
   EXPECT_NO_THROW(CircuitOptimizer::deferMeasurements(qc););
 
   std::cout << qc << "\n";
 
-  EXPECT_FALSE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_FALSE(qc.isDynamic());
 
   ASSERT_EQ(qc.getNqubits(), 2);
   ASSERT_EQ(qc.getNindividualOps(), 5);
@@ -401,7 +401,7 @@ TEST(DeferMeasurements, errorOnImplicitReset) {
   qc.classicControlled(qc::X, 0, {0, 1U}, 1U);
   std::cout << qc << "\n";
 
-  EXPECT_TRUE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_TRUE(qc.isDynamic());
 
   EXPECT_THROW(CircuitOptimizer::deferMeasurements(qc), qc::QFRException);
 }
@@ -429,7 +429,7 @@ TEST(DeferMeasurements, isDynamicOnRepeatedMeasurements) {
   qc.h(0);
   qc.measure(0, 1);
 
-  EXPECT_TRUE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_TRUE(qc.isDynamic());
 }
 
 } // namespace qc

test/circuit_optimizer/test_eliminate_resets.cpp

@@ -22,7 +22,7 @@ TEST(EliminateResets, eliminateResetsBasicTest) {
 
   std::cout << qc << "\n";
 
-  EXPECT_TRUE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_TRUE(qc.isDynamic());
 
   EXPECT_NO_THROW(CircuitOptimizer::eliminateResets(qc););
 
@@ -78,7 +78,7 @@ TEST(EliminateResets, eliminateResetsClassicControlled) {
   qc.classicControlled(qc::X, 0, {0, 1U}, 1U);
   std::cout << qc << "\n";
 
-  EXPECT_TRUE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_TRUE(qc.isDynamic());
 
   EXPECT_NO_THROW(CircuitOptimizer::eliminateResets(qc););
 
@@ -128,7 +128,7 @@ TEST(EliminateResets, eliminateResetsMultipleTargetReset) {
 
   std::cout << qc << "\n";
 
-  EXPECT_TRUE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_TRUE(qc.isDynamic());
 
   EXPECT_NO_THROW(CircuitOptimizer::eliminateResets(qc););
 
@@ -176,7 +176,7 @@ TEST(EliminateResets, eliminateResetsCompoundOperation) {
 
   std::cout << qc << "\n";
 
-  EXPECT_TRUE(CircuitOptimizer::isDynamicCircuit(qc));
+  EXPECT_TRUE(qc.isDynamic());
 
   EXPECT_NO_THROW(CircuitOptimizer::eliminateResets(qc););
 

test/ir/test_qfr_functionality.cpp

@@ -1131,3 +1131,14 @@ TEST_F(QFRFunctionality, OperationReorderingBarrier) {
   const auto target2 = (*it)->getTargets().at(0);
   EXPECT_EQ(target2, 1);
 }
+
+TEST_F(QFRFunctionality, isDynamicCompoundOperation) {
+  QuantumComputation qc(1, 1);
+  QuantumComputation compound(1, 1);
+  compound.measure(0, 0);
+  compound.x(0);
+  compound.measure(0, 0);
+  qc.emplace_back(compound.asCompoundOperation());
+  std::cout << qc << "\n";
+  EXPECT_TRUE(qc.isDynamic());
+}