void
MultiAggregate::addBinaryClauses( Solver& solver )
{
assert( solver.getCurrentDecisionLevel() == 0 );
//ids[ i + 1 ] -> ids[ i ]
for( unsigned int i = 1; i < ids.size() - 2; i++ )
{
trace_msg( multiaggregates, 1, "Adding " << ids[ i + 1 ] << "->" << ids[ i ] );
Clause* clause = new Clause();
clause->addLiteral( ids[ i + 1 ].getOppositeLiteral() );
clause->addLiteral( ids[ i ] );
solver.cleanAndAddClause( clause );
}
}
Clause*
QueryInterface::computeClauseFromCandidates()
{
Clause* clause = new Clause();
unsigned int j = 0;
for( unsigned int i = 0; i < candidates.size(); i++ )
{
Var v = candidates[ j ] = candidates[ i ];
assert( !solver.isUndefined( v ) );
if( !solver.isTrue( v ) )
continue;
if( solver.getDecisionLevel( v ) == 0 )
addAnswer( v );
else
{
clause->addLiteral( Literal( v, NEGATIVE ) );
j++;
}
}
candidates.shrink( j );
clause->setCanBeDeleted( false );
printCandidates();
return clause;
}
void
HCComponent::addLearnedClausesFromChecker(
Clause* learnedClause )
{
assert( solver.exchangeClauses() );
if( learnedClause->size() > 8 )
return;
Clause* c = new Clause( learnedClause->size() );
for( unsigned int i = 0; i < learnedClause->size(); i++ )
{
Literal current = getGeneratorLiteralFromCheckerLiteral( learnedClause->getAt( i ) );
c->addLiteral( current );
}
learnedClausesFromChecker.push_back( c );
}
void
HCComponent::createInitialClauseAndSimplifyHCVars()
{
trace_msg( modelchecker, 1, "Simplifying Head Cycle variables" );
Clause* clause = new Clause();
bool satisfied = false;
int j = 0;
for( unsigned int i = 0; i < hcVariables.size(); i++ )
{
Var v = hcVariables[ j ] = hcVariables[ i ];
if( solver.isTrue( v ) && solver.getDecisionLevel( v ) == 0 )
{
Literal lit = Literal( v, NEGATIVE );
unfoundedSetCandidates.push_back( lit );
removedHCVars++;
trace_msg( modelchecker, 2, "Variable " << Literal( v ) << " is true at level 0: removed" );
if( !satisfied )
satisfied = !addLiteralInClause( lit, clause );
}
else
j++;
}
hcVariables.resize( j );
trace_msg( modelchecker, 2, "Clause before adding a fresh variable " << *clause << ", which is " << ( satisfied ? "" : "not" ) << " satisfied");
if( clause->size() == 0 || satisfied )
{
trace_msg( modelchecker, 3, "Removed" );
delete clause;
}
else
{
statistics( &checker, setTrueAtLevelZero( removedHCVars ) );
assert( clause != NULL );
Var newVar = addFreshVariable();
literalToAdd = Literal( newVar, NEGATIVE );
clause->addLiteral( literalToAdd.getOppositeLiteral() );
trace_msg( modelchecker, 3, "Clause to add " << *clause );
if( !isConflictual )
isConflictual = !checker.addClauseRuntime( clause );
}
assert( removedHCVars == unfoundedSetCandidates.size() );
}
void
HCComponent::iterationInternalLiterals(
vector< Literal >& assumptions )
{
bool hasToAddClause = true;
Clause* clause = new Clause();
for( unsigned int i = 0; i < hcVariables.size(); i++ )
{
Literal lit = Literal( hcVariables[ i ], NEGATIVE );
if( solver.isFalse( hcVariables[ i ] ) )
assumptions.push_back( lit );
else
{
unfoundedSetCandidates.push_back( lit );
if( !hasToAddClause )
continue;
hasToAddClause = addLiteralInClause( lit, clause );
}
}
if( hasToAddClause && literalToAdd != Literal::null )
hasToAddClause = addLiteralInClause( literalToAdd, clause );
if( !hasToAddClause )
{
delete clause;
return;
}
Var addedVar = addFreshVariable();
assumptionLiteral = Literal( addedVar, POSITIVE );
clause->addLiteral( assumptionLiteral.getOppositeLiteral() );
assumptions.push_back( assumptionLiteral );
trace_msg( modelchecker, 2, "Adding clause " << *clause );
#ifndef NDEBUG
bool result =
#endif
checker.addClauseRuntime( clause );
assert( result );
statistics( &checker, assumptionsOR( clause->size() ) );
trace_msg( modelchecker, 3, "Adding " << assumptionLiteral << " as assumption" );
}
void
HCComponent::addClauseToChecker(
Clause* c,
Var headAtom )
{
assert( c != NULL );
trace_msg( modelchecker, 2, "Adding clause " << *c );
Clause& orig = *c;
Clause* clause = new Clause( c->size() );
for( unsigned int i = 0; i < orig.size(); i++ )
{
clause->addLiteral( orig[ i ] );
Var v = orig[ i ].getVariable();
if( !sameComponent( v ) )
{
Var newVar = getCheckerVarFromExternalLiteral( orig[ i ] );
if( newVar != v )
{
orig[ i ].setVariable( newVar );
orig[ i ].setPositive();
}
}
else
{
if( orig[ i ].isNegativeBodyLiteral() )
{
Var newVar = getCheckerVarFromExternalLiteral( orig[ i ] );
if( newVar != v )
{
orig[ i ].setVariable( newVar );
orig[ i ].setPositive();
}
}
}
}
getGUSData( headAtom ).definingRulesForNonHCFAtom.push_back( clause );
checker.addClause( c );
}
Formula *Parser::parse(FILE *file) {
int nClauses, nVars;
fscanf(file, "p cnf %d %d", &nVars, &nClauses);
Formula *formula = new Formula(nVars);
for (int i = 0; i < nClauses; i ++) {
Clause *clause = new Clause();
formula->addClause(clause);
// Get next literal.
while (1) {
int literal;
int nScanned = fscanf(file, "%d", &literal);
if (nScanned == 0 || literal == 0) break;
clause->addLiteral(abs(literal) - 1, literal > 0);
}
}
return formula;
}
bool
One::processCoreOne(
vector< Literal >& literals,
vector< uint64_t >& weights,
uint64_t minWeight,
unsigned int& n )
{
trace_msg( weakconstraints, 2, "Processing core for algorithm One" );
bool trivial = false;
Clause* clause = new Clause();
unsigned int originalSize = solver.numberOfOptimizationLiterals( level() );
for( unsigned int i = 0; i < originalSize; i++ )
{
OptimizationLiteralData& optLitData = solver.getOptimizationLiteral( level(), i );
if( optLitData.isRemoved() )
continue;
Literal lit = optLitData.lit;
trace_msg( weakconstraints, 3, "Considering literal " << lit << " - weight " << optLitData.weight );
Var v = lit.getVariable();
if( visited( v ) )
{
trace_msg( weakconstraints, 4, "is in unsat core" );
literals.push_back( lit );
// weights.push_back( optLitData.weight );
weights.push_back( 1 );
optLitData.remove();
if( solver.isTrue( lit ) )
trivial = true;
if( !solver.isFalse( lit ) )
clause->addLiteral( lit );
if( optLitData.weight > minWeight )
solver.addOptimizationLiteral( lit, optLitData.weight - minWeight, level(), true );
}
}
n = literals.size();
vector< Var > newVars;
for( unsigned int i = 0; i < n - 1; i++ )
{
Var auxVar = addAuxVariable();
literals.push_back( Literal( auxVar, POSITIVE ) );
weights.push_back( 1 );
solver.addOptimizationLiteral( Literal( auxVar, NEGATIVE ), minWeight, level(), true );
newVars.push_back( auxVar );
}
for( int i = newVars.size() - 1; i >= 1; i-- )
{
Clause* c = new Clause();
c->addLiteral( Literal( newVars[ i ], NEGATIVE ) );
c->addLiteral( Literal( newVars[ i - 1 ], POSITIVE ) );
solver.addClauseRuntime( c );
}
if( trivial )
{
delete clause;
return true;
}
return solver.addClauseRuntime( clause );
}
template<typename T> void TransformationTseitin<T>::addClausesRacine(int varCourante)
{
Clause* c = new Clause(V+nbrVariableAux);
c->addLiteral(formuleNormalisee->getLiteral(varCourante));
formuleNormalisee->addClause(c);
}
