First implementation for heuristic forward state-space search added.

Author: RuedigerLunde

aima-core/src/main/java/aima/core/logic/fol/inference/FOLFCAsk.java

@@ -86,7 +86,7 @@ public InferenceResult ask(FOLKnowledgeBase KB, Sentence query) {
 		Literal alpha = new Literal((AtomicSentence) query);
 
 		// local variables: new, the new sentences inferred on each iteration
-		List<Literal> newSentences = new ArrayList<Literal>();
+		List<Literal> newSentences = new ArrayList<>();
 
 		// Ensure query is not already a know fact before
 		// attempting forward chaining.

aima-core/src/main/java/aima/core/logic/fol/parsing/ast/Predicate.java

@@ -12,7 +12,7 @@
  */
 public class Predicate implements AtomicSentence {
 	private String predicateName;
-	private List<Term> terms = new ArrayList<Term>();
+	private List<Term> terms = new ArrayList<>();
 	private String stringRep = null;
 	private int hashCode = 0;
 
@@ -48,7 +48,7 @@ public Object accept(FOLVisitor v, Object arg) {
 	}
 
 	public Predicate copy() {
-		List<Term> copyTerms = new ArrayList<Term>();
+		List<Term> copyTerms = new ArrayList<>();
 		for (Term t : terms) {
 			copyTerms.add(t.copy());
 		}

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

@@ -17,8 +17,8 @@
  * @author Ruediger Lunde
  */
 public class BackwardStateSpaceSearchProblem extends GeneralProblem<List<Literal>, ActionSchema> {
-    PlanningProblem pProblem;
-    List<ActionSchema> propositionalisedActions;
+    protected PlanningProblem pProblem;
+    protected List<ActionSchema> propositionalisedActions;
 
     public BackwardStateSpaceSearchProblem(PlanningProblem pProblem) {
         this.pProblem = pProblem;

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

@@ -2,6 +2,7 @@
 
 import aima.core.logic.fol.kb.data.Literal;
 import aima.core.search.framework.problem.GeneralProblem;
+import aima.core.search.framework.problem.StepCostFunction;
 
 import java.util.ArrayList;
 import java.util.Comparator;
@@ -17,18 +18,23 @@
  * @author Ruediger Lunde
  */
 public class ForwardStateSpaceSearchProblem extends GeneralProblem<List<Literal>, ActionSchema> {
-    PlanningProblem pProblem;
-    List<ActionSchema> propositionalisedActions;
+    protected PlanningProblem pProblem;
+    protected List<ActionSchema> propositionalisedActions;
 
     public ForwardStateSpaceSearchProblem(PlanningProblem pProblem) {
+        this(pProblem, pProblem.getPropositionalisedActions(), (s, a, sp) -> 1);
+    }
+
+    public ForwardStateSpaceSearchProblem(PlanningProblem pProblem, List<ActionSchema> propositionalisedActions,
+                                          StepCostFunction<List<Literal>, ActionSchema> stepCostFn) {
         this.pProblem = pProblem;
-        propositionalisedActions = pProblem.getPropositionalisedActions();
+        this.propositionalisedActions = propositionalisedActions;
 
         initialState = pProblem.getInitialState().getFluents();
         actionsFn = this::actions;
         resultFn = this::result;
         goalTest = s -> s.containsAll(pProblem.getGoalState().getFluents());
-        stepCostFn = (s, a, sp) -> 1;
+        this.stepCostFn = stepCostFn;
     }
 
     List<ActionSchema> actions(List<Literal> state) {

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

@@ -2,10 +2,7 @@
 
 import aima.core.logic.fol.kb.data.Literal;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
+import java.util.*;
 
 /**
  * Artificial Intelligence A Modern Approach (3rd Edition): page 379.<br>
@@ -52,7 +49,36 @@ public void expand(PlanningProblem problem) {
         literalLevels.add(litLevelNext);
     }
 
-    private Level<ActionSchema, Literal> createActionLevel(Level<Literal, ActionSchema> prevLevel, PlanningProblem problem) {
+    /**
+     * A graph is said to be levelled off if two consecutive levels are identical.
+     *
+     * @return Boolean stating if the graph is levelled off.
+     */
+    public boolean levelledOff() {
+        if (numLevels() < 2)
+            return false;
+        return getLiteralLevel(numLevels() - 1).equals(getLiteralLevel(numLevels() - 2));
+    }
+
+    public Set<ActionSchema> getAllActions() {
+        Set<ActionSchema> result = new LinkedHashSet<>();
+        for (Level<ActionSchema, Literal> level : actionLevels)
+            result.addAll(level.getLevelObjects());
+        return result;
+    }
+
+    public int getFirstLevelOfOccurrence(Literal literal) {
+        int result = 0;
+        for (Level<Literal, ActionSchema> level : literalLevels) {
+            if (level.getLevelObjects().contains(literal))
+                return result;
+            result++;
+        }
+        return Integer.MAX_VALUE;
+    }
+
+    private Level<ActionSchema, Literal> createActionLevel(Level<Literal, ActionSchema> prevLevel,
+                                                           PlanningProblem problem) {
         Level<ActionSchema, Literal> result =  new Level<>(prevLevel, problem);
         // add actions with empty precondition
         for (ActionSchema action : problem.getPropositionalisedActions()) {
@@ -67,7 +93,8 @@ private Level<ActionSchema, Literal> createActionLevel(Level<Literal, ActionSche
     }
 
     // prevLevel can be null
-    private Level<Literal, ActionSchema> createLiteralLevel(Level<ActionSchema, Literal> prevLevel, PlanningProblem problem) {
+    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<>(prevLevel, problem);

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

@@ -71,7 +71,7 @@ public List<List<ActionSchema>> graphPlan(PlanningProblem problem) {
                 nogoods.put(tl, goals);
             }
             // if graph and nogoods have both leveled off then return failure
-            if (levelledOff(graph) && leveledOff(nogoods))
+            if (graph.levelledOff() && leveledOff(nogoods))
                 return null;
             // graph ← EXPAND-GRAPH(graph, problem)
             graph.expand(problem);
@@ -180,29 +180,13 @@ private boolean checkAllGoalsNonMutex(Level<Literal, ActionSchema> level, List<L
         return (!mutexCheck);
     }
 
-    /**
-     * A graph is said to be levelled off if two consecutive levels are identical.
-     *
-     * @return Boolean stating if the hashtable is levelled off.
-     */
     private boolean leveledOff(Hashtable<Integer, List<Literal>> nogoods) {
         int lastLevel = nogoods.size()-1;
         if (lastLevel < 1)
             return false;
         return nogoods.get(lastLevel).equals(nogoods.get(lastLevel-1));
     }
 
-    /**
-     * A graph is said to be levelled off if two consecutive levels are identical.
-     *
-     * @return Boolean stating if the graph is levelled off.
-     */
-    private boolean levelledOff(Graph graph) {
-        if (graph.numLevels() < 2)
-            return false;
-        return graph.getLiteralLevel(graph.numLevels() - 1).equals(graph.getLiteralLevel(graph.numLevels() - 2));
-    }
-
     public List<List<ActionSchema>> generateCombinations(List<List<ActionSchema>> actionLists) {
         List<List<ActionSchema>> result = new ArrayList<>();
         if (actionLists.size() == 1) {

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

@@ -0,0 +1,67 @@
+package aima.core.logic.planning;
+
+import aima.core.logic.fol.kb.data.Literal;
+import aima.core.search.framework.Node;
+import aima.core.search.framework.QueueBasedSearch;
+import aima.core.search.framework.problem.StepCostFunction;
+import aima.core.search.framework.qsearch.GraphSearch;
+import aima.core.search.informed.AStarSearch;
+
+import java.util.*;
+import java.util.function.ToDoubleFunction;
+
+/**
+ * Implements a simple heuristic forward state-space search algorithm using A*. By default, a level sum heuristic
+ * is used. Heuristic function as well as the step-cost function can be replaced.
+ *
+ * @author Ruediger Lunde
+ */
+public class HeuristicForwardStateSpaceSearchAlgorithm {
+
+    private ToDoubleFunction<Node<List<Literal>, ActionSchema>> heuristicFn = n -> levelSumHeuristic(n.getState());
+    private StepCostFunction<List<Literal>, ActionSchema> stepCostFn = (s0, a, s1) -> 1;
+
+    PlanningProblem pProblem;
+    private final Graph graph;
+    private final HashMap<Literal, Integer> literalLookup = new HashMap<>();
+
+    public HeuristicForwardStateSpaceSearchAlgorithm(final PlanningProblem pProblem) {
+        this.pProblem = pProblem;
+        // Compute planning graph. It is used to filter propositionalised actions and for heuristic value computation.
+        graph = new Graph(pProblem);
+        while (!graph.levelledOff())
+            graph.expand(pProblem);
+        literalLookup.clear();
+    }
+
+    public void setHeuristicFn(ToDoubleFunction<Node<List<Literal>, ActionSchema>> heuristicFn) {
+        this.heuristicFn = heuristicFn;
+    }
+
+    public void setStepCostFn(StepCostFunction<List<Literal>, ActionSchema> stepCostFn) {
+        this.stepCostFn = stepCostFn;
+    }
+
+    public Optional<List<ActionSchema>> search() {
+        ForwardStateSpaceSearchProblem sProblem =
+                new ForwardStateSpaceSearchProblem(pProblem, new ArrayList<>(graph.getAllActions()), stepCostFn);
+        QueueBasedSearch<List<Literal>, ActionSchema> search =
+                new AStarSearch<>(new GraphSearch<>(), heuristicFn);
+        return search.findActions(sProblem);
+    }
+
+    private double levelSumHeuristic(List<Literal> state) {
+        double result = 0;
+        for (Literal literal : pProblem.getGoalState().getFluents()) {
+            if (!state.contains(literal)) {
+                Integer level = literalLookup.get(literal);
+                if (level == null) {
+                    level = graph.getFirstLevelOfOccurrence(literal);
+                    literalLookup.put(literal, level);
+                }
+                result = result + level;
+            }
+        }
+        return result;
+    }
+}