Main Page | Modules | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members

Emptiness-check algorithms
[Emptiness-checks]


Classes

class  spot::couvreur99_check
 Check whether the language of an automate is empty. More...
class  spot::couvreur99_check_shy
 A version of spot::couvreur99_check that tries to visit known states first. More...

Functions

emptiness_check * spot::explicit_gv04_check (const tgba *a)
 Emptiness check based on Geldenhuys and Valmari's TACAS'04 paper.
emptiness_check * spot::explicit_magic_search (const tgba *a)
 Returns an emptiness checker on the spot::tgba automaton a.
emptiness_check * spot::bit_state_hashing_magic_search (const tgba *a, size_t size)
 Returns an emptiness checker on the spot::tgba automaton a.
emptiness_check * spot::explicit_se05_search (const tgba *a)
 Returns an emptiness check on the spot::tgba automaton a.
emptiness_check * spot::bit_state_hashing_se05_search (const tgba *a, size_t size)
 Returns an emptiness checker on the spot::tgba automaton a.
emptiness_check * spot::explicit_tau03_search (const tgba *a)
 Returns an emptiness checker on the spot::tgba automaton a.
emptiness_check * spot::explicit_tau03_opt_search (const tgba *a)
 Returns an emptiness checker on the spot::tgba automaton a.

Function Documentation

emptiness_check* bit_state_hashing_magic_search const tgba *  a,
size_t  size
 

Returns an emptiness checker on the spot::tgba automaton a.

Precondition:
The automaton a must have at most one accepting condition (i.e. it is a TBA).
During the visit of a, the returned checker does not store explicitely the traversed states but uses the bit-state hashing technic presented in:

      @book{Holzmann91,
         author = {G.J. Holzmann},
         title = {Design and Validation of Computer Protocols},
         publisher = {Prentice-Hall},
         address = {Englewood Cliffs, New Jersey},
         year = {1991}
      }
      

Consequently, the detection of an acceptence cycle is not ensured. The implemented algorithm is the same as the one of spot::explicit_magic_search.

See also:
spot::explicit_magic_search

emptiness_check* bit_state_hashing_se05_search const tgba *  a,
size_t  size
 

Returns an emptiness checker on the spot::tgba automaton a.

Precondition:
The automaton a must have at most one accepting condition (i.e. it is a TBA).
During the visit of a, the returned checker does not store explicitely the traversed states but uses the bit-state hashing technic presented in:

      @book{Holzmann91,
         author = {G.J. Holzmann},
         title = {Design and Validation of Computer Protocols},
         publisher = {Prentice-Hall},
         address = {Englewood Cliffs, New Jersey},
         year = {1991}
      }
      

Consequently, the detection of an acceptence cycle is not ensured. The implemented algorithm is the same as the one of spot::explicit_se05_search.

See also:
spot::explicit_se05_search

emptiness_check* explicit_gv04_check const tgba *  a  ) 
 

Emptiness check based on Geldenhuys and Valmari's TACAS'04 paper.

Precondition:
The automaton a must have at most one accepting condition.
The original algorithm, coming from the following paper, has only been slightly modified to work on transition-based automata.
      @InProceedings{geldenhuys.04.tacas,
        author  = {Jaco Geldenhuys and Antti Valmari},
        title   = {Tarjan's Algorithm Makes On-the-Fly {LTL} Verification
                  More Efficient},
        booktitle = {Proceedings of the 10th International Conference on Tools
                  and Algorithms for the Construction and Analysis of Systems
                  (TACAS'04)},
        editor  = {Kurt Jensen and Andreas Podelski},
        pages   = {205--219},
        year    = {2004},
        publisher = {Springer-Verlag},
        series  = {Lecture Notes in Computer Science},
        volume  = {2988},
        isbn    = {3-540-21299-X}
      }
      

emptiness_check* explicit_magic_search const tgba *  a  ) 
 

Returns an emptiness checker on the spot::tgba automaton a.

Precondition:
The automaton a must have at most one accepting condition (i.e. it is a TBA).
During the visit of a, the returned checker stores explicitely all the traversed states. The method check() of the checker can be called several times (until it returns a null pointer) to enumerate all the visited accepting paths. The implemented algorithm is the following:

      procedure check ()
      begin
        call dfs_blue(s0);
      end;
     
      procedure dfs_blue (s)
      begin
        s.color = blue;
        for all t in post(s) do
          if t.color == white then
            call dfs_blue(t);
          end if;
          if (the edge (s,t) is accepting) then
            target = s;
            call dfs_red(t);
          end if;
        end for;
      end;
     
      procedure dfs_red(s)
      begin
        s.color = red;
        if s == target then
          report cycle
        end if;
        for all t in post(s) do
          if t.color == blue then
            call dfs_red(t);
          end if;
        end for;
      end;
      

This algorithm is an adaptation to TBA of the one (which deals with accepting states) presented in

       Article{         courcoubertis.92.fmsd,
         author        = {Costas Courcoubetis and Moshe Y. Vardi and Pierre
                         Wolper and Mihalis Yannakakis},
         title         = {Memory-Efficient Algorithm for the Verification of
                         Temporal Properties},
         journal       = {Formal Methods in System Design},
         pages         = {275--288},
         year          = {1992},
         volume        = {1}
       }
      

emptiness_check* explicit_se05_search const tgba *  a  ) 
 

Returns an emptiness check on the spot::tgba automaton a.

Precondition:
The automaton a must have at most one accepting condition (i.e. it is a TBA).
During the visit of a, the returned checker stores explicitely all the traversed states. The method check() of the checker can be called several times (until it returns a null pointer) to enumerate all the visited accepting paths. The implemented algorithm is an optimization of spot::explicit_magic_search and is the following:

      procedure check ()
      begin
        call dfs_blue(s0);
      end;
     
      procedure dfs_blue (s)
      begin
        s.color = cyan;
        for all t in post(s) do
          if t.color == white then
            call dfs_blue(t);
          else if t.color == cyan and
                  (the edge (s,t) is accepting or
                   (it exists a predecessor p of s in st_blue and s != t and
                   the arc between p and s is accepting)) then
            report cycle;
          end if;
          if the edge (s,t) is accepting then
            call dfs_red(t);
          end if;
        end for;
        s.color = blue;
      end;
     
      procedure dfs_red(s)
      begin
        if s.color == cyan then
          report cycle;
        end if;
        s.color = red;
        for all t in post(s) do
          if t.color == blue then
            call dfs_red(t);
          end if;
        end for;
      end;
      

It is an adaptation to TBA of the one presented in

       @techreport{SE04,
         author = {Stefan Schwoon and Javier Esparza},
         institution = {Universit{\"a}t Stuttgart, Fakult\"at Informatik,
         Elektrotechnik und Informationstechnik},
         month = {November},
         number = {2004/06},
         title = {A Note on On-The-Fly Verification Algorithms},
         year = {2004},
         url =
     {http://www.fmi.uni-stuttgart.de/szs/publications/info/schwoosn.SE04.shtml}
       }
      

See also:
spot::explicit_magic_search

emptiness_check* explicit_tau03_opt_search const tgba *  a  ) 
 

Returns an emptiness checker on the spot::tgba automaton a.

Precondition:
The automaton a must have at least one accepting condition.
During the visit of a, the returned checker stores explicitely all the traversed states. The implemented algorithm is the following:

      procedure check ()
      begin
        weight = 0; // the null vector
        call dfs_blue(s0);
      end;
     
      procedure dfs_blue (s)
      begin
        s.color = cyan;
        s.acc = emptyset;
        s.weight = weight;
        for all t in post(s) do
          let (s, l, a, t) be the edge from s to t;
          if t.color == white then
            for all b in a do
              weight[b] = weight[b] + 1;
            end for;
            call dfs_blue(t);
            for all b in a do
              weight[b] = weight[b] - 1;
            end for;
          end if;
          Acc = s.acc U a;
          if t.color == cyan &&
                    (Acc U support(weight - t.weight) U t.acc) == all_acc then
            report a cycle;
          else if Acc not included in t.acc then
            t.acc := t.acc U Acc;
            call dfs_red(t, Acc);
          end if;
        end for;
        s.color = blue;
      end;
     
      procedure dfs_red(s, Acc)
      begin
        for all t in post(s) do
          let (s, l, a, t) be the edge from s to t;
          if t.color == cyan &&
                      (Acc U support(weight - t.weight) U t.acc) == all_acc then
            report a cycle;
          else if t.color != white and Acc not included in t.acc then
            t.acc := t.acc U Acc;
            call dfs_red(t, Acc);
          end if;
        end for;
      end;
      

This algorithm is a generalisation to TGBA of the one implemented in spot::explicit_se05_search. It is based on the acceptance set labelling of states used in spot::explicit_tau03_search. Moreover, it introduce a slight optimisation based on vectors of integers counting for each acceptance condition how many time the condition has been visited in the path stored in the blue stack. Such a vector is associated to each state of this stack.

emptiness_check* explicit_tau03_search const tgba *  a  ) 
 

Returns an emptiness checker on the spot::tgba automaton a.

Precondition:
The automaton a must have at least one accepting condition.
During the visit of a, the returned checker stores explicitely all the traversed states. The implemented algorithm is the following:

      procedure check ()
      begin
        call dfs_blue(s0);
      end;
     
      procedure dfs_blue (s)
      begin
        s.color = blue;
        s.acc = emptyset;
        for all t in post(s) do
          if t.color == white then
            call dfs_blue(t);
          end if;
        end for;
        for all t in post(s) do
          let (s, l, a, t) be the edge from s to t;
          if s.acc U a not included in t.acc then
            call dfs_red(t, a U s.acc);
          end if;
        end for;
        if s.acc == all_acc then
          report a cycle;
        end if;
      end;
     
      procedure dfs_red(s, A)
      begin
        s.acc = s.acc U A;
        for all t in post(s) do
          if t.color != white and A not included in t.acc then
            call dfs_red(t, A);
          end if;
        end for;
      end;
      

This algorithm is the one presented in

      @techreport{HUT-TCS-A83,
         address = {Espoo, Finland},
         author = {Heikki Tauriainen},
         institution = {Helsinki University of Technology, Laboratory for
         Theoretical Computer Science},
         month = {December},
         number = {A83},
         pages = {132},
         title = {On Translating Linear Temporal Logic into Alternating and
         Nondeterministic Automata},
         type = {Research Report},
         year = {2003},
         url = {http://www.tcs.hut.fi/Publications/info/bibdb.HUT-TCS-A83.shtml}
      }
      


Please comment this page and report errors about it on the RefDocComments page.
Generated on Mon Jan 31 12:55:19 2005 for spot by doxygen 1.4.0