Z3 sources

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

lib/push_app_ite.cpp

@@ -0,0 +1,220 @@
+/*++
+Copyright (c) 2006 Microsoft Corporation
+
+Module Name:
+
+    push_app_ite.cpp
+
+Abstract:
+
+    TODO: Write a better ite lifter
+
+
+Author:
+
+    Leonardo de Moura (leonardo) 2008-05-14.
+
+Revision History:
+
+--*/
+#include"push_app_ite.h"
+#include"ast_pp.h"
+
+push_app_ite::push_app_ite(simplifier & s, bool conservative):
+    simplifier(s.get_manager()),
+    m_conservative(conservative) {
+
+    borrow_plugins(s);
+}
+
+push_app_ite::~push_app_ite() {
+    // the plugins were borrowed. So, release ownership.
+    m_plugins.release();
+}
+
+int push_app_ite::has_ite_arg(unsigned num_args, expr * const * args) {
+    for (unsigned i = 0; i < num_args; i++)
+        if (m_manager.is_ite(args[i]))
+            return i;
+    return -1;
+}
+
+void push_app_ite::apply(func_decl * decl, unsigned num_args, expr * const * args, expr_ref & r) {
+    TRACE("push_app_ite", tout << "pushing app...\n";);
+    int ite_arg_idx = has_ite_arg(num_args, args);
+    if (ite_arg_idx < 0) {
+        mk_app(decl, num_args, args, r);
+        return;
+    }
+    app * ite               = to_app(args[ite_arg_idx]);
+    expr * c                = ite->get_arg(0);
+    expr * t                = ite->get_arg(1);
+    expr * e                = ite->get_arg(2);
+    expr ** args_prime      = const_cast<expr**>(args);
+    expr * old              = args_prime[ite_arg_idx];
+    args_prime[ite_arg_idx] = t;
+    expr_ref t_new(m_manager);
+    apply(decl, num_args, args_prime, t_new);
+    args_prime[ite_arg_idx] = e;
+    expr_ref e_new(m_manager);
+    apply(decl, num_args, args_prime, e_new);
+    args_prime[ite_arg_idx] = old;
+    expr * new_args[3] = { c, t_new, e_new };
+    mk_app(ite->get_decl(), 3, new_args, r);
+}
+
+/**
+   \brief Default (conservative) implementation. Return true if there one and only one ite-term argument.
+*/
+bool push_app_ite::is_target(func_decl * decl, unsigned num_args, expr * const * args) {
+    if (m_manager.is_ite(decl))
+        return false;
+    bool found_ite = false;
+    for (unsigned i = 0; i < num_args; i++) {
+        if (m_manager.is_ite(args[i]) && !m_manager.is_bool(args[i])) {
+            if (found_ite) {
+                if (m_conservative)
+                    return false;
+            }
+            else {
+                found_ite = true;
+            }
+        }
+    }
+    CTRACE("push_app_ite", found_ite, tout << "found target for push app ite:\n";
+          tout << decl->get_name();
+          for (unsigned i = 0; i < num_args; i++) tout << " " << mk_pp(args[i], m_manager);
+          tout << "\n";);
+    return found_ite;
+}
+
+void push_app_ite::operator()(expr * s, expr_ref & r, proof_ref & p) {
+    expr  * result;
+    proof * result_proof;
+    reduce_core(s);
+    get_cached(s, result, result_proof);
+    r = result;
+    switch (m_manager.proof_mode()) {
+    case PGM_DISABLED:
+        p = m_manager.mk_undef_proof();
+        break;
+    case PGM_COARSE:
+        if (result == s)
+            p = m_manager.mk_reflexivity(s);
+        else
+            p = m_manager.mk_rewrite_star(s, result, 0, 0);
+        break;
+    case PGM_FINE:
+        if (result == s)
+            p = m_manager.mk_reflexivity(s);
+        else
+            p = result_proof;
+        break;
+    }
+}
+
+void push_app_ite::reduce_core(expr * n) {
+    if (!is_cached(n)) {
+        unsigned sz = m_todo.size();
+        m_todo.push_back(n);
+        while (m_todo.size() != sz) {
+            expr * n = m_todo.back();
+            if (is_cached(n))
+                m_todo.pop_back();
+            else if (visit_children(n)) {
+                m_todo.pop_back();
+                reduce1(n);
+            }
+        }
+    }
+}
+
+bool push_app_ite::visit_children(expr * n) {
+    bool visited = true;
+    unsigned j;
+    switch(n->get_kind()) {
+    case AST_VAR:
+        return true;
+    case AST_APP:
+        j = to_app(n)->get_num_args();
+        while (j > 0) {
+            --j;
+            visit(to_app(n)->get_arg(j), visited);
+        }
+        return visited;
+    case AST_QUANTIFIER: 
+        visit(to_quantifier(n)->get_expr(), visited);
+        return visited;
+    default:
+        UNREACHABLE();
+        return true;
+    }
+}
+
+void push_app_ite::reduce1(expr * n) {
+    switch (n->get_kind()) {
+    case AST_VAR:
+        cache_result(n, n, 0);
+        break;
+    case AST_APP:
+        reduce1_app(to_app(n));
+        break;
+    case AST_QUANTIFIER:
+        reduce1_quantifier(to_quantifier(n));
+        break;
+    default:
+        UNREACHABLE();
+    }
+}
+
+void push_app_ite::reduce1_app(app * n) {
+    m_args.reset();
+    
+    func_decl * decl = n->get_decl();
+    proof_ref p1(m_manager);
+    get_args(n, m_args, p1);
+
+    expr_ref r(m_manager);
+    if (is_target(decl, m_args.size(), m_args.c_ptr()))
+        apply(decl, m_args.size(), m_args.c_ptr(), r);
+    else
+        mk_app(decl, m_args.size(), m_args.c_ptr(), r);
+    
+    if (!m_manager.fine_grain_proofs())
+        cache_result(n, r, 0);
+    else {
+        expr * s = m_manager.mk_app(decl, m_args.size(), m_args.c_ptr());
+        proof * p;
+        if (n == r)
+            p = 0;
+        else if (r != s) 
+            p = m_manager.mk_transitivity(p1, m_manager.mk_rewrite(s, r));
+        else
+            p = p1;
+        cache_result(n, r, p);
+    }
+}
+
+void push_app_ite::reduce1_quantifier(quantifier * q) {
+    expr *  new_body;
+    proof * new_body_pr;
+    get_cached(q->get_expr(), new_body, new_body_pr);
+    
+    quantifier * new_q = m_manager.update_quantifier(q, new_body);
+    proof *      p     = q == new_q ? 0 : m_manager.mk_quant_intro(q, new_q, new_body_pr);   
+    cache_result(q, new_q, p);
+}
+
+bool ng_push_app_ite::is_target(func_decl * decl, unsigned num_args, expr * const * args) {
+    bool r = push_app_ite::is_target(decl, num_args, args);
+    if (!r) 
+        return false;
+    for (unsigned i = 0; i < num_args; i++)
+        if (!is_ground(args[i]))
+            return true;
+    return false;
+}
+
+ng_push_app_ite::ng_push_app_ite(simplifier & s, bool conservative):
+    push_app_ite(s, conservative) {
+}