Z3 sources

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

lib/spc_rewriter.h

@@ -0,0 +1,122 @@
+/*++
+Copyright (c) 2006 Microsoft Corporation
+
+Module Name:
+
+    spc_rewriter.h
+
+Abstract:
+
+    <abstract>
+
+Author:
+
+    Leonardo de Moura (leonardo) 2008-02-11.
+
+Revision History:
+
+--*/
+#ifndef _SPC_REWRITER_H_
+#define _SPC_REWRITER_H_
+
+#include"simplifier.h"
+#include"order.h"
+#include"substitution_tree.h"
+#include"spc_clause.h"
+#include"spc_asserted_literals.h"
+#include"sparse_use_list.h"
+
+namespace spc {
+    
+    /**
+       \brief Apply rewriting steps using demodulation rule:
+
+       C[s] ==> C[sigma(r)]
+       when 
+       
+       l = r is a known equality (demodulator)
+       sigma(l) = s
+       sigma(l) > sigma(r)
+
+       It also applies the following rules:
+       
+       - Duplicate literal deletion
+
+       - Resolved literal deletion
+
+       - Positive simplify reflect
+       s = t,  (u[p <- sigma(s)] != u[p <- sigma(t)] or R)
+       ==>
+       R
+   
+       - Negative simplify reflect
+       s != t  (sigma(s = t) or R)
+       ===>
+       R
+    */
+    class rewriter : public simplifier {
+    protected:
+        typedef sparse_use_list<expr, ptr_vector<clause> > clause_use_list;
+        asserted_literals &       m_asserted_literals;
+        order &                   m_order;
+        family_id                 m_spc_fid;
+
+        substitution              m_subst;
+        substitution_tree         m_st; // index for potential demodulators left-hand-side
+        clause_use_list           m_cls_use_list; // index for demodulators left-hand-side to equation.
+        found_literals            m_found_literals;
+
+        ptr_vector<justification> m_justifications;
+
+        struct visitor : public st_visitor {
+            ast_manager &     m_manager;
+            order &           m_order;
+            clause_use_list & m_cls_use_list;
+            bool              m_found;
+            clause *          m_clause;
+            expr *            m_source;
+            expr *            m_target;
+
+            visitor(order & ord, substitution & subst, clause_use_list & ul):
+                st_visitor(subst), m_manager(ord.get_manager()), m_order(ord), m_cls_use_list(ul) {
+            }
+            
+            virtual bool operator()(expr * e);
+        };
+
+        unsigned                  m_max_scope_lvl; // maximal scope level used during rewrite.
+        visitor                   m_visitor;
+
+        proof * mk_demodulation_proof(expr * old_expr, expr * new_expr, proof * parent);
+
+        bool demodulator(clause * cls) const;
+        void insert(clause * cls, expr * source);
+        void erase(clause * cls, expr * source);
+        void reserve_vars(unsigned num_vars);
+        void reserve_offsets(unsigned num_offsets);
+        void save_justification(justification * j);
+
+        void reduce_literal(literal const & l, literal & l_r, proof * & l_pr);
+
+    public:
+        rewriter(ast_manager & m, simplifier & s, order & ord, asserted_literals & al);
+        virtual ~rewriter();
+        
+        /**
+           \brief Insert clause into rewriter indexes
+        */
+        void insert(clause * cls);
+
+        /**
+           \brief Remove clause from rewriter indexes
+        */
+        void erase(clause * cls);
+        
+        clause * operator()(clause * cls);
+
+        void reset();
+    };
+};
+
+#endif /* _SPC_REWRITER_H_ */
+