minimization fixed

MarcG-TUE · MarcG-TUE · commit f5cdc7ddfbe6 · 2023-04-16T16:33:04.000+02:00
diff --git a/include/maxplus/base/fsm/fsm.h b/include/maxplus/base/fsm/fsm.h
@@ -691,8 +691,8 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
     using EquivalenceMap = std::map<const Abstract::State*,
                                     std::shared_ptr<Abstract::SetOfStateRefs>>;
 
-    // minimize the automaton based on edge labels only.
-    std::shared_ptr<FiniteStateMachine<StateLabelType, EdgeLabelType>> minimizeEdgeLabels() {
+    // minimize the automaton based on edge and state labels.
+    std::shared_ptr<FiniteStateMachine<StateLabelType, EdgeLabelType>> minimizeEdgeLabels(bool ignoreStateLabels = false) {
         // partition refinement algorithm
 
         // generate a vector of equivalence classes
@@ -709,8 +709,58 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
             eqMap[sp] = initialClass;
         }
 
-        // partition refinement
+        // partition on state labels
+
         bool changed = false;
+        if (! ignoreStateLabels) {
+            do {
+                changed = false;
+
+                std::list<std::shared_ptr<Abstract::SetOfStateRefs>> newEqClasses;
+
+                // for every potential equivalence class
+                for (const auto &ic : eqClasses) {
+                    std::shared_ptr<Abstract::SetOfStateRefs> _class = ic;
+
+                    auto i = _class->begin();
+
+                    // pick arbitrary state from class
+                    auto s1 = dynamic_cast<const State<StateLabelType, EdgeLabelType> *>(*i);
+
+                    std::shared_ptr<Abstract::SetOfStateRefs> equivSet =
+                            std::make_shared<Abstract::SetOfStateRefs>();
+                    std::shared_ptr<Abstract::SetOfStateRefs> remainingSet =
+                            std::make_shared<Abstract::SetOfStateRefs>();
+                    equivSet->insert(s1);
+
+                    // check whether all other states have the same label.
+                    while (++i != _class->end()) {
+                        auto s2 = dynamic_cast<const State<StateLabelType, EdgeLabelType> *>(*i);
+                        if (s1->getLabel() == s2->getLabel()) {
+                            equivSet->insert(s2);
+                        } else {
+                            remainingSet->insert(s2);
+                        }
+                    }
+                    // if not, split the class
+                    if (equivSet->size() == _class->size()) {
+                        newEqClasses.push_back(equivSet);
+                        this->mapStates(eqMap, equivSet);
+                    } else {
+                        newEqClasses.push_back(equivSet);
+                        this->mapStates(eqMap, equivSet);
+                        newEqClasses.push_back(remainingSet);
+                        this->mapStates(eqMap, remainingSet);
+                        changed = true;
+                    }
+                }
+                auto tempEqClasses = eqClasses;
+                eqClasses = newEqClasses;
+            } while (changed);
+        }
+
+        // partition refinement on transitions
+        changed = false;
         do {
             changed = false;
 
@@ -818,8 +868,8 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
             std::shared_ptr<Abstract::SetOfStateRefs> ns1 = s1->nextStatesOfEdgeLabel(l);
             std::shared_ptr<Abstract::SetOfStateRefs> ns2 = s2->nextStatesOfEdgeLabel(l);
             // collect classes of states in ns1 and ns2
-            std::set<SetOfStates<StateLabelType, EdgeLabelType> *> cs1;
-            std::set<SetOfStates<StateLabelType, EdgeLabelType> *> cs2;
+            std::set<std::shared_ptr<Abstract::SetOfStateRefs>> cs1;
+            std::set<std::shared_ptr<Abstract::SetOfStateRefs>> cs2;
             for (auto j : *ns1) {
                 auto s = j;
                 cs1.insert(m[s]);
@@ -846,38 +896,12 @@ class FiniteStateMachine : public Abstract::FiniteStateMachine {
 };
 } // namespace Labeled
 
-// Edge Labelled Scenario Automaton
-using ELSState = ::FSM::Labeled::State<CId, CString>;
-using ELSEdge = ::FSM::Labeled::Edge<CId, CString>;
-using ELSSetOfStates = ::FSM::Labeled::SetOfStates<CId, CString>;
-using ELSSetOfEdges = ::FSM::Abstract::SetOfEdges;
-using ELSSetOfStateRefs = ::FSM::Abstract::SetOfStateRefs;
-using ELSSetOfEdgeRefs = ::FSM::Abstract::SetOfEdgeRefs;
-
-class EdgeLabeledScenarioFSM : public ::FSM::Labeled::FiniteStateMachine<CId, CString> {
-public:
-    EdgeLabeledScenarioFSM() = default;
-    ~EdgeLabeledScenarioFSM() override = default;
-
-    EdgeLabeledScenarioFSM(const EdgeLabeledScenarioFSM &) = delete;
-    EdgeLabeledScenarioFSM &operator=(const EdgeLabeledScenarioFSM &other) = delete;
-    EdgeLabeledScenarioFSM(EdgeLabeledScenarioFSM &&) = delete;
-    EdgeLabeledScenarioFSM &operator=(EdgeLabeledScenarioFSM &&) = delete;
-
-    virtual void removeDanglingStates();
-};
 
 namespace StateStringLabeled {
 
 // make an FSM class with unlabeled edges, based on the labeled one with some dummy char labels
 //
 
-// class SetOfEdges : public Labeled::SetOfEdges<CString, char> {};
-// class SetOfEdgeRefs : public Labeled::SetOfEdgeRefs<CString, char> {};
-
-// class SetOfStates : public Labeled::SetOfStates<CString, char> {};
-// class SetOfStateRefs : public Labeled::SetOfStateRefs<CString, char> {};
-
 class State : public Labeled::State<CString, char> {
 public:
     explicit State(const CString &withLabel) : Labeled::State<CString, char>(withLabel) {}
diff --git a/include/maxplus/graph/mpautomaton.h b/include/maxplus/graph/mpautomaton.h
@@ -224,7 +224,8 @@ class MaxPlusAutomatonWithRewards
     // compute the maximum cycle ratio of delay over progress
     CDouble calculateMCR();
     // compute the maximum cycle ratio of delay over progress and also return a critical cycle
-    CDouble calculateMCRAndCycle(MPARCycle **cycle);
+    CDouble calculateMCRAndCycle(std::shared_ptr<std::vector<const MPAREdge*>> *cycle);
+
 };
 
 } // namespace MaxPlus
diff --git a/src/base/fsm/fsm.cc b/src/base/fsm/fsm.cc
@@ -46,64 +46,6 @@ namespace FSM {
 
 CId FSM::Abstract::WithUniqueID::nextID = 0;
 
-/*removes states of the fsm with no outgoing edges.*/
-void EdgeLabeledScenarioFSM::removeDanglingStates() {
-
-    // temporary sets of states and edges
-    ELSSetOfEdgeRefs edgesToBeRemoved;
-    ELSSetOfStateRefs statesToBeRemoved;
-
-    ELSSetOfStates &elsStates = this->getStates();
-    ELSSetOfEdges &elsEdges = this->getEdges();
-
-    /*go through all edges and find all edges that end in
-    dangling states. Also store dangling states.*/
-    for(const auto& it: elsEdges){
-        auto& e = *(it.second);
-        const auto& s = dynamic_cast<const ELSState&>(e.getDestination());
-        const auto &oEdges = dynamic_cast<const ELSSetOfEdgeRefs &>(s.getOutgoingEdges());
-        if (oEdges.empty()) {
-            edgesToBeRemoved.insert(&e);
-            statesToBeRemoved.insert(&s);
-        }
-    }
-
-    while (!edgesToBeRemoved.empty()) {
-
-        // remove dangling states
-        for (const auto &s : statesToBeRemoved) {
-            this->removeState(dynamic_cast<const ELSState&>(*s));
-        }
-
-        // remove edges ending in dangling states
-        // remove edges ending in dangling states from the outgoing edges of their source states
-        for (const auto & e : edgesToBeRemoved) {
-            this->removeEdge(dynamic_cast<const ELSEdge&>(*e));
-            auto s = e->getSource();
-            s.removeOutgoingEdge(*e);
-        }
-
-        // empty the temporary sets
-        edgesToBeRemoved.clear();
-        statesToBeRemoved.clear();
-
-        elsStates = this->getStates();
-        elsEdges = this->getEdges();
-
-        /*go through all edges and find all edges that end in
-        dangling states. Also store dangling states.*/
-        for (const auto & it : elsEdges) {
-            const auto& elsEdge = *(it.second);
-            auto e = dynamic_cast<const ELSEdge&>(elsEdge);
-            auto s = dynamic_cast<const ELSState&>(e.getDestination());
-            const auto &oEdges = (s.getOutgoingEdges());
-            if (oEdges.empty()) {
-                edgesToBeRemoved.insert(&e);
-                statesToBeRemoved.insert(&s);
-            }
-        }
-    }
-}
 
 namespace StateStringLabeled {
 
diff --git a/src/graph/CMakeLists.txt b/src/graph/CMakeLists.txt
@@ -1 +1,3 @@
-
+target_sources(maxplus PRIVATE
+    mpautomaton.cc
+)
diff --git a/src/graph/mpautomaton.cc b/src/graph/mpautomaton.cc
@@ -0,0 +1,70 @@
+#include "base/basic_types.h"
+#include "base/analysis/mcm/mcm.h"
+#include "base/analysis/mcm/mcmyto.h"
+#include "graph/mpautomaton.h"
+#include <memory>
+
+using namespace MaxPlus;
+using namespace Graphs;
+
+
+// compute the maximum cycle ratio of delay over progress
+CDouble MaxPlusAutomatonWithRewards::calculateMCR(){
+    
+    MCMgraph g;
+    CId nId = 0;
+
+    std::map<const ::FSM::Abstract::State*, MCMnode*> nodeMap;
+
+    for (auto s: this->getStates()) {
+        auto n = g.addNode(nId++);
+        nodeMap[&(*(s.second))] = n;
+    }
+
+    CId eId = 0;
+    for (auto s: this->getStates()) {
+        for(auto e: (s.second)->getOutgoingEdges()) {
+            auto mpae = dynamic_cast<MPAREdge*>(e);
+            g.addEdge(eId++, *nodeMap[&(mpae->getSource())], *nodeMap[&(mpae->getDestination())], static_cast<CDouble>(mpae->getLabel().delay), mpae->getLabel().reward);
+        }
+    }
+
+    std::shared_ptr<std::vector<const MCMedge*>> cycle;
+    CDouble mcr = maxCycleRatioAndCriticalCycleYoungTarjanOrlin(g, &cycle);
+
+    return mcr;
+}
+
+CDouble MaxPlusAutomatonWithRewards::calculateMCRAndCycle(std::shared_ptr<std::vector<const MPAREdge*>> *cycle) {
+    
+    MCMgraph g;
+
+    CId nId = 0;
+    std::map<const ::FSM::Abstract::State*, MCMnode*> nodeMap;
+
+    for (auto s: this->getStates()) {
+        auto n = g.addNode(nId++);
+        nodeMap[&(*(s.second))] = n;
+    }
+
+    CId eId = 0;
+    std::map<const MCMedge*, const MPAREdge*> edgeMap;
+
+    for (auto s: this->getStates()) {
+        for(auto e: (s.second)->getOutgoingEdges()) {
+            auto mpae = dynamic_cast<MPAREdge*>(e);
+            g.addEdge(eId++, *nodeMap[&(mpae->getSource())], *nodeMap[&(mpae->getDestination())], static_cast<CDouble>(mpae->getLabel().delay), mpae->getLabel().reward);
+        }
+    }
+
+    std::shared_ptr<std::vector<const MCMedge*>> mcmCycle;
+    CDouble mcr = maxCycleRatioAndCriticalCycleYoungTarjanOrlin(g, &mcmCycle);
+    if (cycle != nullptr) {
+        *cycle = std::make_shared<std::vector<const MPAREdge*>>();
+        for (auto e: *mcmCycle) {
+            (*cycle)->push_back(edgeMap[e]);
+        }
+    }
+
+    return mcr;
+}
diff --git a/src/testbench/graph/mpautomatontest.cc b/src/testbench/graph/mpautomatontest.cc
@@ -8,6 +8,8 @@
 #include "graph/mpautomaton.h"
 #include "testing.h"
 
+#define ASSERT_EPSILON 0.001
+
 using namespace MaxPlus;
 
 MPAutomatonTest::MPAutomatonTest() = default;
@@ -19,6 +21,7 @@ void MPAutomatonTest::TearDown() {}
 void MPAutomatonTest::Run() {
     testCreateFSM(); 
     testDeterminizeFSM();
+    testMinimizeFSM();
 }
 
 void MPAutomatonTest::testCreateFSM() {
@@ -56,12 +59,10 @@ void MPAutomatonTest::testDeterminizeFSM() {
     std::cout << "Running test: DeterminizeFSM" << std::endl;
 
     MaxPlusAutomatonWithRewards mpa;
-    // One FSM state, three tokens:
-    CId fsm_s0 = 0;
 
-    MPARState *s1 = mpa.addState(makeMPAStateLabel(fsm_s0, 0));
-    MPARState *s2 = mpa.addState(makeMPAStateLabel(fsm_s0, 1));
-    MPARState *s3 = mpa.addState(makeMPAStateLabel(fsm_s0, 2));
+    MPARState *s1 = mpa.addState(makeMPAStateLabel(0, 0));
+    MPARState *s2 = mpa.addState(makeMPAStateLabel(0, 1));
+    MPARState *s3 = mpa.addState(makeMPAStateLabel(0, 2));
 
     // s1 -- (3,A,1) -> s2 
     mpa.addEdge(*s1, makeRewardEdgeLabel(MPTime(3.0), CString("A"), 1.0), *s2);
@@ -88,10 +89,37 @@ void MPAutomatonTest::testDeterminizeFSM() {
     ASSERT_THROW(mpaDeterminized->getStates().size() == 2);
     ASSERT_THROW(mpaDeterminized->getEdges().size()==3);
 
-    auto mpaMin = mpa.minimizeEdgeLabels();
+    CDouble mcr = mpa.calculateMCR();
+    std::shared_ptr<std::vector<const MPAREdge*>> cycle;
+    CDouble mcr1 = mpaDeterminized->calculateMCRAndCycle(&cycle);
+    
+    ASSERT_APPROX_EQUAL(mcr, mcr1, ASSERT_EPSILON);
+    ASSERT_EQUAL(cycle->size(), 2);
+    
+}
+
+void MPAutomatonTest::testMinimizeFSM() {
+
+    std::cout << "Running test: MinimizeFSM" << std::endl;
+
+    FSM::Labeled::FiniteStateMachine<int,int> fsa;
+
+    auto s0 = fsa.addState(3);
+    auto s1 = fsa.addState(5);
+    auto s2 = fsa.addState(5);
+
+    fsa.addEdge(*s0, 2, *s1);
+    fsa.addEdge(*s1, 2, *s2);
+    fsa.addEdge(*s2, 2, *s2);
+
+    fsa.setInitialState(*s0);
+
+    std::shared_ptr<FSM::Labeled::FiniteStateMachine<int,int>> fsaMin = std::dynamic_pointer_cast<FSM::Labeled::FiniteStateMachine<int,int>>(fsa.minimizeEdgeLabels());
+
+    std::cout << "Nr states: " << fsaMin->getStates().size() << std::endl;
+    std::cout << "Nr edges: " << fsaMin->getEdges().size() << std::endl;
 
-    // TODO: implement MCR on MaxPlusAutomatonWithRewards and MCM on MaxPlusAutomaton
-    // CDouble mcr = mpaDeterminized->calculateMCR();
-    // std::cout << "MCR: " << mcr << std::endl;
+    ASSERT_EQUAL(fsaMin->getStates().size(), 2);
+    ASSERT_EQUAL(fsaMin->getEdges().size(), 2);
 
 }
diff --git a/src/testbench/graph/mpautomatontest.h b/src/testbench/graph/mpautomatontest.h
@@ -18,4 +18,5 @@ class MPAutomatonTest : public ::testing::Test {
     void Run() override;
     void testCreateFSM();
     void testDeterminizeFSM();
+    void testMinimizeFSM();
 };
diff --git a/src/testbench/graph/testing.cc b/src/testbench/graph/testing.cc
@@ -7,9 +7,5 @@ int main() {
     MPAutomatonTest T1;
     T1.Run();
 
-    // TODO(MG): add tests for MCM algorithms
-    std::cout << "TODO: add tests for MCM algorithms." << std::endl;
-
-
     return 0;
 }
diff --git a/src/testbench/graph/testing.h b/src/testbench/graph/testing.h
@@ -36,6 +36,25 @@ namespace testing {
   }                                                                 \
 }
 
+#define ASSERT_APPROX_EQUAL( x, y, eps )                                   \
+{                                                                   \
+  if( abs(( x ) - ( y )) > eps )                                              \
+  {                                                                 \
+    throw std::runtime_error(   std::string( "Asserted approximate equality violated." )                  \
+                              + std::string( "\nIn:" )              \
+                              + std::string( __FILE__ )             \
+                              + std::string( ":" )                  \
+                              + std::to_string( __LINE__ )          \
+                              + std::string( " in " )               \
+                              + std::string( __FUNCTION__ )         \
+                              + std::string( ": " )                 \
+                              + std::to_string( ( x ) )             \
+                              + std::string( " != " )               \
+                              + std::to_string( ( y ) )             \
+    );                                                              \
+  }                                                                 \
+}
+
 #define ASSERT_EQUAL_NOPRINT( x, y )                                   \
 {                                                                   \
   if( ( x ) != ( y ) )                                              \

-Original file line number
+Diff line change
@@ @@ -1 +1,3 @@ @@
+-
 +target_sources(maxplus PRIVATE
 +    mpautomaton.cc
 +)
Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,5 @@ int main() {`
`7`	`7`	`MPAutomatonTest T1;`
`8`	`8`	`T1.Run();`
`9`	`9`
`10`		`- // TODO(MG): add tests for MCM algorithms`
`11`		`- std::cout << "TODO: add tests for MCM algorithms." << std::endl;`
`12`		`-`
`13`		`-`
`14`	`10`	`return 0;`
`15`	`11`	`}`