alarsyo/spot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

New Automata: TGTA (Transition-based Generalized TA)

Browse source 
* 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.
This commit is contained in:
Ala-Eddine Ben-Salem 2011-11-23 12:24:25 +01:00 • committed by Alexandre Duret-Lutz
parent 1f0bf0b1cf
commit c882eadda6
16 changed files with 921 additions and 152 deletions
Download patch file Download diff file Expand all files Collapse all files

11
src/ta/Makefile.am
View file

@ -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

47
src/ta/taexplicit.cc
View file

@ -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);
}

16
src/ta/taexplicit.hh
View file

@ -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_;

2
src/ta/taproduct.cc
View file

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

35
src/ta/tgbta.cc Normal file
View file

@ -0,0 +1,35 @@
// 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()
{};
}

44
src/ta/tgbta.hh Normal file
View file

@ -0,0 +1,44 @@
// 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

98
src/ta/tgbtaexplicit.cc Normal file
View file

@ -0,0 +1,98 @@
// 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);
}
}

66
src/ta/tgbtaexplicit.hh Normal file
View file

@ -0,0 +1,66 @@
// 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

258
src/ta/tgbtaproduct.cc Normal file
View file

@ -0,0 +1,258 @@
// 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;
if (!done())
find_next_succ_();
}
void
tgbta_succ_iterator_product::find_next_succ_()
{
while (!done())
{
if (!tgbta_succ_it_->done())
{
current_state_ = new (pool_->allocate()) state_product(
kripke_current_dest_state->clone(),
tgbta_succ_it_->current_state(), pool_);
current_acceptance_conditions_
= tgbta_succ_it_->current_acceptance_conditions();
return;
}
step_();
}
}
bool
tgbta_succ_iterator_product::done() const
{
if (source_ == 0)
{
return !tgbta_succ_it_ || tgbta_succ_it_->done();
}
else
{
return !kripke_succ_it_ || kripke_succ_it_->done();
}
}
state_product*
tgbta_succ_iterator_product::current_state() const
{
trace
<< "*** current_state() .... if(done()) = ***" << done() << std::endl;
return current_state_->clone();
}
bdd
tgbta_succ_iterator_product::current_condition() const
{
return current_condition_;
}
bdd
tgbta_succ_iterator_product::current_acceptance_conditions() const
{
return current_acceptance_conditions_;
}
}

110
src/ta/tgbtaproduct.hh Normal file
View file

@ -0,0 +1,110 @@
// Copyright (C) 2011 Laboratoire de Recherche et Développement
// de l'Epita (LRDE).
// Copyright (C) 2003, 2004, 2006 Laboratoire d'Informatique de Paris
// 6 (LIP6), 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_TGBTA_TGBAPRODUCT_HH
# define SPOT_TGBTA_TGBAPRODUCT_HH
#include "tgba/tgba.hh"
#include "tgba/tgbaproduct.hh"
#include "misc/fixpool.hh"
#include "kripke/kripke.hh"
#include "tgbta.hh"
namespace spot
{
/// \brief A lazy product. (States are computed on the fly.)
class tgbta_product : public tgba_product
{
public:
tgbta_product(const kripke* left, const tgbta* right);
virtual state*
get_init_state() const;
virtual tgba_succ_iterator*
succ_iter(const state* local_state, const state* global_state = 0,
const tgba* global_automaton = 0) const;
};
/// \brief Iterate over the successors of a product computed on the fly.
class tgbta_succ_iterator_product : public tgba_succ_iterator
{
public:
tgbta_succ_iterator_product(const state_product* s, const kripke* k, const tgbta* tgbta, fixed_size_pool* pool);
virtual
~tgbta_succ_iterator_product();
// iteration
void
first();
void
next();
bool
done() const;
// inspection
state_product*
current_state() const;
bdd
current_condition() const;
bdd
current_acceptance_conditions() const;
private:
//@{
/// Internal routines to advance to the next successor.
void
step_();
void
find_next_succ_();
void
next_kripke_dest();
//@}
protected:
const state_product* source_;
const tgbta* tgbta_;
const kripke* kripke_;
fixed_size_pool* pool_;
tgba_succ_iterator* tgbta_succ_it_;
tgba_succ_iterator* kripke_succ_it_;
state_product* current_state_;
bdd current_condition_;
bdd current_acceptance_conditions_;
bdd kripke_source_condition;
state * kripke_current_dest_state;
};
}
#endif // SPOT_TGBTA_TGBAPRODUCT_HH