bool SimplexDecisionProcedure::standardProcessSignals(TimerStat &timer, IntStat& conflicts) {
TimerStat::CodeTimer codeTimer(timer);
Assert( d_conflictVariables.empty() );
while(d_errorSet.moreSignals()){
ArithVar curr = d_errorSet.topSignal();
if(d_tableau.isBasic(curr) && !d_variables.assignmentIsConsistent(curr)){
Assert(d_linEq.basicIsTracked(curr));
if(!d_conflictVariables.isMember(curr) && checkBasicForConflict(curr)){
Debug("recentlyViolated")
<< "It worked? "
<< conflicts.getData()
<< " " << curr
<< " " << checkBasicForConflict(curr) << endl;
reportConflict(curr);
++conflicts;
}
}
// Pop signal afterwards in case d_linEq.trackVariable(curr);
// is needed for for the ErrorSet
d_errorSet.popSignal();
}
d_errorSize = d_errorSet.errorSize();
Assert(d_errorSet.noSignals());
return !d_conflictVariables.empty();
}
void SimplexDecisionProcedure::tearDownInfeasiblityFunction(TimerStat& timer, ArithVar tmp){
TimerStat::CodeTimer codeTimer(timer);
Assert(tmp != ARITHVAR_SENTINEL);
Assert(d_tableau.isBasic(tmp));
RowIndex ri = d_tableau.basicToRowIndex(tmp);
d_linEq.stopTrackingRowIndex(ri);
d_tableau.removeBasicRow(tmp);
releaseVariable(tmp);
}
void SimplexDecisionProcedure::shrinkInfeasFunc(TimerStat& timer, ArithVar inf, const ArithVarVec& dropped){
TimerStat::CodeTimer codeTimer(timer);
for(ArithVarVec::const_iterator i=dropped.begin(), i_end = dropped.end(); i != i_end; ++i){
ArithVar back = *i;
int focusSgn = d_errorSet.focusSgn(back);
Rational chg(-focusSgn);
d_linEq.substitutePlusTimesConstant(inf, back, chg);
}
}
void SimplexDecisionProcedure::adjustInfeasFunc(TimerStat& timer, ArithVar inf, const AVIntPairVec& focusChanges){
TimerStat::CodeTimer codeTimer(timer);
for(AVIntPairVec::const_iterator i=focusChanges.begin(), i_end = focusChanges.end(); i != i_end; ++i){
ArithVar v = (*i).first;
int focusChange = (*i).second;
Rational chg(focusChange);
if(d_tableau.isBasic(v)){
d_linEq.substitutePlusTimesConstant(inf, v, chg);
}else{
d_linEq.directlyAddToCoefficient(inf, v, chg);
}
}
}
void BitblastSolver::bitblastQueue() {
while (!d_bitblastQueue.empty()) {
TNode atom = d_bitblastQueue.front();
d_bitblastQueue.pop();
Debug("bv-bitblast-queue") << "BitblastSolver::bitblastQueue (" << atom << ")\n";
if (options::bvAbstraction() &&
d_abstractionModule->isLemmaAtom(atom)) {
// don't bit-blast lemma atoms
continue;
}
if( !utils::isBitblastAtom(atom) ){
continue;
}
Debug("bitblast-queue") << "Bitblasting atom " << atom <<"\n";
{
TimerStat::CodeTimer codeTimer(d_bitblaster->d_statistics.d_bitblastTimer);
d_bitblaster->bbAtom(atom);
}
}
}
ArithVar SimplexDecisionProcedure::constructInfeasiblityFunction(TimerStat& timer, const ArithVarVec& set){
Debug("constructInfeasiblityFunction") << "constructInfeasiblityFunction start" << endl;
TimerStat::CodeTimer codeTimer(timer);
Assert(!d_errorSet.focusEmpty());
Assert(debugIsASet(set));
ArithVar inf = requestVariable();
Assert(inf != ARITHVAR_SENTINEL);
std::vector<Rational> coeffs;
std::vector<ArithVar> variables;
for(ArithVarVec::const_iterator iter = set.begin(), iend = set.end(); iter != iend; ++iter){
ArithVar e = *iter;
Assert(d_tableau.isBasic(e));
Assert(!d_variables.assignmentIsConsistent(e));
int sgn = d_errorSet.getSgn(e);
Assert(sgn == -1 || sgn == 1);
const Rational& violatedCoeff = sgn < 0 ? d_negOne : d_posOne;
coeffs.push_back(violatedCoeff);
variables.push_back(e);
Debug("constructInfeasiblityFunction") << violatedCoeff << " " << e << endl;
}
d_tableau.addRow(inf, coeffs, variables);
DeltaRational newAssignment = d_linEq.computeRowValue(inf, false);
d_variables.setAssignment(inf, newAssignment);
//d_linEq.trackVariable(inf);
d_linEq.trackRowIndex(d_tableau.basicToRowIndex(inf));
Debug("constructInfeasiblityFunction") << inf << " " << newAssignment << endl;
Debug("constructInfeasiblityFunction") << "constructInfeasiblityFunction done" << endl;
return inf;
}
void ArrayInfo::mergeInfo(const TNode a, const TNode b){
// can't have assertion that find(b) = a !
TimerStat::CodeTimer codeTimer(d_mergeInfoTimer);
++d_callsMergeInfo;
Trace("arrays-mergei")<<"Arrays::mergeInfo merging "<<a<<"\n";
Trace("arrays-mergei")<<" and "<<b<<"\n";
CNodeInfoMap::iterator ita = info_map.find(a);
CNodeInfoMap::iterator itb = info_map.find(b);
if(ita != info_map.end()) {
Trace("arrays-mergei")<<"Arrays::mergeInfo info "<<a<<"\n";
if(Trace.isOn("arrays-mergei"))
(*ita).second->print();
if(itb != info_map.end()) {
Trace("arrays-mergei")<<"Arrays::mergeInfo info "<<b<<"\n";
if(Trace.isOn("arrays-mergei"))
(*itb).second->print();
CTNodeList* lista_i = (*ita).second->indices;
CTNodeList* lista_st = (*ita).second->stores;
CTNodeList* lista_inst = (*ita).second->in_stores;
CTNodeList* listb_i = (*itb).second->indices;
CTNodeList* listb_st = (*itb).second->stores;
CTNodeList* listb_inst = (*itb).second->in_stores;
mergeLists(lista_i, listb_i);
mergeLists(lista_st, listb_st);
mergeLists(lista_inst, listb_inst);
/* sketchy stats */
//FIXME
int s = 0;//lista_i->size();
d_maxList.maxAssign(s);
if(s!= 0) {
d_avgIndexListLength.addEntry(s);
++d_listsCount;
}
s = lista_st->size();
d_maxList.maxAssign(s);
if(s!= 0) {
d_avgStoresListLength.addEntry(s);
++d_listsCount;
}
s = lista_inst->size();
d_maxList.maxAssign(s);
if(s!=0) {
d_avgInStoresListLength.addEntry(s);
++d_listsCount;
}
/* end sketchy stats */
}
} else {
Trace("arrays-mergei")<<" First element has no info \n";
if(itb != info_map.end()) {
Trace("arrays-mergei")<<" adding second element's info \n";
(*itb).second->print();
CTNodeList* listb_i = (*itb).second->indices;
CTNodeList* listb_st = (*itb).second->stores;
CTNodeList* listb_inst = (*itb).second->in_stores;
Info* temp_info = new Info(ct, bck);
mergeLists(temp_info->indices, listb_i);
mergeLists(temp_info->stores, listb_st);
mergeLists(temp_info->in_stores, listb_inst);
info_map[a] = temp_info;
} else {
Trace("arrays-mergei")<<" Second element has no info \n";
}
}
Trace("arrays-mergei")<<"Arrays::mergeInfo done \n";
}
//corresponds to Check() in dM06
//template <SimplexDecisionProcedure::PreferenceFunction pf>
bool DualSimplexDecisionProcedure::searchForFeasibleSolution(uint32_t remainingIterations){
TimerStat::CodeTimer codeTimer(d_statistics.d_searchTime);
Debug("arith") << "searchForFeasibleSolution" << endl;
Assert(remainingIterations > 0);
while(remainingIterations > 0 && !d_errorSet.focusEmpty()){
if(Debug.isOn("paranoid:check_tableau")){ d_linEq.debugCheckTableau(); }
Assert(d_conflictVariables.empty());
ArithVar x_i = d_errorSet.topFocusVariable();
Debug("arith::update::select") << "selectSmallestInconsistentVar()=" << x_i << endl;
if(x_i == ARITHVAR_SENTINEL){
Debug("arith::update") << "No inconsistent variables" << endl;
return false; //sat
}
--remainingIterations;
bool useVarOrderPivot = d_pivotsInRound.count(x_i) >= options::arithPivotThreshold();
if(!useVarOrderPivot){
d_pivotsInRound.add(x_i);
}
Debug("arith::update")
<< "pivots in rounds: " << d_pivotsInRound.count(x_i)
<< " use " << useVarOrderPivot
<< " threshold " << options::arithPivotThreshold()
<< endl;
LinearEqualityModule::VarPreferenceFunction pf = useVarOrderPivot ?
&LinearEqualityModule::minVarOrder : &LinearEqualityModule::minBoundAndColLength;
//DeltaRational beta_i = d_variables.getAssignment(x_i);
ArithVar x_j = ARITHVAR_SENTINEL;
int32_t prevErrorSize CVC4_UNUSED = d_errorSet.errorSize();
if(d_variables.cmpAssignmentLowerBound(x_i) < 0 ){
x_j = d_linEq.selectSlackUpperBound(x_i, pf);
if(x_j == ARITHVAR_SENTINEL ){
Unreachable();
// ++(d_statistics.d_statUpdateConflicts);
// reportConflict(x_i);
// ++(d_statistics.d_simplexConflicts);
// Node conflict = d_linEq.generateConflictBelowLowerBound(x_i); //unsat
// d_conflictVariable = x_i;
// reportConflict(conflict);
// return true;
}else{
const DeltaRational& l_i = d_variables.getLowerBound(x_i);
d_linEq.pivotAndUpdate(x_i, x_j, l_i);
}
}else if(d_variables.cmpAssignmentUpperBound(x_i) > 0){
x_j = d_linEq.selectSlackLowerBound(x_i, pf);
if(x_j == ARITHVAR_SENTINEL ){
Unreachable();
// ++(d_statistics.d_statUpdateConflicts);
// reportConflict(x_i);
// ++(d_statistics.d_simplexConflicts);
// Node conflict = d_linEq.generateConflictAboveUpperBound(x_i); //unsat
// d_conflictVariable = x_i;
// reportConflict(conflict);
// return true;
}else{
const DeltaRational& u_i = d_variables.getUpperBound(x_i);
d_linEq.pivotAndUpdate(x_i, x_j, u_i);
}
}
Assert(x_j != ARITHVAR_SENTINEL);
bool conflict = processSignals();
int32_t currErrorSize CVC4_UNUSED = d_errorSet.errorSize();
d_pivots++;
if(Debug.isOn("arith::dual")){
Debug("arith::dual")
<< "#" << d_pivots
<< " c" << conflict
<< " d" << (prevErrorSize - currErrorSize)
<< " f" << d_errorSet.inError(x_j)
<< " h" << d_conflictVariables.isMember(x_j)
<< " " << x_i << "->" << x_j
<< endl;
}
if(conflict){
return true;
}
}
Assert(!d_errorSet.focusEmpty() || d_errorSet.errorEmpty());
Assert(remainingIterations == 0 || d_errorSet.focusEmpty());
Assert(d_errorSet.noSignals());
return false;
}
SatValue CryptoMinisatSolver::solve(){
TimerStat::CodeTimer codeTimer(d_statistics.d_solveTime);
++d_statistics.d_statCallsToSolve;
return toSatLiteralValue(d_solver->solve());
}
