z3-src 415.4.4

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

/*++
Copyright (c) 2022 Microsoft Corporation

Module Name:

    opt_cores.h

Abstract:
   
    "walk" subsets of soft constraints to extract multiple cores and satisfying assignments.

Author:

    Nikolaj Bjorner (nbjorner) 2022-04-27

--*/

#pragma once
#include "opt/opt_lns.h"

namespace opt {


    class cores {
        ast_manager&     m;
        solver&          s;
        lns_context&     ctx;

        random_gen               m_rand;
        rational                 m_best_cost = rational::minus_one();
        vector<weighted_core>    m_cores;
        obj_map<expr, rational>  m_weight;

        unsigned m_max_saturate_conflicts = 500;
        unsigned m_max_conflicts          = 1000;
        bool     m_hill_climb             = true;
        unsigned m_max_num_cores          = UINT_MAX;
        unsigned m_max_core_size          = 4;
        bool     m_enable_core_rotate     = false;

        struct scoped_update;

        bool improve();
        void rotate_rec(obj_hashtable<expr> const& mss, obj_map<expr, ptr_vector<expr>>& backbone2core, unsigned depth);
        bool rotate(obj_hashtable<expr> const& mss, expr* excl, unsigned depth);
        void saturate_core(expr_ref_vector& core);
        void local_mss();
        void hitting_set(obj_hashtable<expr>& hs);
        rational core_weight(expr_ref_vector const& core) { return core_weight(core.size(), core.data()); }
        rational core_weight(ptr_vector<expr> const& core) { return core_weight(core.size(), core.data()); }
        rational core_weight(unsigned sz, expr* const* core);
        lbool check_sat_hill_climb(expr_ref_vector const& _soft);

        void add_core(expr_ref_vector const& core);

        vector<weighted_core> const& disjoint_cores();

        void rotate_cores();

        vector<weighted_core> const& weighted_disjoint_cores();

        expr_ref_vector unsat_core();

    public:
        cores(solver& s, lns_context& ctx);
        
        vector<weighted_core> const& operator()();

        void updt_params(params_ref& p);
    };
};