Building Goal-Based Agents

1. What is the goal to be achieved?

   Could describe a situation we want to achieve, a set of properties that we want to hold, etc. Requires defining a "goal test" so that we know what it means to have achieved/satisfied our goal.

   This is a hard part that is rarely tackled in AI, usually assuming that the system designer or user will specify the goal to be achieved. Certainly psychologists and motivational speakers always stress the importance of people establishing clear goals for themselves as the first step towards solving a problem. What are your goals???

2. What are the actions?

   Quantify all of the primitive actions or events that are sufficient to describe all necessary changes in solving a task/goal. No uncertainty associated with what an action does to the world. That is, given an action (also called an operator or move) and a description of the current state of the world, the action completely specifies (1) if that action CAN be applied to the current world (i.e., is it applicable and legal), and (2) what the exact state of the world will be after the action is performed in the current world (i.e., we don't need any "history" information to be able to compute what the new world looks like).

   Note also that actions can all be considered as discrete events that can be thought of as occurring at an instant of time. That is, the world is in one situation, then an action occurs and the world is now in a new situation. For example, if "Mary is in class" and then performs the action "go home," then in the next situation she is "at home." There is no representation of a point in time where she is neither in class nor at home (i.e., in the state of "going home").

   The number of operators needed depends on the representation used in describing a state (see below). For example, in the 8-puzzle, we could specify 4 possible moves for each of the 8 tiles, resulting in a total of 4*8=32 operators. On the other hand, we could specify four moves for the "blank" square and there would need to be only 4 operators.

3. What information is necessary to encode about the the world to sufficiently describe all relevant aspects to solving the goal? That is, what knowledge needs to be represented in a state description to adequately describe the current state or situation of the world?

   The size of a problem is usually described in terms of the number of states that are possible. For example, in Tic-Tac-Toe there are about 3^9 states. In Checkers there are about 10^40 states. Rubik's Cube has about 10^19 states. Chess has about 10^120 states in a typical game.

   We will use the Closed World Assumption: All necessary information about a problem domain is available in each percept so that each state is a complete description of the world. There is no incomplete information at any point in time.

   What's in a state is the knowledge representation problem. That is, we must decide what information from the raw percept data is relevant to keep, and what form the data should be represented in so as to make explicit the most important features of the data for solving the goal. Is the color of the boat relevant to solving the Missionaries and Cannibals problem? Is sunspot activity relevant to predicting the stock market? What to represent is a very hard problem that is usually left to the system designer to specify. How to represent domain knowledge is a topic that will be treated later in the course.

   Related to this is the issue of what level of abstraction or detail to describe the world. Too fine-grained and we'll "miss the forest for the trees." Too coarse-grained and we'll miss critical details for solving the problem.

   The number of states depends on the representation and level of abstraction chosen. For example, in the Remove-5-Sticks problem, if we represent the individual sticks, then there are 17-choose-5 possible ways of removing 5 sticks. On the other hand, if we represent the "squares" defined by 4 sticks, then there are 6 squares initially and we must remove 3 squares, so only 6-choose-3 ways of removing 3 squares.

Examples

• 8-Puzzle
  Given an initial configuration of 8 numbered tiles on a 3 x 3 board, move the tiles in such a way so as to produce a desired goal configuration of the tiles. State = 3 x 3 array configuration of the tiles on the board. Operators: Move Blank square Left, Right, Up or Down. (Note: this is a more efficient encoding of the operators than one in which each of four possible moves for each of the 8 distinct tiles is used.) Initial State: A particular configuration of the board. Goal: A particular configuration of the board.

• Missionaries and Cannibals
  There are 3 missionaries, 3 cannibals, and 1 boat that can carry up to two people on one side of a river. Goal: Move all the missionaries and cannibals across the river. Constraint: Missionaries can never be outnumbered by cannibals on either side of the river, or else the missionaries are killed. State = configuration of missionaries and cannibals and boat on each side of the river. Operators: Move boat containing some set of occupants across the river (in either direction) to the other side.

• Cryptarithmetic
  Find an assignment of digits (0, ..., 9) to letters so that a given arithmetic expression is true. For example, SEND + MORE = MONEY Note: In this problem, unlike the two above, the solution is NOT a sequence of actions that transforms the initial state into the goal state, but rather the solution is simply finding a goal node that includes an assignment of digits to each of the distinct letters in the given problem.

• Remove 5 Sticks
  Given the following configuration of sticks, remove exactly 5 sticks in such a way that the remaining configuration forms exactly 3 squares.

   - -
  | | |
   - -
  | | |
   - -
  | | |
   - -
  

• Water Jug Problem
  Given a 5-gallon jug and a 2-gallon jug, with the 5-gallon jug initially full of water and the 2-gallon jug empty, the goal is to fill the 2-gallon jug with exactly one gallon of water.
  • State = (x,y), where x = number of gallons of water in the 5-gallon jug and y is gallons in the 2-gallon jug
  • Initial State = (5,0)
  • Goal State = (*,1), where * means any amount
  • Operators
    • (x,y) -> (0,y) ; empty 5-gal jug
    • (x,y) -> (x,0) ; empty 2-gal jug
    • (x,2) and x<=3 -> (x+2,0) ; pour 2-gal into 5-gal
    • (x,0) and x>=2 -> (x-2,2) ; pour 5-gal into 2-gal
    • (1,0) -> (0,1) ; empty 5-gal into 2-gal
  • State Space (also called the Problem Space)

                         (5,0) = Start
    		     /  \
                     (3,2)  (0,0)
                      / \
                  (3,0) (0,2)
                   /
               (1,2)
                /
            (1,0)
    	 /
         (0,1) = Goal
    

Formalizing Search in a State Space

• A state space is a graph, (V, E), where V is a set of nodes and E is a set of arcs, where each arc is directed from a node to another node

• Each node is a data structure that contains a state description plus other information such as the parent of the node, the name of the operator that generated the node from that parent, and other bookkeeping data

• Each arc corresponds to an instance of one of the operators. When the operator is applied to the state associated with the arc's source node, then the resulting state is the state associated with the arc's destination node

• Each arc has a fixed, positive cost associated with it corresponding to the cost of the operator

• Each node has a set of successor nodes corresponding to all of the legal operators that can be applied at the source node's state. The process of expanding a node means to generate all of the successor nodes and add them and their associated arcs to the state-space graph

• One or more nodes are designated as start nodes

• A goal test predicate is applied to a state to determine if its associated node is a goal node

• A solution is a sequence of operators that is associated with a path in a state space from a start node to a goal node

• The cost of a solution is the sum of the arc costs on the solution path

• State-space search is the process of searching through a state space for a solution by making explicit a sufficient portion of an implicit state-space graph to include a goal node. Hence, initially V={S}, where S is the start node; when S is expanded, its successors are generated and those nodes are added to V and the associated arcs are added to E. This process continues until a goal node is found

• Each node implicitly or explicitly represents a partial solution path (and cost of the partial solution path) from the start node to the given node. In general, from this node there are many possible paths (and therefore solutions) that have this partial path as a prefix

State-Space Search Algorithm

function general-search(problem, QUEUEING-FUNCTION)
  ;; problem describes the start state, operators, goal test, and
  ;;   operator costs
  ;; queueing-function is a comparator function that ranks two states
  ;; general-search returns either a goal node or "failure"

  nodes = MAKE-QUEUE(MAKE-NODE(problem.INITIAL-STATE))
  loop
     if EMPTY(nodes) then return "failure"
     node = REMOVE-FRONT(nodes)
     if problem.GOAL-TEST(node.STATE) succeeds
	then return node
     nodes = QUEUEING-FUNCTION(nodes, EXPAND(node, problem.OPERATORS))
     ;; Note: The goal test is NOT done when nodes are generated
     ;; Note: This algorithm does not detect loops
  end

Key Procedures to be Defined

• EXPAND
  Generate all successor nodes of a given node

• GOAL-TEST
  Test if state satisfies all goal conditions

• QUEUEING-FUNCTION
  Used to maintain a ranked list of nodes that are candidates for expansion

Key Issues

• Search process constructs a search tree, where root is the initial state and all of the leaf nodes are nodes that have not yet been expanded (i.e., they are in the list "nodes") or are nodes that have no successors (i.e., they're "deadends" because no operators were applicable and yet they are not goals)

• Search tree may be infinite because of loops even if state space is small

• Return a path or a node depending on problem. E.g., in cryptarithmetic return a node; in 8-puzzle return a path

• Changing definition of the QUEUEING-FUNCTION leads to different search strategies

Evaluating Search Strategies

• Completeness
  Guarantees finding a solution whenever one exists

• Time Complexity
  How long (worst or average case) does it take to find a solution? Usually measured in terms of the number of nodes expanded. For an overview of "Big-Oh" notation used for measuring time (and space) complexity, see CS 577 notes on Big-Oh notation.

• Space Complexity
  How much space is used by the algorithm? Usually measured in terms of the maximum size that the "nodes" list becomes during the search.

• Optimality/Admissibility
  If a solution is found, is it guaranteed to be an optimal one? That is, is it the one with minimum cost?

Uninformed Search Strategies

• Breadth-First (BFS)
  
  • Enqueue nodes on nodes in FIFO (first-in, first-out) order. That is, nodes used as a queue data structure to order nodes.
  • Complete
  • Optimal (i.e., admissible) if all operators have the same cost. Otherwise, not optimal but finds solution with shortest path length.
  • Exponential time and space complexity, O(b^d), where d is the depth of the solution and b is the branching factor (i.e., number of children) at each node
  • Will take a long time to find solutions with a large number of steps because must look at all shorter length possibilities first
  • A complete search tree of depth d where each non-leaf node has b children, has a total of 1 + b + b^2 + ... + b^d = (b^(d+1) - 1)/(b-1) nodes
  • For a complete search tree of depth 12, where every node at depths 0, ..., 11 has 10 children and every node at depth 12 has 0 children, there are 1 + 10 + 100 + 1000 + ... + 10^12 = (10^13 - 1)/9 = O(10^12) nodes in the complete search tree. If BFS expands 1000 nodes/sec and each node uses 100 bytes of storage, then BFS will take 35 years to run in the worst case, and it will use 111 terabytes of memory!
• Depth-First (DFS)
  
  • Enqueue nodes on nodes in LIFO (last-in, first-out) order. That is, nodes used as a stack data structure to order nodes.
  • May not terminate without a "depth bound," i.e., cutting off search below a fixed depth D
  • Not complete (with or without cycle detection, and with or without a cutoff (depth boound) depth)
  • Exponential time, O(b^d), but only linear space, O(bd), required
  • Can find long solutions quickly if lucky
  • When search hits a deadend, can only back up one level at a time even if the "problem" occurs because of a bad operator choice near the top of the tree. Hence, only does "chronological backtracking"
• Uniform-Cost (UCS)
  
  • Enqueue nodes by path cost. That is, let g(n) = cost of the path from the start node to the current node n. Sort nodes by increasing value of g.
  • Called "Dijkstra's Algorithm" in the algorithms literature
  • Similar to "Branch and Bound Algorithm" in operations research literature
  • Complete
  • Optimal/Admissible
  • Admissibility depends on the goal test being applied when a node is removed from the nodes list, not when it's parent node is expanded and the node is first generated
  • Exponential time and space complexity, O(b^d)
• Depth-First Iterative Deepening (IDS)
  

  • c=1
    until solution found do
       DFS with depth bound (aka cutoff) c
       c = c+1

  • First do DFS to depth 1 (i.e., consider children of the start node to have no successors); then, if no solution found, do DFS to depth 2; etc.
  • Complete
  • Optimal/Admissible if all operators have the same cost. Otherwise, not optimal but does guarantee finding solution of shortest length (like BFS).
  • Time complexity is a little worse than BFS or DFS because nodes near the top of the search tree are generated multiple times, but because almost all of the nodes are near the bottom of a tree, the worst case time complexity is still exponential, O(b^d)
  • Example: If branching factor is b and solution is at depth d, then all nodes at depth d are generated at most once, all nodes at depth d-1 are generated at most twice, etc. Hence b^d + 2b^(d-1) + ... + db <= b^d / (1 - 1/b)^2 = O(b^d). If b=4, then worst case is 1.78 * 4^d. In other words 78% more nodes searched than exist at depth d (in the worst case).
  • Linear space complexity, O(bd), like DFS
  • Has advantage of BFS (i.e., completeness) and also advantages of DFS (i.e., limited space and finds longer paths more quickly)

Example Illustrating Uninformed Search Strategies

             S ... Initial State
            /|\
          1/ 5 \8
          /  |  \
         A   B   C
        /|\  |  / 
      3/ 7 9 4 /5  
      /  |  \|/
     D   E   G .... Goal State
    

• Depth-First Search: S A D E G
  Solution found: S A G

• Breadth-First Search: S A B C D E G
  Solution found: S A G

• Uniform-Cost Search: S A D B C E G
  Solution found: S B G
  This is the only uninformed search that worries about costs.

• Iterative-Deepening Search: S A B C S A D E G
  Solution found: S A G

    return GENERAL-SEARCH(problem, ENQUEUE-AT-FRONT) 

    return GENERAL-SEARCH(problem, ENQUEUE-AT-END) 

    return GENERAL-SEARCH(problem, ENQUEUE-BY-PATH-COST) 

Copyright © 1996-2003 by Charles R. Dyer. All rights reserved.