/**
* If this formula should be visited, then we visit its children only if they could have
* contributed to the unsatisfiability of the top-level formula. For example, let binFormula =
* "p && q", binFormula simplified to FALSE, p simplified to FALSE and q was not simplified,
* then only p should be visited since p caused binFormula's reduction to FALSE.
*/
public void visit(BinaryFormula binFormula) {
if (visited(binFormula)) return;
relevant.add(binFormula);
final Formula l = binFormula.left(), r = binFormula.right();
final Boolean lval = constNodes.get(l), rval = constNodes.get(r);
final boolean lvisit, rvisit;
switch (binFormula.op()) {
case AND:
lvisit = (lval == Boolean.FALSE || (lval == null && rval != Boolean.FALSE));
rvisit = (rval != Boolean.TRUE && lval != Boolean.FALSE);
break;
case OR:
lvisit = (lval == Boolean.TRUE || (lval == null && rval != Boolean.TRUE));
rvisit = (rval != Boolean.FALSE && lval != Boolean.TRUE);
break;
case IMPLIES: // !l || r
lvisit = (lval == Boolean.FALSE || (lval == null && rval != Boolean.TRUE));
rvisit = (rval != Boolean.FALSE && lval != Boolean.FALSE);
break;
case IFF: // (!l || r) && (l || !r)
lvisit = rvisit = true;
break;
default:
throw new IllegalArgumentException("Unknown operator: " + binFormula.op());
}
if (lvisit) {
l.accept(this);
}
if (rvisit) {
r.accept(this);
}
}
/**
* Returns the nodes necessary for proving the trivial unsatisfiability of log.formula.
*
* @requires some r: log.records | r.node = log.formula && r.literal =
* BooleanConstant.FALSE.label
* @requires highLevelCore in log.roots() and unsatisfiable(highLevelCore, log.bounds,
* log.options)
* @return nodes necessary for proving the trivial unsatisfiability of log.formula.
*/
static Set<Node> relevantNodes(TranslationLog log, Set<Formula> highLevelCore) {
final NodePruner finder = new NodePruner(log);
for (Formula root : highLevelCore) {
if (!finder.isTrue(root)) {
root.accept(finder);
}
}
return finder.relevant;
}
/**
* If this formula should be visited, then we visit its children only if they could have
* contributed to the unsatisfiability of the top-level formula. For example, let binFormula =
* "p && q", binFormula simplified to FALSE, p simplified to FALSE and q was not simplified,
* then only p should be visited since p caused binFormula's reduction to FALSE.
*/
public void visit(NaryFormula formula) {
if (visited(formula)) return;
relevant.add(formula);
final Boolean val = constNodes.get(formula);
final Boolean cancel;
switch (formula.op()) {
case AND:
cancel = Boolean.FALSE;
break;
case OR:
cancel = Boolean.TRUE;
break;
default:
throw new IllegalArgumentException("Unknown nary operator: " + formula.op());
}
final Boolean iden = Boolean.valueOf(!cancel);
if (val != iden) {
for (Formula child : formula) {
if (constNodes.get(child) == cancel) {
child.accept(this);
return;
}
}
for (Formula child : formula) {
if (constNodes.get(child) != iden) {
child.accept(this);
}
}
return;
}
for (Formula child : formula) {
child.accept(this);
}
}
