bool SimpSMTSolver::addSMTClause( const vec<Lit>& smt_clause
#ifdef PRODUCE_PROOF
, const ipartitions_t in
#endif
)
{
assert( config.sat_preprocess_theory == 0 );
#ifdef PRODUCE_PROOF
assert(config.produce_inter == 0 || in != 0);
#endif
for (int i = 0; i < smt_clause.size(); i++) {
Lit e = smt_clause[i];
// Do not add false literals
// if ( e->isFalse( ) ) continue;
// If a literal is true, the clause is true
// if ( e->isTrue( ) )
// return true;
// Keep track of atoms seen, as they may
// be interface equalities to skip later
// if (config.logic == QF_UFIDL || config.logic == QF_UFLRA)
// atoms_seen.insert( e );
}
vec<Lit> cl_out;
// addClause will change the contents, and we don't want that here.
smt_clause.copyTo(cl_out);
#ifdef PRODUCE_PROOF
return addClause(smt_clause, in);
#else
return addClause(cl_out);
#endif
}
void SimpSMTSolver::initialize( )
{
CoreSMTSolver::initialize( );
#ifdef PRODUCE_PROOF
if ( config.sat_preprocess_booleans != 0
|| config.sat_preprocess_theory != 0 )
{
opensmt_warning( "disabling SATElite preprocessing to track proof" );
use_simplification = false;
config.sat_preprocess_booleans = 0;
config.sat_preprocess_theory = 0;
}
#else
use_simplification = config.sat_preprocess_booleans != 0;
#endif
// Add clauses for true/false
// Useful for expressing TAtoms that are constantly true/false
const Var var_True = newVar( );
const Var var_False = newVar( );
setFrozen( var_True, true );
setFrozen( var_False, true );
vec< Lit > clauseTrue, clauseFalse;
clauseTrue.push( Lit( var_True ) );
addClause( clauseTrue );
clauseFalse.push( Lit( var_False, true ) );
addClause( clauseFalse );
theory_handler = new THandler( egraph, config, *this, trail, level, assigns, var_True, var_False );
}
MojErr MojDbQuery::addClauses(WhereMap& map, const MojObject& array)
{
MojObject clause;
MojSize i = 0;
while (array.at(i++, clause)) {
MojString prop;
MojErr err = clause.getRequired(PropKey, prop);
MojErrCheck(err);
MojString opStr;
err = clause.getRequired(OpKey, opStr);
MojErrCheck(err);
CompOp op = OpNone;
err = stringToOp(opStr, op);
MojErrCheck(err);
MojObject val;
err = clause.getRequired(ValKey, val);
MojErrCheck(err);
MojDbCollationStrength coll = MojDbCollationInvalid;
MojString collateStr;
bool found = false;
err = clause.get(CollateKey, collateStr, found);
MojErrCheck(err);
if (found) {
err = MojDbUtils::collationFromString(collateStr, coll);
MojErrCheck(err);
}
err = addClause(map, prop, op, val, coll);
MojErrCheck(err);
}
return MojErrNone;
}
MojErr MojDbQuery::where(const MojChar* propName, CompOp op, const MojObject& val, MojDbCollationStrength coll)
{
MojErr err = addClause(m_whereClauses, propName, op, val, coll);
MojErrCheck(err);
return MojErrNone;
}
void SimpSolver::remember(Var v)
{
assert(decisionLevel() == 0);
assert(isEliminated(v));
vec<Lit> clause;
// Re-activate variable:
elimtable[v].order = 0;
setDecisionVar(v, true); // Not good if the variable wasn't a decision variable before. Not sure how to fix this right now.
if (use_simplification)
updateElimHeap(v);
// Reintroduce all old clauses which may implicitly remember other clauses:
for (int i = 0; i < elimtable[v].eliminated.size(); i++){
Clause& c = *elimtable[v].eliminated[i];
clause.clear();
for (int j = 0; j < c.size(); j++)
clause.push(c[j]);
remembered_clauses++;
check(addClause(clause));
free(&c);
}
elimtable[v].eliminated.clear();
}
MojErr MojDbQuery::filter(const MojChar* propName, CompOp op, const MojObject& val)
{
MojErr err = addClause(m_filterClauses, propName, op, val, MojDbCollationInvalid);
MojErrCheck(err);
return MojErrNone;
}
void advInfraTrans(rootData *rdata,indexList *varList,linkedList clauseList,linkedList fullTransNodes){
int x,i,n;
linkedList clause;
clauseVarData *clauseVar;
// at most, least one trans/stage
int transWidth = sizeLinked(fullTransNodes);
tempTransVar **transArray = toArrayLinked(fullTransNodes);
int logVal = log2Int(transWidth);
// can have an empty state with zero transitions
// at most one
for(i=0;i<transWidth;i++){
tempTransVar *tv = transArray[i];
int desObjId = tv->desObjId;
int transId = tv->transId;
nodeStages *stages = tv->stages;
if(tv->isSim)
continue;
for(n=0;n<numStagesGlobal-1;n++){
if(n < stages->start || n > stages->end)
continue;
varData *trans = getTransVar(varList,transId,desObjId,n);
assert(trans,"Trans Failed");
int setPart = i+1;
// set the vars to the corresponding trans
for(x=0;x<=logVal;x++){
clause = createLinked(Malloc,Free);
varData *part = getTransPartVar(varList,x,n);
if(!part)
part = createTransPartVar(varList,x,n);
clauseVar = createClauseVar(trans,1);
addTailLinked(clause,clauseVar);
int isNeg = !(setPart % 2);
setPart = setPart >> 1;
clauseVar = createClauseVar(part,isNeg);
addTailLinked(clause,clauseVar);
addClause(clauseList,clause);
}
}
}
}
bool ClingoPropagator::isModel(Solver& s) {
POTASSCO_REQUIRE(prop_ == trail_.size(), "Assignment not propagated");
if (call_->checkMode() == ClingoPropagatorCheck_t::Total) {
Control ctrl(*this, s);
ScopedLock(call_->lock(), call_->propagator(), Inc(epoch_))->check(ctrl);
return addClause(s, 0u) && s.numFreeVars() == 0 && s.queueSize() == 0;
}
return true;
}
bool SimpSMTSolver::eliminateVar(Var v, bool fail)
{
if (!fail && asymm_mode && !asymmVar(v)) return false;
const vec<Clause*>& cls = getOccurs(v);
// if (value(v) != l_Undef || cls.size() == 0) return true;
if (value(v) != l_Undef) return true;
// Split the occurrences into positive and negative:
vec<Clause*> pos, neg;
for (int i = 0; i < cls.size(); i++)
(find(*cls[i], Lit(v)) ? pos : neg).push(cls[i]);
// Check if number of clauses decreases:
int cnt = 0;
for (int i = 0; i < pos.size(); i++)
for (int j = 0; j < neg.size(); j++)
if (merge(*pos[i], *neg[j], v) && ++cnt > cls.size() + grow)
return true;
#ifdef PEDANTIC_DEBUG
cerr << "XXY gonna-remove" << endl;
#endif
// Delete and store old clauses:
setDecisionVar(v, false);
elimtable[v].order = elimorder++;
assert(elimtable[v].eliminated.size() == 0);
for (int i = 0; i < cls.size(); i++)
{
elimtable[v].eliminated.push(Clause_new(*cls[i]));
removeClause(*cls[i]);
}
// Produce clauses in cross product:
int top = clauses.size();
vec<Lit> resolvent;
for (int i = 0; i < pos.size(); i++)
for (int j = 0; j < neg.size(); j++)
if (merge(*pos[i], *neg[j], v, resolvent) && !addClause(resolvent))
return false;
// DEBUG: For checking that a clause set is saturated with respect to variable elimination.
// If the clause set is expected to be saturated at this point, this constitutes an
// error.
if (fail){
reportf("eliminated var %d, %d <= %d\n", v+1, cnt, cls.size());
reportf("previous clauses:\n");
for (int i = 0; i < cls.size(); i++){
printClause(*cls[i]); reportf("\n"); }
reportf("new clauses:\n");
for (int i = top; i < clauses.size(); i++){
printClause(*clauses[i]); reportf("\n"); }
assert(0); }
return backwardSubsumptionCheck();
}
/**
* Generate and print a random clause with nbLiterals literals
* @param f the formula
* @param clauseNumber : the clause to generate
* @param : the number of literals that contain the clause
*/
void generateClause(Formula * f, int nbLiterals) {
Clause * c;
createClause(&c);
addClause(f,c);
for(int i = 0;i<nbLiterals;i++) {
int sign = rand()%2 ? 1 : -1;
Literal l = sign*(rand()%f->nbVariables+1);
addLiteralInClause(*f,c,l);
}
}
bool SimpSMTSolver::addSMTClause( vector< Enode * > & smt_clause
#ifdef PRODUCE_PROOF
, const ipartitions_t in
#endif
)
{
assert( config.sat_preprocess_theory == 0 );
vec< Lit > sat_clause;
#ifdef PRODUCE_PROOF
assert( config.produce_inter == 0 || in != 0 );
#endif
for ( vector< Enode * >::iterator it = smt_clause.begin( ) ;
it != smt_clause.end( ) ;
it ++ )
{
Enode * e = *it;
// Do not add false literals
if ( e->isFalse( ) ) continue;
// If a literal is true, the clause is true
if ( e->isTrue( ) )
return true;
// Keep track of atoms seen, as they may
// be interface equalities to skip later
if ( config.logic == QF_UFIDL
|| config.logic == QF_UFLRA )
atoms_seen.insert( e );
Lit l = theory_handler->enodeToLit( e );
sat_clause.push( l );
}
#ifdef PRODUCE_PROOF
return addClause( sat_clause, in );
#else
return addClause( sat_clause );
#endif
}
void SAT::addClause(vec<Lit>& ps, bool one_watch) {
int i, j;
for (i = j = 0; i < ps.size(); i++) {
if (value(ps[i]) == l_True) return;
if (value(ps[i]) == l_Undef) ps[j++] = ps[i];
}
ps.resize(j);
if (ps.size() == 0) {
assert(false);
TL_FAIL();
}
addClause(*Clause_new(ps), one_watch);
}
bool ClingoPropagator::propagateFixpoint(Clasp::Solver& s, Clasp::PostPropagator*) {
POTASSCO_REQUIRE(prop_ <= trail_.size(), "Invalid propagate");
for (Control ctrl(*this, s, state_prop); prop_ != trail_.size() || front_ < (int32)s.numAssignedVars();) {
if (prop_ != trail_.size()) {
// create copy because trail might change during call to user propagation
temp_.assign(trail_.begin() + prop_, trail_.end());
prop_ = static_cast<uint32>(trail_.size());
ScopedLock(call_->lock(), call_->propagator(), Inc(epoch_))->propagate(ctrl, Potassco::toSpan(temp_));
}
else {
registerUndo(s);
front_ = (int32)s.numAssignedVars();
ScopedLock(call_->lock(), call_->propagator(), Inc(epoch_))->check(ctrl);
}
if (!addClause(s, state_prop) || (s.queueSize() && !s.propagateUntil(this))) {
return false;
}
}
return true;
}
void addClause(int a) {
std::array<int const, 1> clause{a};
addClause(clause.begin(), clause.end());
}
void addClause(int a, int b, int c) {
std::array<int const, 3> clause{a, b, c};
addClause(clause.begin(), clause.end());
}
// this sets cellUsedStageN=>N+1 variables when that cell is used in that transition
void setUsedClauses(rootData *rdata,indexList *varList,linkedList clauseList,linkedList fullTransNodes){
int i,n;
linkedList clause;
clauseVarData *clauseVar;
// trans
int transWidth = sizeLinked(fullTransNodes);
tempTransVar **transArray = toArrayLinked(fullTransNodes);
// board
treeNode *boardNode = rdata->boardNode;
setData *boardSet = boardNode->data;
int boardWidth = boardSet->width;
int boardHeight = boardSet->height;
cellData **boardVars = boardSet->setVars;
int boardX, boardY;
int desObjX, desObjY;
// for each cellStage used-var
// find all transitions that use that cell, put it into the set
for(boardY=0;boardY<boardHeight;boardY++){
for(boardX=0;boardX<boardWidth;boardX++){
if(!boardVars[boardY*boardWidth+boardX])
continue;
cellData *boardCell = boardVars[boardY*boardWidth+boardX];
int boardCellName = boardCell->cellName;
for(n=0;n<numStagesGlobal-1;n++){
varData *used = getUsedVar(varList,boardX,boardY,n);
assert(used,"Used NULL");
// NOT cellUsedStageN=>N+1 OR tran1StageN=>N+1 OR tran2StageN=>N+1 OR ...
linkedList transListClause = createLinked(Malloc,Free);
// contains varData
// this is for saying at most one of these simultaneous trans that use this cell can be used
linkedList transSimAtMostList = createLinked(Malloc,Free);
// try to find it in trans
for(i=0;i<transWidth;i++){
tempTransVar *trans = transArray[i];
// if this trans does not occur at this stage, it is not included in list that would indicate cell is used
nodeStages *stages = trans->stages;
if(n < stages->start || n > stages->end)
continue;
varData *tv = getTransVar(varList,trans->transId,trans->desObjId,n);
assert(tv,"Trans NULL");
// true if the transition operates on board cell (boardX,boardY)
int transUsesBoardCell = 0;
// if it is the board, this x,y is used
setData *dos = trans->desObjSet;
manyData **desObjSet = dos->setVars;
int desObjHeight = dos->height;
int desObjWidth = dos->width;
for(desObjY=0;desObjY<desObjHeight;desObjY++){
for(desObjX=0;desObjX<desObjWidth;desObjX++){
if(!desObjSet[desObjY*desObjWidth + desObjX])
continue;
manyData *md = desObjSet[desObjY*desObjWidth + desObjX];
linkedList brackVars = md->brackVars;
int *objSymP = peekLinked(brackVars);
int desObjCellName = *objSymP;
if(boardCellName == desObjCellName){
transUsesBoardCell = 1;
}
}
}
// found board cell
if(transUsesBoardCell){
clause = createLinked(Malloc,Free);
clauseVar = createClauseVar(used,0);
addTailLinked(clause,clauseVar);
clauseVar = createClauseVar(tv,1);
addTailLinked(clause,clauseVar);
assertBool(sizeLinked(clause) != 0,"Empty Clause Used");
addClause(clauseList,clause);
clauseVar = createClauseVar(tv,0);
addTailLinked(transListClause,clauseVar);
// if it is not a TransSim it is already in an at-most-one
if(trans->isSim){
// varData
addTailLinked(transSimAtMostList,tv);
}
}
}
// connect this trans to this used cell
clauseVar = createClauseVar(used,1);
pushLinked(transListClause,clauseVar);
addClause(clauseList,transListClause);
// for TransSim
atMostOne(transSimAtMostList,clauseList);
destroyLinked(transSimAtMostList,NULL);
}
}
}
}
// this forces the cell to remain the same when cellUsedStageN=>N+1 is not set
void usedClauses(rootData *rdata,indexList *varList,linkedList clauseList,linkedList fullTransNodes){
int i,n;
linkedList clause;
clauseVarData *clauseVar;
// board
treeNode *boardNode = rdata->boardNode;
setData *boardSet = boardNode->data;
int boardWidth = boardSet->width;
int boardHeight = boardSet->height;
cellData **boardVars = boardSet->setVars;
int boardX, boardY;
// for each cellStage used-var
// find all transitions that use that cell, put it into the set
for(boardY=0;boardY<boardHeight;boardY++){
for(boardX=0;boardX<boardWidth;boardX++){
if(!boardVars[boardY*boardWidth+boardX])
continue;
cellData *cell = boardVars[boardY*boardWidth+boardX];
linkedList symList = cell->symList;
int symWidth = sizeLinked(symList);
int **symArray = toArrayLinked(symList);
for(n=0;n<numStagesGlobal-1;n++){
varData *used = getUsedVar(varList,boardX,boardY,n);
assert(used,"No Used\n");
for(i=0;i<symWidth;i++){
int sym = *symArray[i];
// empty transitions
// boardCell0UsedStageN=>N+1 OR NOT boardCell0IsSym0StageN OR boardCell0IsSym0StageN+1
// and reverse
varData *scv0 = getSymCellVar(varList,boardX,boardY,sym,n);
assert(scv0,"No SCV0\n");
varData *scv1 = getSymCellVar(varList,boardX,boardY,sym,n+1);
assert(scv1,"No SCV1\n");
clause = createLinked(Malloc,Free);
clauseVar = createClauseVar(used,0);
addTailLinked(clause,clauseVar);
clauseVar = createClauseVar(scv0,1);
addTailLinked(clause,clauseVar);
clauseVar = createClauseVar(scv1,0);
addTailLinked(clause,clauseVar);
assertBool(sizeLinked(clause) != 0,"Empty Clause Used");
addClause(clauseList,clause);
clause = createLinked(Malloc,Free);
clauseVar = createClauseVar(used,0);
addTailLinked(clause,clauseVar);
clauseVar = createClauseVar(scv1,1);
addTailLinked(clause,clauseVar);
clauseVar = createClauseVar(scv0,0);
addTailLinked(clause,clauseVar);
assertBool(sizeLinked(clause) != 0,"Empty Clause Used");
addClause(clauseList,clause);
}
}
}
}
}
void addClause(int a, int b) {
std::array<int const, 2> clause{a, b};
addClause(clause.begin(), clause.end());
}
