Enhance flaw handling: Add compute_flaw_cost method, update flaw cost notifications, and improve cost estimation logic in solver_core and server classes.

Author: riccardodebenedictis

include/basic_solver.hpp

@@ -35,6 +35,8 @@ namespace ratio
   private:
     [[nodiscard]] riddle::atom_expr create_atom(bool is_fact, riddle::predicate &pred, std::map<std::string, riddle::expr, std::less<>> &&args) override;
 
+    void compute_flaw_cost(flaw &f) noexcept;
+
     struct Node
     {
       std::size_t id = 0;                                  // The unique identifier of the node..

include/server/basic_solver_server.hpp

@@ -19,14 +19,17 @@ namespace ratio
     void on_ws_error(network::ws_server_session_base &ws, const std::error_code &);
 
     void state_changed() noexcept override;
+
     void flaw_created(const flaw &f) noexcept override;
+    void flaw_cost_changed(const flaw &f) noexcept override;
+
     void resolver_created(const ratio::resolver &r) noexcept override;
 
     void current_flaw(std::optional<std::reference_wrapper<ratio::flaw>> f) noexcept override;
     void current_resolver(std::optional<std::reference_wrapper<ratio::resolver>> r) noexcept override;
 
     void causal_link_added(const flaw &f, const resolver &r) override;
-    
+
   private:
     std::unordered_set<network::ws_server_session_base *> clients;
   };

include/solver_core.hpp

@@ -27,6 +27,8 @@ namespace ratio
     [[nodiscard]] const std::vector<std::reference_wrapper<resolver>> &get_resolvers() const noexcept { return resolvers; }
     [[nodiscard]] const std::vector<std::reference_wrapper<resolver>> &get_supports() const noexcept { return supports; }
 
+    [[nodiscard]] const utils::rational &get_estimated_cost() const noexcept { return est_cost; }
+
     [[nodiscard]] virtual json::json to_json() const;
 
   protected:
@@ -38,11 +40,12 @@ namespace ratio
     virtual void compute_resolvers() = 0;
 
   private:
-    solver_core &slv;                                        // The solver managing this flaw..
-    bool expanded = false;                                   // Whether the flaw has been expanded..
-    std::vector<std::reference_wrapper<resolver>> causes;    // The causes of this flaw..
-    std::vector<std::reference_wrapper<resolver>> resolvers; // The resolvers for this flaw..
-    std::vector<std::reference_wrapper<resolver>> supports;  // The resolvers supported by this flaw..
+    solver_core &slv;                                              // The solver managing this flaw..
+    bool expanded = false;                                         // Whether the flaw has been expanded..
+    std::vector<std::reference_wrapper<resolver>> causes;          // The causes of this flaw..
+    std::vector<std::reference_wrapper<resolver>> resolvers;       // The resolvers for this flaw..
+    std::vector<std::reference_wrapper<resolver>> supports;        // The resolvers supported by this flaw..
+    utils::rational est_cost = utils::rational::positive_infinite; // The estimated cost to resolve this flaw..
   };
 
   class resolver
@@ -61,6 +64,8 @@ namespace ratio
 
     [[nodiscard]] const utils::rational &get_intrinsic_cost() const noexcept { return intrinsic_cost; }
 
+    [[nodiscard]] utils::rational get_estimated_cost() const noexcept;
+
     [[nodiscard]] const std::vector<std::reference_wrapper<flaw>> &get_preconditions() const noexcept { return preconditions; }
 
     [[nodiscard]] virtual json::json to_json() const;
@@ -187,6 +192,8 @@ namespace ratio
 
     void retract_resolver(resolver &res) noexcept;
 
+    void set_flaw_cost(flaw &f, const utils::rational &cost) noexcept;
+
   private:
     [[nodiscard]] riddle::atom_state get_atom_state(const riddle::atom_term &atom) const noexcept override;
 
@@ -210,6 +217,15 @@ namespace ratio
      */
     virtual void flaw_created([[maybe_unused]] const flaw &f) noexcept {}
 
+    /**
+     * @brief Notifies when the cost of a flaw has changed.
+     *
+     * This function is called when the cost of a flaw has changed. It is a virtual function that can be overridden by derived classes to perform specific actions when a flaw's cost changes.
+     *
+     * @param f The flaw whose cost has changed.
+     */
+    virtual void flaw_cost_changed([[maybe_unused]] const flaw &f) {}
+
     /**
      * @brief Notifies that a new resolver has been created.
      *
@@ -224,28 +240,28 @@ namespace ratio
      *
      * This function is called to inform about the current flaw being processed in the solver.
      *
-     * @param The current flaw being processed.
+     * @param f The current flaw being processed.
      */
-    virtual void current_flaw([[maybe_unused]] std::optional<std::reference_wrapper<ratio::flaw>>) noexcept {}
+    virtual void current_flaw([[maybe_unused]] std::optional<std::reference_wrapper<ratio::flaw>> f) noexcept {}
 
     /**
      * @brief Notifies about the current resolver being applied.
      *
      * This function is called to inform about the current resolver being applied in the solver.
      *
-     * @param The current resolver being applied.
+     * @param r The current resolver being applied.
      */
-    virtual void current_resolver([[maybe_unused]] std::optional<std::reference_wrapper<ratio::resolver>>) noexcept {}
+    virtual void current_resolver([[maybe_unused]] std::optional<std::reference_wrapper<ratio::resolver>> r) noexcept {}
 
     /**
      * @brief Notifies when a causal link has been added.
      *
      * This function is called when a causal link has been added. It is a virtual function that can be overridden by derived classes to perform specific actions when a causal link is added.
      *
-     * @param flaw The flaw that is the source of the causal link.
-     * @param resolver The resolver that is the destination of the causal link.
+     * @param f The flaw that is the source of the causal link.
+     * @param r The resolver that is the destination of the causal link.
      */
-    virtual void causal_link_added([[maybe_unused]] const flaw &, [[maybe_unused]] const resolver &) {}
+    virtual void causal_link_added([[maybe_unused]] const flaw &f, [[maybe_unused]] const resolver &r) {}
 #endif
 
   protected:

src/basic_solver.cpp

@@ -1,6 +1,7 @@
 #include "basic_solver.hpp"
 #include "conjunction.hpp"
 #include "logging.hpp"
+#include <stack>
 #include <cassert>
 
 namespace ratio
@@ -93,7 +94,10 @@ namespace ratio
             LOG_DEBUG(flw.to_json().dump());
             // Compute the resolvers for the selected flaw..
             if (!flw.is_expanded())
+            {
                 compute_resolvers(flw);
+                compute_flaw_cost(flw);
+            }
             if (flw.get_resolvers().size() == 1)
             { // If there is only one resolver and applying it does not lead to a conflict, continue from the current node..
                 auto &res = flw.get_resolvers().front().get();
@@ -130,6 +134,33 @@ namespace ratio
         return af.get_atom();
     }
 
+    void basic_solver::compute_flaw_cost(flaw &f) noexcept
+    {
+        std::stack<std::pair<flaw *, std::unordered_set<flaw *>>> stk;
+        stk.push({&f, {}}); // we push the flaw in the stack..
+
+        while (!stk.empty())
+        {
+            auto c_f = stk.top();
+            stk.pop();
+
+            utils::rational c_cost = utils::rational::positive_infinite;
+            for (const auto &res : c_f.first->get_resolvers())
+                c_cost = std::min(c_cost, res.get().get_estimated_cost());
+
+            if (c_f.first->get_estimated_cost() != c_cost) // we update the cost of the flaw..
+            {
+                set_flaw_cost(*c_f.first, c_cost);
+                // we propagate the cost to the causes..
+                for (auto &cause : c_f.first->get_causes())
+                    stk.push({&cause.get().get_flaw(), c_f.second}); // we push the cause flaw in the stack..
+                // we propagate the cost to the supported resolvers..
+                for (auto &support : c_f.first->get_supports())
+                    stk.push({&support.get().get_flaw(), c_f.second}); // we push the supported flaw in the stack..
+            }
+        }
+    }
+
     std::shared_ptr<basic_solver::Node> basic_solver::find_common_ancestor(std::shared_ptr<Node> a, std::shared_ptr<Node> b) const
     {
         std::unordered_set<std::shared_ptr<Node>> ancestors;

src/server/basic_solver_server.cpp

@@ -53,18 +53,15 @@ namespace ratio
     {
         auto j_msg = f.to_json();
         j_msg["id"] = static_cast<uint64_t>(f.get_id());
-        j_msg["cost"] = linspire::to_json(utils::rational::zero);
         j_msg["state"] = "active";
         j_msg["msg_type"] = "flaw_created";
         auto msg = j_msg.dump();
         for (auto client : clients)
             client->send(msg);
     }
-    void server::current_flaw(std::optional<std::reference_wrapper<ratio::flaw>> f) noexcept
+    void server::flaw_cost_changed(const ratio::flaw &f) noexcept
     {
-        auto j_msg = json::json{{"msg_type", "current_flaw"}};
-        if (f)
-            j_msg["id"] = f.value().get().get_id();
+        auto j_msg = json::json{{"msg_type", "flaw_cost_changed"}, {"id", f.get_id()}, {"cost", linspire::to_json(f.get_estimated_cost())}};
         auto msg = j_msg.dump();
         for (auto client : clients)
             client->send(msg);
@@ -80,6 +77,16 @@ namespace ratio
         for (auto client : clients)
             client->send(msg);
     }
+
+    void server::current_flaw(std::optional<std::reference_wrapper<ratio::flaw>> f) noexcept
+    {
+        auto j_msg = json::json{{"msg_type", "current_flaw"}};
+        if (f)
+            j_msg["id"] = f.value().get().get_id();
+        auto msg = j_msg.dump();
+        for (auto client : clients)
+            client->send(msg);
+    }
     void server::current_resolver(std::optional<std::reference_wrapper<ratio::resolver>> r) noexcept
     {
         auto j_msg = json::json{{"msg_type", "current_resolver"}};

src/solver_core.cpp

@@ -5,10 +5,12 @@
 
 #ifdef ORATIO_ENABLE_LISTENERS
 #define CURRENT_FLAW(f) current_flaw(f)
+#define FLAW_COST_CHANGED(f) flaw_cost_changed(f)
 #define CURRENT_RESOLVER(r) current_resolver(r)
 #define NEW_CAUSAL_LINK(f, r) causal_link_added(f, r)
 #else
 #define CURRENT_FLAW(f)
+#define FLAW_COST_CHANGED(f)
 #define CURRENT_RESOLVER(r)
 #define NEW_CAUSAL_LINK(f, r)
 #endif
@@ -25,7 +27,7 @@ namespace ratio
 
     json::json flaw::to_json() const
     {
-        json::json j_flaw;
+        json::json j_flaw{{"cost", linspire::to_json(est_cost)}};
         if (!causes.empty())
         {
             json::json j_causes(json::json_type::array);
@@ -43,6 +45,24 @@ namespace ratio
             throw std::runtime_error("Failed to execute expression in resolver");
     }
 
+    utils::rational resolver::resolver::get_estimated_cost() const noexcept
+    {
+        if (preconditions.empty())
+            return intrinsic_cost;
+#ifdef H_ADD
+        // we compute the cost of the resolver as the sum of its intrinsic cost and the estimated costs of its preconditions..
+        return std::accumulate(preconditions.begin(), preconditions.end(), intrinsic_cost, [](const auto &lhs, const auto &prec)
+                               { return lhs + prec.get().get_estimated_cost(); });
+#endif
+#ifdef H_MAX
+        // we compute the cost of the resolver as the sum of its intrinsic cost and the maximum of its preconditions' estimated costs..
+        return intrinsic_cost + (*std::max_element(preconditions.begin(), preconditions.end(), [](const auto &lhs, const auto &rhs)
+                                                   { return lhs.get().get_estimated_cost() < rhs.get().get_estimated_cost(); }))
+                                    .get()
+                                    .get_estimated_cost();
+#endif
+    }
+
     json::json resolver::to_json() const
     {
         json::json j_resolver{{"flaw", flw.get_id()}, {"intrinsic_cost", linspire::to_json(intrinsic_cost)}};
@@ -445,6 +465,15 @@ namespace ratio
             ac_slv.retract(ac_cnst);
     }
 
+    void solver_core::set_flaw_cost(flaw &flw, const utils::rational &cost) noexcept
+    {
+        if (flw.est_cost != cost)
+        {
+            flw.est_cost = cost;
+            FLAW_COST_CHANGED(flw);
+        }
+    }
+
     riddle::atom_state solver_core::get_atom_state(const riddle::atom_term &atm) const noexcept
     {
         switch (ac_slv.sat_val(static_cast<const riddle::atom &>(atm).get_sigma()))