cleanup

Author: bimalgaudel

SeQuant/core/optimize/single_term.hpp

@@ -62,15 +62,6 @@ struct OptRes {
   container::vector<uint16_t> subnets;
 };
 
-// constexpr auto cse_hasher = [](TNMeta const& data) -> size_t {
-//   return data.hash_value();
-// };
-
-// constexpr auto cse_equal = [](TNMeta const& left,
-//                               TNMeta const& right) -> bool {
-//   return bliss::ConstGraphCmp::cmp(*left.graph, *right.graph) == 0;
-// };
-
 struct SubNetHash {
   size_t operator()(
       TensorNetwork::SlotCanonicalizationMetadata const& data) const noexcept {
@@ -95,30 +86,35 @@ struct SubNetEqual {
 ///
 /// \tparam CostFn A function object type that computes the cost of a single
 /// binary contraction.
-///                Expected signature: \code double(meta::range_of<Index> auto
-///                const& lhs, meta::range_of<Index> auto const& rhs,
-///                meta::range_of<Index> auto const& res) \endcode
+/// Expected signature:
+// \code double(meta::range_of<Index> auto const& lhs,
+//              meta::range_of<Index> auto const& rhs,
+///             meta::range_of<Index> auto const& res)
+// \endcode
 ///
 /// \param network The \ref TensorNetwork containing the tensors to be
-/// contracted. \param tidxs The set of indices that should remain open in the
-/// final result. \param cost_fn The cost model used to evaluate contractions
-/// (e.g., flop count). \param subnet_cse If true, enables Common Subexpression
+/// contracted.
+//  \param tidxs The set of indices that should remain open in the
+/// final result.
+//  \param cost_fn The cost model used to evaluate contractions
+/// (e.g., flop count).
+//  \param subnet_cse If true, enables Common Subexpression
 /// Elimination (CSE) for
-///                   equivalent subnetworks. When enabled, the cost of
-///                   evaluating structurally identical subnetworks is counted
-///                   only once in the total cost of a contraction tree.
-///                   Equivalence is determined by canonicalizing the subnetwork
-///                   graph.
+/// equivalent subnetworks. When enabled, the cost of
+/// evaluating structurally identical subnetworks is counted
+/// only once in the total cost of a contraction tree.
+/// Equivalence is determined by canonicalizing the subnetwork
+/// graph.
 ///
 /// \return An \ref EvalSequence representing the optimal contraction order.
 ///
 /// \details The optimization uses a bitmask-based dynamic programming approach
-///          where each state represents a subnetwork (subset of tensors).
-///          If \p subnet_cse is enabled, the algorithm precomputes canonical
-///          metadata for every possible subnetwork to identify common
-///          structures. This allows it to find trees that benefit from reusing
-///          intermediate results, which is particularly effective for
-///          expressions with repeating tensor patterns.
+///  where each state represents a subnetwork (subset of tensors).
+///  If \p subnet_cse is enabled, the algorithm precomputes canonical
+///  metadata for every possible subnetwork to identify common
+///  structures. This allows it to find trees that benefit from reusing
+///  intermediate results, which is particularly effective for
+///  expressions with repeating tensor patterns.
 ///
 template <typename CostFn>
   requires requires(CostFn&& fn, decltype(OptRes::indices) const& ixs) {

tests/unit/test_optimize.cpp

@@ -353,16 +353,21 @@ TEST_CASE("optimize", "[optimize]") {
     auto prod9 =
         deserialize("X{i1;a1} X{i2;a4} Y{a3;i3} Y{a1;i4}")->as<Product>();
     auto res9 = single_term_opt(prod9);
-    // take a look at res9_ for a result with subnet_cse disabled
-    // should give different result
-    // auto res9_ = single_term_opt(prod9, false);
-    // std::wcout << "res9_\n" << serialize(res9_) << std::endl;
     // this is the one we want to find
     // (X Y) (X Y)
     REQUIRE(extract(res9, {0, 0}) == prod9.at(0));
     REQUIRE(extract(res9, {0, 1}) == prod9.at(3));
     REQUIRE(extract(res9, {1, 0}) == prod9.at(1));
     REQUIRE(extract(res9, {1, 1}) == prod9.at(2));
+
+    // take a look at res9_ for a result with subnet_cse disabled
+    // should give different result
+    // std::wcout << "res9_\n" << serialize(res9_) << std::endl;
+    auto res9_no_cse = single_term_opt(prod9, false);
+    REQUIRE(extract(res9_no_cse, {0, 0, 0}) == prod9.at(0));
+    REQUIRE(extract(res9_no_cse, {0, 0, 1}) == prod9.at(3));
+    REQUIRE(extract(res9_no_cse, {0, 1}) == prod9.at(1));
+    REQUIRE(extract(res9_no_cse, {1}) == prod9.at(2));
   }
 
   /// verify that space changes did not leak
@@ -371,27 +376,3 @@ TEST_CASE("optimize", "[optimize]") {
   REQUIRE(uocc);
   REQUIRE(uocc->approximate_size() == 10);
 }
-
-TEST_CASE("feature optimize", "[feature]") {
-  using namespace sequant;
-  auto ctx_resetter = set_scoped_default_context(get_default_context().clone());
-  auto reg = get_default_context().mutable_index_space_registry();
-  mbpt::add_df_spaces(reg);
-  mbpt::add_pao_spaces(reg);
-  mbpt::add_ao_spaces(reg);
-  // i 10
-  // a 40
-  // μ̃ 50
-  // Κ 90
-  for (auto&& [k, v] :
-       std::initializer_list<std::pair<std::wstring_view, size_t>>{
-           {L"i", 10}, {L"a", 40}, {L"μ̃", 50}, {L"Κ", 90}}) {
-    reg->retrieve_ptr(k)->approximate_size(v);
-  }
-
-  for (auto&& ix :
-       std::initializer_list<std::wstring_view>{L"i", L"a", L"μ̃", L"Κ"}) {
-    std::wcout << std::format(L"{}: {}\n", ix,
-                              reg->retrieve_ptr(ix)->approximate_size());
-  }
-}