/*++
Copyright (c) 2012 Microsoft Corporation

Module Name:

    dl_bmc_engine.cpp

Abstract:

    BMC engine for fixedpoint solver.

Author:

    Nikolaj Bjorner (nbjorner) 2012-9-20

Revision History:

--*/

#include "muz/base/dl_context.h"
#include "muz/base/dl_rule_transformer.h"
#include "muz/bmc/dl_bmc_engine.h"
#include "muz/transforms/dl_mk_slice.h"
#include "smt/smt_kernel.h"
#include "ast/datatype_decl_plugin.h"
#include "ast/dl_decl_plugin.h"
#include "ast/rewriter/bool_rewriter.h"
#include "model/model_smt2_pp.h"
#include "ast/ast_smt_pp.h"
#include "ast/well_sorted.h"
#include "ast/rewriter/rewriter_def.h"
#include "muz/transforms/dl_transforms.h"
#include "muz/transforms/dl_mk_rule_inliner.h"
#include "ast/scoped_proof.h"

#include "muz/base/fp_params.hpp"

namespace datalog {

    // ---------------------------------------------------------------------------
    // Basic linear BMC based on indexed variables using quantified bit-vector domains.

    class bmc::qlinear {
        bmc&             b;
        ast_manager&     m;
        bv_util          m_bv;
        unsigned         m_bit_width;
    public:
        qlinear(bmc& b): b(b), m(b.m), m_bv(m), m_bit_width(1) {}

        lbool check() {
            setup();
            m_bit_width = 4;
            lbool res = l_false;
            while (res == l_false) {
                b.m_solver.push();
                IF_VERBOSE(1, verbose_stream() << "bit_width: " << m_bit_width << "\n";);
                compile();
                b.checkpoint();
                func_decl_ref q = mk_q_func_decl(b.m_query_pred);
                expr* T = m.mk_const(symbol("T"), mk_index_sort());
                expr_ref fml(m.mk_app(q, T), m);
                b.assert_expr(fml);
                res = b.m_solver.check();

                if (res == l_true) {
                    res = get_model();
                }
                b.m_solver.pop(1);
                ++m_bit_width;
            }
            return res;
        }
    private:

        sort_ref mk_index_sort() {
            return sort_ref(m_bv.mk_sort(m_bit_width), m);
        }

        var_ref mk_index_var() {
            return var_ref(m.mk_var(0, mk_index_sort()), m);
        }

        void compile() {
            sort_ref index_sort = mk_index_sort();
            var_ref var = mk_index_var();
            sort* index_sorts[1] = { index_sort };
            symbol tick("T");
            rule_set::decl2rules::iterator it  = b.m_rules.begin_grouped_rules();
            rule_set::decl2rules::iterator end = b.m_rules.end_grouped_rules();
            for (; it != end; ++it) {
                func_decl* p = it->m_key;
                rule_vector const& rls = *it->m_value;
                // Assert: forall level . p(T) => body of rule i + equalities for head of rule i
                func_decl_ref pr = mk_q_func_decl(p);
                expr_ref pred = expr_ref(m.mk_app(pr, var.get()), m);
                expr_ref_vector rules(m), sub(m), conjs(m);
                expr_ref trm(m), rule_body(m), rule_i(m);
                for (unsigned i = 0; i < rls.size(); ++i) {
                    sub.reset();
                    conjs.reset();
                    rule& r = *rls[i];
                    rule_i = m.mk_app(mk_q_rule(p, i), var.get());
                    rules.push_back(rule_i);

                    mk_qrule_vars(r, i, sub);

                    // apply substitution to body.
                    var_subst vs(m, false);
                    for (unsigned k = 0; k < p->get_arity(); ++k) {
                        vs(r.get_head()->get_arg(k), sub.size(), sub.c_ptr(), trm);
                        conjs.push_back(m.mk_eq(trm, mk_q_arg(p, k, true)));
                    }
                    for (unsigned j = 0; j < r.get_uninterpreted_tail_size(); ++j) {
                        func_decl* q = r.get_decl(j);
                        for (unsigned k = 0; k < q->get_arity(); ++k) {
                            vs(r.get_tail(j)->get_arg(k), sub.size(), sub.c_ptr(), trm);
                            conjs.push_back(m.mk_eq(trm, mk_q_arg(q, k, false)));
                        }
                        func_decl_ref qr = mk_q_func_decl(q);
                        conjs.push_back(m.mk_app(qr, m_bv.mk_bv_sub(var, mk_q_one())));
                    }
                    for (unsigned j = r.get_uninterpreted_tail_size(); j < r.get_tail_size(); ++j) {
                        vs(r.get_tail(j), sub.size(), sub.c_ptr(), trm);
                        conjs.push_back(trm);
                    }
                    if (r.get_uninterpreted_tail_size() > 0) {
                        conjs.push_back(m_bv.mk_ule(mk_q_one(), var));
                    }
                    bool_rewriter(m).mk_and(conjs.size(), conjs.c_ptr(), rule_body);
                    trm = m.mk_implies(rule_i, rule_body);
                    trm = m.mk_forall(1, index_sorts, &tick, trm, 1);
                    b.assert_expr(trm);
                }
                bool_rewriter(m).mk_or(rules.size(), rules.c_ptr(), trm);
                trm = m.mk_implies(pred, trm);
                trm = m.mk_forall(1, index_sorts, &tick, trm, 1);
                SASSERT(is_well_sorted(m, trm));
                b.assert_expr(trm);
            }
        }

        void setup() {
            b.m_fparams.m_relevancy_lvl = 2;
            b.m_fparams.m_model = true;
            b.m_fparams.m_model_compact = true;
            b.m_fparams.m_mbqi = true;
            b.m_rule_trace.reset();
        }

        void mk_qrule_vars(datalog::rule const& r, unsigned rule_id, expr_ref_vector& sub) {
            ptr_vector<sort> sorts;
            r.get_vars(m, sorts);
            // populate substitution of bound variables.
            sub.reset();
            sub.resize(sorts.size());

            for (unsigned k = 0; k < r.get_decl()->get_arity(); ++k) {
                expr* arg = r.get_head()->get_arg(k);
                if (is_var(arg)) {
                    unsigned idx = to_var(arg)->get_idx();
                    if (!sub[idx].get()) {
                        sub[idx] = mk_q_arg(r.get_decl(), k, true);
                    }
                }
            }
            for (unsigned j = 0; j < r.get_uninterpreted_tail_size(); ++j) {
                func_decl* q = r.get_decl(j);
                for (unsigned k = 0; k < q->get_arity(); ++k) {
                    expr* arg = r.get_tail(j)->get_arg(k);
                    if (is_var(arg)) {
                        unsigned idx = to_var(arg)->get_idx();
                        if (!sub[idx].get()) {
                            sub[idx] = mk_q_arg(q, k, false);
                        }
                    }
                }
            }
            for (unsigned j = 0, idx = 0; j < sorts.size(); ++j) {
                if (sorts[j] && !sub[j].get()) {
                    sub[j] = mk_q_var(r.get_decl(), sorts[j], rule_id, idx++);
                }
            }
        }

        expr_ref mk_q_var(func_decl* pred, sort* s, unsigned rule_id, unsigned idx) {
            std::stringstream _name;
            _name << pred->get_name() << "#" <<  rule_id << "_" << idx;
            symbol nm(_name.str().c_str());
            var_ref var = mk_index_var();
            return expr_ref(m.mk_app(m.mk_func_decl(nm, mk_index_sort(), s), var), m);
        }

        expr_ref mk_q_arg(func_decl* pred, unsigned idx, bool is_current) {
            SASSERT(idx < pred->get_arity());
            std::stringstream _name;
            _name << pred->get_name() << "#" << idx;
            symbol nm(_name.str().c_str());
            expr_ref var(mk_index_var(), m);
            if (!is_current) {
                var = m_bv.mk_bv_sub(var, mk_q_one());
            }
            return expr_ref(m.mk_app(m.mk_func_decl(nm, mk_index_sort(), pred->get_domain(idx)), var), m);
        }

        expr_ref mk_q_one() {
            return mk_q_num(1);
        }

        expr_ref mk_q_num(unsigned i) {
            return expr_ref(m_bv.mk_numeral(i, m_bit_width), m);
        }

        func_decl_ref mk_q_func_decl(func_decl* f) {
            std::stringstream _name;
            _name << f->get_name() << "#";
            symbol nm(_name.str().c_str());
            return func_decl_ref(m.mk_func_decl(nm, mk_index_sort(), f->get_range()), m);
        }

        func_decl_ref mk_q_rule(func_decl* f, unsigned rule_id) {
            std::stringstream _name;
            _name << f->get_name() << "#" << rule_id;
            symbol nm(_name.str().c_str());
            return func_decl_ref(m.mk_func_decl(nm, mk_index_sort(), m.mk_bool_sort()), m);
        }


        expr_ref eval_q(model_ref& model, func_decl* f, unsigned i) {
            func_decl_ref fn = mk_q_func_decl(f);
            expr_ref t(m);
            t = m.mk_app(mk_q_func_decl(f).get(), mk_q_num(i));
            return (*model)(t);
        }

        expr_ref eval_q(model_ref& model, expr* t, unsigned i) {
            expr_ref tmp(m), result(m), num(m);
            var_subst vs(m, false);
            num = mk_q_num(i);
            expr* nums[1] = { num };
            vs(t, 1, nums, tmp);
            return (*model)(tmp);
        }

        lbool get_model() {
            rule_manager& rm = b.m_ctx.get_rule_manager();
            func_decl_ref q = mk_q_func_decl(b.m_query_pred);
            expr_ref T(m), rule_i(m), vl(m);
            model_ref md;
            proof_ref pr(m);
            rule_unifier unifier(b.m_ctx);
            rational num;
            unsigned level, bv_size;

            b.m_solver.get_model(md);
            func_decl* pred = b.m_query_pred;
            dl_decl_util util(m);
            T = m.mk_const(symbol("T"), mk_index_sort());
            vl = (*md)(T);
            VERIFY (m_bv.is_numeral(vl, num, bv_size));
            SASSERT(num.is_unsigned());
            level = num.get_unsigned();
            SASSERT(m.is_true(eval_q(md, b.m_query_pred, level)));
            TRACE("bmc", model_smt2_pp(tout, m, *md, 0););

            rule_ref r0(rm), r1(rm), r2(rm);
            while (true) {
                TRACE("bmc", tout << "Predicate: " << pred->get_name() << "\n";);
                expr_ref_vector sub(m);
                rule_vector const& rls = b.m_rules.get_predicate_rules(pred);
                rule* r = nullptr;
                unsigned i = 0;
                for (; i < rls.size(); ++i) {
                    rule_i = m.mk_app(mk_q_rule(pred, i), mk_q_num(level).get());
                    TRACE("bmc", rls[i]->display(b.m_ctx, tout << "Checking rule " << mk_pp(rule_i, m) << " "););
                    if (m.is_true(eval_q(md, rule_i, level))) {
                        r = rls[i];
                        break;
                    }
                }
                SASSERT(r);
                mk_qrule_vars(*r, i, sub);
                b.m_rule_trace.push_back(r);
                // we have rule, we have variable names of rule.

                // extract values for the variables in the rule.
                for (unsigned j = 0; j < sub.size(); ++j) {
                    expr_ref vl = eval_q(md, sub[j].get(), i);
                    if (vl) {
                        // vl can be 0 if the interpretation does not assign a value to it.
                        sub[j] = vl;
                    }
                    else {
                        sub[j] = m.mk_var(j, m.get_sort(sub[j].get()));
                    }
                }
                svector<std::pair<unsigned, unsigned> > positions;
                vector<expr_ref_vector> substs;
                expr_ref fml(m), concl(m);

                rm.to_formula(*r, fml);
                r2 = r;
                rm.substitute(r2, sub.size(), sub.c_ptr());
                proof_ref p(m);
                if (r0) {
                    VERIFY(unifier.unify_rules(*r0.get(), 0, *r2.get()));
                    expr_ref_vector sub1 = unifier.get_rule_subst(*r0.get(), true);
                    expr_ref_vector sub2 = unifier.get_rule_subst(*r2.get(), false);
                    apply_subst(sub, sub2);
                    unifier.apply(*r0.get(), 0, *r2.get(), r1);
                    rm.to_formula(*r1.get(), concl);
                    scoped_proof _sp(m);

                    p = r->get_proof();
                    if (!p) {
                        p = m.mk_asserted(fml);
                    }
                    proof* premises[2] = { pr, p };

                    positions.push_back(std::make_pair(0, 1));

                    substs.push_back(sub1);
                    substs.push_back(sub);
                    pr = m.mk_hyper_resolve(2, premises, concl, positions, substs);
                    r0 = r1;
                }
                else {
                    rm.to_formula(*r, concl);
                    scoped_proof _sp(m);
                    p = r->get_proof();
                    if (!p) {
                        p = m.mk_asserted(fml);
                    }
                    if (sub.empty()) {
                        pr = p;
                    }
                    else {
                        substs.push_back(sub);
                        proof* ps[1] = { p };
                        pr = m.mk_hyper_resolve(1, ps, concl, positions, substs);
                    }
                    r0 = r2;
                }

                if (level == 0) {
                    SASSERT(r->get_uninterpreted_tail_size() == 0);
                    break;
                }
                --level;
                SASSERT(r->get_uninterpreted_tail_size() == 1);
                pred = r->get_decl(0);
            }
            scoped_proof _sp(m);
            apply(m, b.m_ctx.get_proof_converter().get(), pr);
            b.m_answer = pr;
            return l_true;
        }
    };


    // --------------------------------------------------------------------------
    // Basic non-linear BMC based on compiling into quantifiers.

    class bmc::nonlinear {
        bmc&         b;
        ast_manager& m;

    public:

        nonlinear(bmc& b): b(b), m(b.m) {}

        lbool check() {
            setup();
            for (unsigned i = 0; ; ++i) {
                IF_VERBOSE(1, verbose_stream() << "level: " << i << "\n";);
                b.checkpoint();
                expr_ref_vector fmls(m);
                compile(b.m_rules, fmls, i);
                assert_fmls(fmls);
                lbool res = check(i);
                if (res == l_undef) {
                    return res;
                }
                if (res == l_true) {
                    get_model(i);
                    return res;
                }
            }
        }

        expr_ref compile_query(func_decl* query_pred, unsigned level) {
            expr_ref_vector vars(m);
            func_decl_ref level_p = mk_level_predicate(query_pred, level);
            for (unsigned i = 0; i < level_p->get_arity(); ++i) {
                std::stringstream _name;
                _name << query_pred->get_name() << "#" << level << "_" << i;
                symbol nm(_name.str().c_str());
                vars.push_back(m.mk_const(nm, level_p->get_domain(i)));
            }
            return expr_ref(m.mk_app(level_p, vars.size(), vars.c_ptr()), m);
        }

        void compile(rule_set const& rules, expr_ref_vector& result, unsigned level) {
            bool_rewriter br(m);
            rule_set::decl2rules::iterator it  = rules.begin_grouped_rules();
            rule_set::decl2rules::iterator end = rules.end_grouped_rules();
            for (; it != end; ++it) {
                func_decl* p = it->m_key;
                rule_vector const& rls = *it->m_value;

                // Assert: p_level(vars) => r1_level(vars) \/ r2_level(vars) \/ r3_level(vars) \/ ...
                // Assert: r_i_level(vars) => exists aux_vars . body of rule i for level

                func_decl_ref level_pred = mk_level_predicate(p, level);
                expr_ref_vector rules(m);
                expr_ref body(m), head(m);
                for (unsigned i = 0; i < rls.size(); ++i) {
                    rule& r = *rls[i];
                    func_decl_ref rule_i = mk_level_rule(p, i, level);
                    rules.push_back(apply_vars(rule_i));

                    ptr_vector<sort> rule_vars;
                    expr_ref_vector args(m), conjs(m);

                    r.get_vars(m, rule_vars);
                    obj_hashtable<expr> used_vars;
                    unsigned num_vars = 0;
                    for (unsigned i = 0; i < r.get_decl()->get_arity(); ++i) {
                        expr* arg = r.get_head()->get_arg(i);
                        if (is_var(arg) && !used_vars.contains(arg)) {
                            used_vars.insert(arg);
                            args.push_back(arg);
                            rule_vars[to_var(arg)->get_idx()] = 0;
                        }
                        else {
                            sort* srt = m.get_sort(arg);
                            args.push_back(m.mk_var(rule_vars.size()+num_vars, srt));
                            conjs.push_back(m.mk_eq(args.back(), arg));
                            ++num_vars;
                        }
                    }
                    head = m.mk_app(rule_i, args.size(), args.c_ptr());
                    for (unsigned i = 0; i < r.get_tail_size(); ++i) {
                        conjs.push_back(r.get_tail(i));
                    }
                    br.mk_and(conjs.size(), conjs.c_ptr(), body);

                    replace_by_level_predicates(level, body);
                    body = skolemize_vars(r, args, rule_vars, body);
                    body = m.mk_implies(head, body);
                    body = bind_vars(body, head);
                    result.push_back(body);
                }
                br.mk_or(rules.size(), rules.c_ptr(), body);
                head = apply_vars(level_pred);
                body = m.mk_implies(head, body);
                body = bind_vars(body, head);
                result.push_back(body);
            }
        }

    private:

        void assert_fmls(expr_ref_vector const& fmls) {
            for (unsigned i = 0; i < fmls.size(); ++i) {
                b.assert_expr(fmls[i]);
            }
        }

        void setup() {
            b.m_fparams.m_model = true;
            b.m_fparams.m_model_compact = true;
            // b.m_fparams.m_mbqi = true;
            b.m_fparams.m_relevancy_lvl = 2;
            b.m_rule_trace.reset();
        }

        lbool check(unsigned level) {
            expr_ref p = compile_query(b.m_query_pred, level);
            expr_ref q(m), q_at_level(m);
            q = m.mk_fresh_const("q",m.mk_bool_sort());
            q_at_level = m.mk_implies(q, p);
            b.assert_expr(q_at_level);
            expr* qr = q.get();
            return b.m_solver.check(1, &qr);
        }

        proof_ref get_proof(model_ref& md, func_decl* pred, app* prop, unsigned level) {
            if (m.canceled()) {
                return proof_ref(nullptr, m);
            }
            TRACE("bmc", tout << "Predicate: " << pred->get_name() << "\n";);
            rule_manager& rm = b.m_ctx.get_rule_manager();
            expr_ref prop_r(m), prop_v(m), fml(m), prop_body(m), tmp(m), body(m);
            expr_ref_vector args(m);
            proof_ref_vector prs(m);
            proof_ref pr(m);

            // find the rule that was triggered by evaluating the arguments to prop.
            rule_vector const& rls = b.m_rules.get_predicate_rules(pred);
            rule* r = nullptr;
            for (unsigned i = 0; i < rls.size(); ++i) {
                func_decl_ref rule_i = mk_level_rule(pred, i, level);
                TRACE("bmc", rls[i]->display(b.m_ctx, tout << "Checking rule " << mk_pp(rule_i, m) << " "););
                prop_r = m.mk_app(rule_i, prop->get_num_args(), prop->get_args());
                if (md->is_true(prop_r)) {
                    r = rls[i];
                    break;
                }
            }
            SASSERT(r);
            b.m_rule_trace.push_back(r);
            rm.to_formula(*r, fml);
            IF_VERBOSE(1, verbose_stream() << mk_pp(fml, m) << "\n";);
            prs.push_back(r->get_proof());
            unsigned sz = r->get_uninterpreted_tail_size();

            ptr_vector<sort> rule_vars;
            r->get_vars(m, rule_vars);
            args.append(prop->get_num_args(), prop->get_args());
            expr_ref_vector sub = mk_skolem_binding(*r, rule_vars, args);
            if (sub.empty() && sz == 0) {
                pr = prs[0].get();
                return pr;
            }
            for (unsigned j = 0; j < sub.size(); ++j) {
                sub[j] = (*md)(sub[j].get());
            }

            svector<std::pair<unsigned, unsigned> > positions;
            vector<expr_ref_vector> substs;
            var_subst vs(m, false);

            substs.push_back(sub);
            for (unsigned j = 0; j < sz; ++j) {
                func_decl* head_j = r->get_decl(j);
                app* body_j = r->get_tail(j);
                vs(body_j, sub.size(), sub.c_ptr(), prop_body);
                prs.push_back(get_proof(md, head_j, to_app(prop_body), level-1));
                positions.push_back(std::make_pair(j+1,0));
                substs.push_back(expr_ref_vector(m));
            }
            pr = m.mk_hyper_resolve(sz+1, prs.c_ptr(), prop, positions, substs);
            return pr;
        }

        void get_model(unsigned level) {
            scoped_proof _sp(m);
            expr_ref level_query = compile_query(b.m_query_pred, level);
            model_ref md;
            b.m_solver.get_model(md);
            IF_VERBOSE(2, model_smt2_pp(verbose_stream(), m, *md, 0););
            proof_ref pr(m);
            pr = get_proof(md, b.m_query_pred, to_app(level_query), level);
            apply(m, b.m_ctx.get_proof_converter().get(), pr);
            b.m_answer = pr;
        }

        func_decl_ref mk_level_predicate(func_decl* p, unsigned level) {
            std::stringstream _name;
            _name << p->get_name() << "#" << level;
            symbol nm(_name.str().c_str());
            return func_decl_ref(m.mk_func_decl(nm, p->get_arity(), p->get_domain(), m.mk_bool_sort()), m);
        }

        func_decl_ref mk_level_rule(func_decl* p, unsigned rule_idx, unsigned level) {
            std::stringstream _name;
            _name << "rule:" << p->get_name() << "#" << level << "_" << rule_idx;
            symbol nm(_name.str().c_str());
            return func_decl_ref(m.mk_func_decl(nm, p->get_arity(), p->get_domain(), m.mk_bool_sort()), m);
        }

        expr_ref apply_vars(func_decl* p) {
            expr_ref_vector vars(m);
            for (unsigned i = 0; i < p->get_arity(); ++i) {
                vars.push_back(m.mk_var(i, p->get_domain(i)));
            }
            return expr_ref(m.mk_app(p, vars.size(), vars.c_ptr()), m);
        }

        // remove variables from dst that are in src.
        void subtract_vars(ptr_vector<sort>& dst, ptr_vector<sort> const& src) {
            for (unsigned i = 0; i < dst.size(); ++i) {
                if (i >= src.size()) {
                    break;
                }
                if (src[i]) {
                    dst[i] = 0;
                }
            }
        }

        expr_ref_vector mk_skolem_binding(rule& r, ptr_vector<sort> const& vars, expr_ref_vector const& args) {
            expr_ref_vector binding(m);
            ptr_vector<sort> arg_sorts;
            for (unsigned i = 0; i < args.size(); ++i) {
                arg_sorts.push_back(m.get_sort(args[i]));
            }
            for (unsigned i = 0; i < vars.size(); ++i) {
                if (vars[i]) {
                    func_decl_ref f = mk_body_func(r, arg_sorts, i, vars[i]);
                    binding.push_back(m.mk_app(f, args.size(), args.c_ptr()));
                }
                else {
                    binding.push_back(nullptr);
                }
            }
            return binding;
        }

        expr_ref skolemize_vars(rule& r, expr_ref_vector const& args, ptr_vector<sort> const& vars, expr* e) {
            expr_ref        result(m);
            expr_ref_vector binding = mk_skolem_binding(r, vars, args);
            var_subst vs(m, false);
            vs(e, binding.size(), binding.c_ptr(), result);
            return result;
        }

        func_decl_ref mk_body_func(rule& r, ptr_vector<sort> const& args, unsigned index, sort* s) {
            std::stringstream _name;
            _name << r.get_decl()->get_name() << "@" << index;
            symbol name(_name.str().c_str());
            func_decl* f = m.mk_func_decl(name, args.size(), args.c_ptr(), s);
            return func_decl_ref(f, m);
        }

        expr_ref bind_vars(expr* e, expr* pat) {
            ptr_vector<sort> sorts;
            svector<symbol> names;
            expr_ref_vector binding(m), patterns(m);
            expr_ref tmp(m), head(m);
            expr_free_vars vars;
            vars(e);
            for (unsigned i = 0; i < vars.size(); ++i) {
                if (vars[i]) {
                    binding.push_back(m.mk_var(sorts.size(), vars[i]));
                    sorts.push_back(vars[i]);
                    names.push_back(symbol(i));
                }
                else {
                    binding.push_back(nullptr);
                }
            }
            sorts.reverse();
            if (sorts.empty()) {
                return expr_ref(e, m);
            }
            var_subst vs(m, false);
            vs(e, binding.size(), binding.c_ptr(), tmp);
            vs(pat, binding.size(), binding.c_ptr(), head);
            patterns.push_back(m.mk_pattern(to_app(head)));
            symbol qid, skid;
            return expr_ref(m.mk_forall(sorts.size(), sorts.c_ptr(), names.c_ptr(), tmp, 1, qid, skid, 1, patterns.c_ptr()), m);
        }

    public:
        class level_replacer {
            nonlinear& n;
            unsigned   m_level;
            bool is_predicate(func_decl* f) {
                return n.b.m_ctx.is_predicate(f);
            }
        public:
            level_replacer(nonlinear& n, unsigned level): n(n), m_level(level) {}

            br_status mk_app_core(func_decl* f, unsigned num_args, expr* const* args, expr_ref& result) {
                if (is_predicate(f)) {
                    if (m_level > 0) {
                        result = n.m.mk_app(n.mk_level_predicate(f, m_level-1), num_args, args);
                    }
                    else {
                        result = n.m.mk_false();
                    }
                    return BR_DONE;
                }
                return BR_FAILED;
            }

            bool reduce_quantifier(quantifier* old_q, expr* new_body, expr_ref& result) {
                if (is_ground(new_body)) {
                    result = new_body;
                }
                else {
                    expr * const * no_pats = &new_body;
                    result = n.m.update_quantifier(old_q, 0, nullptr, 1, no_pats, new_body);
                }
                return true;
            }
        };

        struct level_replacer_cfg : public default_rewriter_cfg {
            level_replacer m_r;

            level_replacer_cfg(nonlinear& nl, unsigned level):
                m_r(nl, level) {}

            bool rewrite_patterns() const { return false; }
            br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
                return m_r.mk_app_core(f, num, args, result);
            }
            bool reduce_quantifier(quantifier * old_q,
                                   expr * new_body,
                                   expr * const * new_patterns,
                                   expr * const * new_no_patterns,
                                   expr_ref & result,
                                   proof_ref & result_pr) {
                return m_r.reduce_quantifier(old_q, new_body, result);
            }

        };

        class level_replacer_star : public rewriter_tpl<level_replacer_cfg> {
            level_replacer_cfg m_cfg;
        public:
            level_replacer_star(nonlinear& nl, unsigned level):
                rewriter_tpl<level_replacer_cfg>(nl.m, false, m_cfg),
                m_cfg(nl, level)
            {}
        };

    private:

        void replace_by_level_predicates(unsigned level, expr_ref& fml) {
            level_replacer_star rep(*this, level);
            expr_ref tmp(m);
            rep(fml, tmp);
            fml = tmp;
        }


    };

    // --------------------------------------------------------------------------
    // Basic non-linear BMC based on compiling into data-types (it is inefficient)

    class bmc::nonlinear_dt {
        bmc&             b;
        ast_manager&     m;
        ast_ref_vector   m_pinned;
        sort_ref         m_path_sort;
        obj_map<func_decl, sort*> m_pred2sort;
        obj_map<sort, func_decl*> m_sort2pred;


    public:
        nonlinear_dt(bmc& b): b(b), m(b.m), m_pinned(m), m_path_sort(m) {}

        lbool check() {
            setup();
            declare_datatypes();
            compile();
            return check_query();
        }

    private:
        void setup() {
            m_pred2sort.reset();
            m_pinned.reset();
            m_sort2pred.reset();
            b.m_fparams.m_relevancy_lvl = 0;
            b.m_fparams.m_model = true;
            b.m_fparams.m_model_compact = true;
            b.m_fparams.m_mbqi = false;
            b.m_fparams.m_relevancy_lvl = 2;
            b.m_rule_trace.reset();
        }

        func_decl_ref mk_predicate(func_decl* pred) {
            std::stringstream _name;
            _name << pred->get_name() << "#";
            symbol nm(_name.str().c_str());
            sort* pred_trace_sort = m_pred2sort.find(pred);
            return func_decl_ref(m.mk_func_decl(nm, pred_trace_sort, m_path_sort, m.mk_bool_sort()), m);
        }

        func_decl_ref mk_rule(func_decl* p, unsigned rule_idx) {
            std::stringstream _name;
            _name << "rule:" << p->get_name() << "#" << rule_idx;
            symbol nm(_name.str().c_str());
            sort* pred_trace_sort = m_pred2sort.find(p);
            return func_decl_ref(m.mk_func_decl(nm, pred_trace_sort, m_path_sort, m.mk_bool_sort()), m);
        }

        expr_ref mk_var(func_decl* pred, sort*s, unsigned idx, expr* path_arg, expr* trace_arg) {
            std::stringstream _name;
            _name << pred->get_name() << "#V_" << idx;
            symbol nm(_name.str().c_str());
            func_decl_ref fn(m);
            fn = m.mk_func_decl(nm, m_pred2sort.find(pred), m_path_sort, s);
            return expr_ref(m.mk_app(fn, trace_arg, path_arg), m);
        }

        expr_ref mk_arg(func_decl* pred, unsigned idx, expr* path_arg, expr* trace_arg) {
            SASSERT(idx < pred->get_arity());
            std::stringstream _name;
            _name << pred->get_name() << "#X_" << idx;
            symbol nm(_name.str().c_str());
            func_decl_ref fn(m);
            fn = m.mk_func_decl(nm, m_pred2sort.find(pred), m_path_sort, pred->get_domain(idx));
            return expr_ref(m.mk_app(fn, trace_arg, path_arg), m);
        }

        void mk_subst(datalog::rule& r, expr* path, app* trace, expr_ref_vector& sub) {
            datatype_util dtu(m);
            ptr_vector<sort> sorts;
            func_decl* p = r.get_decl();
            ptr_vector<func_decl> const& succs  = *dtu.get_datatype_constructors(m.get_sort(path));
            // populate substitution of bound variables.
            r.get_vars(m, sorts);
            sub.reset();
            sub.resize(sorts.size());
            for (unsigned k = 0; k < r.get_decl()->get_arity(); ++k) {
                expr* arg = r.get_head()->get_arg(k);
                if (is_var(arg)) {
                    unsigned idx = to_var(arg)->get_idx();
                    if (!sub[idx].get()) {
                        sub[idx] = mk_arg(p, k, path, trace);
                    }
                }
            }
            for (unsigned j = 0; j < r.get_uninterpreted_tail_size(); ++j) {
                func_decl* q = r.get_decl(j);
                expr_ref path_arg(m);
                if (j == 0) {
                    path_arg = path;
                }
                else {
                    path_arg = m.mk_app(succs[j], path);
                }
                for (unsigned k = 0; k < q->get_arity(); ++k) {
                    expr* arg = r.get_tail(j)->get_arg(k);
                    if (is_var(arg)) {
                        unsigned idx = to_var(arg)->get_idx();
                        if (!sub[idx].get()) {
                            sub[idx] = mk_arg(q, k, path_arg, trace->get_arg(j));
                        }
                    }
                }
            }
            for (unsigned j = 0, idx = 0; j < sorts.size(); ++j) {
                if (sorts[j] && !sub[j].get()) {
                    sub[j] = mk_var(r.get_decl(), sorts[j], idx++, path, trace);
                }
            }
        }

        /**
           \brief compile Horn rule into co-Horn implication.
           forall args . R(path_var, rule_i(trace_vars)) => Body[X(path_var, rule_i(trace_vars)), Y(S_j(path_var), trace_vars_j)]
        */
        void compile() {
            datatype_util dtu(m);

            rule_set::decl2rules::iterator it  = b.m_rules.begin_grouped_rules();
            rule_set::decl2rules::iterator end = b.m_rules.end_grouped_rules();
            for (; it != end; ++it) {
                func_decl* p = it->m_key;
                rule_vector const& rls = *it->m_value;

                // Assert: p_level => r1_level \/ r2_level \/ r3_level \/ ...
                // where:  r_i_level = body of rule i for level + equalities for head of rule i

                expr_ref rule_body(m), tmp(m), pred(m), trace_arg(m), fml(m);
                var_ref path_var(m), trace_var(m);
                expr_ref_vector rules(m), sub(m), conjs(m), vars(m), patterns(m);
                sort* pred_sort = m_pred2sort.find(p);
                path_var  = m.mk_var(0, m_path_sort);
                trace_var = m.mk_var(1, pred_sort);
                // sort* sorts[2] = { pred_sort, m_path_sort };
                ptr_vector<func_decl> const& cnstrs = *dtu.get_datatype_constructors(pred_sort);
                ptr_vector<func_decl> const& succs  = *dtu.get_datatype_constructors(m_path_sort);
                SASSERT(cnstrs.size() == rls.size());
                pred = m.mk_app(mk_predicate(p), trace_var.get(), path_var.get());
                for (unsigned i = 0; i < rls.size(); ++i) {
                    sub.reset();
                    conjs.reset();
                    vars.reset();
                    rule& r = *rls[i];
                    func_decl_ref rule_pred_i = mk_rule(p, i);

                    // Create cnstr_rule_i(Vars)
                    func_decl* cnstr = cnstrs[i];
                    rules.push_back(m.mk_app(rule_pred_i, trace_var.get(), path_var.get()));
                    unsigned arity = cnstr->get_arity();
                    for (unsigned j = 0; j < arity; ++j) {
                        vars.push_back(m.mk_var(arity-j,cnstr->get_domain(j)));
                    }
                    trace_arg = m.mk_app(cnstr, vars.size(), vars.c_ptr());

                    mk_subst(r, path_var, to_app(trace_arg), sub);

                    // apply substitution to body.
                    var_subst vs(m, false);
                    for (unsigned k = 0; k < p->get_arity(); ++k) {
                        vs(r.get_head()->get_arg(k), sub.size(), sub.c_ptr(), tmp);
                        expr_ref arg = mk_arg(p, k, path_var, trace_arg);
                        conjs.push_back(m.mk_eq(tmp, arg));
                    }
                    for (unsigned j = 0; j < r.get_uninterpreted_tail_size(); ++j) {
                        expr_ref path_arg(m);
                        if (j == 0) {
                            path_arg = path_var.get();
                        }
                        else {
                            path_arg = m.mk_app(succs[j], path_var.get());
                        }
                        func_decl* q = r.get_decl(j);
                        for (unsigned k = 0; k < q->get_arity(); ++k) {
                            vs(r.get_tail(j)->get_arg(k), sub.size(), sub.c_ptr(), tmp);
                            expr_ref arg = mk_arg(q, k, path_arg, vars[j].get());
                            conjs.push_back(m.mk_eq(tmp, arg));
                        }
                        func_decl_ref q_pred = mk_predicate(q);
                        conjs.push_back(m.mk_app(q_pred, vars[j].get(), path_arg));
                    }
                    for (unsigned j = r.get_uninterpreted_tail_size(); j < r.get_tail_size(); ++j) {
                        vs(r.get_tail(j), sub.size(), sub.c_ptr(), tmp);
                        conjs.push_back(tmp);
                    }
                    bool_rewriter(m).mk_and(conjs.size(), conjs.c_ptr(), rule_body);
                    ptr_vector<sort> q_sorts;
                    vector<symbol> names;
                    for (unsigned i = 0; i < vars.size(); ++i) {
                        q_sorts.push_back(m.get_sort(vars[i].get()));
                        names.push_back(symbol(i+1));
                    }
                    vars.push_back(path_var);
                    q_sorts.push_back(m.get_sort(path_var));
                    names.push_back(symbol("path"));
                    SASSERT(names.size() == q_sorts.size());
                    SASSERT(vars.size() == names.size());
                    symbol qid = r.name(), skid;
                    tmp = m.mk_app(mk_predicate(p), trace_arg.get(), path_var.get());
                    patterns.reset();
                    patterns.push_back(m.mk_pattern(to_app(tmp)));
                    fml = m.mk_implies(tmp, rule_body);
                    fml = m.mk_forall(vars.size(), q_sorts.c_ptr(), names.c_ptr(), fml, 1, qid, skid, 1, patterns.c_ptr());
                    b.assert_expr(fml);
                }
            }
        }

        void declare_datatypes() {
            rule_set::decl2rules::iterator it  = b.m_rules.begin_grouped_rules();
            rule_set::decl2rules::iterator end = b.m_rules.end_grouped_rules();
            datatype_util dtu(m);
            ptr_vector<datatype_decl> dts;

            obj_map<func_decl, unsigned> pred_idx;
            for (unsigned i = 0; it != end; ++it, ++i) {
                pred_idx.insert(it->m_key, i);
            }

            it  = b.m_rules.begin_grouped_rules();
            for (; it != end; ++it) {
                rule_vector const& rls = *it->m_value;
                func_decl* pred = it->m_key;
                ptr_vector<constructor_decl> cnstrs;
                for (unsigned i = 0; i < rls.size(); ++i) {
                    rule* r = rls[i];
                    ptr_vector<accessor_decl> accs;
                    for (unsigned j = 0; j < r->get_uninterpreted_tail_size(); ++j) {
                        func_decl* q = r->get_decl(j);
                        unsigned idx = pred_idx.find(q);
                        std::stringstream _name;
                        _name << pred->get_name() << "_" << q->get_name() << j;
                        symbol name(_name.str().c_str());
                        type_ref tr(idx);
                        accs.push_back(mk_accessor_decl(m, name, tr));
                    }
                    std::stringstream _name;
                    _name << pred->get_name() << "_" << i;
                    symbol name(_name.str().c_str());
                    _name << "?";
                    symbol is_name(_name.str().c_str());
                    cnstrs.push_back(mk_constructor_decl(name, is_name, accs.size(), accs.c_ptr()));
                }
                dts.push_back(mk_datatype_decl(dtu, pred->get_name(), 0, nullptr, cnstrs.size(), cnstrs.c_ptr()));
            }


            sort_ref_vector new_sorts(m);
            family_id dfid = m.mk_family_id("datatype");
            datatype_decl_plugin* dtp = static_cast<datatype_decl_plugin*>(m.get_plugin(dfid));
            VERIFY (dtp->mk_datatypes(dts.size(), dts.c_ptr(), 0, nullptr, new_sorts));

            it  = b.m_rules.begin_grouped_rules();
            for (unsigned i = 0; it != end; ++it, ++i) {
                m_pred2sort.insert(it->m_key, new_sorts[i].get());
                m_sort2pred.insert(new_sorts[i].get(), it->m_key);
                m_pinned.push_back(new_sorts[i].get());
            }
            if (new_sorts.size() > 0) {
                TRACE("bmc", dtu.display_datatype(new_sorts[0].get(), tout););
            }
            del_datatype_decls(dts.size(), dts.c_ptr());

            // declare path data-type.
            {
                new_sorts.reset();
                dts.reset();
                ptr_vector<constructor_decl> cnstrs;
                unsigned max_arity = 0;
                rule_set::iterator it  = b.m_rules.begin();
                rule_set::iterator end = b.m_rules.end();
                for (; it != end; ++it) {
                    rule* r = *it;
                    unsigned sz = r->get_uninterpreted_tail_size();
                    max_arity = std::max(sz, max_arity);
                }
                cnstrs.push_back(mk_constructor_decl(symbol("Z#"), symbol("Z#?"), 0, nullptr));

                for (unsigned i = 0; i + 1 < max_arity; ++i) {
                    std::stringstream _name;
                    _name << "succ#" << i;
                    symbol name(_name.str().c_str());
                    _name << "?";
                    symbol is_name(_name.str().c_str());
                    std::stringstream _name2;
                    _name2 << "get_succ#" << i;
                    ptr_vector<accessor_decl> accs;
                    type_ref tr(0);
                    accs.push_back(mk_accessor_decl(m, name, tr));
                    cnstrs.push_back(mk_constructor_decl(name, is_name, accs.size(), accs.c_ptr()));
                }
                dts.push_back(mk_datatype_decl(dtu, symbol("Path"), 0, nullptr, cnstrs.size(), cnstrs.c_ptr()));
                VERIFY (dtp->mk_datatypes(dts.size(), dts.c_ptr(), 0, nullptr, new_sorts));
                m_path_sort = new_sorts[0].get();
            }
        }

        proof_ref get_proof(model_ref& md, app* trace, app* path) {
            datatype_util dtu(m);
            rule_manager& rm = b.m_ctx.get_rule_manager();
            sort* trace_sort = m.get_sort(trace);
            func_decl* p = m_sort2pred.find(trace_sort);
            datalog::rule_vector const& rules = b.m_rules.get_predicate_rules(p);
            ptr_vector<func_decl> const& cnstrs = *dtu.get_datatype_constructors(trace_sort);
            ptr_vector<func_decl> const& succs  = *dtu.get_datatype_constructors(m_path_sort);
            for (unsigned i = 0; i < cnstrs.size(); ++i) {
                if (trace->get_decl() == cnstrs[i]) {
                    svector<std::pair<unsigned, unsigned> > positions;
                    scoped_proof _sc(m);
                    proof_ref_vector prs(m);
                    expr_ref_vector sub(m);
                    vector<expr_ref_vector> substs;
                    proof_ref pr(m);
                    expr_ref fml(m), head(m), tmp(m);
                    app_ref path1(m);

                    var_subst vs(m, false);
                    mk_subst(*rules[i], path, trace, sub);
                    rm.to_formula(*rules[i], fml);
                    prs.push_back(rules[i]->get_proof());
                    unsigned sz = trace->get_num_args();
                    if (sub.empty() && sz == 0) {
                        pr = prs[0].get();
                        return pr;
                    }
                    for (unsigned j = 0; j < sub.size(); ++j) {
                        sub[j] = (*md)(sub.get(j));
                    }
                    rule_ref rl(b.m_ctx.get_rule_manager());
                    rl = rules[i];
                    b.m_ctx.get_rule_manager().substitute(rl, sub.size(), sub.c_ptr());

                    substs.push_back(sub);

                    for (unsigned j = 0; j < sz; ++j) {
                        if (j == 0) {
                            path1 = path;
                        }
                        else {
                            path1 = m.mk_app(succs[j], path);
                        }

                        prs.push_back(get_proof(md, to_app(trace->get_arg(j)), path1));
                        positions.push_back(std::make_pair(j+1,0));
                        substs.push_back(expr_ref_vector(m));
                    }
                    head = rl->get_head();
                    pr = m.mk_hyper_resolve(sz+1, prs.c_ptr(), head, positions, substs);
                    b.m_rule_trace.push_back(rl.get());
                    return pr;
                }
            }
            UNREACHABLE();
            return proof_ref(nullptr, m);
        }

        // instantiation of algebraic data-types takes care of the rest.
        lbool check_query() {
            sort* trace_sort = m_pred2sort.find(b.m_query_pred);
            func_decl_ref q = mk_predicate(b.m_query_pred);
            expr_ref trace(m), path(m), fml(m);
            trace = m.mk_const(symbol("trace"), trace_sort);
            path  = m.mk_const(symbol("path"), m_path_sort);
            fml = m.mk_app(q, trace.get(), path.get());
            b.assert_expr(fml);
            while (true) {
                lbool is_sat = b.m_solver.check();
                model_ref md;
                if (is_sat == l_false) {
                    return is_sat;
                }
                b.m_solver.get_model(md);
                mk_answer(md, trace, path);
                return l_true;
            }
        }

        bool check_model(model_ref& md, expr* trace) {
            expr_ref trace_val(m), eq(m);
            trace_val = (*md)(trace);
            eq = m.mk_eq(trace, trace_val);
            b.m_solver.push();
            b.m_solver.assert_expr(eq);
            lbool is_sat = b.m_solver.check();
            if (is_sat != l_false) {
                b.m_solver.get_model(md);
            }
            b.m_solver.pop(1);
            if (is_sat == l_false) {
                IF_VERBOSE(1, verbose_stream() << "infeasible trace " << mk_pp(trace_val, m) << "\n";);
                eq = m.mk_not(eq);
                b.assert_expr(eq);
            }
            return is_sat != l_false;
        }

        void mk_answer(model_ref& md, expr_ref& trace, expr_ref& path) {
            IF_VERBOSE(2, model_smt2_pp(verbose_stream(), m, *md, 0););
            trace = (*md)(trace);
            path = (*md)(path);
            IF_VERBOSE(2, verbose_stream() << mk_pp(trace, m) << "\n";
                       for (unsigned i = 0; i < b.m_solver.size(); ++i) {
                           verbose_stream() << mk_pp(b.m_solver.get_formula(i), m) << "\n";
                       });
            scoped_proof _sp(m);
            proof_ref pr(m);
            pr = get_proof(md, to_app(trace), to_app(path));
            apply(m, b.m_ctx.get_proof_converter().get(), pr);
            b.m_answer = pr;
        }

    };

    // --------------------------------------------------------------------------
    // Basic linear BMC based on incrementally unfolding the transition relation.

    class bmc::linear {
        bmc&         b;
        ast_manager& m;

    public:
        linear(bmc& b): b(b), m(b.m) {}

        lbool check() {
            setup();
            unsigned max_depth = b.m_ctx.get_params().bmc_linear_unrolling_depth();
            for (unsigned i = 0; i < max_depth; ++i) {
                IF_VERBOSE(1, verbose_stream() << "level: " << i << "\n";);
                b.checkpoint();
                compile(i);
                lbool res = check(i);
                if (res == l_undef) {
                    return res;
                }
                if (res == l_true) {
                    get_model(i);
                    return res;
                }
            }
            return l_undef;
        }

    private:

        void get_model(unsigned level) {
            if (m.canceled()) {
                return;
            }
            rule_manager& rm = b.m_ctx.get_rule_manager();
            expr_ref level_query = mk_level_predicate(b.m_query_pred, level);
            model_ref md;
            proof_ref pr(m);
            rule_unifier unifier(b.m_ctx);
            b.m_solver.get_model(md);
            func_decl* pred = b.m_query_pred;
            SASSERT(m.is_true(md->get_const_interp(to_app(level_query)->get_decl())));

            TRACE("bmc", model_smt2_pp(tout, m, *md, 0););

            rule_ref r0(rm), r1(rm), r2(rm);
            while (true) {
                TRACE("bmc", tout << "Predicate: " << pred->get_name() << "\n";);
                expr_ref_vector sub(m);
                rule_vector const& rls = b.m_rules.get_predicate_rules(pred);
                rule* r = nullptr;
                unsigned i = 0;
                for (; i < rls.size(); ++i) {
                    expr_ref rule_i = mk_level_rule(pred, i, level);
                    TRACE("bmc", rls[i]->display(b.m_ctx, tout << "Checking rule " << mk_pp(rule_i, m) << " "););
                    if (m.is_true(md->get_const_interp(to_app(rule_i)->get_decl()))) {
                        r = rls[i];
                        break;
                    }
                }
                SASSERT(r);
                b.m_rule_trace.push_back(r);
                mk_rule_vars(*r, level, i, sub);
                // we have rule, we have variable names of rule.

                // extract values for the variables in the rule.
                for (unsigned j = 0; j < sub.size(); ++j) {
                    expr* vl = md->get_const_interp(to_app(sub[j].get())->get_decl());
                    if (vl) {
                        // vl can be 0 if the interpretation does not assign a value to it.
                        sub[j] = vl;
                    }
                    else {
                        sub[j] = m.mk_var(j, m.get_sort(sub[j].get()));
                    }
                }
                svector<std::pair<unsigned, unsigned> > positions;
                vector<expr_ref_vector> substs;
                expr_ref fml(m), concl(m);

                rm.to_formula(*r, fml);
                r2 = r;
                rm.substitute(r2, sub.size(), sub.c_ptr());
                proof_ref p(m);
                {
                    scoped_proof _sp(m);
                    p = r->get_proof();
                    if (!p) {
                        p = m.mk_asserted(fml);
                    }
                }

                if (r0) {
                    VERIFY(unifier.unify_rules(*r0.get(), 0, *r2.get()));
                    expr_ref_vector sub1 = unifier.get_rule_subst(*r0.get(), true);
                    expr_ref_vector sub2 = unifier.get_rule_subst(*r2.get(), false);
                    apply_subst(sub, sub2);
                    unifier.apply(*r0.get(), 0, *r2.get(), r1);
                    rm.to_formula(*r1.get(), concl);

                    scoped_proof _sp(m);
                    proof* premises[2] = { pr, p };

                    positions.push_back(std::make_pair(0, 1));

                    substs.push_back(sub1);
                    substs.push_back(sub);
                    pr = m.mk_hyper_resolve(2, premises, concl, positions, substs);
                    r0 = r1;
                }
                else {
                    rm.to_formula(*r2.get(), concl);
                    scoped_proof _sp(m);
                    if (sub.empty()) {
                        pr = p;
                    }
                    else {
                        substs.push_back(sub);
                        proof * ps[1] = { p };
                        pr = m.mk_hyper_resolve(1, ps, concl, positions, substs);
                    }
                    r0 = r2;
                }

                if (level == 0) {
                    SASSERT(r->get_uninterpreted_tail_size() == 0);
                    break;
                }
                --level;
                SASSERT(r->get_uninterpreted_tail_size() == 1);
                pred = r->get_decl(0);
            }
            scoped_proof _sp(m);
            apply(m, b.m_ctx.get_proof_converter().get(), pr);
            b.m_answer = pr;
        }


        void setup() {
            b.m_fparams.m_relevancy_lvl = 0;
            b.m_fparams.m_model = true;
            b.m_fparams.m_model_compact = true;
            b.m_fparams.m_mbqi = false;
            // m_fparams.m_auto_config = false;
            b.m_rule_trace.reset();
        }


        lbool check(unsigned level) {
            expr_ref level_query = mk_level_predicate(b.m_query_pred, level);
            expr* q = level_query.get();
            return b.m_solver.check(1, &q);
        }

        expr_ref mk_level_predicate(func_decl* p, unsigned level) {
            return mk_level_predicate(p->get_name(), level);
        }

        expr_ref mk_level_predicate(symbol const& name, unsigned level) {
            std::stringstream _name;
            _name << name << "#" << level;
            symbol nm(_name.str().c_str());
            return expr_ref(m.mk_const(nm, m.mk_bool_sort()), m);
        }

        expr_ref mk_level_arg(func_decl* pred, unsigned idx, unsigned level) {
            SASSERT(idx < pred->get_arity());
            std::stringstream _name;
            _name << pred->get_name() << "#" << level << "_" << idx;
            symbol nm(_name.str().c_str());
            return expr_ref(m.mk_const(nm, pred->get_domain(idx)), m);
        }

        expr_ref mk_level_var(func_decl* pred, sort* s, unsigned rule_id, unsigned idx, unsigned level) {
            std::stringstream _name;
            _name << pred->get_name() << "#" << level << "_" << rule_id << "_" << idx;
            symbol nm(_name.str().c_str());
            return expr_ref(m.mk_const(nm, s), m);
        }

        expr_ref mk_level_rule(func_decl* p, unsigned rule_idx, unsigned level) {
            std::stringstream _name;
            _name << "rule:" << p->get_name() << "#" << level << "_" << rule_idx;
            symbol nm(_name.str().c_str());
            return expr_ref(m.mk_const(nm, m.mk_bool_sort()), m);
        }

        void mk_rule_vars(rule& r, unsigned level, unsigned rule_id, expr_ref_vector& sub) {
            ptr_vector<sort> sorts;
            r.get_vars(m, sorts);
            // populate substitution of bound variables.
            sub.reset();
            sub.resize(sorts.size());

            for (unsigned k = 0; k < r.get_decl()->get_arity(); ++k) {
                expr* arg = r.get_head()->get_arg(k);
                if (is_var(arg)) {
                    unsigned idx = to_var(arg)->get_idx();
                    if (!sub[idx].get()) {
                        sub[idx] = mk_level_arg(r.get_decl(), k, level);
                    }
                }
            }
            for (unsigned j = 0; j < r.get_uninterpreted_tail_size(); ++j) {
                SASSERT(level > 0);
                func_decl* q = r.get_decl(j);
                for (unsigned k = 0; k < q->get_arity(); ++k) {
                    expr* arg = r.get_tail(j)->get_arg(k);
                    if (is_var(arg)) {
                        unsigned idx = to_var(arg)->get_idx();
                        if (!sub[idx].get()) {
                            sub[idx] = mk_level_arg(q, k, level-1);
                        }
                    }
                }
            }
            for (unsigned j = 0, idx = 0; j < sorts.size(); ++j) {
                if (sorts[j] && !sub[j].get()) {
                    sub[j] = mk_level_var(r.get_decl(), sorts[j], rule_id, idx++, level);
                }
            }
        }

        void compile(unsigned level) {
            rule_set::decl2rules::iterator it  = b.m_rules.begin_grouped_rules();
            rule_set::decl2rules::iterator end = b.m_rules.end_grouped_rules();
            for (; it != end; ++it) {
                func_decl* p = it->m_key;
                rule_vector const& rls = *it->m_value;

                // Assert: p_level => r1_level \/ r2_level \/ r3_level \/ ...
                // Assert: r_i_level => body of rule i for level + equalities for head of rule i

                expr_ref level_pred = mk_level_predicate(p, level);
                expr_ref_vector rules(m), sub(m), conjs(m);
                expr_ref rule_body(m), tmp(m);
                for (unsigned i = 0; i < rls.size(); ++i) {
                    sub.reset();
                    conjs.reset();
                    rule& r = *rls[i];
                    expr_ref rule_i = mk_level_rule(p, i, level);
                    rules.push_back(rule_i);
                    if (level == 0 && r.get_uninterpreted_tail_size() > 0) {
                        tmp = m.mk_not(rule_i);
                        b.assert_expr(tmp);
                        continue;
                    }

                    mk_rule_vars(r, level, i, sub);

                    // apply substitution to body.
                    var_subst vs(m, false);
                    for (unsigned k = 0; k < p->get_arity(); ++k) {
                        vs(r.get_head()->get_arg(k), sub.size(), sub.c_ptr(), tmp);
                        conjs.push_back(m.mk_eq(tmp, mk_level_arg(p, k, level)));
                    }
                    for (unsigned j = 0; j < r.get_uninterpreted_tail_size(); ++j) {
                        SASSERT(level > 0);
                        func_decl* q = r.get_decl(j);
                        for (unsigned k = 0; k < q->get_arity(); ++k) {
                            vs(r.get_tail(j)->get_arg(k), sub.size(), sub.c_ptr(), tmp);
                            conjs.push_back(m.mk_eq(tmp, mk_level_arg(q, k, level-1)));
                        }
                        conjs.push_back(mk_level_predicate(q, level-1));
                    }
                    for (unsigned j = r.get_uninterpreted_tail_size(); j < r.get_tail_size(); ++j) {
                        vs(r.get_tail(j), sub.size(), sub.c_ptr(), tmp);
                        conjs.push_back(tmp);
                    }
                    bool_rewriter(m).mk_and(conjs.size(), conjs.c_ptr(), rule_body);
                    rule_body = m.mk_implies(rule_i, rule_body);
                    b.assert_expr(rule_body);
                }
                bool_rewriter(m).mk_or(rules.size(), rules.c_ptr(), tmp);
                tmp = m.mk_implies(level_pred, tmp);
                b.assert_expr(tmp);
            }
        }
    };

    bmc::bmc(context& ctx):
        engine_base(ctx.get_manager(), "bmc"),
        m_ctx(ctx),
        m(ctx.get_manager()),
        m_solver(m, m_fparams),
        m_rules(ctx),
        m_query_pred(m),
        m_answer(m),
        m_rule_trace(ctx.get_rule_manager()) {
    }

    bmc::~bmc() {}

    lbool bmc::query(expr* query) {
        m_solver.reset();
        m_answer = nullptr;
        m_ctx.ensure_opened();
        m_rules.reset();
        datalog::rule_manager& rule_manager = m_ctx.get_rule_manager();
        rule_set& rules0 = m_ctx.get_rules();
        datalog::rule_set old_rules(rules0);
        rule_manager.mk_query(query, rules0);
        expr_ref bg_assertion = m_ctx.get_background_assertion();
        apply_default_transformation(m_ctx);

        if (m_ctx.xform_slice()) {
            datalog::rule_transformer transformer(m_ctx);
            datalog::mk_slice* slice = alloc(datalog::mk_slice, m_ctx);
            transformer.register_plugin(slice);
            m_ctx.transform_rules(transformer);
        }

        const rule_set& rules = m_ctx.get_rules();
        if (rules.get_output_predicates().empty()) {
            return l_false;
        }

        m_query_pred = rules.get_output_predicate();
        m_rules.replace_rules(rules);
        m_rules.close();
        m_ctx.reopen();
        m_ctx.replace_rules(old_rules);

        checkpoint();

        IF_VERBOSE(2, m_ctx.display_rules(verbose_stream()););

        if (m_rules.get_num_rules() == 0) {
            return l_false;
        }
        if (m_rules.get_predicate_rules(m_query_pred).empty()) {
            return l_false;
        }


        if (is_linear()) {
            if (m_ctx.get_engine() == QBMC_ENGINE) {
                qlinear ql(*this);
                return ql.check();
            }
            else {
                linear lin(*this);
                return lin.check();
            }
        }
        else {
            IF_VERBOSE(0, verbose_stream() << "WARNING: non-linear BMC is highly inefficient\n";);
            nonlinear nl(*this);
            return nl.check();
        }
    }

    void bmc::assert_expr(expr* e) {
        TRACE("bmc", tout << mk_pp(e, m) << "\n";);
        m_solver.assert_expr(e);
    }

    bool bmc::is_linear() const {
        unsigned sz = m_rules.get_num_rules();
        for (unsigned i = 0; i < sz; ++i) {
            if (m_rules.get_rule(i)->get_uninterpreted_tail_size() > 1) {
                return false;
            }
            if (m_rules.get_rule_manager().has_quantifiers(*m_rules.get_rule(i))) {
                return false;
            }
        }
        return true;
    }

    void bmc::checkpoint() {
        if (m.canceled()) {
            throw default_exception(Z3_CANCELED_MSG);
        }
    }

    void bmc::display_certificate(std::ostream& out) const {
        out << mk_pp(m_answer, m) << "\n";
    }

    void bmc::collect_statistics(statistics& st) const {
        m_solver.collect_statistics(st);
    }

    void bmc::reset_statistics() {
        m_solver.reset_statistics();
    }

    expr_ref bmc::get_answer() {
        return m_answer;
    }

    void bmc::get_rules_along_trace(datalog::rule_ref_vector& rules) {
        rules.append(m_rule_trace);
    }

    void bmc::compile(rule_set const& rules, expr_ref_vector& fmls, unsigned level) {
        nonlinear nl(*this);
        nl.compile(rules, fmls, level);
    }

    expr_ref bmc::compile_query(func_decl* query_pred, unsigned level) {
        nonlinear nl(*this);
        return nl.compile_query(query_pred, level);
    }

};

template class rewriter_tpl<datalog::bmc::nonlinear::level_replacer_cfg>;