inline int look_fix_ternary_implications( const int nrval )
{
int i, lit1, lit2, *tImp = TernaryImp[ -nrval ];
for( i = TernaryImpSize[ -nrval ]; i > 0; i-- )
{
lit1 = *(tImp++);
lit2 = *(tImp++);
if( IS_FIXED(lit1) )
{
if( FIXED_ON_COMPLEMENT(lit1) )
{
if( IS_FIXED(lit2) )
{
if( FIXED_ON_COMPLEMENT(lit2) ) return UNSAT;
}
else if( add_constraint_resolvent( lit2 ) == UNSAT ) return UNSAT;
}
}
else if( IS_FIXED(lit2) )
{
if( FIXED_ON_COMPLEMENT(lit2) )
if( add_constraint_resolvent( lit1 ) == UNSAT ) return UNSAT;
}
else
{
new_binaries++;
weighted_new_binaries += diff[ lit1 ] * diff[ lit2 ];
}
}
return SAT;
}
inline int look_fix_binary_implications( const int nrval )
{
int i, lit, *bImp, *local_fixstackp = end_fixstackp;
if( IS_FIXED(nrval) )
return( FIXED_ON_COMPLEMENT(nrval) == UNSAT );
FIX( nrval, currentTimeStamp );
*( end_fixstackp++ ) = nrval;
while( local_fixstackp < end_fixstackp )
{
bImp = BIMP_START( *(local_fixstackp++) );
for( i = BIMP_ELEMENTS; --i; )
{
lit = *(bImp++);
if( IS_FIXED(lit) )
{ if( FIXED_ON_COMPLEMENT(lit) ) return UNSAT; }
else
{
FIX( lit, currentTimeStamp );
*( end_fixstackp++ ) = lit; }
}
}
return SAT;
}
inline int ternarylook_fix_ternary_implications( const int nrval )
{
int i, lit1, lit2, *tImp = TernaryImp[ -nrval ];
for( i = TernaryImpSize[ -nrval ]; i > 0; i-- )
{
lit1 = *(tImp++);
lit2 = *(tImp++);
if( IS_FIXED(lit1) )
{
if( FIXED_ON_COMPLEMENT(lit1) )
{
if( IS_FIXED(lit2) )
{
if( FIXED_ON_COMPLEMENT(lit2) ) return UNSAT;
}
else
{
FIX( lit2, currentTimeStamp );
*(look_fixstackp++) = lit2;
*(look_resstackp++) = lit2;
}
}
}
else if( IS_FIXED(lit2) )
if( FIXED_ON_COMPLEMENT(lit2) )
{
FIX( lit1, currentTimeStamp );
*(look_fixstackp++) = lit1;
*(look_resstackp++) = lit1;
}
}
return SAT;
}
int DPLL_add_binary_implications( int lit1, int lit2 )
{
int i, *bImp;
if( IS_FIXED(lit1) )
{
if( !FIXED_ON_COMPLEMENT(lit1) ) return SAT;
else if( IS_FIXED(lit2) )
return( !FIXED_ON_COMPLEMENT(lit2) );
else return look_fix_binary_implications(lit2);
}
else if( IS_FIXED(lit2) )
{
if( !FIXED_ON_COMPLEMENT(lit2) ) return SAT;
else return look_fix_binary_implications(lit1);
}
#ifdef BIEQ
while( (VeqDepends[ NR(lit1) ] != INDEPENDENT) &&
(VeqDepends[ NR(lit1) ] != EQUIVALENT) )
lit1 = VeqDepends[ NR(lit1) ] * SGN(lit1);
while( (VeqDepends[ NR(lit2) ] != INDEPENDENT) &&
(VeqDepends[ NR(lit2) ] != EQUIVALENT) )
lit2 = VeqDepends[ NR(lit2) ] * SGN(lit2);
if( lit1 == -lit2 ) return SAT;
if( lit1 == lit2 ) return look_fix_binary_implications(lit1);
#endif
STAMP_IMPLICATIONS( -lit1 );
if( bImp_stamps[ -lit2 ] == current_bImp_stamp )
return look_fix_binary_implications( lit1 );
if( bImp_stamps[lit2] != current_bImp_stamp )
{
int _result;
bImp_stamps[ BinaryImp[-lit1][ BinaryImp[-lit1][0] - 1] ] = current_bImp_stamp;
_result = DPLL_add_compensation_resolvents( lit1, lit2 );
if( _result != UNKNOWN )
return _result;
STAMP_IMPLICATIONS( -lit2 );
if( bImp_stamps[ -lit1 ] == current_bImp_stamp )
return look_fix_binary_implications( lit2 );
_result = DPLL_add_compensation_resolvents( lit2, lit1 );
if( _result != UNKNOWN )
return _result;
ADD_BINARY_IMPLICATIONS( lit1, lit2 );
}
return SAT;
}
inline int ternarylook_fix_direct_implications( const int parent, const int reference )
{
int i, lit1, lit2, *tImp = TernaryImp[ parent ];
for( i = TernaryImpSize[ parent ]; i > 0; i-- )
{
lit1 = *(tImp++);
lit2 = *(tImp++);
if( lit1 == reference )
{
if( IS_FIXED(lit2) ) { if( FIXED_ON_COMPLEMENT(lit2) ) return UNSAT; }
else{ FIX( lit2, currentTimeStamp ); *(look_fixstackp++) = lit2; }
}
else if( lit2 == reference )
{
if( IS_FIXED(lit1) ) { if( FIXED_ON_COMPLEMENT(lit1) ) return UNSAT; }
else{ FIX( lit1, currentTimeStamp ); *(look_fixstackp++) = lit1; }
}
}
return SAT;
}
inline int look_fix_ternary_implications( const int nrval )
{
int i, lit1, lit2, *tImp = TernaryImp[ -nrval ];
for( i = TernaryImpSize[ -nrval ]; i > 0; i-- )
{
lit1 = *(tImp++);
lit2 = *(tImp++);
if( IS_FIXED(lit1) )
{
if( FIXED_ON_COMPLEMENT(lit1) )
{
if( IS_FIXED(lit2) )
{
if( FIXED_ON_COMPLEMENT(lit2) ) return UNSAT;
}
else if( add_hyper_binary( lit2, 0 ) == UNSAT ) return UNSAT;
}
}
else if( IS_FIXED(lit2) )
{
if( FIXED_ON_COMPLEMENT(lit2) )
if( add_hyper_binary( lit1, 0 ) == UNSAT ) return UNSAT;
}
else
{
#ifndef EVAL_VAR
new_binaries++;
#endif
weighted_new_binaries += diff[ lit1 ] * diff[ lit2 ];
}
}
#ifdef EVAL_VAR
new_binaries++;
#endif
return SAT;
}
inline int look_fix_big_clauses( const int nrval )
{
int lit, *literals;
int clause_index;
int *clauseSet = clause_set[ -nrval ];
while( *clauseSet != LAST_CLAUSE )
{
clause_index = *(clauseSet++);
clause_length[ clause_index ]--;
#ifndef EVAL_VAR
new_binaries++;
#endif
#ifndef HIDIFF
weighted_new_binaries += size_diff[ clause_length[ clause_index ] ];
#endif
if( clause_length[ clause_index ] <= 1 )
{
literals = clause_list[ clause_index ];
while( *literals != LAST_LITERAL )
{
lit = *(literals)++;
if( IS_NOT_FIXED( lit ) )
{
if( add_hyper_binary( lit, 0 ) == SAT )
goto next_clause;
break;
}
else if( !FIXED_ON_COMPLEMENT(lit) )
goto next_clause;
}
while( *clauseSet != LAST_CLAUSE )
clause_length[ *(clauseSet++) ]--;
return UNSAT;
}
next_clause:;
}
#ifdef HIDIFF
weighted_new_binaries += hiSum[ -nrval ];
#endif
#ifdef EVAL_VAR
new_binaries++;
#endif
return SAT;
}
inline int DPLL_update_datastructures( const int nrval )
{
int i, *bImp;
#ifdef EQ
int nr, ceqidx;
nr = NR( nrval );
PUSH( sub, STACK_BLOCK );
#endif
// printf("FIXING %i\n", nrval );
FIX( nrval, NARY_MAX );
// diff[ nrval ] = 0;
// diff[ -nrval ] = 0;
#ifdef TIMEOUT
if( (int) clock() > CLOCKS_PER_SEC * TIMEOUT )
return SAT;
#endif
unitResolveCount++;
reduce_freevars( nrval );
bImp = BIMP_START(-nrval);
for( i = BIMP_ELEMENTS; --i; )
bImp_satisfied[ -(*(bImp++)) ]++;
// Update eager datastructures
if( kSAT_flag == 0 )
{
#ifdef GLOBAL_AUTARKY
int lit1, lit2;
int *tImp = TernaryImp[ nrval ] + 2 * TernaryImpSize[ nrval ];
for( i = TernaryImpLast[ nrval ] - TernaryImpSize[ nrval ]; i--; )
{
lit1 = *(tImp++);
lit2 = *(tImp++);
if( IS_REDUCED_TIMP( lit1, lit2 ) )
TernaryImpReduction[ lit1 ]--;
else if( IS_REDUCED_TIMP( lit2, lit1 ) )
TernaryImpReduction[ lit2 ]--;
}
#endif
remove_satisfied_implications( nrval );
remove_satisfied_implications( -nrval );
#ifdef GLOBAL_AUTARKY
tImp = TernaryImp[ -nrval ];
for( i = tmpTernaryImpSize[ -nrval ]; i--; )
{
TernaryImpReduction[ *(tImp++) ]++;
TernaryImpReduction[ *(tImp++) ]++;
}
#endif
}
else
{
int *clauseSet, clause_index;
// REMOVE SATISFIED CLAUSES
clauseSet = clause_set[ nrval ];
while( *clauseSet != LAST_CLAUSE )
{
clause_index = *(clauseSet++);
// if clause is not satisfied
if( clause_length[ clause_index ] < SAT_INCREASE - 2 )
{
#ifdef GLOBAL_AUTARKY
// if clause is already been reduced
if( clause_reduction[ clause_index ] > 0 )
{
int *literals = clause_list[ clause_index ];
while( *literals != LAST_LITERAL )
TernaryImpReduction[ *(literals++) ]--;
}
clause_SAT_flag[ clause_index ] = 1;
#endif
reduce_big_occurences( clause_index, nrval );
}
clause_length[ clause_index ] += SAT_INCREASE;
}
#ifdef GLOBAL_AUTARKY
for( i = 0; i < btb_size[ nrval ]; ++i )
{
// decrease literal reduction
int *literals = clause_list[ big_to_binary[ nrval ][ i ] ], flag = 0;
while( *literals != LAST_LITERAL )
{
if( timeAssignments[ *(literals++) ] == NARY_MAX )
{
if( flag == 1 ) { flag = 0; break; }
flag = 1;
}
}
if( flag == 1 )
{
clause_SAT_flag[ big_to_binary[ nrval ][ i ] ] = 1;
literals = clause_list[ big_to_binary[ nrval ][ i ] ];
while( *literals != LAST_LITERAL )
TernaryImpReduction[ *(literals++) ]--;
}
}
#endif
}
#ifdef GLOBAL_AUTARKY
#ifdef EQ
tmpEqImpSize[ nr ] = Veq[ nr ][ 0 ];
for( i = 1; i < Veq[ nr ][0]; i++ )
{
int j;
ceqidx = Veq[ nr ][i];
for( j = 0; j < CeqSizes[ ceqidx ]; j++ )
TernaryImpReduction[ Ceq[ceqidx][j] ]++;
}
#endif
#endif
if( kSAT_flag )
{
int UNSAT_flag, *clauseSet, clause_index;
int first_lit, *literals, lit;
// REMOVE UNSATISFIED LITERALS
UNSAT_flag = 0;
clauseSet = clause_set[ -nrval ];
while( *clauseSet != LAST_CLAUSE )
{
clause_index = *(clauseSet++);
#ifdef GLOBAL_AUTARKY
// if clause is for the first time reduced
if( clause_reduction[ clause_index ] == 0 )
{
int *literals = clause_list[ clause_index ];
while( *literals != LAST_LITERAL )
TernaryImpReduction[ *(literals++) ]++;
clause_red_depth[ clause_index ] = depth;
}
clause_reduction[ clause_index ]++;
#endif
clause_length[ clause_index ]--;
#ifdef HIDIFF
HiRemoveLiteral( clause_index, nrval );
#endif
if( clause_length[ clause_index ] == 2 )
{
#ifdef GLOBAL_AUTARKY
literals = clause_list[ clause_index ];
while( *literals != LAST_LITERAL )
{
lit = *(literals)++;
if( timeAssignments[ lit ] < NARY_MAX )
big_to_binary[ lit ][ btb_size[ lit ]++ ] = clause_index;
}
#endif
reduce_big_occurences( clause_index, -nrval );
clause_length[ clause_index ] = SAT_INCREASE;
if( UNSAT_flag == 0 )
{
first_lit = 0;
literals = clause_list[ clause_index ];
while( *literals != LAST_LITERAL )
{
lit = *(literals)++;
if( IS_NOT_FIXED( lit ) )
{
if( first_lit == 0 ) first_lit = lit;
else
{
UNSAT_flag = !DPLL_add_binary_implications( first_lit, lit );
goto next_clause;
}
}
else if( !FIXED_ON_COMPLEMENT(lit) ) goto next_clause;
}
if( first_lit != 0 ) UNSAT_flag = !look_fix_binary_implications( first_lit );
else UNSAT_flag = 1;
}
next_clause:;
}
}
if( UNSAT_flag ) return UNSAT;
}
if( kSAT_flag == 0 )
{
int *tImp = TernaryImp[ -nrval ];
for( i = tmpTernaryImpSize[ -nrval ] - 1; i >= 0; i-- )
{
int lit1 = *(tImp++);
int lit2 = *(tImp++);
if( DPLL_add_binary_implications( lit1, lit2 ) == UNSAT )
return UNSAT;
}
}
#ifdef EQ
while( Veq[ nr ][ 0 ] > 1 )
{
ceqidx = Veq[ nr ][ 1 ];
fixEq( nr, 1, SGN(nrval));
PUSH( sub, nrval );
if( CeqSizes[ ceqidx ] == 2 )
{
if ( DPLL_propagate_binary_equivalence( ceqidx ) == UNSAT )
return UNSAT;
}
else if( CeqSizes[ ceqidx ] == 1 )
{
if( look_fix_binary_implications(Ceq[ceqidx][0]*CeqValues[ceqidx]) == UNSAT )
return UNSAT;
}
}
while( newbistackp != newbistack )
{
POP( newbi, ceqidx );
if( CeqSizes[ ceqidx ] == 2 )
if ( DPLL_propagate_binary_equivalence( ceqidx ) == UNSAT )
return UNSAT;
}
#endif
return SAT;
}
int treelookvar( const int nrval )
{
int i, parent;
const int *loc;
assert( currentTimeStamp < VARMAX );
parent = assignment_array[ nrval ].parent;
assert(parent != nrval);
if( (parent != 0) && IS_FIXED(parent) && IS_NOT_FORCED(parent) )
{
NBCounter [ nrval ] = NBCounter [ parent ];
WNBCounter[ nrval ] = WNBCounter[ parent ];
}
else
{
NBCounter [ nrval ] = 0;
WNBCounter[ nrval ] = 0;
}
if( IS_FIXED(nrval) )
{
if (IS_FORCED(nrval) )
return SAT;
if( FIXED_ON_COMPLEMENT(nrval) )
{
return look_fix_forced_literal(-nrval);
}
#ifdef AUTARKY
look_add_autarky_binary_implications( parent, nrval );
#endif
return SAT;
}
lookAheadCount++;
if( look_IFIUP(nrval) == UNSAT )
return look_fix_forced_literal(-nrval);
NBCounter [ nrval ] += new_binaries;
WNBCounter[ nrval ] += weighted_new_binaries;
#ifdef DOUBLELOOK
if( check_doublelook( nrval ) == UNSAT ) return UNSAT;
#endif
#ifdef AUTARKY
if( new_binaries == 0 )
{
if( (parent == 0) || IS_FORCED(parent) )
{
look_fix_forced_literal( nrval );
return SAT;
}
look_add_autarky_binary_implications( parent, nrval );
}
#endif
loc = BinaryImp[ -nrval ];
for( i = 2; i < loc[ 0 ]; i++ )
{
const int lit = loc[ i ];
if( IS_FIXED(lit) && IS_NOT_FORCED(lit) )
{
if( !FIXED_ON_COMPLEMENT(lit) )
{
necessary_assignments++;
if( look_fix_forced_literal(lit) == UNSAT ) return UNSAT;
loc = BinaryImp[ -nrval ];
}
else
{
#ifdef BIEQ
int bieq = -parent;
if( VeqDepends[ NR(nrval) ] != INDEPENDENT ) return 1;
while( VeqDepends[ NR(bieq) ] != INDEPENDENT )
{
if( VeqDepends[ NR(bieq) ] != EQUIVALENT )
bieq = VeqDepends[ NR(bieq) ] * SGN(bieq);
else
bieq = EQUIVALENT;
if( bieq == nrval ) break;
}
if( (bieq != EQUIVALENT) && (bieq != nrval) )
{
VeqDepends[ NR(bieq) ] = nrval * SGN(bieq);
PUSH( bieq, NR(bieq) );
}
#endif
}
}
}
return SAT;
}
