Examples with CompiledRule at.ac.tuwien.kr.alpha.core.rules.CompiledRule used on opensource projects

Example 16 with CompiledRule

use of at.ac.tuwien.kr.alpha.core.rules.CompiledRule in project Alpha by alpha-asp.

the class StratifiedEvaluation method evaluateRules.

private void evaluateRules(Set<CompiledRule> rules, boolean isInitialRun) {
    workingMemory.reset();
    LOGGER.debug("Starting component evaluation run...");
    for (CompiledRule r : rules) {
        evaluateRule(r, !isInitialRun);
    }
}

Example 17 with CompiledRule

use of at.ac.tuwien.kr.alpha.core.rules.CompiledRule in project Alpha by alpha-asp.

the class AnalyzeUnjustified method rulesHeadUnifyingWith.

private List<RuleAndUnifier> rulesHeadUnifyingWith(Atom p) {
    List<RuleAndUnifier> rulesWithUnifier = new ArrayList<>();
    Predicate predicate = p.getPredicate();
    ArrayList<FactOrNonGroundRule> definingRulesAndFacts = new ArrayList<>();
    // Get facts over the same predicate.
    LinkedHashSet<Instance> factInstances = factsFromProgram.get(predicate);
    if (factInstances != null) {
        for (Instance factInstance : factInstances) {
            definingRulesAndFacts.add(new FactOrNonGroundRule(factInstance));
        }
    }
    HashSet<CompiledRule> rulesDefiningPredicate = programAnalysis.getPredicateDefiningRules().get(predicate);
    if (rulesDefiningPredicate != null) {
        for (CompiledRule nonGroundRule : rulesDefiningPredicate) {
            definingRulesAndFacts.add(new FactOrNonGroundRule(nonGroundRule));
        }
    }
    for (FactOrNonGroundRule factOrNonGroundRule : definingRulesAndFacts) {
        boolean isNonGroundRule = factOrNonGroundRule.nonGroundRule != null;
        Set<Literal> renamedBody;
        Atom headAtom;
        if (isNonGroundRule) {
            // First rename all variables in the rule.
            CompiledRule rule = factOrNonGroundRule.nonGroundRule.renameVariables("_" + renamingCounter++);
            renamedBody = rule.getBody();
            headAtom = rule.getHeadAtom();
        } else {
            // Create atom and empty rule body out of instance.
            headAtom = Atoms.newBasicAtom(p.getPredicate(), factOrNonGroundRule.factInstance.terms);
            renamedBody = Collections.emptySet();
        }
        // Unify rule head with literal to justify.
        Unifier unifier = Unification.unifyAtoms(p, headAtom);
        // Skip if unification failed.
        if (unifier == null) {
            continue;
        }
        rulesWithUnifier.add(new RuleAndUnifier(renamedBody, unifier, headAtom));
    }
    return rulesWithUnifier;
}

Example 18 with CompiledRule

use of at.ac.tuwien.kr.alpha.core.rules.CompiledRule in project Alpha by alpha-asp.

the class NaiveGrounder method initializeFactsAndRules.

private void initializeFactsAndRules() {
    // Initialize all facts.
    for (Atom fact : program.getFacts()) {
        final Predicate predicate = fact.getPredicate();
        // Record predicate
        workingMemory.initialize(predicate);
    }
    // Register internal atoms.
    workingMemory.initialize(RuleAtom.PREDICATE);
    workingMemory.initialize(ChoiceAtom.OFF);
    workingMemory.initialize(ChoiceAtom.ON);
    // Initialize rules and constraints in working memory.
    for (CompiledRule nonGroundRule : program.getRulesById().values()) {
        // Create working memories for all predicates occurring in the rule.
        for (Predicate predicate : nonGroundRule.getOccurringPredicates()) {
            // FIXME: this also contains interval/builtin predicates that are not needed.
            workingMemory.initialize(predicate);
        }
        // If the rule has fixed ground instantiations, it is not registered but grounded once like facts.
        if (nonGroundRule.getGroundingInfo().hasFixedInstantiation()) {
            fixedRules.add(nonGroundRule);
            continue;
        }
        // Register each starting literal at the corresponding working memory.
        for (Literal literal : nonGroundRule.getGroundingInfo().getStartingLiterals()) {
            registerLiteralAtWorkingMemory(literal, nonGroundRule);
        }
    }
}

Example 19 with CompiledRule

use of at.ac.tuwien.kr.alpha.core.rules.CompiledRule in project Alpha by alpha-asp.

the class NaiveGrounderTest method testDeadEnd.

/**
 * Tests the method {@link NaiveGrounder#getGroundInstantiations(InternalRule, RuleGroundingOrder, Substitution, Assignment)} on a
 * predefined program:
 * <code>
 *  p1(1). q1(1). <br/>
 * 	x :- p1(X), p2(X), q1(Y), q2(Y). <br/>
 * 	p2(X) :- something(X). <br/>
 * 	q2(X) :- something(X). <br/>
 * </code>
 * Given one grounding order {@code groundingOrder} for the first rule in this program which starts with
 * the literal whose predicate name is {@code predicateNameOfStartingLiteral} and a substitution substituting
 * the variable in this literal by 1 it is attempted to ground the rule.
 * It is then asserted that ground instantiations are produced if and only if {@code expectNoGoods} is true.
 *
 * @param predicateNameOfStartingLiteral the predicate name of the starting literal, either "p1" or "q1".
 * @param groundingOrder                 a grounding order for the first rule in the predefined program that starts with the literal
 *                                       whose predicate name is {@code predicateNameOfStartingLiteral}.
 * @param expectNoGoods                  {@code true} iff ground instantiations are expected to be produced under the conditions
 *                                       described above.
 */
private void testDeadEnd(String predicateNameOfStartingLiteral, RuleGroundingOrderImpl groundingOrder, boolean expectNoGoods) {
    String aspStr = "p1(1). q1(1). " + "x :- p1(X), p2(X), q1(Y), q2(Y). " + "p2(X) :- something(X). " + "q2(X) :- something(X). ";
    CompiledProgram program = InternalProgram.fromNormalProgram(NORMALIZE_TRANSFORM.apply(PROGRAM_PARSER.parse(aspStr)));
    AtomStore atomStore = new AtomStoreImpl();
    NaiveGrounder grounder = (NaiveGrounder) GrounderFactory.getInstance("naive", program, atomStore, p -> true, GrounderHeuristicsConfiguration.permissive(), true);
    CompiledRule nonGroundRule = grounder.getNonGroundRule(0);
    String strLiteral = "p1".equals(predicateNameOfStartingLiteral) ? "p1(X)" : "p1(Y)";
    final Literal startingLiteral = PROGRAM_PART_PARSER.parseLiteral(strLiteral);
    ((RuleGroundingInfoImpl) nonGroundRule.getGroundingInfo()).groundingOrders.put(startingLiteral, groundingOrder);
    grounder.bootstrap();
    TrailAssignment currentAssignment = new TrailAssignment(atomStore);
    final Substitution subst1 = BasicSubstitution.specializeSubstitution(startingLiteral, new Instance(Terms.newConstant(1)), BasicSubstitution.EMPTY_SUBSTITUTION);
    final BindingResult bindingResult = grounder.getGroundInstantiations(nonGroundRule, groundingOrder, subst1, currentAssignment);
    assertEquals(expectNoGoods, bindingResult.size() > 0);
}

Example 20 with CompiledRule

use of at.ac.tuwien.kr.alpha.core.rules.CompiledRule in project Alpha by alpha-asp.

the class NaiveGrounderTest method testIfGrounderGroundsRule.

/**
 * Tests if {@link NaiveGrounder#getGroundInstantiations(InternalRule, RuleGroundingOrder, Substitution, Assignment)}
 * produces ground instantiations for the rule with ID {@code ruleID} in {@code program} when {@code startingLiteral}
 * unified with the numeric instance {@code startingInstance} is used as starting literal and {@code b(1)} is assigned
 * {@code bTruth}.
 * It is asserted that ground instantiations are produced if and only if {@code expectNoGoods} is true.
 */
private void testIfGrounderGroundsRule(ASPCore2Program program, int ruleID, Literal startingLiteral, int startingInstance, ThriceTruth bTruth, boolean expectNoGoods) {
    CompiledProgram internalPrg = InternalProgram.fromNormalProgram(NORMALIZE_TRANSFORM.apply(program));
    AtomStore atomStore = new AtomStoreImpl();
    TrailAssignment currentAssignment = new TrailAssignment(atomStore);
    NaiveGrounder grounder = (NaiveGrounder) GrounderFactory.getInstance("naive", internalPrg, atomStore, p -> true, GrounderHeuristicsConfiguration.permissive(), true);
    int b = atomStore.putIfAbsent(atom("b", 1));
    currentAssignment.growForMaxAtomId();
    currentAssignment.assign(b, bTruth);
    grounder.bootstrap();
    final CompiledRule nonGroundRule = grounder.getNonGroundRule(ruleID);
    final Substitution substStartingLiteral = BasicSubstitution.specializeSubstitution(startingLiteral, new Instance(Terms.newConstant(startingInstance)), BasicSubstitution.EMPTY_SUBSTITUTION);
    final BindingResult bindingResult = grounder.getGroundInstantiations(nonGroundRule, nonGroundRule.getGroundingInfo().orderStartingFrom(startingLiteral), substStartingLiteral, currentAssignment);
    assertEquals(expectNoGoods, bindingResult.size() > 0);
}