🏗️ Remove SolverFactory to entirely isolate NALAC (#609)

## Description

NASP had still a dependency on NALAC. The only part where this was used
was the solver factory. Sine this was not super useful anyways, the
solver factory is removed together with the dependency on NALAC.

## Checklist:

- [x] The pull request only contains commits that are related to it.
- [x] I have added appropriate tests and documentation.
- [x] I have made sure that all CI jobs on GitHub pass.
- [x] The pull request introduces no new warnings and follows the
project's style guidelines.

Author: ystade

include/na/nasp/Solver.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "Definitions.hpp"
+#include "ir/QuantumComputation.hpp"
 
 #include <cstddef>
 #include <cstdint>
@@ -467,6 +468,36 @@ class NASolver {
         uint16_t newNumQubits, uint16_t newNumStages,
         std::optional<uint16_t> newNumTransfers = std::nullopt,
         bool mindOpsOrder = false, bool shieldIdleQubits = true) -> Result;
+
+  /**
+   * @brief Get the list of entangling operations that the solver takes as
+   * input.
+   *
+   * @details The solver only considers the entangling operations of a circuit.
+   * For that it receives a list of qubit pairs that represent each one
+   * entangling operation. This function generates this list from a given
+   * QuantumComputation and a FullOpType that specifies the entangling
+   * operation.
+   *
+   * @warning This function expects a QuantumComputation that was used as input
+   * for the NASolver. Additionally, this function assumes the quantum circuit
+   * represented by the QuantumComputation to be of the following form:
+   * First, all qubits are initialized in the |+> state by applying a Hadamard
+   * gate to each qubit. Then, a set of entangling gates (CZ) is applied to the
+   * qubits. Finally, hadamard gates are applied to some qubits. Unfortunately,
+   * the function cannot deal with arbitrary quantum circuits as the NASolver
+   * cannot do either.
+   *
+   * @param circ
+   * @param opType
+   * @param ctrls
+   * @param quiet
+   * @return
+   */
+  [[nodiscard]] static auto
+  getOpsForSolver(const qc::QuantumComputation& circ, qc::OpType opType,
+                  std::size_t ctrls, bool quiet = false)
+      -> std::vector<std::pair<qc::Qubit, qc::Qubit>>;
 };
 
 struct ExprHash {

include/na/nasp/SolverFactory.hpp

@@ -12,7 +12,7 @@ if(NOT TARGET ${MQT_QMAP_NASP_TARGET_NAME})
   target_link_libraries(
     ${MQT_QMAP_NASP_TARGET_NAME}
     PUBLIC MQT::CoreNA nlohmann_json::nlohmann_json z3::z3lib
-    PRIVATE MQT::CoreCircuitOptimizer MQT::ProjectOptions MQT::ProjectWarnings MQT::NALAC)
+    PRIVATE MQT::CoreDS MQT::CoreCircuitOptimizer MQT::ProjectOptions MQT::ProjectWarnings)
 
   add_library(MQT::NASP ALIAS ${MQT_QMAP_NASP_TARGET_NAME})
 endif()

src/na/nasp/CMakeLists.txt

@@ -1,6 +1,8 @@
 #include "na/nasp/Solver.hpp"
 
 #include "Definitions.hpp"
+#include "circuit_optimizer/CircuitOptimizer.hpp"
+#include "ir/QuantumComputation.hpp"
 
 #include <algorithm>
 #include <cstddef>
@@ -764,4 +766,30 @@ auto NASolver::Result::json() const -> nlohmann::json {
 auto NASolver::Result::operator==(const Result& other) const -> bool {
   return sat == other.sat && stages == other.stages;
 }
+auto NASolver::getOpsForSolver(const qc::QuantumComputation& circ,
+                               const qc::OpType opType, const std::size_t ctrls,
+                               const bool quiet)
+    -> std::vector<std::pair<unsigned int, unsigned int>> {
+  auto flattened = circ;
+  qc::CircuitOptimizer::flattenOperations(flattened);
+  std::vector<std::pair<unsigned int, unsigned int>> ops;
+  ops.reserve(flattened.size());
+  for (const auto& op : flattened) {
+    if (op->getType() == opType && op->getNcontrols() == ctrls) {
+      const auto& operands = op->getUsedQubits();
+      if (operands.size() != 2) {
+        std::stringstream ss;
+        ss << "Operation " << op->getName() << " does not have two operands.";
+        throw std::invalid_argument(ss.str());
+      }
+      ops.emplace_back(*operands.cbegin(), *operands.rbegin());
+    } else if (!quiet) {
+      std::stringstream ss;
+      ss << "Operation " << op->getName() << " is not of type " << opType
+         << " or does not have " << ctrls << " controls.";
+      throw std::invalid_argument(ss.str());
+    }
+  }
+  return ops;
+}
 } // namespace na

src/na/nasp/Solver.cpp

@@ -18,7 +18,6 @@
 #include "na/NAComputation.hpp"
 #include "na/nasp/CodeGenerator.hpp"
 #include "na/nasp/Solver.hpp"
-#include "na/nasp/SolverFactory.hpp"
 #include "qasm3/Importer.hpp"
 #include "sc/Architecture.hpp"
 #include "sc/Mapper.hpp"
@@ -1020,7 +1019,7 @@ of the abstraction from the 2D grid used for the solver must be provided again.
         std::transform(opTypeLowerStr.begin(), opTypeLowerStr.end(),
                        opTypeLowerStr.begin(),
                        [](unsigned char c) { return std::tolower(c); });
-        return na::SolverFactory::getOpsForSolver(
+        return na::NASolver::getOpsForSolver(
             qc, qc::opTypeFromString(operationType), numControls, quiet);
       },
       "qc"_a, "operation_type"_a = "Z", "num_operands"_a = 1, "quiet"_a = true,

src/na/nasp/SolverFactory.cpp

@@ -3,7 +3,6 @@
 #include "na/NAComputation.hpp"
 #include "na/nasp/CodeGenerator.hpp"
 #include "na/nasp/Solver.hpp"
-#include "na/nasp/SolverFactory.hpp"
 #include "qasm3/Importer.hpp"
 
 #include <cstdint>
@@ -26,7 +25,7 @@ TEST(CodeGenerator, Generate) {
   //    storage zone at the top and at the bottom
   na::NASolver solver(3, 7, 2, 3, 2, 2, 2, 2, 2, 4);
   // get operations for solver
-  const auto& pairs = na::SolverFactory::getOpsForSolver(circ, qc::Z, 1, true);
+  const auto& pairs = na::NASolver::getOpsForSolver(circ, qc::Z, 1, true);
   // solve
   const auto result =
       solver.solve(pairs, static_cast<uint16_t>(circ.getNqubits()), 4,