New Automata: TGTA (Transition-based Generalized TA)

* src/ta/Makefile.am, src/ta/taexplicit.cc, src/ta/taexplicit.hh,
src/ta/taproduct.cc, src/ta/tgbta.cc, src/ta/tgbta.hh,
src/ta/tgbtaexplicit.cc, src/ta/tgbtaexplicit.hh,
src/ta/tgbtaproduct.cc, src/ta/tgbtaproduct.hh,
src/taalgos/emptinessta.cc, src/taalgos/emptinessta.hh,
src/taalgos/sba2ta.cc, src/taalgos/tgba2ta.cc, src/taalgos/tgba2ta.hh,
src/tgbatest/ltl2tgba.cc: Implementation of TGTA, a new kind of automata
combining ideas from TGBA and TA.

src/ta/Makefile.am

@@ -25,11 +25,18 @@ tadir = $(pkgincludedir)/ta
 
 ta_HEADERS = \
   ta.hh \
+  taexplicit.hh \
   taproduct.hh \
-  taexplicit.hh
+  tgbta.hh \
+  tgbtaexplicit.hh \
+  tgbtaproduct.hh
+  
   
 noinst_LTLIBRARIES = libta.la
 libta_la_SOURCES = \
   ta.cc \
   taproduct.cc \
-  taexplicit.cc
+  tgbta.cc \
+  tgbtaexplicit.cc \
+  taexplicit.cc \
+  tgbtaproduct.cc

src/ta/taexplicit.cc

@@ -18,6 +18,15 @@
 // Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 // 02111-1307, USA.
 
+//#define TRACE
+
+#include <iostream>
+#ifdef TRACE
+#define trace std::clog
+#else
+#define trace while (0) std::clog
+#endif
+
 #include "ltlast/atomic_prop.hh"
 #include "ltlast/constant.hh"
 #include "taexplicit.hh"
@@ -71,7 +80,9 @@ namespace spot
   state*
   ta_explicit_succ_iterator::current_state() const
   {
+    trace << "***ta_explicit_succ_iterator::current_state()  if(done()) =***" << done() << std::endl;
     assert(!done());
+    trace << "***ta_explicit_succ_iterator::current_state() (*i_)->condition =***" << (*i_)->condition << std::endl;
     state_ta_explicit* s = (*i_)->dest;
     return s;
   }
@@ -125,7 +136,8 @@ namespace spot
   }
 
   void
-  state_ta_explicit::add_transition(state_ta_explicit::transition* t)
+  state_ta_explicit::add_transition(state_ta_explicit::transition* t,
+      bool add_at_beginning)
   {
     if (transitions_ == 0)
       transitions_ = new transitions;
@@ -153,8 +165,17 @@ namespace spot
 
     if (!transition_found)
       {
-        transitions_condition->push_back(t);
-        transitions_->push_back(t);
+        if (add_at_beginning)
+          {
+            transitions_condition->push_front(t);
+            transitions_->push_front(t);
+          }
+        else
+          {
+            transitions_condition->push_back(t);
+            transitions_->push_back(t);
+          }
+
       }
     else
       {
@@ -245,7 +266,7 @@ namespace spot
   size_t
   state_ta_explicit::hash() const
   {
-    return wang32_hash(tgba_state_->hash()) ^ wang32_hash(tgba_condition_.id());
+    return wang32_hash(tgba_state_->hash());
   }
 
   state_ta_explicit*
@@ -353,7 +374,6 @@ namespace spot
     delete tgba_;
   }
 
-
   state_ta_explicit*
   ta_explicit::add_state(state_ta_explicit* s)
   {
@@ -377,7 +397,7 @@ namespace spot
     if (get_artificial_initial_state() != 0)
       if (add_state.second)
         create_transition((state_ta_explicit*) get_artificial_initial_state(),
-            condition, s);
+            condition, bddfalse, s);
 
   }
 
@@ -392,27 +412,16 @@ namespace spot
 
   }
 
-  void
-  ta_explicit::create_transition(state_ta_explicit* source, bdd condition,
-      state_ta_explicit* dest)
-  {
-    state_ta_explicit::transition* t = new state_ta_explicit::transition;
-    t->dest = dest;
-    t->condition = condition;
-    t->acceptance_conditions = bddfalse;
-    source->add_transition(t);
-
-  }
 
   void
   ta_explicit::create_transition(state_ta_explicit* source, bdd condition,
-      bdd acceptance_conditions, state_ta_explicit* dest)
+      bdd acceptance_conditions, state_ta_explicit* dest, bool add_at_beginning)
   {
     state_ta_explicit::transition* t = new state_ta_explicit::transition;
     t->dest = dest;
     t->condition = condition;
     t->acceptance_conditions = acceptance_conditions;
-    source->add_transition(t);
+    source->add_transition(t, add_at_beginning);
 
   }
 

src/ta/taexplicit.hh

@@ -53,13 +53,11 @@ namespace spot
     void
     add_to_initial_states_set(state* s, bdd condition = bddfalse);
 
-    void
-    create_transition(state_ta_explicit* source, bdd condition,
-        state_ta_explicit* dest);
 
     void
     create_transition(state_ta_explicit* source, bdd condition,
-        bdd acceptance_conditions, state_ta_explicit* dest);
+        bdd acceptance_conditions, state_ta_explicit* dest,
+        bool add_at_beginning = false);
 
     void
     delete_stuttering_transitions();
@@ -132,7 +130,6 @@ namespace spot
       return all_acceptance_conditions_;;
     }
 
-
   private:
     // Disallow copy.
     ta_explicit(const ta_explicit& other);
@@ -179,6 +176,11 @@ namespace spot
     virtual state_ta_explicit*
     clone() const;
 
+    virtual
+    void destroy() const
+    {
+    }
+
     virtual
     ~state_ta_explicit()
     {
@@ -192,7 +194,7 @@ namespace spot
     get_transitions(bdd condition) const;
 
     void
-    add_transition(transition* t);
+    add_transition(transition* t, bool add_at_beginning = false);
 
     const state*
     get_tgba_state() const;
@@ -221,8 +223,6 @@ namespace spot
     void
     free_transitions();
 
-
-
   private:
     const state* tgba_state_;
     const bdd tgba_condition_;

src/ta/taproduct.cc

-// Copyright (C) 2010 Laboratoire de Recherche et Developpement
+// Copyright (C) 2011 Laboratoire de Recherche et Developpement
 // de l Epita (LRDE).
 //
 //

src/ta/tgbta.cc

+// Copyright (C) 2012 Laboratoire de Recherche et Developpement
+// de l Epita_explicit (LRDE).
+//
+// 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 MERCHANta_explicitBILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+// License for more deta_explicitils.
+//
+// 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.
+
+#include "tgbta.hh"
+
+
+namespace spot
+{
+
+     tgbta::tgbta()
+     {};
+     tgbta::~tgbta()
+     {};
+
+
+}
+
+

src/ta/tgbta.hh

+// Copyright (C) 2010, 2011 Laboratoire de Recherche et Developpement
+// de l Epita_explicit (LRDE).
+//
+// 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 MERCHANta_explicitBILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+// License for more deta_explicitils.
+//
+// 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_TA_TGBTA_HH
+# define SPOT_TA_TGBTA_HH
+
+#include "tgba/tgba.hh"
+
+namespace spot
+{
+  class tgbta : public tgba
+  {
+
+  protected:
+    tgbta();
+  public:
+
+    virtual
+    ~tgbta();
+    virtual tgba_succ_iterator*
+    succ_iter_by_changeset(const spot::state* s, bdd change_set) const =0;
+
+  };
+
+}
+
+#endif // SPOT_TA_TGBTA_HH

src/ta/tgbtaexplicit.cc

+// Copyright (C) 2010, 2011 Laboratoire de Recherche et Developpement
+// de l Epita (LRDE).
+//
+// 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.
+
+#include "ltlast/atomic_prop.hh"
+#include "ltlast/constant.hh"
+#include "tgbtaexplicit.hh"
+#include "tgba/formula2bdd.hh"
+#include "misc/bddop.hh"
+#include "ltlvisit/tostring.hh"
+
+#include "tgba/bddprint.hh"
+
+namespace spot
+{
+
+
+  tgbta_explicit::tgbta_explicit(const tgba* tgba, bdd all_acceptance_conditions,
+        state_ta_explicit* artificial_initial_state) :
+      ta_explicit(tgba, all_acceptance_conditions, artificial_initial_state)
+    {
+    }
+
+
+  state*
+   tgbta_explicit::get_init_state() const
+   {
+       return ta_explicit::get_artificial_initial_state();
+   }
+
+   tgba_succ_iterator*
+   tgbta_explicit::succ_iter(const spot::state* state,
+                            const spot::state* global_state,
+                            const tgba* global_automaton) const
+   {
+     return ta_explicit::succ_iter(state);
+   }
+
+   bdd
+   tgbta_explicit::compute_support_conditions(const spot::state* in) const
+   {
+     return get_tgba()->support_conditions(((state_ta_explicit*) in)->get_tgba_state());
+   }
+
+   bdd
+   tgbta_explicit::compute_support_variables(const spot::state* in) const
+   {
+     return get_tgba()->support_variables(((state_ta_explicit*) in)->get_tgba_state());
+   }
+
+   bdd_dict*
+   tgbta_explicit::get_dict() const
+   {
+     return ta_explicit::get_dict();
+   }
+
+   bdd
+   tgbta_explicit::all_acceptance_conditions() const
+   {
+
+     return ta_explicit::all_acceptance_conditions();
+   }
+
+   bdd
+   tgbta_explicit::neg_acceptance_conditions() const
+   {
+     return get_tgba()->neg_acceptance_conditions();
+   }
+
+   std::string
+   tgbta_explicit::format_state(const spot::state* s) const
+   {
+     return ta_explicit::format_state(s);
+   }
+
+
+   spot::tgba_succ_iterator* tgbta_explicit::succ_iter_by_changeset(const spot::state* s, bdd change_set) const
+   {
+     return ta_explicit::succ_iter(s,change_set);
+   }
+
+}

src/ta/tgbtaexplicit.hh

+// Copyright (C) 2010, 2011 Laboratoire de Recherche et Developpement
+// de l Epita_explicit (LRDE).
+//
+// 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 MERCHANta_explicitBILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+// License for more deta_explicitils.
+//
+// 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_TA_TGBTAEXPLICIT_HH
+# define SPOT_TA_TGBTAEXPLICIT_HH
+
+#include "misc/hash.hh"
+#include <list>
+#include "tgba/tgba.hh"
+#include <set>
+#include "ltlast/formula.hh"
+#include <cassert>
+#include "misc/bddlt.hh"
+#include "taexplicit.hh"
+#include "tgbta.hh"
+
+namespace spot
+{
+   class tgbta_explicit : public tgbta, public ta_explicit
+  {
+  public:
+     tgbta_explicit(const tgba* tgba, bdd all_acceptance_conditions,
+             state_ta_explicit* artificial_initial_state) ;
+
+     // tgba interface
+        virtual spot::state* get_init_state() const;
+        virtual tgba_succ_iterator*
+        succ_iter(const spot::state* local_state,
+                  const spot::state* global_state = 0,
+                  const tgba* global_automaton = 0) const;
+        virtual bdd_dict* get_dict() const;
+
+        virtual bdd all_acceptance_conditions() const;
+        virtual bdd neg_acceptance_conditions() const;
+
+        virtual std::string format_state(const spot::state* s) const;
+
+        virtual tgba_succ_iterator* succ_iter_by_changeset(const spot::state* s, bdd change_set) const;
+      protected:
+        virtual bdd compute_support_conditions(const spot::state* state) const;
+        virtual bdd compute_support_variables(const spot::state* state) const;
+
+  };
+
+
+
+}
+
+#endif // SPOT_TA_TGBTAEXPLICIT_HH

src/ta/tgbtaproduct.cc

+// Copyright (C) 2012 Laboratoire de Recherche et Developpement
+// de l Epita (LRDE).
+//
+// 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.
+
+
+//#define TRACE
+
+#include <iostream>
+#ifdef TRACE
+#define trace std::clog
+#else
+#define trace while (0) std::clog
+#endif
+
+#include "tgbtaproduct.hh"
+#include <string>
+#include <cassert>
+#include "misc/hashfunc.hh"
+#include "kripke/kripke.hh"
+
+namespace spot
+{
+
+  ////////////////////////////////////////////////////////////
+  // tgbta_succ_iterator_product
+
+
+  ////////////////////////////////////////////////////////////
+  // tgbta_product
+
+  tgbta_product::tgbta_product(const kripke* left, const tgbta* right) :
+    tgba_product(left, right)
+  {
+  }
+
+  state*
+  tgbta_product::get_init_state() const
+  {
+    fixed_size_pool* p = const_cast<fixed_size_pool*> (&pool_);
+    return new (p->allocate()) state_product(left_->get_init_state(),
+        right_->get_init_state(), p);
+  }
+
+  tgba_succ_iterator*
+  tgbta_product::succ_iter(const state* local_state, const state* global_state,
+      const tgba* global_automaton) const
+  {
+    const state_product* s = down_cast<const state_product*> (local_state);
+    assert(s);
+
+    fixed_size_pool* p = const_cast<fixed_size_pool*> (&pool_);
+
+    return new tgbta_succ_iterator_product(s, (kripke*) left_,
+        (tgbta *) right_, p);
+  }
+
+  ////////////////////////////////////////////////////////////
+  // tgbtgbta_succ_iterator_product
+  tgbta_succ_iterator_product::tgbta_succ_iterator_product(
+      const state_product* s, const kripke* k, const tgbta* t,
+      fixed_size_pool* pool) :
+    source_(s), tgbta_(t), kripke_(k), pool_(pool)
+  {
+
+    state * tgbta_init_state = tgbta_->get_init_state();
+    if ((s->right())->compare(tgbta_init_state) == 0)
+      source_ = 0;
+
+    if (source_ == 0)
+      {
+        kripke_succ_it_ = 0;
+        kripke_current_dest_state = kripke_->get_init_state();
+        current_condition_
+            = kripke_->state_condition(kripke_current_dest_state);
+        tgbta_succ_it_ = tgbta_->succ_iter_by_changeset(
+            tgbta_init_state, current_condition_);
+        tgbta_succ_it_->first();
+        trace
+          << "*** tgbta_succ_it_->done() = ***" << tgbta_succ_it_->done()
+              << std::endl;
+
+      }
+    else
+      {
+        kripke_source_condition = kripke_->state_condition(s->left());
+        kripke_succ_it_ = kripke_->succ_iter(s->left());
+        kripke_current_dest_state = 0;
+        tgbta_succ_it_ = 0;
+      }
+
+    tgbta_init_state->destroy();
+    current_state_ = 0;
+  }
+
+  tgbta_succ_iterator_product::~tgbta_succ_iterator_product()
+  {
+    // ta_->free_state(current_state_);
+    if (current_state_ != 0)
+      current_state_->destroy();
+    current_state_ = 0;
+    delete tgbta_succ_it_;
+    delete kripke_succ_it_;
+    if (kripke_current_dest_state != 0)
+      kripke_current_dest_state->destroy();
+  }
+
+  void
+  tgbta_succ_iterator_product::step_()
+  {
+    if (!tgbta_succ_it_->done())
+      tgbta_succ_it_->next();
+    if (tgbta_succ_it_->done())
+      {
+        delete tgbta_succ_it_;
+        tgbta_succ_it_ = 0;
+        next_kripke_dest();
+      }
+  }
+
+  void
+  tgbta_succ_iterator_product::next_kripke_dest()
+  {
+    if (!kripke_succ_it_)
+      return;
+
+    if (kripke_current_dest_state == 0)
+      {
+        kripke_succ_it_->first();
+      }
+    else
+      {
+        kripke_current_dest_state->destroy();
+        kripke_current_dest_state = 0;
+        kripke_succ_it_->next();
+      }
+
+    // If one of the two successor sets is empty initially, we reset
+    // kripke_succ_it_, so that done() can detect this situation easily.  (We
+    // choose to reset kripke_succ_it_ because this variable is already used by
+    // done().)
+    if (kripke_succ_it_->done())
+      {
+        delete kripke_succ_it_;
+        kripke_succ_it_ = 0;
+        return;
+      }
+
+    kripke_current_dest_state = kripke_succ_it_->current_state();
+    bdd kripke_current_dest_condition = kripke_->state_condition(
+        kripke_current_dest_state);
+
+    current_condition_ = bdd_setxor(kripke_source_condition,
+        kripke_current_dest_condition);
+    tgbta_succ_it_ = tgbta_->succ_iter_by_changeset(source_->right(),
+        current_condition_);
+    tgbta_succ_it_->first();
+
+  }
+
+  void
+  tgbta_succ_iterator_product::first()
+  {
+
+    next_kripke_dest();
+    trace
+      << "*** first() .... if(done()) = ***" << done() << std::endl;
+    if (!done())
+      find_next_succ_();
+
+  }
+
+  void
+  tgbta_succ_iterator_product::next()
+  {
+    current_state_->destroy();
+    current_state_ = 0;
+
+    step_();
+
+    trace
+      << "*** next() .... if(done()) = ***" << done() << std::endl;