Minor cleanup.

Author: RuedigerLunde

aima-core/src/main/java/aima/core/logic/planning/BackwardStateSpaceSearchProblem.java

@@ -46,7 +46,7 @@ List<ActionSchema> actions(List<Literal> state) {
             if (relevant) {
                 for (Literal literal : action.getPrecondition()) {
                     Literal cLit = literal.getComplementaryLiteral();
-                    if (!action.getEffect().contains(cLit) && state.contains(cLit)) {
+                    if (state.contains(cLit) && !action.getEffect().contains(cLit)) {
                         relevant = false; // unchanged precondition contradicts state specification
                         break;
                     }

aima-core/src/main/java/aima/core/logic/planning/ForwardStateSpaceSearchProblem.java

@@ -73,9 +73,10 @@ else if (!result.contains(literal))
 
     boolean goalTest(List<Literal> state) {
         for (Literal literal : pProblem.getGoal())
-            if (literal.isPositiveLiteral() && !state.contains(literal)
-                || literal.isNegativeLiteral() && state.contains(literal.getComplementaryLiteral()))
+            if (literal.isPositiveLiteral()
+                    ? !state.contains(literal)
+                    : state.contains(literal.getComplementaryLiteral()))
                 return false;
-            return true;
+        return true;
     }
 }

aima-core/src/main/java/aima/core/logic/planning/PlanningProblem.java

@@ -16,16 +16,17 @@
  * within the domain is defined with the addition of an initial state and a goal. The initial
  * state is a conjunction of ground atoms.The goal is just like a
  * precondition: a conjunction of literals (positive or negative) that may contain variables, such
- * as At(p, SFO ) ∧ Plane(p). Any variables are treated as existentially quantified, so this goal
+ * as At(p, SFO) ∧ Plane(p). Any variables are treated as existentially quantified, so this goal
  * is to have any plane at SFO. The problem is solved when we can find a sequence of actions
  * that end in a state s that entails the goal.
  *
  * @author samagra
+ * @author Ruediger Lunde
  */
 public class PlanningProblem {
-    private final State initialState; // initialState
-    private final Set<ActionSchema> actionSchemas; // Planning Domain
-    private final List<Literal> goal; // goal
+    private final State initialState;
+    private final Set<ActionSchema> actionSchemas;
+    private final List<Literal> goal;
 
     private List<ActionSchema> propositionalisedActionSchemas;
 

aima-core/src/main/java/aima/core/logic/planning/PlanningProblemFactory.java

@@ -1,5 +1,6 @@
 package aima.core.logic.planning;
 
+import aima.core.logic.fol.kb.data.Literal;
 import aima.core.logic.fol.parsing.ast.Constant;
 import aima.core.logic.fol.parsing.ast.Term;
 import aima.core.logic.fol.parsing.ast.Variable;
@@ -40,7 +41,7 @@ public class PlanningProblemFactory {
     public static PlanningProblem airCargoTransportProblem() {
         State initialState = new State("At(C1,SFO)^At(C2,JFK)^At(P1,SFO)" +
                 "^At(P2,JFK)^Cargo(C1)^Cargo(C2)^Plane(P1)^Plane(P2)^Airport(JFK)^Airport(SFO)");
-        State goalState = new State("At(C1,JFK)^At(C2,SFO)");
+        List<Literal> goal = Utils.parse("At(C1,JFK)^At(C2,SFO)");
         Variable c = new Variable("c");
         Variable p = new Variable("p");
         Variable a = new Variable("a");
@@ -58,7 +59,7 @@ public static PlanningProblem airCargoTransportProblem() {
                 "At(p,from)^Plane(p)^Airport(from)^Airport(to)",
                 "~At(p,from)^At(p,to)");
 
-        return new PlanningProblem(initialState, goalState.getFluents(), loadAction, unloadAction, flyAction);
+        return new PlanningProblem(initialState, goal, loadAction, unloadAction, flyAction);
     }
 
     /**
@@ -85,7 +86,7 @@ public static PlanningProblem airCargoTransportProblem() {
      */
     public static PlanningProblem spareTireProblem() {
         State initialState = new State("Tire(Flat)^Tire(Spare)^At(Flat,Axle)^At(Spare,Trunk)");
-        State goalState = new State("At(Spare,Axle)");
+        List<Literal> goal = Utils.parse("At(Spare,Axle)");
         Variable obj = new Variable("obj");
         Variable loc = new Variable("loc");
         Variable t = new Variable("t");
@@ -101,7 +102,7 @@ public static PlanningProblem spareTireProblem() {
                 "",
                 "~At(Spare,Ground)^~At(Spare,Axle)^~At(Spare,Trunk)" +
                         "^~At(Flat,Ground)^~At(Flat,Axle)^~At(Flat,Trunk)");
-        return new PlanningProblem(initialState, goalState.getFluents(), removeAction, putOnAction, leaveOvernightAction);
+        return new PlanningProblem(initialState, goal, removeAction, putOnAction, leaveOvernightAction);
     }
 
     /**
@@ -119,7 +120,7 @@ public static PlanningProblem spareTireProblem() {
      */
     public static PlanningProblem goHomeToSFOProblem() {
         State initialState = new State("At(Home)");
-        State goalState = new State("At(SFO)");
+        List<Literal> goal = Utils.parse("At(SFO)");
         ActionSchema driveAction = new ActionSchema("Drive", null,
                 "At(Home)",
                 "~At(Home)^At(SFOLongTermParking)");
@@ -129,7 +130,7 @@ public static PlanningProblem goHomeToSFOProblem() {
         ActionSchema taxiAction = new ActionSchema("Taxi", null,
                 "At(Home)",
                 "~At(Home)^At(SFO)");
-        return new PlanningProblem(initialState, goalState.getFluents(), driveAction, shuttleAction, taxiAction);
+        return new PlanningProblem(initialState, goal, driveAction, shuttleAction, taxiAction);
 
     }
 

aima-core/src/test/java/aima/test/core/unit/logic/planning/PlanningProblemTest.java

@@ -1,12 +1,10 @@
 package aima.test.core.unit.logic.planning;
 
+import aima.core.logic.fol.kb.data.Literal;
 import aima.core.logic.fol.parsing.ast.Constant;
 import aima.core.logic.fol.parsing.ast.Term;
 import aima.core.logic.fol.parsing.ast.Variable;
-import aima.core.logic.planning.ActionSchema;
-import aima.core.logic.planning.PlanningProblemFactory;
-import aima.core.logic.planning.PlanningProblem;
-import aima.core.logic.planning.State;
+import aima.core.logic.planning.*;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
@@ -29,7 +27,7 @@ public void setup() {
     @Test
     public void constructorTest() {
         State initState = new State("Tire(Flat)^Tire(Spare)^At(Flat,Axle)^At(Spare,Trunk)");
-        State goalState = new State("At(Spare,Axle)");
+        List<Literal> goal = Utils.parse("At(Spare,Axle)");
         Variable obj = new Variable("obj");
         Variable loc = new Variable("loc");
         Variable t = new Variable("t");
@@ -46,7 +44,7 @@ public void constructorTest() {
                 "~At(Spare,Ground)^~At(Spare,Axle)^~At(Spare,Trunk)" +
                         "^~At(Flat,Ground)^~At(Flat,Axle)^~At(Flat,Trunk)");
         Assert.assertEquals(initState, testProblem.getInitialState());
-        Assert.assertEquals(goalState, testProblem.getGoal());
+        Assert.assertEquals(goal, testProblem.getGoal());
         Assert.assertEquals(3, testProblem.getActionSchemas().size());
         Assert.assertTrue(testProblem.getActionSchemas().contains(removeAction));
         Assert.assertTrue(testProblem.getActionSchemas().contains(putOnAction));