Artificial Intelligence

Module 2: Automated Problem Solving

Module 2: Automated Problem Solving
• PART 2.1: Intelligent Agent & Environment
PART 2.3: Problem Representation in AI • PART 2.2: Complex Problems and AI
• PART 2.3: Problem Representation in AI
– Problem Solving Agents
• Intelligent Agent
– Problem Solving Methods
• Defining the problem as a State Space Search
Dr. Chandra Prakash
• Problem Decomposition
Assistant Professor
Department of Computer Science and Engineering
– Problem Formulation by AI Search Methods
• Modeling formulation of a problem to AI

(Slides adapted from StuartJ. Russell, B Ravindran, Mausam, Prof. Pallab Dasgupta, Prof. Partha Pratim Chakrabarti, Saikishor
Jangiti

Type of Agents Design an Agent for The Mars Rover Sojourner

• Step 1: Aim of the agent ????
• The 25-lb, 6-wheeled robotic explorer needs to
Simple reflex agents – travel on sandy, rocky terrain
– perceive its surroundings
Model-based reflex agents – drive autonomously for short distances
– communicate and transmit data
Goal-based agents
– be remotely controlled
Utility-based agents – be transported easily
– withstand extreme temperatures on Mars
– carry necessary equipments
– respond to events as they occur
– decide what to do next
 Step 2: Task Environment Problem Solving Agents
• Reflex agents cannot work well in those environments
– state/action mapping too large
– take too long to learn
• Problem-solving agent
– is one kind of goal-based agent
– decides what to do by finding sequences of actions that lead to desirable states
• Formulation
– Goal formulation (final state)
– Problem formulation (decide what actions and states to consider)
• Search (look for solution i.e. action sequence)
• Execution (follow states in solution)
• Assume the environment is static, observable, discrete, deterministic
Credit : Narayanan (CK) Chatapuram Krishnan

Intelligent Agent –Goal based We want

• Smart human :
– not only good in 1 problem but in other areas
• Our aim is to solve all type of problems in the world
• Automated Problem solving approach
• Generalized Techniques for
– Solving Large Classes of Complex Problems
– if not clear how to start/ proceed :
• Ask what is input and what is output

Intelligent agents may also learn or use knowledge to achieve their goals
 Problem solving agent : Pac-Man Search Problems

How to represent the environment/ world/ percepts for a problem ??

L2D3, replanning.
Figure out how to get to next dot.
Clears board; non-optimal. Fast.

Methods of Problem Representation in AI Defining the problem: State Space representation

• Before a solution can be found, the prime condition is that the problem must be • State Space
very precisely defined. – provide all possible state, operations and the goals.
• The most common methods of problem representation in AI are: – all information about the environment
1. State Space representation – All information necessary to make a decision for
• Includes the initial state S and all other states reachable from S by a the task at hand.
sequence of actions – If the entire state-space representation for a
2. Problem Reduction problem is given, it is possible to trace the path
from the initial state to the goal state and identify
• Whether the problem can be decomposed into smaller problems?
the sequence of operations necessary for doing it.
• Using the technique of problem decomposition, we can solve very large
– Limitation :
problems easily.
• not possible to visualize all states for a given
– Example for decomposable problems
problem.
» ∫( x2 +3x + Sin2x.Cos2x )dx
 Agent Classification in Terms of State Representations Spectrum of State Representations
Type State representation Focus
No internal structure Search on atomic
Atomic States are indivisible;
states;

States are made of state variables Search+inference in logical (prop logic)

Propositional
that take values (Propositional or and probabilistic (bayes nets)
(aka Factored)
Multi-valued or Continuous) representations

States describe the objects in the Search+Inference in predicate logic (or

Relational
world and their interrelations relational prob. Models)

Search+Inference in first order logic (or

First-order functions over objects
first order probabilistic models)

Illustration with Vacuum World Representing States

Atomic: Propositional/Factored: • State space:
S1, S2…. S8, Each state is
seen as an indivisible
States made up of 3 state variables – A state space can be organized as a graph:
snapshot Dirt-in-left-room T/F
Dirt-in-right-room T/F
• nodes: states in the space
All Actions are SXS matrices.
Roomba-in-room L/R • arcs: actions/operations
If you add a second roomba the state
space doubles
Each state is an assignment of Values to state • The size of a problem is usually described in terms of
variables
If you want to consider noisiness of the number of states (or the size of the state space) that
23 Different states
the rooms, the representation
Actions can just mention the variables they
are possible.
Quadruples.
affect • Tic-Tac-Toe has about 3^9 states.
Note that the representation is compact
Relational: (logarithmic in the size of the state space)
• Checkers has about 10^40 states.
World made of objects: Roomba; L-room, R-room If you add a second roomba, the • Chess has about 10^120 states in a typical game.
Relations: In (<robot>, <room>); dirty(<room>) representation increases by just one more state
If you add a second roomba, or more rooms, only the objects variable.
• Shannon number
increase.
If you want to consider “noisiness” of rooms,
If you want to consider noisiness, you just need to add one other
we need two variables, one for each room
relation
 Atomic Agent Representing States
• At any moment, the relevant world is represented as a state
• Input
– Initial (start) state: S
– Set of states
– Possible action (or an operation)
– Operators [ and cost]
• changes the current state to another state (if it is applied):
– Start state – State transition / Transition Model
– Goal state [Test] • An action can be taken (applicable) only if the its
• This is a hard part that is rarely tackled in AI, usually assuming that precondition is met by the current state
the system designer or user will specify the goal to be achieved. • For a given state, there might be more than one applicable
actions
– Goal state/ Goal Test :
• Output
• a state satisfies the goal description or passes the goal test
– Path : start => a state satisfying goal test
– Dead-end state:
– May require shortest path • a non-goal state to which no action is applicable

Formalizing Search in a State Space Problem Solving in AI

• A state space is a graph, (V, E) where • A process or procedure used to find out the solution to a specific problem.
– V is set of nodes and E is set of arcs • To build a system to solve a particular problem we need to do 4 things.
• Node: corresponds to a state 1. Define the problem precisely
• Arc: corresponds to an applicable action/operation. • This definition must include precise specifications of what the initial situations will
be as well as what the final situations constitute acceptable solution to the problem.
• node generation: making explicit a node by applying an action to
another node which has been made explicit 2. Analyze the problem
• A few important features of the problem can help in the selection of various
• node expansion: generate all children of an explicit node by
possible techniques for solving the problem.
applying all applicable operations to that node
3. Isolate and represent the task knowledge that is necessary to solve the problem
• One or more nodes are designated as start nodes
• A goal test predicate is applied to a node to determine if its
4. Choose the best problem-solving techniques and apply it to the particular problem.
associated state is a goal state
• A solution is a sequence of operations 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
 Problem Solving Stages Example : Pac-Man
1. Assumptions
2. Solution steps
3. State Space Representations
v Initial state
v Final state
v Operators that can be applied
v Abbreviations
v State space representation of the given problem
v Operators and Conditions.

24

Pac-Man Example : Search Problems Search Problems

• A search problem consists of: • A search problem consists of:

– A state space – A state space S

– An initial state s0
– Actions A(s) in each state
– A successor function “N”, 1.0 N -9
– Transition model Result(s,a)
• (with actions, costs) – A goal test G(s) E -9
• s has no dots left
“E”, 1.0
– A start state and a goal test – Action cost c(s,a,s’)
• +1 per step; -10 food; -500 win; +500 die; -200 eat ghost

• A solution is a sequence of actions (a plan) which transforms

the start state to a goal state • A solution is an action sequence that reaches a goal state
• An optimal solution has least cost among all solutions
 Pacman agent program in Python
Pac-Man Example: What’s in a State Space?
The world state includes every last detail of the environment
class GoWestAgent(Agent):

def getAction(self, percept):

if [Link] in [Link]():
return [Link] A search state keeps only the details needed for planning (abstraction)
else: • Problem: Pathing • Problem: Eat-All-Dots
return [Link] – States: (x,y) location – States: {(x,y), dot booleans}
– Actions: NSEW – Actions: NSEW
– Successor: update location only – Successor: update location
– Goal test: is (x,y)=END and possibly a dot boolean
– Goal test: dots all false

State Space Sizes? Quiz: Safe Passage

• World state: 12x10 grid
– Agent positions: 120
– Food count: 30
– Ghost positions: 12
– Agent facing: NSEW
• How many
– World states?
120x(230)x(122)x4
– States for pathing?
• Problem: eat all dots while keeping the ghosts perma-scared
120
– States for eat-all-dots? • What does the state space have to specify?
120x(230) – (agent position, dot booleans, power pellet booleans, remaining scared time)
 Example : Romania Problem Solving – Atomic Agents
• Traveling in Romania • Atomic Agents
• Agent is holidaying in Arad. – States are indivisible
• Many factors in its performance – Searching through the states to reach the goal.
measure
– Tour the famous places
– Try local cuisine
– Souvenir Shopping

Problem Solving Agents – Formulate Problem Solving Agents :Traveling in Romania

A problem can be formulated using five components • In the above definition
1. Initial State : – Many possible states – In(Arad), the agent has many
– The agent’s starting state. E.g., In(Arad) possibilities in real world, e.g., can be in the middle of
2. Possible Actions : Arad, near an airport, shopping center, hotel, etc.
– Set of applicable actions in a given state. E.g., from the state s = In(Arad),
applicable actions
– Many possible actions – Agent can take several actions
while driving from Arad to Sibiu. It can halt at a place,
• ACTIONS(s) → {Go(Sibiu), Go(Timisoara), Go(Zerind)}
take a detour, turn the radio on.
3. Transition Model :
– The resulting state of an action in a given state, modeled as RESULT(s, a) – However, they are irrelevant for finding the solution of
• RESULT( In(Arad), Go(Sibiu) ) = In(Sibiu) path to Bucharest
4. Goal Test : • State space: Cities – Hence, can be abstracted
• Assumptions about the Environment
– Determines whether a given state is a goal state. • Successor function: Roads: Go to adjacent • Abstraction – Process of removing detail from a representation
– Observable: Agent always knows the current state
• IsGoal( In(Bucharest) ) = Yes city with cost = distance • Problem Formulation: – Discrete: At any given state, only finitely many
5. Path Cost : • Start state: Arad actions to choose from
– Process of deciding what actions and states to consider,
– A function that assigns a numeric cost to each path. A path is a series of • Goal test: Is state == Bucharest? – Known: Knows which states are reached by each
actions. Each action is given a cost depending on the problem. given a goal
• Path Cost: ? action
• cost( In(Arad), go(Sibiu)) = 140 kms – Deterministic: Each action would always have the
• Solution: Finding the sequence of actions - same resulting state
Search
 Search Problems Are Models Problem Representation in AI
• Before a solution can be found, the prime condition is that the
problem must be very precisely defined. The most common
methods of problem representation in AI are:
1. State Space representation
• Includes the initial state S and all other states that are reachable from S
by a sequence of actions
2. Problem Reduction
• Whether the problem can be decomposed into smaller problems?
• Using the technique of problem decomposition, we can often solve very
large problems easily.
– Example for decomposable problems
– ∫( x2 +3x + Sin2x.Cos2x )dx

AND/OR graph representation Problem Formulation - Examples

• Problem decomposition into sub-problems • Toy Problems :
• AND/OR graph – Intended to illustrate or exercise various problem solving methods. Useful in
• Solved node Nod SAU
research for comparing the performance of algorithms
• Unsolvable node • Vacuum World, 8-Puzzle, 8-Queens Problem,
Noduri SI
• Problem solution • Cryptarithmetic, Missionaries and Cannibals
Noduri SAU • Real-World Problems :
– Problems for which solutions can be impacting people’s daily lives.
• Route finding, Touring problems
• Traveling salesman problem,
• VLSI layout, Robot navigation,
• Assembly sequencing,
• Protein Design, Internet Searching
 Modeling Formulate – Toy Problem Example Formalizing problem in a State Space: Toy Example
• Possible States – There are two locations and two possibilities of dirt. Total of 8 possible states:
• 2x22=8
1. State
• Robot and dirt locations
• Initial State
– Any state with position of agent and dirt mentioned
2. Actions
• Three possible actions, Left, Right, Suck
3. Transition Model
• Left would move the agent to left location, except when the agent is in leftmost location, there would be
no effect.
• Similarly for Right action. Suck would remove the dirt, if any.
4. Goal Test
• Checks whether all locations are clean or no Dirt
5. Path cost
• Each step costs 1, so the path cost is total number of steps

Problem Formulation Example: 8-puzzle Problem Formulation Example: 8-puzzle

a) Initial state • Possible states = 9! / 2
b) Final/ Goal State 1. Initial State :
c) Operator – Any permutation of 1-8 numbers with a blank
i. Move(left) 2. Actions :
ii. Move(right) – Movement of blank space either by Left,
iii. Move(Up) Right, Up or Down
iv. Move(Down) 3. Transition Model :
– The resulting state after moving the blank
– Belongs to sliding-block puzzles space will replace the digit
– NP - Complete problem. 4. Goal Test :
– Check whether the state matches the goal
configuration
5. Path cost :
– Each step costs 1, so the path cost is total
number of steps
 Problem Formulation : Water Jug Problem Example : Step1-Assumptions
Define the Problem Accurately. In order to solve the given problem we can make the following
– You are given two jugs, a 4 gallon one and a 3 gallon one. assumptions without affecting the problem.
– Neither has any measuring markers on it. There is a pump that can be used to 1. We can fill the jugs with the help of a pump.
fill the jugs with water.
– Discuss how exactly 2 gallon of water can be filled into 4 gallon of jug by 2. We can pour water from any jug to the ground.
employing the state space representations. 3. We can transfer water from one jug to the other.
4. No external measuring devices are available.

Example : Step2- Solution Steps State Space Representation

State Space Representation 1. Initial & Final States
• The state space for this problem can be described as the set of ordered pairs of integers (x,y)
1. Initial and final states • such that x = 0, 1,2, 3 or 4 and y = 0,1,2 or 3;
2. Operators – x represents the number of gallons of water in the 4-gallon jug and
3. Abbrivations – y represents the quantity of water in 3-gallon jug
4. State space representation of the given problem • The start state is (0,0)
State No. Operator State (G4,G3) • The goal state is (2,n) for any n.
• Attempting to end up in a goal state.
2. Operators
5. Operators and Conditions
Let us define the following 4 operators.
6. Production rules for Water Jug Problem
– FILL (jug): where jug = 3 gallon or 4 gallon, fill the jug fully with water.
– EMPTY (jug): where jug = 3 gallon or 4 gallon, empty the jug by pouring the water to ground.
– POUR (jug1, jug2): pour the water from jug1 to jug 2 until it is just filled
– TRANSFER (jug1, jug2): pour the water from jug1 to jug 2 completely.
 State Space Representation
State Space Representation
3. Abbreviations 5. Operators and Conditions Production rules :
G3 è 3 Gallon Jug
Operators Conditions
G4 è 4 Gallon Jug

FILL (G3) : G3 was not full

4. State space representation of the given problem
FILL (G4) : G4 was not full
State No. Operator State (G4,G3)
EMPTY (G4) : G4 was not empty
0 (Initial) --------- (0, 0)
1 FILL (G3) (0, 3) TRANSFER (G3,G4) : G3 was not empty
2 TRANSFER (G3, G4) (3, 0) & G4 was not full
3 FILL (G3) (3, 3)
4 POUR (G3, G4) (4, 2)
5 EMPTY (G4) (0, 2)
POUR (G3, G4) : G3 was not empty
6 (Final) TRANSFER (G3,G4) (2, 0) & G4 was not full

Water Jug Problem : Solution Problem Formulation: The 8-Queens

We can list the steps that may be followed to reach the Gallons in the Gallons in the Rule applied
• Incremental formulation vs. complete-state formulation
goal state. 4-gallon jug 3-gallon jug • States-I-1: 0-8 queens on board
1. Fill the 3 gallon jug with water 0 0 2
• Successor function-I-1:
2. Pour the water from 3 gallon jug to 4 gallon jug. 0 3 9 – add a queen to any square
3. Again fill the 3 gallon jug with water – # of possible states = (64*63*…*57= )
4. Pour the water carefully from 3 gallon jug to 4 gallon 3 0 2 • States-I-2:
jug such that it is just filled. 3 3 7
– 0-8 non-attacking queens on board
5. Empty the 4 gallon jug • Successor function-I-2:
6. Transfer the water from 3 gallon jug to 4 gallon jug. 4 2 5 or 12 – add a queen to a non-attacking square in the left-most empty column
7. Stop. – # of possible states = 2057 --- ???
0 2 9 0r 11
• Goal test: 8 queens on board, none attacked
2 0 • Path cost: of no interest (since only the final state count)
 The Eight Queens Problem N queens problem formulation
• One strategy: guess at a solution Formulation 1 Formulation 2 Formulation 3
– There are 4,426,165,368 ways to arrange 8 queens on a chessboard of 64 • States: Any arrangement of 0 to • States: Any arrangement of • States: Any arrangement
squares 8 queens on the board 8 queens on the board of k queens in the first k
– Initial state: 0 queens on the – Initial state: All queens are at rows such that none are
• An observation that eliminates many arrangements from
board column 1 attacked
consideration
• Successor function: Add a • Successor function: Change – Initial state: 0 queens on
– No queen can reside in a row or a column that contains another queen the board
queen in any square the position of any one
• Now: only 40,320 (8!) arrangements of queens to be checked for attacks • Successor function: Add
• Goal test: 8 queens on the queen
along diagonals
board, none are attacked • Goal test: 8 queens on the a queen to the (k+1)th
board, none are attacked row so that none are
attacked.
• Goal test : 8 queens on
the board, none are
52
attacked 53

Formulate – Real World Example Formulate – Real World Example

• Route finding problem, e.g., Google • Airline Travel problem
Maps – the task of a travel agent to book cheapest and fastest flight route from City A to City B.
• Routing Video Streams in Computer – E.g., Need to Travel from Delhi to Los Angeles within Rs. 70,000
Networks – Possible States – Each state is a location and current time.
• Traveling Salesman problem 1. Initial State – Specified by User’s query
2. Actions – Flight from current location at a particular time with enough time for
• Robot Navigation
within-airport transfer if needed
3. Transition Model – The destination location and arrival time
4. Goal test – Are we at final destination at the specified time?
5. Path Cost – Flight cost + Duration + Waiting time + Immigration, etc.
 Searching for Solutions State Space Graphs and Search Trees
• Solution for above Problems:
– A sequence of possible actions starting at the initial
state and reaching the destination specified
• Search Algorithms:
– Given problem formulation as input, these
algorithms would output the sequence of actions
– Search Trees
• Where states are nodes and actions are edges.
The initial state will be the root node and
possible actions are branches

State Space Graphs Search Trees

• State space graph: A mathematical representation
This is now / start
of a search problem
a G “N”, 1.0 “E”, 1.0
– Nodes are (abstracted) world configurations
– Arcs represent successors (action results) b c
Possible futures
– The goal test is a set of goal nodes (maybe only one) e
d f
S
• In a state space graph, each state occurs only once! h

p r
q • Different plans that achieve the same state,
• A search tree:
• We can rarely build this full graph in memory (it’s will be different nodes in the tree.
– A “what if” tree of plans and their outcomes • Every plan in the tree.
too big), but it’s a useful idea Tiny State Space graph for a tiny • Search ignores most of the tree.
– The start state is the root node
– Find solution without writing most of the graph search problem
– Children correspond to successors
down. – Nodes show states, but correspond to PLANS that achieve those states
– really care about the start and what you can do – For most problems, we can never actually build the whole tree
from the start -> search tree
 State Space Graphs vs. Search Trees State Space Graphs vs. Search Trees

Consider this 4-state graph: How big is its search tree (from S)?
Each NODE in the
State Space Graph search tree is an Search Tree
entire PATH in the
state space graph. S a s
a G d e p a b
b c
b c e h r q S G
d
e
f
b G a G
a a h r p q f
S h We construct both on
demand – and we p q f q c G b a G b G
p q r
construct as little as a
possible. q c G
a
… …

Important: Lots of repeated structure in the search tree!

Tree Search General Tree Search

• Important ideas:
– Fringe
– Expansion
– Exploration strategy

• Main question: which fringe nodes to explore?

That’s the abstraction. Now talk about algorithm.
 Example: Tree Search Search Example: Romania
a G • Frontier:
b c • Set of all leaf nodes available for expansion
e at any given point
d f • Search Strategy:
S h • Choosing which state to expand next
p q r

S Fringe
s
d e p sàd
sàe
b c e h r q sàp
sàdàb
a a h r p q f sàdàc
sàdàe
p q f q c G sàdàeàh
sàdàeàr
q c a sàdàeàràf
G sàdàeàràfàc
a sàdàeàràfàG

Searching for a solution with a Tree search Algorithm Tree Search Algorithm: Romania
Generation

In(Arad)
Repeated State
generated by Go(Sibiu) Go(Timisoara) Go(Zerind)
Expansion
Loopy Path
In(Sibiu) In(Timisoara) In(Zerind)

Go(Arad) Go(Fagaras) Go(Oradea) Go(Rimnicu Vilcea)

• Frontier: Set of all leaf nodes available for expansion at any given point In(Arad) In(Fagaras) In(Oradea) In(Rimnicu Vilcea)
– Search Strategy: Choosing which state to expand next
• Search: Redundant Path: More than one way to reach a state from another.
- E.g., Arad – Sibiu (140 kms) and Arad-Zerind-Oradea-Sibiu (297 kms)
– Expand out potential plans (tree nodes) - Loopy Path is a special case
– Maintain a fringe of partial plans under consideration
– Try to expand as few tree nodes as possible
 Revision Can Solution Steps be ignored or undone?
• Description of the problem • Suppose we are trying to prove a math theorem.
– Define a state space that contains all the possible configurations of the – We can prove a lemma. If we find the lemma is not of any help, we can still
relevant objects. continue.
– Specify one or more states within that space that describe possible situations • 8-puzzle problem
from which the problem solving process may start ( initial state)
• Chess: A move cannot be taken back.
– Specify one or more states that would be acceptable as solutions to the
problem. ( goal states) • Important classes of problems:
– Specify a set of rules that describe the actions ( operations) available. – Ignorable (e.g. theorem proving) in which solution steps can be ignored
• What are unstated assumptions? – Recoverable (e.g. 8-puzzle) in which solution steps can be undone.
• How general should the rules be? – Irrecoverable (e.g. chess) in which solution steps cannot be undone
• How much knowledge for solutions should be in the rules?

COMPLEX PROBLEMS & SOLUTIONS COMPLEX PROBLEMS & SOLUTIONS

 Measuring Search Algorithm Performance Measuring Search Algorithm Performance
• Completeness : • Effectiveness of an algorithm can be measured by:
– Is the algorithm guaranteed to find a solution when there is one?
– Search Cost:
• Optimality :
– Does the algorithm find the optimal solution?
• Time spent by the algorithm in finding a solution
• Time Complexity :
(can also include memory usage)
– How long does it take to find the solution? – Solution Cost:
• Space Complexity : • Path cost of the solution
– How much memory is needed to perform the search? – Total Cost:
• Search Cost + Solution Cost (if not in same units,
• Time and space complexity
convert them)
– Search in AI is represented by initial state, actions and transitions which usually result in infinite
Nodes and Edges in a [Link], the complexity is rather measured by
• Branching Factor (b): Maximum number of successors of any node
• Depth (d) of the shallowest goal, i.e., number of steps from initial node
• Maximum length (m) of any path in state space ( may be ∞ )

Search Algorithms Summary

• Uninformed Search Algorithms • Four steps for designing a program to solve a problem:
– No additional information about states beyond what is provided in problem 1. Define the problem precisely
formulation 2. Analyse the problem
– Generate successors and distinguish a goal state from a non-goal state 3. Identify and represent the knowledge required by the task
• Informed Search Algorithms 4. Choose one or more techniques for problem solving and apply those
– Strategies that know if one non-goal state is more promising than another techniques to the problem.
non-goal state
– Also called Heuristic Search strategies
 Next : Explore
• Problem Formulation by AI Search
• Module 3: Search Strategies
Methods for the following famous
• # of states
– PART 3.1: Search
problems : • State :
– PART 3.2: Uninformed Search
– PART 3.3: Informed/Heuristic Search – Tic-Tac-Toe • Initial State:
– PART 3.4: Beyond Classical Search – 8-puzzel problem • Action :
– PART 3.5: Problem reduction – 8 Queens Problem
– PART 3.6: Adversarial Search
• Goal test :
– Missionaries and Cannibals
– Tower of Hanoi
• path cost :
– Travelling Salesman Problem (TSP)
– Rubik’s Cube

Search Tree References

• Artificial intelligence : A Modern Approach, Prentice Hall by Stuart Russell, Peter Norvig,
• Artificial Intelligence by Elaine Rich & Kevin Knight, Third Ed, Tata McGraw Hill
• Artificial Intelligence and Expert System by Patterson
• Slides adapted from CS188 Instructor: Anca Dragan, University of California, Berkeley
• Slides adapted from CS60045 ARTIFICIAL INTELLIGENCE