use of kodkod.util.ints.IntBitSet in project org.alloytools.alloy by AlloyTools.
the class StrategyUtils method clausesFor.
/**
* Returns the indices of all axioms in the given trace that form the
* translations of the formulas identified by the given variables. This method
* assumes that the axioms in the given trace were generated by the Kodkod
* {@linkplain Translator}.
*
* @return let C = { c: trace.prover.clauses | c.maxVariable() in relevantVars
* }, T = { c1, c2: C | c2.maxVariable() in abs(c1.literals) } | C.*T
*/
static IntSet clausesFor(ResolutionTrace trace, IntSet relevantVars) {
// System.out.println("relevant: " + relevantVars);
final IntSet axioms = trace.axioms();
final IntSet reachableVars = new IntBitSet(relevantVars.max() + 1);
reachableVars.addAll(relevantVars);
final IntSet relevantAxioms = new IntBitSet(axioms.size());
final Iterator<Clause> itr = trace.reverseIterator(axioms);
for (int i = axioms.max(); i >= 0; i--) {
Clause clause = itr.next();
int maxVar = clause.maxVariable();
if (reachableVars.contains(maxVar)) {
for (IntIterator lits = clause.literals(); lits.hasNext(); ) {
reachableVars.add(StrictMath.abs(lits.next()));
}
relevantAxioms.add(i);
}
}
return relevantAxioms;
}
use of kodkod.util.ints.IntBitSet in project org.alloytools.alloy by AlloyTools.
the class StrategyUtils method coreVars.
/**
* Returns the variables that correspond to the roots of log.formula, in the
* order in which they were specified in log.formula.
*
* @return variables that correspond to the roots of log.formula, in the order
* in which they were specified in log.formula.
*/
// static IntVector orderedRootVars(TranslationLog log) {
// final Set<Formula> roots = log.roots();
// final Map<Formula,int[]> maxRootVar = new
// LinkedHashMap<Formula,int[]>(roots.size());
// final RecordFilter filter = new RecordFilter() {
// public boolean accept(Node node, int literal, Map<Variable, TupleSet>
// env) {
// return roots.contains(node) && env.isEmpty();
// }
// };
// for(Iterator<TranslationRecord> itr = log.replay(filter); itr.hasNext();)
// {
// TranslationRecord record = itr.next();
// int[] var = maxRootVar.get(record.node());
// if (var==null) {
// var = new int[1];
// maxRootVar.put((Formula)record.node(), var);
// }
// var[0] = StrictMath.abs(record.literal());
// }
// final IntSet uniqueRoots = new IntTreeSet();
// final IntVector orderedRoots = new ArrayIntVector(roots.size());
// for(int[] var : maxRootVar.values()) {
// int topVar = var[0];
// if (topVar != Integer.MAX_VALUE) // formula simplified to TRUE
// if (uniqueRoots.add(var[0])) {
// orderedRoots.add(var[0]);
// };
// }
// return orderedRoots;
// }
/**
* Returns relevant core variables; that is, all variables that occur both in
* the positive and negative phase in trace.core.
*
* @return { v: [1..) | (some p, n: trace.core | v in trace.elts[p].literals and
* -v in trace.elts[n].literals) }
*/
public static IntSet coreVars(ResolutionTrace trace) {
final IntSet posVars = new IntTreeSet(), negVars = new IntTreeSet();
for (Iterator<Clause> iter = trace.iterator(trace.core()); iter.hasNext(); ) {
Clause clause = iter.next();
for (IntIterator lits = clause.literals(); lits.hasNext(); ) {
int lit = lits.next();
if (lit > 0)
posVars.add(lit);
else
negVars.add(-lit);
}
}
posVars.retainAll(negVars);
assert !posVars.isEmpty();
final IntSet ret = new IntBitSet(posVars.max() + 1);
ret.addAll(posVars);
return ret;
}
use of kodkod.util.ints.IntBitSet in project org.alloytools.alloy by AlloyTools.
the class LazyTrace method directlyLearnable.
/**
* {@inheritDoc}
*
* @see kodkod.engine.satlab.ResolutionTrace#directlyLearnable(kodkod.util.ints.IntSet)
*/
@Override
public IntSet directlyLearnable(IntSet indices) {
if (indices.isEmpty())
return Ints.EMPTY_SET;
else if (valid(indices)) {
final IntSet ret = new IntBitSet(trace.length);
ret.addAll(indices);
TOP: for (int i = axioms, length = trace.length; i < length; i++) {
int[] resolvent = trace[i];
if (resolved(i)) {
for (int j = 1, antes = resolvent[0]; j <= antes; j++) {
if (!indices.contains(resolvent[j])) {
continue TOP;
}
}
} else {
for (int j = 0; j < resolvent.length; j++) {
if (!indices.contains(resolvent[j])) {
continue TOP;
}
}
}
ret.add(i);
}
return ret;
} else
throw new IndexOutOfBoundsException("invalid indices: " + indices);
}
use of kodkod.util.ints.IntBitSet in project org.alloytools.alloy by AlloyTools.
the class LazyTrace method learnable.
/**
* {@inheritDoc}
*
* @see kodkod.engine.satlab.ResolutionTrace#learnable(kodkod.util.ints.IntSet)
*/
@Override
public IntSet learnable(IntSet indices) {
if (indices.isEmpty())
return Ints.EMPTY_SET;
else if (valid(indices)) {
final IntSet ret = new IntBitSet(trace.length);
ret.addAll(indices);
TOP: for (int i = axioms, length = trace.length; i < length; i++) {
int[] resolvent = trace[i];
if (resolved(i)) {
for (int j = 1, antes = resolvent[0]; j <= antes; j++) {
if (!ret.contains(resolvent[j])) {
continue TOP;
}
}
} else {
for (int j = 0; j < resolvent.length; j++) {
if (!ret.contains(resolvent[j])) {
continue TOP;
}
}
}
ret.add(i);
}
return ret;
} else
throw new IndexOutOfBoundsException("invalid indices: " + indices);
}
use of kodkod.util.ints.IntBitSet in project org.alloytools.alloy by AlloyTools.
the class MiniSatProver method formatTrivial.
/**
* Returns a subset of the given trivial trace that consists only of axioms. A
* trace is trivial iff its last clause is an empty clause. This means that the
* empty axiom was added to the solver via {@linkplain #addClause(int[])}, so no
* resolution was necessary to reach the conflict. The empty axiom is always the
* last clause in the trace.
*
* @requires trace[trace.length].length = 0
* @return a subset of the given trivial trace that consists only of axioms
*/
private int[][] formatTrivial(int[][] trace) {
final int length = trace.length;
final int empty = length - 1;
final IntSet axioms = new IntBitSet(length);
axioms.add(empty);
final int numVars = numberOfVariables();
for (int i = 0; i < empty; i++) {
int[] clause = trace[i];
if (clause[0] <= numVars) {
axioms.add(i);
}
}
if (axioms.size() == length) {
return trace;
}
final int[][] axiomClauses = new int[axioms.size()][];
final IntIterator itr = axioms.iterator();
for (int i = 0; itr.hasNext(); i++) {
axiomClauses[i] = trace[itr.next()];
}
return axiomClauses;
}
Aggregations