diff --git a/include/plasp/pddl/Action.h b/include/plasp/pddl/Action.h
index ff96c56..56a0fee 100644
--- a/include/plasp/pddl/Action.h
+++ b/include/plasp/pddl/Action.h
@@ -30,7 +30,7 @@ class Action
 		const Expression *precondition() const;
 		const Expression *effect() const;
 
-		void normalizeParameterNames();
+		void normalize();
 
 	private:
 		Action() = default;
diff --git a/include/plasp/pddl/Context.h b/include/plasp/pddl/Context.h
index 931c60f..8844c91 100644
--- a/include/plasp/pddl/Context.h
+++ b/include/plasp/pddl/Context.h
@@ -58,6 +58,11 @@ class Context
 			return *this;
 		}
 
+		constexpr static const char *auxiliaryPrefix()
+		{
+			return "__plasp_";
+		}
+
 		Parser parser;
 		utils::Logger logger;
 };
diff --git a/include/plasp/pddl/Domain.h b/include/plasp/pddl/Domain.h
index b3fd831..81ea1ce 100644
--- a/include/plasp/pddl/Domain.h
+++ b/include/plasp/pddl/Domain.h
@@ -67,8 +67,6 @@ class Domain
 
 		void parseActionSection();
 
-		void normalizeParameterNames();
-
 		Context &m_context;
 
 		std::string m_name;
diff --git a/include/plasp/pddl/Expression.h b/include/plasp/pddl/Expression.h
index 055a4c0..31b726c 100644
--- a/include/plasp/pddl/Expression.h
+++ b/include/plasp/pddl/Expression.h
@@ -96,6 +96,13 @@ class Expression
 		virtual ~Expression() = default;
 
 		virtual Type expressionType() const = 0;
+
+		// Normalizes the expression dependent on its type, recursing through all child expressions
+		//
+		// Result:
+		//     * a new expression pointer to replace this one if required; this object is then empty
+		//     * nullptr otherwise; the object may or may not have changed
+		virtual ExpressionPointer normalize() = 0;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/plasp/pddl/expressions/At.h b/include/plasp/pddl/expressions/At.h
index 166d9ad..7bc8ef4 100644
--- a/include/plasp/pddl/expressions/At.h
+++ b/include/plasp/pddl/expressions/At.h
@@ -34,12 +34,13 @@ class At: public ExpressionCRTP<At>
 
 		size_t timePoint() const;
 
-		const Expression *argument() const;
-
-	private:
 		void setArgument(const Expression *argument);
 		void setArgument(ExpressionPointer &&argument);
+		const Expression *argument() const;
 
+		ExpressionPointer normalize() override;
+
+	protected:
 		size_t m_timePoint;
 
 		const Expression *m_argument;
diff --git a/include/plasp/pddl/expressions/Binary.h b/include/plasp/pddl/expressions/Binary.h
index 1561ceb..7ac7e59 100644
--- a/include/plasp/pddl/expressions/Binary.h
+++ b/include/plasp/pddl/expressions/Binary.h
@@ -28,14 +28,15 @@ class Binary: public ExpressionCRTP<Derived>
 			ExpressionContext &expressionContext, ExpressionParser parseExpression);
 
 	public:
-		const std::array<const Expression *, 2> &arguments() const;
-
-	private:
 		template<size_t i>
 		void setArgument(const Expression *argument);
 		template<size_t i>
 		void setArgument(ExpressionPointer &&argument);
+		const std::array<const Expression *, 2> &arguments() const;
 
+		ExpressionPointer normalize() override;
+
+	protected:
 		std::array<const Expression *, 2> m_arguments;
 		std::array<ExpressionPointer, 2> m_argumentStorage;
 };
@@ -104,6 +105,28 @@ const std::array<const Expression *, 2> &Binary<Derived>::arguments() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+template<class Derived>
+inline ExpressionPointer Binary<Derived>::normalize()
+{
+	for (size_t i = 0; i < m_argumentStorage.size(); i++)
+	{
+		BOOST_ASSERT(m_argumentStorage[i]);
+
+		auto normalizedArgument = m_argumentStorage[i]->normalize();
+
+		// Replace argument if changed by normalization
+		if (!normalizedArgument)
+			continue;
+
+		m_argumentStorage[i] = std::move(normalizedArgument);
+		m_arguments[i] = m_argumentStorage[i].get();
+	}
+
+	return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }
diff --git a/include/plasp/pddl/expressions/Constant.h b/include/plasp/pddl/expressions/Constant.h
index 0aed166..4f69f2e 100644
--- a/include/plasp/pddl/expressions/Constant.h
+++ b/include/plasp/pddl/expressions/Constant.h
@@ -35,6 +35,8 @@ class Constant: public ExpressionCRTP<Constant>
 		const std::string &name() const;
 		const PrimitiveType *type() const;
 
+		ExpressionPointer normalize() override;
+
 	private:
 		static ConstantPointer parseDeclaration(Context &context);
 		static void parseTypedDeclaration(Context &context, Domain &domain, Constants &constants);
diff --git a/include/plasp/pddl/expressions/Either.h b/include/plasp/pddl/expressions/Either.h
index 8e49e76..f502322 100644
--- a/include/plasp/pddl/expressions/Either.h
+++ b/include/plasp/pddl/expressions/Either.h
@@ -22,6 +22,9 @@ class Either: public NAry<Either>
 		static const Expression::Type ExpressionType = Expression::Type::Either;
 
 		static const std::string Identifier;
+
+	public:
+		ExpressionPointer normalize() override;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/plasp/pddl/expressions/Imply.h b/include/plasp/pddl/expressions/Imply.h
index 56234a2..3626772 100644
--- a/include/plasp/pddl/expressions/Imply.h
+++ b/include/plasp/pddl/expressions/Imply.h
@@ -22,6 +22,9 @@ class Imply: public Binary<Imply>
 		static const Expression::Type ExpressionType = Expression::Type::Imply;
 
 		static const std::string Identifier;
+
+	public:
+		ExpressionPointer normalize() override;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/plasp/pddl/expressions/NAry.h b/include/plasp/pddl/expressions/NAry.h
index 7f6789b..c136f38 100644
--- a/include/plasp/pddl/expressions/NAry.h
+++ b/include/plasp/pddl/expressions/NAry.h
@@ -28,12 +28,13 @@ class NAry: public ExpressionCRTP<Derived>
 			ExpressionContext &expressionContext, ExpressionParser parseExpression);
 
 	public:
-		const std::vector<const Expression *> &arguments() const;
-
-	private:
 		void addArgument(const Expression *argument);
 		void addArgument(ExpressionPointer &&argument);
+		const std::vector<const Expression *> &arguments() const;
 
+		ExpressionPointer normalize() override;
+
+	protected:
 		std::vector<const Expression *> m_arguments;
 		Expressions m_argumentStorage;
 };
@@ -110,6 +111,28 @@ const std::vector<const Expression *> &NAry<Derived>::arguments() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+template<class Derived>
+inline ExpressionPointer NAry<Derived>::normalize()
+{
+	for (size_t i = 0; i < m_argumentStorage.size(); i++)
+	{
+		BOOST_ASSERT(m_argumentStorage[i]);
+
+		auto normalizedArgument = m_argumentStorage[i]->normalize();
+
+		// Replace argument if changed by normalization
+		if (!normalizedArgument)
+			continue;
+
+		m_argumentStorage[i] = std::move(normalizedArgument);
+		m_arguments[i] = m_argumentStorage[i].get();
+	}
+
+	return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }
diff --git a/include/plasp/pddl/expressions/Not.h b/include/plasp/pddl/expressions/Not.h
index 641ec7e..a4af388 100644
--- a/include/plasp/pddl/expressions/Not.h
+++ b/include/plasp/pddl/expressions/Not.h
@@ -29,12 +29,13 @@ class Not: public ExpressionCRTP<Not>
 	public:
 		Not();
 
-		const Expression *argument() const;
-
-	private:
 		void setArgument(const Expression *argument);
 		void setArgument(ExpressionPointer &&argument);
+		const Expression *argument() const;
 
+		ExpressionPointer normalize() override;
+
+	protected:
 		const Expression *m_argument;
 		ExpressionPointer m_argumentStorage;
 };
diff --git a/include/plasp/pddl/expressions/Predicate.h b/include/plasp/pddl/expressions/Predicate.h
index fc4f886..c9f2af0 100644
--- a/include/plasp/pddl/expressions/Predicate.h
+++ b/include/plasp/pddl/expressions/Predicate.h
@@ -30,6 +30,8 @@ class Predicate: public ExpressionCRTP<Predicate>
 
 		bool isDeclared() const;
 
+		ExpressionPointer normalize() override;
+
 	private:
 		Predicate();
 
diff --git a/include/plasp/pddl/expressions/PredicateDeclaration.h b/include/plasp/pddl/expressions/PredicateDeclaration.h
index b14622a..17c3e43 100644
--- a/include/plasp/pddl/expressions/PredicateDeclaration.h
+++ b/include/plasp/pddl/expressions/PredicateDeclaration.h
@@ -29,7 +29,7 @@ class PredicateDeclaration: public ExpressionCRTP<PredicateDeclaration>
 
 		bool isDeclared() const;
 
-		void normalizeParameterNames();
+		ExpressionPointer normalize() override;
 
 	private:
 		PredicateDeclaration();
diff --git a/include/plasp/pddl/expressions/PrimitiveType.h b/include/plasp/pddl/expressions/PrimitiveType.h
index 12b3819..9cd26e9 100644
--- a/include/plasp/pddl/expressions/PrimitiveType.h
+++ b/include/plasp/pddl/expressions/PrimitiveType.h
@@ -35,6 +35,8 @@ class PrimitiveType: public ExpressionCRTP<PrimitiveType>
 		const std::string &name() const;
 		const std::vector<const PrimitiveType *> &parentTypes() const;
 
+		ExpressionPointer normalize() override;
+
 	private:
 		void setDirty(bool isDirty = true);
 		bool isDirty() const;
diff --git a/include/plasp/pddl/expressions/Unsupported.h b/include/plasp/pddl/expressions/Unsupported.h
index 6be1be4..b5039cc 100644
--- a/include/plasp/pddl/expressions/Unsupported.h
+++ b/include/plasp/pddl/expressions/Unsupported.h
@@ -27,6 +27,8 @@ class Unsupported: public ExpressionCRTP<Unsupported>
 	public:
 		const std::string &type() const;
 
+		ExpressionPointer normalize() override;
+
 	private:
 		std::string m_type;
 };
diff --git a/include/plasp/pddl/expressions/Variable.h b/include/plasp/pddl/expressions/Variable.h
index a5869d2..ed6d95b 100644
--- a/include/plasp/pddl/expressions/Variable.h
+++ b/include/plasp/pddl/expressions/Variable.h
@@ -38,6 +38,8 @@ class Variable: public ExpressionCRTP<Variable>
 
 		void setType(const Expression *type);
 
+		ExpressionPointer normalize() override;
+
 	private:
 		static void parseDeclaration(Context &context, Variables &parameters);
 
diff --git a/src/plasp/pddl/Action.cpp b/src/plasp/pddl/Action.cpp
index 506745d..e83d52c 100644
--- a/src/plasp/pddl/Action.cpp
+++ b/src/plasp/pddl/Action.cpp
@@ -87,8 +87,13 @@ const Expression *Action::effect() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void Action::normalizeParameterNames()
+void Action::normalize()
 {
+	// Normalize preconditions and effects
+	m_precondition->normalize();
+	m_effect->normalize();
+
+	// Normalize parameter names
 	for (size_t i = 0; i < m_parameters.size(); i++)
 		m_parameters[i]->setName("X" + std::to_string(i));
 }
diff --git a/src/plasp/pddl/Domain.cpp b/src/plasp/pddl/Domain.cpp
index 889886b..54d097d 100644
--- a/src/plasp/pddl/Domain.cpp
+++ b/src/plasp/pddl/Domain.cpp
@@ -416,24 +416,17 @@ void Domain::checkConsistency()
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 void Domain::normalize()
-{
-	normalizeParameterNames();
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
-void Domain::normalizeParameterNames()
 {
 	std::for_each(m_predicates.begin(), m_predicates.end(),
 		[](auto &predicate)
 		{
-			predicate->normalizeParameterNames();
+			predicate->normalize();
 		});
 
 	std::for_each(m_actions.begin(), m_actions.end(),
 		[](auto &action)
 		{
-			action->normalizeParameterNames();
+			action->normalize();
 		});
 }
 
diff --git a/src/plasp/pddl/expressions/At.cpp b/src/plasp/pddl/expressions/At.cpp
index 1a40799..327af08 100644
--- a/src/plasp/pddl/expressions/At.cpp
+++ b/src/plasp/pddl/expressions/At.cpp
@@ -43,6 +43,21 @@ const Expression *At::argument() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer At::normalize()
+{
+	BOOST_ASSERT(m_argumentStorage);
+
+	auto normalizedArgument = m_argumentStorage->normalize();
+
+	// Replace argument if changed by normalization
+	if (normalizedArgument)
+		setArgument(std::move(normalizedArgument));
+
+	return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }
diff --git a/src/plasp/pddl/expressions/Constant.cpp b/src/plasp/pddl/expressions/Constant.cpp
index d092907..e245433 100644
--- a/src/plasp/pddl/expressions/Constant.cpp
+++ b/src/plasp/pddl/expressions/Constant.cpp
@@ -239,6 +239,13 @@ const PrimitiveType *Constant::type() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer Constant::normalize()
+{
+	return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }
diff --git a/src/plasp/pddl/expressions/Either.cpp b/src/plasp/pddl/expressions/Either.cpp
index 8f795ec..5c6bbb9 100644
--- a/src/plasp/pddl/expressions/Either.cpp
+++ b/src/plasp/pddl/expressions/Either.cpp
@@ -17,6 +17,13 @@ const std::string Either::Identifier = "either";
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer Either::normalize()
+{
+	return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }
diff --git a/src/plasp/pddl/expressions/Imply.cpp b/src/plasp/pddl/expressions/Imply.cpp
index c9d86ca..33c7235 100644
--- a/src/plasp/pddl/expressions/Imply.cpp
+++ b/src/plasp/pddl/expressions/Imply.cpp
@@ -1,5 +1,8 @@
 #include <plasp/pddl/expressions/Imply.h>
 
+#include <plasp/pddl/expressions/Not.h>
+#include <plasp/pddl/expressions/Or.h>
+
 namespace plasp
 {
 namespace pddl
@@ -18,6 +21,23 @@ const std::string Imply::Identifier = "imply";
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer Imply::normalize()
+{
+	BOOST_ASSERT(m_argumentStorage[0]);
+	BOOST_ASSERT(m_argumentStorage[1]);
+
+	auto notArgument0 = std::make_unique<Not>();
+	notArgument0->setArgument(std::move(m_argumentStorage[0]));
+
+	auto orExpression = std::make_unique<Or>();
+	orExpression->addArgument(std::move(notArgument0));
+	orExpression->addArgument(std::move(m_argumentStorage[1]));
+
+	return std::move(orExpression);
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }
diff --git a/src/plasp/pddl/expressions/Not.cpp b/src/plasp/pddl/expressions/Not.cpp
index d547eda..fec4f57 100644
--- a/src/plasp/pddl/expressions/Not.cpp
+++ b/src/plasp/pddl/expressions/Not.cpp
@@ -43,6 +43,21 @@ const Expression *Not::argument() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer Not::normalize()
+{
+	BOOST_ASSERT(m_argumentStorage);
+
+	auto normalizedArgument = m_argumentStorage->normalize();
+
+	// Replace argument if changed by normalization
+	if (normalizedArgument)
+		setArgument(std::move(normalizedArgument));
+
+	return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }
diff --git a/src/plasp/pddl/expressions/Predicate.cpp b/src/plasp/pddl/expressions/Predicate.cpp
index ed1dbe2..59bf051 100644
--- a/src/plasp/pddl/expressions/Predicate.cpp
+++ b/src/plasp/pddl/expressions/Predicate.cpp
@@ -170,6 +170,13 @@ const std::vector<const Expression *> &Predicate::arguments() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer Predicate::normalize()
+{
+	return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }
diff --git a/src/plasp/pddl/expressions/PredicateDeclaration.cpp b/src/plasp/pddl/expressions/PredicateDeclaration.cpp
index 5e15449..a3d8f84 100644
--- a/src/plasp/pddl/expressions/PredicateDeclaration.cpp
+++ b/src/plasp/pddl/expressions/PredicateDeclaration.cpp
@@ -79,10 +79,12 @@ const Variables &PredicateDeclaration::arguments() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-void PredicateDeclaration::normalizeParameterNames()
+ExpressionPointer PredicateDeclaration::normalize()
 {
 	for (size_t i = 0; i < m_parameters.size(); i++)
 		m_parameters[i]->setName("X" + std::to_string(i));
+
+	return nullptr;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/plasp/pddl/expressions/PrimitiveType.cpp b/src/plasp/pddl/expressions/PrimitiveType.cpp
index 0486978..9f23558 100644
--- a/src/plasp/pddl/expressions/PrimitiveType.cpp
+++ b/src/plasp/pddl/expressions/PrimitiveType.cpp
@@ -169,6 +169,13 @@ const std::vector<const PrimitiveType *> &PrimitiveType::parentTypes() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer PrimitiveType::normalize()
+{
+	return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }
diff --git a/src/plasp/pddl/expressions/Unsupported.cpp b/src/plasp/pddl/expressions/Unsupported.cpp
index ef00a0d..fdff330 100644
--- a/src/plasp/pddl/expressions/Unsupported.cpp
+++ b/src/plasp/pddl/expressions/Unsupported.cpp
@@ -41,6 +41,13 @@ const std::string &Unsupported::type() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer Unsupported::normalize()
+{
+	return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }
diff --git a/src/plasp/pddl/expressions/Variable.cpp b/src/plasp/pddl/expressions/Variable.cpp
index 783eb6e..9e137e8 100644
--- a/src/plasp/pddl/expressions/Variable.cpp
+++ b/src/plasp/pddl/expressions/Variable.cpp
@@ -206,6 +206,13 @@ void Variable::setType(const Expression *type)
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer Variable::normalize()
+{
+	return nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }