void clean_bImp()
{
int i, j, *clean_mark, removed = 0, *bImp, size;
clean_mark = (int *) malloc (sizeof(int ) * (2*nrofvars + 1));
for( i = 0; i <= 2*nrofvars; i++ ) clean_mark[ i ] = 0;
clean_mark += nrofvars;
/*
for( i = 1; i <= nrofvars; i++ )
{
bImp = BIMP_START(i);
for( j = BIMP_ELEMENTS; --j; )
{
if( VeqDepends[ *bImp ] == SCC )
{
// printf("c check %i\n", BinaryImp[ *bImp ][ 0 ] );
*bImp = BinaryImp[ *bImp ][ 2 ];
}
bImp++;
}
bImp = BIMP_START(-i);
y for( j = BIMP_ELEMENTS; --j; )
{
if( VeqDepends[ *bImp ] == SCC )
{
// printf("c check %i\n", BinaryImp[ *bImp ][ 0 ] );
*bImp = BinaryImp[ *bImp ][ 2 ];
}
bImp++;
}
}
*/
for( i = 1; i <= nrofvars; i++ )
{
size = 2;
bImp = BIMP_START(i);
for( j = BIMP_ELEMENTS; --j; )
{
if( clean_mark[ *bImp ] != i ) { clean_mark[ *bImp ] = i; size++; bImp++; }
else { bImp[0] = bImp[j-1]; removed++; }
}
BinaryImp[ i ][ 0 ] = size;
size = 2;
bImp = BIMP_START(-i);
for( j = BIMP_ELEMENTS; --j; )
{
if( clean_mark[ *bImp ] != -i ) { clean_mark[ *bImp ] = -i; size++; bImp++; }
else { bImp[0] = bImp[j-1]; removed++; }
}
BinaryImp[ -i ][ 0 ] = size;
}
printf("c removed %i binary implications\n", removed );
clean_mark -= nrofvars;
free( clean_mark );
}
inline int DPLL_add_compensation_resolvents( const int lit1, const int lit2 )
{
int i, lit, *bImp = BIMP_START(lit2);
CHECK_NODE_STAMP( -lit1 );
CHECK_BIMP_UPPERBOUND( -lit1, BinaryImp[ lit2 ][ 0 ] );
for (i = BIMP_ELEMENTS; --i; )
{
lit = *(bImp++);
if( IS_FIXED(lit) ) continue;
if( bImp_stamps[ -lit ] == current_bImp_stamp )
return look_fix_binary_implications( lit1 );
#ifdef COMPENSATION_RESOLVENTS
if( bImp_stamps[ lit ] != current_bImp_stamp )
{
CHECK_NODE_STAMP( -lit );
CHECK_BIMP_BOUND ( -lit );
ADD_BINARY_IMPLICATIONS( lit, lit1 );
}
#endif
}
return UNKNOWN;
}
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;
}
int els_stamp_rec( int nrval, int stamp )
{
int i;
int *bImp, lit;
int flag = 1;
*S++ = nrval;
dsc[ nrval ] = stamp++;
bImp = BIMP_START(nrval);
for( i = BIMP_ELEMENTS; --i; )
{
lit = *bImp; // different than trd!
if( dsc[ lit ] == 0 )
stamp = els_stamp_rec( lit, stamp );
if( fin[ lit ] == 0 && dsc[ lit ] < dsc[ nrval ] ) // lit is parent of nrval
{
dsc[ nrval ] = dsc[ lit ];
flag = 0;
}
bImp++;
}
if( flag )
{
int size = 0;
stamp++;
do
{
--S;
lit = *S;
size++;
if( rep[ nrval ] == nrval && lit != nrval )
{
rep[ lit ] = nrval;
rep[ -lit ] = -nrval;
}
fin[ lit ] = stamp;
}
while( lit != nrval );
// if( size > 1 && rep[ nrval ] == nrval )
// printf("c size of SCC[ %i ] = %i\n", nrval, size );
}
return stamp;
}
inline void look_add_autarky_binary_implications( const int parent, const int nrval )
{
int i, *bImp = BIMP_START(-nrval);
for( i = BIMP_ELEMENTS; --i; )
if( *(bImp++) == parent )
return;
CHECK_BIMP_BOUND ( -nrval );
CHECK_BIMP_BOUND ( parent );
CHECK_NODE_STAMP( -nrval );
CHECK_NODE_STAMP( parent );
ADD_BINARY_IMPLICATIONS( -parent, nrval );
}
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;
}
void restore_implication_arrays( const int nrval )
{
int i, *bImp;
#ifdef GLOBAL_AUTARKY
int lit1, lit2;
#endif
#ifdef EQ
int ceqsubst, var;
while( !( *( substackp - 1 ) == STACK_BLOCK ) )
{
POP( sub, var );
ceqsubst = Veq[ NR(var) ][ Veq[ NR(var) ][ 0 ]++ ];
CeqValues[ ceqsubst ] *= SGN(var);
CeqSizes[ ceqsubst ]++;
}
substackp--;
#ifdef GLOBAL_AUTARKY
for( i = 1; i < Veq[NR(nrval)][0]; i++ )
{
int j;
ceqsubst = Veq[NR(nrval)][i];
for( j = 0; j < CeqSizes[ceqsubst]; j++ )
TernaryImpReduction[ Ceq[ceqsubst][j] ]--;
}
#endif
#endif
// printf("UNFIXING %i\n", nrval );
if( kSAT_flag )
{
int clause_index, *clauseSet;
clauseSet = clause_set[ nrval ];
while( *clauseSet != LAST_CLAUSE )
{
clause_index = *(clauseSet++);
clause_length[ clause_index ] -= SAT_INCREASE;
if( clause_length[ clause_index ] < SAT_INCREASE - 2 )
{
restore_big_occurences( clause_index, nrval );
#ifdef GLOBAL_AUTARKY
clause_SAT_flag[ clause_index ] = 0;
if( clause_reduction[ clause_index ] > 0 )
{
int *literals = clause_list[ clause_index ];
while( *literals != LAST_LITERAL )
TernaryImpReduction[ *(literals++) ]++;
}
#endif
}
}
#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 ] ] = 0;
literals = clause_list[ big_to_binary[ nrval ][ i ] ];
while( *literals != LAST_LITERAL )
TernaryImpReduction[ *(literals++) ]++;
}
}
#endif
clauseSet = clause_set[ -nrval ];
while( *clauseSet != LAST_CLAUSE )
{
clause_index = *(clauseSet++);
if( clause_length[ clause_index ] == SAT_INCREASE )
{
restore_big_occurences( clause_index, -nrval );
clause_length[ clause_index ] = 2;
#ifdef GLOBAL_AUTARKY
int *literals = clause_list[ clause_index ];
while( *literals != LAST_LITERAL )
{
int lit = *(literals)++;
if( timeAssignments[ lit ] < NARY_MAX )
btb_size[ lit ]--;
}
#endif
}
#ifdef GLOBAL_AUTARKY
clause_reduction[ clause_index ]--;
// if clause is restored to original length
if( clause_reduction[ clause_index ] == 0 )
{
// decreasee literal reduction array
int *literals = clause_list[ clause_index ];
while( *literals != LAST_LITERAL )
TernaryImpReduction[ *(literals++) ]--;
clause_red_depth[ clause_index ] = nrofvars;
}
#endif
#ifdef HIDIFF
HiAddLiteral( clause_index, nrval );
#endif
clause_length[ clause_index ]++;
}
}
/* restore all literals that were removed due to fixing of nrval */
if( kSAT_flag == 0 )
{
int *tImp = TernaryImp[ -nrval ];
for( i = TernaryImpSize[ -nrval ] = tmpTernaryImpSize[ -nrval ]; i--; )
{
TernaryImpSize[ *(tImp++) ]++;
TernaryImpSize[ *(tImp++) ]++;
}
#ifdef GLOBAL_AUTARKY
tImp = TernaryImp[ -nrval ];
for( i = tmpTernaryImpSize[ -nrval ]; i--; )
{
TernaryImpReduction[ *(tImp++) ]--;
TernaryImpReduction[ *(tImp++) ]--;
}
#endif
/* restore all clauses that were removed due to fixing of nrval */
tImp = TernaryImp[ nrval ];
for( i = TernaryImpSize[ nrval ] = tmpTernaryImpSize[ nrval ]; i--; )
{
TernaryImpSize[ *(tImp++) ]++;
TernaryImpSize[ *(tImp++) ]++;
}
#ifdef GLOBAL_AUTARKY
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
}
bImp = BIMP_START(-nrval);
for( i = BIMP_ELEMENTS; --i; )
bImp_satisfied[ -(*(bImp++)) ]--;
freevars++;
UNFIX( nrval );
}
void ComputeDiffWeights( )
{
int i, j, index, *Reductions, accuracy;
int *tImp, *bImp, iteration_count = 1;
float *tmpfloat;
float pos, neg;
float sum = 0.0, wnorm, factor, fsquare;
diff = _diff;
diff_tmp = _diff_tmp;
if( kSAT_flag ) Reductions = big_occ;
else Reductions = TernaryImpSize;
#ifdef EQ
if( non_tautological_equivalences )
{
for( i = freevars - 1; i >= 0; i-- )
{
sum = 0.0;
index = freevarsArray[ i ];
if( Veq[ index ][ 0 ] > 1 )
for( j = Veq[ index ][ 0 ] - 1; j > 0; j-- )
sum += 2 * lengthWeight[ CeqSizes[ Veq[ index ][ j ] ] - 1 ];
EqDiff[ index ] = sum + Reductions[ index ];
EqDiff[ -index ] = sum + Reductions[ -index ];
}
}
else
#endif
if( (non_tautological_equivalences == 0 ) && (kSAT_flag == 0) &&
(depth > ROOTSIZE) && (depth <= RECORDSIZE) )
{
diff = diff_depth[ depth - 1 ];
sum = 2.0 * freevars;
}
else
{
sum = 0.0;
for( i = freevars - 1; i >= 0; i-- )
{
index = freevarsArray[ i ];
#ifdef EQ
if( non_tautological_equivalences )
{
pos = 1 + EqDiff[ index ]; bImp = BinaryImp[ index ] + 2;
for(j = bImp[ -2 ] - 1; --j; ) pos += EqDiff[ -*(bImp++) ];
neg = 1 + EqDiff[ -index ]; bImp = BinaryImp[ -index ] + 2;
for(j = bImp[ -2 ] - 1; --j; ) neg += EqDiff[ -*(bImp++) ];
}
else
#endif
if( kSAT_flag )
{
#ifdef HIDIFF
pos = 1 + hiSum[ index ]; bImp = BinaryImp[ index ] + 2;
for(j = bImp[ -2 ] - 1; --j; ) pos += hiSum[ -*(bImp++) ];
neg = 1 + hiSum[ -index ]; bImp = BinaryImp[ -index ] + 2;
for(j = bImp[ -2 ] - 1; --j; ) neg += hiSum[ -*(bImp++) ];
#else
pos = 1 + Reductions[ index ]; bImp = BinaryImp[ index ] + 2;
for(j = bImp[ -2 ] - 1; --j; ) pos += Reductions[ -*(bImp++) ];
neg = 1 + Reductions[ -index ]; bImp = BinaryImp[ -index ] + 2;
for( j = bImp[ -2 ] - 1; --j; ) neg += Reductions[ -*(bImp++) ];
#endif
Rank[ index ] = 1024 * pos * neg + pos + neg + 1;
// assert( Rank[ index ] > 0 );
}
else
{
pos = 0.1 + (Reductions[ -index ] +
DIFF_WEIGHT * (BinaryImp[ index ][ 0 ] - bImp_satisfied[ index ]));
neg = 0.1 + (Reductions[ index ] +
DIFF_WEIGHT * (BinaryImp[ -index ][ 0 ] - bImp_satisfied[ -index ]));
if( non_tautological_equivalences ) Rank[ index ] = 1024 * pos * neg + 1;
else
{ sum += pos + neg; diff[ index ] = pos; diff[ -index ] = neg; }
}
}
}
if( non_tautological_equivalences | kSAT_flag ) return;
dist_acc_flag = dist_acc_flag > 0;
if( depth <= ROOTSIZE ) accuracy = ROOTACC;
else accuracy = ACCURACY;
if( depth <= RECORDSIZE )
{
while( iteration_count < (accuracy+ dist_acc_flag) )
{
factor = 2.0 * freevars / sum;
fsquare = factor * factor;
wnorm = DIFF_WEIGHT / factor;
tmpfloat = diff_tmp;
diff_tmp = diff;
diff = tmpfloat;
if( iteration_count == 2 ) diff = _diff;
sum = 0.0;
for( i = freevars - 1; i >= 0; i-- )
{
index = freevarsArray[ i ];
pos = 0.0; bImp = BIMP_START( -index );
for( j = BIMP_ELEMENTS; --j; )
{ if( IS_NOT_FIXED(*bImp) ) pos += diff_tmp[ *bImp ]; bImp++; }
pos *= wnorm;
// if( kSAT_flag) pos += EqDiff[ index ] + big_occ[ index ] / 2;
// else
{ tImp = TernaryImp[ index ];
for( j = TernaryImpSize[ index ]; j > 0; j-- )
{ pos += diff_tmp[ tImp[0] ] * diff_tmp[ tImp[1] ]; tImp += 2; } }
neg = 0.0; bImp = BIMP_START( index );
for( j = BIMP_ELEMENTS; --j; )
{ if( IS_NOT_FIXED(*bImp) ) neg += diff_tmp[ *bImp ]; bImp++; }
neg *= wnorm;
// if( kSAT_flag ) neg += EqDiff[ index ] + big_occ[ -index ] / 2;
// else
{ tImp = TernaryImp[ -index ];
for( j = TernaryImpSize[ -index ]; j > 0; j-- )
{ neg += diff_tmp[ tImp[0] ] * diff_tmp[ tImp[1] ]; tImp += 2; } }
diff[ -index ] = fsquare * pos;
diff[ index ] = fsquare * neg;
if( diff[ -index ] > 25 ) diff[ -index ] = 25;
if( diff[ index ] > 25 ) diff[ index ] = 25;
if( diff[ -index ] < 0.1 ) diff[ -index ] = 0.1;
if( diff[ index ] < 0.1 ) diff[ index ] = 0.1;
sum += diff[ index ] + diff[ -index ];
}
iteration_count++;
}
}
diff_tmp = diff;
if( depth < RECORDSIZE ) diff = diff_depth[ depth ];
else diff = _diff;
factor = 2.0 * freevars / sum;
wnorm = DIFF_WEIGHT / factor;
for( i = freevars - 1; i >= 0; i-- )
{
index = freevarsArray[ i ];
diff[ index ] = diff_tmp[ index ] * factor;
diff[ -index ] = diff_tmp[ -index ] * factor;
Rank[ index ] = 1024 * diff[ index ] * diff[ -index ];
}
dist_acc_flag = 0;
return;
}
int trd_stamp_rec( int nrval, int stamp )
{
int i;
int *bImp, lit;
dsc[ nrval ] = stamp++;
/*
bImp = BIMP_START(nrval);
for( i = BIMP_ELEMENTS; --i; )
{
int new = rand() % i;
if( new )
{
lit = *bImp;
*bImp = bImp[new];
bImp[new] = lit;
}
bImp++;
}
*/
bImp = BIMP_START(nrval);
for( i = BIMP_ELEMENTS; --i; )
{
lit = bin_db[ *bImp ];
if( lit != 0 )
{
if( dsc[lit ] > dsc[ nrval ] )
{
bin_db[ *bImp ] = 0;
bin_db[ (*bImp)^1 ] = 0;
removed++;
}
if( dsc[ lit ] == 0 )
stamp = trd_stamp_rec( lit, stamp );
else if( fin[ lit ] != 0 )
dsc[ lit ] = stamp++ ;
}
bImp++;
}
bImp = BIMP_START(nrval);
for( i = BIMP_ELEMENTS; --i; )
{
lit = bin_db[ bImp[i-1] ];
if( lit != 0 )
{
if( fin[lit ] > dsc[ nrval ] && dsc[lit] > fin[lit] )
{
bin_db[ bImp[i-1] ] = 0;
bin_db[ (bImp[i-1])^1 ] = 0;
removed++;
}
}
}
fin[ nrval ] = stamp++;
return stamp;
}
void els_red()
{
int i, j;
int stamp = 0;
int lit, *bImp;
int *fle, nroffailed = 0;
fle = (int*) malloc ( sizeof(int) * 2 * nrofvars );
S = (int*) malloc ( sizeof(int) * 2 * nrofvars );
rep = (int*) malloc( sizeof(int) * (2*nrofvars+1) );
rep += nrofvars;
for( i = -nrofvars; i <= nrofvars; i++ )
{
dsc[ i ] = 0; fin[ i ] = 0; rep[ i ] = i;
if( IS_FORCED( i ) )
{
dsc[ i ] = 1;
fin[ i ] = 1;
}
}
dsc[ 0 ] = 1;
for( i = -nrofvars; i <= nrofvars; i++ )
if( dsc[ i ] == 0 )
stamp = els_stamp_rec( i, stamp );
for( i = -nrofvars; i <= nrofvars; i++ )
{
if( rep[ i ] == i )
{
bImp = BIMP_START(i);
for( j = BIMP_ELEMENTS; --j; )
{
lit = *bImp;
if( rep[ lit ] == -i )
{
printf("c found failed literal %i\n", i );
fle[ nroffailed++ ] = -i;
}
else if( rep[ lit ] != i && rep[lit] != lit )
{
// printf("c lit %i equal to lit %i (%i)\n", lit, rep[ lit ], i );
*bImp = rep[ lit ];
}
bImp++;
}
}
else
{
int flag = 1;
// printf("c moving implications from %i to %i\n", i, rep[ i ] );
bImp = BIMP_START(i);
CHECK_BIMP_UPPERBOUND( rep[ i ], BIMP_ELEMENTS +1 );
for( j = BIMP_ELEMENTS; --j; )
{
lit = *bImp++;
if( rep[ lit ] == -rep[ i ] )
{
printf("c found failed literal %i\n", rep[ i ] );
fle[ nroffailed++ ] = -rep[ i];
}
else if( rep[ lit ] != rep[ i ] )
{ ADD_BINARY_IMPLICATION( -rep[ i ], rep[ lit ] );
// printf("c adding %i to %i\n", rep[ lit ], rep[ i ] );
}
else if( lit == rep[ i ] )
flag = 0;
}
BinaryImp[ i ][ 0 ] = 3;
BinaryImp[ i ][ 2 ] = rep[ i ];
if( flag )
ADD_BINARY_IMPLICATION( -rep[ i ], i );
}
}
for( i = 0; i < nroffailed; i++ )
look_fix_forced_literal( fle[i] );
free(fle);
rep -= nrofvars;
free(rep);
free(S);
}
void trans_red()
{
int i,j ;
int lit, *bImp, *rts;
int size = 0, nrofroots = 0;
int stamp = 0;
int root_dsc;
int _removed = 0;
removed = 0;
for( i = -nrofvars; i <= nrofvars; i++ )
{
size += BinaryImp[ i ][ 0 ] - 2;
}
bin_db = (int*) malloc( sizeof(int) * size );
rts = (int*) malloc( sizeof(int) * nrofvars );
// printf("c bin size %i\n", size );
size = 0;
for( i = -nrofvars; i <= nrofvars; i++ )
{
bImp = BIMP_START( i);
for( j = BIMP_ELEMENTS; --j; )
{
lit = *(bImp++);
if( -i < lit ) continue;
bin_db[ size++ ] = -i;
bin_db[ size++ ] = lit;
}
dsc[ i ] = 0;
fin[ i ] = 0;
BinaryImp[i][0] = 2;
}
// printf("c bin size %i\n", size );
for( i = 0; i < size; i+=2 )
{
int a = bin_db[ i ];
int b = bin_db[ i+1 ];
BinaryImp[ -a ][ BinaryImp[ -a ][ 0 ]++ ] = i+1;
BinaryImp[ -b ][ BinaryImp[ -b ][ 0 ]++ ] = i;
}
start_trd:;
for( i = -nrofvars; i <= nrofvars; i++ )
if( (BinaryImp[ i ][0] > 2) && (BinaryImp[ -i ][0] == 2) )
rts[ nrofroots++ ] = i;
// printf("c number of roots %i\n", nrofroots );
while( nrofroots != 0 )
{
int idx = rand() % nrofroots;
root_dsc = stamp + 1;
stamp = trd_stamp_rec( rts[ idx ], stamp );
rts[ idx ] = rts[ --nrofroots ];
}
if( removed > size/1000 )
{
stamp = 0;
for( i = -nrofvars; i <= nrofvars; i++ )
{
dsc[ i ] = 0;
fin[ i ] = 0;
}
_removed += removed;
removed = 0;
goto start_trd;
}
for( i = -nrofvars; i <= nrofvars; i++ )
BinaryImp[i][0] = 2;
for( i = 0; i < size; i+=2 )
{
int a = bin_db[ i ];
int b = bin_db[ i+1 ];
if( a == 0 || b == 0 ) continue;
BinaryImp[ -a ][ BinaryImp[ -a ][ 0 ]++ ] = b;
BinaryImp[ -b ][ BinaryImp[ -b ][ 0 ]++ ] = a;
}
free( bin_db );
free( rts );
removed = _removed;
printf("c removed %i of %i binaries\n", removed, size / 2 );
}
