Outline

• Problem Solving Agents
• Problem Solving via Depth First Search
• Problem Solving via Breadth First Search
• In-class Exercise
• Iterative Deepening
• Bi-directional Search
• `A^star`-search

Problem Solving Agents

• Last day, we talked about different kinds agents to solve AI problems.
• We are now going to look at a particular kind of goal-based agent, called a problem-solving agent, in more detail.
• Problem solving agents use atomic representations for the environment, that is, states of the world are considered as whole, with no internal structure to the problem solving algorithm.
• Goal-based agents that use more advanced factored or structured representations are called planning agents.
• Basically, problem solving agents consider different sequences of actions until they find one that achieves the desired goal. For example, one might have a game and the goal of a monster in the game is to get from where it is to where the trapped player is. However, there are obstacles in between the monster can't go through. The monster might consider several potential paths until it finds one that works.
• The process of looking over sequences of actions is called search.
• A solution is an action sequence that achieves the goal.
• To discuss problem solving we want to make precise the notion of problems and their solutions.

A Problem

• An initial state.
• A set of possible actions.
• A successor function which maps an action and a state to a new state. (state space)
• A goal test (to check if problem is solved).
• A cost associated with performing a given action. This cost of a single action induces a cost associated with a path in the state space. (A path is a sequence of (action, states)).

Examples -- 8 Puzzle

• States -- description of the location of each of 8 tiles.
• The initial state -- the position we want to solve from
• The successor function -- says how the hole can be moved.
• Goal Test -- Does the board look like (final solution)
• Path Cost- 1 for each move of hole in path.

Examples -- 8-Queens Problem

• States -- any arrangement of 0 to 8 queens on a chess board.
• Initial State -- no queens on the board.
• Successor function -- add a queen to an empty square.
• Goal Test -- 8 queens on the board none attacking each other.

Above state space could be as large as 64 x 63 x 62 x 61 x 60 x 59 x 58 x 57

Can reduce search space by requiring newly placed queens not to be attack-able by existing queens. (2,057 possible)

In-Class Exercise

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.

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)`.