Preprocessing

.gitignore

@@ -107,3 +107,4 @@ gradle-app.setting
 /.dbeaver
 /Scripts
 /.vscode/
+workspace.code-workspace

README.md

@@ -42,6 +42,8 @@ $ java -jar alpha.jar -i benchmarks/omiga/omiga-testcases/3col/3col-10-18.txt -f
 
 Note that in this example the path to the input file is relative to the root of this repository. If you have not checked out the repository, you can just [download the example file from GitHub](/benchmarks/omiga/omiga-testcases/3col/3col-10-18.txt).
 
+[A coder's guide to answer set programming](https://madmike200590.github.io/asp-guide/) provides a short and high-level tutorial on Answer Set Programming.
+
 ## Building
 
 Alpha uses the [Gradle build automation system](https://gradle.org). Executing
@@ -73,6 +75,10 @@ run into trouble feel free to file an issue.
 
 ## Suggested Reading
 
+### Beginners' Tutorials
+ * [A coder's guide to answer set programming](https://madmike200590.github.io/asp-guide/)
+
+### Theoretical Background and Language Specification
  * [Answer Set Programming: A Primer](http://www.kr.tuwien.ac.at/staff/tkren/pub/2009/rw2009-asp.pdf)
  * [ASP-Core-2 Input Language Format](https://www.mat.unical.it/aspcomp2013/files/ASP-CORE-2.01c.pdf)
  * [Conflict-Driven Answer Set Solving: From Theory to Practice](http://www.cs.uni-potsdam.de/wv/pdfformat/gekasc12c.pdf)
@@ -82,6 +88,10 @@ run into trouble feel free to file an issue.
 
 Peer-reviewed publications part of journals, conferences and workshops:
 
+#### 2021
+
+ * [Solving Configuration Problems with ASP and Declarative Domain-Specific Heuristics](http://ceur-ws.org/Vol-2945/21-RT-ConfWS21_paper_4.pdf)
+
 #### 2020
 
  * [Conflict Generalisation in ASP: Learning Correct and Effective Non-Ground Constraints](https://doi.org/10.1017/S1471068420000368)

alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/config/SystemConfig.java

@@ -58,6 +58,7 @@ public class SystemConfig {
 	public static final boolean DEFAULT_SORT_ANSWER_SETS = false;
 	public static final List<Integer> DEFAULT_REPLAY_CHOICES = Collections.emptyList();
 	public static final boolean DEFAULT_STRATIFIED_EVALUATION = true;
+	public static final boolean DEFAULT_PREPROCESSING_ENABLED = true;
 	public static final boolean DEFAULT_DISABLE_NOGOOD_DELETION = false;
 	public static final String DEFAULT_GROUNDER_TOLERANCE_CONSTRAINTS = GrounderHeuristicsConfiguration.STRICT_STRING;
 	public static final String DEFAULT_GROUNDER_TOLERANCE_RULES = GrounderHeuristicsConfiguration.STRICT_STRING;
@@ -79,6 +80,7 @@ public class SystemConfig {
 	private boolean sortAnswerSets = DEFAULT_SORT_ANSWER_SETS;
 	private List<Integer> replayChoices = DEFAULT_REPLAY_CHOICES;
 	private boolean evaluateStratifiedPart = DEFAULT_STRATIFIED_EVALUATION;
+	private boolean enablePreprocessing = DEFAULT_PREPROCESSING_ENABLED;
 	private boolean disableNoGoodDeletion = DEFAULT_DISABLE_NOGOOD_DELETION;
 	private String grounderToleranceConstraints = DEFAULT_GROUNDER_TOLERANCE_CONSTRAINTS;
 	private String grounderToleranceRules = DEFAULT_GROUNDER_TOLERANCE_RULES;
@@ -232,6 +234,14 @@ public void setEvaluateStratifiedPart(boolean evaluateStratifiedPart) {
 		this.evaluateStratifiedPart = evaluateStratifiedPart;
 	}
 
+	public boolean isPreprocessingEnabled() {
+		return this.enablePreprocessing;
+	}
+
+	public void setPreprocessingEnabled(boolean enablePreprocessing) {
+		this.enablePreprocessing = enablePreprocessing;
+	}
+
 	public boolean isDisableNoGoodDeletion() {
 		return this.disableNoGoodDeletion;
 	}

alpha-api/src/main/java/at/ac/tuwien/kr/alpha/api/terms/IntervalTerm.java

@@ -0,0 +1,14 @@
+package at.ac.tuwien.kr.alpha.api.terms;
+
+/**
+ * A term representing an interval of integers.
+ * Intervals are syntactic sugar, e.g. the rule "p(X) :- X = 1..2." is a shorthand for
+ * "p(X) :- X = 1. p(X) :- X = 2.".
+ */
+public interface IntervalTerm extends Term {
+
+	Term getLowerBound();
+
+	Term getUpperBound();
+
+}

alpha-cli-app/src/main/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParser.java

@@ -149,6 +149,9 @@ public class CommandLineParser {
 			.desc("a character (sequence) to use as separator for atoms in printed answer sets (default: "
 					+ SystemConfig.DEFAULT_ATOM_SEPARATOR + ")")
 			.build();
+	private static final Option OPT_DISABLE_PROGRAM_PREPROCESSING = Option.builder("dpp").longOpt("disableProgramPreprocessing")
+			.desc("disable preprocessing of input program")
+			.build();
 	//@formatter:on
 
 	private static final Options CLI_OPTS = new Options();
@@ -189,6 +192,7 @@ public class CommandLineParser {
 		CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_GROUNDER_TOLERANCE_RULES);
 		CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_GROUNDER_ACCUMULATOR_ENABLED);
 		CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_OUTPUT_ATOM_SEPARATOR);
+		CommandLineParser.CLI_OPTS.addOption(CommandLineParser.OPT_DISABLE_PROGRAM_PREPROCESSING);
 	}
 
 	/*
@@ -240,12 +244,13 @@ private void initializeGlobalOptionHandlers() {
 		this.globalOptionHandlers.put(CommandLineParser.OPT_NO_JUSTIFICATION.getOpt(), this::handleNoJustification);
 		this.globalOptionHandlers.put(CommandLineParser.OPT_AGGREGATES_NO_SORTING_GRID.getOpt(), this::handleDisableSortingGrid);
 		this.globalOptionHandlers.put(CommandLineParser.OPT_AGGREGATES_NO_NEGATIVE_INTEGERS.getOpt(), this::handleDisableNegativeSumElements);
-		this.globalOptionHandlers.put(CommandLineParser.OPT_NO_EVAL_STRATIFIED.getOpt(), this::handleDisableStratifedEval);
+		this.globalOptionHandlers.put(CommandLineParser.OPT_NO_EVAL_STRATIFIED.getOpt(), this::handleDisableStratifiedEval);
 		this.globalOptionHandlers.put(CommandLineParser.OPT_NO_NOGOOD_DELETION.getOpt(), this::handleNoNoGoodDeletion);
 		this.globalOptionHandlers.put(CommandLineParser.OPT_GROUNDER_TOLERANCE_CONSTRAINTS.getOpt(), this::handleGrounderToleranceConstraints);
 		this.globalOptionHandlers.put(CommandLineParser.OPT_GROUNDER_TOLERANCE_RULES.getOpt(), this::handleGrounderToleranceRules);
 		this.globalOptionHandlers.put(CommandLineParser.OPT_GROUNDER_ACCUMULATOR_ENABLED.getOpt(), this::handleGrounderNoInstanceRemoval);
 		this.globalOptionHandlers.put(CommandLineParser.OPT_OUTPUT_ATOM_SEPARATOR.getOpt(), this::handleAtomSeparator);
+		this.globalOptionHandlers.put(CommandLineParser.OPT_DISABLE_PROGRAM_PREPROCESSING.getOpt(), this::handleDisablePreprocessing);
 	}
 
 	private void initializeInputOptionHandlers() {
@@ -441,7 +446,7 @@ private void handleDisableNegativeSumElements(Option opt, SystemConfig cfg) {
 		cfg.getAggregateRewritingConfig().setSupportNegativeValuesInSums(false);
 	}
 
-	private void handleDisableStratifedEval(Option opt, SystemConfig cfg) {
+	private void handleDisableStratifiedEval(Option opt, SystemConfig cfg) {
 		cfg.setEvaluateStratifiedPart(false);
 	}
 
@@ -470,5 +475,9 @@ private void handleGrounderNoInstanceRemoval(Option opt, SystemConfig cfg) {
 	private void handleAtomSeparator(Option opt, SystemConfig cfg) {
 		cfg.setAtomSeparator(StringEscapeUtils.unescapeJava(opt.getValue(SystemConfig.DEFAULT_ATOM_SEPARATOR)));
 	}
+
+	private void handleDisablePreprocessing(Option opt, SystemConfig cfg) {
+		cfg.setPreprocessingEnabled(false);
+	}
 
 }

alpha-cli-app/src/main/resources/simplelogger.properties

@@ -22,8 +22,7 @@ org.slf4j.simpleLogger.log.at.ac.tuwien.kr.alpha.core.solver.heuristics.HeapOfAc
 org.slf4j.simpleLogger.showDateTime=true
 
 # Format for logged timestamps. 
-# For Alpha, we use milliseconds since startup
-org.slf4j.simpleLogger.dateTimeFormat=S
+# For Alpha, we use milliseconds since startup, which is the default time format
 
 # Disable including thread name in logged line since Alpha is currently single-threaded.
 org.slf4j.simpleLogger.showThreadName=false

alpha-cli-app/src/test/java/at/ac/tuwien/kr/alpha/app/config/CommandLineParserTest.java

@@ -181,4 +181,11 @@ public void atomSeparator() throws ParseException {
 		assertEquals("some-string", cfg.getSystemConfig().getAtomSeparator());
 	}
 
+	@Test
+	public void disableProgramPreprocessing() throws ParseException {
+		CommandLineParser parser = new CommandLineParser(DEFAULT_COMMAND_LINE, DEFAULT_ABORT_ACTION);
+		AlphaConfig ctx = parser.parseCommandLine(new String[]{"-str", "aString.", "-dpp"});
+		assertFalse(ctx.getSystemConfig().isPreprocessingEnabled());
+	}
+
 }

alpha-cli-app/src/test/resources/simplelogger.properties

@@ -22,8 +22,7 @@ org.slf4j.simpleLogger.log.at.ac.tuwien.kr.alpha.core.solver.heuristics.HeapOfAc
 org.slf4j.simpleLogger.showDateTime=true
 
 # Format for logged timestamps. 
-# For Alpha, we use milliseconds since startup
-org.slf4j.simpleLogger.dateTimeFormat=S
+# For Alpha, we use milliseconds since startup, which is the default time format
 
 # Disable including thread name in logged line since Alpha is currently single-threaded.
 org.slf4j.simpleLogger.showThreadName=false

alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/IntervalTerm.java → alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/IntervalTermImpl.java

@@ -4,28 +4,25 @@
 import java.util.Set;
 
 import at.ac.tuwien.kr.alpha.api.grounder.Substitution;
-import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm;
+import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm;
 import at.ac.tuwien.kr.alpha.api.terms.Term;
 import at.ac.tuwien.kr.alpha.api.terms.VariableTerm;
 import at.ac.tuwien.kr.alpha.commons.util.Interner;
-import at.ac.tuwien.kr.alpha.commons.util.Util;
 
 /**
  * An IntervalTerm represents the shorthand notation for a set of rules where all elements in this interval occur once, e.g., fact(2..5).
  * An IntervalTerm is a meta-term and the grounder must replace it with its corresponding set of facts or rules.
  * Copyright (c) 2017, the Alpha Team.
  */
-public class IntervalTerm extends AbstractTerm {
-	private static final Interner<IntervalTerm> INTERNER = new Interner<>();
+class IntervalTermImpl extends AbstractTerm implements IntervalTerm {
+
+	private static final Interner<IntervalTermImpl> INTERNER = new Interner<>();
 	private final Term lowerBoundTerm;
 	private final Term upperBoundTerm;
 
-	private final int lowerBound;
-	private final int upperBound;
-
 	private final boolean ground;
 
-	private IntervalTerm(Term lowerBound, Term upperBound) {
+	private IntervalTermImpl(Term lowerBound, Term upperBound) {
 		if (lowerBound == null || upperBound == null) {
 			throw new IllegalArgumentException();
 		}
@@ -34,44 +31,22 @@
 
 		this.lowerBoundTerm = lowerBound;
 		this.upperBoundTerm = upperBound;
-
-		if (this.ground) {
-			this.upperBound = Integer.parseInt(upperBoundTerm.toString());
-			this.lowerBound = Integer.parseInt(lowerBoundTerm.toString());
-		} else {
-			this.upperBound = -1;
-			this.lowerBound = -1;
-		}
 	}
 
-	public static IntervalTerm getInstance(Term lowerBound, Term upperBound) {
-		return INTERNER.intern(new IntervalTerm(lowerBound, upperBound));
+	static IntervalTermImpl getInstance(Term lowerBound, Term upperBound) {
+		return INTERNER.intern(new IntervalTermImpl(lowerBound, upperBound));
 	}
 
 	@Override
 	public boolean isGround() {
 		return this.ground;
 	}
 
-	public int getLowerBound() {
-		if (!isGround()) {
-			throw Util.oops("Cannot get the lower bound of non-ground interval");
-		}
-		return this.lowerBound;
-	}
-
-	public int getUpperBound() {
-		if (!isGround()) {
-			throw Util.oops("Cannot get the upper bound of non-ground interval");
-		}
-		return this.upperBound;
-	}
-
-	public Term getLowerBoundTerm() {
+	public Term getLowerBound() {
 		return lowerBoundTerm;
 	}
 
-	public Term getUpperBoundTerm() {
+	public Term getUpperBound() {
 		return upperBoundTerm;
 	}
 
@@ -88,11 +63,11 @@
 	}
 
 	@Override
-	public IntervalTerm substitute(Substitution substitution) {
+	public IntervalTermImpl substitute(Substitution substitution) {
 		if (isGround()) {
 			return this;
 		}
-		return new IntervalTerm(lowerBoundTerm.substitute(substitution), upperBoundTerm.substitute(substitution));
+		return new IntervalTermImpl(lowerBoundTerm.substitute(substitution), upperBoundTerm.substitute(substitution));
 	}
 
 	@Override
@@ -109,7 +84,7 @@
 			return false;
 		}
 
-		IntervalTerm that = (IntervalTerm) o;
+		IntervalTermImpl that = (IntervalTermImpl) o;
 
 		if (!lowerBoundTerm.equals(that.lowerBoundTerm)) {
 			return false;
@@ -130,41 +105,14 @@
 
 	@Override
 	public Term renameVariables(String renamePrefix) {
-		return new IntervalTerm(lowerBoundTerm.renameVariables(renamePrefix), upperBoundTerm.renameVariables(renamePrefix));
+		return new IntervalTermImpl(lowerBoundTerm.renameVariables(renamePrefix), upperBoundTerm.renameVariables(renamePrefix));
 	}
 
 	@Override
 	public Term normalizeVariables(String renamePrefix, Term.RenameCounter counter) {
-		return IntervalTerm.getInstance(
+		return IntervalTermImpl.getInstance(
 			lowerBoundTerm.normalizeVariables(renamePrefix, counter),
 			upperBoundTerm.normalizeVariables(renamePrefix, counter));
 	}
 
-	/**
-	 * Returns true if the term contains (or is) some IntervalTerm.
-	 * @param term the term to test
-	 * @return true iff an IntervalTerm occurs in term.
-	 */
-	public static boolean termContainsIntervalTerm(Term term) {
-		if (term instanceof IntervalTerm) {
-			return true;
-		} else if (term instanceof FunctionTermImpl) {
-			return functionTermContainsIntervals((FunctionTermImpl) term);
-		} else {
-			return false;
-		}
-	}
-
-	public static boolean functionTermContainsIntervals(FunctionTerm functionTerm) {
-		// Test whether a function term contains an interval term (recursively).
-		for (Term term : functionTerm.getTerms()) {
-			if (term instanceof IntervalTerm) {
-				return true;
-			}
-			if (term instanceof FunctionTermImpl && functionTermContainsIntervals((FunctionTerm) term)) {
-				return true;
-			}
-		}
-		return false;
-	}
 }

alpha-commons/src/main/java/at/ac/tuwien/kr/alpha/commons/terms/Terms.java

@@ -9,6 +9,7 @@
 import at.ac.tuwien.kr.alpha.api.terms.ArithmeticTerm;
 import at.ac.tuwien.kr.alpha.api.terms.ConstantTerm;
 import at.ac.tuwien.kr.alpha.api.terms.FunctionTerm;
+import at.ac.tuwien.kr.alpha.api.terms.IntervalTerm;
 import at.ac.tuwien.kr.alpha.api.terms.Term;
 import at.ac.tuwien.kr.alpha.api.terms.VariableTerm;
 import at.ac.tuwien.kr.alpha.commons.substitutions.Unifier;
@@ -65,6 +66,10 @@
 		return MinusTerm.getInstance(negatedTerm);
 	}
 
+	public static IntervalTerm newIntervalTerm(Term lowerBound, Term upperBound) {
+		return IntervalTermImpl.getInstance(lowerBound, upperBound);
+	}
+
 	@SafeVarargs
 	public static <T extends Comparable<T>> List<ConstantTerm<T>> asTermList(T... values) {
 		List<ConstantTerm<T>> retVal = new ArrayList<>();
@@ -117,4 +122,36 @@
 		}
 	}
 
+	/**
+	 * Returns true if the term contains (or is) some IntervalTerm.
+	 * @param term the term to test
+	 * @return true iff an IntervalTerm occurs in term.
+	 */
+	public static boolean termContainsIntervalTerm(Term term) {
+		if (term instanceof IntervalTermImpl) {
+			return true;
+		} else if (term instanceof FunctionTermImpl) {
+			return functionTermContainsIntervals((FunctionTermImpl) term);
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Returns true if the given {@link FunctionTerm} contains some IntervalTerm.
+	 * @param functionTerm the term to test
+	 * @return true iff an IntervalTerm occurs in functionTerm.
+	 */
+	public static boolean functionTermContainsIntervals(FunctionTerm functionTerm) {
+		for (Term term : functionTerm.getTerms()) {
+			if (term instanceof IntervalTermImpl) {
+				return true;
+			}
+			if (term instanceof FunctionTermImpl && functionTermContainsIntervals((FunctionTerm) term)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
 }