🚚 Rename checker

Author: TeWas

include/checker/dd/HybridSchrodingerFeynmanChecker.hpp include/checker/dd/DDHybridSchrodingerFeynmanChecker.hpp

@@ -23,7 +23,7 @@
 namespace ec {
 /**
  * @brief Approximate Equivalence Checking with the
- * HybridSchrodingerFeynmanChecker This checker divides a circuit horizontally
+ * DDHybridSchrodingerFeynmanChecker This checker divides a circuit horizontally
  * into two halves: a lower part and an upper part. This is achieved by
  * decomposing controlled gates, acting across both halves, according to the
  * Schmidt decomposition. By leveraging key trace equalities - specifically,
@@ -41,12 +41,12 @@ namespace ec {
  * @note Only suitable for shallow circuits with a maximum number of 63
  * controlled gates acting on both circuit parts (decisions).
  */
-class HybridSchrodingerFeynmanChecker final
+class DDHybridSchrodingerFeynmanChecker final
     : public DDEquivalenceChecker<qc::MatrixDD, dd::DDPackageConfig> {
 public:
-  HybridSchrodingerFeynmanChecker(const qc::QuantumComputation& circ1,
-                                  const qc::QuantumComputation& circ2,
-                                  ec::Configuration config)
+  DDHybridSchrodingerFeynmanChecker(const qc::QuantumComputation& circ1,
+                                    const qc::QuantumComputation& circ2,
+                                    ec::Configuration config)
       : DDEquivalenceChecker(circ1, circ2, std::move(config)),
         qc1(std::make_unique<qc::QuantumComputation>(circ1)),
         qc2Inverted(std::make_unique<qc::QuantumComputation>()) {

src/EquivalenceCheckingManager.cpp

@@ -10,8 +10,8 @@
 #include "ThreadSafeQueue.hpp"
 #include "checker/dd/DDAlternatingChecker.hpp"
 #include "checker/dd/DDConstructionChecker.hpp"
+#include "checker/dd/DDHybridSchrodingerFeynmanChecker.hpp"
 #include "checker/dd/DDSimulationChecker.hpp"
-#include "checker/dd/HybridSchrodingerFeynmanChecker.hpp"
 #include "checker/dd/simulation/StateType.hpp"
 #include "checker/zx/ZXChecker.hpp"
 #include "circuit_optimizer/CircuitOptimizer.hpp"
@@ -535,7 +535,7 @@ void EquivalenceCheckingManager::checkSequential() {
   }
 
   if (configuration.execution.runHSFChecker && !done) {
-    checkers.emplace_back(std::make_unique<HybridSchrodingerFeynmanChecker>(
+    checkers.emplace_back(std::make_unique<DDHybridSchrodingerFeynmanChecker>(
         qc1, qc2, configuration));
     const auto& hsfChecker = checkers.back();
     if (!done) {
@@ -691,7 +691,7 @@ void EquivalenceCheckingManager::checkParallel() {
   if (configuration.execution.runHSFChecker && !done) {
     // start a new thread that constructs and runs the HSF check
     futures.emplace_back(
-        asyncRunChecker<HybridSchrodingerFeynmanChecker>(id, queue));
+        asyncRunChecker<DDHybridSchrodingerFeynmanChecker>(id, queue));
     ++id;
   }
 
@@ -785,7 +785,7 @@ void EquivalenceCheckingManager::checkParallel() {
     // answers once they finish
     if ((dynamic_cast<const DDAlternatingChecker*>(checker) != nullptr) ||
         (dynamic_cast<const DDConstructionChecker*>(checker) != nullptr) ||
-        (dynamic_cast<const HybridSchrodingerFeynmanChecker*>(checker) !=
+        (dynamic_cast<const DDHybridSchrodingerFeynmanChecker*>(checker) !=
          nullptr)) {
       setAndSignalDone();
       results.equivalence = result;

src/checker/dd/HybridSchrodingerFeynmanChecker.cpp src/checker/dd/DDHybridSchrodingerFeynmanChecker.cpp

@@ -1,4 +1,4 @@
-#include "checker/dd/HybridSchrodingerFeynmanChecker.hpp"
+#include "checker/dd/DDHybridSchrodingerFeynmanChecker.hpp"
 
 #include "Definitions.hpp"
 #include "EquivalenceCriterion.hpp"
@@ -28,7 +28,7 @@
 #include <thread>
 
 namespace ec {
-std::size_t HybridSchrodingerFeynmanChecker::getNDecisions(
+std::size_t DDHybridSchrodingerFeynmanChecker::getNDecisions(
     qc::QuantumComputation& qc) const {
   std::size_t ndecisions = 0;
   // calculate number of decisions
@@ -86,7 +86,7 @@ std::size_t HybridSchrodingerFeynmanChecker::getNDecisions(
   return ndecisions;
 }
 
-dd::ComplexValue HybridSchrodingerFeynmanChecker::simulateSlicing(
+dd::ComplexValue DDHybridSchrodingerFeynmanChecker::simulateSlicing(
     std::unique_ptr<DDPackage>& sliceDD1, std::unique_ptr<DDPackage>& sliceDD2,
     size_t i) {
   Slice lower(sliceDD1, 0, splitQubit - 1, i);
@@ -104,7 +104,7 @@ dd::ComplexValue HybridSchrodingerFeynmanChecker::simulateSlicing(
   return result;
 }
 
-bool HybridSchrodingerFeynmanChecker::Slice::apply(
+bool DDHybridSchrodingerFeynmanChecker::Slice::apply(
     std::unique_ptr<DDPackage>& sliceDD,
     const std::unique_ptr<qc::Operation>& op) {
   bool isSplitOp = false;
@@ -174,15 +174,15 @@ bool HybridSchrodingerFeynmanChecker::Slice::apply(
   return isSplitOp;
 }
 
-EquivalenceCriterion HybridSchrodingerFeynmanChecker::run() {
+EquivalenceCriterion DDHybridSchrodingerFeynmanChecker::run() {
   const auto start = std::chrono::steady_clock::now();
   equivalence = checkEquivalence();
   const auto end = std::chrono::steady_clock::now();
   runtime += std::chrono::duration<double>(end - start).count();
   return equivalence;
 }
 
-EquivalenceCriterion HybridSchrodingerFeynmanChecker::checkEquivalence() {
+EquivalenceCriterion DDHybridSchrodingerFeynmanChecker::checkEquivalence() {
   const auto ndecisions = getNDecisions(*qc1) + getNDecisions(*qc2Inverted);
   if (ndecisions > 63) {
     throw std::overflow_error(
@@ -227,7 +227,7 @@ EquivalenceCriterion HybridSchrodingerFeynmanChecker::checkEquivalence() {
   return EquivalenceCriterion::NotEquivalent;
 }
 
-void HybridSchrodingerFeynmanChecker::json(
+void DDHybridSchrodingerFeynmanChecker::json(
     nlohmann::basic_json<>& j) const noexcept {
   DDEquivalenceChecker::json(j);
   j["checker"] = "decision_diagram_hybridSchrodingerFeynman";