Version bump for release 0.1.8 RC 3

The unary modulus operation does not require extra parentheses to be
printed in cases like “|X + Y|”. This adds a new option to the printing
routine to omit parentheses in cases where the parent expression already
defines a parenthesis-like scope (currently only with unary operations).

.ci/Dockerfile-ubuntu-18.04

@@ -3,7 +3,7 @@ FROM ubuntu:18.04
 ARG toolchain
 
 RUN apt-get update
-RUN apt-get install -y cmake git ninja-build re2c
+RUN apt-get install -y bison cmake git ninja-build re2c
 RUN if [ "${toolchain}" = "gcc" ]; then apt-get install -y g++; fi
 RUN if [ "${toolchain}" = "clang" ]; then apt-get install -y clang; fi
 

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Change Log
 
+## 0.1.8 RC 3 (2018-04-12)
+
+### Features
+
+* more and advanced simplification rules
+* adds support for exponentiation (power) and modulus (absolute value)
+* new examples: prime numbers, permutation generator, and graph coloring (extended)
+
 ## 0.1.7 (2018-04-08)
 
 ### Features

README.md

@@ -9,10 +9,11 @@
 ## Usage
 
 ```bash
-$ anthem [--simplify] file...
+$ anthem [--complete] [--simplify] file...
 ```
 
-With the option `--simplify`, output formulas are simplified by applying several basic transformation rules.
+`--complete` instructs `anthem` to perform Clark’s completion on the translated formulas.
+With the option `--simplify`, the output formulas are simplified by applying several basic transformation rules.
 
 ## Building
 

app/main.cpp

@@ -70,7 +70,7 @@ int main(int argc, char **argv)
 
 	if (version)
 	{
-		std::cout << "anthem version 0.1.7" << std::endl;
+		std::cout << "anthem version 0.1.8-rc.3" << std::endl;
 		return EXIT_SUCCESS;
 	}
 

examples/graph-coloring.lp

@@ -3,7 +3,8 @@
 #external vertex(1).
 #show color/2.
 
-{color(V,C)} :- vertex(V), color(C).
+{color(V, C)} :- vertex(V), color(C).
 covered(V) :- color(V, _).
 :- vertex(V), not covered(V).
-:- color(V1,C), color(V2,C), edge(V1,V2).
+:- color(V1, C), color(V2, C), edge(V1, V2).
+:- color(V, C1), color(V, C2), C1 != C2.

examples/permutations.lp

@@ -0,0 +1,12 @@
+{p(1..n, 1..n)}.
+
+:- p(X, Y1), p(X, Y2), Y1 != Y2.
+:- p(X1, Y), p(X2, Y), X1 != X2.
+
+q1(X) :- p(X, _).
+q2(Y) :- p(_, Y).
+
+:- not q1(X), X = 1..n.
+:- not q2(Y), Y = 1..n.
+
+#show p/2.

examples/prime.lp

@@ -0,0 +1,4 @@
+#show prime/1.
+
+composite(I * J) :- I = 2..n, J = 2..n.
+prime(N) :- N = 2..n, not composite(N).

examples/schur-numbers.lp

@@ -3,3 +3,5 @@ covered(I) :- in(I, S).
 
 :- I = 1..n, not covered(I).
 :- in(I, S), in(J, S), in(I + J, S).
+
+#show in/2.

include/anthem/AST.h

@@ -32,7 +32,8 @@ struct BinaryOperation
 		Minus,
 		Multiplication,
 		Division,
-		Modulo
+		Modulo,
+		Power
 	};
 
 	explicit BinaryOperation(Operator operator_, Term &&left, Term &&right)
@@ -292,6 +293,30 @@ struct String
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+struct UnaryOperation
+{
+	enum class Operator
+	{
+		Absolute
+	};
+
+	explicit UnaryOperation(Operator operator_, Term &&argument)
+	:	operator_{operator_},
+		argument{std::move(argument)}
+	{
+	}
+
+	UnaryOperation(const UnaryOperation &other) = delete;
+	UnaryOperation &operator=(const UnaryOperation &other) = delete;
+	UnaryOperation(UnaryOperation &&other) noexcept = default;
+	UnaryOperation &operator=(UnaryOperation &&other) noexcept = default;
+
+	Operator operator_;
+	Term argument;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 struct Variable
 {
 	explicit Variable(VariableDeclaration *declaration)

include/anthem/ASTForward.h

@@ -37,6 +37,7 @@ struct Or;
 struct Predicate;
 struct SpecialInteger;
 struct String;
+struct UnaryOperation;
 struct Variable;
 struct VariableDeclaration;
 using VariableDeclarationPointer = std::unique_ptr<VariableDeclaration>;
@@ -68,6 +69,7 @@ using Term = Clingo::Variant<
 	Interval,
 	SpecialInteger,
 	String,
+	UnaryOperation,
 	Variable>;
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

include/anthem/ASTVisitors.h

@@ -165,6 +165,14 @@ struct RecursiveTermVisitor
 		return T::accept(string, term, std::forward<Arguments>(arguments)...);
 	}
 
+	template <class... Arguments>
+	ReturnType visit(UnaryOperation &unaryOperation, Term &term, Arguments &&... arguments)
+	{
+		unaryOperation.argument.accept(*this, unaryOperation.argument, std::forward<Arguments>(arguments)...);
+
+		return T::accept(unaryOperation, term, std::forward<Arguments>(arguments)...);
+	}
+
 	template <class... Arguments>
 	ReturnType visit(Variable &variable, Term &term, Arguments &&... arguments)
 	{

include/anthem/Equality.h

@@ -0,0 +1,430 @@
+#ifndef __ANTHEM__EQUALITY_H
+#define __ANTHEM__EQUALITY_H
+
+#include <anthem/AST.h>
+#include <anthem/ASTUtils.h>
+
+namespace anthem
+{
+namespace ast
+{
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// Equality
+//
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// TODO: move to separate class
+enum class Tristate
+{
+	True,
+	False,
+	Unknown,
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+Tristate equal(const Formula &lhs, const Formula &rhs);
+Tristate equal(const Term &lhs, const Term &rhs);
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct FormulaEqualityVisitor
+{
+	Tristate visit(const And &and_, const Formula &otherFormula)
+	{
+		if (!otherFormula.is<And>())
+			return Tristate::Unknown;
+
+		const auto &otherAnd = otherFormula.get<And>();
+
+		for (const auto &argument : and_.arguments)
+		{
+			const auto match = std::find_if(
+				otherAnd.arguments.cbegin(), otherAnd.arguments.cend(),
+				[&](const auto &otherArgument)
+				{
+					return equal(argument, otherArgument) == Tristate::True;
+				});
+
+			if (match == otherAnd.arguments.cend())
+				return Tristate::Unknown;
+		}
+
+		for (const auto &otherArgument : otherAnd.arguments)
+		{
+			const auto match = std::find_if(
+				and_.arguments.cbegin(), and_.arguments.cend(),
+				[&](const auto &argument)
+				{
+					return equal(otherArgument, argument) == Tristate::True;
+				});
+
+			if (match == and_.arguments.cend())
+				return Tristate::Unknown;
+		}
+
+		return Tristate::True;
+	}
+
+	Tristate visit(const Biconditional &biconditional, const Formula &otherFormula)
+	{
+		if (!otherFormula.is<Biconditional>())
+			return Tristate::Unknown;
+
+		const auto &otherBiconditional = otherFormula.get<Biconditional>();
+
+		if (equal(biconditional.left, otherBiconditional.left) == Tristate::True
+		    && equal(biconditional.right, otherBiconditional.right) == Tristate::True)
+		{
+			return Tristate::True;
+		}
+
+		if (equal(biconditional.left, otherBiconditional.right) == Tristate::True
+		    && equal(biconditional.right, otherBiconditional.left) == Tristate::True)
+		{
+			return Tristate::True;
+		}
+
+		return Tristate::Unknown;
+	}
+
+	Tristate visit(const Boolean &boolean, const Formula &otherFormula)
+	{
+		if (!otherFormula.is<Boolean>())
+			return Tristate::Unknown;
+
+		const auto &otherBoolean = otherFormula.get<Boolean>();
+
+		return (boolean.value == otherBoolean.value)
+			? Tristate::True
+			: Tristate::False;
+	}
+
+	Tristate visit(const Comparison &comparison, const Formula &otherFormula)
+	{
+		if (!otherFormula.is<Comparison>())
+			return Tristate::Unknown;
+
+		const auto &otherComparison = otherFormula.get<Comparison>();
+
+		if (comparison.operator_ != otherComparison.operator_)
+			return Tristate::Unknown;
+
+		if (equal(comparison.left, otherComparison.left) == Tristate::True
+		    && equal(comparison.right, otherComparison.right) == Tristate::True)
+		{
+			return Tristate::True;
+		}
+
+		// Only = and != are commutative operators, all others don’t need to be checked with exchanged arguments
+		if (comparison.operator_ != Comparison::Operator::Equal
+		    && comparison.operator_ != Comparison::Operator::NotEqual)
+		{
+			return Tristate::Unknown;
+		}
+
+		if (equal(comparison.left, otherComparison.right) == Tristate::True
+		    && equal(comparison.right, otherComparison.left) == Tristate::True)
+		{
+			return Tristate::True;
+		}
+
+		return Tristate::Unknown;
+	}
+
+	Tristate visit(const Exists &, const Formula &otherFormula)
+	{
+		if (!otherFormula.is<Exists>())
+			return Tristate::Unknown;
+
+		// TODO: implement stronger check
+		return Tristate::Unknown;
+	}
+
+	Tristate visit(const ForAll &, const Formula &otherFormula)
+	{
+		if (!otherFormula.is<ForAll>())
+			return Tristate::Unknown;
+
+		// TODO: implement stronger check
+		return Tristate::Unknown;
+	}
+
+	Tristate visit(const Implies &implies, const Formula &otherFormula)
+	{
+		if (!otherFormula.is<Implies>())
+			return Tristate::Unknown;
+
+		const auto &otherImplies = otherFormula.get<Implies>();
+
+		if (equal(implies.antecedent, otherImplies.antecedent) == Tristate::True
+		    && equal(implies.consequent, otherImplies.consequent) == Tristate::True)
+		{
+			return Tristate::True;
+		}
+
+		return Tristate::Unknown;
+	}
+
+	Tristate visit(const In &in, const Formula &otherFormula)
+	{
+		if (!otherFormula.is<In>())
+			return Tristate::Unknown;
+
+		const auto &otherIn = otherFormula.get<In>();
+
+		if (equal(in.element, otherIn.element) == Tristate::True
+		    && equal(in.set, otherIn.set) == Tristate::True)
+		{
+			return Tristate::True;
+		}
+
+		return Tristate::Unknown;
+	}
+
+	Tristate visit(const Not &not_, const Formula &otherFormula)
+	{
+		if (!otherFormula.is<Not>())
+			return Tristate::Unknown;
+
+		const auto &otherNot = otherFormula.get<Not>();
+
+		return equal(not_.argument, otherNot.argument);
+	}
+
+	Tristate visit(const Or &or_, const Formula &otherFormula)
+	{
+		if (!otherFormula.is<Or>())
+			return Tristate::Unknown;
+
+		const auto &otherOr = otherFormula.get<Or>();
+
+		for (const auto &argument : or_.arguments)
+		{
+			const auto match = std::find_if(
+				otherOr.arguments.cbegin(), otherOr.arguments.cend(),
+				[&](const auto &otherArgument)
+				{
+					return equal(argument, otherArgument) == Tristate::True;
+				});
+
+			if (match == otherOr.arguments.cend())
+				return Tristate::Unknown;
+		}
+
+		for (const auto &otherArgument : otherOr.arguments)
+		{
+			const auto match = std::find_if(
+				or_.arguments.cbegin(), or_.arguments.cend(),
+				[&](const auto &argument)
+				{
+					return equal(otherArgument, argument) == Tristate::True;
+				});
+
+			if (match == or_.arguments.cend())
+				return Tristate::Unknown;
+		}
+
+		return Tristate::True;
+	}
+
+	Tristate visit(const Predicate &predicate, const Formula &otherFormula)
+	{
+		if (!otherFormula.is<Predicate>())
+			return Tristate::Unknown;
+
+		const auto &otherPredicate = otherFormula.get<Predicate>();
+
+		if (!matches(predicate, otherPredicate))
+			return Tristate::False;
+
+		assert(predicate.arguments.size() == otherPredicate.arguments.size());
+
+		for (size_t i = 0; i < predicate.arguments.size(); i++)
+			if (equal(predicate.arguments[i], otherPredicate.arguments[i]) != Tristate::True)
+				return Tristate::Unknown;
+
+		return Tristate::True;
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct TermEqualityVisitor
+{
+	Tristate visit(const BinaryOperation &binaryOperation, const Term &otherTerm)
+	{
+		if (!otherTerm.is<BinaryOperation>())
+			return Tristate::Unknown;
+
+		const auto &otherBinaryOperation = otherTerm.get<BinaryOperation>();
+
+		if (binaryOperation.operator_ != otherBinaryOperation.operator_)
+			return Tristate::Unknown;
+
+		if (equal(binaryOperation.left, otherBinaryOperation.left) == Tristate::True
+		    && equal(binaryOperation.right, otherBinaryOperation.right) == Tristate::True)
+		{
+			return Tristate::True;
+		}
+
+		// Only + and * are commutative operators, all others don’t need to be checked with exchanged arguments
+		if (binaryOperation.operator_ != BinaryOperation::Operator::Plus
+		    && binaryOperation.operator_ != BinaryOperation::Operator::Multiplication)
+		{
+			return Tristate::Unknown;
+		}
+
+		if (equal(binaryOperation.left, binaryOperation.right) == Tristate::True
+		    && equal(binaryOperation.right, binaryOperation.left) == Tristate::True)
+		{
+			return Tristate::True;
+		}
+
+		return Tristate::Unknown;
+	}
+
+	Tristate visit(const Boolean &boolean, const Term &otherTerm)
+	{
+		if (!otherTerm.is<Boolean>())
+			return Tristate::Unknown;
+
+		const auto &otherBoolean = otherTerm.get<Boolean>();
+
+		return (boolean.value == otherBoolean.value)
+			? Tristate::True
+			: Tristate::False;
+	}
+
+	Tristate visit(const Constant &constant, const Term &otherTerm)
+	{
+		if (!otherTerm.is<Constant>())
+			return Tristate::Unknown;
+
+		const auto &otherConstant = otherTerm.get<Constant>();
+
+		return (constant.name == otherConstant.name)
+			? Tristate::True
+			: Tristate::False;
+	}
+
+	Tristate visit(const Function &function, const Term &otherTerm)
+	{
+		if (!otherTerm.is<Function>())
+			return Tristate::Unknown;
+
+		const auto &otherFunction = otherTerm.get<Function>();
+
+		if (function.name != otherFunction.name)
+			return Tristate::False;
+
+		if (function.arguments.size() != otherFunction.arguments.size())
+			return Tristate::False;
+
+		for (size_t i = 0; i < function.arguments.size(); i++)
+			if (equal(function.arguments[i], otherFunction.arguments[i]) != Tristate::True)
+				return Tristate::Unknown;
+
+		return Tristate::True;
+	}
+
+	Tristate visit(const Integer &integer, const Term &otherTerm)
+	{
+		if (!otherTerm.is<Integer>())
+			return Tristate::Unknown;
+
+		const auto &otherInteger = otherTerm.get<Integer>();
+
+		return (integer.value == otherInteger.value)
+			? Tristate::True
+			: Tristate::False;
+	}
+
+	Tristate visit(const Interval &interval, const Term &otherTerm)
+	{
+		if (!otherTerm.is<Interval>())
+			return Tristate::Unknown;
+
+		const auto &otherInterval = otherTerm.get<Interval>();
+
+		if (equal(interval.from, otherInterval.from) != Tristate::True)
+			return Tristate::Unknown;
+
+		if (equal(interval.to, otherInterval.to) != Tristate::True)
+			return Tristate::Unknown;
+
+		return Tristate::True;
+	}
+
+	Tristate visit(const SpecialInteger &specialInteger, const Term &otherTerm)
+	{
+		if (!otherTerm.is<SpecialInteger>())
+			return Tristate::Unknown;
+
+		const auto &otherSpecialInteger = otherTerm.get<SpecialInteger>();
+
+		return (specialInteger.type == otherSpecialInteger.type)
+			? Tristate::True
+			: Tristate::False;
+	}
+
+	Tristate visit(const String &string, const Term &otherTerm)
+	{
+		if (!otherTerm.is<String>())
+			return Tristate::Unknown;
+
+		const auto &otherString = otherTerm.get<String>();
+
+		return (string.text == otherString.text)
+			? Tristate::True
+			: Tristate::False;
+	}
+
+	Tristate visit(const UnaryOperation &unaryOperation, const Term &otherTerm)
+	{
+		if (!otherTerm.is<UnaryOperation>())
+			return Tristate::Unknown;
+
+		const auto &otherUnaryOperation = otherTerm.get<UnaryOperation>();
+
+		if (unaryOperation.operator_ != otherUnaryOperation.operator_)
+			return Tristate::Unknown;
+
+		return equal(unaryOperation.argument, otherUnaryOperation.argument);
+	}
+
+	Tristate visit(const Variable &variable, const Term &otherTerm)
+	{
+		if (!otherTerm.is<Variable>())
+			return Tristate::Unknown;
+
+		const auto &otherVariable = otherTerm.get<Variable>();
+
+		return (variable.declaration == otherVariable.declaration)
+			? Tristate::True
+			: Tristate::False;
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+Tristate equal(const Formula &lhs, const Formula &rhs)
+{
+	return lhs.accept(FormulaEqualityVisitor(), rhs);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+Tristate equal(const Term &lhs, const Term &rhs)
+{
+	return lhs.accept(TermEqualityVisitor(), rhs);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+}
+}
+
+#endif

include/anthem/Simplification.h

@@ -12,6 +12,14 @@ namespace anthem
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+enum class SimplificationResult
+{
+	Simplified,
+	Unchanged,
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 void simplify(ast::Formula &formula);
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

include/anthem/SimplificationVisitors.h

@@ -0,0 +1,198 @@
+#ifndef __ANTHEM__SIMPLIFICATION_VISITORS_H
+#define __ANTHEM__SIMPLIFICATION_VISITORS_H
+
+#include <anthem/AST.h>
+#include <anthem/Simplification.h>
+
+namespace anthem
+{
+namespace ast
+{
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// Simplification Visitor
+//
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class T>
+struct FormulaSimplificationVisitor
+{
+	template <class... Arguments>
+	SimplificationResult visit(And &and_, Formula &formula, Arguments &&... arguments)
+	{
+		for (auto &argument : and_.arguments)
+			if (argument.accept(*this, argument, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+				return SimplificationResult::Simplified;
+
+		return T::accept(formula, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Biconditional &biconditional, Formula &formula, Arguments &&... arguments)
+	{
+		if (biconditional.left.accept(*this, biconditional.left, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+			return SimplificationResult::Simplified;
+
+		if (biconditional.right.accept(*this, biconditional.right, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+			return SimplificationResult::Simplified;
+
+		return T::accept(formula, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Boolean &, Formula &formula, Arguments &&... arguments)
+	{
+		return T::accept(formula, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Comparison &, Formula &formula, Arguments &&... arguments)
+	{
+		return T::accept(formula, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Exists &exists, Formula &formula, Arguments &&... arguments)
+	{
+		if (exists.argument.accept(*this, exists.argument, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+			return SimplificationResult::Simplified;
+
+		return T::accept(formula, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(ForAll &forAll, Formula &formula, Arguments &&... arguments)
+	{
+		if (forAll.argument.accept(*this, forAll.argument, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+			return SimplificationResult::Simplified;
+
+		return T::accept(formula, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Implies &implies, Formula &formula, Arguments &&... arguments)
+	{
+		if (implies.antecedent.accept(*this, implies.antecedent, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+			return SimplificationResult::Simplified;
+
+		if (implies.consequent.accept(*this, implies.consequent, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+			return SimplificationResult::Simplified;
+
+		return T::accept(formula, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(In &, Formula &formula, Arguments &&... arguments)
+	{
+		return T::accept(formula, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Not &not_, Formula &formula, Arguments &&... arguments)
+	{
+		if (not_.argument.accept(*this, not_.argument, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+			return SimplificationResult::Simplified;
+
+		return T::accept(formula, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Or &or_, Formula &formula, Arguments &&... arguments)
+	{
+		for (auto &argument : or_.arguments)
+			if (argument.accept(*this, argument, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+				return SimplificationResult::Simplified;
+
+		return T::accept(formula, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Predicate &, Formula &formula, Arguments &&... arguments)
+	{
+		return T::accept(formula, std::forward<Arguments>(arguments)...);
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class T, class SimplificationResult = void>
+struct TermSimplificationVisitor
+{
+	template <class... Arguments>
+	SimplificationResult visit(BinaryOperation &binaryOperation, Term &term, Arguments &&... arguments)
+	{
+		if (binaryOperation.left.accept(*this, binaryOperation.left, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+			return SimplificationResult::Simplified;
+
+		if (binaryOperation.right.accept(*this, binaryOperation.right, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+			return SimplificationResult::Simplified;
+
+		return T::accept(term, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Boolean &, Term &term, Arguments &&... arguments)
+	{
+		return T::accept(term, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Constant &, Term &term, Arguments &&... arguments)
+	{
+		return T::accept(term, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Function &function, Term &term, Arguments &&... arguments)
+	{
+		for (auto &argument : function.arguments)
+			if (argument.accept(*this, argument, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+				return SimplificationResult::Simplified;
+
+		return T::accept(term, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Integer &, Term &term, Arguments &&... arguments)
+	{
+		return T::accept(term, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Interval &interval, Term &term, Arguments &&... arguments)
+	{
+		if (interval.from.accept(*this, interval.from, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+			return SimplificationResult::Simplified;
+
+		if (interval.to.accept(*this, interval.to, std::forward<Arguments>(arguments)...) == SimplificationResult::Simplified)
+			return SimplificationResult::Simplified;
+
+		return T::accept(term, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(SpecialInteger &, Term &term, Arguments &&... arguments)
+	{
+		return T::accept(term, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(String &, Term &term, Arguments &&... arguments)
+	{
+		return T::accept(term, std::forward<Arguments>(arguments)...);
+	}
+
+	template <class... Arguments>
+	SimplificationResult visit(Variable &, Term &term, Arguments &&... arguments)
+	{
+		return T::accept(term, std::forward<Arguments>(arguments)...);
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+}
+}
+
+#endif

include/anthem/Term.h

@@ -23,6 +23,12 @@ ast::BinaryOperation::Operator translate(Clingo::AST::BinaryOperator binaryOpera
 {
 	switch (binaryOperator)
 	{
+		case Clingo::AST::BinaryOperator::XOr:
+			throw TranslationException(term.location, "binary operation “xor” currently unsupported");
+		case Clingo::AST::BinaryOperator::Or:
+			throw TranslationException(term.location, "binary operation “or” currently unsupported");
+		case Clingo::AST::BinaryOperator::And:
+			throw TranslationException(term.location, "binary operation “and” currently unsupported");
 		case Clingo::AST::BinaryOperator::Plus:
 			return ast::BinaryOperation::Operator::Plus;
 		case Clingo::AST::BinaryOperator::Minus:
@@ -33,11 +39,28 @@ ast::BinaryOperation::Operator translate(Clingo::AST::BinaryOperator binaryOpera
 			return ast::BinaryOperation::Operator::Division;
 		case Clingo::AST::BinaryOperator::Modulo:
 			return ast::BinaryOperation::Operator::Modulo;
-		default:
-			throw TranslationException(term.location, "“binary operation” terms currently unsupported");
+		case Clingo::AST::BinaryOperator::Power:
+			return ast::BinaryOperation::Operator::Power;
 	}
 
-	return ast::BinaryOperation::Operator::Plus;
+	throw TranslationException(term.location, "unknown binary operation");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ast::UnaryOperation::Operator translate(Clingo::AST::UnaryOperator unaryOperator, const Clingo::AST::Term &term)
+{
+	switch (unaryOperator)
+	{
+		case Clingo::AST::UnaryOperator::Absolute:
+			return ast::UnaryOperation::Operator::Absolute;
+		case Clingo::AST::UnaryOperator::Minus:
+			throw TranslationException(term.location, "binary operation “minus” currently unsupported");
+		case Clingo::AST::UnaryOperator::Negation:
+			throw TranslationException(term.location, "binary operation “negation” currently unsupported");
+	}
+
+	throw TranslationException(term.location, "unknown unary operation");
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -100,12 +123,6 @@ struct TermTranslateVisitor
 		return ast::Term::make<ast::Variable>(ruleContext.freeVariables.back().get());
 	}
 
-	std::optional<ast::Term> visit(const Clingo::AST::UnaryOperation &, const Clingo::AST::Term &term, RuleContext &, const ast::VariableStack &)
-	{
-		throw TranslationException(term.location, "“unary operation” terms currently unsupported");
-		return std::nullopt;
-	}
-
 	std::optional<ast::Term> visit(const Clingo::AST::BinaryOperation &binaryOperation, const Clingo::AST::Term &term, RuleContext &ruleContext, const ast::VariableStack &variableStack)
 	{
 		const auto operator_ = translate(binaryOperation.binary_operator, term);
@@ -115,6 +132,14 @@ struct TermTranslateVisitor
 		return ast::Term::make<ast::BinaryOperation>(operator_, std::move(left), std::move(right));
 	}
 
+	std::optional<ast::Term> visit(const Clingo::AST::UnaryOperation &unaryOperation, const Clingo::AST::Term &term, RuleContext &ruleContext, const ast::VariableStack &variableStack)
+	{
+		const auto operator_ = translate(unaryOperation.unary_operator, term);
+		auto argument = translate(unaryOperation.argument, ruleContext, variableStack);
+
+		return ast::Term::make<ast::UnaryOperation>(operator_, std::move(argument));
+	}
+
 	std::optional<ast::Term> visit(const Clingo::AST::Interval &interval, const Clingo::AST::Term &, RuleContext &ruleContext, const ast::VariableStack &variableStack)
 	{
 		auto left = translate(interval.left, ruleContext, variableStack);

include/anthem/output/AST.h

@@ -41,37 +41,39 @@ struct PrintContext
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-output::ColorStream &print(output::ColorStream &stream, const BinaryOperation::Operator operator_, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const BinaryOperation &binaryOperation, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Boolean &boolean, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Comparison &comparison, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Constant &constant, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Function &function, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const In &in, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Integer &integer, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Interval &interval, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Predicate &predicate, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const SpecialInteger &specialInteger, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const String &string, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Variable &variable, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const VariableDeclaration &variableDeclaration, PrintContext &printContext);
+output::ColorStream &print(output::ColorStream &stream, const BinaryOperation::Operator operator_, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const BinaryOperation &binaryOperation, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Boolean &boolean, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Comparison &comparison, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, Comparison::Operator operator_, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Constant &constant, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Function &function, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const In &in, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Integer &integer, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Interval &interval, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Predicate &predicate, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const SpecialInteger &specialInteger, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const String &string, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const UnaryOperation &unaryOperation, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Variable &variable, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const VariableDeclaration &variableDeclaration, PrintContext &printContext, bool omitParentheses = false);
 
-output::ColorStream &print(output::ColorStream &stream, const And &and_, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Biconditional &biconditional, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Exists &exists, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const ForAll &forAll, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Implies &implies, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Not &not_, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Or &or_, PrintContext &printContext);
+output::ColorStream &print(output::ColorStream &stream, const And &and_, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Biconditional &biconditional, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Exists &exists, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const ForAll &forAll, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Implies &implies, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Not &not_, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Or &or_, PrintContext &printContext, bool omitParentheses = false);
 
-output::ColorStream &print(output::ColorStream &stream, const Formula &formula, PrintContext &printContext);
-output::ColorStream &print(output::ColorStream &stream, const Term &term, PrintContext &printContext);
+output::ColorStream &print(output::ColorStream &stream, const Formula &formula, PrintContext &printContext, bool omitParentheses = false);
+output::ColorStream &print(output::ColorStream &stream, const Term &term, PrintContext &printContext, bool omitParentheses = false);
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Primitives
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, BinaryOperation::Operator operator_, PrintContext &)
+inline output::ColorStream &print(output::ColorStream &stream, BinaryOperation::Operator operator_, PrintContext &, bool)
 {
 	switch (operator_)
 	{
@@ -85,6 +87,8 @@ inline output::ColorStream &print(output::ColorStream &stream, BinaryOperation::
 			return (stream << output::Operator("/"));
 		case BinaryOperation::Operator::Modulo:
 			return (stream << output::Operator("%"));
+		case BinaryOperation::Operator::Power:
+			return (stream << output::Operator("**"));
 	}
 
 	return stream;
@@ -92,22 +96,26 @@ inline output::ColorStream &print(output::ColorStream &stream, BinaryOperation::
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const BinaryOperation &binaryOperation, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const BinaryOperation &binaryOperation, PrintContext &printContext, bool omitParentheses)
 {
-	stream << "(";
+	if (!omitParentheses || printContext.context.parenthesisStyle == ParenthesisStyle::Full)
+		stream << "(";
+
 	print(stream, binaryOperation.left, printContext);
 	stream << " ";
 	print(stream, binaryOperation.operator_, printContext);
 	stream << " ";
 	print(stream, binaryOperation.right, printContext);
-	stream << ")";
+
+	if (!omitParentheses || printContext.context.parenthesisStyle == ParenthesisStyle::Full)
+		stream << ")";
 
 	return stream;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Boolean &boolean, PrintContext &)
+inline output::ColorStream &print(output::ColorStream &stream, const Boolean &boolean, PrintContext &, bool)
 {
 	if (boolean.value)
 		return (stream << output::Boolean("#true"));
@@ -117,7 +125,7 @@ inline output::ColorStream &print(output::ColorStream &stream, const Boolean &bo
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, Comparison::Operator operator_, PrintContext &)
+inline output::ColorStream &print(output::ColorStream &stream, Comparison::Operator operator_, PrintContext &, bool)
 {
 	switch (operator_)
 	{
@@ -140,7 +148,7 @@ inline output::ColorStream &print(output::ColorStream &stream, Comparison::Opera
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Comparison &comparison, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const Comparison &comparison, PrintContext &printContext, bool)
 {
 	if (printContext.context.parenthesisStyle == ParenthesisStyle::Full)
 		stream << "(";
@@ -159,14 +167,14 @@ inline output::ColorStream &print(output::ColorStream &stream, const Comparison
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Constant &constant, PrintContext &)
+inline output::ColorStream &print(output::ColorStream &stream, const Constant &constant, PrintContext &, bool)
 {
 	return (stream << constant.name);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Function &function, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const Function &function, PrintContext &printContext, bool)
 {
 	stream << function.name;
 
@@ -193,7 +201,7 @@ inline output::ColorStream &print(output::ColorStream &stream, const Function &f
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const In &in, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const In &in, PrintContext &printContext, bool)
 {
 	if (printContext.context.parenthesisStyle == ParenthesisStyle::Full)
 		stream << "(";
@@ -210,14 +218,14 @@ inline output::ColorStream &print(output::ColorStream &stream, const In &in, Pri
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Integer &integer, PrintContext &)
+inline output::ColorStream &print(output::ColorStream &stream, const Integer &integer, PrintContext &, bool)
 {
 	return (stream << output::Number<int>(integer.value));
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Interval &interval, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const Interval &interval, PrintContext &printContext, bool)
 {
 	if (printContext.context.parenthesisStyle == ParenthesisStyle::Full)
 		stream << "(";
@@ -234,7 +242,7 @@ inline output::ColorStream &print(output::ColorStream &stream, const Interval &i
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Predicate &predicate, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const Predicate &predicate, PrintContext &printContext, bool)
 {
 	stream << predicate.name;
 
@@ -258,7 +266,7 @@ inline output::ColorStream &print(output::ColorStream &stream, const Predicate &
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const SpecialInteger &specialInteger, PrintContext &)
+inline output::ColorStream &print(output::ColorStream &stream, const SpecialInteger &specialInteger, PrintContext &, bool)
 {
 	switch (specialInteger.type)
 	{
@@ -273,14 +281,37 @@ inline output::ColorStream &print(output::ColorStream &stream, const SpecialInte
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const String &string, PrintContext &)
+inline output::ColorStream &print(output::ColorStream &stream, const String &string, PrintContext &, bool)
 {
 	return (stream << output::String(string.text.c_str()));
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Variable &variable, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const UnaryOperation &unaryOperation, PrintContext &printContext, bool)
+{
+	switch (unaryOperation.operator_)
+	{
+		case UnaryOperation::Operator::Absolute:
+			stream << "|";
+			break;
+	}
+
+	print(stream, unaryOperation.argument, printContext, true);
+
+	switch (unaryOperation.operator_)
+	{
+		case UnaryOperation::Operator::Absolute:
+			stream << "|";
+			break;
+	}
+
+	return stream;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+inline output::ColorStream &print(output::ColorStream &stream, const Variable &variable, PrintContext &printContext, bool)
 {
 	assert(variable.declaration != nullptr);
 
@@ -289,7 +320,7 @@ inline output::ColorStream &print(output::ColorStream &stream, const Variable &v
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const VariableDeclaration &variableDeclaration, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const VariableDeclaration &variableDeclaration, PrintContext &printContext, bool)
 {
 	const auto printVariableDeclaration =
 		[&stream, &variableDeclaration](const auto *prefix, auto &variableIDs) -> output::ColorStream &
@@ -325,9 +356,10 @@ inline output::ColorStream &print(output::ColorStream &stream, const VariableDec
 // Expressions
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const And &and_, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const And &and_, PrintContext &printContext, bool omitParentheses)
 {
-	stream << "(";
+	if (!omitParentheses || printContext.context.parenthesisStyle == ParenthesisStyle::Full)
+		stream << "(";
 
 	for (auto i = and_.arguments.cbegin(); i != and_.arguments.cend(); i++)
 	{
@@ -337,27 +369,32 @@ inline output::ColorStream &print(output::ColorStream &stream, const And &and_,
 		print(stream, *i, printContext);
 	}
 
-	stream << ")";
+	if (!omitParentheses || printContext.context.parenthesisStyle == ParenthesisStyle::Full)
+		stream << ")";
 
 	return stream;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Biconditional &biconditional, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const Biconditional &biconditional, PrintContext &printContext, bool omitParentheses)
 {
-	stream << "(";
+	if (!omitParentheses || printContext.context.parenthesisStyle == ParenthesisStyle::Full)
+		stream << "(";
+
 	print(stream, biconditional.left, printContext);
 	stream << " <-> ";
 	print(stream, biconditional.right, printContext);
-	stream << ")";
+
+	if (!omitParentheses || printContext.context.parenthesisStyle == ParenthesisStyle::Full)
+		stream << ")";
 
 	return stream;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Exists &exists, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const Exists &exists, PrintContext &printContext, bool)
 {
 	if (printContext.context.parenthesisStyle == ParenthesisStyle::Full)
 		stream << "(";
@@ -383,7 +420,7 @@ inline output::ColorStream &print(output::ColorStream &stream, const Exists &exi
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const ForAll &forAll, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const ForAll &forAll, PrintContext &printContext, bool)
 {
 	if (printContext.context.parenthesisStyle == ParenthesisStyle::Full)
 		stream << "(";
@@ -409,20 +446,24 @@ inline output::ColorStream &print(output::ColorStream &stream, const ForAll &for
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Implies &implies, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const Implies &implies, PrintContext &printContext, bool omitParentheses)
 {
-	stream << "(";
+	if (!omitParentheses || printContext.context.parenthesisStyle == ParenthesisStyle::Full)
+		stream << "(";
+
 	print(stream, implies.antecedent, printContext);
 	stream << " -> ";
 	print(stream, implies.consequent, printContext);
-	stream << ")";
+
+	if (!omitParentheses || printContext.context.parenthesisStyle == ParenthesisStyle::Full)
+		stream << ")";
 
 	return stream;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Not &not_, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const Not &not_, PrintContext &printContext, bool)
 {
 	if (printContext.context.parenthesisStyle == ParenthesisStyle::Full)
 		stream << "(";
@@ -438,9 +479,10 @@ inline output::ColorStream &print(output::ColorStream &stream, const Not &not_,
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Or &or_, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const Or &or_, PrintContext &printContext, bool omitParentheses)
 {
-	stream << "(";
+	if (!omitParentheses || printContext.context.parenthesisStyle == ParenthesisStyle::Full)
+		stream << "(";
 
 	for (auto i = or_.arguments.cbegin(); i != or_.arguments.cend(); i++)
 	{
@@ -450,7 +492,8 @@ inline output::ColorStream &print(output::ColorStream &stream, const Or &or_, Pr
 		print(stream, *i, printContext);
 	}
 
-	stream << ")";
+	if (!omitParentheses || printContext.context.parenthesisStyle == ParenthesisStyle::Full)
+		stream << ")";
 
 	return stream;
 }
@@ -463,24 +506,24 @@ template<class Variant>
 struct VariantPrintVisitor
 {
 	template<class T>
-	output::ColorStream &visit(const T &x, output::ColorStream &stream, PrintContext &printContext)
+	output::ColorStream &visit(const T &x, output::ColorStream &stream, PrintContext &printContext, bool omitParentheses)
 	{
-		return print(stream, x, printContext);
+		return print(stream, x, printContext, omitParentheses);
 	}
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Formula &formula, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const Formula &formula, PrintContext &printContext, bool omitParentheses)
 {
-	return formula.accept(VariantPrintVisitor<Formula>(), stream, printContext);
+	return formula.accept(VariantPrintVisitor<Formula>(), stream, printContext, omitParentheses);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-inline output::ColorStream &print(output::ColorStream &stream, const Term &term, PrintContext &printContext)
+inline output::ColorStream &print(output::ColorStream &stream, const Term &term, PrintContext &printContext, bool omitParentheses)
 {
-	return term.accept(VariantPrintVisitor<Term>(), stream, printContext);
+	return term.accept(VariantPrintVisitor<Term>(), stream, printContext, omitParentheses);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

src/anthem/ASTCopy.cpp

@@ -159,6 +159,13 @@ String prepareCopy(const String &other)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+UnaryOperation prepareCopy(const UnaryOperation &other)
+{
+	return UnaryOperation(other.operator_, prepareCopy(other.argument));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 Variable prepareCopy(const Variable &other)
 {
 	return Variable(other.declaration);
@@ -320,6 +327,12 @@ struct FixDanglingVariablesInTermVisitor
 	{
 	}
 
+	template <class... Arguments>
+	void visit(UnaryOperation &unaryOperation, Arguments &&... arguments)
+	{
+		unaryOperation.argument.accept(*this, std::forward<Arguments>(arguments)...);
+	}
+
 	void visit(Variable &variable, ScopedFormula &scopedFormula, VariableStack &variableStack,
 		std::map<VariableDeclaration *, VariableDeclaration *> &replacements)
 	{

src/anthem/ASTUtils.cpp

@@ -178,6 +178,11 @@ struct CollectFreeVariablesVisitor
 	{
 	}
 
+	void visit(UnaryOperation &unaryOperation, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
+	{
+		unaryOperation.argument.accept(*this, variableStack, freeVariables);
+	}
+
 	void visit(Variable &variable, VariableStack &variableStack, std::vector<VariableDeclaration *> &freeVariables)
 	{
 		if (variableStack.contains(*variable.declaration))

src/anthem/Simplification.cpp

@@ -3,7 +3,9 @@
 #include <optional>
 
 #include <anthem/ASTCopy.h>
-#include <anthem/ASTVisitors.h>
+#include <anthem/Equality.h>
+#include <anthem/output/AST.h>
+#include <anthem/SimplificationVisitors.h>
 
 namespace anthem
 {
@@ -97,18 +99,65 @@ struct ReplaceVariableInFormulaVisitor : public ast::RecursiveFormulaVisitor<Rep
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-// Simplifies exists statements by using the equivalence “exists X (X = t and F(X))” == “F(t)”
-// The exists statement has to be of the form “exists <variables> <conjunction>”
-void simplify(ast::Exists &exists, ast::Formula &formula)
+template<class SimplificationRule>
+SimplificationResult simplify(ast::Formula &formula)
 {
-	// Simplify formulas like “exists X (X = Y)” to “#true”
-	// TODO: check that this covers all cases
-	if (exists.argument.is<ast::Comparison>())
+	return SimplificationRule::apply(formula);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+template<class FirstSimplificationRule, class SecondSimplificationRule, class... OtherSimplificationRules>
+SimplificationResult simplify(ast::Formula &formula)
+{
+	if (simplify<FirstSimplificationRule>(formula) == SimplificationResult::Simplified)
+		return SimplificationResult::Simplified;
+
+	return simplify<SecondSimplificationRule, OtherSimplificationRules...>(formula);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct SimplificationRuleExistsWithoutQuantifiedVariables
+{
+	static constexpr const auto Description = "exists () (F) === F";
+
+	static SimplificationResult apply(ast::Formula &formula)
 	{
+		if (!formula.is<ast::Exists>())
+			return SimplificationResult::Unchanged;
+
+		auto &exists = formula.get<ast::Exists>();
+
+		if (!exists.variables.empty())
+			return SimplificationResult::Unchanged;
+
+		formula = std::move(exists.argument);
+
+		return SimplificationResult::Simplified;
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct SimplificationRuleTrivialAssignmentInExists
+{
+	static constexpr const auto Description = "exists X (X = Y) === #true";
+
+	static SimplificationResult apply(ast::Formula &formula)
+	{
+		if (!formula.is<ast::Exists>())
+			return SimplificationResult::Unchanged;
+
+		const auto &exists = formula.get<ast::Exists>();
+
+		if (!exists.argument.is<ast::Comparison>())
+			return SimplificationResult::Unchanged;
+
 		const auto &comparison = exists.argument.get<ast::Comparison>();
 
 		if (comparison.operator_ != ast::Comparison::Operator::Equal)
-			return;
+			return SimplificationResult::Unchanged;
 
 		const auto matchingAssignment = std::find_if(exists.variables.cbegin(), exists.variables.cend(),
 			[&](const auto &variableDeclaration)
@@ -117,107 +166,378 @@ void simplify(ast::Exists &exists, ast::Formula &formula)
 					|| matchesVariableDeclaration(comparison.right, *variableDeclaration);
 			});
 
-		if (matchingAssignment != exists.variables.cend())
-			formula = ast::Formula::make<ast::Boolean>(true);
+		if (matchingAssignment == exists.variables.cend())
+			return SimplificationResult::Unchanged;
 
-		return;
+		formula = ast::Formula::make<ast::Boolean>(true);
+
+		return SimplificationResult::Simplified;
 	}
+};
 
-	if (!exists.argument.is<ast::And>())
-		return;
+////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	auto &conjunction = exists.argument.get<ast::And>();
-	auto &arguments = conjunction.arguments;
+struct SimplificationRuleAssignmentInExists
+{
+	static constexpr const auto Description = "exists X (X = t and F(X)) === exists () (F(t))";
 
-	// Simplify formulas of type “exists X (X = t and F(X))” to “F(t)”
-	for (auto i = exists.variables.begin(); i != exists.variables.end();)
+	static SimplificationResult apply(ast::Formula &formula)
 	{
-		const auto &variableDeclaration = **i;
+		if (!formula.is<ast::Exists>())
+			return SimplificationResult::Unchanged;
 
-		bool wasVariableReplaced = false;
+		auto &exists = formula.get<ast::Exists>();
 
-		// TODO: refactor
-		for (auto j = arguments.begin(); j != arguments.end(); j++)
+		if (!exists.argument.is<ast::And>())
+			return SimplificationResult::Unchanged;
+
+		auto &and_ = exists.argument.get<ast::And>();
+		auto &arguments = and_.arguments;
+
+		auto simplificationResult = SimplificationResult::Unchanged;
+
+		for (auto i = exists.variables.begin(); i != exists.variables.end();)
 		{
-			auto &argument = *j;
-			// Find term that is equivalent to the given variable
-			auto assignedTerm = extractAssignedTerm(argument, variableDeclaration);
+			const auto &variableDeclaration = **i;
 
-			if (!assignedTerm)
-				continue;
+			bool wasVariableReplaced = false;
 
-			// Replace all occurrences of the variable with the equivalent term
-			for (auto k = arguments.begin(); k != arguments.end(); k++)
+			// TODO: refactor
+			for (auto j = arguments.begin(); j != arguments.end(); j++)
 			{
-				if (k == j)
+				auto &argument = *j;
+				// Find term that is equivalent to the given variable
+				auto assignedTerm = extractAssignedTerm(argument, variableDeclaration);
+
+				if (!assignedTerm)
 					continue;
 
-				auto &otherArgument = *k;
-				otherArgument.accept(ReplaceVariableInFormulaVisitor(), otherArgument, variableDeclaration, assignedTerm.value());
+				// Replace all occurrences of the variable with the equivalent term
+				for (auto k = arguments.begin(); k != arguments.end(); k++)
+				{
+					if (k == j)
+						continue;
+
+					auto &otherArgument = *k;
+					otherArgument.accept(ReplaceVariableInFormulaVisitor(), otherArgument, variableDeclaration, assignedTerm.value());
+				}
+
+				arguments.erase(j);
+
+				wasVariableReplaced = true;
+				simplificationResult = SimplificationResult::Simplified;
+
+				break;
 			}
 
-			arguments.erase(j);
-			wasVariableReplaced = true;
-			break;
+			if (wasVariableReplaced)
+			{
+				i = exists.variables.erase(i);
+				continue;
+			}
+
+			i++;
 		}
 
-		if (wasVariableReplaced)
-		{
-			i = exists.variables.erase(i);
-			continue;
-		}
-
-		i++;
+		return simplificationResult;
 	}
+};
 
-	// If there are no arguments left, we had a formula of the form “exists X1, ..., Xn (X1 = Y1 and ... and Xn = Yn)”
-	// Such exists statements are useless and can be safely replaced with “#true”
-	if (arguments.empty())
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct SimplificationRuleEmptyConjunction
+{
+	static constexpr const auto Description = "[empty conjunction] === #true";
+
+	static SimplificationResult apply(ast::Formula &formula)
 	{
+		if (!formula.is<ast::And>())
+			return SimplificationResult::Unchanged;
+
+		auto &and_ = formula.get<ast::And>();
+
+		if (!and_.arguments.empty())
+			return SimplificationResult::Unchanged;
+
 		formula = ast::Formula::make<ast::Boolean>(true);
-		return;
+
+		return SimplificationResult::Simplified;
 	}
+};
 
-	// If the argument now is a conjunction with just one element, directly replace the input formula with the argument
-	if (arguments.size() == 1)
-		exists.argument = std::move(arguments.front());
+////////////////////////////////////////////////////////////////////////////////////////////////////
 
-	// If there are still remaining variables, simplification is over
-	if (!exists.variables.empty())
-		return;
+struct SimplificationRuleOneElementConjunction
+{
+	static constexpr const auto Description = "[conjunction of only F] === F";
 
-	assert(!arguments.empty());
+	static SimplificationResult apply(ast::Formula &formula)
+	{
+		if (!formula.is<ast::And>())
+			return SimplificationResult::Unchanged;
 
-	// If there is more than one element in the conjunction, replace the input formula with the conjunction
-	formula = std::move(exists.argument);
-}
+		auto &and_ = formula.get<ast::And>();
+
+		if (and_.arguments.size() != 1)
+			return SimplificationResult::Unchanged;
+
+		formula = std::move(and_.arguments.front());
+
+		return SimplificationResult::Simplified;
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct SimplificationRuleTrivialExists
+{
+	static constexpr const auto Description = "exists ... ([#true/#false]) === [#true/#false]";
+
+	static SimplificationResult apply(ast::Formula &formula)
+	{
+		if (!formula.is<ast::Exists>())
+			return SimplificationResult::Unchanged;
+
+		auto &exists = formula.get<ast::Exists>();
+
+		if (!exists.argument.is<ast::Boolean>())
+			return SimplificationResult::Unchanged;
+
+		formula = std::move(exists.argument);
+
+		return SimplificationResult::Simplified;
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct SimplificationRuleInWithPrimitiveArguments
+{
+	static constexpr const auto Description = "[primitive A] in [primitive B] === A = B";
+
+	static SimplificationResult apply(ast::Formula &formula)
+	{
+		if (!formula.is<ast::In>())
+			return SimplificationResult::Unchanged;
+
+		auto &in = formula.get<ast::In>();
+
+		assert(ast::isPrimitive(in.element));
+
+		if (!ast::isPrimitive(in.element) || !ast::isPrimitive(in.set))
+			return SimplificationResult::Unchanged;
+
+		formula = ast::Comparison(ast::Comparison::Operator::Equal, std::move(in.element), std::move(in.set));
+
+		return SimplificationResult::Simplified;
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct SimplificationRuleSubsumptionInBiconditionals
+{
+	static constexpr const auto Description = "(F <-> (F and G)) === (F -> G)";
+
+	static SimplificationResult apply(ast::Formula &formula)
+	{
+		if (!formula.is<ast::Biconditional>())
+			return SimplificationResult::Unchanged;
+
+		auto &biconditional = formula.get<ast::Biconditional>();
+
+		const auto leftIsPredicate = biconditional.left.is<ast::Predicate>();
+		const auto rightIsPredicate = biconditional.right.is<ast::Predicate>();
+
+		const auto leftIsAnd = biconditional.left.is<ast::And>();
+		const auto rightIsAnd = biconditional.right.is<ast::And>();
+
+		if (!(leftIsPredicate && rightIsAnd) && !(rightIsPredicate && leftIsAnd))
+			return SimplificationResult::Unchanged;
+
+		auto &predicateSide = (leftIsPredicate ? biconditional.left : biconditional.right);
+		auto &andSide = (leftIsPredicate ? biconditional.right : biconditional.left);
+		auto &and_ = andSide.get<ast::And>();
+
+		const auto matchingPredicate =
+			std::find_if(and_.arguments.cbegin(), and_.arguments.cend(),
+			[&](const auto &argument)
+			{
+				return (ast::equal(predicateSide, argument) == ast::Tristate::True);
+			});
+
+		if (matchingPredicate == and_.arguments.cend())
+			return SimplificationResult::Unchanged;
+
+		and_.arguments.erase(matchingPredicate);
+
+		formula = ast::Formula::make<ast::Implies>(std::move(predicateSide), std::move(andSide));
+
+		return SimplificationResult::Simplified;
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct SimplificationRuleDoubleNegation
+{
+	static constexpr const auto Description = "not not F === F";
+
+	static SimplificationResult apply(ast::Formula &formula)
+	{
+		if (!formula.is<ast::Not>())
+			return SimplificationResult::Unchanged;
+
+		auto &not_ = formula.get<ast::Not>();
+
+		if (!not_.argument.is<ast::Not>())
+			return SimplificationResult::Unchanged;
+
+		auto &notNot = not_.argument.get<ast::Not>();
+
+		formula = std::move(notNot.argument);
+
+		return SimplificationResult::Simplified;
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct SimplificationRuleDeMorganForConjunctions
+{
+	static constexpr const auto Description = "(not (F and G)) === (not F or not G)";
+
+	static SimplificationResult apply(ast::Formula &formula)
+	{
+		if (!formula.is<ast::Not>())
+			return SimplificationResult::Unchanged;
+
+		auto &not_ = formula.get<ast::Not>();
+
+		if (!not_.argument.is<ast::And>())
+			return SimplificationResult::Unchanged;
+
+		auto &and_ = not_.argument.get<ast::And>();
+
+		for (auto &argument : and_.arguments)
+			argument = ast::Formula::make<ast::Not>(std::move(argument));
+
+		formula = ast::Formula::make<ast::Or>(std::move(and_.arguments));
+
+		return SimplificationResult::Simplified;
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct SimplificationRuleImplicationFromDisjunction
+{
+	static constexpr const auto Description = "(not F or G) === (F -> G)";
+
+	static SimplificationResult apply(ast::Formula &formula)
+	{
+		if (!formula.is<ast::Or>())
+			return SimplificationResult::Unchanged;
+
+		auto &or_ = formula.get<ast::Or>();
+
+		if (or_.arguments.size() != 2)
+			return SimplificationResult::Unchanged;
+
+		const auto leftIsNot = or_.arguments[0].is<ast::Not>();
+		const auto rightIsNot = or_.arguments[1].is<ast::Not>();
+
+		if (leftIsNot == rightIsNot)
+			return SimplificationResult::Unchanged;
+
+		auto &negativeSide = leftIsNot ? or_.arguments[0] : or_.arguments[1];
+		auto &positiveSide = leftIsNot ? or_.arguments[1] : or_.arguments[0];
+
+		assert(negativeSide.is<ast::Not>());
+		assert(!positiveSide.is<ast::Not>());
+
+		auto &negativeSideArgument = negativeSide.get<ast::Not>().argument;
+
+		formula = ast::Formula::make<ast::Implies>(std::move(negativeSideArgument), std::move(positiveSide));
+
+		return SimplificationResult::Simplified;
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct SimplificationRuleNegatedComparison
+{
+	static constexpr const auto Description = "(not F [comparison] G) === (F [negated comparison] G)";
+
+	static SimplificationResult apply(ast::Formula &formula)
+	{
+		if (!formula.is<ast::Not>())
+			return SimplificationResult::Unchanged;
+
+		auto &not_ = formula.get<ast::Not>();
+
+		if (!not_.argument.is<ast::Comparison>())
+			return SimplificationResult::Unchanged;
+
+		auto &comparison = not_.argument.get<ast::Comparison>();
+
+		switch (comparison.operator_)
+		{
+			case ast::Comparison::Operator::GreaterThan:
+				comparison.operator_ = ast::Comparison::Operator::LessEqual;
+				break;
+			case ast::Comparison::Operator::LessThan:
+				comparison.operator_ = ast::Comparison::Operator::GreaterEqual;
+				break;
+			case ast::Comparison::Operator::LessEqual:
+				comparison.operator_ = ast::Comparison::Operator::GreaterThan;
+				break;
+			case ast::Comparison::Operator::GreaterEqual:
+				comparison.operator_ = ast::Comparison::Operator::LessThan;
+				break;
+			case ast::Comparison::Operator::NotEqual:
+				comparison.operator_ = ast::Comparison::Operator::Equal;
+				break;
+			case ast::Comparison::Operator::Equal:
+				comparison.operator_ = ast::Comparison::Operator::NotEqual;
+				break;
+		}
+
+		formula = std::move(comparison);
+
+		return SimplificationResult::Simplified;
+	}
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+const auto simplifyWithDefaultRules =
+	simplify
+	<
+		SimplificationRuleDoubleNegation,
+		SimplificationRuleTrivialAssignmentInExists,
+		SimplificationRuleAssignmentInExists,
+		SimplificationRuleEmptyConjunction,
+		SimplificationRuleTrivialExists,
+		SimplificationRuleOneElementConjunction,
+		SimplificationRuleExistsWithoutQuantifiedVariables,
+		SimplificationRuleInWithPrimitiveArguments,
+		SimplificationRuleSubsumptionInBiconditionals,
+		SimplificationRuleDeMorganForConjunctions,
+		SimplificationRuleImplicationFromDisjunction,
+		SimplificationRuleNegatedComparison
+	>;
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // Performs the different simplification techniques
-struct SimplifyFormulaVisitor : public ast::RecursiveFormulaVisitor<SimplifyFormulaVisitor>
+struct SimplifyFormulaVisitor : public ast::FormulaSimplificationVisitor<SimplifyFormulaVisitor>
 {
-	// Forward exists statements to the dedicated simplification function
-	static void accept(ast::Exists &exists, ast::Formula &formula)
-	{
-		simplify(exists, formula);
-	}
-
-	// Simplify formulas of type “A in B” to “A = B” if A and B are primitive
-	static void accept(ast::In &in, ast::Formula &formula)
-	{
-		assert(ast::isPrimitive(in.element));
-
-		if (!ast::isPrimitive(in.element) || !ast::isPrimitive(in.set))
-			return;
-
-		formula = ast::Comparison(ast::Comparison::Operator::Equal, std::move(in.element), std::move(in.set));
-	}
-
 	// Do nothing for all other types of expressions
-	template<class T>
-	static void accept(T &, ast::Formula &)
+	static SimplificationResult accept(ast::Formula &formula)
 	{
+		return simplifyWithDefaultRules(formula);
 	}
 };
 
@@ -225,7 +545,7 @@ struct SimplifyFormulaVisitor : public ast::RecursiveFormulaVisitor<SimplifyForm
 
 void simplify(ast::Formula &formula)
 {
-	formula.accept(SimplifyFormulaVisitor(), formula);
+	while (formula.accept(SimplifyFormulaVisitor(), formula) == SimplificationResult::Simplified);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////

tests/TestCompletion.cpp

@@ -152,9 +152,9 @@ TEST_CASE("[completion] Rules are completed", "[completion]")
 
 		CHECK(output.str() ==
 			"forall V1 (covered(V1) <-> exists U1 in(V1, U1))\n"
-			"forall V2, V3 (in(V2, V3) <-> (V2 in 1..n and V3 in 1..r and in(V2, V3)))\n"
-			"forall U2 not (U2 in 1..n and not covered(U2))\n"
-			"forall U3, U4, U5 not (in(U3, U4) and in(U5, U4) and exists X1 (X1 in (U3 + U5) and in(X1, U4)))\n");
+			"forall V2, V3 (in(V2, V3) -> (V2 in 1..n and V3 in 1..r))\n"
+			"forall U2 (U2 in 1..n -> covered(U2))\n"
+			"forall U3, U4, U5 (not in(U3, U4) or not in(U5, U4) or not exists X1 (X1 in (U3 + U5) and in(X1, U4)))\n");
 	}
 
 	SECTION("binary operations with multiple variables")
@@ -176,4 +176,20 @@ TEST_CASE("[completion] Rules are completed", "[completion]")
 		CHECK(output.str() ==
 			"forall V1, V2, V3 (p(V1, V2, V3) <-> #true)\n");
 	}
+
+	SECTION("negated comparisons")
+	{
+		input << ":- color(V, C1), color(V, C2), C1 != C2.";
+		anthem::translate("input", input, context);
+
+		CHECK(output.str() == "forall V1, V2 not color(V1, V2)\nforall U1, U2, U3 (not color(U1, U2) or not color(U1, U3) or U2 = U3)\n");
+	}
+
+	SECTION("absolute value operation")
+	{
+		input << "adj(X, Y) :- X = 1..n, Y = 1..n, |X - Y| = 1.";
+		anthem::translate("input", input, context);
+
+		CHECK(output.str() == "forall V1, V2 (adj(V1, V2) <-> (V1 in 1..n and V2 in 1..n and |V1 - V2| = 1))\n");
+	}
 }

tests/TestHiddenPredicateElimination.cpp

@@ -103,9 +103,10 @@ TEST_CASE("[hidden predicate elimination] Hidden predicates are correctly elimin
 			"#show a/1.";
 		anthem::translate("input", input, context);
 
+		// TODO: simplify further
 		CHECK(output.str() ==
 			"forall V1 (a(V1) <-> not d(V1))\n"
-			"forall V2 (d(V2) <-> not not d(V2))\n"
+			"forall V2 (d(V2) <-> d(V2))\n"
 			"forall V3 (e(V3) <-> e(V3))\n");
 	}
 
@@ -164,12 +165,11 @@ TEST_CASE("[hidden predicate elimination] Hidden predicates are correctly elimin
 			"#show t/0.";
 		anthem::translate("input", input, context);
 
-		// TODO: simplify further
 		CHECK(output.str() ==
-			"(s <-> (not #false and s))\n"
-			"(t <-> (not #false and t))\n"
-			"not (s and not t)\n"
-			"not (not #false and not #false and #false)\n");
+			"(s -> not #false)\n"
+			"(t -> not #false)\n"
+			"(s -> t)\n"
+			"(#false or #false or not #false)\n");
 	}
 
 	SECTION("predicate with more than one argument is hidden correctly")

tests/TestPlaceholders.cpp

@@ -55,8 +55,8 @@ TEST_CASE("[placeholders] Programs with placeholders are correctly completed", "
 		anthem::translate("input", input, context);
 
 		CHECK(output.str() ==
-			"forall V1, V2 (color(V1, V2) <-> (vertex(V1) and color(V2) and color(V1, V2)))\n"
-			"forall U1 not (vertex(U1) and not exists U2 color(U1, U2))\n"
-			"forall U3, U4, U5 not (color(U3, U4) and color(U5, U4) and edge(U3, U5))\n");
+			"forall V1, V2 (color(V1, V2) -> (vertex(V1) and color(V2)))\n"
+			"forall U1 (vertex(U1) -> exists U2 color(U1, U2))\n"
+			"forall U3, U4, U5 (not color(U3, U4) or not color(U5, U4) or not edge(U3, U5))\n");
 	}
 }

tests/TestTranslation.cpp

@@ -296,4 +296,12 @@ TEST_CASE("[translation] Rules are translated correctly", "[translation]")
 
 		CHECK(output.str() == "((V1 in U1 and V2 in U2 and exists X1, X2 (X1 in U3 and X2 in U4 and q(X1, X2))) -> p(V1, V2))\n");
 	}
+
+	SECTION("exponentiation operator")
+	{
+		input << "p(N, N ** N) :- N = 1..n.";
+		anthem::translate("input", input, context);
+
+		CHECK(output.str() == "((V1 in U1 and V2 in (U1 ** U1) and exists X1, X2 (X1 in U1 and X2 in 1..n and X1 = X2)) -> p(V1, V2))\n");
+	}
 }