void satcheck_glucose_simplifiert::set_frozen(literalt a)
{
if(!a.is_constant())
{
add_variables();
solver->setFrozen(a.var_no(), true);
}
}
void satcheck_minisat2_baset<T>::set_assignment(literalt a, bool value)
{
assert(!a.is_constant());
unsigned v=a.var_no();
bool sign=a.sign();
// MiniSat2 kills the model in case of UNSAT
solver->model.growTo(v+1);
value^=sign;
solver->model[v]=Minisat::lbool(value);
}
tvt satcheck_lingelingt::l_get(literalt a) const
{
if(a.is_constant())
return tvt(a.sign());
tvt result;
if(a.var_no()>lglmaxvar(solver))
return tvt(tvt::TV_UNKNOWN);
const int val=lglderef(solver, a.dimacs());
if(val>0)
result=tvt(true);
else if(val<0)
result=tvt(false);
else
return tvt(tvt::TV_UNKNOWN);
return result;
}
tvt satcheck_precosatt::l_get(literalt a) const
{
if(a.is_constant())
return tvt(a.sign());
tvt result;
if(a.var_no()>solver->getMaxVar())
return tvt(tvt::tv_enumt::TV_UNKNOWN);
const int val=solver->val(precosat_lit(a));
if(val>0)
result=tvt(true);
else if(val<0)
result=tvt(false);
else
return tvt(tvt::tv_enumt::TV_UNKNOWN);
return result;
}
void boolbv_mapt::set_literal(
const irep_idt &identifier,
const unsigned bit,
const typet &type,
literalt literal)
{
assert(literal.is_constant() ||
literal.var_no()<prop.no_variables());
map_entryt &map_entry=get_map_entry(identifier, type);
assert(bit<map_entry.literal_map.size());
if(map_entry.literal_map[bit].is_set)
{
prop.set_equal(map_entry.literal_map[bit].l, literal);
return;
}
map_entry.literal_map[bit].is_set=true;
map_entry.literal_map[bit].l=literal;
}
void satcheck_minisat2_baset<T>::set_polarity(literalt a, bool value)
{
assert(!a.is_constant());
add_variables();
solver->setPolarity(a.var_no(), value);
}
bool satcheck_minisat_simplifiert::is_eliminated(literalt a) const
{
assert(!a.is_constant());
return solver->isEliminated(a.var_no());
}
void satcheck_minisat_simplifiert::set_frozen(literalt a)
{
assert(!a.is_constant());
add_variables();
solver->setFrozen(a.var_no(), true);
}
literalt bv_utilst::carry(literalt a, literalt b, literalt c)
{
#ifdef COMPACT_CARRY
if(prop.has_set_to() && prop.cnf_handled_well())
{
// propagation possible?
unsigned const_count=
a.is_constant() + b.is_constant() + c.is_constant();
// propagation is possible if two or three inputs are constant
if(const_count>=2)
return prop.lor(prop.lor(
prop.land(a, b),
prop.land(a, c)),
prop.land(b, c));
// it's also possible if two of a,b,c are the same
if(a==b)
return a;
else if(a==c)
return a;
else if(b==c)
return b;
// the below yields fewer clauses and variables,
// but doesn't propagate anything at all
bvt clause;
literalt x=prop.new_variable();
/*
carry_correct: LEMMA
( a OR b OR NOT x) AND
( a OR NOT b OR c OR NOT x) AND
( a OR NOT b OR NOT c OR x) AND
(NOT a OR b OR c OR NOT x) AND
(NOT a OR b OR NOT c OR x) AND
(NOT a OR NOT b OR x)
IFF
(x=((a AND b) OR (a AND c) OR (b AND c)));
*/
prop.lcnf(a, b, !x);
prop.lcnf(a, !b, c, !x);
prop.lcnf(a, !b, !c, x);
prop.lcnf(!a, b, c, !x);
prop.lcnf(!a, b, !c, x);
prop.lcnf(!a, !b, x);
return x;
}
else
#endif // COMPACT_CARRY
{
// trivial encoding
bvt tmp;
tmp.push_back(prop.land(a, b));
tmp.push_back(prop.land(a, c));
tmp.push_back(prop.land(b, c));
return prop.lor(tmp);
}
}
literalt bv_utilst::full_adder(
const literalt a,
const literalt b,
const literalt carry_in,
literalt &carry_out)
{
#ifdef OPTIMAL_FULL_ADDER
if(prop.has_set_to() && prop.cnf_handled_well())
{
literalt x;
literalt y;
int constantProp = -1;
if(a.is_constant())
{
x = b;
y = carry_in;
constantProp = (a.is_true()) ? 1 : 0;
}
else if(b.is_constant())
{
x = a;
y = carry_in;
constantProp = (b.is_true()) ? 1 : 0;
}
else if(carry_in.is_constant())
{
x = a;
y = b;
constantProp = (carry_in.is_true()) ? 1 : 0;
}
literalt sum;
// Rely on prop.l* to do further constant propagation
if(constantProp == 1)
{
// At least one input bit is 1
carry_out = prop.lor(x, y);
sum = prop.lequal(x, y);
}
else if(constantProp == 0)
{
// At least one input bit is 0
carry_out = prop.land(x, y);
sum = prop.lxor(x, y);
}
else
{
carry_out = prop.new_variable();
sum = prop.new_variable();
// Any two inputs 1 will set the carry_out to 1
prop.lcnf(!a, !b, carry_out);
prop.lcnf(!a, !carry_in, carry_out);
prop.lcnf(!b, !carry_in, carry_out);
// Any two inputs 0 will set the carry_out to 0
prop.lcnf(a, b, !carry_out);
prop.lcnf(a, carry_in, !carry_out);
prop.lcnf(b, carry_in, !carry_out);
// If both carry out and sum are 1 then all inputs are 1
prop.lcnf(a, !sum, !carry_out);
prop.lcnf(b, !sum, !carry_out);
prop.lcnf(carry_in, !sum, !carry_out);
// If both carry out and sum are 0 then all inputs are 0
prop.lcnf(!a, sum, carry_out);
prop.lcnf(!b, sum, carry_out);
prop.lcnf(!carry_in, sum, carry_out);
// If all of the inputs are 1 or all are 0 it sets the sum
prop.lcnf(!a, !b, !carry_in, sum);
prop.lcnf(a, b, carry_in, !sum);
}
return sum;
}
else // NOLINT(readability/braces)
#endif // OPTIMAL_FULL_ADDER
{
// trivial encoding
carry_out=carry(a, b, carry_in);
return prop.lxor(prop.lxor(a, b), carry_in);
}
}
/// Returns true if an assumed literal is in conflict if the formula is UNSAT.
///
/// NOTE: if the literal is not in the assumption it causes an
/// assertion failure in lingeling.
bool satcheck_lingelingt::is_in_conflict(literalt a) const
{
assert(!a.is_constant());
return lglfailed(solver, a.dimacs())!=0;
}
void satcheck_lingelingt::set_frozen(literalt a)
{
if(!a.is_constant())
lglfreeze(solver, a.dimacs());
}
void bv_refinementt::approximationt::add_under_assumption(literalt l)
{
// if it's a constant already, give up
if(!l.is_constant())
under_assumptions.push_back(l);
}