Outline

• Searching for Solutions
• Quiz
• Uninformed and Informed Search
• Depth-first, Breadth First, Uniform-cost, Iterative Deepening Search.
• `A^\star`-search

Introduction

• Last week, we began our study of AI by defining the notion of agent -- anything that can be viewed as perceiving its environment through sensors and acting upon that environment through actuators.
• We said an agent is rational if for each possible percept sequence, the agent always selects an action that is expected to maximize its performance measure, given the evidence provided by the percept sequence and whatever built-in knowledge it has.
• In order to come up with algorithms for agents, we need to specify their task environment, which we said we'd do use the PEAS framework. That is, we specify: a Performance measure, the Environment the agent acts in, the Actuators the agent has, and the Sensors the agent has.
• We defined several terms which can be applied to task environments: Fully observable vs partially observable, Single agent versus multiagent, etc.
• We also look at several kinds of agent programs: table-driven, simple reflex agents, model-based agents, goal-based agents, and utility-based agents.
• We said goal-based agents can be distinguished by whether items in the domain are made up of parts (factored), or if the items in the domain have fixed number of discrete values (unfactored). We said agents in the former setting are called planning agents, and in the latter, problem solving agents.
• We focused our attention on problem solving agents, and said how to formally define a problem: Give initial state, give a list of possible actions the agent can do, give a successor function that maps state and action to new state, give a goal test that indicates if the goal is met, and associate a cost to each action.
• We said a solution to such a problem is a path (sequence of actions) from the initial state to a state passes the goal test.
• We start today by looking at search algorithms to find such solution paths for problems.

Searching for Solutions

• A solution to a search problem is an action sequence that takes the agent from the initial state to a goal state.
• We use the problem specification to define a search tree:
  • The root of the tree is the initial state.
  • The edges/branches in our tree are labeled with actions.
  • The nodes/vertices in our tree correspond to states in the state space.
• We typically imagine this tree as not given to us in toto. Instead, we start with the tree being just the root. We apply the goal test. If it satisfies the goal, we're done and we output the sequence of actions so far. If not, we expand the node we are working with. This involves applying each legal action to the current state and generating a set of new states. Then one picks from the tree a node (possible one of these child nodes) that has not been expanded to consider further.
• A node with no children in this tree is called a leaf.
• The set of all leaf nodes is called the frontier or open list.
• A search strategy is a method for choosing a node on the frontier to consider next.

Loops

• Suppose we have a King in the bottom left hand corner (A1) of an otherwise unoccupied chess board.
• Our goal is to move the King to the top right hand corner (H8).
• Applying the goal test to A1 we see the square is not labeled (H8), so we expand the node.
• This gives us the search tree consisting of A1 with children/frontier (B1), (B2), (A2).
• If we pick (B1) to expand next we get the tree A1[B1[A1, A2, B2, C1, C2], B2, A2]
• Notice A1, A2, B2 are repeated. They are so-called repeated states.
• If we expand a repeated state we could end up on loopy path, and never end up at our goal of H8.
• Loopy paths are a special case of a more general problem which are two paths that go to the same state (redundant paths).
• To avoid this problem, any reasonable search algorithm, maintains in addition to a frontier list, a closed list also known as an explored set of all states it has already seen.

Ways of Measuring our Search Strategy

We would like to come up with means of distinguishing which is better amongst different possible search strategies. Some axes of comparison are:

• Completeness: Is the algorithm guaranteed to find a solution when there is one?
• Optimality: Does the strategy find the optimal solution? (For example, a shortest path in the case of the chess problem we just described.)
• Time Complexity: How long does it take to find a solution?
• Space Complexity: How much memory is needed to perform the search?
• Time and space complexity are often measured in terms of the depth `d` of the smallest goal state in the search tree as well as the maximum branching factor `b` of expanding a node.

Quiz

Which of the following is true?

1. According to the syllabus Quizzes are worth 2pts each.
2. All cards games are known task environments.
3. Any simple reflex agent could be implemented as a table driven agent.

Informed and Uninformed Search

• Search algorithms can be classified into two main categories: informed and uninformed.
• In uninformed search, the search strategy is not allowed to use any information about states beyond that provided in the problem definition. The algorithm is only allowed to generate successors and distinguish a goal state from a non-goal state.
• If a strategy uses some additional information, it is called an informed search strategy.
• We next look at some examples of uninformed search strategies.

Uninformed Search Strategies

• Depth First Search (DFS) -- always expand left most node that still can be expanded. (Charles Pierre Tremaux, described by Edouard Lucas 1882)
• Breadth First Search (BFS) -- expand root, then expand all children of root until reach goal. (Moore 1959 and Lee 1961)
• Uniform Cost Search (UCS) -- this is a generalization of BFS to the case where the costs of each action is its own rational number protentially different from 1. In this kind of search we expand the node on the frontier whose path cost from the root is the least. (Dijkstra 1959)

Performance of DFS and BFS

• Let's consider the king on the chess board problem again, but let the chess board now be infinite in the up and right directions.
• Pick some fixed square (maybe H8, maybe some other square) as the goal state.
• In terms of our different means of measuring the performance of these algorithms, notice if the goal state was H8 and if depth first search was used, our agent may never find H8. It would could move A1, A2, A3, A4, ... So DFS is incomplete.
• How much memory does DFS use? Notice DFS only needs to keep track of the branch from the root it is on. So it takes O(d) space.
• Suppose we allowed the goal to be either the square H1 or the square A9. In this case, DFS finds a goal, but it does not find the shortest one, so it is not optimal.
• On the other hand, BFS is complete. It also will find H1 rather than A9 so it is optimal.
• Unfortunately, both its time and space complexity are `b + b^2+ ... + b^d = Omega(b^d)`. So if the goal was A100, BFS would take `Omega(8^100)` time -- way too long.
• If `epsilon` is the least cost of an action and `C^star` is the least cost goal, one can show UCS has time and space complexity `O(b^(1+C^star/epsilon))`.
• Is there are way to get the best of both world the DFS and BFS worlds?

Iterative Deepening Depth-First Search

• Let `DFS(n)` denote running the depth first search algorithm on the search tree restricted to depth n.
• i.e., This algorithm first considers the leftmost branch of depth `n`, the next to leftmost branch of depth n, and so on.
• It stops if along any of these branches it finds a goal.
• This algorithm has space complexity `O(n)` and time complexity `O(b^n)`.
• It is, of course, not complete.
• Now consider the algorithm which operates as follows. It checks if DFS(1) finds a solution, if not it runs DFS(2), if not it runs DFS(3) and so on...
• This is called iterative deepening depth-first search (when I'm lazy... iterative deepening search or IDS). (Korf 1985, although variants date back earlier)
• Notice if there is a goal of depth less than `n`, then `DFS(n)` finds it, and so does `IDS`.
• The space complexity IDS needs if the goal was at depth `n` is `O(n)`.
• What is the time complexity?
  TIME(DFS(1)) + ... + TIME(DFS(n))
  `O(b) + cdots + O(b^n) = O(b^(n+1))`.
• IDS can be generalized to the rational action costs setting, by doing DFS to cost `epsilon`, `2epsilon`, ... This is called iterative lengthening search.

Bidirectional Search (Pohl 1971)

• The idea of bidirectional search is that we run two simultaneous searches: one from the initial state and one from the goal state
• If we find a state that is common on the frontiers of these two searches then we stop.
• Notice if the depth of the goal is `d`, then this involves two searches of to depth `d/2`.
• If we use BFS to do these searches, then the time complexity will be `O(b^(d/2))` which is much smaller than `O(b^d)`.

Informed Search Strategies

• We now want to consider search strategies where one has problem specific knowledge.
• Here the node we select for expansion is chosen according to some evaluation function `f(n)`.
• In a Best-First-Search we assume `f(n)` is a cost and always expands node for which `f(n)` is smallest.
• The question is how to choose `f`?
• A key component of `f` is usually some heuristic function, `h(n)` where this is an estimate of the cost from a given node `n` to the goal.