Chapter 1

Chapter 2Problem Solving by Searching (1)King Saud UniversityCollege of Computer and Information Sciences Information Technology DepartmentIT422 - Intelligent systems 1ObjectivesLearn how to formulate a search problem.

Learn the different algorithms used to solve problems by searching.

Learn how to assess the performance of a search algorithm.2IntroductionSolving a particular problem Need to define the elements of a problem and its solution.Before start searching for solutions, Identify the goal and Define the problem precisely.Isolate and represent the task knowledge that is necessary to solve the problem.Choose and apply the best problem solving technique(s) to the particular problem.

3Introduction: Problem solving as searchTask = SearchSearch is required to solve a wide range of problems.Search is a method that can be used by computers to examine a huge problem space to find a goal.e.g Searching for a contact lens on a football field Challenge: How to find the goal as quickly as possible or without using too many resources. 4Introduction: Problem solving as searchA problem can be considered to consist of a goal and a set of actions that can be taken to lead to the goalProblem: On holiday in Romania; currently in Arad. Flight leaves tomorrow from Bucharest. Find a short route to drive to Bucharest.

Task = finding the sequence of actions that lead to the desirable goal.

StartEnd5Introduction: Problem solving as searchToy problemsVacuum worldThe N-QueenRubik's cubeThe 8-PuzzleThe 8-puzzle belongs to the family of Sliding-block puzzles.The 8-puzzle has 9!/2=181,440 reachable states.The 15-puzzle has around 1.3 trillion states

Real world ProblemsTouring problems-Route Finding-Travelling salesperson-VLSI Layout-Robot navigation-Internet searching

6Introduction: Problem solving as searchSearch can be performed without any additional information about how to reach a solution: Blind Search (Uniformed search)

Search can be performed using heuristics: Informed Search

7Uninformed searchTo successfully operate, blind search should satisfy some properties:It must be complete: It must generate every possible solution otherwise it might miss a suitable solution.It must be able to find the best solution.8Uninformed searchKey questions to be addressed:What goal do we need to achieve?How to know when a goal is reached?What knowledge we need?What actions do we need to do?

A goal can be described as:A task to be accomplishedA situation to be reachedA set of properties to be acquired9Uninformed search: Basic conceptsState: configuration, situation, point

Problem formulation: Process of deciding what actions and states to consider given a goal.

Solution: Sequence of actions that help achieving the goal: a path from an initial state to the goal state .

Search: Process of looking for a solution. Takes input (problem) and returns solution.

Execution: To carry out the actions recommended by the solution

10Uninformed search: Problem formulationProblem formulation: a problem can be formally defined by:State representation: What information is necessary to encode to solve a problem. Initial state: starting point. s = In (Arad)Actions: A description of the possible actions that can be executed in a particular state.ACTIONS(s) = {Go(Sibiu),Go(Timisoara),Go(Zerind)}Transition model (Description of what each action does)RESULT (s,a) = sGoal test: determines whether a given state is a goal state.Path cost function: assigns a cost to each path. Should reflect the performance measure used to assess the quality of any solution.

1111Uninformed search: Problem formulationSuccessor function:Given a particular state x, RESULT(x,a) = (new state) where action is one of the legal actions in state x and new state is the successor state that can be reached from x by applying action.

The result function allows together with the initial state to define the state space.

STATE SPACE: The set of all states reachable from the initial state.(see AIMA 3rd Ed. page 67)

A path in the state space is a sequence of states connected by a sequence of actions.

12Uninformed search: Problem formulationMore about state space:A state space can be represented as a directed graph:where the nodes are states and the arcs between them are the actionse.g.: the Map of Romania in slide #5 (if we view each road as standing for two driving directions)

13Uninformed search: Problem formulationExample problem 1: The vacuum world

State representation: The agent is on one of two locations, each of which might or might not contain dirt. Thus, there are 2 x 22 = 8 possible world states.Initial state: Any state can be designated as the initial state.Actions: each state has just 3 actions: Left, Right, and Suck.Transition Model: Generates the legal states that result from applying the following actions: (Left, Right, Suck). Goal test: Check whether all the squares are clean.Path cost function: Each step costs 1. So the path cost is the number of steps.

14

Uninformed search: Problem formulationExample problem 1: The vacuum world state space as a graph

15

Uninformed search: Problem formulationIf the initial state is known, for simplicity, the state space can also be drawn as a tree.

We designate an initial state for the vacuum world:

16

Uninformed search: Problem formulationA tree is a directed acyclic graph all of whose nodes have at most one parent.A root of a tree is a node with no parents.A leaf is a node with no children.Graphs can be turned into trees by duplicating nodes and breaking cyclic paths, if any.To convert a graph into a tree:choose a root node trace every path from that node until you reach a leaf node (goal) or a node already in that path (Repeated State or R.S.)AGAIN, trees are used only for simplicity, i.e. if the problem is complex and it will be hard to draw it as a graph.17Uninformed search: Problem formulationVacuum world state space as a tree 18

LRSR.S.LRSLRS

R.S.

R.S.

R.S.

R.S.

LRSLRS

R.S.

R.S.

Goal State

R.S.

R.S.LRSGoal State

R.S.

R.S.What is the total number of unrepeated states?Uninformed search: Problem formulation

Solution definition: A potential solution is a path from the initial state to a goal state. Solution quality is measured by the path cost function.An optimal solution has the lowest path cost among all solutions.19Uninformed search: Problem formulationAn example of solution path:20 AradZerind SibiuTimisoaraOradeaFagarasRimnicu VilceaAradSibiuBucharestExample problem 2 - The Touring problem: Given a set of n cities, the touring problem consists in visiting cities at least once starting and ending in the same city.

States: Specified by the current city and the set of cities already visited.

Initial state: Any state can be designed as the initial state.

Actions: take a trip between adjacent cities.

Transition model (Successor function): Generates the next city to visit according to the current state.

Goal test: Ending city reached and all cities have been visited.

Path cost: Sum of all step costs.21Uninformed search: Problem formulationUninformed search: Searching for solutionsTo solve the problem, we need to define a search strategy that allows to explore efficiently the state space.

A solution is an action sequence.

The possible action sequences starting at the initial state form a search tree.

Each state is represented by a node.

Expansion operation: A node is expanded if the successor function for the corresponding state generates new states.22Uninformed search: Informal description23

Uninformed search: Towards a formal descriptionSearch algorithms require a data structure to keep track of the search tree.Node n definition: Data structure with 5 components:State: representation of a physical configuration. Parent node: The node in the search tree that generated this node.Action: action applied to the parent node to generate the node.Path cost: cost denoted by g(n), of the path from the initial state to the node n.Depth: The number of steps along the path from the initial state.24Parent nodeNode(State)ChildrenUninformed search: Towards a formal descriptionHow to deal with non expanded nodes?Frontier: set of nodes generated but not yet expanded. Each node is a leaf node.

What is the suitable representation of frontier?Set of nodes: Simplest way but could be computationally expensive.Queue: best implementation of the frontier.

25Uninformed search: Towards a formal descriptionWhat are the operations to be performed on the queue?Make-Node(state,parent,action,depth,cost): creates a node with the given parameters.Empty?(queue): returns TRUE only if there are no more nodes in the queue.First(queue) : returns the first node of the queue.Remove-First(queue): returns First(queue) and removes it from the queue.Insert(element, queue): inserts a node into the queue and returns the resulting queue.Insert-All(elements, queue): inserts a set of nodes into the queue and returns the resulting queue.26Uninformed search: Repeated statesProblem: Possibility of wasting time by expanding states that have already been encountered and expanded before.

Occurs when actions are reversible. (Example: move left, and move right)

A solvable problem can become unsolvable if the algorithm does not detect them systematically.

For detection purposes, a comparison operation is needed. Solution: keep a list to store every expanded node.27Uninformed search: Avoiding repeated states28

Uninformed search: Performance evaluationThe performance of problem solving algorithms can be evaluated along the following dimensions:

Completeness: is it guaranteed to find a solution when there is one?

Optimality: Does the strategy find the optimal solution (i.e., Has the lowest path cost among all solutions)?

Time complexity: how long does it take to find a solution? It can be measured by the number of generated nodes.

Space complexity: how much memory is needed to perform the search? It can be measured in terms of the maximum number of nodes stored in memory.

29Uninformed search: Performance evaluationComplexity for search on tree is expressed in terms of 3 quantities :

b: The branching factor: maximum number of successors of any node.

d: The depth of the shallowest goal node (i.e., the number of steps along the path from the root).

m: The maximum length of any path in the state space.

30Uninformed search: Basic strategiesBreadth First Search (BFS)

Depth First Search (DFS)

Depth Limited Search (DLS)

Uniform Cost Search (UCS)

Iterative Deepening Search (IDS)

Bidirectional search

31Uninformed search: Basic strategiesStrategies that order nodes without using any domain specific information (only problem definition is provided).

Generate successors and simply differentiate between a goal state and a non goal state.

Blind search strategies differ by the order of node expansion.

32Uninformed search: Breadth First SearchMain idea: Nodes at depth i are expanded before nodes at depth (i+1).Implementation: use of a First-In-First-Out queue (FIFO) for the frontier. Nodes visited first are expanded first.The goal test is applied to each node when it is generated rather then when it is selected for expansion.

Shallow nodes are expanded before deeper nodes.

33

Breadth-first search on a graphfunction BREADTH-FIRST-SEARCH(problem) returns a solution, or failurenode a node with STATE = problem.INITIAL-STATE, PATH-COST = 0if problem.GOAL-TEST(node.STATE) then return SOLUTION(node)frontier a FIFO queue with node as the only elementexplored an empty setloop doif EMPTY?( frontier) then return failurenodePOP( frontier ) /* chooses the shallowest node in frontier */add node.STATE to exploredfor each action in problem.ACTIONS(node.STATE) dochild CHILD-NODE(problem, node, action)if child .STATE is not in explored or frontier thenif problem.GOAL-TEST(child .STATE) then return SOLUTION(child )frontier INSERT(child , frontier )34Uninformed search: BFS evaluation35Completeness: Yes, if the branching factor b is finite.

Optimality: shallowest goal is not necessarily the optimal one. It is optimal if all actions have the same cost.

Time complexity: At the worst case, BFS expands every node (except goal node) thus taking time as follows: b+ + b2 + b3 +.+ bd = O(bd) If the goal test is applied to nodes when selected for expansion, rather then generated, the time complexity would be: 1+b+ + b2 + b3 +.+ bd = O(bd+1)

Memory complexity: BFS keeps every node in memory. Space is a big problem.Uninformed search: Depth First SearchDFS expands the deepest node in the current frontier on the search tree. DFS algorithm is an instance of the graph-search algorithm.As nodes are expanded, they are dropped from the frontier so then the search backs up to the next shallowest node that still has unexplored successors.DFS strategy is implemented using (LIFO) queue or stack (i.e., the most recently generated node is chosen for expansion).Another alternative is to implement DFS with a recursive function that calls itself on each of its children in turn.36Uninformed search: Depth First Search37

Uninformed search: DFS evaluationCompleteness: Incomplete in case of unbounded depth containing no solution.

Optimality: does not provide always optimal solutions.

Time complexity: At the worst case, DFS generates about O(bm) nodes in the search tree.

Memory complexity: DFS requires less memory than BFS. It needs to store only a single path from the root to a leaf node along with the remaining unexpanded sibling nodes for each node in the path. The required storage is O(bm) where b is the branching factor and m maximum depth.

38Uninformed search: Depth Limited Search It is simply DFS with a depth bound.

Searching is not permitted beyond the depth bound.

Works well if we know what the depth of the solution is.

Termination is guaranteed.

If the solution is beneath the depth bound, the search cannot find the goal (hence this search algorithm is incomplete).

Otherwise use Iterative deepening search (IDS).39Uninformed search: Iterative Deepening depth First Search 40

Uninformed search: IDS (cont.)Key idea: Iterative deepening search (IDS) applies DLS repeatedly with increasing depth. It terminates when a solution is found or no solutions exists.IDS combines the benefits of BFS and DFS: Like DFS the memory requirements are very modest (O(bd)). Like BFS, it is complete when the branching factor is finite. IDS is optimal when the step costs are all identical.

The time complexity: the total number of generated nodes is : N(IDS)=(d)b + (d-1) b2 + +(1)bd=O(bd)In general, iterative deepening is the preferred Uninformed search method when there is a large search space and the depth of the solution is not known.41Uninformed search: Uniform Cost Search In case of equal step costs, Breadth First search finds the optimal solution.

For any step-cost function, Uniform Cost search expands the node n with the lowest path cost.

UCS takes into account the total cost.

UCS is guided by path costs rather than depths. Nodes are ordered according to their path cost.

42UCS algorithm on a graph43

Uninformed search: UCS 44

Uninformed search: UCS 45

Uninformed search: UCS 46

Bidirectional SearchIdea: run 2 simultaneous searches. One forward from the initial state and the other backward from the goal. The hope target is that the 2 searches meet in the middle.Motivation: bd/2+ bd/2 < bdImplementation: check whether the frontiers of the 2 searches intersect rather than the goal test. If they do, a solution has been found (not necessarily an optimal one). 47

Bidirectional SearchThe check is done when each node is generated or selected for expansion and, with a hash table, will take constant time.Example: A problem has solution depth d=6Each direction runs BFS one node at a time. In the worst case they will meet when they have generated all of the nodes at depth 3.For b=10, total node generations=2220 compared with 1 111 110 for a standard BFS.Weakness: At least 1 of the 2 frontiers must be kept in memory.Bidirectional search is more attractive because the reduction of time complexity is significant. But how do we search backward? Some cases may require substantial ingenuity. 48Uninformed search: SummarySearch: process of constructing sequences of actions that achieve a goal given a problem.

Goal identification is the first step in solving problems by searching. It facilitates problem formulation.

Formulating a problem requires specifying 5 components: Initial state, a set of actions, a transition model describing the results of those actions, a goal test and path cost function. Environment is represented as a state space.

A solution is a path from the initial state to a goal state.

Search algorithms are judged on the basis of completeness, optimality, time complexity and space complexity.

Several search strategies, the basic algorithms are: BFS, DFS, DLS, IDS,UCS and Bidirectional search.49