12#ifndef MCRL2_PG_PARITYGAME_IMPL_H
13#define MCRL2_PG_PARITYGAME_IMPL_H
15#include "mcrl2/pg/ParityGame.h"
17template<
class ForwardIterator>
19 ForwardIterator vertices_begin,
20 ForwardIterator vertices_end,
24 assert(
this != &game);
26 const verti num_vertices =
std::distance(vertices_begin, vertices_end);
31 for (it = vertices_begin, v = 0; v < num_vertices; ++v, ++it)
35 graph_.make_subgraph(game
.graph_, vertices_begin, vertices_end,
40template<
class StrategyT>
std::size_t edgei
type used to number edges
void swap(StaticGraph &a, StaticGraph &b)
std::size_t verti
type used to number vertices
void merge_strategies(std::vector< verti > &strategy, const std::vector< verti > &substrat, const std::vector< verti > &vertex_map)
void merge_vertex_maps(ForwardIterator begin, ForwardIterator end, const verti *old_map, verti old_map_size)
player_t opponent(const player_t p)
bool operator==(const ParityGameVertex &a, const ParityGameVertex &b)
void swap(ParityGame &a, ParityGame &b)
bool operator!=(const ParityGameVertex &a, const ParityGameVertex &b)
bool aborted()
Returns whether this instance has been aborted.
Factory class for ComponentSolver instances.
const int max_depth_
Maximum recursion depth.
ParityGameSolver * create(const ParityGame &game, const verti *vertex_map, verti vertex_map_size)
Return a new ComponentSolver instance.
~ComponentSolverFactory()
ParityGameSolverFactory & pgsf_
Factory used to create subsolvers.
ComponentSolverFactory(ParityGameSolverFactory &pgsf, int max_depth=10)
ComponentSolver(const ParityGame &game, ParityGameSolverFactory &pgsf, int max_depth, const verti *vmap=0, verti vmap_size=0)
const verti vmap_size_
Size of vertex map.
const int max_depth_
Max. recusion depth.
ParityGame::Strategy solve()
ParityGameSolverFactory & pgsf_
Solver factory to use.
const verti * vmap_
Current vertex map.
int operator()(const verti *vertices, std::size_t num_vertices)
ParityGame::Strategy strategy_
Resulting strategy.
bool operator>=(const Iterator &other)
value_type * operator->()
Iterator(const Iterator &it)
Iterator(value_type *pos)
bool operator!=(const Iterator &other)
Iterator & operator=(const Iterator &it)
bool operator<=(const Iterator &other)
bool operator<(const Iterator &other)
bool operator>(const Iterator &other)
bool operator==(const Iterator &other)
const_iterator begin() const
const_iterator find(Key k) const
DenseMap(Key begin, Key end, const Alloc &alloc=Alloc())
const std::size_t range_size_
const_iterator end() const
std::pair< iterator, bool > insert(const value_type &new_kv)
std::vector< value_type > values_
DenseMap & operator=(const DenseMap &)
DenseMap(const DenseMap &)
std::pair< Key, Val > value_type
const verti * vec(verti v) const
verti * spm_
array storing the SPM vector data
DenseSPM(const ParityGame &game, ParityGame::Player player, LiftingStatistics *stats=0, const verti *vertex_map=0, verti vertex_map_size=0)
void set_vec_to_top(verti v)
void set_vec(verti v, const verti src[], bool carry)
long long lifts_attempted() const
LiftingStatistics(const ParityGame &game, long long max_lifts=-1)
void add_lifts_succeeded(long long count)
void add_lifts_attempted(long long count)
void add_lifts_succeeded(verti v, long long count)
std::vector< std::pair< long long, long long > > vertex_stats_
long long lifts_attempted_
long long lifts_succeeded_
long long lifts_attempted(verti v) const
void record_lift(verti v, bool success)
long long lifts_succeeded() const
long long lifts_succeeded(verti v) const
void add_lifts_attempted(verti v, long long count)
virtual ~ParityGameSolverFactory()
virtual ParityGameSolver * create(const ParityGame &game, const verti *vertex_map=NULL, verti vertex_map_size=0)=0
const ParityGame & game() const
virtual ~ParityGameSolver()
const ParityGame & game_
Game being solved.
ParityGameSolver(const ParityGame &game)
virtual ParityGame::Strategy solve()=0
priority_t priority(verti v) const
verti cardinality(int p) const
void make_subgame(const ParityGame &game, ForwardIterator vertices_begin, ForwardIterator vertices_end, bool proper, StaticGraph::EdgeDirection edge_dir=StaticGraph::EDGE_NONE)
Player player(verti v) const
ParityGame(const ParityGame &game)
void swap(ParityGame &pg)
void reset(verti V, int d)
long long propagate_priorities()
ParityGame & operator=(const ParityGame &game)
void write_pgsolver(std::ostream &os) const
void assign(const ParityGame &game)
void assign_pbes(mcrl2::pbes_system::pbes &pbes, verti *goal_vertex=0, StaticGraph::EdgeDirection edge_dir=StaticGraph::EDGE_BIDIRECTIONAL, const std::string &rewrite_strategy="jitty")
void read_pgsolver(std::istream &is, StaticGraph::EdgeDirection edge_dir=StaticGraph::EDGE_BIDIRECTIONAL)
void write_dot(std::ostream &os) const
void shuffle(const std::vector< verti > &perm)
void read_raw(std::istream &is)
void write_debug(const Strategy &s=Strategy(), std::ostream &os=std::cerr) const
void write_raw(std::ostream &os) const
void recalculate_cardinalities(verti num_vertices)
bool verify(const Strategy &s, verti *error) const
Player winner(const StrategyT &s, verti v) const
int propagate_priority(verti v, StaticGraph::const_iterator it, StaticGraph::const_iterator end)
void compress_priorities(const verti cardinality[]=0, bool preserve_parity=true)
ParityGameVertex * vertex_
void read_pbes(const std::string &file_path, verti *goal_vertex=0, StaticGraph::EdgeDirection edge_dir=StaticGraph::EDGE_BIDIRECTIONAL, const std::string &rewrite_strategy="jitty")
void assign(const StaticGraph &g, ParityGameVertex *na)
const StaticGraph & graph() const
void make_random(verti V, unsigned clustersize, unsigned outdeg, StaticGraph::EdgeDirection edge_dir, int d)
std::vector< verti > Strategy
void deref() const
Decrement reference count and delete the object if it becomes zero.
void ref() const
Increment reference count.
SmallProgressMeasuresSolver2 & operator=(const SmallProgressMeasuresSolver2 &)
SmallProgressMeasuresSolver2(const SmallProgressMeasuresSolver2 &)
ParityGame::Strategy solve_alternate()
ParityGame::Strategy solve_normal()
SmallProgressMeasuresSolver2(const ParityGame &game, std::shared_ptr< LiftingStrategyFactory > lsf, bool alternate=false, LiftingStatistics *stats=0, const verti *vmap=0, verti vmap_size=0)
SmallProgressMeasuresSolverFactory(std::shared_ptr< LiftingStrategyFactory > lsf, int version=1, bool alt=false, LiftingStatistics *stats=0)
ParityGameSolver * create(const ParityGame &game, const verti *vmap, verti vmap_size)
LiftingStatistics * stats_
std::shared_ptr< LiftingStrategyFactory > lsf_
SetToTopIterator(SmallProgressMeasures &spm)
SetToTopIterator & operator*()
SetToTopIterator & operator=(verti v)
SetToTopIterator & operator++(int)
SetToTopIterator & operator++()
SmallProgressMeasures & spm
bool alternate_
whether to use the alternate algorithm
const verti vmap_size_
size of vertex map
virtual ParityGame::Strategy solve_normal()
std::shared_ptr< LiftingStrategyFactory > lsf_
factory used to create lifting strategy
virtual ParityGame::Strategy solve_alternate()
SmallProgressMeasuresSolver & operator=(const SmallProgressMeasuresSolver &)
ParityGame::Strategy solve()
LiftingStatistics * stats_
object to record lifting statistics
const verti * vmap_
current vertex map
static void preprocess_game(ParityGame &game)
SmallProgressMeasuresSolver(const SmallProgressMeasuresSolver &)
SmallProgressMeasuresSolver(const ParityGame &game, std::shared_ptr< LiftingStrategyFactory > lsf, bool alternate=false, LiftingStatistics *stats=0, const verti *vmap=0, verti vmap_size=0)
void debug_print_vertex(int v) const
long long solve_some(LiftingStrategy2 &ls, long long attempts=work_size)
long long solve_some(LiftingStrategy &ls, long long attempts=work_size)
const verti * vmap_
active vertex map (if any)
LiftingStatistics * stats_
statistics object to record lifts
SmallProgressMeasures(const ParityGame &game, ParityGame::Player player, LiftingStatistics *stats=0, const verti *vmap=0, verti vmap_size=0)
const std::size_t p_
the player to solve for
verti solve_one(LiftingStrategy2 &ls)
SmallProgressMeasures & operator=(const SmallProgressMeasures &)
void get_strategy(ParityGame::Strategy &strat) const
verti * M_
bounds on the SPM vector components
bool take_max(verti v) const
verti get_max_succ(verti v) const
void set_M(const verti *new_M)
std::size_t len_
length of SPM vectors
virtual void set_vec_to_top(verti v)=0
bool is_top(const verti vec[]) const
verti get_min_succ(verti v) const
SmallProgressMeasures(const SmallProgressMeasures &)
virtual ~SmallProgressMeasures()
bool less_than(verti v, const verti vec2[], bool carry=0)
bool is_top(verti v) const
bool compare_strict(verti v) const
int vector_cmp(verti v, verti w, int N) const
verti get_ext_succ(verti v) const
bool is_dirty(verti v) const
bool lift_to(verti v, const verti vec2[], bool carry=0)
void get_winning_set(ParityGame::Player player, OutputIterator result)
const ParityGame & game() const
bool * dirty_
marks unstable vertices
ParityGame::Player player() const
std::pair< verti, bool > solve_one(LiftingStrategy &ls)
verti vmap_size_
size of vertex map
bool lift_to_top(verti v)
static const int work_size
Maximum number of lifting attempts in a row before checking timer.
verti get_successor(verti v) const
verti get_strategy(verti v) const
int vector_cmp(const verti vec1[], const verti vec2[], int N) const
void initialize_lifting_strategy(LiftingStrategy2 &ls)
const ParityGame & game_
the game being solved
verti get_ext_succ(verti v, bool take_max) const
virtual void set_vec(verti v, const verti src[], bool carry)=0
ParityGame::Strategy strategy_
current strategy
virtual const verti * vec(verti v) const =0
std::vector< std::pair< verti, verti > > edge_list
void make_random(verti V, unsigned outdeg, EdgeDirection edge_dir, bool scc)
StaticGraph(const StaticGraph &graph)
edgei degree(verti v) const
const_iterator succ_end(verti v) const
void reset(verti V, edgei E, EdgeDirection edge_dir)
edgei indegree(verti v) const
EdgeDirection edge_dir() const
StaticGraph & operator=(const StaticGraph &graph)
void make_subgraph(const StaticGraph &graph, ForwardIterator vertices_begin, ForwardIterator vertices_end, bool proper, EdgeDirection edge_dir=EDGE_NONE)
edgei * predecessor_index_
void make_random_clustered(verti cluster_size, verti V, unsigned outdeg, EdgeDirection edge_dir)
void read_raw(std::istream &is)
void swap(StaticGraph &g)
const_iterator succ_begin(verti v) const
void make_subgraph_threads(const StaticGraph &graph, const verti *verts, const verti nvert, bool proper, EdgeDirection edge_dir=EDGE_NONE)
void assign(edge_list edges, EdgeDirection edge_dir)
void make_random_scc(edge_list &edges)
bool has_succ(verti v, verti w) const
void write_raw(std::ostream &os) const
edge_list get_edges() const
void assign(const StaticGraph &graph)
void make_subgraph(const StaticGraph &graph, ForwardIterator vertices_begin, ForwardIterator vertices_end, VertexMapT &vertex_map, bool proper, EdgeDirection edge_dir=EDGE_NONE)
void remove_edges(edge_list &edges)
void shuffle_vertices(const std::vector< verti > &perm)
const_iterator pred_begin(verti v) const
bool has_pred(verti w, verti v) const
const_iterator pred_end(verti v) const
edgei outdegree(verti v) const
const verti * const_iterator
logger(const log_level_t l)
Default constructor.
parameterized boolean equation system
#define mCRL2log(LEVEL)
mCRL2log(LEVEL) provides the stream used to log.
The main namespace for the PBES library.
player_t player
the vertex owner (i.e. next player to move)
priority_t priority
the priority of the vertex between 0 and d (exclusive).
std::size_t operator()(const atermpp::detail::reference_aterm< T > &t) const