Commit 496083b1 authored by Alexandre Lewkowicz's avatar Alexandre Lewkowicz Committed by Alexandre Duret-Lutz
Browse files

safra: implement powerset construction

* spot/twaalgos/Makefile.am: Update it.
* src/twaalgos/safra.cc, src/twaalgos/safra.hh: New.
parent 064ccd5c
......@@ -66,6 +66,7 @@ twaalgos_HEADERS = \
remfin.hh \
remprop.hh \
strength.hh \
safra.hh \
sbacc.hh \
sccfilter.hh \
sccinfo.hh \
......@@ -121,6 +122,7 @@ libtwaalgos_la_SOURCES = \
remprop.cc \
relabel.cc \
strength.cc \
safra.cc \
sbacc.cc \
sccinfo.cc \
sccfilter.cc \
......
// -*- coding: utf-8 -*-
// Copyright (C) 2015 Laboratoire de Recherche et
// Développement de l'Epita.
//
// 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 3 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 this program. If not, see <http://www.gnu.org/licenses/>.
#include <deque>
#include "safra.hh"
namespace spot
{
auto
safra_state::compute_succs(const const_twa_graph_ptr& aut) const -> succs_t
{
succs_t res;
// Given a bdd returns index of associated safra_state in res
std::map<bdd, unsigned, bdd_less_than> bdd2num;
for (auto& node: nodes_)
{
for (auto& t: aut->out(node.id_))
{
auto i = bdd2num.insert(std::make_pair(t.cond, res.size()));
unsigned idx;
if (!i.second)
idx = i.first->second;
else
{
// Each new node starts out with same number of nodes as src
safra_state empty_state = safra_state(nb_braces_.size());
idx = res.size();
res.push_back(std::make_pair(empty_state, t.cond));
std::cerr << "Created inner node: " << idx << std::endl;
}
safra_state& ss = res[idx].first;
ss.update_succ(node, t.dst, t.acc);
}
}
for (auto& s: res)
{
safra_state& tmp = s.first;
tmp.finalize_construction();
}
return res;
}
void safra_state::finalize_construction()
{
// TODO this is a dirty hack to have two comparision functions depending on
// wether or not we are still construction the safra_stata
// Ideally I'd like to have this done statically but not sure how to do it
for (unsigned i = 0; i < nb_braces_.size(); ++i)
{
if (nb_braces_[i] == 0)
{
// TODO We also emit Red = min(red, i)
is_green_[i] = false;
}
}
for (auto& n: nodes_)
{
node& nn = const_cast<node&>(n);
nn.disable_construction();
}
}
void safra_state::update_succ(const node& src, unsigned dst,
const acc_cond::mark_t acc)
{
(void) acc; // TODO
auto i = nodes_.find(node(dst));
if (i != nodes_.end())
{
// Todo need to handle acc and create new braces
if (src.braces_ > i->braces_)
{
std::cerr << "Replacing braces of: " << dst << std::endl;
node& dst = const_cast<node&>(*i);
for (auto b: dst.braces_)
nb_braces_[b]--;
dst.braces_ = src.braces_;
}
// Node already exists and has bigger values
else
return;
}
else
{
// Todo need to handle acc and create new braces
nodes_.emplace(dst, src.braces_);
}
for (auto b: src.braces_)
nb_braces_[b]++;
// If brace has no right-hand-side brace than it cannot emit any green color
is_green_[src.braces_[src.braces_.size() - 1]] = false;
}
// Comparison is needed when for a set of safra_state
bool
safra_state::operator<(const safra_state& other) const
{
return nodes_ < other.nodes_;
}
// Called only to initialize first state
safra_state::safra_state(unsigned val, bool init_state)
{
if (init_state)
{
unsigned state_num = val;
// One brace set
is_green_.push_back(true);
// First brace has init_state hence one state inside the first braces.
nb_braces_.push_back(1);
nodes_.emplace(state_num, 0);
}
else
{
unsigned nb_braces = val;
// One brace set
is_green_.assign(true, nb_braces);
// First brace has init_state hence one state inside the first braces.
nb_braces_.assign(nb_braces, 0);
}
}
bool
safra_state::node::operator<(const node& other) const
{
if (id_ == other.id_)
return in_construction_ ? false : braces_ < other.braces_;
else
return id_ < other.id_;
}
bool
safra_state::node::operator==(const node& other) const
{
if (id_ == other.id_)
return in_construction_ ? true : braces_ == other.braces_;
else
return false;
}
twa_graph_ptr
tgba_determinisation(const const_twa_graph_ptr& aut)
{
auto res = make_twa_graph(aut->get_dict());
res->copy_ap_of(aut);
res->prop_copy(aut,
{ true, // state based
true, // inherently_weak
true, // deterministic
false // stutter inv
});
// Given a safra_state get its associated state in output automata.
// Required to create new transitions from 2 safra-state
typedef std::map<safra_state, int> power_set;
power_set seen;
safra_state init(aut->get_init_state_number(), true);
unsigned num = res->new_state();
res->set_init_state(num);
seen.insert(std::make_pair(init, num));
std::deque<safra_state> todo;
todo.push_back(init);
while (!todo.empty())
{
using succs_t = safra_state::succs_t;
safra_state curr = todo.front();
unsigned src_num = seen.find(curr)->second;
todo.pop_front();
succs_t succs = curr.compute_succs(aut);
for (auto s: succs)
{
auto i = seen.find(s.first);
unsigned dst_num;
if (i != seen.end())
{
dst_num = i->second;
}
else
{
dst_num = res->new_state();
std::cerr << "New state " << dst_num << std::endl;
todo.push_back(s.first);
seen.insert(std::make_pair(s.first, dst_num));
}
std::cerr << "Tr: " << src_num << " -> " << dst_num << "["
<< s.second << "]" << std::endl;
res->new_transition(src_num, dst_num, s.second);
}
}
return res;
}
}
// -*- coding: utf-8 -*-
// Copyright (C) 2015 Laboratoire de Recherche et Développement
// de l'Epita.
//
// 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 3 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 this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include <set>
#include "misc/bddlt.hh"
#include "twa/twagraph.hh"
namespace spot
{
class safra_state
{
class node
{
public:
using brace_t = size_t;
bool operator==(const node& other) const;
bool operator<(const node& other) const;
void disable_construction() { in_construction_ = false; }
node(unsigned id)
: id_(id), in_construction_(true) {}
node(unsigned id, brace_t b_id, bool in_construction = true)
: id_(id), braces_(1, b_id), in_construction_(in_construction) {}
node(unsigned id, std::vector<brace_t> b, bool in_construction = true)
: id_(id), braces_(b), in_construction_(in_construction) {}
// The name used to identify a state
unsigned id_;
// The list of braces the state is nested in.
std::vector<brace_t> braces_;
// Hack to have two comparision functions during construction and after
// construction
// During construction only the nodes id matterns as the braces are under
// construction. After construction (id, braces) is what distinguishes a
// node.
bool in_construction_;
};
public:
typedef std::vector<std::pair<safra_state, bdd>> succs_t;
bool operator<(const safra_state& other) const;
safra_state(unsigned state_number, bool init_state = false);
// Given a certain transition_label, compute all the successors of that
// label, and return that new node.
succs_t compute_succs(const const_twa_graph_ptr& aut) const;
// Used when creating the list of successors
void update_succ(const node& src, unsigned dst, const acc_cond::mark_t);
void finalize_construction();
// A list of nodes similar to the ones of a
// safra tree. These are constructed in the same way as the powerset
// algorithm.
std::set<node> nodes_;
// A counter that indicates the nomber of states within a brace.
// This enables us to compute the red value
std::vector<size_t> nb_braces_;
// A bitfield to know if a brace can emit green.
std::vector<bool> is_green_;
};
SPOT_API twa_graph_ptr
tgba_determinisation(const const_twa_graph_ptr& aut);
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment