Started implementing derived predicates for decomposing complex PDDL conditions.

src/plasp/pddl/Domain.cpp

@@ -232,6 +232,20 @@ const std::vector<std::unique_ptr<Action>> &Domain::actions() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+expressions::DerivedPredicates &Domain::derivedPredicates()
+{
+	return m_derivedPredicates;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+const expressions::DerivedPredicates &Domain::derivedPredicates() const
+{
+	return m_derivedPredicates;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 void Domain::parseRequirementSection()
 {
 	auto &parser = m_context.parser;

src/plasp/pddl/Expression.cpp

@@ -15,6 +15,7 @@
 #include <plasp/pddl/expressions/Unsupported.h>
 #include <plasp/pddl/expressions/When.h>
 #include <plasp/utils/ParserException.h>
+#include <plasp/utils/TranslatorException.h>
 
 namespace plasp
 {
@@ -112,6 +113,13 @@ ExpressionPointer Expression::disjunctionNormalized()
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer Expression::decomposed(expressions::DerivedPredicates &)
+{
+	throw utils::TranslatorException("Expression is not in first-order negation normal form and cannot be decomposed");
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 ExpressionPointer Expression::negated()
 {
 	if (expressionType() == Type::Not)

src/plasp/pddl/expressions/And.cpp

@@ -4,6 +4,7 @@
 #include <iostream>
 
 #include <plasp/pddl/expressions/Or.h>
+#include <plasp/utils/TranslatorException.h>
 
 namespace plasp
 {
@@ -67,6 +68,29 @@ ExpressionPointer And::disjunctionNormalized()
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer And::decomposed(DerivedPredicates &derivedPredicates)
+{
+	// Check that all children are simple or negated predicates
+	std::for_each(m_arguments.begin(), m_arguments.end(),
+		[&](auto &argument)
+		{
+			if (argument->expressionType() == Expression::Type::Not)
+			{
+				argument = argument->decomposed(derivedPredicates);
+				return;
+			}
+
+			if (argument->expressionType() != Expression::Type::Predicate)
+				return;
+
+			throw utils::TranslatorException("Expression is not in first-order negation normal form and cannot be decomposed");
+		});
+
+	return this;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

src/plasp/pddl/expressions/DerivedPredicate.cpp

@@ -0,0 +1,44 @@
+#include <plasp/pddl/expressions/DerivedPredicate.h>
+
+#include <plasp/pddl/Context.h>
+#include <plasp/pddl/ExpressionContext.h>
+
+namespace plasp
+{
+namespace pddl
+{
+namespace expressions
+{
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+// DerivedPredicate
+//
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void DerivedPredicate::setArgument(ExpressionPointer argument)
+{
+	m_argument = argument;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ExpressionPointer DerivedPredicate::argument() const
+{
+	return m_argument;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void DerivedPredicate::print(std::ostream &ostream) const
+{
+	ostream << "(:derived <no name> ";
+	m_argument->print(ostream);
+	ostream << ")";
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+}
+}
+}

src/plasp/pddl/expressions/Exists.cpp

@@ -20,6 +20,15 @@ const std::string Exists::Identifier = "exists";
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer Exists::decomposed(DerivedPredicates &derivedPredicates)
+{
+	m_argument = m_argument->decomposed(derivedPredicates);
+
+	return this;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

src/plasp/pddl/expressions/ForAll.cpp

@@ -3,6 +3,8 @@
 #include <algorithm>
 #include <iostream>
 
+#include <plasp/pddl/expressions/DerivedPredicate.h>
+
 namespace plasp
 {
 namespace pddl
@@ -20,6 +22,18 @@ const std::string ForAll::Identifier = "forall";
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer ForAll::decomposed(DerivedPredicates &derivedPredicates)
+{
+	auto derivedPredicate = DerivedPredicatePointer(new DerivedPredicate);
+	derivedPredicates.push_back(derivedPredicate);
+
+	derivedPredicate->setArgument(this);
+
+	return derivedPredicate;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

src/plasp/pddl/expressions/Not.cpp

@@ -4,6 +4,7 @@
 #include <plasp/pddl/expressions/Exists.h>
 #include <plasp/pddl/expressions/ForAll.h>
 #include <plasp/pddl/expressions/Or.h>
+#include <plasp/utils/TranslatorException.h>
 
 namespace plasp
 {
@@ -183,6 +184,19 @@ void Not::print(std::ostream &ostream) const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer Not::decomposed(DerivedPredicates &)
+{
+	if (m_argument->expressionType() != Expression::Type::Not
+	    && m_argument->expressionType() != Expression::Type::Predicate)
+	{
+		throw utils::TranslatorException("Expression is not in first-order negation normal form and cannot be decomposed");
+	}
+
+	return this;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }

src/plasp/pddl/expressions/Or.cpp

@@ -1,5 +1,7 @@
 #include <plasp/pddl/expressions/Or.h>
 
+#include <plasp/pddl/expressions/DerivedPredicate.h>
+
 namespace plasp
 {
 namespace pddl
@@ -17,6 +19,25 @@ const std::string Or::Identifier = "or";
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+ExpressionPointer Or::decomposed(DerivedPredicates &derivedPredicates)
+{
+	// Check that all children are simple or negated predicates
+	std::for_each(m_arguments.begin(), m_arguments.end(),
+		[&](auto &argument)
+		{
+			argument = argument->decomposed(derivedPredicates);
+		});
+
+	auto derivedPredicate = DerivedPredicatePointer(new DerivedPredicate);
+	derivedPredicates.push_back(derivedPredicate);
+
+	derivedPredicate->setArgument(this);
+
+	return derivedPredicate;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 }