1. G5BAIM Artificial Intelligence Methods
Graham Kendall
Searching

2. Initial State Operator
Problem Definition - 1
Initial State
The initial state of the problem, defined in some suitable manner
Operator
A set of actions that moves the problem from one state to another

3. Neighbourhood (Successor Function)
Problem Definition - 1
Neighbourhood (Successor Function)
The set of all possible states reachable from a given state
State Space
The set of all states reachable from the initial state

4. Problem Definition - 2
Goal Test
A test applied to a state which returns if we have reached a state that solves the problem
Path Cost
How much it costs to take a particular path

5. Problem Definition - Example5 4 6 1 8 7 3 2 1 4 7 2 5 8 3 6 1 2 3 4 5 6 7 8 1 2 3 8 4 7 6 5
Initial State
Goal State

6. Problem Definition - Example
States
A description of each of the eight tiles in each location that it can occupy. It is also useful to include the blank
Operators
The blank moves left, right, up or down

7. Problem Definition - Example
Goal Test
The current state matches a certain state (e.g. one of the ones shown on previous slide)
Path Cost
Each move of the blank costs 1

8. Problem Definition - Datatype
Datatype PROBLEM
Components
INITIAL-STATE,
OPERATORS,
GOAL-TEST,
PATH-COST-FUNCTION

9. Does our search method actually find a solution?
How Good is a Solution?
Does our search method actually find a solution?
Is it a good solution?
Path Cost
Search Cost (Time and Memory)
Does it find the optimal solution?
But what is optimal?

10. Completeness Time Complexity
Evaluating a Search
Completeness
Is the strategy guaranteed to find a solution?
Time Complexity
How long does it take to find a solution?

11. Space Complexity Optimality
Evaluating a Search
Space Complexity
How much memory does it take to perform the search?
Optimality
Does the strategy find the optimal solution where there are several solutions?

12. Search Trees x o
………..

13. ISSUES Search trees grow very quickly
The size of the search tree is governed by the branching factor
Even this simple game has a complete search tree of 984,410 potential nodes
The search tree for chess has a branching factor of about 35

14. Implementing a Search - What we need to store
State
This represents the state in the state space to which this node corresponds
Parent-Node
This points to the node that generated this node. In a data structure representing a tree it is usual to call this the parent node

15. Implementing a Search - What we need to store
Operator
The operator that was applied to generate this node
Depth
The number of nodes from the root (i.e. the depth)
Path-Cost
The path cost from the initial state to this node

16. Implementing a Search - Datatype
Datatype node
Components:
STATE,
PARENT-NODE,
OPERATOR,
DEPTH,
PATH-COST

17. Using a Tree – The Obvious Solution?
Advantages
It’s intuitive
Parent’s are automatically catered for

18. Using a Tree – The Obvious Solution?
But
It can be wasteful on space
It can be difficult the implement, particularly if there are varying number of children (as in tic-tac-toe)
It is not always obvious which node to expand next. We may have to search the tree looking for the best leaf node (sometimes called the fringe or frontier nodes). This can obviously be computationally expensive

19. Using a Tree – Maybe not so obvious
Therefore
It would be nice to have a “simpler” data structure to represent our tree
And it would be nice if the next node to be expanded was an O(1) operation

20. Basic Queue Operations
Make-Queue(Elements)
Create a queue with the given elements
Empty?(Queue)
Returns true if the queue is empty
Remove-Front(Queue)
Removes the element at the head of the queue and returns it

21. Queue Operations - Adding Elements
Queuing-FN(Elements,Queue)
Inserts a set of elements into the queue. Different queuing functions produce different search algorithms.

22. End Function General Search
Function GENERAL-SEARCH(problem, QUEUING-FN) returns a solution or failure
nodes = MAKE-QUEUE(MAKE-NODE(INITIAL-STATE[problem]))
Loop do
If nodes is empty then return failure
node = REMOVE-FRONT(nodes)
If GOAL-TEST[problem] applied to STATE(node) succeeds then return node
nodes = QUEUING-FN(nodes,EXPAND(node,OPERATORS[problem]))
End
End Function

23. nodes = MAKE-QUEUE(MAKE-NODE(INITIAL-STATE[problem]))
General Search
Function GENERAL-SEARCH(problem, QUEUING-FN) returns a solution or failure
nodes = MAKE-QUEUE(MAKE-NODE(INITIAL-STATE[problem]))
Loop do
If nodes is empty then return failure
node = REMOVE-FRONT(nodes)
If GOAL-TEST[problem] applied to STATE(node) succeeds then return node
nodes = QUEUING-FN(nodes,EXPAND(node,OPERATORS[problem]))
End
End Function

24. General Search Loop do End
Function GENERAL-SEARCH(problem, QUEUING-FN) returns a solution or failure
nodes = MAKE-QUEUE(MAKE-NODE(INITIAL-STATE[problem]))
Loop do
If nodes is empty then return failure
node = REMOVE-FRONT(nodes)
If GOAL-TEST[problem] applied to STATE(node) succeeds then return node
nodes = QUEUING-FN(nodes,EXPAND(node,OPERATORS[problem]))
End
End Function

25. If nodes is empty then return failure
General Search
Function GENERAL-SEARCH(problem, QUEUING-FN) returns a solution or failure
nodes = MAKE-QUEUE(MAKE-NODE(INITIAL-STATE[problem]))
Loop do
If nodes is empty then return failure
node = REMOVE-FRONT(nodes)
If GOAL-TEST[problem] applied to STATE(node) succeeds then return node
nodes = QUEUING-FN(nodes,EXPAND(node,OPERATORS[problem]))
End
End Function

26. node = REMOVE-FRONT(nodes)
General Search
Function GENERAL-SEARCH(problem, QUEUING-FN) returns a solution or failure
nodes = MAKE-QUEUE(MAKE-NODE(INITIAL-STATE[problem]))
Loop do
If nodes is empty then return failure
node = REMOVE-FRONT(nodes)
If GOAL-TEST[problem] applied to STATE(node) succeeds then return node
nodes = QUEUING-FN(nodes,EXPAND(node,OPERATORS[problem]))
End
End Function

27. If GOAL-TEST[problem] applied to STATE(node) succeeds then return node
General Search
Function GENERAL-SEARCH(problem, QUEUING-FN) returns a solution or failure
nodes = MAKE-QUEUE(MAKE-NODE(INITIAL-STATE[problem]))
Loop do
If nodes is empty then return failure
node = REMOVE-FRONT(nodes)
If GOAL-TEST[problem] applied to STATE(node) succeeds then return node
nodes = QUEUING-FN(nodes,EXPAND(node,OPERATORS[problem]))
End
End Function

28. nodes = QUEUING-FN(nodes,EXPAND(node,OPERATORS[problem]))
General Search
Function GENERAL-SEARCH(problem, QUEUING-FN) returns a solution or failure
nodes = MAKE-QUEUE(MAKE-NODE(INITIAL-STATE[problem]))
Loop do
If nodes is empty then return failure
node = REMOVE-FRONT(nodes)
If GOAL-TEST[problem] applied to STATE(node) succeeds then return node
nodes = QUEUING-FN(nodes,EXPAND(node,OPERATORS[problem]))
End
End Function

29. G5BAIM Artificial Intelligence Methods
Graham Kendall
End of Searching