mCRL2
Loading...
Searching...
No Matches
ParityGame_impl.h
Go to the documentation of this file.
1// Copyright (c) 2009-2013 University of Twente
2// Copyright (c) 2009-2013 Michael Weber <michaelw@cs.utwente.nl>
3// Copyright (c) 2009-2013 Maks Verver <maksverver@geocities.com>
4// Copyright (c) 2009-2013 Eindhoven University of Technology
5//
6// Distributed under the Boost Software License, Version 1.0.
7// (See accompanying file LICENSE_1_0.txt or copy at
8// http://www.boost.org/LICENSE_1_0.txt)
9
10// Don't include this directly; include ParityGame.h instead!
11
12#ifndef MCRL2_PG_PARITYGAME_IMPL_H
13#define MCRL2_PG_PARITYGAME_IMPL_H
14
15#include "mcrl2/pg/ParityGame.h"
16
17template<class ForwardIterator>
19 ForwardIterator vertices_begin,
20 ForwardIterator vertices_end,
21 bool proper,
22 StaticGraph::EdgeDirection edge_dir )
23{
24 assert(this != &game);
25
26 const verti num_vertices = std::distance(vertices_begin, vertices_end);
27 ForwardIterator it;
28 verti v;
29
30 reset(num_vertices, game.d());
31 for (it = vertices_begin, v = 0; v < num_vertices; ++v, ++it)
32 {
33 vertex_[v] = game.vertex_[*it];
34 }
35 graph_.make_subgraph(game.graph_, vertices_begin, vertices_end,
36 proper, edge_dir);
38}
39
40template<class StrategyT>
41ParityGame::Player ParityGame::winner(const StrategyT &s, verti v) const
42{
43 /* A vertex is won by its player iff the player has a strategy for it: */
44 return (s[v] != NO_VERTEX) ? player(v) : opponent(player(v));
45}
46
47#endif // MCRL2_PG_PARITYGAME_IMPL_H
std::size_t edgei
type used to number edges
Definition Graph.h:25
void swap(StaticGraph &a, StaticGraph &b)
Definition Graph.h:297
std::size_t verti
type used to number vertices
Definition Graph.h:24
#define NO_VERTEX
Definition Graph.h:27
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)
std::size_t priority_t
Definition ParityGame.h:32
player_t
Definition ParityGame.h:35
@ PLAYER_ODD
Odd (1)
Definition ParityGame.h:36
@ PLAYER_EVEN
Even (0)
Definition ParityGame.h:35
player_t opponent(const player_t p)
Definition ParityGame.h:40
bool operator==(const ParityGameVertex &a, const ParityGameVertex &b)
Definition ParityGame.h:68
#define ATTR_PACKED
Definition ParityGame.h:23
void swap(ParityGame &a, ParityGame &b)
Definition ParityGame.h:328
bool operator!=(const ParityGameVertex &a, const ParityGameVertex &b)
Definition ParityGame.h:73
bool aborted()
Returns whether this instance has been aborted.
Definition Abortable.h:25
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.
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)
Definition DenseMap.h:59
value_type * operator->()
Definition DenseMap.h:62
value_type * pos_
Definition DenseMap.h:47
Iterator(const Iterator &it)
Definition DenseMap.h:51
Iterator(value_type *pos)
Definition DenseMap.h:50
bool operator!=(const Iterator &other)
Definition DenseMap.h:55
Iterator & operator=(const Iterator &it)
Definition DenseMap.h:52
bool operator<=(const Iterator &other)
Definition DenseMap.h:58
bool operator<(const Iterator &other)
Definition DenseMap.h:56
value_type operator*()
Definition DenseMap.h:61
bool operator>(const Iterator &other)
Definition DenseMap.h:57
bool operator==(const Iterator &other)
Definition DenseMap.h:54
Val & operator[](Key k)
Definition DenseMap.h:137
iterator end()
Definition DenseMap.h:104
std::size_t used_
Definition DenseMap.h:162
const_iterator begin() const
Definition DenseMap.h:109
const_iterator find(Key k) const
Definition DenseMap.h:132
DenseMap(Key begin, Key end, const Alloc &alloc=Alloc())
Definition DenseMap.h:68
const std::size_t range_size_
Definition DenseMap.h:160
const_iterator end() const
Definition DenseMap.h:114
bool empty() const
Definition DenseMap.h:82
std::pair< iterator, bool > insert(const value_type &new_kv)
Definition DenseMap.h:148
const Key range_begin
Definition DenseMap.h:157
std::vector< value_type > values_
Definition DenseMap.h:161
Iterator iterator
Definition DenseMap.h:65
iterator begin()
Definition DenseMap.h:97
const Key range_end
Definition DenseMap.h:157
iterator find(Key k)
Definition DenseMap.h:119
std::size_t size() const
Definition DenseMap.h:81
DenseMap & operator=(const DenseMap &)
Iterator const_iterator
Definition DenseMap.h:66
DenseMap(const DenseMap &)
void clear()
Definition DenseMap.h:84
std::pair< Key, Val > value_type
Definition DenseMap.h:43
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(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 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
Definition ParityGame.h:259
verti cardinality(int p) const
Definition ParityGame.h:266
priority_t d() const
Definition ParityGame.h:253
void clear()
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
Definition ParityGame.h:262
bool empty() const
Definition ParityGame.h:115
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
StaticGraph graph_
Definition ParityGame.h:318
void assign(const ParityGame &game)
verti * cardinality_
Definition ParityGame.h:325
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)
bool proper() const
void write_dot(std::ostream &os) const
player_t Player
Definition ParityGame.h:87
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)
void make_dual()
ParityGameVertex * vertex_
Definition ParityGame.h:321
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
Definition ParityGame.h:256
void make_random(verti V, unsigned clustersize, unsigned outdeg, StaticGraph::EdgeDirection edge_dir, int d)
std::vector< verti > Strategy
Definition ParityGame.h:97
void deref() const
Decrement reference count and delete the object if it becomes zero.
Definition RefCounted.h:39
void ref() const
Increment reference count.
Definition RefCounted.h:36
Definition SCC_impl.h:36
SmallProgressMeasuresSolver2 & operator=(const SmallProgressMeasuresSolver2 &)
SmallProgressMeasuresSolver2(const SmallProgressMeasuresSolver2 &)
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)
std::shared_ptr< LiftingStrategyFactory > lsf_
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 &)
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
const verti * M() const
SmallProgressMeasures(const SmallProgressMeasures &)
void debug_print() const
bool less_than(verti v, const verti vec2[], bool carry=0)
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
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
Definition Graph.h:74
void make_random(verti V, unsigned outdeg, EdgeDirection edge_dir, bool scc)
Definition Graph.cpp:138
StaticGraph(const StaticGraph &graph)
verti * successors_
Definition Graph.h:278
edgei degree(verti v) const
Definition Graph.h:218
const_iterator succ_end(verti v) const
Definition Graph.h:193
~StaticGraph()
Definition Graph.cpp:22
void reset(verti V, edgei E, EdgeDirection edge_dir)
Definition Graph.cpp:35
edgei indegree(verti v) const
Definition Graph.h:228
EdgeDirection edge_dir() const
Definition Graph.h:185
StaticGraph & operator=(const StaticGraph &graph)
void make_subgraph(const StaticGraph &graph, ForwardIterator vertices_begin, ForwardIterator vertices_end, bool proper, EdgeDirection edge_dir=EDGE_NONE)
Definition Graph_impl.h:52
edgei * predecessor_index_
Definition Graph.h:283
verti V_
Definition Graph.h:271
void make_random_clustered(verti cluster_size, verti V, unsigned outdeg, EdgeDirection edge_dir)
Definition Graph.cpp:191
void read_raw(std::istream &is)
Definition Graph.cpp:474
void swap(StaticGraph &g)
Definition Graph.cpp:498
const_iterator succ_begin(verti v) const
Definition Graph.h:188
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)
Definition Graph.cpp:308
void make_random_scc(edge_list &edges)
Definition Graph.cpp:83
bool has_succ(verti v, verti w) const
Definition Graph.h:208
edgei * successor_index_
Definition Graph.h:283
void write_raw(std::ostream &os) const
Definition Graph.cpp:457
verti V() const
Definition Graph.h:179
edge_list get_edges() const
Definition Graph.cpp:438
void assign(const StaticGraph &graph)
Definition Graph.cpp:288
void make_subgraph(const StaticGraph &graph, ForwardIterator vertices_begin, ForwardIterator vertices_end, VertexMapT &vertex_map, bool proper, EdgeDirection edge_dir=EDGE_NONE)
Definition Graph_impl.h:76
verti * predecessors_
Definition Graph.h:278
void remove_edges(edge_list &edges)
Definition Graph.cpp:365
void shuffle_vertices(const std::vector< verti > &perm)
Definition Graph.cpp:277
const_iterator pred_begin(verti v) const
Definition Graph.h:198
void shuffle_vertices()
Definition Graph.cpp:269
EdgeDirection
Definition Graph.h:84
@ EDGE_SUCCESSOR
Definition Graph.h:86
@ EDGE_BIDIRECTIONAL
Definition Graph.h:88
@ EDGE_NONE
Definition Graph.h:85
@ EDGE_PREDECESSOR
Definition Graph.h:87
void clear()
Definition Graph.cpp:30
bool has_pred(verti w, verti v) const
Definition Graph.h:213
const_iterator pred_end(verti v) const
Definition Graph.h:203
edgei outdegree(verti v) const
Definition Graph.h:223
bool empty() const
Definition Graph.h:176
EdgeDirection edge_dir_
Definition Graph.h:286
const verti * const_iterator
Definition Graph.h:66
edgei E_
Definition Graph.h:272
StaticGraph()
Definition Graph.cpp:15
edgei E() const
Definition Graph.h:182
logger(const log_level_t l)
Default constructor.
Definition logger.h:164
parameterized boolean equation system
Definition pbes.h:58
#define mCRL2log(LEVEL)
mCRL2log(LEVEL) provides the stream used to log.
Definition logger.h:391
@ verbose
Definition logger.h:37
The main namespace for the PBES library.
player_t player
the vertex owner (i.e. next player to move)
Definition ParityGame.h:62
priority_t priority
the priority of the vertex between 0 and d (exclusive).
Definition ParityGame.h:65
std::size_t operator()(const atermpp::detail::reference_aterm< T > &t) const