patrick/plasp
Archived
1
0
Fork 0
Code Issues 12 Releases 8 Activity

Started implementing translation for derived predicates.

Browse Source
This commit is contained in:
Patrick Lühne
2016-12-07 01:56:06 +01:00
parent 443c126b88
commit 3b110c0b8a
28 changed files with 471 additions and 674 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
tests/TestPDDLNormalization.cpp
View File

@@ -79,7 +79,7 @@ TEST_CASE("[PDDL normalization] Implications are correctly replaced", "[PDDL nor
i->setArgument(1, new expressions::Dummy("b"));
std::stringstream output;
i->normalized()->print(output);
i->reduced()->print(output);
CHECK(output.str() == "(or (not (a)) (b))");
}
@@ -95,68 +95,35 @@ TEST_CASE("[PDDL normalization] Double negations are correctly replaced", "[PDDL
n1->setArgument(n2);
std::stringstream output;
n1->normalized()->print(output);
n1->simplified()->print(output);
CHECK(output.str() == "(a)");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL normalization] De Morgan’s rule is correctly applied to negative conjunctions", "[PDDL normalization]")
{
auto a = expressions::AndPointer(new expressions::And);
a->addArgument(new expressions::Dummy("a"));
a->addArgument(new expressions::Dummy("b"));
a->addArgument(new expressions::Dummy("c"));
auto n = expressions::NotPointer(new expressions::Not);
n->setArgument(a);
std::stringstream output;
n->normalized()->print(output);
CHECK(output.str() == "(or (not (a)) (not (b)) (not (c)))");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL normalization] De Morgan’s rule is correctly applied to negative disjunctions", "[PDDL normalization]")
{
auto a = expressions::OrPointer(new expressions::Or);
a->addArgument(new expressions::Dummy("a"));
a->addArgument(new expressions::Dummy("b"));
a->addArgument(new expressions::Dummy("c"));
auto n = expressions::NotPointer(new expressions::Not);
n->setArgument(a);
std::stringstream output;
n->normalized()->print(output);
CHECK(output.str() == "(and (not (a)) (not (b)) (not (c)))");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL normalization] Expressions inside double negations are also normalized", "[PDDL normalization]")
TEST_CASE("[PDDL normalization] Expressions inside double negations are also simplified", "[PDDL normalization]")
{
auto n1 = expressions::NotPointer(new expressions::Not);
auto n2 = expressions::NotPointer(new expressions::Not);
auto n3 = expressions::NotPointer(new expressions::Not);
auto a = expressions::AndPointer(new expressions::And);
auto a1 = expressions::AndPointer(new expressions::And);
auto a2 = expressions::AndPointer(new expressions::And);
a->addArgument(new expressions::Dummy("a"));
a->addArgument(new expressions::Dummy("b"));
a->addArgument(new expressions::Dummy("c"));
a2->addArgument(new expressions::Dummy("d"));
a2->addArgument(new expressions::Dummy("e"));
n3->setArgument(a);
n2->setArgument(n3);
a1->addArgument(new expressions::Dummy("a"));
a1->addArgument(new expressions::Dummy("b"));
a1->addArgument(new expressions::Dummy("c"));
a1->addArgument(a2);
n2->setArgument(a1);
n1->setArgument(n2);
std::stringstream output;
n1->normalized()->print(output);
n1->simplified()->print(output);
CHECK(output.str() == "(or (not (a)) (not (b)) (not (c)))");
CHECK(output.str() == "(and (a) (b) (c) (d) (e))");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -180,7 +147,7 @@ TEST_CASE("[PDDL normalization] Nested “for all” expressions are correctly s
f2->setArgument(new expressions::Dummy("a"));
std::stringstream output;
f1->normalized()->print(output);
f1->simplified()->print(output);
CHECK(output.str() == "(forall (?x ?y ?z ?u ?v ?w) (a))");
}
@@ -206,149 +173,36 @@ TEST_CASE("[PDDL normalization] Nested “exists” expressions are correctly si
e2->setArgument(new expressions::Dummy("a"));
std::stringstream output;
e1->normalized()->print(output);
e1->simplified()->print(output);
CHECK(output.str() == "(exists (?x ?y ?z ?u ?v ?w) (a))");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL normalization] Prenex normal form is correctly established", "[PDDL normalization]")
TEST_CASE("[PDDL normalization] “for all” expressions are correctly replaced by “exists” expressions during normalization", "[PDDL normalization]")
{
auto a = expressions::AndPointer(new expressions::And);
auto f1 = expressions::ForAllPointer(new expressions::ForAll);
auto o = expressions::OrPointer(new expressions::Or);
auto e = expressions::ExistsPointer(new expressions::Exists);
auto f2 = expressions::ForAllPointer(new expressions::ForAll);
auto v1 = expressions::VariablePointer(new expressions::Variable("x"));
auto v2 = expressions::VariablePointer(new expressions::Variable("y"));
auto v3 = expressions::VariablePointer(new expressions::Variable("z"));
auto v4 = expressions::VariablePointer(new expressions::Variable("u"));
auto v5 = expressions::VariablePointer(new expressions::Variable("v"));
auto v6 = expressions::VariablePointer(new expressions::Variable("w"));
a->addArgument(new expressions::Dummy("a"));
a->addArgument(f1);
f1->variables() = {v1};
f1->setArgument(o);
o->addArgument(e);
e->variables() = {v3};
e->setArgument(new expressions::Dummy("b"));
o->addArgument(f2);
f2->variables() = {v2};
f2->setArgument(new expressions::Dummy("c"));
auto normalized = a->reduced()->negationNormalized()->prenex();
SECTION("normalized")
{
std::stringstream output;
normalized->print(output);
CHECK(output.str() == "(forall (?x) (forall (?y) (exists (?z) (and (a) (or (b) (c))))))");
}
SECTION("simplified")
{
normalized = normalized->simplified();
std::stringstream output;
normalized->print(output);
CHECK(output.str() == "(forall (?x ?y) (exists (?z) (and (a) (or (b) (c)))))");
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL normalization] Same-type first-order expressions are correctly grouped in prenex normal form", "[PDDL normalization]")
{
auto f1 = expressions::ForAllPointer(new expressions::ForAll);
auto f2 = expressions::ForAllPointer(new expressions::ForAll);
auto f3 = expressions::ForAllPointer(new expressions::ForAll);
auto f4 = expressions::ForAllPointer(new expressions::ForAll);
auto f5 = expressions::ForAllPointer(new expressions::ForAll);
auto f6 = expressions::ForAllPointer(new expressions::ForAll);
auto e1 = expressions::ExistsPointer(new expressions::Exists);
auto e2 = expressions::ExistsPointer(new expressions::Exists);
auto e3 = expressions::ExistsPointer(new expressions::Exists);
auto a = expressions::AndPointer(new expressions::And);
f1->variables() = {new expressions::Variable("v1")};
f1->setArgument(a);
// forall exists forall exists
a->addArgument(f2);
f2->variables() = {new expressions::Variable("v2")};
f2->setArgument(e1);
e1->variables() = {new expressions::Variable("v3")};
e1->setArgument(f3);
f3->variables() = {new expressions::Variable("v4")};
f3->setArgument(e2);
e2->variables() = {new expressions::Variable("v5")};
e2->setArgument(new expressions::Dummy("a"));
// forall forall exists forall
a->addArgument(f4);
f4->variables() = {new expressions::Variable("v6")};
f4->setArgument(f5);
f5->variables() = {new expressions::Variable("v7")};
f5->setArgument(e3);
e3->variables() = {new expressions::Variable("v8")};
e3->setArgument(f6);
f6->variables() = {new expressions::Variable("v9")};
f6->setArgument(new expressions::Dummy("b"));
auto normalized = f1->normalized();
std::stringstream output;
normalized->print(output);
CHECK(output.str() == "(forall (?v1 ?v2 ?v6 ?v7) (exists (?v3 ?v8) (forall (?v4 ?v9) (exists (?v5) (and (a) (b))))))");
}
////////////////////////////////////////////////////////////////////////////////////////////////////
TEST_CASE("[PDDL normalization] Disjunctive normal form is correctly established", "[PDDL normalization]")
{
auto f = expressions::ForAllPointer(new expressions::ForAll);
auto e = expressions::ExistsPointer(new expressions::Exists);
auto a = expressions::AndPointer(new expressions::And);
auto o1 = expressions::OrPointer(new expressions::Or);
auto o2 = expressions::OrPointer(new expressions::Or);
auto o3 = expressions::OrPointer(new expressions::Or);
auto f2 = expressions::ForAllPointer(new expressions::ForAll);
f->variables() = {new expressions::Variable("v1")};
f->setArgument(e);
f1->variables() = {v1, v2};
e->variables() = {v3, v4};
f2->variables() = {v5, v6};
e->variables() = {new expressions::Variable("v2")};
e->setArgument(o1);
o1->addArgument(a);
o1->addArgument(new expressions::Dummy("h"));
a->addArgument(new expressions::Dummy("a"));
a->addArgument(new expressions::Dummy("b"));
a->addArgument(o2);
a->addArgument(o3);
o2->addArgument(new expressions::Dummy("c"));
o2->addArgument(new expressions::Dummy("d"));
o2->addArgument(new expressions::Dummy("e"));
o3->addArgument(new expressions::Dummy("f"));
o3->addArgument(new expressions::Dummy("g"));
auto normalized = f->normalized();
f1->setArgument(e);
e->setArgument(f2);
f2->setArgument(new expressions::Dummy("a"));
std::stringstream output;
normalized->print(output);
f1->normalized()->print(output);
CHECK(output.str() == "(forall (?v1) (exists (?v2) (or "
"(and (a) (b) (c) (f)) "
"(h) "
"(and (a) (b) (d) (f)) "
"(and (a) (b) (e) (f)) "
"(and (a) (b) (c) (g)) "
"(and (a) (b) (d) (g)) "
"(and (a) (b) (e) (g))"
")))");
CHECK(output.str() == "(exists (?x ?y) (not (exists (?z ?u ?v ?w) (not (a)))))");
}