Bug in GraphPlanAlgorithm fixed. Negative precondition literals must be added at graph level 0.

Author: RuedigerLunde

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

@@ -96,13 +96,27 @@ private Level<ActionSchema, Literal> createActionLevel(Level<Literal, ActionSche
     private Level<Literal, ActionSchema> createLiteralLevel(Level<ActionSchema, Literal> prevLevel,
                                                             PlanningProblem problem) {
         Level<Literal, ActionSchema> result = (prevLevel == null)
-                ? new Level<>(problem.getInitialState().getFluents(), problem)
+                ? new Level<>(getInitialPlanningState(problem), problem)
                 : new Level<>(prevLevel, problem);
         calculateNextLinks(result, problem);
         calculateMutexLinksForLiteralLevel(result);
         return result;
     }
 
+    // negative precondition literals are needed for backward search...
+    private List<Literal> getInitialPlanningState(PlanningProblem problem) {
+        List<Literal> result = new ArrayList<>(problem.getInitialState().getFluents());
+        for (ActionSchema action : problem.getPropositionalisedActions()) {
+            for (Literal literal : action.getPrecondition())
+                if (literal.isNegativeLiteral()) {
+                    Literal posLiteral = literal.getComplementaryLiteral();
+                    if (!result.contains(posLiteral))
+                        result.add(literal);
+                }
+        }
+        return result;
+    }
+
     private void calculateNextLinks(Level<Literal, ActionSchema> level, PlanningProblem problem) {
         // add applicable actions:
         for (ActionSchema action : problem.getPropositionalisedActions()) {

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

@@ -9,10 +9,10 @@
  * @author Ruediger Lunde
  */
 public class Level<CURR, PREV> {
-    private List<CURR> levelObjects = new ArrayList<>();
+    private final List<CURR> levelObjects = new ArrayList<>();
     HashMap<CURR, List<PREV>> prevLinks = new HashMap<>();
     HashMap<CURR, List<PREV>> nextLinks = new HashMap<>();
-    private HashMap<CURR, List<CURR>> mutexLinks = new HashMap<>();; //can be planned alternatively
+    private final HashMap<CURR, List<CURR>> mutexLinks = new HashMap<>(); // can be planned alternatively
 
     private Level<PREV, CURR> prevLevel;
 

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

@@ -23,9 +23,10 @@
  * @author samagra
  */
 public class PlanningProblem {
-    State initialState; // initialState
-    Set<ActionSchema> actionSchemas; // Planning Domain
-    State goalState; // goalState
+    private State initialState; // initialState
+    private Set<ActionSchema> actionSchemas; // Planning Domain
+    private List<ActionSchema> propositionalisedActionSchemas;
+    private State goalState; // goalState
 
 
     public PlanningProblem(State initialState, State goalState, Set<ActionSchema> actionSchemas) {
@@ -35,7 +36,7 @@ public PlanningProblem(State initialState, State goalState, Set<ActionSchema> ac
     }
 
     public PlanningProblem(State initialState, State goalState, ActionSchema... actions) {
-        this(initialState, goalState, new HashSet<>(Arrays.asList(actions)));
+        this(initialState, goalState, new LinkedHashSet<>(Arrays.asList(actions)));
     }
 
     public State getInitialState() {
@@ -86,13 +87,15 @@ public List<Constant> getProblemConstants() {
      * @return Propositionalises all the actionschemas to return a set of possible ground actions
      */
     public List<ActionSchema> getPropositionalisedActions() {
-        List<Constant> problemConstants = getProblemConstants();
-        List<ActionSchema> result = new ArrayList<>();
-        for (ActionSchema actionSchema : getActionSchemas()) {
-            int numberOfVars = actionSchema.getVariables().size();
-            for (List<Constant> constants : PermutationGenerator.generatePermutations(problemConstants, numberOfVars))
-                result.add(actionSchema.getActionBySubstitution(constants));
+        if (propositionalisedActionSchemas == null) {
+            List<Constant> problemConstants = getProblemConstants();
+            propositionalisedActionSchemas = new ArrayList<>();
+            for (ActionSchema actionSchema : getActionSchemas()) {
+                int numberOfVars = actionSchema.getVariables().size();
+                for (List<Constant> constants : PermutationGenerator.generatePermutations(problemConstants, numberOfVars))
+                    propositionalisedActionSchemas.add(actionSchema.getActionBySubstitution(constants));
+            }
         }
-        return result;
+        return propositionalisedActionSchemas;
     }
 }

aima-core/src/main/java/aima/core/util/math/permute/PermutationGenerator.java

@@ -1,16 +1,15 @@
 package aima.core.util.math.permute;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.List;
+import java.util.*;
 
 /**
  * @author samagra
  */
 public class PermutationGenerator {
 
     public static <T> Iterable<List<T>> generatePermutations(List<T> list, int r) {
+        if (r > list.size())
+            return Collections.emptyList();
         long rfact = (long) PermutationGenerator.factorial(r);
         long total = (long) CombinationGenerator.nCr(list.size(), r) * rfact;
         return () -> new Iterator<>() {

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

@@ -1,13 +1,14 @@
 package aima.test.core.unit.logic.planning;
 
+import aima.core.logic.fol.parsing.ast.Variable;
 import aima.core.logic.planning.*;
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.Arrays;
 import java.util.List;
 
 /**
- * @author samagra
  * @author Ruediger Lunde
  */
 public class GraphPlanAlgorithmTest {
@@ -33,13 +34,29 @@ public void spareTireTest() {
 
     @Test
     public void levelOffTest() {
-        GraphPlanAlgorithm algorithm = new GraphPlanAlgorithm();
         PlanningProblem stProblem = PlanningProblemFactory.spareTireProblem();
-        State initialState = new State("Tire(Flat)^Tire(Spare)^At(Flat,Axle)"); //^At(Spare,Trunk)");
-        PlanningProblem modifiedProblem = new PlanningProblem(initialState, stProblem.getGoalState(), stProblem.getActionSchemas());
+        State initialState = new State("Tire(Flat)^Tire(Spare)^At(Flat,Axle)");
+        PlanningProblem modifiedProblem = new PlanningProblem(initialState,
+                stProblem.getGoalState(), stProblem.getActionSchemas());
+        GraphPlanAlgorithm algorithm = new GraphPlanAlgorithm();
         List<List<ActionSchema>> solution = algorithm.graphPlan(modifiedProblem);
         Assert.assertEquals(4, algorithm.getGraph().numLevels());
         Assert.assertNull(solution);
+    }
 
+    @Test
+    public void negativeLiteralsNeededInFirstGraphLevel() {
+        State initialState = new State("Device(Radio1)");
+        State goalState = new State("On(Radio1)");
+        Variable d = new Variable("d");
+        ActionSchema switchOnAction = new ActionSchema("switch-on", List.of(d),
+                "Device(d)^~On(d)",
+                "On(d)");
+        PlanningProblem problem = new PlanningProblem(initialState, goalState, switchOnAction);
+        GraphPlanAlgorithm algorithm = new GraphPlanAlgorithm();
+        List<List<ActionSchema>> solution = algorithm.graphPlan(problem);
+        Assert.assertEquals(1, solution.size());
     }
+
+
 }