diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java index 2cc01b42a..74ef89dac 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/Alpha.java @@ -28,18 +28,18 @@ public interface Alpha { * * @param cfg and {@link InputConfig} specifying program sources (strings, files) as well as config metadata (e.g. literate program, * external atoms, etc) - * @return an {@link ASPCore2Program} representing the parsed ASP code from all sources referenced in the given {@link InputConfig} + * @return an {@link InputProgram} representing the parsed ASP code from all sources referenced in the given {@link InputConfig} * @throws IOException in case one or more program sources (e.g. files) cannot be read, or parsing fails */ InputProgram readProgram(InputConfig cfg) throws IOException; /** - * Reads and parses an {@link ASPCore2Program} from a list of {@link String}s representing paths. + * Reads and parses an {@link InputProgram} from a list of {@link String}s representing paths. * * @param literate flag indicating whether ASP code should be treated as "literate". * @param externals Custom {@link PredicateInterpretation}s for user-defined external atoms * @param paths a list of {@link String}s representing paths containing all sources from which ASP code should be read - * @return an {@link ASPCore2Program} representing the parsed ASP code from all given path strings + * @return an {@link InputProgram} representing the parsed ASP code from all given path strings * @throws IOException in case one or more program sources cannot be read, or parsing fails */ InputProgram readProgramFiles(boolean literate, Map externals, List paths) throws IOException; @@ -50,12 +50,12 @@ public interface Alpha { InputProgram readProgramFiles(boolean literate, Map externals, Path... paths) throws IOException; /** - * Parses a given String into an {@link ASPCore2Program}, using a map of custom {@link PredicateInterpretation}s to resolve external atoms + * Parses a given String into an {@link InputProgram}, using a map of custom {@link PredicateInterpretation}s to resolve external atoms * in ASP code. * * @param aspString a string representing a valid ASP-Core2 program * @param externals a map of custom {@link PredicateInterpretation}s against which external atoms in the given code are resolved - * @return an {@link ASPCore2Program} representing the parsed ASP code + * @return an {@link InputProgram} representing the parsed ASP code */ InputProgram readProgramString(String aspString, Map externals); @@ -75,7 +75,7 @@ public interface Alpha { InputProgram readProgramStream(InputStream is, Map externals) throws IOException; /** - * Prepares a {@link DebugSolvingContext} for the given {@link ASPCore2Program} to debug program preprocessing. + * Prepares a {@link DebugSolvingContext} for the given {@link InputProgram} to debug program preprocessing. * * @return a {@link DebugSolvingContext} holding debug information for the given program */ @@ -89,7 +89,7 @@ public interface Alpha { DebugSolvingContext prepareDebugSolve(final NormalProgram program); /** - * Prepares a {@link DebugSolvingContext} for the given {@link ASPCore2Program} to debug program preprocessing. + * Prepares a {@link DebugSolvingContext} for the given {@link InputProgram} to debug program preprocessing. * * @param filter a {@link java.util.function.Predicate} against which {@link Predicate}s of answer sets are tested. * @return a {@link DebugSolvingContext} holding debug information for the given program @@ -105,7 +105,7 @@ public interface Alpha { DebugSolvingContext prepareDebugSolve(final NormalProgram program, java.util.function.Predicate filter); /** - * Solves the given {@link ASPCore2Program}. + * Solves the given {@link InputProgram}. * * @param program an input program * @return a {@link Stream} of {@link AnswerSet}s of the given program @@ -113,7 +113,7 @@ public interface Alpha { Stream solve(InputProgram program); /** - * Solves the given {@link ASPCore2Program}. + * Solves the given {@link InputProgram}. * * @param program an input program * @param filter a {@link java.util.function.Predicate} against which {@link Predicate}s of answer sets are tested. @@ -143,13 +143,13 @@ public interface Alpha { * code. * See {@link NormalProgram}, * - * @param program An {@link ASPCore2Program} to normalize + * @param program An {@link InputProgram} to normalize * @return a {@link NormalProgram} that is a semantic equivalent to the given input program */ NormalProgram normalizeProgram(InputProgram program); /** - * Constructs a @{link Solver} pre-loaded with the given {@link ASPCore2Program} from which {@link AnswerSet}s can be obtained via + * Constructs a @{link Solver} pre-loaded with the given {@link InputProgram} from which {@link AnswerSet}s can be obtained via * {@link Solver#stream()}. * * @param program the program to solve @@ -174,11 +174,11 @@ public interface Alpha { * @param program an ASP program to reify * @return a set of {@link BasicAtom}s encoding the given program */ - Set reify(ASPCore2Program program); + Set reify(InputProgram program); /** * Runs all test cases of the given program. */ - TestResult test(ASPCore2Program program); + TestResult test(InputProgram program); } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java index 1015fb833..8b80fc9ef 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/AnswerSet.java @@ -32,7 +32,7 @@ public interface AnswerSet extends Comparable { boolean isEmpty(); /** - * List {@link Atom}s in this answer set satisfying the given {@link AnswerSetQuery}. + * List {@link Atom}s in this answer set satisfying the given {@link AtomQuery}. */ List query(AtomQuery query); diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java deleted file mode 100644 index fa444b184..000000000 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/ASPCore2Program.java +++ /dev/null @@ -1,21 +0,0 @@ -package at.ac.tuwien.kr.alpha.api.programs; - -import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; -import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; -import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; - -import java.util.List; - -/** - * A {@link Program} that conforms to Alphas implementation of the ASP-Core2-Standard. - * - * Copyright (c) 2021, the Alpha Team. - */ -public interface ASPCore2Program extends Program> { - - /** - * The test cases associated with this program. - */ - List getTestCases(); - -} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/InputProgram.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/InputProgram.java index c7be5bd2f..f9fe5122f 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/InputProgram.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/InputProgram.java @@ -1,9 +1,16 @@ package at.ac.tuwien.kr.alpha.api.programs; -import at.ac.tuwien.kr.alpha.api.rules.Rule; -import at.ac.tuwien.kr.alpha.api.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; +import at.ac.tuwien.kr.alpha.api.programs.tests.TestCase; + +import java.util.List; -// TODO javadoc public interface InputProgram extends Program> { + /** + * The test cases associated with this program. + */ + List getTestCases(); + } diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/RuleInstantiator.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/RuleInstantiator.java new file mode 100644 index 000000000..74646f00d --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/RuleInstantiator.java @@ -0,0 +1,11 @@ +package at.ac.tuwien.kr.alpha.api.programs.rules; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.InstantiableHead; + +public interface RuleInstantiator { + + BasicAtom instantiate(InstantiableHead ruleHead, Substitution substitution); + +} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ActionHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ActionHead.java new file mode 100644 index 000000000..744531317 --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/ActionHead.java @@ -0,0 +1,16 @@ +package at.ac.tuwien.kr.alpha.api.programs.rules.heads; + +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; + +import java.util.List; + +public interface ActionHead extends NormalHead { + + String getActionName(); + + List getActionInputTerms(); + + VariableTerm getActionOutputTerm(); + +} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/InstantiableHead.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/InstantiableHead.java new file mode 100644 index 000000000..82aa89343 --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/rules/heads/InstantiableHead.java @@ -0,0 +1,11 @@ +package at.ac.tuwien.kr.alpha.api.programs.rules.heads; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.rules.RuleInstantiator; + +public interface InstantiableHead extends Head { + + BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution); + +} diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ActionResultTerm.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ActionResultTerm.java new file mode 100644 index 000000000..28fc53769 --- /dev/null +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/terms/ActionResultTerm.java @@ -0,0 +1,30 @@ +package at.ac.tuwien.kr.alpha.api.programs.terms; + + /** + * A term representing the result of an evolog action (i.e. result of action function application). + * Action result terms are function terms with symbol "success" or "error" depending on whether the corresponding action was sucessful. + * There is always one argument which is either some term representing the actual function result or an error message, respectively. + */ +public interface ActionResultTerm extends FunctionTerm { + + public static final String SUCCESS_SYMBOL = "success"; + public static final String ERROR_SYMBOL = "error"; + + /** + * True if the action that generated this result was successful (i.e. executed normally). + */ + boolean isSuccess(); + + /** + * True if the action that generated this result failed (i.e. threw an error in execution). + */ + boolean isError(); + + /** + * Gets the actual value wrapped in this result. + * Either a term representing the action return value or a string term representing an error + * message.s + */ + T getValue(); + +} \ No newline at end of file diff --git a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java index 70da34ddc..4acf1e5f8 100644 --- a/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java +++ b/alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/programs/tests/Assertion.java @@ -1,6 +1,6 @@ package at.ac.tuwien.kr.alpha.api.programs.tests; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; public interface Assertion { @@ -23,7 +23,7 @@ public String toString() { Mode getMode(); - ASPCore2Program getVerifier(); + InputProgram getVerifier(); } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java index 32c5ccacf..c67097ed3 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/ASPCore2ProgramImpl.java @@ -27,8 +27,8 @@ */ package at.ac.tuwien.kr.alpha.commons.programs; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.Head; @@ -43,7 +43,8 @@ *

* Copyright (c) 2017-2019, the Alpha Team. */ -class ASPCore2ProgramImpl extends AbstractProgram> implements ASPCore2Program{ +// TODO rename this to InputProgramImpl or some such +class ASPCore2ProgramImpl extends AbstractProgram> implements InputProgram { static final ASPCore2ProgramImpl EMPTY = new ASPCore2ProgramImpl(Collections.emptyList(), Collections.emptyList(), new InlineDirectivesImpl(), Collections.emptyList()); diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java index e42a486fe..460231815 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/Programs.java @@ -6,6 +6,7 @@ import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.InlineDirectives; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.NormalProgram; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.rules.NormalRule; @@ -20,15 +21,17 @@ private Programs() { throw new AssertionError("Cannot instantiate utility class!"); } - public static ASPCore2Program emptyProgram() { + public static InputProgram emptyProgram() { return ASPCore2ProgramImpl.EMPTY; } - public static ASPCore2Program newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives, List testCases) { + // TODO rename method + public static InputProgram newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives, List testCases) { return new ASPCore2ProgramImpl(rules, facts, inlineDirectives, testCases); } - public static ASPCore2Program newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives) { + // TODO rename method + public static InputProgram newASPCore2Program(List> rules, List facts, InlineDirectives inlineDirectives) { return new ASPCore2ProgramImpl(rules, facts, inlineDirectives, Collections.emptyList()); } @@ -36,7 +39,7 @@ public static ASPCore2ProgramBuilder builder() { return new ASPCore2ProgramBuilder(); } - public static ASPCore2ProgramBuilder builder(ASPCore2Program program) { + public static ASPCore2ProgramBuilder builder(InputProgram program) { return new ASPCore2ProgramBuilder(program); } @@ -44,7 +47,7 @@ public static NormalProgram newNormalProgram(List rules, List return new NormalProgramImpl(rules, facts, inlineDirectives); } - public static NormalProgram toNormalProgram(ASPCore2Program inputProgram) { + public static NormalProgram toNormalProgram(InputProgram inputProgram) { List normalRules = new ArrayList<>(); for (Rule r : inputProgram.getRules()) { normalRules.add(Rules.toNormalRule(r)); @@ -57,8 +60,9 @@ public static InlineDirectives newInlineDirectives() { } /** - * Builder for more complex program construction scenarios, ensuring that an {@link AspCore2ProgramImpl} is immutable + * Builder for more complex program construction scenarios, ensuring that an {@link ASPCore2ProgramImpl} is immutable */ + // TODO maybe rename public static class ASPCore2ProgramBuilder { private List> rules = new ArrayList<>(); @@ -67,7 +71,7 @@ public static class ASPCore2ProgramBuilder { private List testCases = new ArrayList<>(); - public ASPCore2ProgramBuilder(ASPCore2Program prog) { + public ASPCore2ProgramBuilder(InputProgram prog) { this.addRules(prog.getRules()); this.addFacts(prog.getFacts()); this.addInlineDirectives(prog.getInlineDirectives()); @@ -113,11 +117,11 @@ public ASPCore2ProgramBuilder addTestCases(List testCases) { return this; } - public ASPCore2ProgramBuilder accumulate(ASPCore2Program prog) { + public ASPCore2ProgramBuilder accumulate(InputProgram prog) { return this.addRules(prog.getRules()).addFacts(prog.getFacts()).addInlineDirectives(prog.getInlineDirectives()).addTestCases(prog.getTestCases()); } - public ASPCore2Program build() { + public InputProgram build() { return Programs.newASPCore2Program(this.rules, this.facts, this.inlineDirectives, this.testCases); } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java index dc0396863..3d04c53f9 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/Rules.java @@ -1,6 +1,7 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; @@ -23,10 +24,7 @@ public static Rule newRule(Head head, List body) { } public static Rule newRule(Head head, Literal... body) { - List bodyLst = new ArrayList<>(); - for (Literal lit : body) { - bodyLst.add(lit); - } + List bodyLst = new ArrayList<>(Arrays.asList(body)); return new BasicRule(head, bodyLst); } @@ -35,10 +33,7 @@ public static NormalRule newNormalRule(NormalHead head, List body) { } public static NormalRule newNormalRule(NormalHead head, Literal... body) { - List bodyLst = new ArrayList<>(); - for (Literal lit : body) { - bodyLst.add(lit); - } + List bodyLst = new ArrayList<>(Arrays.asList(body)); return new NormalRuleImpl(head, bodyLst); } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java new file mode 100644 index 000000000..46a598442 --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/ActionHeadImpl.java @@ -0,0 +1,63 @@ +package at.ac.tuwien.kr.alpha.commons.programs.rules.heads; + +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; +import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.rules.RuleInstantiator; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ActionHead; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import org.apache.commons.lang3.StringUtils; + +import java.util.Collections; +import java.util.List; + +class ActionHeadImpl implements ActionHead { + + private final BasicAtom atom; + private final String actionName; + private final List actionInputTerms; + private final VariableTerm actionOutputTerm; + + ActionHeadImpl(BasicAtom atom, String actionName, List actionInputTerms, VariableTerm actionOutputTerm) { + this.atom = atom; + this.actionName = actionName; + this.actionInputTerms = Collections.unmodifiableList(actionInputTerms); + this.actionOutputTerm = actionOutputTerm; + } + + @Override + public BasicAtom getAtom() { + return atom; + } + + @Override + public boolean isGround() { + // TODO: an action head is conceptually a basic one with an (interpreted) function term + return false; + } + + @Override + public BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution) { + return instantiator.instantiate(this, substitution); + } + + @Override + public String getActionName() { + return actionName; + } + + @Override + public List getActionInputTerms() { + return actionInputTerms; + } + + @Override + public VariableTerm getActionOutputTerm() { + return actionOutputTerm; + } + + public String toString() { + return atom.toString() + " : @" + actionName + "(" + StringUtils.join(actionInputTerms, ", ") + ") = " + actionOutputTerm; + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java index 6e7aeebf1..3ebf81b63 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/Heads.java @@ -5,10 +5,12 @@ import at.ac.tuwien.kr.alpha.api.ComparisonOperator; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; +import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ActionHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.ChoiceHead.ChoiceElement; import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.ChoiceHeadImpl.ChoiceElementImpl; public final class Heads { @@ -29,5 +31,9 @@ public static ChoiceHead newChoiceHead(List choiceElements, Term public static ChoiceElement newChoiceElement(BasicAtom choiceAtom, List conditionLiterals) { return new ChoiceElementImpl(choiceAtom, conditionLiterals); } + + public static ActionHead newActionHead(BasicAtom atom, String actionName, List actionInputTerms, VariableTerm actionResult) { + return new ActionHeadImpl(atom, actionName, actionInputTerms, actionResult); + } } diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/NormalHeadImpl.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/NormalHeadImpl.java index 7bae74aba..1422d8e75 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/NormalHeadImpl.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/rules/heads/NormalHeadImpl.java @@ -1,6 +1,8 @@ package at.ac.tuwien.kr.alpha.commons.programs.rules.heads; +import at.ac.tuwien.kr.alpha.api.grounder.Substitution; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; +import at.ac.tuwien.kr.alpha.api.programs.rules.RuleInstantiator; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; /** @@ -26,6 +28,11 @@ public BasicAtom getAtom() { return atom; } + @Override + public BasicAtom instantiate(RuleInstantiator instantiator, Substitution substitution) { + return instantiator.instantiate(this, substitution); + } + @Override public String toString() { return atom.toString(); diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java new file mode 100644 index 000000000..9a94e942d --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/AbstractActionResultTerm.java @@ -0,0 +1,26 @@ +package at.ac.tuwien.kr.alpha.commons.programs.terms; + +import at.ac.tuwien.kr.alpha.api.programs.terms.ActionResultTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; + +import java.util.Collections; + +abstract class AbstractActionResultTerm extends FunctionTermImpl implements ActionResultTerm { + + AbstractActionResultTerm(String symbol, T value) { + super(symbol, Collections.singletonList(value)); + } + + public abstract boolean isSuccess(); + + public boolean isError() { + return !isSuccess(); + } + + // Note: Unchecked cast is ok, we permit only instances of T as constructor arguments. + @SuppressWarnings("unchecked") + public T getValue() { + return (T) getTerms().get(0); + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java new file mode 100644 index 000000000..683b640c1 --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionErrorTerm.java @@ -0,0 +1,24 @@ +package at.ac.tuwien.kr.alpha.commons.programs.terms; + +import at.ac.tuwien.kr.alpha.api.programs.terms.ActionResultTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; +import at.ac.tuwien.kr.alpha.commons.util.Interner; + +class ActionErrorTerm extends AbstractActionResultTerm> { + + private static final Interner INTERNER = new Interner<>(); + + ActionErrorTerm(ConstantTerm value) { + super(ActionResultTerm.ERROR_SYMBOL, value); + } + + public static ActionErrorTerm getInstance(ConstantTerm term) { + return INTERNER.intern(new ActionErrorTerm(term)); + } + + @Override + public boolean isSuccess() { + return false; + } + +} \ No newline at end of file diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java new file mode 100644 index 000000000..2c4d7ddfd --- /dev/null +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/ActionSuccessTerm.java @@ -0,0 +1,25 @@ +package at.ac.tuwien.kr.alpha.commons.programs.terms; + +import at.ac.tuwien.kr.alpha.api.programs.terms.ActionResultTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.Term; +import at.ac.tuwien.kr.alpha.commons.util.Interner; + +class ActionSuccessTerm extends AbstractActionResultTerm { + + private static final Interner> INTERNER = new Interner<>(); + + ActionSuccessTerm(T value) { + super(ActionResultTerm.SUCCESS_SYMBOL, value); + } + + @SuppressWarnings("unchecked") + public static ActionSuccessTerm getInstance(T term) { + return (ActionSuccessTerm) INTERNER.intern(new ActionSuccessTerm<>(term)); + } + + @Override + public boolean isSuccess() { + return true; + } + +} diff --git a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/Terms.java b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/Terms.java index d38088b6b..7d0ac9971 100644 --- a/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/Terms.java +++ b/alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/programs/terms/Terms.java @@ -5,13 +5,7 @@ import java.util.Set; import at.ac.tuwien.kr.alpha.api.grounder.Substitution; -import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticOperator; -import at.ac.tuwien.kr.alpha.api.programs.terms.ArithmeticTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.ConstantTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.FunctionTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.IntervalTerm; -import at.ac.tuwien.kr.alpha.api.programs.terms.Term; -import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; +import at.ac.tuwien.kr.alpha.api.programs.terms.*; import at.ac.tuwien.kr.alpha.commons.programs.terms.ArithmeticTermImpl.MinusTerm; import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; @@ -70,6 +64,15 @@ public static IntervalTerm newIntervalTerm(Term lowerBound, Term upperBound) { return IntervalTermImpl.getInstance(lowerBound, upperBound); } + public static ActionResultTerm actionSuccess(T value) { + return ActionSuccessTerm.getInstance(value); + } + + public static ActionResultTerm> actionError(String errMsg) { + return ActionErrorTerm.getInstance(Terms.newConstant(errMsg)); + } + + @SafeVarargs public static > List> asTermList(T... values) { List> retVal = new ArrayList<>(); diff --git a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 index 44039084e..bbd952cad 100644 --- a/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 +++ b/alpha-core/src/main/antlr/at/ac/tuwien/kr/alpha/core/antlr/ASPCore2.g4 @@ -20,7 +20,9 @@ statement : head DOT # statement_fact | WCONS body? DOT SQUARE_OPEN weight_at_level SQUARE_CLOSE # statement_weightConstraint | directive # statement_directive; // NOT Core2 syntax. -head : disjunction | choice; +head : disjunction | choice | action; + +action: classical_literal COLON AT ID SQUARE_OPEN terms SQUARE_CLOSE EQUAL variable_term; // NOT Core2 syntax body : ( naf_literal | aggregate ) (COMMA body)?; diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java similarity index 84% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java index cc63f903d..64e36c247 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/AbstractProgramParser.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/parser/ProgramParserImpl.java @@ -7,6 +7,7 @@ import java.util.HashMap; import java.util.Map; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import org.antlr.v4.runtime.BailErrorStrategy; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.CharStreams; @@ -17,12 +18,9 @@ import org.antlr.v4.runtime.misc.ParseCancellationException; import at.ac.tuwien.kr.alpha.api.common.fixedinterpretations.PredicateInterpretation; -import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; import at.ac.tuwien.kr.alpha.api.programs.ProgramParser; import at.ac.tuwien.kr.alpha.commons.programs.Programs; import at.ac.tuwien.kr.alpha.commons.programs.Programs.ASPCore2ProgramBuilder; -import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Lexer; -import at.ac.tuwien.kr.alpha.core.antlr.ASPCore2Parser; import at.ac.tuwien.kr.alpha.core.externals.Externals; public class ProgramParserImpl implements ProgramParser { @@ -39,12 +37,12 @@ public ProgramParserImpl(Map externals) { } @Override - public ASPCore2Program parse(String s) { + public InputProgram parse(String s) { return parse(s, Collections.emptyMap()); } @Override - public ASPCore2Program parse(String s, Map externals) { + public InputProgram parse(String s, Map externals) { try { return parse(CharStreams.fromString(s), externals); } catch (RecognitionException | ParseCancellationException e) { @@ -55,11 +53,11 @@ public ASPCore2Program parse(String s, Map exte } } - public ASPCore2Program parse(CharStream stream) { + public InputProgram parse(CharStream stream) { return parse(stream, Collections.emptyMap()); } - public ASPCore2Program parse(CharStream stream, Map externals) { + public InputProgram parse(CharStream stream, Map externals) { //@formatter:off /* * // In order to require less memory: use unbuffered streams and avoid constructing a full parse tree. @@ -132,17 +130,17 @@ public ASPCore2Program parse(CharStream stream, Map externalPredicateDefinitions) throws IOException { + public InputProgram parse(InputStream programSource, Map externalPredicateDefinitions) throws IOException { return parse(CharStreams.fromStream(programSource), externalPredicateDefinitions); } @Override - public ASPCore2Program parse(Path programPath, Map externalPredicateDefinitions) throws IOException { + public InputProgram parse(Path programPath, Map externalPredicateDefinitions) throws IOException { return parse(CharStreams.fromPath(programPath), externalPredicateDefinitions); } @Override - public ASPCore2Program parse(Map externalPredicateDefinitions, Path... programSources) throws IOException { + public InputProgram parse(Map externalPredicateDefinitions, Path... programSources) throws IOException { ASPCore2ProgramBuilder bld = Programs.builder(); for (Path src : programSources) { bld.accumulate(parse(src, externalPredicateDefinitions)); @@ -151,7 +149,7 @@ public ASPCore2Program parse(Map externalPredic } @Override - public ASPCore2Program parse(Iterable programSources, Map externalPredicateDefinitions) throws IOException { + public InputProgram parse(Iterable programSources, Map externalPredicateDefinitions) throws IOException { ASPCore2ProgramBuilder bld = Programs.builder(); for (Path src : programSources) { bld.accumulate(parse(src, externalPredicateDefinitions)); diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java index fb998a297..8b57907f2 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java @@ -25,37 +25,18 @@ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java -package at.ac.tuwien.kr.alpha.core.rules; - -import java.util.ArrayList; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Set; - -import com.google.common.annotations.VisibleForTesting; -======== package at.ac.tuwien.kr.alpha.core.programs.rules; ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; import at.ac.tuwien.kr.alpha.api.programs.literals.AggregateLiteral; import at.ac.tuwien.kr.alpha.api.programs.literals.Literal; -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java -import at.ac.tuwien.kr.alpha.api.rules.NormalRule; -import at.ac.tuwien.kr.alpha.api.rules.heads.NormalHead; -import at.ac.tuwien.kr.alpha.api.terms.VariableTerm; -import at.ac.tuwien.kr.alpha.commons.rules.Rules; -import at.ac.tuwien.kr.alpha.commons.rules.heads.Heads; -======== import at.ac.tuwien.kr.alpha.api.programs.rules.Rule; import at.ac.tuwien.kr.alpha.api.programs.rules.heads.NormalHead; import at.ac.tuwien.kr.alpha.api.programs.terms.VariableTerm; import at.ac.tuwien.kr.alpha.commons.programs.rules.AbstractRule; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier; import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.core.grounder.RuleGroundingInfoImpl; @@ -70,23 +51,15 @@ * * {@link InternalRule}s are assumed to be uniquely identified by an ID. */ -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java -public class CompiledRuleImpl implements CompiledRule { -======== public class InternalRule extends AbstractRule implements CompiledRule { ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java private static final IntIdGenerator ID_GENERATOR = new IntIdGenerator(); - private final NormalRule wrappedRule; - private final int ruleId; + private final List occurringPredicates; + private final RuleGroundingInfoImpl groundingOrders; -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java - - CompiledRuleImpl(NormalHead head, Set body) { -======== /** * Creates a new {@link InternalRule} with the given head plus body and a fresh identifier. @@ -96,13 +69,11 @@ public class InternalRule extends AbstractRule implements CompiledRu */ public InternalRule(NormalHead head, List body) { super(head, body); ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java if (body.isEmpty()) { throw new IllegalArgumentException( "Empty bodies are not supported for InternalRule! (Head = " + (head == null ? "NULL" : head.getAtom().toString()) + ")"); } - this.ruleId = CompiledRuleImpl.ID_GENERATOR.getNextId(); - this.wrappedRule = Rules.newNormalRule(head, body); + this.ruleId = InternalRule.ID_GENERATOR.getNextId(); this.occurringPredicates = new ArrayList<>(); if (!isConstraint()) { @@ -116,24 +87,32 @@ public InternalRule(NormalHead head, List body) { this.occurringPredicates.add(literal.getPredicate()); } + // not needed, done in AbstractRule! Leaving it commented out for future reference since this might actually be the + // proper place to put it + // this.checkSafety(); + this.groundingOrders = new RuleGroundingInfoImpl(this); this.groundingOrders.computeGroundingOrders(); } @VisibleForTesting public static void resetIdGenerator() { - CompiledRuleImpl.ID_GENERATOR.resetGenerator(); + InternalRule.ID_GENERATOR.resetGenerator(); + } + + public static CompiledRule fromNormalRule(Rule rule) { + return new InternalRule(rule.isConstraint() ? null : Heads.newNormalHead(rule.getHead().getAtom()), new ArrayList<>(rule.getBody())); } /** * Returns a new Rule that is equal to this one except that all variables are renamed to have the newVariablePostfix * appended. - * + * * @param newVariablePostfix * @return */ @Override - public CompiledRuleImpl renameVariables(String newVariablePostfix) { + public InternalRule renameVariables(String newVariablePostfix) { // TODO handle action heads! List occurringVariables = new ArrayList<>(); BasicAtom headAtom = this.getHeadAtom(); @@ -147,13 +126,13 @@ public CompiledRuleImpl renameVariables(String newVariablePostfix) { variableReplacement.put(occurringVariable, Terms.newVariable(newVariableName)); } BasicAtom renamedHeadAtom = headAtom.substitute(variableReplacement); - Set renamedBody = new LinkedHashSet<>(this.getBody().size()); + ArrayList renamedBody = new ArrayList<>(this.getBody().size()); for (Literal literal : this.getBody()) { renamedBody.add(literal.substitute(variableReplacement)); } // TODO action heads! // TODO we want to pull renameVariables down to atom, term, etc level - return new CompiledRuleImpl(Heads.newNormalHead(renamedHeadAtom), renamedBody); + return new InternalRule(Heads.newNormalHead(renamedHeadAtom), renamedBody); } /** @@ -175,46 +154,6 @@ public int getRuleId() { return this.ruleId; } - @Override -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java - public BasicAtom getHeadAtom() { - return wrappedRule.getHeadAtom(); - } - - @Override - public NormalHead getHead() { - return wrappedRule.getHead(); - } - - @Override - public Set getBody() { - return wrappedRule.getBody(); - } - - @Override - public boolean isConstraint() { - return wrappedRule.isConstraint(); - } - - @Override - public Set getPositiveBody() { - return wrappedRule.getPositiveBody(); - } - - @Override - public Set getNegativeBody() { - return wrappedRule.getNegativeBody(); - } - - @Override - public boolean isGround() { - return wrappedRule.isGround(); - } - - @Override - public String toString() { - return wrappedRule.toString(); -======== public boolean isGround() { if (!isConstraint() && !getHead().isGround()) { return false; @@ -225,14 +164,10 @@ public boolean isGround() { } } return true; ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java } @Override public boolean equals(Object o) { -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java - return wrappedRule.equals(o); -======== if (this == o) { return true; } @@ -241,17 +176,12 @@ public boolean equals(Object o) { } InternalRule that = (InternalRule) o; return getRuleId() == that.getRuleId(); ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java } @Override public int hashCode() { -<<<<<<<< HEAD:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/rules/CompiledRuleImpl.java - return wrappedRule.hashCode(); - } - -======== return Integer.hashCode(getRuleId()); } ->>>>>>>> master:alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/rules/InternalRule.java + } + diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermTransformer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java similarity index 89% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermTransformer.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java index b556c642a..029123628 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermTransformer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ArithmeticTermsRewriting.java @@ -22,6 +22,7 @@ import at.ac.tuwien.kr.alpha.commons.programs.rules.Rules; import at.ac.tuwien.kr.alpha.commons.programs.rules.heads.Heads; import at.ac.tuwien.kr.alpha.commons.programs.terms.Terms; +import at.ac.tuwien.kr.alpha.commons.util.IntIdGenerator; import at.ac.tuwien.kr.alpha.commons.util.Util; /** @@ -32,8 +33,12 @@ * Copyright (c) 2020-2021, the Alpha Team. */ public class ArithmeticTermsRewriting extends ProgramTransformation { - private static final String ARITHMETIC_VARIABLES_PREFIX = "_A"; - private int numArithmeticVariables; + /** + private int numArithmeticVariables; + * The prefix with which to begin names of internal variables created by this transformation. + */ + private final String generatedVariablesPrefix = "_A"; + private final IntIdGenerator variableNumberGenerator = new IntIdGenerator(); @Override public NormalProgram apply(NormalProgram inputProgram) { @@ -57,19 +62,20 @@ public NormalProgram apply(NormalProgram inputProgram) { /** * Takes a normal rule and rewrites it such that {@link ArithmeticTerm}s only appear inside - * {@link at.ac.tuwien.kr.alpha.common.atoms.ComparisonLiteral}s. + * {@link at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral}s. * * @param inputProgramRule the rule to rewrite. * @return the rewritten rule. Note that a new {@link NormalRule} is returned for every call of this method. */ private NormalRule rewriteRule(NormalRule inputProgramRule) { - numArithmeticVariables = 0; // Reset number of introduced variables for each rule. + variableNumberGenerator.resetGenerator(); // Reset number of introduced variables for each rule. NormalHead rewrittenHead = null; List rewrittenBodyLiterals = new ArrayList<>(); // Rewrite head. if (!inputProgramRule.isConstraint()) { BasicAtom headAtom = inputProgramRule.getHeadAtom(); if (containsArithmeticTermsToRewrite(headAtom)) { + // TODO handle action heads rewrittenHead = Heads.newNormalHead((BasicAtom) rewriteAtom(headAtom, rewrittenBodyLiterals)); } else { rewrittenHead = inputProgramRule.getHead(); @@ -89,11 +95,11 @@ private NormalRule rewriteRule(NormalRule inputProgramRule) { /** * Checks whether a normal rule contains an {@link ArithmeticTerm} outside of a - * {@link at.ac.tuwien.kr.alpha.common.atoms.ComparisonLiteral}. + * {@link at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral}. * * @param inputProgramRule the rule to check for presence of arithmetic terms outside comparison literals. * @return true if the inputProgramRule contains an {@link ArithmeticTerm} outside of a - * {@link at.ac.tuwien.kr.alpha.common.atoms.ComparisonLiteral}. + * {@link at.ac.tuwien.kr.alpha.api.programs.literals.ComparisonLiteral}. */ private boolean containsArithmeticTermsToRewrite(NormalRule inputProgramRule) { if (!inputProgramRule.isConstraint()) { @@ -118,7 +124,7 @@ private Term rewriteArithmeticSubterms(Term term, List bodyLiterals) { } // Switch on term type. if (term instanceof ArithmeticTerm) { - VariableTerm replacementVariable = Terms.newVariable(ARITHMETIC_VARIABLES_PREFIX + numArithmeticVariables++); + VariableTerm replacementVariable = Terms.newVariable(generatedVariablesPrefix + variableNumberGenerator.getNextId()); bodyLiterals.add(Atoms.newComparisonAtom(replacementVariable, term, ComparisonOperators.EQ).toLiteral()); return replacementVariable; } else if (term instanceof VariableTerm || term instanceof ConstantTerm) { diff --git a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadNormalizer.java b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java similarity index 96% rename from alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadNormalizer.java rename to alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java index 5783dd2d9..486c57e12 100644 --- a/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadNormalizer.java +++ b/alpha-core/src/main/java/at/ac/tuwien/kr/alpha/core/programs/transformation/ChoiceHeadToNormal.java @@ -32,6 +32,7 @@ import java.util.List; import at.ac.tuwien.kr.alpha.api.programs.ASPCore2Program; +import at.ac.tuwien.kr.alpha.api.programs.InputProgram; import at.ac.tuwien.kr.alpha.api.programs.Predicate; import at.ac.tuwien.kr.alpha.api.programs.atoms.Atom; import at.ac.tuwien.kr.alpha.api.programs.atoms.BasicAtom; @@ -53,11 +54,11 @@ * Copyright (c) 2017-2021, the Alpha Team. */ // TODO this could already give NormalProgram as result type -public class ChoiceHeadToNormal extends ProgramTransformation { +public class ChoiceHeadToNormal extends ProgramTransformation { private final static String PREDICATE_NEGATION_PREFIX = "_n"; @Override - public ASPCore2Program apply(ASPCore2Program inputProgram) { + public InputProgram apply(InputProgram inputProgram) { ASPCore2ProgramBuilder programBuilder = Programs.builder(); List> additionalRules = new ArrayList<>();