Added smallest set-vertex MFVS implementation

Author: Kalashnikovni

algorithms/matching/matching.cpp

@@ -60,6 +60,7 @@ Matching::Matching(MatchKind kind) : _kind(kind), _impl()
 
     default: {
       Util::ERROR("Unsupported matching algorithm implementation");
+      break;
     }
   }  
 }

algorithms/mfvs/CMakeLists.txt

@@ -1,7 +1,8 @@
 target_sources(
     sbgraph
     PRIVATE
+        greedy_mfvs.cpp
         min_feedback_vertex_set.cpp
         mfvs_fact.cpp
-        greedy_mfvs.cpp
+        smallest_sv_mfvs.cpp
 )

algorithms/mfvs/mfvs_fact.cpp

@@ -25,20 +25,29 @@ namespace SBG {
 namespace LIB {
 
 ////////////////////////////////////////////////////////////////////////////////
-// Maximum Degree Cut Vertex Factory -------------------------------------------
+// Maximum Degree MFVS Factory -------------------------------------------------
 ////////////////////////////////////////////////////////////////////////////////
 
 MinFeedbackVertexSet GreedyMFVSFact::createMFVSAlgorithm() const
 {
   return MinFeedbackVertexSet{MFVSKind::kGreedy};
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// Smallest set-vertex MFVS Factory --------------------------------------------
+////////////////////////////////////////////////////////////////////////////////
+
+MinFeedbackVertexSet SmallSVMFVSFact::createMFVSAlgorithm() const
+{
+  return MinFeedbackVertexSet{MFVSKind::kSmallSV};
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Factory for clients --------------------------------------------------------- 
 ////////////////////////////////////////////////////////////////////////////////
 
 MFVSFactory::MFVSFactory()
-  : _kind(MFVSKind::kGreedy), _impl(GreedyMFVSFact{}) {}
+  : _kind(MFVSKind::kSmallSV), _impl(SmallSVMFVSFact{}) {}
 
 MFVSFactory& MFVSFactory::instance()
 {
@@ -54,6 +63,12 @@ void MFVSFactory::set_mfvs_fact(MFVSKind kind)
   switch (kind) {
     case MFVSKind::kGreedy: {
       _impl = GreedyMFVSFact{};
+      break;
+    }
+
+    case MFVSKind::kSmallSV: {
+      _impl = SmallSVMFVSFact{};
+      break;
     }
 
     default: {

algorithms/mfvs/mfvs_fact.hpp

@@ -39,6 +39,13 @@ class GreedyMFVSFact {
   MinFeedbackVertexSet createMFVSAlgorithm() const;
 };
 
+class SmallSVMFVSFact {
+public:
+  SmallSVMFVSFact() = default;
+
+  MinFeedbackVertexSet createMFVSAlgorithm() const;
+};
+
 /**
  * @brief Single instance of cv factory to be used by clients in need of
  * creating an instance of a cv algorithm. A client includes this file and
@@ -56,7 +63,7 @@ class MFVSFactory {
   MinFeedbackVertexSet createMFVSAlgorithm() const;
 
 private:
-  using MFVSFactImpl = std::variant<GreedyMFVSFact>;
+  using MFVSFactImpl = std::variant<GreedyMFVSFact, SmallSVMFVSFact>;
 
   MFVSFactory();
 

algorithms/mfvs/min_feedback_vertex_set.cpp

@@ -37,6 +37,11 @@ std::ostream& operator<<(std::ostream& out, const MFVSKind kind)
       break;
     }
 
+    case MFVSKind::kSmallSV: {
+      out << "smallest set-vertex";
+      break;
+    }
+
     default: {
       Util::ERROR("MFVSKind::operator<<: unsupported MFVS implementation");
       break;
@@ -58,6 +63,11 @@ MinFeedbackVertexSet::MinFeedbackVertexSet(MFVSKind kind) : _kind(kind), _impl()
       break;
     }
 
+    case MFVSKind::kSmallSV: {
+      _impl = detail::SmallestSVMFVS{};
+      break;
+    }
+
     default: {
       Util::ERROR("MinFeedbackVertexSet: unsupported MFVS implementation");
       break;

algorithms/mfvs/min_feedback_vertex_set.hpp

@@ -25,6 +25,7 @@
 #define SBGRAPH_ALGORITHMS_MFVS_MIN_FEEDBACK_VERTEX_SET_HPP_
 
 #include "algorithms/mfvs/greedy_mfvs.hpp"
+#include "algorithms/mfvs/smallest_sv_mfvs.hpp"
 #include "sbg/directed_sbg.hpp"
 
 #include <iosfwd>
@@ -40,11 +41,11 @@ namespace detail {
 // Minimum Feedback Vertex Set Implementations --------------------------------
 ///////////////////////////////////////////////////////////////////////////////
 
-using MFVSImpl = std::variant<GreedyMFVS>;
+using MFVSImpl = std::variant<GreedyMFVS, SmallestSVMFVS>;
 
 }
 
-enum class MFVSKind { kGreedy };
+enum class MFVSKind { kGreedy, kSmallSV };
 
 std::ostream& operator<<(std::ostream& out, const MFVSKind kind);
 

algorithms/mfvs/smallest_sv_mfvs.cpp

@@ -0,0 +1,115 @@
+/*******************************************************************************
+
+ This file is part of Set--Based Graph Library.
+
+ SBG Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ SBG Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with SBG Library.  If not, see <http://www.gnu.org/licenses/>.
+
+ ******************************************************************************/
+
+#include "algorithms/mfvs/smallest_sv_mfvs.hpp"
+#include "algorithms/scc/scc.hpp"
+#include "algorithms/scc/scc_fact.hpp"
+#include "sbg/natural.hpp"
+#include "sbg/pw_map.hpp"
+#include "sbg/set_fact.hpp"
+#include "util/logger.hpp"
+
+#include <numeric>
+
+namespace SBG {
+
+namespace LIB {
+
+namespace detail {
+
+////////////////////////////////////////////////////////////////////////////////
+// Greedy MFVS Algorithm -------------------------------------------------------
+////////////////////////////////////////////////////////////////////////////////
+
+SmallestSVMFVS::SmallestSVMFVS() {}
+
+/**
+ * @brief It calculates the minimum vertex from the smallest SV. 
+ */
+MD_NAT getVertexFromSmallestSV(const DirectedSBG& dsbg)
+{
+  PWMap Vmap = dsbg.Vmap();
+  PWMap mmap = Vmap.imageMultiplicity();
+
+  MD_NAT min_mult{dsbg.V().arity(), Inf};
+  Set remaining = mmap.image();
+  while (!remaining.isEmpty()) {
+    MD_NAT jth_mult = remaining.minElem();
+    NAT current_degree = std::accumulate(min_mult.begin(), min_mult.end()
+      , 0);
+    NAT jth_degree = std::accumulate(jth_mult.begin(), jth_mult.end(), 0);
+    if (jth_degree < current_degree) {
+      min_mult = jth_mult;
+    }
+
+    remaining = remaining.difference(SET_FACT.createSet(jth_mult));
+  }
+
+  Set small_sv = mmap.preImage(SET_FACT.createSet(min_mult));
+  Set vertex = Vmap.preImage(small_sv);
+
+  return vertex.minElem();
+}
+
+Set SmallestSVMFVS::calculate(const DirectedSBG& input_dsbg) const
+{
+  DirectedSBG dsbg = input_dsbg;
+
+  Util::DEBUG_LOG << "initial smallest set-vertex mfvs dsbg:\n" << dsbg << "\n";
+
+  PWMap rmap = SCC_FACT.createSCCAlgorithm().calculate(dsbg).rmap();
+  Set fvs_result = SET_FACT.createSet();
+  Set visitedSV = SET_FACT.createSet();
+  while (rmap.fixedPoints() != rmap.domain()) {
+    // Get vertex from smallest set-vertex
+    MD_NAT smallest_sv_vertex = getVertexFromSmallestSV(dsbg);
+    Set Vj = SET_FACT.createSet(smallest_sv_vertex);
+    fvs_result = std::move(fvs_result).disjointCup(Vj);
+
+    // Handle repetition
+    PWMap Vmap = dsbg.Vmap();
+    Set repeatedSV = visitedSV.intersection(Vmap.image(Vj));
+    if (!repeatedSV.isEmpty()) {
+      Set V_plus = Vmap.preImage(Vmap.image(Vj));
+      fvs_result = std::move(fvs_result).cup(std::move(V_plus));
+
+      visitedSV = repeatedSV.difference(Vmap.image(Vj));
+    } else {
+      visitedSV = std::move(repeatedSV).disjointCup(Vmap.image(Vj));
+    }
+
+    // Erase selected vertices
+    dsbg.eraseVertices(fvs_result);
+
+    // Resulting SCC from induced graph
+    rmap = SCC_FACT.createSCCAlgorithm().calculate(dsbg).rmap();
+
+    Util::DEBUG_LOG << "Vj: " << Vj << "\n";
+    Util::DEBUG_LOG << "new rmap: " << rmap << "\n\n";
+  }
+
+  fvs_result.compact();
+  return fvs_result;
+}
+
+} // namespace detail
+
+} // namespace LIB
+
+} // namespace SBG

algorithms/mfvs/smallest_sv_mfvs.hpp

@@ -0,0 +1,58 @@
+/** @file smallest_sv_mfvs.hpp
+
+ @brief <b>Concrete SBG Smallest SV MFVS Algorithm implementation</b>
+
+ <hr>
+
+ This file is part of Set--Based Graph Library.
+
+ SBG Library is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ SBG Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with SBG Library.  If not, see <http://www.gnu.org/licenses/>.
+
+ ******************************************************************************/
+
+#ifndef SBGRAPH_ALGORITHMS_MFVS_SMALLEST_SV_MFVS_HPP_
+#define SBGRAPH_ALGORITHMS_MFVS_SMALLEST_SV_MFVS_HPP_
+
+#include "sbg/directed_sbg.hpp"
+#include "sbg/set.hpp"
+
+namespace SBG {
+
+namespace LIB {
+
+namespace detail {
+
+///////////////////////////////////////////////////////////////////////////////
+// Smallest set-vertex MFVS Algorithm Implementation --------------------------
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @brief In each step takes out vertices of the smallest set-vertex available.
+ * This way, it is first checked if it is possible to disconnect the SBG
+ * with a constant number of elements.
+ */
+class SmallestSVMFVS {
+public:
+  SmallestSVMFVS();
+
+  Set calculate(const DirectedSBG& input_dsbg) const;
+};
+
+} // namespace detail
+
+} // namespace LIB
+
+} // namespace SBG
+
+#endif // SBGRAPH_ALGORITHMS_MFVS_GREEDY_MFVS_HPP_

algorithms/misc/causalization_builders.cpp

@@ -89,14 +89,15 @@ std::tuple<SBG::LIB::PWMap, SBG::LIB::PWMap, SBG::LIB::PWMap> buildSCCEdges(
   return {mapB, mapD, Emap};
 }
 
-SBG::LIB::PWMap partitionEmap(const SBG::LIB::DirectedSBG& dsbg)
+void partitionEmap(SBG::LIB::DirectedSBG& dsbg)
 {
+  SBG::LIB::Set V = dsbg.V();
   SBG::LIB::PWMap Vmap = dsbg.Vmap();
   SBG::LIB::PWMap mapB = dsbg.mapB();
   SBG::LIB::PWMap mapD = dsbg.mapD();
   SBG::LIB::PWMap Emap = dsbg.Emap();
 
-  std::size_t arity = dsbg.V().arity();
+  std::size_t arity = V.arity();
   SBG::LIB::NAT j = 1;
   SBG::LIB::PWMap partitioned_Emap = SBG::LIB::PWMAP_FACT.createPWMap();
   dsbg.foreachSetEdge([&](const SBG::LIB::MD_NAT& SE)
@@ -132,7 +133,7 @@ SBG::LIB::PWMap partitionEmap(const SBG::LIB::DirectedSBG& dsbg)
     }
   });
 
-  return partitioned_Emap;
+  dsbg = SBG::LIB::DirectedSBG{V, Vmap, mapB, mapD, partitioned_Emap};
 }
 
 SBG::LIB::DirectedSBG buildLoopDetectionSBG(const SBG::LIB::MatchData& data)
@@ -148,10 +149,10 @@ SBG::LIB::DirectedSBG buildLoopDetectionSBG(const SBG::LIB::MatchData& data)
   SBG::LIB::PWMap Emap = SBG::LIB::PWMAP_FACT.createPWMap();
   std::tie(mapB, mapD, Emap) = buildSCCEdges(data, Vmap);
 
-  //SBG::LIB::DirectedSBG dsbg{V, Vmap, mapB, mapD, Emap};
-  //Emap = partitionEmap(dsbg);
+  SBG::LIB::DirectedSBG dsbg{V, Vmap, mapB, mapD, Emap};
+  partitionEmap(dsbg);
 
-  return SBG::LIB::DirectedSBG{V, Vmap, mapB, mapD, Emap};
+  return dsbg;
 }
 
 ////////////////////////////////////////////////////////////////////////////////