z3-src 500.0.0

Source distribution of the Z3 SMT solver, for use as a build dependency
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

/*++
Copyright (c) 2020 Microsoft Corporation

Module Name:

    specrel_solver.h

Abstract:

    Theory plugin for special relations

Author:

    Nikolaj Bjorner (nbjorner) 2020-09-08

--*/

#include "sat/smt/specrel_solver.h"
#include "sat/smt/euf_solver.h"
#include "ast/euf/euf_specrel_plugin.h"

namespace euf {
    class solver;
}

namespace specrel {

    solver::solver(euf::solver& ctx, theory_id id) :
        th_euf_solver(ctx, ctx.get_manager().get_family_name(id), id),
        sp(m)
    {
        ctx.get_egraph().add_plugin(alloc(euf::specrel_plugin, ctx.get_egraph()));
    }

    void solver::asserted(sat::literal l) {

    }

    sat::check_result solver::check() {
        return sat::check_result::CR_DONE;
    }

    std::ostream& solver::display(std::ostream& out) const {
        return out;
    }

    void solver::collect_statistics(statistics& st) const {
    }

    euf::th_solver* solver::clone(euf::solver& ctx) {
        return alloc(solver, ctx, get_id());
    }

    void solver::new_eq_eh(euf::th_eq const& eq) {    
        TRACE(specrel, tout << "new-eq\n");
        if (eq.is_eq()) {
            auto* p = ctx.get_egraph().get_plugin(sp.get_family_id());
            p->merge_eh(var2enode(eq.v1()), var2enode(eq.v2()));
            TRACE(specrel, tout << eq.v1() << " " << eq.v2() << "\n");                       
        }
    }

    void solver::add_value(euf::enode* n, model& mdl, expr_ref_vector& values) {        
    }

    bool solver::add_dep(euf::enode* n, top_sort<euf::enode>& dep) {
        return false;
    }

    bool solver::include_func_interp(func_decl* f) const {
        return false;
    }

    sat::literal solver::internalize(expr* e, bool sign, bool root) {
        if (!visit_rec(m, e, sign, root))
            return sat::null_literal;
        auto lit = ctx.expr2literal(e);
        if (sign)
            lit.neg();
        return lit;
    }

    void solver::internalize(expr* e) {
        visit_rec(m, e, false, false);
    }

    bool solver::visit(expr* e) {
        if (visited(e))
            return true;
        m_stack.push_back(sat::eframe(e));
        return false;
    }

    bool solver::visited(expr* e) {
        euf::enode* n = expr2enode(e);
        return n && n->is_attached_to(get_id());
    }

    bool solver::post_visit(expr* term, bool sign, bool root) {
        euf::enode* n = expr2enode(term);
        SASSERT(!n || !n->is_attached_to(get_id()));
        if (!n)
            n = mk_enode(term);
        SASSERT(!n->is_attached_to(get_id()));
        mk_var(n);
        TRACE(specrel, tout << ctx.bpp(n) << "\n");
        return true;
    }

    euf::theory_var solver::mk_var(euf::enode* n) {
        if (is_attached_to_var(n))
            return n->get_th_var(get_id());
        euf::theory_var r = th_euf_solver::mk_var(n);
        ctx.attach_th_var(n, this, r);
        return r;
    }
}