EdgeAbstractor.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <memory>
#include <set>
#include <vector>
 
#include "storm-gamebased-ar/abstraction/GameBddResult.h"
#include "storm-gamebased-ar/abstraction/LocalExpressionInformation.h"
#include "storm-gamebased-ar/abstraction/StateSetAbstractor.h"
 
#include "storm/storage/expressions/ExpressionEvaluator.h"
 
#include "storm/storage/dd/DdType.h"
#include "storm/storage/expressions/Expression.h"
 
#include "storm/solver/SmtSolver.h"
 
namespace storm {
namespace utility {
namespace solver {
class SmtSolverFactory;
}
}  // namespace utility
 
namespace dd {
template<storm::dd::DdType DdType>
class Bdd;
 
template<storm::dd::DdType DdType, typename ValueType>
class Add;
}  // namespace dd
 
namespace jani {
// Forward-declare concrete edge and assignment classes.
class Edge;
class Assignment;
class OrderedAssignments;
}  // namespace jani
}  // namespace storm
 
namespace storm::gbar {
namespace abstraction {
template<storm::dd::DdType DdType>
class AbstractionInformation;
 
template<storm::dd::DdType DdType>
struct BottomStateResult;
 
namespace jani {
template<storm::dd::DdType DdType, typename ValueType>
class EdgeAbstractor {
   public:
    EdgeAbstractor(uint64_t edgeId, storm::jani::Edge const& edge, AbstractionInformation<DdType>& abstractionInformation,
                   std::shared_ptr<storm::utility::solver::SmtSolverFactory> const& smtSolverFactory, bool useDecomposition, bool addPredicatesForValidBlocks,
                   bool debug);
 
    void refine(std::vector<uint_fast64_t> const& predicates);
 
    storm::expressions::Expression const& getGuard() const;
 
    uint64_t getNumberOfUpdates(uint64_t player1Choice) const;
 
    std::map<storm::expressions::Variable, storm::expressions::Expression> getVariableUpdates(uint64_t auxiliaryChoice) const;
 
    std::set<storm::expressions::Variable> const& getAssignedVariables() const;
 
    GameBddResult<DdType> abstract();
 
    BottomStateResult<DdType> getBottomStateTransitions(
        storm::dd::Bdd<DdType> const& reachableStates, uint_fast64_t numberOfPlayer2Variables,
        boost::optional<std::pair<storm::expressions::Variable, storm::expressions::Variable>> const& locationVariables);
 
    storm::dd::Add<DdType, ValueType> getEdgeDecoratorAdd(
        boost::optional<std::pair<storm::expressions::Variable, storm::expressions::Variable>> const& locationVariables) const;
 
    storm::jani::Edge const& getConcreteEdge() const;
 
    void notifyGuardIsPredicate();
 
   private:
    std::pair<std::set<uint_fast64_t>, std::set<uint_fast64_t>> computeRelevantPredicates(storm::jani::OrderedAssignments const& assignments) const;
 
    std::pair<std::set<uint_fast64_t>, std::vector<std::set<uint_fast64_t>>> computeRelevantPredicates() const;
 
    bool relevantPredicatesChanged(std::pair<std::set<uint_fast64_t>, std::vector<std::set<uint_fast64_t>>> const& newRelevantPredicates) const;
 
    void addMissingPredicates(std::pair<std::set<uint_fast64_t>, std::vector<std::set<uint_fast64_t>>> const& newRelevantPredicates);
 
    storm::dd::Bdd<DdType> getSourceStateBdd(storm::solver::SmtSolver::ModelReference const& model,
                                             std::vector<std::pair<storm::expressions::Variable, uint_fast64_t>> const& variablePredicates) const;
 
    storm::dd::Bdd<DdType> getDistributionBdd(storm::solver::SmtSolver::ModelReference const& model,
                                              std::vector<std::vector<std::pair<storm::expressions::Variable, uint_fast64_t>>> const& variablePredicates) const;
 
    void recomputeCachedBdd();
 
    void recomputeCachedBddWithoutDecomposition();
 
    void recomputeCachedBddWithDecomposition();
 
    storm::dd::Bdd<DdType> computeMissingDestinationIdentities() const;
 
    AbstractionInformation<DdType> const& getAbstractionInformation() const;
 
    AbstractionInformation<DdType>& getAbstractionInformation();
 
    // An SMT responsible for this abstract command.
    std::unique_ptr<storm::solver::SmtSolver> smtSolver;
 
    // The abstraction-related information.
    std::reference_wrapper<AbstractionInformation<DdType>> abstractionInformation;
 
    // The ID of the edge.
    uint64_t edgeId;
 
    // The concrete edge this abstract command refers to.
    std::reference_wrapper<storm::jani::Edge const> edge;
 
    // The variables to which this edge assigns expressions.
    std::set<storm::expressions::Variable> assignedVariables;
 
    // The local expression-related information.
    LocalExpressionInformation<DdType> localExpressionInformation;
 
    // The evaluator used to translate the probability expressions.
    storm::expressions::ExpressionEvaluator<ValueType> evaluator;
 
    // The currently relevant source/successor predicates and the corresponding variables.
    std::pair<std::vector<std::pair<storm::expressions::Variable, uint_fast64_t>>,
              std::vector<std::vector<std::pair<storm::expressions::Variable, uint_fast64_t>>>>
        relevantPredicatesAndVariables;
 
    // The set of all relevant predicates.
    std::set<uint64_t> allRelevantPredicates;
 
    // The most recent result of a call to computeDd. If nothing has changed regarding the relevant
    // predicates, this result may be reused.
    GameBddResult<DdType> cachedDd;
 
    // All relevant decision variables over which to perform AllSat.
    std::vector<storm::expressions::Variable> decisionVariables;
 
    // A flag indicating whether to use the decomposition when abstracting.
    bool useDecomposition;
 
    // Whether or not to add predicates indirectly related to assignment variables to relevant source predicates.
    bool addPredicatesForValidBlocks;
 
    // A flag indicating whether the computation of bottom states can be skipped (for example, if the bottom
    // states become empty at some point).
    bool skipBottomStates;
 
    // A flag remembering whether we need to force recomputation of the BDD.
    bool forceRecomputation;
 
    // The abstract guard of the edge. This is only used if the guard is not a predicate, because it can
    // then be used to constrain the bottom state abstractor.
    storm::dd::Bdd<DdType> abstractGuard;
 
    // A state-set abstractor used to determine the bottom states if not all guards were added.
    StateSetAbstractor<DdType, ValueType> bottomStateAbstractor;
 
    // A flag that indicates whether or not debug mode is enabled.
    bool debug;
};
}  // namespace jani
}  // namespace abstraction
}  // namespace storm::gbar