Test LP generalization

include/PetriEngine/PQL/Contexts.h

@@ -26,6 +26,7 @@
 #include "../Simplification/LPCache.h"
 #include "../NetStructures.h"
 #include "utils/structures/shared_string.h"
+#include "PetriEngine/options.h"
 
 #include "utils/errors.h"
 
@@ -36,6 +37,8 @@
 #include <chrono>
 #include <glpk.h>
 
+#include <chrono>
+
 namespace PetriEngine {
 
     namespace PQL {
@@ -201,16 +204,22 @@ namespace PetriEngine {
         };
 
         class SimplificationContext {
+            struct simplificationRules{
+                bool G_rule = false;
+                bool F_rule = false;
+                bool X_rule = false;
+            };
         public:
 
             SimplificationContext(const MarkVal* marking,
-                    const PetriNet* net, uint32_t queryTimeout, uint32_t lpTimeout,
+                    const PetriNet* net, int num_paths, uint32_t queryTimeout, uint32_t lpTimeout, uint32_t lpPrintLevel,
                     Simplification::LPCache* cache, uint32_t potencyTimeout = 0)
-                    : _queryTimeout(queryTimeout), _lpTimeout(lpTimeout),
+                    : _queryTimeout(queryTimeout), _lpTimeout(lpTimeout), _lpPrintLevel(lpPrintLevel),
                     _potencyTimeout(potencyTimeout) {
                 _negated = false;
                 _marking = marking;
                 _net = net;
+                _num_paths = num_paths;
                 _base_lp = buildBase();
                 _start = std::chrono::high_resolution_clock::now();
                 _cache = cache;
@@ -220,8 +229,26 @@ namespace PetriEngine {
                         _markingOutOfBounds = true;
                     }
                 }
+
+                _isDeadlocked = _net->deadlocked(_marking);
+                _id = std::chrono::system_clock::now();
+            }
+
+            SimplificationContext(const MarkVal* marking,
+                    const PetriNet* net, int num_paths, uint32_t queryTimeout, options_t& options,
+                    Simplification::LPCache* cache)
+                    :  SimplificationContext(marking, net, num_paths, queryTimeout, options.lpsolveTimeout, options.lpPrintLevel, cache){
+                        _rules = {options.useGRule, options.useFRule, options.useXRule};
+                        _permutationLimit = static_cast<uint64_t>(options.permutationLimit);
+
             }
 
+            SimplificationContext(const MarkVal* marking,
+                    const PetriNet* net, uint32_t queryTimeout, uint32_t lpTimeout, uint32_t lpPrintLevel,
+                    Simplification::LPCache* cache, uint32_t potencyTimeout = 0) : SimplificationContext(marking, net, 1, queryTimeout, lpTimeout, lpPrintLevel, cache, potencyTimeout){};
+
+            std::chrono::time_point<std::chrono::system_clock> _id;
+
             virtual ~SimplificationContext() {
                 if(_base_lp != nullptr)
                     glp_delete_prob(_base_lp);
@@ -237,6 +264,10 @@ namespace PetriEngine {
                 return _markingOutOfBounds;
             }
 
+            bool isDeadlocked() const {
+                return _isDeadlocked;
+            }
+
             const PetriNet* net() const {
                 return _net;
             }
@@ -269,20 +300,52 @@ namespace PetriEngine {
 
             uint32_t getLpTimeout() const;
             uint32_t getPotencyTimeout() const;
+            uint32_t getPrintLevel() const;
+
+            uint32_t numPaths() const{
+                return _num_paths;
+            }
+
+            uint32_t getNumBaseVariables() const{
+                return _num_paths * (_net->numberOfPlaces() + _net->numberOfTransitions());
+            }
+
+            uint32_t getNumBaseConstraints() const{
+                return _num_paths * _net->numberOfPlaces();
+            }
 
             Simplification::LPCache* cache() const
             {
                 return _cache;
             }
 
+            const simplificationRules& rules() const
+            {
+                return _rules;
+            } 
+
+            const uint64_t getPermutationLimit() const
+            {
+                return _permutationLimit;
+            }
+
+            void addAllPathConstraint(glp_prob* lp, size_t t, size_t l, int32_t* ind, double* col) const;
+            void addAllPathConstraint(glp_prob* lp, size_t t, size_t l, std::vector<int32_t>& ind, std::vector<double>& col) const;
+
             glp_prob* makeBaseLP() const;
 
+            glp_prob* buildBaseFromMarking(std::vector<std::pair<std::vector<uint32_t>, double>>& setMarking) const;
+
         private:
+            uint32_t _num_paths = 1;
+            simplificationRules _rules;
+            uint64_t _permutationLimit = 128;
             bool _negated;
             const MarkVal* _marking;
             bool _markingOutOfBounds;
+            bool _isDeadlocked;
             const PetriNet* _net;
-            uint32_t _queryTimeout, _lpTimeout, _potencyTimeout;
+            uint32_t _queryTimeout, _lpTimeout, _lpPrintLevel, _potencyTimeout;
             mutable glp_prob* _base_lp = nullptr;
             std::chrono::high_resolution_clock::time_point _start;
             Simplification::LPCache* _cache;

include/PetriEngine/PQL/Simplifier.h

@@ -39,6 +39,18 @@ namespace PetriEngine { namespace PQL {
         SimplificationContext& _context;
         Retval _return_value;
 
+        enum LPOP {NONE, GLOBAL, FINAL, NEXT, UNTIL, OTHER, NULLT};
+        LPOP operator_found = LPOP::NONE;
+        LPOP operator_parent = LPOP::NONE;
+        bool op_parent_negated = false;
+        AbstractProgramCollection::temporalContext tcx;
+        int32_t operators = 0;
+
+        bool finalLpsImpossible(std::vector<AbstractProgramCollection_ptr>& final_lps);
+        bool finalLpsImpossibleAll(std::vector<AbstractProgramCollection_ptr>& final_lps);
+        bool nextLpsImpossible(std::vector<AbstractProgramCollection_ptr>& next_lps, std::vector<AbstractProgramCollection_ptr>& final_lps, bool is_invariant, bool is_or = false);
+        bool isNextImpossible(AbstractProgramCollection_ptr next_lps, bool strict);
+
         Retval simplify_or(const LogicalCondition* element);
         Retval simplify_and(const LogicalCondition *element);
 
@@ -50,9 +62,14 @@ namespace PetriEngine { namespace PQL {
         Retval simplify_EF(Retval &r);
         Retval simplify_EX(Retval &r);
 
+        Retval simplify_global_quantifier(Retval &r);
+
         template <typename Quantifier>
         Retval simplify_simple_quantifier(Retval &r);
 
+        template <typename Quantifier>
+        Retval simplify_simple_quantifier(Retval &r, bool strict);
+
         void _accept(const NotCondition *element) override;
 
         void _accept(const AndCondition *element) override;
@@ -113,6 +130,7 @@ namespace PetriEngine { namespace PQL {
     };
 
     Member memberForPlace(size_t p, const SimplificationContext &context);
+    Member memberForPathPlace(size_t p, int trace, const SimplificationContext &context);
     Member constraint(const Expr *element, const SimplificationContext &context);
 
     class ConstraintVisitor : public ExpressionVisitor {
@@ -123,6 +141,7 @@ namespace PetriEngine { namespace PQL {
 
     private:
         const SimplificationContext& _context;
+        int _current_path = 0;
         Member _return_value;
 
         void _accept(const LiteralExpr *element) override;

include/PetriEngine/Simplification/LinearProgram.h

@@ -11,8 +11,10 @@
 #include <memory>
 #include <glpk.h>
 
+
 namespace PetriEngine {
     namespace Simplification {
+        using REAL = double;
 
         struct equation_t
         {
@@ -35,6 +37,17 @@ namespace PetriEngine {
             enum result_t { UKNOWN, IMPOSSIBLE, POSSIBLE };
             result_t _result = result_t::UKNOWN;
             std::vector<equation_t> _equations;
+            // does the writing
+            static bool _writeEquationsImpl(glp_prob* lp, const PQL::SimplificationContext& context, int& rowno, std::vector<REAL>& row, std::vector<int32_t>& indir, const std::vector<equation_t>& equations, bool allocate, int32_t variable_shift = 0);
+            // adds rows to the lp, works from empty lp
+            static bool pushEquations(glp_prob* lp, const PQL::SimplificationContext& context, int& rowno, std::vector<REAL>& row, std::vector<int32_t>& indir, const std::vector<equation_t>& equations);
+            static bool pushEquationsShifted(glp_prob* lp, const PQL::SimplificationContext& context, int& rowno, std::vector<REAL>& row, std::vector<int32_t>& indir, const std::vector<equation_t>& equations, int32_t variable_shift = 0);
+            // does not add rows to the lp, requires pre-allocating
+            static bool emplaceEquations(glp_prob* lp, const PQL::SimplificationContext& context, int& rowno, std::vector<REAL>& row, std::vector<int32_t>& indir, const std::vector<equation_t>& equations);
+            static bool emplaceEquationsShifted(glp_prob* lp, const PQL::SimplificationContext& context, int& rowno, std::vector<REAL>& row, std::vector<int32_t>& indir, const std::vector<equation_t>& equations, int32_t variable_shift = 0);
+
+            static result_t solve_built_lp(glp_prob* lp, const PQL::SimplificationContext& context, uint32_t solvetime , bool delete_lp = true);
+            result_t solve_and_set(glp_prob* lp, const PQL::SimplificationContext& context, uint32_t solvetime, bool delete_lp = true);
         public:
             void swap(LinearProgram& other)
             {
@@ -62,11 +75,19 @@ namespace PetriEngine {
             bool knownImpossible() const { return _result == result_t::IMPOSSIBLE; }
             bool knownPossible() const { return _result == result_t::POSSIBLE; }
 
+
             bool isImpossible(const PQL::SimplificationContext& context, uint32_t solvetime);
+            bool isFinalImpossibleWith(const LinearProgram* withLp, bool is_next, bool is_strict, const PQL::SimplificationContext& context, uint32_t solvetime = std::numeric_limits<uint32_t>::max()) const;
+            bool isFinalImpossibleWithN(const std::vector<uint32_t>& permutation, const std::vector<LinearProgram*>& lps, bool is_next, bool is_strict, const PQL::SimplificationContext& context, uint32_t solvetime = std::numeric_limits<uint32_t>::max()) const;
+            bool isNStepsImpossible(double firelimit, bool strict, const PQL::SimplificationContext& context, uint32_t solvetime = std::numeric_limits<uint32_t>::max());
             void solvePotency(const PQL::SimplificationContext& context, std::vector<uint32_t>& potencies);
 
+            static bool solveFinalConjunctionImpossible(std::vector<LinearProgram*>& lps, std::vector<std::vector<uint32_t>>& perms, std::vector<uint32_t>& starts,const PQL::SimplificationContext& context, uint32_t solvetime = std::numeric_limits<uint32_t>::max());
+        private:
+            static bool isFinalPermutationImpossible(glp_prob* lp, const std::vector<uint32_t>& permutation, const std::vector<LinearProgram*>& lps,const PQL::SimplificationContext& context, uint32_t solvetime = std::numeric_limits<uint32_t>::max());
+        public:    
             void make_union(const LinearProgram& other);
-
+        
             std::ostream& print(std::ostream& ss, size_t indent = 0) const
             {
                 for (size_t i = 0; i < indent ; ++i) ss << "\t";