diff --git a/include/plasp/pddl/Expression.h b/include/plasp/pddl/Expression.h
index 7d17863..06441c2 100644
--- a/include/plasp/pddl/Expression.h
+++ b/include/plasp/pddl/Expression.h
@@ -107,12 +107,8 @@ class Expression
 
 		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;
+		virtual ExpressionPointer normalized();
+		ExpressionPointer negated();
 
 	private:
 		friend void intrusive_ptr_add_ref(Expression *expression);
diff --git a/include/plasp/pddl/expressions/At.h b/include/plasp/pddl/expressions/At.h
index 2933597..41b9524 100644
--- a/include/plasp/pddl/expressions/At.h
+++ b/include/plasp/pddl/expressions/At.h
@@ -37,7 +37,7 @@ class At: public ExpressionCRTP<At>
 		void setArgument(ExpressionPointer argument);
 		ExpressionPointer argument() const;
 
-		ExpressionPointer normalize() override;
+		ExpressionPointer normalized() override;
 
 	protected:
 		size_t m_timePoint;
diff --git a/include/plasp/pddl/expressions/Binary.h b/include/plasp/pddl/expressions/Binary.h
index a91eb93..a369737 100644
--- a/include/plasp/pddl/expressions/Binary.h
+++ b/include/plasp/pddl/expressions/Binary.h
@@ -31,7 +31,7 @@ class Binary: public ExpressionCRTP<Derived>
 		void setArgument(size_t i, ExpressionPointer argument);
 		const std::array<ExpressionPointer, 2> &arguments() const;
 
-		ExpressionPointer normalize() override;
+		ExpressionPointer normalized() override;
 
 	protected:
 		std::array<ExpressionPointer, 2> m_arguments;
@@ -72,7 +72,7 @@ boost::intrusive_ptr<Derived> Binary<Derived>::parse(Context &context,
 template<class Derived>
 void Binary<Derived>::setArgument(size_t i, ExpressionPointer expression)
 {
-	BOOST_ASSERT_MSG(i <= 2, "Index out of range");
+	BOOST_ASSERT_MSG(i <= m_arguments.size(), "Index out of range");
 
 	m_arguments[i] = expression;
 }
@@ -88,22 +88,16 @@ const std::array<ExpressionPointer, 2> &Binary<Derived>::arguments() const
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 template<class Derived>
-inline ExpressionPointer Binary<Derived>::normalize()
+inline ExpressionPointer Binary<Derived>::normalized()
 {
 	for (size_t i = 0; i < m_arguments.size(); i++)
 	{
 		BOOST_ASSERT(m_arguments[i]);
 
-		auto normalizedArgument = m_arguments[i]->normalize();
-
-		// Replace argument if changed by normalization
-		if (!normalizedArgument)
-			continue;
-
-		m_arguments[i] = std::move(normalizedArgument);
+		m_arguments[i] = m_arguments[i]->normalized();
 	}
 
-	return nullptr;
+	return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/plasp/pddl/expressions/Constant.h b/include/plasp/pddl/expressions/Constant.h
index b8d4a49..26da80f 100644
--- a/include/plasp/pddl/expressions/Constant.h
+++ b/include/plasp/pddl/expressions/Constant.h
@@ -35,8 +35,6 @@ class Constant: public ExpressionCRTP<Constant>
 		const std::string &name() const;
 		PrimitiveTypePointer 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/Dummy.h b/include/plasp/pddl/expressions/Dummy.h
index 2985c88..e2eed5a 100644
--- a/include/plasp/pddl/expressions/Dummy.h
+++ b/include/plasp/pddl/expressions/Dummy.h
@@ -23,7 +23,7 @@ class Dummy: public ExpressionCRTP<Dummy>
 
 		bool isNormalized() const;
 
-		ExpressionPointer normalize() override;
+		ExpressionPointer normalized() override;
 
 	private:
 		bool m_isNormalized = false;
diff --git a/include/plasp/pddl/expressions/Either.h b/include/plasp/pddl/expressions/Either.h
index f502322..8e49e76 100644
--- a/include/plasp/pddl/expressions/Either.h
+++ b/include/plasp/pddl/expressions/Either.h
@@ -22,9 +22,6 @@ 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 3626772..8b1a6bf 100644
--- a/include/plasp/pddl/expressions/Imply.h
+++ b/include/plasp/pddl/expressions/Imply.h
@@ -24,7 +24,7 @@ class Imply: public Binary<Imply>
 		static const std::string Identifier;
 
 	public:
-		ExpressionPointer normalize() override;
+		ExpressionPointer normalized() override;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/plasp/pddl/expressions/NAry.h b/include/plasp/pddl/expressions/NAry.h
index c03cf06..3c5a0ae 100644
--- a/include/plasp/pddl/expressions/NAry.h
+++ b/include/plasp/pddl/expressions/NAry.h
@@ -28,10 +28,11 @@ class NAry: public ExpressionCRTP<Derived>
 			ExpressionContext &expressionContext, ExpressionParser parseExpression);
 
 	public:
+		void setArgument(size_t i, ExpressionPointer argument);
 		void addArgument(ExpressionPointer argument);
 		const Expressions &arguments() const;
 
-		ExpressionPointer normalize() override;
+		ExpressionPointer normalized() override;
 
 	protected:
 		Expressions m_arguments;
@@ -78,6 +79,16 @@ boost::intrusive_ptr<Derived> NAry<Derived>::parse(Context &context,
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+template<class Derived>
+void NAry<Derived>::setArgument(size_t i, ExpressionPointer expression)
+{
+	BOOST_ASSERT_MSG(i <= m_arguments.size(), "Index out of range");
+
+	m_arguments[i] = expression;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 template<class Derived>
 void NAry<Derived>::addArgument(ExpressionPointer argument)
 {
@@ -98,22 +109,16 @@ const Expressions &NAry<Derived>::arguments() const
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 template<class Derived>
-inline ExpressionPointer NAry<Derived>::normalize()
+inline ExpressionPointer NAry<Derived>::normalized()
 {
 	for (size_t i = 0; i < m_arguments.size(); i++)
 	{
 		BOOST_ASSERT(m_arguments[i]);
 
-		auto normalizedArgument = m_arguments[i]->normalize();
-
-		// Replace argument if changed by normalization
-		if (!normalizedArgument)
-			continue;
-
-		m_arguments[i] = std::move(normalizedArgument);
+		m_arguments[i] = m_arguments[i]->normalized();
 	}
 
-	return nullptr;
+	return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/include/plasp/pddl/expressions/Not.h b/include/plasp/pddl/expressions/Not.h
index ec20037..1e3abd5 100644
--- a/include/plasp/pddl/expressions/Not.h
+++ b/include/plasp/pddl/expressions/Not.h
@@ -32,7 +32,7 @@ class Not: public ExpressionCRTP<Not>
 		void setArgument(ExpressionPointer argument);
 		ExpressionPointer argument() const;
 
-		ExpressionPointer normalize() override;
+		ExpressionPointer normalized() override;
 
 	protected:
 		ExpressionPointer m_argument;
diff --git a/include/plasp/pddl/expressions/Predicate.h b/include/plasp/pddl/expressions/Predicate.h
index 09887f3..fca134f 100644
--- a/include/plasp/pddl/expressions/Predicate.h
+++ b/include/plasp/pddl/expressions/Predicate.h
@@ -30,8 +30,6 @@ 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 17c3e43..b14622a 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;
 
-		ExpressionPointer normalize() override;
+		void normalizeParameterNames();
 
 	private:
 		PredicateDeclaration();
diff --git a/include/plasp/pddl/expressions/PrimitiveType.h b/include/plasp/pddl/expressions/PrimitiveType.h
index 45c7525..11e6f58 100644
--- a/include/plasp/pddl/expressions/PrimitiveType.h
+++ b/include/plasp/pddl/expressions/PrimitiveType.h
@@ -35,8 +35,6 @@ class PrimitiveType: public ExpressionCRTP<PrimitiveType>
 		const std::string &name() const;
 		const PrimitiveTypes &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 b5039cc..6be1be4 100644
--- a/include/plasp/pddl/expressions/Unsupported.h
+++ b/include/plasp/pddl/expressions/Unsupported.h
@@ -27,8 +27,6 @@ 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 e61e6e1..1d8e333 100644
--- a/include/plasp/pddl/expressions/Variable.h
+++ b/include/plasp/pddl/expressions/Variable.h
@@ -37,8 +37,6 @@ class Variable: public ExpressionCRTP<Variable>
 		void setDirty(bool isDirty = true);
 		bool isDirty() const;
 
-		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 e83d52c..e4ad3fc 100644
--- a/src/plasp/pddl/Action.cpp
+++ b/src/plasp/pddl/Action.cpp
@@ -90,8 +90,8 @@ const Expression *Action::effect() const
 void Action::normalize()
 {
 	// Normalize preconditions and effects
-	m_precondition->normalize();
-	m_effect->normalize();
+	m_precondition = m_precondition->normalized();
+	m_effect = m_effect->normalized();
 
 	// Normalize parameter names
 	for (size_t i = 0; i < m_parameters.size(); i++)
diff --git a/src/plasp/pddl/Domain.cpp b/src/plasp/pddl/Domain.cpp
index 54d097d..ef10936 100644
--- a/src/plasp/pddl/Domain.cpp
+++ b/src/plasp/pddl/Domain.cpp
@@ -420,7 +420,7 @@ void Domain::normalize()
 	std::for_each(m_predicates.begin(), m_predicates.end(),
 		[](auto &predicate)
 		{
-			predicate->normalize();
+			predicate->normalizeParameterNames();
 		});
 
 	std::for_each(m_actions.begin(), m_actions.end(),
diff --git a/src/plasp/pddl/Expression.cpp b/src/plasp/pddl/Expression.cpp
index 0e3be3b..4f7df1c 100644
--- a/src/plasp/pddl/Expression.cpp
+++ b/src/plasp/pddl/Expression.cpp
@@ -24,6 +24,30 @@ namespace pddl
 //
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer Expression::normalized()
+{
+	return this;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ExpressionPointer Expression::negated()
+{
+	if (expressionType() == Type::Not)
+	{
+		auto &notExpression = dynamic_cast<expressions::Not &>(*this);
+
+		return notExpression.argument();
+	}
+
+	auto notExpression = expressions::NotPointer(new expressions::Not);
+	notExpression->setArgument(this);
+
+	return notExpression;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 ExpressionPointer parseEffectBodyExpression(Context &context, ExpressionContext &expressionContext);
 ExpressionPointer parsePredicate(Context &context, ExpressionContext &expressionContext);
 
diff --git a/src/plasp/pddl/Problem.cpp b/src/plasp/pddl/Problem.cpp
index 9f38d69..312cef3 100644
--- a/src/plasp/pddl/Problem.cpp
+++ b/src/plasp/pddl/Problem.cpp
@@ -401,7 +401,7 @@ void Problem::normalize()
 
 	// TODO: normalize objects and initial state
 
-	m_goal->normalize();
+	m_goal = m_goal->normalized();
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/plasp/pddl/expressions/At.cpp b/src/plasp/pddl/expressions/At.cpp
index 1005d79..ec8f248 100644
--- a/src/plasp/pddl/expressions/At.cpp
+++ b/src/plasp/pddl/expressions/At.cpp
@@ -34,17 +34,13 @@ ExpressionPointer At::argument() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ExpressionPointer At::normalize()
+ExpressionPointer At::normalized()
 {
 	BOOST_ASSERT(m_argument);
 
-	auto normalizedArgument = m_argument->normalize();
+	m_argument = m_argument->normalized();
 
-	// Replace argument if changed by normalization
-	if (normalizedArgument)
-		setArgument(std::move(normalizedArgument));
-
-	return nullptr;
+	return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/plasp/pddl/expressions/Constant.cpp b/src/plasp/pddl/expressions/Constant.cpp
index 7a9ca85..7f13f0c 100644
--- a/src/plasp/pddl/expressions/Constant.cpp
+++ b/src/plasp/pddl/expressions/Constant.cpp
@@ -239,13 +239,6 @@ PrimitiveTypePointer Constant::type() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ExpressionPointer Constant::normalize()
-{
-	return nullptr;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
 }
 }
 }
diff --git a/src/plasp/pddl/expressions/Dummy.cpp b/src/plasp/pddl/expressions/Dummy.cpp
index 662b396..d1fac3d 100644
--- a/src/plasp/pddl/expressions/Dummy.cpp
+++ b/src/plasp/pddl/expressions/Dummy.cpp
@@ -22,11 +22,11 @@ bool Dummy::isNormalized() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ExpressionPointer Dummy::normalize()
+ExpressionPointer Dummy::normalized()
 {
 	m_isNormalized = true;
 
-	return nullptr;
+	return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/plasp/pddl/expressions/Either.cpp b/src/plasp/pddl/expressions/Either.cpp
index 5c6bbb9..8f795ec 100644
--- a/src/plasp/pddl/expressions/Either.cpp
+++ b/src/plasp/pddl/expressions/Either.cpp
@@ -17,13 +17,6 @@ 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 e1ec21e..d0e9adc 100644
--- a/src/plasp/pddl/expressions/Imply.cpp
+++ b/src/plasp/pddl/expressions/Imply.cpp
@@ -21,19 +21,22 @@ const std::string Imply::Identifier = "imply";
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ExpressionPointer Imply::normalize()
+ExpressionPointer Imply::normalized()
 {
 	BOOST_ASSERT(m_arguments[0]);
 	BOOST_ASSERT(m_arguments[1]);
 
+	m_arguments[0] = m_arguments[0]->normalized();
+	m_arguments[1] = m_arguments[1]->normalized();
+
 	auto notArgument0 = NotPointer(new Not);
-	notArgument0->setArgument(std::move(m_arguments[0]));
+	notArgument0->setArgument(m_arguments[0]);
 
 	auto orExpression = OrPointer(new Or);
-	orExpression->addArgument(std::move(notArgument0));
-	orExpression->addArgument(std::move(m_arguments[1]));
+	orExpression->addArgument(notArgument0);
+	orExpression->addArgument(m_arguments[1]);
 
-	auto normalizedOrExpression = orExpression->normalize();
+	auto normalizedOrExpression = orExpression->normalized();
 
 	if (normalizedOrExpression)
 		return normalizedOrExpression;
diff --git a/src/plasp/pddl/expressions/Not.cpp b/src/plasp/pddl/expressions/Not.cpp
index 5e994a9..5b35557 100644
--- a/src/plasp/pddl/expressions/Not.cpp
+++ b/src/plasp/pddl/expressions/Not.cpp
@@ -34,7 +34,7 @@ ExpressionPointer Not::argument() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ExpressionPointer Not::normalize()
+ExpressionPointer Not::normalized()
 {
 	BOOST_ASSERT(m_argument);
 
@@ -43,22 +43,12 @@ ExpressionPointer Not::normalize()
 	{
 		auto &argument = dynamic_cast<Not &>(*m_argument);
 
-		auto normalized = std::move(argument.m_argument);
-		auto normalizedInner = normalized->normalize();
-
-		if (normalizedInner)
-			return normalizedInner;
-
-		return normalized;
+		return argument.m_argument->normalized();
 	}
 
-	auto normalizedArgument = m_argument->normalize();
+	m_argument = m_argument->normalized();
 
-	// Replace argument if changed by normalization
-	if (normalizedArgument)
-		setArgument(std::move(normalizedArgument));
-
-	return nullptr;
+	return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/plasp/pddl/expressions/Predicate.cpp b/src/plasp/pddl/expressions/Predicate.cpp
index ccfc0f8..dbf6b8e 100644
--- a/src/plasp/pddl/expressions/Predicate.cpp
+++ b/src/plasp/pddl/expressions/Predicate.cpp
@@ -170,13 +170,6 @@ const Expressions &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 6823fe4..377f9cb 100644
--- a/src/plasp/pddl/expressions/PredicateDeclaration.cpp
+++ b/src/plasp/pddl/expressions/PredicateDeclaration.cpp
@@ -79,12 +79,10 @@ const Variables &PredicateDeclaration::arguments() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ExpressionPointer PredicateDeclaration::normalize()
+void PredicateDeclaration::normalizeParameterNames()
 {
 	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 394af70..198f76e 100644
--- a/src/plasp/pddl/expressions/PrimitiveType.cpp
+++ b/src/plasp/pddl/expressions/PrimitiveType.cpp
@@ -169,13 +169,6 @@ const PrimitiveTypes &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 3b38400..7202f50 100644
--- a/src/plasp/pddl/expressions/Unsupported.cpp
+++ b/src/plasp/pddl/expressions/Unsupported.cpp
@@ -41,13 +41,6 @@ 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 81255a7..0a3286d 100644
--- a/src/plasp/pddl/expressions/Variable.cpp
+++ b/src/plasp/pddl/expressions/Variable.cpp
@@ -203,13 +203,6 @@ bool Variable::isDirty() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-ExpressionPointer Variable::normalize()
-{
-	return nullptr;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-
 }
 }
 }
diff --git a/tests/TestPDDLNormalization.cpp b/tests/TestPDDLNormalization.cpp
index e0ff2f7..b174adb 100644
--- a/tests/TestPDDLNormalization.cpp
+++ b/tests/TestPDDLNormalization.cpp
@@ -20,7 +20,7 @@ TEST(PDDLNormalizationTests, Implication)
 	i->setArgument(0, d1);
 	i->setArgument(1, d2);
 
-	auto normalized = i->normalize();
+	auto normalized = i->normalized();
 
 	ASSERT_EQ(normalized->expressionType(), Expression::Type::Or);
 
@@ -48,7 +48,7 @@ TEST(PDDLNormalizationTests, DoubleNegation)
 	n2->setArgument(std::move(d));
 	n1->setArgument(std::move(n2));
 
-	auto normalized = n1->normalize();
+	auto normalized = n1->normalized();
 
 	ASSERT_EQ(normalized.get(), dp);
 	ASSERT_TRUE(dp->isNormalized());