C++ expr_ref::get_manager方法代码示例

    br_status dl_rewriter::mk_app_core(
        func_decl * f, unsigned num_args, expr* const* args, expr_ref& result) {
        ast_manager& m = result.get_manager();
        uint64 v1, v2;
        switch(f->get_decl_kind()) {
		case datalog::OP_DL_LT:
            if (m_util.is_numeral_ext(args[0], v1) &&
                m_util.is_numeral_ext(args[1], v2)) {
                result = (v1 < v2)?m.mk_true():m.mk_false();
                return BR_DONE;
            }
            // x < x <=> false
            if (args[0] == args[1]) {
                result = m.mk_false();
                return BR_DONE;
            }
            // x < 0 <=> false
            if (m_util.is_numeral_ext(args[1], v2) && v2 == 0) {
                result = m.mk_false();
                return BR_DONE;
            }
            // 0 < x <=> 0 != x
            if (m_util.is_numeral_ext(args[1], v1) && v1 == 0) {
                result = m.mk_not(m.mk_eq(args[0], args[1]));
                return BR_DONE;
            }
            break;

        default:
            break;
        }
        return BR_FAILED;
    }

    bool push_toplevel_junction_negation_inside(expr_ref& e)
    {
        ast_manager& m = e.get_manager();
        bool_rewriter brwr(m);

        expr * arg;
        if(!m.is_not(e, arg)) { return false; }
        bool is_and = m.is_and(arg);
        if(!is_and && !m.is_or(arg)) { return false; }

        //now we know we have formula we need to transform
        app * junction = to_app(arg);
        expr_ref_vector neg_j_args(m);
        unsigned num_args = junction->get_num_args();
        for(unsigned i=0; i<num_args; ++i) {
            expr_ref neg_j_arg(m);
            brwr.mk_not(junction->get_arg(i), neg_j_arg);
            neg_j_args.push_back(neg_j_arg);
        }
        if(is_and) {
            brwr.mk_or(neg_j_args.size(), neg_j_args.c_ptr(), e);
        }
        else {
            brwr.mk_and(neg_j_args.size(), neg_j_args.c_ptr(), e);
        }
        return true;
    }

 void udoc_relation::to_formula(expr_ref& fml) const {
     ast_manager& m = fml.get_manager();
     expr_ref_vector disj(m);
     for (unsigned i = 0; i < m_elems.size(); ++i) {
         disj.push_back(to_formula(m_elems[i]));
     }
     fml = mk_or(m, disj.size(), disj.c_ptr());
 }

void label_rewriter::remove_labels(expr_ref& fml, proof_ref& pr) {
    ast_manager& m = fml.get_manager();
    expr_ref tmp(m);
    m_rwr(fml, tmp);
    if (pr && fml != tmp) {        
        pr = m.mk_modus_ponens(pr, m.mk_rewrite(fml, tmp));
    }
    fml = tmp;
}

static void parse_fml(char const* str, app_ref_vector& vars, expr_ref& fml) {
    ast_manager& m = fml.get_manager();
    fml = parse_fml(m, str);
    if (is_exists(fml)) {
        quantifier* q = to_quantifier(fml);
        for (unsigned i = 0; i < q->get_num_decls(); ++i) {
            vars.push_back(m.mk_const(q->get_decl_name(i), q->get_decl_sort(i)));
        }
        fml = q->get_expr();
        var_subst vs(m, true);
        vs(fml, vars.size(), (expr*const*)vars.c_ptr(), fml);
    }
}

 void sieve_relation::to_formula(expr_ref& fml) const {
     ast_manager& m = fml.get_manager();
     expr_ref_vector s(m);
     expr_ref tmp(m);
     relation_signature const& sig = get_inner().get_signature();
     unsigned sz = sig.size();
     for (unsigned i = sz ; i > 0; ) {
         --i;
         unsigned idx = m_inner2sig[i];
         s.push_back(m.mk_var(idx, sig[i]));
     }
     get_inner().to_formula(tmp);
     get_plugin().get_context().get_var_subst()(tmp, sz, s.c_ptr(), fml);
 }

static void test(app* var, expr_ref& fml) {

    ast_manager& m = fml.get_manager();
    smt_params params;
    params.m_model = true;

    symbol x_name(var->get_decl()->get_name());   
    sort* x_sort = m.get_sort(var);

    expr_ref pr(m);
    expr_ref_vector lits(m);
    flatten_and(fml, lits);

    model_ref md;
    {
        smt::context ctx(m, params);
        ctx.assert_expr(fml);
        lbool result = ctx.check();
        if (result != l_true) return;
        ctx.get_model(md);
    }    
    VERIFY(qe::arith_project(*md, var, lits));
    pr = mk_and(lits);
   
    std::cout << "original:  " << mk_pp(fml, m) << "\n";
    std::cout << "projected: " << mk_pp(pr,  m) << "\n";

    // projection is consistent with model.
    VERIFY(md->is_true(pr));

    // projection implies E x. fml
    {
        qe::expr_quant_elim qelim(m, params);
        expr_ref result(m), efml(m);
        expr* x = var;
        expr_abstract(m, 0, 1, &x, fml, efml);
        efml = m.mk_exists(1, &x_sort, &x_name, efml);
        qelim(m.mk_true(), efml, result);

        smt::context ctx(m, params);
        ctx.assert_expr(pr);
        ctx.assert_expr(m.mk_not(result));
        std::cout << "exists: " << pr << " =>\n" << result << "\n";
        VERIFY(l_false == ctx.check());
    }    

    std::cout << "\n";
}

 void table_base::to_formula(relation_signature const& sig, expr_ref& fml) const {
     // iterate over rows and build disjunction
     ast_manager & m = fml.get_manager();
     expr_ref_vector disjs(m);
     expr_ref_vector conjs(m);
     dl_decl_util util(m);
     bool_rewriter brw(m);
     table_fact fact;
     iterator it = begin();
     iterator iend = end();
     for(; it != iend; ++it) {
         const row_interface & r = *it;   
         r.get_fact(fact);
         conjs.reset();
         for (unsigned i = 0; i < fact.size(); ++i) {
             conjs.push_back(m.mk_eq(m.mk_var(i, sig[i]), util.mk_numeral(fact[i], sig[i])));
         }
         brw.mk_and(conjs.size(), conjs.c_ptr(), fml);
         disjs.push_back(fml);
     }
     brw.mk_or(disjs.size(), disjs.c_ptr(), fml);        
 }