Lit THandler::getDeduction( )
{
Enode * e = core_solver.getDeduction( );
if ( e == NULL )
return lit_Undef;
if ( config.certification_level > 1 )
verifyDeductionWithExternalTool( e );
assert( e->isDeduced( ) );
assert( e->getDeduced( ) == l_False
|| e->getDeduced( ) == l_True );
bool negate = e->getDeduced( ) == l_False;
Var v = enodeToVar( e );
return Lit( v, negate );
}
void THandler::getReason( Lit l, vec< Lit > & reason )
{
#if LAZY_COMMUNICATION
assert( checked_trail_size == stack.size( ) );
assert( static_cast< int >( checked_trail_size ) == trail.size( ) );
#else
#endif
Var v = var(l);
Enode * e = varToEnode( v );
// It must be a TAtom and already disabled
assert( e->isTAtom( ) );
assert( !e->hasPolarity( ) );
assert( e->isDeduced( ) );
assert( e->getDeduced( ) != l_Undef ); // Last assigned deduction
#if LAZY_COMMUNICATION
assert( e->getPolarity( ) != l_Undef ); // Last assigned polarity
assert( e->getPolarity( ) == e->getDeduced( ) ); // The two coincide
#else
#endif
core_solver.pushBacktrackPoint( );
// Assign reversed polarity temporairly
e->setPolarity( e->getDeduced( ) == l_True ? l_False : l_True );
// Compute reason in whatever solver
const bool res = core_solver.assertLit( e, true ) &&
core_solver.check( true );
// Result must be false
if ( res )
{
cout << endl << "unknown" << endl;
exit( 1 );
}
// Get Explanation
vector< Enode * > & explanation = core_solver.getConflict( true );
if ( config.certification_level > 0 )
verifyExplanationWithExternalTool( explanation );
// Reserve room for implied lit
reason.push( lit_Undef );
// Copy explanation
while ( !explanation.empty( ) )
{
Enode * ei = explanation.back( );
explanation.pop_back( );
assert( ei->hasPolarity( ) );
assert( ei->getPolarity( ) == l_True
|| ei->getPolarity( ) == l_False );
bool negate = ei->getPolarity( ) == l_False;
Var v = enodeToVar( ei );
// Toggle polarity for deduced literal
if ( e == ei )
{
assert( e->getDeduced( ) != l_Undef ); // But still holds the deduced polarity
// The deduced literal must have been pushed
// with the the same polarity that has been deduced
reason[ 0 ] = Lit( v, !negate );
}
else
{
assert( ei->hasPolarity( ) ); // Lit in explanation is active
// This assertion might fail if in your theory solver
// you do not skip deduced literals during assertLit
//
// TODO: check ! It could be deduced: by another solver
// For instance BV found conflict and ei was deduced by EUF solver
//
// assert( !ei->isDeduced( ) ); // and not deduced
Lit l = Lit( v, !negate );
reason.push( l );
}
}
core_solver.popBacktrackPoint( );
// Resetting polarity
e->resetPolarity( );
}
/*_________________________________________________________________________________________________
|
| propagate : [void] -> [Clause*]
|
| Description:
| Propagates all enqueued facts. If a conflict arises, the conflicting clause is returned,
| otherwise NULL.
|
| Post-conditions:
| * the propagation queue is empty, even if there was a conflict.
|________________________________________________________________________________________________@*/
Clause* MiniSATP::propagate(const bool deduce)
{
Clause* confl = NULL;
int num_props = 0;
while (qhead < trail.size()){
Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate.
vec<Clause*>& ws = watches[toInt(p)];
Clause **i, **j, **end;
num_props++;
for (i = j = (Clause**)ws, end = i + ws.size(); i != end;){
Clause& c = **i++;
// Make sure the false literal is data[1]:
Lit false_lit = ~p;
if (c[0] == false_lit)
c[0] = c[1], c[1] = false_lit;
assert(c[1] == false_lit);
// If 0th watch is true, then clause is already satisfied.
Lit first = c[0];
if (value(first) == l_True){
*j++ = &c;
}else{
// Look for new watch:
for (int k = 2; k < c.size(); k++)
if (value(c[k]) != l_False){
c[1] = c[k]; c[k] = false_lit;
watches[toInt(~c[1])].push(&c);
goto FoundWatch; }
// Did not find watch -- clause is unit under assignment:
*j++ = &c;
if (value(first) == l_False){
confl = &c;
qhead = trail.size();
// Copy the remaining watches:
while (i < end)
*j++ = *i++;
}
else
{
uncheckedEnqueue(first, &c);
//=================================================================================================
// Added Code
assert( (int)var_to_enode.size( ) > var( first ) );
if ( deduce && var_to_enode[ var( first ) ] != NULL )
{
Enode * e = var_to_enode[ var( first ) ];
if ( !e->hasPolarity( ) && !e->isDeduced( ) )
{
e->setDeduced( sign( first ), solver_id );
deductions.push_back( e );
}
}
// Added Code
//=================================================================================================
}
}
FoundWatch:;
}
ws.shrink(i - j);
}
propagations += num_props;
simpDB_props -= num_props;
return confl;
}