z3-src 501.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

/*++
Copyright (c) 2006 Microsoft Corporation

Module Name:

    arith_eq_adapter.h

Abstract:

    <abstract>

Author:

    Leonardo de Moura (leonardo) 2008-05-25.

Revision History:

--*/
#pragma once

#include "smt/smt_theory.h"
#include "util/obj_pair_hashtable.h"
#include "ast/arith_decl_plugin.h"
#include "util/statistics.h"

namespace smt {

    struct arith_eq_adapter_stats {
        unsigned m_num_eq_axioms;
        void reset() { m_num_eq_axioms = 0; }
        arith_eq_adapter_stats() { reset(); }
    };

    /**
       \brief Auxiliary class used to convert (dis) equalities
       propagated from the core into arith equalities/inequalities
       atoms. This class is used by the arithmetic theories to 
       handle the (dis) equalities propagated from the logical context.
      
       - config 1:
         recreate axioms at restart

       - config 2:
         lazy diseq split
    */
    class arith_eq_adapter {
    public:
        arith_eq_adapter_stats           m_stats;

    private:
        struct data {
            expr * m_t1_eq_t2;
            expr * m_le;
            expr * m_ge;
            data():m_t1_eq_t2(nullptr), m_le(nullptr), m_ge(nullptr) {}
            data(expr * t1_eq_t2, expr * le, expr * ge):m_t1_eq_t2(t1_eq_t2), m_le(le), m_ge(ge) {}
        };

    public:
        typedef obj_pair_map<enode, enode, data> already_processed; 
        
    private:
        theory &                         m_owner;
        arith_util &                     m_util;

        already_processed                m_already_processed;
        enode_pair_vector                m_restart_pairs;
        svector<parameter>               m_proof_hint;

        context & get_context() const { return m_owner.get_context(); }
        ast_manager & get_manager() const { return m_owner.get_manager(); }
        enode * get_enode(theory_var v) const { return m_owner.get_enode(v); }
        expr * get_expr(theory_var v) const { return m_owner.get_expr(v); }

    public:
        arith_eq_adapter(theory & owner, arith_util & u):m_owner(owner), m_util(u) {}
        void new_eq_eh(theory_var v1, theory_var v2);
        void new_diseq_eh(theory_var v1, theory_var v2);
        void reset_eh();
        void init_search_eh();
        void restart_eh();
        /**
           \brief Add the eq axioms for n1 and n2. 
        */
        void mk_axioms(enode * n1, enode * n2);
        void collect_statistics(::statistics & st) const;
        void display_already_processed(std::ostream & out) const;
    };
}