Skip to content

Commit ac34dbd

Browse files
levnachlevnach
committed
consolidate throttling
1 parent 727dfd2 commit ac34dbd

6 files changed

Lines changed: 81 additions & 89 deletions

File tree

‎src/math/lp/nla_monotone_lemmas.cpp‎

Lines changed: 1 addition & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -7,30 +7,9 @@
77
--*/
88
#include "math/lp/nla_basics_lemmas.h"
99
#include "math/lp/nla_core.h"
10-
#include "util/trail.h"
1110
namespace nla {
1211

1312
monotone::monotone(core * c) : common(c) {}
14-
15-
bool monotone::throttle_monotone(const monic& m, bool is_lt) {
16-
// Check if throttling is enabled
17-
if (!c().params().arith_nl_thrl())
18-
return false;
19-
20-
// Create the key for this specific monotonicity_lemma invocation
21-
monotone_key key(m.var(), is_lt);
22-
23-
// Check if this combination has already been processed
24-
if (m_processed_monotone.contains(key)) {
25-
TRACE(nla_solver, tout << "throttled monotonicity_lemma\n";);
26-
return true;
27-
}
28-
29-
// Mark this combination as processed and add to trail for backtracking
30-
m_processed_monotone.insert(key);
31-
c().trail().push(insert_map(m_processed_monotone, key));
32-
return false;
33-
}
3413

3514
void monotone::monotonicity_lemma() {
3615
unsigned shift = random();
@@ -52,7 +31,7 @@ void monotone::monotonicity_lemma(monic const& m) {
5231
bool is_lt = m_val < prod_val;
5332

5433
// Check if this specific combination should be throttled
55-
if (throttle_monotone(m, is_lt))
34+
if (c().throttle().insert_new(nla_throttle::MONOTONE_LEMMA, m.var(), is_lt))
5635
return;
5736

5837
if (is_lt)

‎src/math/lp/nla_monotone_lemmas.h‎

Lines changed: 0 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -6,8 +6,6 @@
66
Nikolaj Bjorner (nbjorner)
77
--*/
88
#pragma once
9-
#include "util/hashtable.h"
10-
#include "util/hash.h"
119

1210
namespace nla {
1311
class core;
@@ -16,33 +14,7 @@ namespace nla {
1614
monotone(core *core);
1715
void monotonicity_lemma();
1816

19-
// Structure to represent the key parameters for throttling monotonicity_lemma
20-
struct monotone_key {
21-
short mvar;
22-
bool is_lt;
23-
24-
// Default constructor for hashtable
25-
monotone_key() : mvar(0), is_lt(false) {}
26-
27-
monotone_key(lpvar mvar, bool is_lt)
28-
: mvar(static_cast<short>(mvar)), is_lt(is_lt) {}
29-
30-
bool operator==(const monotone_key& other) const {
31-
return mvar == other.mvar && is_lt == other.is_lt;
32-
}
33-
};
34-
35-
struct monotone_key_hash {
36-
unsigned operator()(const monotone_key& k) const {
37-
return combine_hash(static_cast<unsigned>(k.mvar),
38-
static_cast<unsigned>(k.is_lt));
39-
}
40-
};
41-
4217
private:
43-
hashtable<monotone_key, monotone_key_hash, default_eq<monotone_key>> m_processed_monotone;
44-
bool throttle_monotone(const monic& m, bool is_lt);
45-
4618
void monotonicity_lemma(monic const& m);
4719
void monotonicity_lemma_gt(const monic& m);
4820
void monotonicity_lemma_lt(const monic& m);

‎src/math/lp/nla_tangent_lemmas.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -70,6 +70,9 @@ class tangent_imp {
7070
}
7171

7272
void generate_plane(const point & pl) {
73+
if (c().throttle().insert_new(nla_throttle::TANGENT_LEMMA, m_j, m_jx, m_jy, m_below))
74+
return;
75+
7376
lemma_builder lemma(c(), "generate tangent plane");
7477
c().negate_relation(lemma, m_jx, m_x.rat_sign()*pl.x);
7578
c().negate_relation(lemma, m_jy, m_y.rat_sign()*pl.y);

‎src/math/lp/nla_throttle.cpp‎

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,69 @@
1010

1111
namespace nla {
1212

13+
bool nla_throttle::insert_new(throttle_kind k, lpvar mvar, bool is_lt) {
14+
if (!m_enabled) return false;
15+
signature sig;
16+
sig.m_values[0] = static_cast<unsigned>(k);
17+
sig.m_values[1] = static_cast<unsigned>(mvar);
18+
sig.m_values[2] = static_cast<unsigned>(is_lt ? 1 : 0);
19+
return insert_new_impl(sig);
20+
}
21+
22+
bool nla_throttle::insert_new(throttle_kind k, lpvar xy_var, lpvar x, lpvar y, int sign, int sy) {
23+
if (!m_enabled) return false;
24+
signature sig;
25+
sig.m_values[0] = static_cast<unsigned>(k);
26+
sig.m_values[1] = static_cast<unsigned>(xy_var);
27+
sig.m_values[2] = static_cast<unsigned>(x);
28+
sig.m_values[3] = static_cast<unsigned>(y);
29+
sig.m_values[4] = normalize_sign(sign);
30+
sig.m_values[5] = normalize_sign(sy);
31+
return insert_new_impl(sig);
32+
}
33+
34+
bool nla_throttle::insert_new(throttle_kind k, lpvar ac_var, lpvar a, const rational& c_sign, lpvar c,
35+
lpvar bd_var, lpvar b_var, const rational& d_sign, lpvar d, llc ab_cmp) {
36+
if (!m_enabled) return false;
37+
signature sig;
38+
sig.m_values[0] = static_cast<unsigned>(k);
39+
sig.m_values[1] = static_cast<unsigned>(ac_var);
40+
sig.m_values[2] = static_cast<unsigned>(a);
41+
sig.m_values[3] = pack_rational_sign(c_sign);
42+
sig.m_values[4] = static_cast<unsigned>(c);
43+
sig.m_values[5] = static_cast<unsigned>(bd_var);
44+
sig.m_values[6] = static_cast<unsigned>(b_var);
45+
// Pack d_sign, d, and ab_cmp into the last slot
46+
sig.m_values[7] = (pack_rational_sign(d_sign) << 24) |
47+
((static_cast<unsigned>(d) & 0xFFFF) << 8) |
48+
(static_cast<unsigned>(ab_cmp) & 0xFF);
49+
return insert_new_impl(sig);
50+
}
51+
52+
bool nla_throttle::insert_new(throttle_kind k, lpvar monic_var, lpvar x_var, lpvar y_var, bool below, int plane_type) {
53+
if (!m_enabled) return false;
54+
signature sig;
55+
sig.m_values[0] = static_cast<unsigned>(k);
56+
sig.m_values[1] = static_cast<unsigned>(monic_var);
57+
sig.m_values[2] = static_cast<unsigned>(x_var);
58+
sig.m_values[3] = static_cast<unsigned>(y_var);
59+
sig.m_values[4] = static_cast<unsigned>(below ? 1 : 0);
60+
sig.m_values[5] = static_cast<unsigned>(plane_type);
61+
return insert_new_impl(sig);
62+
}
63+
64+
bool nla_throttle::insert_new(throttle_kind k, lpvar monic_var, lpvar x_var, lpvar y_var, bool below) {
65+
if (!m_enabled) return false;
66+
signature sig;
67+
sig.m_values[0] = static_cast<unsigned>(k);
68+
sig.m_values[1] = static_cast<unsigned>(monic_var);
69+
sig.m_values[2] = static_cast<unsigned>(x_var);
70+
sig.m_values[3] = static_cast<unsigned>(y_var);
71+
sig.m_values[4] = static_cast<unsigned>(below ? 1 : 0);
72+
// No plane_type parameter, so leave m_values[5] as 0
73+
return insert_new_impl(sig);
74+
}
75+
1376
bool nla_throttle::insert_new_impl(const signature& sig) {
1477
if (m_seen.contains(sig)) {
1578
TRACE(nla_solver, tout << "throttled lemma generation\n";);

‎src/math/lp/nla_throttle.h‎

Lines changed: 14 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -17,8 +17,9 @@ class nla_throttle {
1717
public:
1818
enum throttle_kind {
1919
ORDER_LEMMA, // order lemma (9 params)
20-
BINOMIAL_SIGN_LEMMA, // binomial sign (5 params)
21-
MONOTONE_LEMMA // monotonicity (2 params)
20+
BINOMIAL_SIGN_LEMMA, // binomial sign (6 params)
21+
MONOTONE_LEMMA, // monotonicity (2 params)
22+
TANGENT_LEMMA // tangent lemma (5 params: monic_var, x_var, y_var, below, plane_type)
2223
};
2324

2425
private:
@@ -50,51 +51,24 @@ class nla_throttle {
5051

5152
public:
5253
nla_throttle(trail_stack& trail) : m_trail(trail) {}
53-
54-
void set_enabled(bool enabled) { m_enabled = enabled; }
54+
void set_enabled(bool enabled) { m_enabled = enabled; }
5555
bool enabled() const { return m_enabled; }
5656

5757
// Monotone lemma: mvar + is_lt
58-
bool insert_new(throttle_kind k, lpvar mvar, bool is_lt) {
59-
if (!m_enabled) return false;
60-
signature sig;
61-
sig.m_values[0] = static_cast<unsigned>(k);
62-
sig.m_values[1] = static_cast<unsigned>(mvar);
63-
sig.m_values[2] = static_cast<unsigned>(is_lt);
64-
return insert_new_impl(sig);
65-
}
58+
bool insert_new(throttle_kind k, lpvar mvar, bool is_lt);
6659

6760
// Binomial sign: xy_var + x + y + sign + sy
68-
bool insert_new(throttle_kind k, lpvar xy_var, lpvar x, lpvar y, int sign, int sy) {
69-
if (!m_enabled) return false;
70-
signature sig;
71-
sig.m_values[0] = static_cast<unsigned>(k);
72-
sig.m_values[1] = static_cast<unsigned>(xy_var);
73-
sig.m_values[2] = static_cast<unsigned>(x);
74-
sig.m_values[3] = static_cast<unsigned>(y);
75-
sig.m_values[4] = normalize_sign(sign);
76-
sig.m_values[5] = normalize_sign(sy);
77-
return insert_new_impl(sig);
78-
}
61+
bool insert_new(throttle_kind k, lpvar xy_var, lpvar x, lpvar y, int sign, int sy);
7962

8063
// Order lemma: ac_var + a + c_sign + c + bd_var + b_var + d_sign + d + ab_cmp
8164
bool insert_new(throttle_kind k, lpvar ac_var, lpvar a, const rational& c_sign, lpvar c,
82-
lpvar bd_var, lpvar b_var, const rational& d_sign, lpvar d, llc ab_cmp) {
83-
if (!m_enabled) return false;
84-
signature sig;
85-
sig.m_values[0] = static_cast<unsigned>(k);
86-
sig.m_values[1] = static_cast<unsigned>(ac_var);
87-
sig.m_values[2] = static_cast<unsigned>(a);
88-
sig.m_values[3] = pack_rational_sign(c_sign);
89-
sig.m_values[4] = static_cast<unsigned>(c);
90-
sig.m_values[5] = static_cast<unsigned>(bd_var);
91-
sig.m_values[6] = static_cast<unsigned>(b_var);
92-
// Pack d_sign, d, and ab_cmp into the last slot
93-
sig.m_values[7] = (pack_rational_sign(d_sign) << 24) |
94-
((static_cast<unsigned>(d) & 0xFFFF) << 8) |
95-
(static_cast<unsigned>(ab_cmp) & 0xFF);
96-
return insert_new_impl(sig);
97-
}
65+
lpvar bd_var, lpvar b_var, const rational& d_sign, lpvar d, llc ab_cmp);
66+
67+
// Tangent lemma: monic_var + x_var + y_var + below + plane_type
68+
bool insert_new(throttle_kind k, lpvar monic_var, lpvar x_var, lpvar y_var, bool below, int plane_type);
69+
70+
// Tangent lemma (simplified): monic_var + x_var + y_var + below
71+
bool insert_new(throttle_kind k, lpvar monic_var, lpvar x_var, lpvar y_var, bool below);
9872

9973
private:
10074
bool insert_new_impl(const signature& sig);
@@ -107,6 +81,7 @@ class nla_throttle {
10781
static unsigned normalize_sign(int sign) {
10882
return static_cast<unsigned>(sign + 127);
10983
}
84+
11085
};
11186

11287
}

‎src/math/lp/nla_throttle_example.cpp‎

Whitespace-only changes.

0 commit comments

Comments
 (0)