AI Solving Problems- Knowledge Representation plus Search
Revision of some concepts
Substitution: An assignment of a constant, functional expression or variable to the variables in a given expression. Instance: the form an expression takes after a substitution has been applied to it. E. g. The substitution {X=mary,Y=W} applied to the clause: grandparent(X,Y):- parent(X,Z), parent(Z,Y). yields the clause instance: grandparent(mary,Y):- parent(X,Z), parent(Z,W).
2
Revision (cont.)
Resolvent of a rule and a query: new query obtained by unifying the head of the rule with the first subgoal in the query, and retaining all other predicates affected by the substitution used to unify.
?- grandparent(mary,W). {X=mary, Y=W} grandparent(X,Y):parent(X,Z), parent(Z,Y).
?- parent(mary,Z), parent(Z,W).
3
Revision: Backtracking
Consider a query: ?- p(X), q(Y), r(X,Y). Backtracking goes back to the first subgoal that can try a different (as yet untried) value for a variable. So if the program is: p(1). p(2). q(a). ..... q(z). r(2,b). for X=1, all 26 possible values of Y will be tried before backtracking to p/1. For each, r(1,Y) fails, but Prolog's search is exhaustive, cannot intelligently backtrack to the variable whose current value causes the failure.
4
Revision: backtracking
For our expert system:
woman(eve). woman(claire). compatible(eve,adam). man(tom). man(adam).
match(X,Y):- woman(X), man(Y), compatible(X,Y). go:- match(eve,X), write(X), nl, fail.
The query ?- go. binds X=eve and Y=tom before failing, upon which Prolog backtracks to man(Y) (the first subgoal that can try a different value for Y), and tries Y=adam.5
This is what the trace looks like
?- trace | ?- go. 1 2 3 3 4 ? 4 5 5 4 4 6 6 2 7 7 1 Call: go ? 2 Call: match(eve,_926) ? 3 Call: woman(eve) ? 3 Exit: woman(eve) ? 3 Call: man(_926) ? 3 Exit: man(tom) ? 3 Call: compatible(eve,tom) ? 3 Fail: compatible(eve,tom) ? 3 Redo: man(tom) ? 3 Exit: man(adam) ? 3 Call: compatible(eve,adam) ? 3 Exit: compatible(eve,adam) ? 2 Exit: match(eve,adam) ? 2 Call: write(adam) ? 2 Exit: write(adam) ? adam
6
Readings from the textbook
Structures and Strategies for State Space Search:
Introduction Graph Theory Strategies for State Space Search: up to Depth-First Search with Iterative Deepening included
Heuristic Search
Introduction The Best-First Search Algorithm Admissibility, Monotonicity, Informedness Complexity Issues
7
How do we go about having computers solve AI problems ?
We need:
a convenient way to represent the information relevant to the problem to be solved a procedure to search for a solution from the representation given
A first AI paradigm: KNOWLEDGE REPRESENTATION + SEARCH
8
Importance of a good representation
Not all possible representations of the same problem will lend themselves to good solutions of it. Example 1- Hanoi towers Example 2- Konigsberg bridges- illustrates the power of graph theory to analyze the structure and complexity of some problems.
9
Problem Solving as Graph Search
similar to some kinds of human problemsolving- e.g., possible moves in a chess game. We need:
1. an initial state(s) (e.g. empty board) 2. operations to change one state into another 3. final state(s)
These define a state space graph to be searched: solutions are found by finding a path between an initial state and a final state in the graph.
10
How to search
exhaustively: through the entire search space (called uninformed search) heuristically: using judgmental rules that guide our search to those portions of the state space that seem "promising" (called informed or heuristic search)
11
Problem Solving as Graph Search
Example: flip two adjacent tiles of same colour (flipping changes red to blue and viceversa) until you get four blue tiles, starting from the configuration rbbr (b=blue, r=red) Initial state= r b b r Final state= b b b b Operations= b b -> r r r r -> b b State Graph= ? Any loops in it? Possible heuristics? Give preference to 2nd rule
12
A direct correspondence: graph formulations/ Prolog formulations
For our example: Initial state as a fact= state([r,b, b, r]). Final state as a query= ?- state([b, b, b, b]). Operations as rules= state([S1,S1,Z,W]):- state([S,S,Z,W]), flip(S,S1). state([Z,S1,S1,W]):- state([Z,S,S,W]), flip(S,S1). state([Z,W,S1,S1]):- state([Z,W,S,S]), flip(S,S1). State Graph= automatically generated Will it loop? Search Strategy= top-down, left-to-right w/backtracking Possible heuristics? Place flippings into blue first: flip(r,b). flip(b,r).
13
For our example: (problem dependent parts in violet) Initial and final states as parameters in a query to solve/3: ?- solve([r,b, b, r], [b, b, b, b],Path). Operations as rules= s([S1,S1,Z,W], [S,S,Z,W]):flip(S,S1). s ([Z,S1,S1,W],[Z,S,S,W]):flip(S,S1). s ([Z,W,S1,S1],[Z,W,S,S]):flip(S,S1). State Graph determined by the general procedure = solve(N,Goal,[N|Path]):- solve(G,G,[G]). s(N,N1), solve(N1,Goal,Path). Search Strategy= top-down, left-to-right w/backtracking Possible heuristics? Place flippings into blue first: flip(r,b). flip(b,r).
Recording the path from initial to goal nodes: more general
14
Avoiding loops
We keep track of the path so far and check that the state we're about to move into has not occurred already in the path: Initial and final states as before: ?- solve([r,b, b, r], [b, b, b, b],Path). A technicality: initialize the path so far to [[r,b,b,r]]: solve(Initial,Final,Path):- solve1(Initial,Final,[Initial],Path). Operations as before; State graph determined by: solve1(State,State,Path,Path). solve1(State,Sf,Psofar,P):-s(State,S2), not(member(S2,Psofar)), solve1(S2,Sf,[S2|Psofar],P). State Graph= automatically generated. Build it by hand! Search Strategy= top-down, left-to-right w/backtracking Possible heuristics?Give preference to changes into blue: 15 flip(r,b). flip(b,r).
State Space Search: more formally
[N,A,S,GS] where N are the nodes, or states in the graph, A are the arcs, or links between nodes in the graph, S is (are) the start node(s), and GS is (are) the goal state(s) or node(s). A solution path is a path through the graph from a node in S to a node in GS. Example for practice: formulate the following blocks world problem in terms of state space search: c a a --> b b c
16
Homework
write a Prolog definition for the predicate reverse(L,L1) which should succeed with L1 being the reverse of list L, e.g. ?- reverse([a,b,c],R). R= [c,b,a] yes Modify the definition of solve/4 so the path obtained is ordered from the initial state to the final, as we would expect. Test all predicates. If no definition of member/2 is available, use: member(X,[X|_). member(X,[_|L]):- member(X,L).
17
Further examples
Eight queens problem: place 8 queens in an 8 by 8 chessboard so that none attacks any other Tic-tac-toe The 8-puzzle Traveling salesman
18
To determine a search strategy
Determine a search direction: either
forward-chaining: from facts and rules, derive a goal backward-chaining: from goal and rules, derive the facts
Determine the order for examining nodes: with left-to-right or right-to-left (decide which), either:
depth first: consider siblings only when no further descendant can be found breadth first: examine al nodes at level n before proceeding to level n+1
19
Choice of search direction affects search complexity
Branching factor: number of states generated on average in each direction (forward- vs. backward-) Example- To prove that Marie Curie is my ancestor:
ancestor(X,Y):- parent(X,Y). ancestor(X,Y):- parent(X,Z), ancestor(Z,Y). ?- ancestor(marie_curie,X), X=veronica. % forward ?- ancestor(A,veronica), A=marie_curie. % backward
In forward-chaining mode (from Marie Curie to Veronica), with 3 children average, across 5 generations, there's an average of 35 nodes to chec...