Examples with Antecedent at.ac.tuwien.kr.alpha.core.solver.Antecedent used on opensource projects

Example 1 with Antecedent

use of at.ac.tuwien.kr.alpha.core.solver.Antecedent in project Alpha by alpha-asp.

the class GroundConflictNoGoodLearnerTest method smallConflictNonTrivial1UIP.

@Test
public void smallConflictNonTrivial1UIP() {
    GroundConflictNoGoodLearner learner = new GroundConflictNoGoodLearner(assignment, atomStore);
    NoGood n1 = new NoGood(fromOldLiterals(2, -8, 1));
    NoGood n2 = new NoGood(fromOldLiterals(-1, -7));
    NoGood n3 = new NoGood(fromOldLiterals(-3, 1));
    NoGood n4 = new NoGood(fromOldLiterals(5, 3));
    NoGood n5 = new NoGood(fromOldLiterals(6, -5));
    NoGood n6 = new NoGood(fromOldLiterals(4, -2));
    NoGood n7 = new NoGood(fromOldLiterals(-6, -4));
    store.add(10, n1);
    store.add(11, n2);
    store.add(12, n3);
    store.add(13, n4);
    store.add(14, n5);
    store.add(15, n6);
    store.add(16, n7);
    assignment.choose(9, ThriceTruth.TRUE);
    assignment.choose(8, ThriceTruth.FALSE);
    assertNull(store.propagate());
    assertFalse(store.didPropagate());
    assignment.choose(7, ThriceTruth.FALSE);
    ConflictCause conflictCause = store.propagate();
    assertTrue(store.didPropagate());
    assertNotNull(conflictCause);
    Antecedent violatedNoGood = conflictCause.getAntecedent();
    assertNotNull(violatedNoGood);
    assertTrue(antecedentsEquals(violatedNoGood, n5.asAntecedent()) || antecedentsEquals(violatedNoGood, n7.asAntecedent()));
    GroundConflictNoGoodLearner.ConflictAnalysisResult analysisResult = learner.analyzeConflictingNoGood(conflictCause.getAntecedent());
    NoGood learnedNoGood = analysisResult.learnedNoGood;
    assertEquals(new NoGood(fromOldLiterals(1, -8)), learnedNoGood);
    int backjumpingDecisionLevel = analysisResult.backjumpLevel;
    assertEquals(backjumpingDecisionLevel, 2);
}

Example 2 with Antecedent

use of at.ac.tuwien.kr.alpha.core.solver.Antecedent in project Alpha by alpha-asp.

the class GroundConflictNoGoodLearner method analyzeTrailBased.

private ConflictAnalysisResult analyzeTrailBased(Antecedent conflictReason) {
    LOGGER.trace("Analyzing trail based.");
    if (assignment.getDecisionLevel() == 0) {
        LOGGER.trace("Conflict on decision level 0.");
        return ConflictAnalysisResult.UNSAT;
    }
    int numLiteralsInConflictLevel = 0;
    List<Integer> resolutionLiterals = new ArrayList<>();
    List<Integer> resolutionAtoms = new ArrayList<>();
    int currentDecisionLevel = assignment.getDecisionLevel();
    // NOTE: other solvers use a global array for seen atoms, this might be slightly faster (initial tests with local arrays showed no significant improvement).
    Set<Integer> seenAtoms = new HashSet<>();
    // Since trail contains 2 entries for MBT->TRUE assigned atoms, explicitly record which seen atoms have ben processed to avoid processing seen atoms twice.
    Set<Integer> processedAtoms = new HashSet<>();
    int[] currentConflictReason = conflictReason.getReasonLiterals();
    int backjumpLevel = -1;
    conflictReason.bumpActivity();
    TrailAssignment.TrailBackwardsWalker trailWalker = ((TrailAssignment) assignment).getTrailBackwardsWalker();
    if (LOGGER.isTraceEnabled()) {
        LOGGER.trace("Current trail is: {}", trailWalker);
        LOGGER.trace("Violated nogood is: {}", reasonsToString(conflictReason.getReasonLiterals()));
    }
    int nextAtom = -1;
    do {
        // Add current conflict reasons; only add those of lower decision levels, since from current one, only the 1UIP literal will be added.
        if (LOGGER.isTraceEnabled()) {
            LOGGER.trace("Atom {} implied by {}, resolving with that nogood", nextAtom, reasonsToString(currentConflictReason));
        }
        for (int literal : currentConflictReason) {
            // Seen atoms have already been dealt with.
            if (!seenAtoms.contains(atomOf(literal))) {
                seenAtoms.add(atomOf(literal));
                int literalDecisionLevel = assignment.getWeakDecisionLevel(atomOf(literal));
                if (literalDecisionLevel == currentDecisionLevel) {
                    numLiteralsInConflictLevel++;
                } else {
                    resolutionLiterals.add(literal);
                    if (literalDecisionLevel > backjumpLevel) {
                        backjumpLevel = literalDecisionLevel;
                    }
                }
                resolutionAtoms.add(atomOf(literal));
            }
        }
        if (LOGGER.isTraceEnabled()) {
            LOGGER.trace("LiteralsInConflictLevel now: {}", numLiteralsInConflictLevel);
            LOGGER.trace("Seen atoms are {}.", seenAtoms);
            LOGGER.trace("Intermediate learned literals: {}", reasonsToString(resolutionLiterals));
        }
        // Find next literal, i.e. first from top of trail that has been seen but is not yet processed, also skip atoms whose TRUE assignment is on current level but their MBT/weak assignment is lower.
        do {
            int nextLiteral = trailWalker.getNextLowerLiteral();
            nextAtom = atomOf(nextLiteral);
            if (LOGGER.isTraceEnabled()) {
                LOGGER.trace("Next literal on trail is: {}", isPositive(nextLiteral) ? "+" + nextAtom : "-" + nextAtom);
            }
        } while (assignment.getWeakDecisionLevel(nextAtom) != currentDecisionLevel || !seenAtoms.contains(nextAtom) || processedAtoms.contains(nextAtom));
        Antecedent impliedBy = assignment.getImpliedBy(nextAtom);
        if (impliedBy != null) {
            currentConflictReason = impliedBy.getReasonLiterals();
            impliedBy.bumpActivity();
        }
        processedAtoms.add(nextAtom);
    } while (numLiteralsInConflictLevel-- > 1);
    // Add the 1UIP literal.
    resolutionLiterals.add(atomToLiteral(nextAtom, assignment.getTruth(nextAtom).toBoolean()));
    int[] learnedLiterals = minimizeLearnedLiterals(resolutionLiterals, seenAtoms);
    NoGood learnedNoGood = NoGood.learnt(learnedLiterals);
    if (LOGGER.isTraceEnabled()) {
        LOGGER.trace("Learned NoGood is: {}", atomStore.noGoodToString(learnedNoGood));
    }
    int backjumpingDecisionLevel = computeBackjumpingDecisionLevel(learnedNoGood);
    if (backjumpingDecisionLevel < 0) {
        // Due to out-of-order assigned literals, the learned nogood may be not assigning.
        backjumpingDecisionLevel = computeConflictFreeBackjumpingLevel(learnedNoGood);
        if (backjumpingDecisionLevel < 0) {
            return ConflictAnalysisResult.UNSAT;
        }
    }
    if (LOGGER.isTraceEnabled()) {
        LOGGER.trace("Backjumping decision level: {}", backjumpingDecisionLevel);
    }
    return new ConflictAnalysisResult(learnedNoGood, backjumpingDecisionLevel, resolutionAtoms, computeLBD(learnedLiterals));
}