add intersection using symbolic automata facility

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>

src/math/automata/automaton.h

@@ -178,15 +178,19 @@ public:
         return alloc(automaton, a.m, a.init(), final, mvs);
     }
 
+    automaton* clone() const {
+        return clone(*this);
+    }
+
     // create the sum of disjoint automata
     static automaton* mk_union(automaton const& a, automaton const& b) {
         SASSERT(&a.m == &b.m);
         M& m = a.m;
         if (a.is_empty()) {
-            return clone(b);
+            return b.clone();
         }
         if (b.is_empty()) {
-            return clone(a);
+            return a.clone();
         }
         moves mvs;
         unsigned_vector final;
@@ -213,7 +217,7 @@ public:
             mvs.push_back(move(m, 0, a.init() + offset));
         }
         if (a.is_empty()) {
-            return clone(a);
+            return a.clone();
         }
 
         mvs.push_back(move(m, init, a.final_state() + offset));
@@ -227,16 +231,16 @@ public:
         SASSERT(&a.m == &b.m);
         M& m = a.m;
         if (a.is_empty()) {
-            return clone(a);
+            return a.clone();
         }
         if (b.is_empty()) {
-            return clone(b);
+            return b.clone();
         }
         if (a.is_epsilon()) {
-            return clone(b);
+            return b.clone();
         }
         if (b.is_epsilon()) {
-            return clone(a);
+            return a.clone();
         }
 
         moves mvs;
@@ -458,6 +462,7 @@ public:
     }
 
     unsigned init() const { return m_init; }
+    unsigned_vector const& final_states() const { return m_final_states; }
     unsigned in_degree(unsigned state) const { return m_delta_inv[state].size(); }
     unsigned out_degree(unsigned state) const { return m_delta[state].size(); }
     move const& get_move_from(unsigned state) const { SASSERT(m_delta[state].size() == 1); return m_delta[state][0]; }

src/math/automata/boolean_algebra.h

@@ -0,0 +1,46 @@
+/*++
+Copyright (c) 2015 Microsoft Corporation
+
+Module Name:
+
+    boolean_algebra.h
+
+Abstract:
+
+    Boolean Algebra, a la Margus Veanes Automata library.
+
+Author:
+
+    Nikolaj Bjorner (nbjorner) 2016-2-27
+
+Revision History:
+
+
+--*/
+
+#ifndef BOOLEAN_ALGEBRA_H_
+#define BOOLEAN_ALGEBRA_H_
+
+#include "util.h"
+
+template<class T>
+class positive_boolean_algebra {
+public:
+    virtual T mk_false() = 0;
+    virtual T mk_true() = 0;
+    virtual T mk_and(T x, T y) = 0;
+    virtual T mk_or(T x, T y) = 0;
+    virtual T mk_and(unsigned sz, T const* ts) = 0;
+    virtual T mk_or(unsigned sz, T const* ts) = 0;
+    virtual lbool is_sat(T x) = 0;
+};
+
+template<class T>
+class boolean_algebra : public positive_boolean_algebra<T> {
+public:
+    virtual T mk_not(T x) = 0;
+    //virtual lbool are_equivalent(T x, T y) = 0;
+    //virtual T simplify(T x) = 0;    
+};
+
+#endif

src/math/automata/symbolic_automata.h

@@ -0,0 +1,104 @@
+/*++
+Copyright (c) 2015 Microsoft Corporation
+
+Module Name:
+
+    symbolic_automata.h
+
+Abstract:
+
+    Symbolic Automata over Boolean Algebras, a la Margus Veanes Automata library.
+
+Author:
+
+    Nikolaj Bjorner (nbjorner) 2016-02-27.
+
+Revision History:
+
+
+--*/
+
+#ifndef SYMBOLIC_AUTOMATA_H_
+#define SYMBOLIC_AUTOMATA_H_
+
+
+#include "automaton.h"
+#include "boolean_algebra.h"
+
+
+template<class T, class M = default_value_manager<T> >
+class symbolic_automata {
+    typedef automaton<T, M>    automaton_t;
+    typedef boolean_algebra<T*> ba_t;
+    typedef typename automaton_t::move  move_t;
+    typedef vector<move_t>     moves_t;
+    typedef obj_ref<T, M>      ref_t;
+    typedef ref_vector<T, M>   refs_t;
+
+    M&    m;
+    ba_t& m_ba;
+
+
+    class block {
+        uint_set m_set;
+        unsigned m_rep;
+        bool     m_rep_chosen;
+    public:
+
+        block(): m_rep(0), m_rep_chosen(false) {}
+
+        block(uint_set const& s):
+            m_set(s),
+            m_rep(0),
+            m_rep_chosen(false) {
+        }
+
+        block(unsigned_vector const& vs) {
+            for (unsigned i = 0; i < vs.size(); ++i) {
+                m_set.insert(vs[i]);               
+            }
+            m_rep_chosen = false;
+            m_rep = 0;
+        }
+
+        block& operator=(block const& b) {
+            m_set = b.m_set;
+            m_rep = 0;
+            m_rep_chosen = false;
+            return *this;
+        }
+
+        unsigned get_representative() {
+            if (!m_rep_chosen) {
+                uint_set::iterator it = m_set.begin();
+                if (m_set.end() != it) {
+                    m_rep = *it;                    
+                }
+                m_rep_chosen = true;
+            }
+            return m_rep;
+        }
+
+        void add(unsigned i) { m_set.insert(i); }
+        bool contains(unsigned i) const { return m_set.contains(i); }        
+        bool is_empty() const { return m_set.empty(); }
+        unsigned size() const { return m_set.num_elems(); }
+        void remove(unsigned i) { m_set.remove(i); m_rep_chosen = false; }        
+        void clear() { m_set.reset(); m_rep_chosen = false; }
+        uint_set::iterator begin() { return m_set.begin(); }
+        uint_set::iterator end() { return m_set.end(); }
+    };
+
+public:
+    symbolic_automata(M& m, ba_t& ba): m(m), m_ba(ba) {}
+    automaton_t* mk_determinstic(automaton_t& a);
+    automaton_t* mk_complement(automaton_t& a);
+    automaton_t* remove_epsilons(automaton_t& a);
+    automaton_t* mk_total(automaton_t& a);
+    automaton_t* mk_minimize(automaton_t& a);
+    automaton_t* mk_product(automaton_t& a, automaton_t& b);
+};
+
+
+
+#endif 

src/math/automata/symbolic_automata_def.h

@@ -0,0 +1,227 @@
+/*++
+Copyright (c) 2015 Microsoft Corporation
+
+Module Name:
+
+    symbolic_automata_def.h
+
+Abstract:
+
+    Symbolic Automata over Boolean Algebras, a la Margus Veanes Automata library.
+
+Author:
+
+    Nikolaj Bjorner (nbjorner) 2016-02-27.
+
+Revision History:
+
+
+--*/
+
+#ifndef SYMBOLIC_AUTOMATA_DEF_H_
+#define SYMBOLIC_AUTOMATA_DEF_H_
+
+
+#include "symbolic_automata.h"
+#include "hashtable.h"
+
+typedef std::pair<unsigned, unsigned> unsigned_pair;
+
+
+
+template<class T, class M>
+typename symbolic_automata<T, M>::automaton_t* symbolic_automata<T, M>::mk_total(automaton_t& a) {
+    unsigned dead_state = a.num_states();
+    moves_t mvs;
+    for (unsigned i = 0; i < dead_state; ++i) {
+        mvs.reset();
+        a.get_moves(i, mvs, true);
+        refs_t vs(m);
+        
+        for (unsigned j = 0; j < mvs.size(); ++j) {
+            mv.push_back(mvs[j]());
+        }
+        ref_t cond(m_ba.mk_not(m_ba.mk_or(vs.size(), vs.c_ptr())), m);
+        lbool is_sat = m_ba.is_sat(cond);
+        if (is_sat == l_undef) {
+            return 0;
+        }
+        if (is_sat == l_true) {
+            new_mvs.push_back(move_t(m, i, dead_state, cond));
+        }
+    }
+    if (new_mvs.empty()) {
+        return a.clone();
+    }
+    new_mvs.push_back(move_t(m, dead_state, dead_state, m_ba.mk_true()));
+    automaton_t::append_moves(0, a, new_mvs);
+    
+    return alloc(automaton_t, m, a.init(), a.final_states(), new_mvs);        
+}
+
+template<class T, class M>
+typename symbolic_automata<T, M>::automaton_t* symbolic_automata<T, M>::mk_minimize(automaton_t& a) {
+    if (a.is_empty()) {
+        return a.clone();
+    }
+    if (a.is_epsilon()) {
+        return a.clone();
+    }
+    // SASSERT(a.is_deterministic());
+    
+    scoped_ptr<automaton_t> fa = mk_total(a);
+    if (!fa) {
+        return 0;
+    }
+    
+    block final_block(fa->final_states());
+    block non_final_block(fa->non_final_states());
+    vector<block> blocks;
+    for (unsigned i = 0; i < fa->num_states(); ++i) {
+        if (fa->is_final_state(i)) {
+            blocks.push_back(final_block);
+        }
+        else {
+            blocks.push_back(non_final_block);
+        }
+    }
+    vector<block> W;
+    if (final_block.size() > non_final_block.size()) {
+        W.push_back(non_final_block);
+    }
+    else {
+        W.push_back(final_block);
+    }
+    
+#if 0
+    
+    refs_t trail(m);
+    u_map<T*> gamma;
+    moves_t mvs;
+    while (!W.empty()) {
+        block R(W.back());
+        W.pop_back();
+        block Rcopy(R);
+        gamma.reset();
+        uint_set::iterator it = Rcopy.begin(), end = Rcopy.end();
+        for (; it != end; ++it) {
+            unsigned q = *it;
+            mvs.reset();
+            fa->get_moves_to(q, mvs);
+            for (unsigned i = 0; i < mvs.size(); ++i) {
+                unsigned src = mvs[i].src();
+                if (blocks[src].size() > 1) {
+                    T* t = mvs[i]();
+                    if (gamma.find(src, t1)) {
+                        t = m_ba.mk_or(t, t1);
+                        trail.push_back(t);
+                    }
+                    gamma.insert(src, t);
+                }
+            }
+        }
+        hashtable<block*> relevant;
+        u_map<T*>::iterator end = gamma.end();
+        for (u_map<T*>::iterator it = gamma.begin(); it != end; ++it) {
+            relevant.insert(blocks[it->m_key]);
+        }
+        
+    }
+#endif
+    
+    return 0;
+        
+}
+
+template<class T, class M>
+typename symbolic_automata<T, M>::automaton_t* symbolic_automata<T, M>::mk_product(automaton_t& a, automaton_t& b) {
+    map<unsigned_pair, unsigned, pair_hash<unsigned_hash, unsigned_hash>, default_eq<unsigned_pair> > state_ids;
+    unsigned_pair init_pair(a.init(), b.init());
+    svector<unsigned_pair> todo;
+    todo.push_back(init_pair);
+    state_ids.insert(init_pair, 0);
+    moves_t mvs;
+    unsigned_vector final;
+    if (a.is_final_state(a.init()) && b.is_final_state(b.init())) {
+        final.push_back(0);
+    }
+    unsigned n = 1;
+    moves_t mvsA, mvsB;
+    while (!todo.empty()) {
+        unsigned_pair curr_pair = todo.back();
+        todo.pop_back();
+        unsigned src = state_ids[curr_pair];
+        mvsA.reset(); mvsB.reset();
+        a.get_moves_from(curr_pair.first,  mvsA, true);
+        b.get_moves_from(curr_pair.second, mvsB, true);
+        for (unsigned i = 0; i < mvsA.size(); ++i) {
+            for (unsigned j = 0; j < mvsB.size(); ++j) {
+                ref_t ab(m_ba.mk_and(mvsA[i].t(), mvsB[j].t()), m);   
+                lbool is_sat = m_ba.is_sat(ab);
+                if (is_sat == l_false) {
+                    continue;
+                }
+                else if (is_sat == l_undef) {
+                    return 0;
+                }
+                unsigned_pair tgt_pair(mvsA[i].dst(), mvsB[j].dst());
+                unsigned tgt;
+                if (!state_ids.find(tgt_pair, tgt)) {
+                    tgt = n++;
+                    state_ids.insert(tgt_pair, tgt);
+                    todo.push_back(tgt_pair);
+                    if (a.is_final_state(tgt_pair.first) && b.is_final_state(tgt_pair.second)) {
+                        final.push_back(tgt);
+                    }
+                }
+                mvs.push_back(move_t(m, src, tgt, ab));
+            }
+        }
+    }
+    
+    if (final.empty()) {
+        return alloc(automaton_t, m);
+    }
+    vector<moves_t> inv(n, moves_t());
+    for (unsigned i = 0; i < mvs.size(); ++i) {
+        move_t const& mv = mvs[i];
+        inv[mv.dst()].push_back(move_t(m, mv.dst(), mv.src(), mv.t())); 
+    }
+    
+    svector<bool> back_reachable(n, false);
+    for (unsigned i = 0; i < final.size(); ++i) {
+        back_reachable[final[i]] = true;
+    }
+    
+    unsigned_vector stack(final);
+    while (!stack.empty()) {
+        unsigned state = stack.back();
+        stack.pop_back();
+        moves_t const& mv = inv[state];
+        for (unsigned i = 0; i < mv.size(); ++i) {
+            state = mv[i].dst();
+            if (!back_reachable[state]) {
+                back_reachable[state] = true;
+                stack.push_back(state);
+            }
+        }
+    }
+    
+    moves_t mvs1;
+    for (unsigned i = 0; i < mvs.size(); ++i) {
+        move_t const& mv = mvs[i];
+        if (back_reachable[mv.dst()]) {
+            mvs1.push_back(mv);
+        }
+    }
+    if (mvs1.empty()) {
+        return alloc(automaton_t, m);
+    }
+    else {
+        return alloc(automaton_t, m, 0, final, mvs1);
+    }
+} 
+
+
+
+#endif