Example 41 with Term
use of at.ac.tuwien.kr.alpha.api.terms.Term in project Alpha by alpha-asp.
the class HanoiTowerTest method checkGoal.
/**
* Conducts a very simple, non-comprehensive goal check (i.e. it may classify answer sets as correct that are actually wrong) by checking if
* for every goal/3
* fact in the input there is a corresponding on/3 atom in the output.
*/
private void checkGoal(ASPCore2Program parsedProgram, AnswerSet answerSet) {
Predicate ongoal = Predicates.getPredicate("ongoal", 2);
Predicate on = Predicates.getPredicate("on", 3);
int steps = getSteps(parsedProgram);
SortedSet<Atom> onInstancesInAnswerSet = answerSet.getPredicateInstances(on);
for (Atom atom : parsedProgram.getFacts()) {
if (atom.getPredicate().getName().equals(ongoal.getName()) && atom.getPredicate().getArity() == ongoal.getArity()) {
Term expectedTop = atom.getTerms().get(0);
Term expectedBottom = atom.getTerms().get(1);
Term expectedSteps = Terms.newConstant(steps);
Atom expectedAtom = Atoms.newBasicAtom(on, expectedSteps, expectedBottom, expectedTop);
assertTrue(onInstancesInAnswerSet.contains(expectedAtom), "Answer set does not contain " + expectedAtom);
}
}
}Example 42 with Term
use of at.ac.tuwien.kr.alpha.api.terms.Term in project Alpha by alpha-asp.
the class ThreeColouringWheelTest method fact.
private Atom fact(String predicateName, int... iTerms) {
List<Term> terms = new ArrayList<>(1);
Predicate predicate = Predicates.getPredicate(predicateName, iTerms.length);
for (int i : iTerms) {
terms.add(Terms.newConstant(i));
}
return Atoms.newBasicAtom(predicate, terms);
}Example 43 with Term
use of at.ac.tuwien.kr.alpha.api.terms.Term in project Alpha by alpha-asp.
the class IntervalTermToIntervalAtom method rewriteFunctionTerm.
private static FunctionTerm rewriteFunctionTerm(FunctionTerm functionTerm, Map<VariableTerm, IntervalTerm> intervalReplacement) {
List<Term> termList = new ArrayList<>(functionTerm.getTerms());
boolean didChange = false;
for (int i = 0; i < termList.size(); i++) {
Term term = termList.get(i);
if (term instanceof IntervalTerm) {
VariableTerm replacementVariable = Terms.newVariable("_Interval" + intervalReplacement.size());
intervalReplacement.put(replacementVariable, (IntervalTerm) term);
termList.set(i, replacementVariable);
didChange = true;
}
if (term instanceof FunctionTerm) {
// Recursively rewrite function terms.
FunctionTerm rewrittenFunctionTerm = rewriteFunctionTerm((FunctionTerm) term, intervalReplacement);
if (rewrittenFunctionTerm != term) {
termList.set(i, rewrittenFunctionTerm);
didChange = true;
}
}
}
if (didChange) {
return Terms.newFunctionTerm(functionTerm.getSymbol(), termList);
}
return functionTerm;
}
Also used :
FunctionTerm(at.ac.tuwien.kr.alpha.api.terms.FunctionTerm)
ArrayList(java.util.ArrayList)
IntervalTerm(at.ac.tuwien.kr.alpha.commons.terms.IntervalTerm)
VariableTerm(at.ac.tuwien.kr.alpha.api.terms.VariableTerm)
Term(at.ac.tuwien.kr.alpha.api.terms.Term)
IntervalTerm(at.ac.tuwien.kr.alpha.commons.terms.IntervalTerm)
VariableTerm(at.ac.tuwien.kr.alpha.api.terms.VariableTerm)
FunctionTerm(at.ac.tuwien.kr.alpha.api.terms.FunctionTerm)
Example 44 with Term
use of at.ac.tuwien.kr.alpha.api.terms.Term in project Alpha by alpha-asp.
the class MinMaxEncoder method buildElementRuleHead.
@Override
protected BasicAtom buildElementRuleHead(String aggregateId, AggregateElement element, Term aggregateArguments) {
Predicate headPredicate = Predicates.getPredicate(this.getElementTuplePredicateSymbol(aggregateId), 2);
Term elementTerm = element.getElementTerms().get(0);
return Atoms.newBasicAtom(headPredicate, aggregateArguments, elementTerm);
}
Also used :
Term(at.ac.tuwien.kr.alpha.api.terms.Term)
VariableTerm(at.ac.tuwien.kr.alpha.api.terms.VariableTerm)
Predicate(at.ac.tuwien.kr.alpha.api.programs.Predicate)
Example 45 with Term
use of at.ac.tuwien.kr.alpha.api.terms.Term in project Alpha by alpha-asp.
the class ChoiceHeadToNormal method apply.
@Override
public ASPCore2Program apply(ASPCore2Program inputProgram) {
InputProgram.Builder programBuilder = InputProgram.builder();
List<Rule<Head>> additionalRules = new ArrayList<>();
List<Rule<Head>> srcRules = new ArrayList<>(inputProgram.getRules());
Iterator<Rule<Head>> ruleIterator = srcRules.iterator();
while (ruleIterator.hasNext()) {
Rule<Head> rule = ruleIterator.next();
Head ruleHead = rule.getHead();
if (!(ruleHead instanceof ChoiceHead)) {
// Rule is constraint or without choice in the head. Leave as is.
continue;
}
// Remove this rule, as it will be transformed.
ruleIterator.remove();
ChoiceHead choiceHead = (ChoiceHead) ruleHead;
// Choice rules with boundaries are not yet supported.
if (choiceHead.getLowerBound() != null || choiceHead.getUpperBound() != null) {
throw new UnsupportedOperationException("Found choice rule with bounds, which are not yet supported. Rule is: " + rule);
}
// Only rewrite rules with a choice in their head.
for (ChoiceElement choiceElement : choiceHead.getChoiceElements()) {
// Create two guessing rules for each choiceElement.
// Construct common body to both rules.
BasicAtom head = choiceElement.getChoiceAtom();
List<Literal> ruleBody = new ArrayList<>(rule.getBody());
ruleBody.addAll(choiceElement.getConditionLiterals());
if (containsIntervalTerms(head)) {
throw new RuntimeException("Program contains a choice rule with interval terms in its head. This is not supported (yet).");
}
// Construct head atom for the choice.
Predicate headPredicate = head.getPredicate();
Predicate negPredicate = Predicates.getPredicate(PREDICATE_NEGATION_PREFIX + headPredicate.getName(), headPredicate.getArity() + 1, true);
List<Term> headTerms = new ArrayList<>(head.getTerms());
// FIXME: when introducing classical negation, this is 1 for classical positive atoms and 0 for
headTerms.add(0, Terms.newConstant("1"));
// classical negative atoms.
BasicAtom negHead = Atoms.newBasicAtom(negPredicate, headTerms);
// Construct two guessing rules.
List<Literal> guessingRuleBodyWithNegHead = new ArrayList<>(ruleBody);
guessingRuleBodyWithNegHead.add(Atoms.newBasicAtom(head.getPredicate(), head.getTerms()).toLiteral(false));
additionalRules.add(new BasicRule(Heads.newNormalHead(negHead), guessingRuleBodyWithNegHead));
List<Literal> guessingRuleBodyWithHead = new ArrayList<>(ruleBody);
guessingRuleBodyWithHead.add(Atoms.newBasicAtom(negPredicate, headTerms).toLiteral(false));
additionalRules.add(new BasicRule(Heads.newNormalHead(head), guessingRuleBodyWithHead));
// TODO: when cardinality constraints are possible, process the boundaries by adding a constraint with a cardinality check.
}
}
return programBuilder.addRules(srcRules).addRules(additionalRules).addFacts(inputProgram.getFacts()).addInlineDirectives(inputProgram.getInlineDirectives()).build();
}
Also used :
BasicRule(at.ac.tuwien.kr.alpha.core.rules.BasicRule)
ChoiceHead(at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead)
Head(at.ac.tuwien.kr.alpha.api.rules.heads.Head)
ArrayList(java.util.ArrayList)
Term(at.ac.tuwien.kr.alpha.api.terms.Term)
IntervalTerm(at.ac.tuwien.kr.alpha.commons.terms.IntervalTerm)
Predicate(at.ac.tuwien.kr.alpha.api.programs.Predicate)
ChoiceElement(at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead.ChoiceElement)
ChoiceHead(at.ac.tuwien.kr.alpha.api.rules.heads.ChoiceHead)
Literal(at.ac.tuwien.kr.alpha.api.programs.literals.Literal)
Rule(at.ac.tuwien.kr.alpha.api.rules.Rule)
BasicRule(at.ac.tuwien.kr.alpha.core.rules.BasicRule)
BasicAtom(at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom)
InputProgram(at.ac.tuwien.kr.alpha.core.programs.InputProgram)
Aggregations
Term (at.ac.tuwien.kr.alpha.api.terms.Term)52
VariableTerm (at.ac.tuwien.kr.alpha.api.terms.VariableTerm)36
ArrayList (java.util.ArrayList)16
ConstantTerm (at.ac.tuwien.kr.alpha.api.terms.ConstantTerm)15
FunctionTerm (at.ac.tuwien.kr.alpha.api.terms.FunctionTerm)15
IntervalTerm (at.ac.tuwien.kr.alpha.commons.terms.IntervalTerm)12
ArithmeticTerm (at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm)10
Predicate (at.ac.tuwien.kr.alpha.api.programs.Predicate)9
Test (org.junit.jupiter.api.Test)8
Literal (at.ac.tuwien.kr.alpha.api.programs.literals.Literal)7
Atom (at.ac.tuwien.kr.alpha.api.programs.atoms.Atom)6
BasicSubstitution (at.ac.tuwien.kr.alpha.commons.substitutions.BasicSubstitution)6
HashSet (java.util.HashSet)6
AggregateLiteral (at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral)4
Instance (at.ac.tuwien.kr.alpha.commons.substitutions.Instance)4
Substitution (at.ac.tuwien.kr.alpha.api.grounder.Substitution)3
BasicAtom (at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom)3
ComparisonLiteral (at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral)3
Unifier (at.ac.tuwien.kr.alpha.commons.substitutions.Unifier)3
MinusTerm (at.ac.tuwien.kr.alpha.commons.terms.ArithmeticTermImpl.MinusTerm)3
