gtec.hh 8.67 KB
Newer Older
1
// Copyright (C) 2003, 2004, 2005  Laboratoire d'Informatique de Paris 6 (LIP6),
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// département Systèmes Répartis Coopératifs (SRC), Université Pierre
// et Marie Curie.
//
// This file is part of Spot, a model checking library.
//
// Spot is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Spot is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
// License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Spot; see the file COPYING.  If not, write to the Free
// Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
// 02111-1307, USA.

#ifndef SPOT_TGBAALGOS_GTEC_GTEC_HH
# define SPOT_TGBAALGOS_GTEC_GTEC_HH

25
#include <stack>
26
#include "status.hh"
27
#include "tgbaalgos/emptiness.hh"
28
#include "tgbaalgos/emptiness_stats.hh"
29
30
31

namespace spot
{
32
33
34
  /// \addtogroup emptiness_check_algorithms
  /// @{

35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
  /// \brief Check whether the language of an automate is empty.
  ///
  /// This is based on the following paper.
  /// \verbatim
  /// @InProceedings{couvreur.99.fm,
  ///   author    = {Jean-Michel Couvreur},
  ///   title     = {On-the-fly Verification of Temporal Logic},
  ///   pages     = {253--271},
  ///   editor    = {Jeannette M. Wing and Jim Woodcock and Jim Davies},
  ///   booktitle = {Proceedings of the World Congress on Formal Methods in
  ///                the Development of Computing Systems (FM'99)},
  ///   publisher = {Springer-Verlag},
  ///   series    = {Lecture Notes in Computer Science},
  ///   volume    = {1708},
  ///   year      = {1999},
  ///   address   = {Toulouse, France},
  ///   month     = {September},
  ///   isbn      = {3-540-66587-0}
  /// }
  /// \endverbatim
  ///
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
  /// A recursive definition of the algorithm would look as follows,
  /// but the implementation is of course not recursive.
  /// (<code>&lt;Sigma, Q, delta, q, F&gt;</code> is the automaton to
  /// check, H is an associative array mapping each state to its
  /// positive DFS order or 0 if it is dead, SCC is and ACC are two
  /// stacks.)
  ///
  /// \verbatim
  /// check(<Sigma, Q, delta, q, F>, H, SCC, ACC)
  ///   if q is not in H   // new state
  ///       H[q] = H.size + 1
  ///       SCC.push(<H[q], {}>)
  ///       forall <a, s> : <q, _, a, s> in delta
  ///           ACC.push(a)
  ///           res = check(<Sigma, Q, delta, s, F>, H, SCC, ACC)
  ///           if res
  ///               return res
  ///       <n, _> = SCC.top()
  ///       if n = H[q]
  ///           SCC.pop()
  ///           mark_reachable_states_as_dead(<Sigma, Q, delta, q, F>, H$)
  ///       return 0
  ///   else
  ///       if H[q] = 0 // dead state
  ///           ACC.pop()
  ///           return true
  ///       else // state in stack: merge SCC
  ///           all = {}
  ///           do
  ///               <n, a> = SCC.pop()
  ///               all = all union a union { ACC.pop() }
  ///           until n <= H[q]
  ///           SCC.push(<n, all>)
  ///           if all != F
  ///               return 0
  ///           return new emptiness_check_result(necessary data)
  /// \endverbatim
  ///
  /// check() returns 0 iff the automaton's language is empty.  It
  /// returns an instance of emptiness_check_result.  If the automaton
  /// accept a word.  (Use emptiness_check_result::accepting_run() to
  /// extract an accepting run.)
98
  ///
99
100
  /// There are two variants of this algorithm: spot::couvreur99_check and
  /// spot::couvreur99_check_shy.  They differ in their memory usage, the
101
102
103
  /// number for successors computed before they are used and the way
  /// the depth first search is directed.
  ///
104
  /// spot::couvreur99_check performs a straightforward depth first search.
105
106
107
  /// The DFS stacks store tgba_succ_iterators, so that only the
  /// iterators which really are explored are computed.
  ///
108
  /// spot::couvreur99_check_shy tries to explore successors which are
109
110
111
112
113
114
  /// visited states first.  this helps to merge SCCs and generally
  /// helps to produce shorter counter-examples.  However this
  /// algorithm cannot stores unprocessed successors as
  /// tgba_succ_iterators: it must compute all successors of a state
  /// at once in order to decide which to explore first, and must keep
  /// a list of all unexplored successors in its DFS stack.
115
116
117
118
119
120
121
122
123
  ///
  /// The \c poprem parameter specifies how the algorithm should
  /// handle the destruction of non-accepting maximal strongly
  /// connected components.  If \c poprem is true, the algorithm will
  /// keep a list of all states of a SCC that are fully processed and
  /// should be removed once the MSCC is popped.  If \c poprem is
  /// false, the MSCC will be traversed again (i.e. generating the
  /// successors of the root recursively) for deletion.  This is
  /// a choice between memory and speed.
124
  class couvreur99_check: public emptiness_check, public ec_statistics
125
126
  {
  public:
127
    couvreur99_check(const tgba* a,
128
		     bool poprem = true,
129
130
131
		     const numbered_state_heap_factory* nshf
		     = numbered_state_heap_hash_map_factory::instance());
    virtual ~couvreur99_check();
132
133

    /// Check whether the automaton's language is empty.
134
    virtual emptiness_check_result* check();
135

136
137
    virtual std::ostream& print_stats(std::ostream& os) const;

138
139
140
141
142
143
144
    /// \brief Return the status of the emptiness-check.
    ///
    /// When check() succeed, the status should be passed along
    /// to spot::counter_example.
    ///
    /// This status should not be deleted, it is a pointer
    /// to a member of this class that will be deleted when
145
146
    /// the couvreur99 object is deleted.
    const couvreur99_check_status* result() const;
147
148

  protected:
149
    couvreur99_check_status* ecs_;
150
151
152
153
154
155
    /// \brief Remove a strongly component from the hash.
    ///
    /// This function remove all accessible state from a given
    /// state. In other words, it removes the strongly connected
    /// component that contains this state.
    void remove_component(const state* start_delete);
156
157
158

    /// Whether to store the state to be removed.
    bool poprem_;
159
160
  };

161
  /// \brief A version of spot::couvreur99_check that tries to visit
162
  /// known states first.
163
  ///
164
165
166
167
168
  /// If \a group is true (the default), the successors of all the
  /// states that belong to the same SCC will be considered when
  /// choosing a successor.  Otherwise, only the successor of the
  /// topmost state on the DFS stack are considered.
  ///
169
170
  /// See the documentation for spot::couvreur99_check
  class couvreur99_check_shy : public couvreur99_check
171
172
  {
  public:
173
    couvreur99_check_shy(const tgba* a,
174
			 bool poprem = true,
175
			 bool group = true,
176
177
178
			 const numbered_state_heap_factory* nshf
			 = numbered_state_heap_hash_map_factory::instance());
    virtual ~couvreur99_check_shy();
179

180
    virtual emptiness_check_result* check();
181
182
183
184
185
186
187
188
189

  protected:
    struct successor {
      bdd acc;
      const spot::state* s;
      successor(bdd acc, const spot::state* s): acc(acc), s(s) {}
    };

    // We use five main data in this algorithm:
190
191
    // * couvreur99_check::root, a stack of strongly connected components (SCC),
    // * couvreur99_check::h, a hash of all visited nodes, with their order,
192
193
194
195
196
197
198
199
200
201
    //   (it is called "Hash" in Couvreur's paper)
    // * arc, a stack of acceptance conditions between each of these SCC,
    std::stack<bdd> arc;
    // * num, the number of visited nodes.  Used to set the order of each
    //   visited node,
    int num;
    // * todo, the depth-first search stack.  This holds pairs of the
    //   form (STATE, SUCCESSORS) where SUCCESSORS is a list of
    //   (ACCEPTANCE_CONDITIONS, STATE) pairs.
    typedef std::list<successor> succ_queue;
202
203
204
205
206
207
208
209
210
211
212
213
214

    struct todo_item
    {
      const state* s;
      int n;
      succ_queue q;
      todo_item(const state* s, int n)
	: s(s), n(n)
      {
      }
    };

    typedef std::list<todo_item> todo_list;
215
216
    todo_list todo;

217
218
    void clear_todo();

219
220
221
    // Whether successors should be grouped for states in the same
    // SCC.
    bool group_;
222

223
224
225
226
227
228
229
230
    /// \brief find the SCC number of a unprocessed state.
    ///
    /// Sometimes we want to modify some of the above structures when
    /// looking up a new state.  This happens for instance when find()
    /// must perform inclusion checking and add new states to process
    /// to TODO during this step.  (Because TODO must be known,
    /// sub-classing spot::numbered_state_heap is not enough.)  Then
    /// overriding this method is the way to go.
231
    virtual int* find_state(const state* s);
232
233
  };

234
  /// @}
235
236
237
}

#endif // SPOT_TGBAALGOS_GTEC_GTEC_HH