mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-24 01:25:31 +00:00
Code Activity

call it data instead of c_ptr for approaching C++11 std::vector convention.

Browse source
This commit is contained in:
Nikolaj Bjorner 2021-04-13 18:17:10 -07:00
parent 524dcd35f9
commit 4a6083836a
456 changed files with 2802 additions and 2802 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/nlsat/nlsat_clause.h
View file

@ -45,7 +45,7 @@ namespace nlsat {
literal * end() { return m_lits + m_size; }
literal const * begin() const { return m_lits; }
literal const * end() const { return m_lits + m_size; }
literal const * c_ptr() const { return m_lits; }
literal const * data() const { return m_lits; }
void inc_activity() { m_activity++; }
void set_activity(unsigned v) { m_activity = v; }
unsigned get_activity() const { return m_activity; }

24
src/nlsat/nlsat_explain.cpp
View file

@ -174,8 +174,8 @@ namespace nlsat {
std::ostream& display(std::ostream & out, literal l) const { return m_solver.display(out, l); }
std::ostream& display_var(std::ostream & out, var x) const { return m_solver.display(out, x); }
std::ostream& display(std::ostream & out, unsigned sz, literal const * ls) const { return m_solver.display(out, sz, ls); }
std::ostream& display(std::ostream & out, literal_vector const & ls) const { return display(out, ls.size(), ls.c_ptr()); }
std::ostream& display(std::ostream & out, scoped_literal_vector const & ls) const { return display(out, ls.size(), ls.c_ptr()); }
std::ostream& display(std::ostream & out, literal_vector const & ls) const { return display(out, ls.size(), ls.data()); }
std::ostream& display(std::ostream & out, scoped_literal_vector const & ls) const { return display(out, ls.size(), ls.data()); }
/**
\brief Add literal to the result vector.
@ -277,7 +277,7 @@ namespace nlsat {
}
}
SASSERT(!m_zero_fs.empty()); // one of the factors must be zero in the current interpretation, since p is zero in it.
literal l = m_solver.mk_ineq_literal(atom::EQ, m_zero_fs.size(), m_zero_fs.c_ptr(), m_is_even.c_ptr());
literal l = m_solver.mk_ineq_literal(atom::EQ, m_zero_fs.size(), m_zero_fs.data(), m_is_even.data());
l.neg();
TRACE("nlsat_explain", tout << "adding (zero assumption) literal:\n"; display(tout, l); tout << "\n";);
add_literal(l);
@ -468,7 +468,7 @@ namespace nlsat {
atom::kind new_k = a->get_kind();
if (atom_sign < 0)
new_k = atom::flip(new_k);
literal new_l = m_solver.mk_ineq_literal(new_k, ps.size(), ps.c_ptr(), is_even.c_ptr());
literal new_l = m_solver.mk_ineq_literal(new_k, ps.size(), ps.data(), is_even.data());
if (l.sign())
new_l.neg();
return new_l;
@ -1191,7 +1191,7 @@ namespace nlsat {
atom::kind new_k = _a->get_kind();
if (atom_sign < 0)
new_k = atom::flip(new_k);
new_lit = m_solver.mk_ineq_literal(new_k, new_factors.size(), new_factors.c_ptr(), new_factors_even.c_ptr());
new_lit = m_solver.mk_ineq_literal(new_k, new_factors.size(), new_factors.data(), new_factors_even.data());
if (l.sign())
new_lit.neg();
TRACE("nlsat_simplify_core", tout << "simplified literal:\n"; display(tout, new_lit) << " " << m_solver.value(new_lit) << "\n";);
@ -1394,7 +1394,7 @@ namespace nlsat {
TRACE("nlsat_explain", display(tout << "core after normalization\n", m_core2) << "\n";);
simplify(m_core2, max);
TRACE("nlsat_explain", display(tout << "core after simplify\n", m_core2) << "\n";);
main(m_core2.size(), m_core2.c_ptr());
main(m_core2.size(), m_core2.data());
m_core2.reset();
}
else {
@ -1468,14 +1468,14 @@ namespace nlsat {
break;
}
TRACE("nlsat_minimize", tout << "core:\n"; display(tout, core););
r.append(core.size(), core.c_ptr());
r.append(core.size(), core.data());
}
void process(unsigned num, literal const * ls) {
if (m_minimize_cores && num > 1) {
m_core1.reset();
minimize(num, ls, m_core1);
process2(m_core1.size(), m_core1.c_ptr());
process2(m_core1.size(), m_core1.data());
m_core1.reset();
}
else {
@ -1515,7 +1515,7 @@ namespace nlsat {
SASSERT(!a || m_evaluator.eval(a, ls[i].sign()));
});
split_literals(x, num, ls, lits);
collect_polys(lits.size(), lits.c_ptr(), m_ps);
collect_polys(lits.size(), lits.data(), m_ps);
var mx_var = max_var(m_ps);
if (!m_ps.empty()) {
svector<var> renaming;
@ -1524,7 +1524,7 @@ namespace nlsat {
renaming.push_back(i);
}
std::swap(renaming[x], renaming[mx_var]);
m_solver.reorder(renaming.size(), renaming.c_ptr());
m_solver.reorder(renaming.size(), renaming.data());
TRACE("qe", tout << "x: " << x << " max: " << mx_var << " num_vars: " << m_solver.num_vars() << "\n";
m_solver.display(tout););
}
@ -1549,7 +1549,7 @@ namespace nlsat {
result.set(i, ~result[i]);
}
DEBUG_CODE(
TRACE("nlsat", m_solver.display(tout, result.size(), result.c_ptr()) << "\n"; );
TRACE("nlsat", m_solver.display(tout, result.size(), result.data()) << "\n"; );
for (literal l : result) {
CTRACE("nlsat", l_true != m_solver.value(l), m_solver.display(tout, l) << " " << m_solver.value(l) << "\n";);
SASSERT(l_true == m_solver.value(l));
@ -1809,7 +1809,7 @@ namespace nlsat {
svector<literal> lits;
polynomial_ref p(m_pm);
split_literals(x, num, ls, lits);
collect_polys(lits.size(), lits.c_ptr(), m_ps);
collect_polys(lits.size(), lits.data(), m_ps);
unbounded = true;
scoped_anum x_val(m_am);
x_val = m_assignment.value(x);

6
src/nlsat/nlsat_interval_set.cpp
View file

@ -263,7 +263,7 @@ namespace nlsat {
new_set->m_full = full;
new_set->m_ref_count = 0;
new_set->m_num_intervals = sz;
memcpy(new_set->m_intervals, buf.c_ptr(), sizeof(interval)*sz);
memcpy(new_set->m_intervals, buf.data(), sizeof(interval)*sz);
return new_set;
}
@ -470,7 +470,7 @@ namespace nlsat {
}
SASSERT(!result.empty());
SASSERT(check_interval_set(m_am, result.size(), result.c_ptr()));
SASSERT(check_interval_set(m_am, result.size(), result.data()));
// Compress
// Remark: we only combine adjacent intervals when they have the same justification
unsigned j = 0;
@ -506,7 +506,7 @@ namespace nlsat {
m_am.del(curr.m_upper);
}
result.shrink(j);
SASSERT(check_interval_set(m_am, result.size(), result.c_ptr()));
SASSERT(check_interval_set(m_am, result.size(), result.data()));
sz = j;
SASSERT(sz >= 1);
bool found_slack = !result[0].m_lower_inf || !result[sz-1].m_upper_inf;

4
src/nlsat/nlsat_scoped_literal_vector.h
View file

@ -47,7 +47,7 @@ namespace nlsat {
m_solver.dec_ref(m_lits[i]);
m_lits[i] = l;
}
literal const * c_ptr() const { return m_lits.c_ptr(); }
literal const * data() const { return m_lits.data(); }
literal const * begin() const { return m_lits.begin(); }
literal const * end() const { return m_lits.end(); }
void shrink(unsigned new_sz) {
@ -65,7 +65,7 @@ namespace nlsat {
push_back(ls[i]);
}
void append(scoped_literal_vector const& ls) {
append(ls.size(), ls.c_ptr());
append(ls.size(), ls.data());
}
void swap(scoped_literal_vector& other) {
SASSERT(&m_solver == &other.m_solver);

82
src/nlsat/nlsat_solver.cpp
View file

@ -401,7 +401,7 @@ namespace nlsat {
}
var max_var(clause const & cls) const {
return max_var(cls.size(), cls.c_ptr());
return max_var(cls.size(), cls.data());
}
/**
@ -605,7 +605,7 @@ namespace nlsat {
void * mem = m_allocator.allocate(ineq_atom::get_obj_size(sz));
if (sign < 0)
k = atom::flip(k);
ineq_atom * tmp_atom = new (mem) ineq_atom(k, sz, uniq_ps.c_ptr(), is_even, max);
ineq_atom * tmp_atom = new (mem) ineq_atom(k, sz, uniq_ps.data(), is_even, max);
ineq_atom * atom = m_ineq_atoms.insert_if_not_there(tmp_atom);
CTRACE("nlsat_table_bug", tmp_atom != atom, ineq_atom::hash_proc h;
tout << "mk_ineq_atom hash: " << h(tmp_atom) << "\n"; display(tout, *tmp_atom, m_display_var) << "\n";);
@ -840,7 +840,7 @@ namespace nlsat {
ps.push_back(ia.p(i));
is_even.push_back(ia.is_even(i));
}
bv = checker.mk_ineq_atom(ia.get_kind(), sz, ps.c_ptr(), is_even.c_ptr());
bv = checker.mk_ineq_atom(ia.get_kind(), sz, ps.data(), is_even.data());
}
else if (a->is_root_atom()) {
root_atom& r = *to_root_atom(a);
@ -864,7 +864,7 @@ namespace nlsat {
for (literal lit : *c) {
lits.push_back(literal(tr[lit.var()], lit.sign()));
}
checker.mk_clause(lits.size(), lits.c_ptr(), nullptr);
checker.mk_clause(lits.size(), lits.data(), nullptr);
}
}
for (unsigned i = 0; i < n; ++i) {
@ -936,7 +936,7 @@ namespace nlsat {
log_lemma(verbose_stream(), *cls);
}
if (learned && m_check_lemmas) {
check_lemma(cls->size(), cls->c_ptr(), false, cls->assumptions());
check_lemma(cls->size(), cls->data(), false, cls->assumptions());
}
if (learned)
m_learned.push_back(cls);
@ -1254,7 +1254,7 @@ namespace nlsat {
m_ism.get_justifications(s, core, clauses);
if (include_l)
core.push_back(~l);
assign(l, mk_lazy_jst(m_allocator, core.size(), core.c_ptr(), clauses.size(), clauses.c_ptr()));
assign(l, mk_lazy_jst(m_allocator, core.size(), core.data(), clauses.size(), clauses.data()));
SASSERT(value(l) == l_true);
}
@ -1585,7 +1585,7 @@ namespace nlsat {
m_lemma.push_back(~mk_ineq_literal(atom::LT, 1, &p2, &is_even));
// perform branch and bound
clause * cls = mk_clause(m_lemma.size(), m_lemma.c_ptr(), false, nullptr);
clause * cls = mk_clause(m_lemma.size(), m_lemma.data(), false, nullptr);
if (cls) {
TRACE("nlsat", display(tout << "conflict " << lo << " " << hi, *cls); tout << "\n";);
}
@ -1644,7 +1644,7 @@ namespace nlsat {
lbool check(literal_vector& assumptions) {
literal_vector result;
unsigned sz = assumptions.size();
literal const* ptr = assumptions.c_ptr();
literal const* ptr = assumptions.data();
for (unsigned i = 0; i < sz; ++i) {
mk_clause(1, ptr+i, (assumption)(ptr+i));
}
@ -1668,7 +1668,7 @@ namespace nlsat {
del_clauses(m_valids);
if (m_check_lemmas) {
for (clause* c : m_learned) {
check_lemma(c->size(), c->c_ptr(), false, nullptr);
check_lemma(c->size(), c->data(), false, nullptr);
}
}
@ -1701,7 +1701,7 @@ namespace nlsat {
bool collect(literal_vector const& assumptions, clause const& c) {
unsigned sz = assumptions.size();
literal const* ptr = assumptions.c_ptr();
literal const* ptr = assumptions.data();
_assumption_set asms = static_cast<_assumption_set>(c.assumptions());
if (asms == nullptr) {
return false;
@ -1796,7 +1796,7 @@ namespace nlsat {
void resolve_clause(bool_var b, clause const & c) {
TRACE("nlsat_resolve", tout << "resolving clause for b: " << b << "\n"; display(tout, c) << "\n";);
resolve_clause(b, c.size(), c.c_ptr());
resolve_clause(b, c.size(), c.data());
m_lemma_assumptions = m_asm.mk_join(static_cast<_assumption_set>(c.assumptions()), m_lemma_assumptions);
}
@ -1812,7 +1812,7 @@ namespace nlsat {
for (unsigned i = 0; i < sz; i++) {
core.push_back(~jst.lit(i));
}
display_mathematica_lemma(tout, core.size(), core.c_ptr(), true););
display_mathematica_lemma(tout, core.size(), core.data(), true););
m_lazy_clause.reset();
m_explain(jst.num_lits(), jst.lits(), m_lazy_clause);
@ -1820,15 +1820,15 @@ namespace nlsat {
m_lazy_clause.push_back(~jst.lit(i));
// lazy clause is a valid clause
TRACE("nlsat_mathematica", display_mathematica_lemma(tout, m_lazy_clause.size(), m_lazy_clause.c_ptr()););
TRACE("nlsat_proof_sk", tout << "theory lemma\n"; display_abst(tout, m_lazy_clause.size(), m_lazy_clause.c_ptr()); tout << "\n";);
TRACE("nlsat_mathematica", display_mathematica_lemma(tout, m_lazy_clause.size(), m_lazy_clause.data()););
TRACE("nlsat_proof_sk", tout << "theory lemma\n"; display_abst(tout, m_lazy_clause.size(), m_lazy_clause.data()); tout << "\n";);
TRACE("nlsat_resolve",
tout << "m_xk: " << m_xk << ", "; m_display_var(tout, m_xk) << "\n";
tout << "new valid clause:\n";
display(tout, m_lazy_clause.size(), m_lazy_clause.c_ptr()) << "\n";);
display(tout, m_lazy_clause.size(), m_lazy_clause.data()) << "\n";);
if (m_check_lemmas) {
m_valids.push_back(mk_clause_core(m_lazy_clause.size(), m_lazy_clause.c_ptr(), false, nullptr));
m_valids.push_back(mk_clause_core(m_lazy_clause.size(), m_lazy_clause.data(), false, nullptr));
}
DEBUG_CODE({
@ -1846,7 +1846,7 @@ namespace nlsat {
}
});
checkpoint();
resolve_clause(b, m_lazy_clause.size(), m_lazy_clause.c_ptr());
resolve_clause(b, m_lazy_clause.size(), m_lazy_clause.data());
for (unsigned i = 0; i < jst.num_clauses(); ++i) {
clause const& c = jst.clause(i);
@ -2034,7 +2034,7 @@ namespace nlsat {
// If lemma only contains literals from previous stages, then we can stop.
// We make progress by returning to a previous stage with additional information (new lemma)
// that forces us to select a new partial interpretation
if (only_literals_from_previous_stages(m_lemma.size(), m_lemma.c_ptr()))
if (only_literals_from_previous_stages(m_lemma.size(), m_lemma.data()))
break;
// Conflict does not depend on the current decision, and it is still in the current stage.
@ -2044,7 +2044,7 @@ namespace nlsat {
// - backtrack to this level
// - and continue conflict resolution from there
// - we must bump m_num_marks for literals removed from m_lemma
unsigned max_lvl = max_scope_lvl(m_lemma.size(), m_lemma.c_ptr());
unsigned max_lvl = max_scope_lvl(m_lemma.size(), m_lemma.data());
TRACE("nlsat_resolve", tout << "conflict does not depend on current decision, backtracking to level: " << max_lvl << "\n";);
SASSERT(max_lvl < scope_lvl());
remove_literals_from_lvl(m_lemma, max_lvl);
@ -2063,11 +2063,11 @@ namespace nlsat {
}
reset_marks(); // remove marks from the literals in m_lemmas.
TRACE("nlsat", tout << "new lemma:\n"; display(tout, m_lemma.size(), m_lemma.c_ptr()); tout << "\n";
TRACE("nlsat", tout << "new lemma:\n"; display(tout, m_lemma.size(), m_lemma.data()); tout << "\n";
tout << "found_decision: " << found_decision << "\n";);
if (false && m_check_lemmas) {
check_lemma(m_lemma.size(), m_lemma.c_ptr(), false, m_lemma_assumptions.get());
check_lemma(m_lemma.size(), m_lemma.data(), false, m_lemma_assumptions.get());
}
// There are two possibilities:
@ -2089,18 +2089,18 @@ namespace nlsat {
// Case 1)
// We just have to find the maximal variable in m_lemma, and return to that stage
// Remark: the lemma may contain only boolean literals, in this case new_max_var == null_var;
var new_max_var = max_var(sz, m_lemma.c_ptr());
var new_max_var = max_var(sz, m_lemma.data());
TRACE("nlsat_resolve", tout << "backtracking to stage: " << new_max_var << ", curr: " << m_xk << "\n";);
undo_until_stage(new_max_var);
SASSERT(m_xk == new_max_var);
new_cls = mk_clause(sz, m_lemma.c_ptr(), true, m_lemma_assumptions.get());
new_cls = mk_clause(sz, m_lemma.data(), true, m_lemma_assumptions.get());
TRACE("nlsat", tout << "new_level: " << scope_lvl() << "\nnew_stage: " << new_max_var << "\n";
if (new_max_var != null_var) m_display_var(tout, new_max_var) << "\n";);
}
else {
SASSERT(scope_lvl() >= 1);
// Case 2)
if (is_bool_lemma(m_lemma.size(), m_lemma.c_ptr())) {
if (is_bool_lemma(m_lemma.size(), m_lemma.data())) {
// boolean lemma, we just backtrack until the last literal is unassigned.
bool_var max_bool_var = m_lemma[m_lemma.size()-1].var();
undo_until_unassigned(max_bool_var);
@ -2109,7 +2109,7 @@ namespace nlsat {
// We must find the maximal decision level in literals in the first sz-1 positions that
// are at the same stage. If all these literals are from previous stages,
// we just backtrack the current level.
unsigned new_lvl = find_new_level_arith_lemma(m_lemma.size(), m_lemma.c_ptr());
unsigned new_lvl = find_new_level_arith_lemma(m_lemma.size(), m_lemma.data());
TRACE("nlsat", tout << "backtracking to new level: " << new_lvl << ", curr: " << m_scope_lvl << "\n";);
undo_until_level(new_lvl);
}
@ -2119,7 +2119,7 @@ namespace nlsat {
VERIFY(process_clause(*conflict_clause, true));
return true;
}
new_cls = mk_clause(sz, m_lemma.c_ptr(), true, m_lemma_assumptions.get());
new_cls = mk_clause(sz, m_lemma.data(), true, m_lemma_assumptions.get());
}
NLSAT_VERBOSE(display(verbose_stream(), *new_cls) << "\n";);
@ -2345,7 +2345,7 @@ namespace nlsat {
for (var x = 0; x < num; x++) {
perm[new_order[x]] = x;
}
reorder(perm.size(), perm.c_ptr());
reorder(perm.size(), perm.data());
SASSERT(check_invariant());
}
@ -2356,8 +2356,8 @@ namespace nlsat {
p.push_back(x);
}
random_gen r(++m_random_seed);
shuffle(p.size(), p.c_ptr(), r);
reorder(p.size(), p.c_ptr());
shuffle(p.size(), p.data(), r);
reorder(p.size(), p.data());
}
bool can_reorder() const {
@ -2440,7 +2440,7 @@ namespace nlsat {
// m_inv_perm: external -> internal
var_vector p;
p.append(m_perm);
reorder(p.size(), p.c_ptr());
reorder(p.size(), p.data());
DEBUG_CODE({
for (var x = 0; x < num_vars(); x++) {
SASSERT(m_perm[x] == x);
@ -2569,7 +2569,7 @@ namespace nlsat {
}
std::sort(m_cs_p.begin(), m_cs_p.end(), degree_lt(m_cs_degrees));
TRACE("nlsat_reorder_clauses", tout << "permutation: "; ::display(tout, m_cs_p.begin(), m_cs_p.end()); tout << "\n";);
apply_permutation(sz, cs, m_cs_p.c_ptr());
apply_permutation(sz, cs, m_cs_p.data());
TRACE("nlsat_reorder_clauses", tout << "after:\n"; for (unsigned i = 0; i < sz; i++) { display(tout, *(cs[i])); tout << "\n"; });
}
@ -2577,7 +2577,7 @@ namespace nlsat {
unsigned num = num_vars();
for (unsigned i = 0; i < num; i++) {
clause_vector & ws = m_watches[i];
sort_clauses_by_degree(ws.size(), ws.c_ptr());
sort_clauses_by_degree(ws.size(), ws.data());
}
}
@ -2740,7 +2740,7 @@ namespace nlsat {
even.push_back(a1.is_even(i));
}
if (!change) continue;
literal l = mk_ineq_literal(k, ps.size(), ps.c_ptr(), even.c_ptr());
literal l = mk_ineq_literal(k, ps.size(), ps.data(), even.data());
lits.push_back(l);
if (a1.m_bool_var != l.var()) {
b2l.insert(a1.m_bool_var, l);
@ -2787,7 +2787,7 @@ namespace nlsat {
is_sat = false;
}
else {
mk_clause(lits.size(), lits.c_ptr(), c->is_learned(), static_cast<_assumption_set>(c->assumptions()));
mk_clause(lits.size(), lits.data(), c->is_learned(), static_cast<_assumption_set>(c->assumptions()));
}
}
}
@ -3274,7 +3274,7 @@ namespace nlsat {
}
std::ostream& display(std::ostream & out, scoped_literal_vector const & cs) {
return display(out, cs.size(), cs.c_ptr(), m_display_var);
return display(out, cs.size(), cs.data(), m_display_var);
}
std::ostream& display(std::ostream & out, clause const & c, display_var_proc const & proc) const {
@ -3282,7 +3282,7 @@ namespace nlsat {
display_assumptions(out, static_cast<_assumption_set>(c.assumptions()));
out << " |- ";
}
return display(out, c.size(), c.c_ptr(), proc);
return display(out, c.size(), c.data(), proc);
}
std::ostream& display(std::ostream & out, clause const & c) const {
@ -3308,7 +3308,7 @@ namespace nlsat {
}
std::ostream& display_smt2(std::ostream & out, clause const & c, display_var_proc const & proc = display_var_proc()) const {
return display_smt2(out, c.size(), c.c_ptr(), proc);
return display_smt2(out, c.size(), c.data(), proc);
}
std::ostream& display_abst(std::ostream & out, literal l) const {
@ -3336,11 +3336,11 @@ namespace nlsat {
}
std::ostream& display_abst(std::ostream & out, scoped_literal_vector const & cs) const {
return display_abst(out, cs.size(), cs.c_ptr());
return display_abst(out, cs.size(), cs.data());
}
std::ostream& display_abst(std::ostream & out, clause const & c) const {
return display_abst(out, c.size(), c.c_ptr());
return display_abst(out, c.size(), c.data());
}
std::ostream& display_mathematica(std::ostream & out, clause const & c) const {
@ -3672,7 +3672,7 @@ namespace nlsat {
}
std::ostream& solver::display(std::ostream & out, literal_vector const& ls) const {
return display(out, ls.size(), ls.c_ptr());
return display(out, ls.size(), ls.data());
}
std::ostream& solver::display_smt2(std::ostream & out, literal l) const {
@ -3688,7 +3688,7 @@ namespace nlsat {
}
std::ostream& solver::display_smt2(std::ostream & out, literal_vector const& ls) const {
return display_smt2(out, ls.size(), ls.c_ptr());
return display_smt2(out, ls.size(), ls.data());
}
std::ostream& solver::display(std::ostream & out, var x) const {

4
src/nlsat/tactic/goal2nlsat.cpp
View file

@ -106,7 +106,7 @@ struct goal2nlsat::imp {
}
if (m_qm.is_neg(fs.get_constant()))
k = flip(k);
return m_solver.mk_ineq_atom(k, ps.size(), ps.c_ptr(), is_even.c_ptr());
return m_solver.mk_ineq_atom(k, ps.size(), ps.data(), is_even.data());
}
nlsat::literal process_atom(app * f, nlsat::atom::kind k) {
@ -248,7 +248,7 @@ struct goal2nlsat::imp {
for (unsigned i = 0; i < num_lits; i++) {
ls.push_back(process_literal(lits[i]));
}
m_solver.mk_clause(ls.size(), ls.c_ptr(), dep);
m_solver.mk_clause(ls.size(), ls.data(), dep);
}
void operator()(goal const & g) {