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; }