void
V3MPDRFrame::removeSelfSubsumed() {
// This function checks whether some cubes in this frame can be subsumed by the other cube
// Remove all cubes that are subsumed by the cube in this frame from _cubeList
V3MPDRCubeList::const_iterator ix;
uint32_t candidates = 1;
while (candidates <= _cubeList.size()) {
ix = _cubeList.begin(); for (uint32_t i = candidates; i < _cubeList.size(); ++i) ++ix;
removeSubsumed(*ix, ix); ++candidates;
}
}
// run provers
int
runprover(List<Clause> &clist)
{
// track current depth in proof
unsigned int currentDepth = 0;
// array of clauses for each depth
Array<OrderedSet<Clause> > clausesArray(maxdepth+1);
ListIterator<Clause> clIter(clist);
for ( ; !clIter.done(); clIter++)
{
// insert clauses at current deph
Clause clause(clIter());
clause.setDepth(currentDepth);
clause.setNumber(nextClause++);
if (clausesArray[currentDepth].insert(clause) != OK)
return(NOTOK);
}
// filter clauses
if (removeTautologies(clausesArray, currentDepth) != OK)
return(NOTOK);
if (removeSubsumed(clausesArray, currentDepth) != OK)
return(NOTOK);
// start breadth-first resolution process
int clausesAdded = 1;
for ( ; currentDepth <= maxdepth && clausesAdded; currentDepth++)
{
// reset clauses-added to false. it is reset to true
// by resolveClauses if any clauses are added.
//
clausesAdded = 0;
// resolve clauses at each level
clausesAdded = 0;
int status =
resolveDepth(clausesArray, clausesAdded, currentDepth);
switch (status)
{
case OK:
case NOMATCH:
case CONTINUE:
// continue to next depth
break;
case VALID:
// valid program
cout << "VALID program." << endl;
return(VALID);
case INVALID:
// invalid program
cout << "INVALID program." << endl;
return(INVALID);
default:
// some type of error
cout << "ERROR from resolveDepth." << endl;
return(status);
}
// remove redundant clauses
if (clausesAdded)
{
if (removeTautologies(
clausesArray, currentDepth+1) != OK)
return(NOTOK);
if (removeSubsumed(
clausesArray, currentDepth+1) != OK)
return(NOTOK);
}
}
// all done
if (currentDepth > maxdepth)
{
return(NOTPROVEN);
}
else if (!clausesAdded)
{
return(INVALID);
}
else
{
return(NOTOK);
}
}
// run provers
int
runprover(List<Clause> &clist)
{
// track current depth in proof
unsigned int currentDepth = 1;
// array of clauses for each depth
Array<BinaryTree_AVL<Clause> > clausesArray(maxdepth+2);
ListIterator<Clause> clIter(clist);
for (nextClause=1; !clIter.done(); clIter++)
{
// insert clauses at current deph
Clause clause(clIter());
clause.setDepth(currentDepth);
clause.setNumber(nextClause++);
if (clausesArray[currentDepth].insert(clause) != OK)
{
ERROR("insert failed.", errno);
return(NOTOK);
}
}
// list clauses
cout << endl;
cout << "===============================================" << endl;
cout << "initial list of clauses: " << endl;
BinaryTree_AVL_Iterator_InOrder<Clause>
cdclIter(clausesArray[currentDepth]);
for ( ; !cdclIter.done(); cdclIter++)
{
cout << cdclIter() << endl;
}
cout << "===============================================" << endl;
// filter clauses
if (removeTautologies(clausesArray, currentDepth) != OK)
{
ERROR("removeTautologies failed.", errno);
return(NOTOK);
}
if (initialRemoveSubsumed(clausesArray, currentDepth) != OK)
{
ERROR("removeSubsumed failed.", errno);
return(NOTOK);
}
// start breadth-first resolution process
int clausesAdded = 1;
for ( ; (currentDepth <= maxdepth) &&
(nextClause <= maxclause) && clausesAdded; currentDepth++)
{
// reset clauses-added to false. it is reset to true
// by resolveClauses if any clauses are added.
//
clausesAdded = 0;
// resolve clauses at each level
int status =
resolveDepth(clausesArray, clausesAdded, currentDepth);
switch (status)
{
case OK:
case NOMATCH:
case CONTINUE:
// continue to next depth
break;
case VALID:
// valid program
programstatistics[TotalValidPrograms] += 1;
cout << endl;
cout << "Run Time Statistics ..." << endl;
cout << statistics << endl;
cout << endl;
cout << "VALID program." << endl;
return(VALID);
case NOTPROVEN:
// not proven program
if (nextClause > maxclause)
{
programstatistics[TotalMaximumClauseExceededPrograms] += 1;
programstatistics[TotalNotProvenPrograms] += 1;
ERROR("maxclause exceeded !!!", EINVAL);
}
else if (currentDepth > maxdepth)
{
programstatistics[TotalMaximumDepthExceededPrograms] += 1;
programstatistics[TotalNotProvenPrograms] += 1;
ERROR("maxdepth exceeded !!!", EINVAL);
}
cout << endl;
cout << "Run Time Statistics ..." << endl;
cout << statistics << endl;
cout << endl;
cout << "NOTPROVEN program." << endl;
return(NOTPROVEN);
default:
// some type of error
cout << "ERROR from resolveDepth." << endl;
return(status);
}
// remove redundant clauses
if (clausesAdded)
{
if (removeTautologies(
clausesArray, currentDepth+1) != OK)
{
ERROR("removeTautologies failed.", errno);
return(NOTOK);
}
if (removeSubsumed(
clausesArray, currentDepth+1) != OK)
{
ERROR("removeSubsumed failed.", errno);
return(NOTOK);
}
}
}
// dump out current statistics
cout << endl;
cout << "Run Time Statistics ..." << endl;
cout << statistics << endl;
// all done
programstatistics[TotalNotProvenPrograms] += 1;
if (nextClause > maxclause)
{
programstatistics[TotalMaximumClauseExceededPrograms] += 1;
ERROR("maxclause exceeded !!!", EINVAL);
return(NOTPROVEN);
}
else if (currentDepth > maxdepth)
{
programstatistics[TotalMaximumDepthExceededPrograms] += 1;
ERROR("maxdepth exceeded !!!", EINVAL);
return(NOTPROVEN);
}
else if (!clausesAdded)
{
cout << endl;
cout << "NOTPROVEN program." << endl;
return(NOTPROVEN);
}
else
{
ERROR("runprover failed.", errno);
return(NOTOK);
}
}
