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()); }