Bump the submodules group with 2 updates

.pre-commit-config.yaml

@@ -72,8 +72,6 @@ repos:
     hooks:
       - id: cmake-format
         additional_dependencies: [pyyaml]
-      - id: cmake-lint
-        additional_dependencies: [pyyaml]
 
   # Clang-format the C++ part of the code base automatically
   - repo: https://github.com/pre-commit/mirrors-clang-format

CMakeLists.txt

@@ -20,6 +20,7 @@ endmacro()
 check_submodule_present(mqt-core)
 check_submodule_present(taskflow)
 
+option(BUILD_MQT_DDSIM_TESTS "Also build tests for the MQT DDSIM project" ON)
 option(BUILD_MQT_DDSIM_BINDINGS "Build the MQT DDSIM Python bindings" OFF)
 if(BUILD_MQT_DDSIM_BINDINGS)
   # ensure that the BINDINGS option is set
@@ -43,9 +44,10 @@ if(BUILD_MQT_DDSIM_BINDINGS)
     OPTIONAL_COMPONENTS Development.SABIModule)
 endif()
 
+include(cmake/ExternalDependencies.cmake)
+
 add_subdirectory(src)
 
-option(BUILD_MQT_DDSIM_TESTS "Also build tests for the MQT DDSIM project" ON)
 if(BUILD_MQT_DDSIM_TESTS)
   enable_testing()
   include(GoogleTest)

apps/simple.cpp

@@ -247,8 +247,7 @@ int main(int argc, char** argv) { // NOLINT(bugprone-exception-escape)
     }
 
     if (vm.count("pcomplex") > 0) {
-        outputObj["complex_stats"]["cache_count"] = ddsim->dd->cn.cacheCount();
-        outputObj["complex_stats"]["real_count"]  = ddsim->dd->cn.realCount();
+        outputObj["complex_stats"]["real_count"] = ddsim->dd->cn.realCount();
     }
 
     if (vm.count("dump_complex") > 0) {

cmake/ExternalDependencies.cmake

@@ -0,0 +1,30 @@
+# Declare all external dependencies and make sure that they are available.
+
+include(FetchContent)
+set(FETCH_PACKAGES "")
+
+if(BUILD_MQT_DDSIM_TESTS)
+  set(gtest_force_shared_crt
+      ON
+      CACHE BOOL "" FORCE)
+  set(GTEST_VERSION
+      1.14.0
+      CACHE STRING "Google Test version")
+  set(GTEST_URL
+      https://github.com/google/googletest/archive/refs/tags/v${GTEST_VERSION}.tar.gz
+  )
+  if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.24)
+    FetchContent_Declare(googletest URL ${GTEST_URL} FIND_PACKAGE_ARGS
+                                        ${GTEST_VERSION} NAMES GTest)
+    list(APPEND FETCH_PACKAGES googletest)
+  else()
+    find_package(googletest ${GTEST_VERSION} QUIET NAMES GTest)
+    if(NOT googletest_FOUND)
+      FetchContent_Declare(googletest URL ${GTEST_URL})
+      list(APPEND FETCH_PACKAGES googletest)
+    endif()
+  endif()
+endif()
+
+# Make all declared dependencies available.
+FetchContent_MakeAvailable(${FETCH_PACKAGES})

include/ShorFastSimulator.hpp

@@ -44,7 +44,7 @@ class ShorFastSimulator: public Simulator<Config> {
 
     void applyGate(dd::GateMatrix matrix, dd::Qubit target);
 
-    std::vector<std::map<dd::vNode*, dd::vEdge>> nodesOnLevel;
+    std::vector<std::map<dd::vNode*, dd::vCachedEdge>> nodesOnLevel;
 
     dd::mEdge addConst(std::uint64_t a);
 

src/CircuitSimulator.cpp

@@ -92,7 +92,7 @@ dd::fp CircuitSimulator<Config>::expectationValue(const qc::QuantumComputation&
     singleShot(true);
 
     // construct the DD for the observable
-    const auto observableDD = dd::buildFunctionality(&observable, Simulator<Config>::dd);
+    const auto observableDD = dd::buildFunctionality(&observable, *Simulator<Config>::dd);
 
     // calculate the expectation value
     return Simulator<Config>::dd->expectationValue(observableDD, Simulator<Config>::rootEdge);
@@ -136,7 +136,7 @@ std::map<std::size_t, bool> CircuitSimulator<Config>::singleShot(const bool igno
                         // apply an X operation whenever the measured result is one
                         if (bit == '1') {
                             const auto x   = qc::StandardOperation(qc->getNqubits(), qubit, qc::X);
-                            auto       tmp = Simulator<Config>::dd->multiply(dd::getDD(&x, Simulator<Config>::dd), Simulator<Config>::rootEdge);
+                            auto       tmp = Simulator<Config>::dd->multiply(dd::getDD(&x, *Simulator<Config>::dd), Simulator<Config>::rootEdge);
                             Simulator<Config>::dd->incRef(tmp);
                             Simulator<Config>::dd->decRef(Simulator<Config>::rootEdge);
                             Simulator<Config>::rootEdge = tmp;
@@ -176,7 +176,7 @@ std::map<std::size_t, bool> CircuitSimulator<Config>::singleShot(const bool igno
                       << " #controls=" << op->getControls().size()
                       << " statesize=" << dd->size(rootEdge) << "\n";//*/
 
-            auto ddOp = dd::getDD(op.get(), Simulator<Config>::dd);
+            auto ddOp = dd::getDD(op.get(), *Simulator<Config>::dd);
             auto tmp  = Simulator<Config>::dd->multiply(ddOp, Simulator<Config>::rootEdge);
             Simulator<Config>::dd->incRef(tmp);
             Simulator<Config>::dd->decRef(Simulator<Config>::rootEdge);

src/DeterministicNoiseSimulator.cpp

@@ -1,6 +1,7 @@
 #include "DeterministicNoiseSimulator.hpp"
 
 #include "dd/Export.hpp"
+#include "dd/Operations.hpp"
 
 using CN = dd::ComplexNumbers;
 
@@ -35,7 +36,7 @@ dd::SparsePVecStrKeys DeterministicNoiseSimulator<Config>::deterministicSimulate
         if (op->isClassicControlledOperation()) {
             throw std::runtime_error("Classical controlled operations are not supported.");
         }
-        auto operation = dd::getDD(op.get(), Simulator<Config>::dd);
+        auto operation = dd::getDD(op.get(), *Simulator<Config>::dd);
 
         // Applying the operation to the density matrix
         Simulator<Config>::dd->applyOperationToDensity(rootEdge, operation, useDensityMatrixType);

src/GroverSimulator.cpp

@@ -14,7 +14,7 @@ std::map<std::string, std::size_t> GroverSimulator<Config>::simulate(std::size_t
         qcSetup.h(i);
     }
 
-    const dd::Edge setupOp{dd::buildFunctionality(&qcSetup, Simulator<Config>::dd)};
+    const dd::Edge setupOp{dd::buildFunctionality(&qcSetup, *Simulator<Config>::dd)};
 
     // Build the oracle
     qc::QuantumComputation qcOracle(nQubits + nAnciallae);
@@ -24,7 +24,7 @@ std::map<std::string, std::size_t> GroverSimulator<Config>::simulate(std::size_t
     }
     qcOracle.mcz(controls, nQubits);
 
-    const dd::Edge oracleOp{dd::buildFunctionality(&qcOracle, Simulator<Config>::dd)};
+    const dd::Edge oracleOp{dd::buildFunctionality(&qcOracle, *Simulator<Config>::dd)};
 
     // Build the diffusion stage.
     qc::QuantumComputation qcDiffusion(nQubits + nAnciallae);
@@ -53,7 +53,7 @@ std::map<std::string, std::size_t> GroverSimulator<Config>::simulate(std::size_t
         qcDiffusion.h(i);
     }
 
-    const dd::Edge diffusionOp{dd::buildFunctionality(&qcDiffusion, Simulator<Config>::dd)};
+    const dd::Edge diffusionOp{dd::buildFunctionality(&qcDiffusion, *Simulator<Config>::dd)};
 
     const dd::Edge fullIteration{Simulator<Config>::dd->multiply(oracleOp, diffusionOp)};
     Simulator<Config>::dd->incRef(fullIteration);

src/HybridSchrodingerFeynmanSimulator.cpp

@@ -112,7 +112,7 @@ bool HybridSchrodingerFeynmanSimulator<Config>::Slice::apply(std::unique_ptr<dd:
             const auto&           param = op->getParameter();
             qc::StandardOperation newOp(nqubits, opControls, opTargets, op->getType(), param, start);
             sliceDD->decRef(edge);
-            edge = sliceDD->multiply(dd::getDD(&newOp, sliceDD), edge, static_cast<dd::Qubit>(start));
+            edge = sliceDD->multiply(dd::getDD(&newOp, *sliceDD), edge, static_cast<dd::Qubit>(start));
             sliceDD->incRef(edge);
         }
     } else {

src/PathSimulator.cpp

@@ -379,7 +379,7 @@ void PathSimulator<Config>::constructTaskGraph() {
                 results.emplace(leftID, zeroState);
             } else {
                 const auto&  op   = CircuitSimulator<Config>::qc->at(leftID - 1);
-                qc::MatrixDD opDD = dd::getDD(op.get(), Simulator<Config>::dd);
+                qc::MatrixDD opDD = dd::getDD(op.get(), *Simulator<Config>::dd);
                 Simulator<Config>::dd->incRef(opDD);
                 results.emplace(leftID, opDD);
             }
@@ -390,7 +390,7 @@ void PathSimulator<Config>::constructTaskGraph() {
                 throw std::runtime_error("Initial state must not appear on right side of the simulation path member.");
             }
             const auto&  op   = CircuitSimulator<Config>::qc->at(rightID - 1);
-            qc::MatrixDD opDD = dd::getDD(op.get(), Simulator<Config>::dd);
+            qc::MatrixDD opDD = dd::getDD(op.get(), *Simulator<Config>::dd);
             Simulator<Config>::dd->incRef(opDD);
             results.emplace(rightID, opDD);
         }

src/ShorFastSimulator.cpp

@@ -329,7 +329,6 @@ void ShorFastSimulator<Config>::applyGate(dd::GateMatrix matrix, dd::Qubit targe
  */
 template<class Config>
 void ShorFastSimulator<Config>::uAEmulate2(const std::uint64_t a) {
-    [[maybe_unused]] const std::size_t cacheCountBefore = Simulator<Config>::dd->cn.cacheCount();
     dagEdges.clear();
 
     dd::vEdge                        f = dd::vEdge::one();
@@ -349,77 +348,56 @@ void ShorFastSimulator<Config>::uAEmulate2(const std::uint64_t a) {
 
     // clear nodesOnLevel. TODO: make it a local variable?
     for (auto& m: nodesOnLevel) {
-        m = std::map<dd::vNode*, dd::vEdge>();
+        m = {};
     }
 
     // initialize nodesOnLevel
     uAEmulate2Rec(Simulator<Config>::rootEdge.p->e[0]);
 
     // special treatment for the nodes on first level
     for (const auto& entry: nodesOnLevel.at(0)) {
-        dd::vEdge left = f;
-        if (entry.first->e[0].w.exactlyZero()) {
-            left = dd::vEdge::zero();
-        } else {
-            left.w = Simulator<Config>::dd->cn.mulCached(left.w, entry.first->e[0].w);
-        }
-
-        dd::vEdge right = Simulator<Config>::dd->multiply(addConstMod(ts[static_cast<std::size_t>(entry.first->v)]), f);
-
-        if (entry.first->e[1].w.exactlyZero()) {
-            right = dd::vEdge::zero();
-        } else {
-            right.w = Simulator<Config>::dd->cn.mulCached(right.w, entry.first->e[1].w);
+        auto left = dd::vCachedEdge::zero();
+        if (!entry.first->e[0].w.exactlyZero()) {
+            left = {f.p, f.w * entry.first->e[0].w};
         }
 
-        const dd::vEdge result = Simulator<Config>::dd->add(left, right);
-
-        if (!left.w.exactlyZero()) {
-            Simulator<Config>::dd->cn.returnToCache(left.w);
+        auto right = dd::vCachedEdge::zero();
+        if (!entry.first->e[1].w.exactlyZero()) {
+            auto tmp = Simulator<Config>::dd->multiply(addConstMod(ts[static_cast<std::size_t>(entry.first->v)]), f);
+            right    = {tmp.p, tmp.w * entry.first->e[1].w};
         }
-        if (!right.w.exactlyZero()) {
-            Simulator<Config>::dd->cn.returnToCache(right.w);
-        }
-
-        Simulator<Config>::dd->incRef(result);
 
-        nodesOnLevel[0][entry.first] = result;
+        nodesOnLevel[0][entry.first] = Simulator<Config>::dd->add2(left, right, 0);
     }
 
     // treat the nodes on the remaining levels
     for (std::size_t i = 1; i < nQubits - 1; i++) {
-        std::vector<dd::vEdge> saveEdges;
         for (auto it = nodesOnLevel.at(i).begin(); it != nodesOnLevel.at(i).end(); it++) {
-            dd::vEdge left = dd::vEdge::zero();
+            auto left = dd::vCachedEdge::zero();
             if (!it->first->e.at(0).w.exactlyZero()) {
                 left   = nodesOnLevel.at(i - 1)[it->first->e.at(0).p];
-                left.w = Simulator<Config>::dd->cn.mulCached(left.w, it->first->e.at(0).w);
+                left.w = left.w * it->first->e.at(0).w;
             }
 
-            dd::vEdge right = dd::vEdge::zero();
+            auto right = dd::vCachedEdge::zero();
             if (!it->first->e.at(1).w.exactlyZero()) {
-                right   = Simulator<Config>::dd->multiply(addConstMod(ts.at(static_cast<std::size_t>(it->first->v))), nodesOnLevel.at(i - 1)[it->first->e.at(1).p]);
-                right.w = Simulator<Config>::dd->cn.mulCached(right.w, it->first->e.at(1).w);
+                auto  node0 = addConstMod(ts.at(static_cast<std::size_t>(it->first->v)));
+                auto& node1 = nodesOnLevel.at(i - 1)[it->first->e.at(1).p];
+                auto  node2 = dd::vEdge{node1.p, Simulator<Config>::dd->cn.lookup(node1.w)};
+                auto  res   = Simulator<Config>::dd->multiply(node0, node2);
+                right       = {res.p, res.w * it->first->e.at(1).w};
             }
 
-            const dd::vEdge result = Simulator<Config>::dd->add(left, right);
-
-            if (!left.w.exactlyZero()) {
-                Simulator<Config>::dd->cn.returnToCache(left.w);
+            dd::Qubit level = 0;
+            if (left.p != nullptr) {
+                level = left.p->v;
             }
-            if (!right.w.exactlyZero()) {
-                Simulator<Config>::dd->cn.returnToCache(right.w);
+            if (right.p != nullptr && right.p->v > level) {
+                level = right.p->v;
             }
 
-            Simulator<Config>::dd->incRef(result);
-            nodesOnLevel.at(i)[it->first] = result;
-            saveEdges.push_back(result);
-        }
-        for (auto& it: nodesOnLevel.at(i - 1)) {
-            Simulator<Config>::dd->decRef(it.second);
+            nodesOnLevel.at(i)[it->first] = Simulator<Config>::dd->add2(left, right, level);
         }
-        Simulator<Config>::dd->garbageCollect();
-        saveEdges.push_back(Simulator<Config>::rootEdge);
         nodesOnLevel.at(i - 1).clear();
     }
 
@@ -428,33 +406,29 @@ void ShorFastSimulator<Config>::uAEmulate2(const std::uint64_t a) {
         throw std::runtime_error("error occurred");
     }
 
-    dd::vEdge result = nodesOnLevel.at(nQubits - 2)[Simulator<Config>::rootEdge.p->e[0].p];
-
-    Simulator<Config>::dd->decRef(result);
+    auto result = nodesOnLevel.at(nQubits - 2)[Simulator<Config>::rootEdge.p->e[0].p];
+    result.w    = result.w * Simulator<Config>::rootEdge.p->e[0].w;
+    auto tmp    = dd::vCachedEdge{Simulator<Config>::rootEdge.p->e[0].p, Simulator<Config>::rootEdge.p->e[0].w};
+    result      = Simulator<Config>::dd->makeDDNode(Simulator<Config>::rootEdge.p->v, std::array{tmp, result});
 
-    result.w = Simulator<Config>::dd->cn.mulCached(result.w, Simulator<Config>::rootEdge.p->e[0].w);
-    auto tmp = result.w;
-
-    result = Simulator<Config>::dd->makeDDNode(Simulator<Config>::rootEdge.p->v, std::array<dd::vEdge, dd::RADIX>{Simulator<Config>::rootEdge.p->e[0], result});
-    Simulator<Config>::dd->cn.returnToCache(tmp);
-
-    result.w = Simulator<Config>::dd->cn.mulCached(result.w, Simulator<Config>::rootEdge.w);
-    tmp      = result.w;
-    result.w = Simulator<Config>::dd->cn.lookup(result.w);
-    Simulator<Config>::dd->cn.returnToCache(tmp);
+    result.w = result.w * Simulator<Config>::rootEdge.w;
+    auto res = dd::vEdge{result.p, Simulator<Config>::dd->cn.lookup(result.w)};
+    Simulator<Config>::dd->incRef(res);
     Simulator<Config>::dd->decRef(Simulator<Config>::rootEdge);
-    Simulator<Config>::dd->incRef(result);
-    Simulator<Config>::rootEdge = result;
+    Simulator<Config>::rootEdge = res;
     Simulator<Config>::dd->garbageCollect();
-    assert(Simulator<Config>::dd->cn.cacheCount() == cacheCountBefore);
 }
 
 template<class Config>
 void ShorFastSimulator<Config>::uAEmulate2Rec(dd::vEdge e) {
-    if (e.isTerminal() || nodesOnLevel.at(static_cast<std::size_t>(e.p->v)).find(e.p) != nodesOnLevel.at(static_cast<std::size_t>(e.p->v)).end()) {
+    if (e.isTerminal()) {
+        return;
+    }
+    auto& nodes = nodesOnLevel.at(static_cast<std::size_t>(e.p->v));
+    if (nodes.find(e.p) != nodes.end()) {
         return;
     }
-    nodesOnLevel.at(static_cast<std::size_t>(e.p->v))[e.p] = dd::vEdge::zero();
+    nodes[e.p] = dd::vCachedEdge::zero();
     uAEmulate2Rec(e.p->e[0]);
     uAEmulate2Rec(e.p->e[1]);
 }