Solving problems by searching

Transcription

1 Solving problems by searching CE417: Introduction to Artificial Intelligence Sharif University of Technology Spring 2014 Soleymani Artificial Intelligence: A Modern Approach, Chapter 3

2 Outline Problem-solving agents Problem formulation and some examples of problems Search algorithms Uninformed Using only the problem definition Informed Using also problem specific knowledge 2

3 Problem-Solving Agents Problem Formulation: process of deciding what actions and states to consider States of the world Actions as transitions between states Goal Formulation: process of deciding what the next goal to be sought will be Agent must find out how to act now and in the future to reach a goal state Search: process of looking for solution (a sequence of actions that reaches the goal starting from initial state) 3

4 Problem-Solving Agents A goal-based agent adopts a goal and aim at satisfying it (as a simple version of intelligent agent maximizing a performance measure) How does an intelligent system formulate its problem as a search problem Goal formulation: specifying a goal (or a set of goals) that agent must reach Problem formulation: abstraction (removing detail) Retaining validity and ensuring that the abstract actions are easy to perform 4

5 Example: Romania On holiday in Romania; currently in Arad. Flight leaves tomorrow from Bucharest Initial state currently in Arad Map of Romania Formulate goal be in Bucharest Formulate problem states: various cities actions: drive between cities Solution sequence of cities, e.g., Arad, Sibiu, Fagaras, Bucharest 5

6 Example: Romania (Cont.) Assumptions about environment Known Observable The initial state can be specified exactly. Deterministic Each applied action to a state results in a specified state. Discrete Given the above first three assumptions, by starting in an initial state and running a sequence of actions, it is absolute where the agent will be Perceptions after each action provide no new information Can search with closed eyes (open-loop) 6

7 Problem-solving agents Formulate, Search, Execute 7

8 Problem types Deterministic and fully observable (single-state problem) Agent knows exactly its state even after a sequence of actions Solution is a sequence Non-observable or sensor-less (conformant problem) Agent s percepts provide no information at all Solution is a sequence Nondeterministic and/or partially observable (contingency problem) Percepts provide new information about current state Solution can be a contingency plan (tree or strategy) and not a sequence Often interleave search and execution Unknown state space (exploration problem) 8

9 Belief State In partially observable & nondeterministic environments, a state is not necessarily mapped to a world configuration State shows the agent s conception of the world state Agent's current belief (given the sequence of actions and percepts up to that point) about the possible physical states it might be in. 9 World states A sample belief state

10 Example: vacuum world Single-state, start in {5} Solution? [Right, Suck] Sensorless, start in {1,2,3,4,5,6,7,8} e.g., Right goes to {2,4,6,8} Solution? [Right,Suck,Left,Suck] Contingency Nondeterministic: Suck may dirty a clean carpet Partially observable: location, dirt only at the current location Percept: [L, Clean], i.e., start in {5} or {7} Solution? [Right, if dirt then Suck] 10 [Right, while dirt do Suck]

11 Single-state problem In this lecture, we focus on single-state problem Search for this type of problems is simpler And also provide strategies that can be base for search in more complex problems 11

12 Single-state problem formulation A problem is defined by five items: Initial state e.g., In( Arad) Actions: ACTIONS(s) shows set of actions that can be executed in s e.g., ACTIONS(In(Arad)) = {Go(Sibiu), Go(Timisoara), Go(Zerind)} 12

13 Single-state problem formulation A problem is defined by five items: Initial state e.g., In( Arad) Actions: ACTIONS(s) shows set of actions that can be executed in s Transition model: RESULTS(s, a) shows the state that results from doing action a in state s e.g., RESULTS(In(Arad), Go(Zerind)) = In(Zerind) 13

14 Single-state problem formulation A problem is defined by five items: Initial state e.g., In( Arad) Actions: ACTIONS(s) shows set of actions that can be executed in s Transition model: RESULTS(s, a) shows the state that results from doing action a in state s Goal test: GOAL_TEST(s) shows whether a given state is a goal state explicit, e.g., x = "at Bucharest" abstract e.g., Checkmate(x) 14

15 Single-state problem formulation A problem is defined by five items: Initial state e.g., In( Arad) Actions: ACTIONS(s) shows set of actions that can be executed in s Transition model: RESULTS(s, a) shows the state that results from doing action a in state s Goal test: GOAL_TEST(s) shows whether a given state is a goal state Path cost (additive): assigns a numeric cost to each path that reflects agent s performance measure e.g., sum of distances, number of actions executed, etc. c(x, a, y) 0 is the step cost 15

16 Single-state problem formulation A problem is defined by five items: Initial state e.g., In( Arad) Actions: ACTIONS(s) shows set of actions that can be executed in s Transition model: RESULTS(s, a) shows the state that results from doing action a in state s Goal test: GOAL_TEST(s) shows whether a given state is a goal state Path cost (additive): assigns a numeric cost to each path that reflects agent s performance measure Solution: a sequence of actions leading from the initial state to a goal state Optimal Solution has the lowest path cost among all solutions. 16

17 State Space State space: set of all reachable states from initial state Initial state, actions, and transition model together define it It forms a directed graph Nodes: states Links: actions Constructing this graph on demand 17

18 Vacuum world state space graph = 8 States States? Actions? Goal test? Path cost? dirt locations & robot location Left, Right, Suck no dirt at all locations one per action 18

19 Example: 8-puzzle 9!/2 = 181,440 States States? Actions? Goal test? Path cost? locations of eight tiles and blank in 9 squares move blank left, right, up, down (within the board) e.g., the above goal state one per move 19 Note: optimal solution of n-puzzle family is NP-complete

20 Example: 8-queens problem States Initial State? no queens on the board States? any arrangement of 0-8 queens on the board is a state Actions? Goal test? Path cost? add a queen to the state (any empty square) 8 queens are on the board, none attacked of no interest search cost vs. solution path cost 20

21 Example: 8-queens problem (other formulation) 2,057 States Initial state? States? Actions? Goal test? Path cost? 21 no queens on the board any arrangement of k queens one per column in the leftmost k columns with no queen attacking another add a queen to any square in the leftmost empty column such that it is not attacked by any other queen 8 queens are on the board of no interest

22 Example: Knuth problem Knuth Conjecture: Starting with 4, a sequence of factorial, square root, and floor operations will reach any desired positive integer. Example: 4!! = 5 States? Positive numbers Initial State? 4 Actions? Factorial (for integers only), square root, floor Goal test? State is the objective positive number Path cost? Of no interest 23

23 Read-world problems Route finding Travelling salesman problem VLSI layout Robot navigation Automatic assembly sequencing 24

24 Example: Robot navigation (real-world) Infinite set of possible actions and states Techniques are required to make the search space finite. For the robot with arms and legs or wheels, the search space becomes many-dimensional. Dealing with errors in sensor readings and motor controls 25

25 Tree search algorithm Basic idea offline, simulated exploration of state space by generating successors of already-explored states function TREE-SEARCH( problem) returns a solution, or failure initialize the frontier using the initial state of problem loop do if the frontier is empty then return failure choose a leaf node and remove it from the frontier if the node contains a goal state then return the corresponding solution expand the chosen node, adding the resulting nodes to the frontier Frontier: all leaf nodes available for expansion at any given point Different data structures (e.g, FIFO, LIFO) for frontier can cause different orders of node expansion and thus produce different search algorithms. 27

26 Tree search example 28

27 Tree search example 29

28 Tree search example 30

29 Graph Search Redundant paths in tree search: more than one way to get from one state to another may be due to a bad problem definition or the essence of the problem can cause a tractable problem to become intractable function GRAPH-SEARCH( problem) returns a solution, or failure initialize the frontier using the initial state of problem loop do if the frontier is empty then return failure choose a leaf node and remove it from the frontier if the node contains a goal state then return the corresponding solution add the node to the explored set expand the chosen node, adding the resulting nodes to the frontier only if not in the frontier or explored set explored set: remembered every explored node 31

30 Graph Search Example: rectangular grid explored frontier 32

31 Search for 8-puzzle Problem Start Goal 33 Taken from:

32 Implementation: states vs. nodes A state is a (representation of) a physical configuration A node is a data structure constituting part of a search tree includes state, parent node, action, path cost g(x), depth 34

33 Search strategies Search strategy: order of node expansion Strategies performance evaluation: Completeness: Does it always find a solution when there is one? Time complexity: How many nodes are generated to find solution? Space complexity: Maximum number of nodes in memory during search Optimality: Does it always find a solution with minimum path cost? Time and space complexity are expressed by b (branching factor): maximum number of successors of any node d (depth): depth of the shallowest goal node m: maximum depth of any node in the search space (may be ) Time & space are described for tree search For graph search, analysis depends on redundant paths 35

34 36 Uninformed Search Algorithms

35 Uninformed (blind) search strategies No additional information beyond the problem definition Breadth-First Search (BFS) Uniform-Cost Search (UCS) Depth-First Search (DFS) Depth-Limited Search (DLS) Iterative Deepening Search (IDS) Bidirectional search 37

36 Breadth-first search Expand the shallowest unexpanded node Implementation: FIFO queue for the frontier 38

37 Breadth-first search 39

38 Breadth-first search 40

39 Breadth-first search 41

40 Properties of breadth-first search Complete? Time Yes (for finite b and d) b + b 2 + b b d = O(b d ) total number of generated nodes Space goal test has been applied to each node when it is generated O(b d 1 ) + O(b d ) = O(b d ) (graph search) Optimal? Tree search does not save much space while may cause a great time excess Yes, if path cost is a non-decreasing function of d explored frontier e.g. all actions having the same cost 43

41 Properties of breadth-first search Space complexity is a bigger problem than time complexity Time is also prohibitive Exponential-complexity search problems cannot be solved by uninformed methods (only the smallest instances) 1 million node/sec, 1kb/node d Time Memory 10 3 hours 10 terabytes days 1 pentabyte years 99 pentabytes years 10 exabytes 44

42 Uniform-Cost Search (UCS) Expand node n (in the frontier) with the lowest path cost g(n) Extension of BFS that is proper for any step cost function Implementation: Priority queue (ordered by path cost) for frontier Equivalent to breadth-first if all step costs are equal Two differences Goal test is applied when a node is selected for expansion A test is added when a better path is found to a node currently on the frontier <

43 Properties of uniform-cost search Complete? Time Yes, if step cost ε > 0 (to avoid infinite sequence of zero-cost actions) Number of nodes with g cost of optimal solution, O(b 1+ C ε ) where C is the optimal solution cost Space O(b d+1 ) when all step costs are equal Number of nodes with g cost of optimal solution, O(b 1+ C ε ) Optimal? Yes nodes expanded in increasing order of g(n) Difficulty: many long paths may exist with cost C 46

44 Uniform-cost search (proof of optimality) Lemma: If UCS selects a node n for expansion, the optimal solution to that node has been found. Proof by contradiction: Another frontier node n must exist on the optimal path from initial node to n (using graph separation property). Moreover, based on definition of path cost (due to non-negative step costs, paths never get shorter as nodes are added), we have g n g n and thus n would have been selected first. Nodes are expanded in order of their optimal path cost. 47

45 Depth First Search (DFS) Expand the deepest node in frontier Implementation: LIFO queue (i.e., put successors at front) for frontier 48

46 DFS Expand the deepest unexpanded node in frontier 49

47 DFS Expand the deepest unexpanded node in frontier 50

48 DFS Expand the deepest unexpanded node in frontier 51

49 DFS Expand the deepest unexpanded node in frontier 52

50 DFS Expand the deepest unexpanded node in frontier 53

51 DFS Expand the deepest unexpanded node in frontier 54

52 DFS Expand the deepest unexpanded node in frontier 55

53 DFS Expand the deepest unexpanded node in frontier 56

54 DFS Expand the deepest unexpanded node in frontier 57

55 DFS Expand the deepest unexpanded node in frontier 58

56 DFS Expand the deepest unexpanded node in frontier 59

57 Properties of DFS Complete? Tree-search version: not complete (repeated states & redundant paths) Graph-search version: fails in infinite state spaces (with infinite non-goal path) but complete in finite ones Time O(b m ): terrible if m is much larger than d Space In tree-version, m can be much larger than the size of the state space O(bm), i.e., linear space complexity for tree search So depth first tree search as the base of many AI areas Recursive version called backtracking search can be implemented in O(m) space Optimal? No DFS: tree-search version 61

58 Depth Limited Search Depth-first search with depth limit l (nodes at depth l have no successors) Solves the infinite-path problem In some problems (e.g., route finding), using knowledge of problem to specify l Complete? Time If l > d, it is complete O(b l ) Space O(bl) Optimal? No 62

59 Iterative Deepening Search (IDS) Combines benefits of DFS & BFS DFS: low memory requirement BFS: completeness & also optimality for special path cost functions Not such wasteful (most of the nodes are in the bottom level) 63

60 IDS: Example l =0 64

61 IDS: Example l =1 65

62 IDS: Example l =2 66

63 IDS: Example d =3 67

64 Properties of iterative deepening search Complete? Time Yes (for finite b and d) d b 1 + (d 1) b b d b d = O(b d ) Space O(bd) Optimal? Yes, if path cost is a non-decreasing function of the node depth IDS is the preferred method when search space is large and the depth of solution is unknown 68

65 Iterative deepening search Number of nodes generated to depth d: N IDS = d b 1 + (d 1) b b d b d = O(b d ) For b = 10, d = 5, we compute number of generated nodes: N BFS = , , ,000 = 111,110 N IDS = , , ,000 = 123,450 Overhead of IDS = (123, ,110)/111,110 = 11% 69

66 Bidirectional search Simultaneous forward and backward search (hoping that they meet in the middle) Idea: b d/2 + b d/2 is much less than b d Do the frontiers of two searches intersect? instead of goal test First solution may not be optimal Implementation Hash table for frontiers in one of these two searches Space requirement: most significant weakness Computing predecessors? May be difficult List of goals? a new dummy goal Abstract goal (checkmate)?! 70

67 Summary of algorithms (tree search) a Complete if b is finite b Complete if step cost ε>0 c Optimal if step costs are equal d If both directions use BFS Iterative deepening search uses only linear space and not much more time than other uninformed algorithms 71

68 Informed Search When exhaustive search is impractical, heuristic methods are used to speed up the process of finding a satisfactory solution. 72

69 Outline Best-first search Greedy best-first search A * search Finding heuristics 73

70 Best-first search Idea: use an evaluation function f(n) for each node and expand the most desirable unexpanded node More general than g n = cost so far to reach n Evaluation function provides an upper bound on the desirability (lower bound on the cost) that can be obtained through expanding a node Implementation: priority queue with decreasing order of desirability (search strategy is determined based on evaluation function) Special cases: Greedy best-first search A * search Uniform-cost search 74

71 Heuristic Function Incorporating problem-specific knowledge in search Information more than problem definition In order to come to an optimal solution as rapidly as possible Heuristic function can be used as a component of f(n) h n : estimated cost of cheapest path from n to a goal Depends only on n (not path from root to n) If n is a goal state then h(n)=0 h(n) 0 Examples of heuristic functions include using a rule-of-thumb, an educated guess, or an intuitive judgment 75

72 Greedy best-first search Evaluation function f n = h(n) e.g., h SLD n = straight-line distance from n to Bucharest Greedy best-first search expands the node that appears to be closest to goal Greedy 76

73 Romania with step costs in km 77

74 Greedy best-first search example 78

75 Greedy best-first search example 79

76 Greedy best-first search example 80

77 Greedy best-first search example 81

78 Properties of greedy best-first search Complete? No Time Space Similar to DFS, only graph search version is complete in finite spaces Infinite loops, e.g., (Iasi to Fagaras) Iasi Neamt Iasi Neamt O(b m ), but a good heuristic can give dramatic improvement O(b m ): keeps all nodes in memory Optimal? No 82

79 A * search Idea: minimizing the total estimated solution cost Evaluation function f n = g n + h(n) g n = cost so far to reach n h n = estimated cost of the cheapest path from n to goal So, f n = estimated total cost of path through n to goal Actual cost g n Estimated cost h n start n goal 83 f n = g n + h(n)

80 A * search Combines advantages of uniform-cost and greedy searches A * can be complete and optimal when h(n) has some properties 84

81 A * search: example 85

82 A * search: example 86

83 A * search: example 87

84 A * search: example 88

85 A * search: example 89

86 A * search: example 90

87 Conditions for optimality of A * Admissibility: h(n) be a lower bound on the cost to reach goal Condition for optimality of TREE-SEARCH version of A * Consistency (monotonicity): h n c n, a, n + h n Condition for optimality of GRAPH-SEARCH version of A * 91

88 Admissible heuristics Admissible heuristic h(n) never overestimates the cost to reach the goal (optimistic) h(n) is a lower bound on path cost from n to goal n, h(n) h (n) where h (n) is the real cost to reach the goal state from n Example: h SLD (n) the actual road distance 92

89 Consistent heuristics Triangle inequality n c(n, a, n ) n h(n) h(n ) G for every node n and every successor n generated by any action a h n c n, a, n + h n c n, a, n : cost of generating n by applying action to n 93

90 Consistency vs. admissibility Consistency Admissblity All consistent heuristic functions are admissible Nonetheless, most admissible heuristics are also consistent c(n 1, a 1, n 2 ) c(n 2, a 2, n 3 ) c(n k, a k, G) n 1 n 2 n 3 n k G h n 1 c n 1, a 1, n 2 + h(n 2 ) c n 1, a 1, n 2 + c n 2, a 2, n 3 + h(n 3 ) k i=1 c n i, a i, n i+1 + h(g) 0 h n 1 cost of (every) path from n 1 to goal cost of optimal path from n 1 to goal 94

91 Admissible but not consistent: Example G n n g n = 5 h n = 9 f(n) = 14 g n = 6 h n = 6 f(n ) = 12 c(n, a, n ) = 1 h(n) = 9 h(n ) = 6 h n h n + c(n, a, n ) f (for admissible heuristic) may decrease along a path Is there any way to make h consistent? h n = max (h n, h n c(n, a, n )) 95

92 Optimality of A * (admissible heuristics) Theorem: If h(n) is admissible, A * using TREE-SEARCH is optimal Assumptions: G 2 is a suboptimal goal in the frontier, n is an unexpanded node in the frontier and it is on a shortest path to an optimal goal G. I. h G 2 = 0 f G 2 = g G 2 II. h(g) = 0 f(g) = g(g) III. G 2 is suboptimal g G 2 > g G IV. I, II, III f G 2 > f G V. h is admissible h n h n g(n) + h(n) g(n) + h (n) A * will never select G 2 for expansion 96 f n f G IV f n < f(g 2 )

93 Optimality of A * (consistent heuristics) Theorem: If h(n) is consistent, A* using GRAPH-SEARCH is optimal Lemma1: if h(n) is consistent then f(n) values are nondecreasing along any path Proof: Let n be a successor of n I. f(n ) = g(n ) + h(n ) II. g(n ) = g(n) + c(n, a, n ) III. I, II f n = g n + c n, a, n + h n IV. h n is consistent h n c n, a, n + h n V. III, IV f(n ) g(n) + h(n) = f(n) 97

94 Optimality of A * (consistent heuristics) Lemma 2: If A* selects a node n for expansion, the optimal solution to that node has been found. Proof by contradiction: Another frontier node n must exist on the optimal path from initial node to n (using graph separation property). Moreover, based on Lemma 1, f n f n and thus n would have been selected first. The sequence of nodes expanded by A* (using GRAPH-SEARCH) is in nondecreasing order of f(n) Since h = 0 for goal nodes, the first selected goal node for expansion is an optimal solution (f is the true cost for goal nodes) 98

95 Admissible vs. consistent (tree vs. graph search) Consistent heuristic: When selecting a node for expansion, the path with the lowest cost to that node has been found When an admissible heuristic is not consistent, a node will need repeated expansion, every time a new best (so-far) cost is achieved for it. 99

96 Contours in the state space A * (using GRAPH-SEARCH) expands nodes in order of increasing f value Gradually adds "f-contours" of nodes Contour i has all nodes with f = f i wheref i < f i+1 A* expands all nodes with f(n) < C* A* expands some nodes with f(n) = C* (nodes on the goal contour) A* expands no nodes with f(n) > C* pruning 100

97 A * search vs. uniform cost search Uniform-cost search (A * using h(n) = 0) causes circular bands around initial state A * causes irregular bands More accurate heuristics stretched toward the goal (more narrowly focused around the optimal path) States are points in 2-D Euclidean space. g(n)=distance from start h(n)=estimate of distance from goal goal Start 101

98 Properties of A* Complete? Yes if nodes with f f G = C are finite Time? Step cost ε > 0 and b is finite Exponential But, with a smaller branching factor b h h or when equal step costs b d h h h Polynomial when h(x) h (x) = O(log h (x)) However, A* is optimally efficient for any given consistent heuristic Space? No optimal algorithm of this type is guaranteed to expand fewer nodes than A* (except to node with f = C ) Keeps all leaf and/or explored nodes in memory Optimal? Yes (expanding node in non-decreasing order of f) 102

99 Robot navigation example Initial state? Red cell States? Cells on rectangular grid (except to obstacle) Actions? Move to one of 8 neighbors (if it is not obstacle) Goal test? Green cell Path cost? Action cost is the Euclidean length of movement 103

100 A* vs. UCS: Robot navigation example Heuristic: Euclidean distance to goal Expanded nodes: filled circles in red & green Color indicating g value (red: lower, green: higher) Frontier: empty nodes with blue boundary Nodes falling inside the obstacle are discarded 104 Adopted from:

101 Robot navigation: Admissible heuristic Is Manhattan d M x, y = x 1 y 1 + x 2 y 2 distance an admissible heuristic for previous example? 105

102 A*: inadmissible heuristic h = 5 h_sld h = h_sld Adopted from: 106

103 A*, Greedy, UCS: Pacman UCS Heuristic: Manhattan distance Greedy Color: expanded in which iteration (red: lower) A* 107 Adapted from Dan Klein s slides

104 8-puzzle problem: state space b 3, average solution cost for random 8-puzzle 22 Tree search: b 3, d states Graph search: 9!/2 181,440 states for 8-puzzle for 15-puzzle 108

105 Admissible heuristics: 8-puzzle h 1 (n) = number of misplaced tiles h 2 (n) = sum of Manhattan distance of tiles from their target position i.e., no. of squares from desired location of each tile h 1 (S) = h 2 (S) = =

106 Effect of heuristic on accuracy N: number of generated nodes by A* d: solution depth Effective branching factor b : branching factor of a uniform tree of depth d containing N + 1 nodes. N + 1 = 1 + b + (b ) (b ) d Well-defined heuristic: b is close to one 110

107 Comparison on 8-puzzle Search Cost (N) d IDS A*(h 1 ) A*(h 2 ) Effective branching factor (b ) d IDS A*(h 1 ) A*(h 2 )

108 Heuristic quality If n, h 2 (n) h 1 (n) (both admissible) then h 2 dominates h 1 and it is better for search Surely expanded nodes: f n < C h n < C g n If h 2 (n) h 1 (n) then every node expanded for h 2 will also be surely expanded with h 1 (h 1 may also causes some more node expansion) 112

109 More accurate heuristic Max of admissible heuristics is admissible (while it is a more accurate estimate) h n = max (h 1 n, h 2 n ) How about using the actual cost as a heuristic? h(n) = h (n) for all n Will go straight to the goal?! Trade of between accuracy and computation time 113

110 Generating heuristics Relaxed problems Inventing admissible heuristics automatically Sub-problems (pattern databases) Learning heuristics from experience 114

111 Relaxed problem Relaxed problem: Problem with fewer restrictions on the actions Optimal solution to the relaxed problem may be computed easily (without search) The cost of an optimal solution to a relaxed problem is an admissible heuristic for the original problem The optimal solution is the shortest path in the super-graph of the statespace. 115

112 Relaxed problem: 8-puzzle 8-Puzzle: move a tile from square A to B if A is adjacent (left, right, above, below) to B and B is blank Relaxed problems 1) can move from A to B if A is adjacent to B (ignore whether or not position is blank) 2) can move from A to B if B is blank (ignore adjacency) 3) can move from A to B (ignore both conditions) Admissible heuristics for original problem (h 1 (n) and h 2 (n)) are optimal path costs for relaxed problems First case: a tile can move to any adjacent square h 2 (n) Third case: a tile can move anywhere h 1 (n) 116

113 Sub-problem heuristic The cost to solve a sub-problem Store exact solution costs for every possible sub-problem Admissible? The cost of the optimal solution to this problem is a lower bound on the cost of the complete problem 117

114 Pattern databases heuristics Storing the exact solution cost for every possible subproblem instance Combination (taking maximum) of heuristics resulted by different sub-problems 15-Puzzle: 10 3 times reduction in no. of generated nodes vs. h 2 118

115 Disjoint pattern databases Adding these pattern-database heuristics yields an admissible heuristic?! Dividing up the problem such that each move affects only one sub-problem (disjoint sub-problems) and then adding heuristics 15-puzzle: 10 4 times reduction in no. of generated nodes vs. h 2 24-Puzzle: 10 6 times reduction in no. of generated nodes vs. h 2 Can Rubik s cube be divided up to disjoint sub-problems? 119

116 Learning heuristics from experience Machine Learning Techniques Learn h(n) from samples of optimally solved problems (predicting solution cost for other states) Features of state (instead of raw state description) 8-puzzle number of misplaced tiles number of adjacent pairs of tiles that are not adjacent in the goal state Linear Combination of features 120

117 A* difficulties Space is the main problem of A* Overcoming space problem while retaining completeness and optimality IDA*, RBFS, MA*, SMA* A* time complexity Variants of A* trying to find suboptimal solutions quickly More accurate but not strictly admissible heuristics 121