cerc-io/solidity
10
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

remove couts

Browse Source
This commit is contained in:
chriseth 2022-02-23 18:24:10 +01:00
parent a3a0f1d95b
commit 6b7c200891
3 changed files with 47 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
libsolutil/BooleanLP.cpp
View File

@ -178,9 +178,9 @@ void BooleanLPSolver::addAssertion(Expression const& _expr)
pair<CheckResult, vector<string>> BooleanLPSolver::check(vector<Expression> const&)
{
cout << "Solving boolean constraint system" << endl;
cout << toString() << endl;
cout << "--------------" << endl;
//cout << "Solving boolean constraint system" << endl;
//cout << toString() << endl;
//cout << "--------------" << endl;
if (state().infeasible)
return make_pair(CheckResult::UNSATISFIABLE, vector<string>{});
@ -200,8 +200,8 @@ pair<CheckResult, vector<string>> BooleanLPSolver::check(vector<Expression> cons
else
resizeAndSet(lpState.variableNames, index, name);
cout << "Boolean variables:" << joinHumanReadable(booleanVariables) << endl;
cout << "Running LP solver on fixed constraints." << endl;
//cout << "Boolean variables:" << joinHumanReadable(booleanVariables) << endl;
//cout << "Running LP solver on fixed constraints." << endl;
if (m_lpSolver.check(lpState).first == LPResult::Infeasible)
return {CheckResult::UNSATISFIABLE, {}};
@ -239,12 +239,12 @@ pair<CheckResult, vector<string>> BooleanLPSolver::check(vector<Expression> cons
auto optionalModel = CDCL{move(booleanVariables), clauses, theorySolver}.solve();
if (!optionalModel)
{
cout << "==============> CDCL final result: unsatisfiable." << endl;
//cout << "==============> CDCL final result: unsatisfiable." << endl;
return {CheckResult::UNSATISFIABLE, {}};
}
else
{
cout << "==============> CDCL final result: SATisfiable / UNKNON." << endl;
//cout << "==============> CDCL final result: SATisfiable / UNKNON." << endl;
// TODO should be "unknown" later on
return {CheckResult::SATISFIABLE, {}};
}

66
libsolutil/CDCL.cpp
View File

@ -45,24 +45,24 @@ CDCL::CDCL(
optional<CDCL::Model> CDCL::solve()
{
cout << "====" << endl;
for (unique_ptr<Clause> const& c: m_clauses)
cout << toString(*c) << endl;
cout << "====" << endl;
// cout << "====" << endl;
// for (unique_ptr<Clause> const& c: m_clauses)
// cout << toString(*c) << endl;
// cout << "====" << endl;
while (true)
{
optional<Clause> conflictClause = propagate();
if (!conflictClause && m_theorySolver)
{
conflictClause = m_theorySolver(m_assignments);
if (conflictClause)
cout << "Theory gave us conflict: " << toString(*conflictClause) << endl;
// if (conflictClause)
// cout << "Theory gave us conflict: " << toString(*conflictClause) << endl;
}
if (conflictClause)
{
if (currentDecisionLevel() == 0)
{
cout << "Unsatisfiable" << endl;
// cout << "Unsatisfiable" << endl;
return nullopt;
}
auto&& [learntClause, backtrackLevel] = analyze(move(*conflictClause));
@ -80,14 +80,14 @@ optional<CDCL::Model> CDCL::solve()
if (auto variable = nextDecisionVariable())
{
m_decisionPoints.emplace_back(m_assignmentTrail.size());
cout << "Deciding on " << m_variables.at(*variable) << " @" << currentDecisionLevel() << endl;
// cout << "Deciding on " << m_variables.at(*variable) << " @" << currentDecisionLevel() << endl;
enqueue(Literal{false, *variable}, nullptr);
}
else
{
cout << "satisfiable." << endl;
for (auto&& [var, value]: m_assignments)
cout << " " << m_variables.at(var) << ": " << (value ? "true" : "false") << endl;
//cout << "satisfiable." << endl;
//for (auto&& [i, value]: m_assignments | ranges::view::enumerate())
// cout << " " << m_variables.at(i) << ": " << value.toString() << endl;
return m_assignments;
}
}
@ -102,12 +102,12 @@ void CDCL::setupWatches(Clause& _clause)
optional<Clause> CDCL::propagate()
{
cout << "Propagating." << endl;
//cout << "Propagating." << endl;
for (; m_assignmentQueuePointer < m_assignmentTrail.size(); m_assignmentQueuePointer++)
{
Literal toPropagate = m_assignmentTrail.at(m_assignmentQueuePointer);
Literal falseLiteral = ~toPropagate;
cout << "Propagating " << toString(toPropagate) << endl;
//cout << "Propagating " << toString(toPropagate) << endl;
// Go through all watched clauses where this assignment makes the literal false.
vector<Clause*> watchReplacement;
auto it = m_watches[falseLiteral].begin();
@ -115,7 +115,7 @@ optional<Clause> CDCL::propagate()
for (; it != end; ++it)
{
Clause& clause = **it;
cout << " watch clause: " << toString(clause) << endl;
//cout << " watch clause: " << toString(clause) << endl;
solAssert(!clause.empty());
if (clause.front() != falseLiteral)
@ -124,7 +124,7 @@ optional<Clause> CDCL::propagate()
if (clause.size() >= 2 && isAssignedTrue(clause[1]))
{
// Clause is already satisfied, keezp the watch.
cout << " -> already satisfied by " << toString(clause[1]) << endl;
//cout << " -> already satisfied by " << toString(clause[1]) << endl;
watchReplacement.emplace_back(&clause);
continue;
}
@ -133,7 +133,7 @@ optional<Clause> CDCL::propagate()
for (size_t i = 2; i < clause.size(); i++)
if (isUnknownOrAssignedTrue(clause[i]))
{
cout << " -> swapping " << toString(clause.front()) << " with " << toString(clause[i]) << endl;
//cout << " -> swapping " << toString(clause.front()) << " with " << toString(clause[i]) << endl;
swap(clause.front(), clause[i]);
m_watches[clause.front()].emplace_back(&clause);
break;
@ -145,10 +145,10 @@ optional<Clause> CDCL::propagate()
// are false, thus clause[1] has to be true (if it exists)
if (clause.size() == 1 || isAssignedFalse(clause[1]))
{
if (clause.size() >= 2)
cout << " - Propagate resulted in conflict because " << toString(clause[1]) << " is also false." << endl;
else
cout << " - Propagate resulted in conflict since clause is single-literal." << endl;
// if (clause.size() >= 2)
// cout << " - Propagate resulted in conflict because " << toString(clause[1]) << " is also false." << endl;
// else
// cout << " - Propagate resulted in conflict since clause is single-literal." << endl;
// Copy over the remaining watches and replace.
while (it != end) watchReplacement.emplace_back(move(*it++));
m_watches[falseLiteral] = move(watchReplacement);
@ -158,7 +158,7 @@ optional<Clause> CDCL::propagate()
}
else
{
cout << " - resulted in new assignment: " << toString(clause[1]) << endl;
// cout << " - resulted in new assignment: " << toString(clause[1]) << endl;
watchReplacement.emplace_back(&clause);
enqueue(clause[1], &clause);
}
@ -172,7 +172,7 @@ optional<Clause> CDCL::propagate()
std::pair<Clause, size_t> CDCL::analyze(Clause _conflictClause)
{
solAssert(!_conflictClause.empty());
cout << "Analyzing conflict." << endl;
//cout << "Analyzing conflict." << endl;
Clause learntClause;
size_t backtrackLevel = 0;
@ -183,7 +183,7 @@ std::pair<Clause, size_t> CDCL::analyze(Clause _conflictClause)
optional<Literal> resolvingLiteral;
do
{
cout << " conflict clause: " << toString(_conflictClause) << endl;
//cout << " conflict clause: " << toString(_conflictClause) << endl;
for (Literal literal: _conflictClause)
if ((!resolvingLiteral || literal != *resolvingLiteral) && !seenVariables.count(literal.variable))
{
@ -191,31 +191,31 @@ std::pair<Clause, size_t> CDCL::analyze(Clause _conflictClause)
size_t variableLevel = m_levelForVariable.at(literal.variable);
if (variableLevel == currentDecisionLevel())
{
cout << " ignoring " << toString(literal) << " at current decision level." << endl;
//cout << " ignoring " << toString(literal) << " at current decision level." << endl;
// ignore variable, we will apply resolution with its reason.
pathCount++;
}
else
{
cout << " adding " << toString(literal) << " @" << variableLevel << " to learnt clause." << endl;
//cout << " adding " << toString(literal) << " @" << variableLevel << " to learnt clause." << endl;
learntClause.push_back(literal);
backtrackLevel = max(backtrackLevel, variableLevel);
}
}
}/*
else
cout << " already seen " << toString(literal) << endl;
cout << " already seen " << toString(literal) << endl;*/
solAssert(pathCount > 0);
pathCount--;
while (!seenVariables.count(m_assignmentTrail[trailIndex--].variable));
resolvingLiteral = m_assignmentTrail[trailIndex + 1];
cout << " resolving literal: " << toString(*resolvingLiteral) << endl;
//cout << " resolving literal: " << toString(*resolvingLiteral) << endl;
seenVariables.erase(resolvingLiteral->variable);
// TODO Is there always a reason? Not if it's a decision variable.
if (pathCount > 0)
{
_conflictClause = *m_reason.at(*resolvingLiteral);
cout << " reason: " << toString(_conflictClause) << endl;
//cout << " reason: " << toString(_conflictClause) << endl;
}
}
while (pathCount > 0);
@ -224,7 +224,7 @@ std::pair<Clause, size_t> CDCL::analyze(Clause _conflictClause)
// Move to front so we can directly propagate.
swap(learntClause.front(), learntClause.back());
cout << "-> learnt clause: " << toString(learntClause) << " backtrack to " << backtrackLevel << endl;
//cout << "-> learnt clause: " << toString(learntClause) << " backtrack to " << backtrackLevel << endl;
return {move(learntClause), backtrackLevel};
@ -238,9 +238,11 @@ void CDCL::addClause(Clause _clause)
void CDCL::enqueue(Literal const& _literal, Clause const* _reason)
{
/*
cout << "Enqueueing " << toString(_literal) << " @" << currentDecisionLevel() << endl;
if (_reason)
cout << " because of " << toString(*_reason) << endl;
*/
// TODO assert that assignmnets was unknown
m_assignments[_literal.variable] = _literal.positive;
m_levelForVariable[_literal.variable] = currentDecisionLevel();
@ -252,13 +254,13 @@ void CDCL::enqueue(Literal const& _literal, Clause const* _reason)
void CDCL::cancelUntil(size_t _backtrackLevel)
{
// TODO what if we backtrack to zero?
cout << "Canceling until " << _backtrackLevel << endl;
//cout << "Canceling until " << _backtrackLevel << endl;
solAssert(m_assignmentQueuePointer == m_assignmentTrail.size());
size_t assignmentsToUndo = m_assignmentTrail.size() - m_decisionPoints.at(_backtrackLevel);
for (size_t i = 0; i < assignmentsToUndo; i++)
{
Literal l = m_assignmentTrail.back();
cout << " undoing " << toString(l) << endl;
//cout << " undoing " << toString(l) << endl;
m_assignmentTrail.pop_back();
m_assignments.erase(l.variable);
m_reason.erase(l);

12
libsolutil/LP.cpp
View File

@ -778,13 +778,13 @@ LPSolver::LPSolver(bool _supportModels):
pair<LPResult, variant<Model, ReasonSet>> LPSolver::check(SolvingState _state)
{
normalizeRowLengths(_state);
cout << "Running LP on:\n" << _state.toString() << endl;
//cout << "Running LP on:\n" << _state.toString() << endl;
auto&& [simplificationResult, modelOrReasonSet] = SolvingStateSimplifier{_state}.simplify();
switch (simplificationResult)
{
case LPResult::Infeasible:
cout << "-> LP infeasible." << endl;
//cout << "-> LP infeasible." << endl;
return {LPResult::Infeasible, modelOrReasonSet};
case LPResult::Feasible:
case LPResult::Unbounded:
@ -808,7 +808,7 @@ pair<LPResult, variant<Model, ReasonSet>> LPSolver::check(SolvingState _state)
if (auto conflict = boundsToConstraints(split))
{
cout << "-> LP infeasible." << endl;
//cout << "-> LP infeasible." << endl;
return {LPResult::Infeasible, move(*conflict)};
}
@ -839,7 +839,7 @@ pair<LPResult, variant<Model, ReasonSet>> LPSolver::check(SolvingState _state)
set<size_t> reasons;
for (auto const& constraint: split.constraints)
reasons += constraint.reasons;
cout << "-> LP infeasible." << endl;
//cout << "-> LP infeasible." << endl;
return {LPResult::Infeasible, move(reasons)};
}
case LPResult::Unknown:
@ -854,11 +854,11 @@ pair<LPResult, variant<Model, ReasonSet>> LPSolver::check(SolvingState _state)
if (canOnlyBeUnknown)
{
cout << "-> LP unknown." << endl;
//cout << "-> LP unknown." << endl;
return {LPResult::Unknown, Model{}};
}
cout << "-> LP feasible." << endl;
//cout << "-> LP feasible." << endl;
return {LPResult::Feasible, move(model)};
}