2009. b) (i)

(ii) At each step of the graph/tree search algorithms, the collection of nodes have been generated by not yet

expanded is known as fringe. During breadth first search of the above search space the contents of the fringe at

each step are presented in below in the following manner Ni {N1, .. Nk} where Ni is the currently expanded node

and the FIFO queue within brace is the current fringe where N1 is the front node and Nk is the rear one.

{A}, A {B, C}, B {C, D, E}, C {D, E, F}, D {E, F}, E {F, G}, F {G}, G and the corresponding cost is:

4+1+3+8+6+4+2 = 30 (without considering the branching cost).

[DO the other two search in the same manner. However in case of Uniform Cost the nodes will be considered

according the increasing path cost and if there is 0 path cost like here Cost(C, C) = 0, the uniform cost path will

be trapped.]

10. (a) A heuristic h(n) is consistent if, for every node n and every successor n of n generated by any action a, the estimated cost of reaching the goal from n is no greater than the step cost of getting to n plus the estimated cost of reaching the goal from n:

i.e. h(n) c(n, a, n) + h(n)

If h(n) is consistent, then the values of f(n) along any path are nondecreasing. The proof follows directly from

the definition of consistency. Suppose n is a successor of n; then g(n) = g(n) + c(n, a, n) for some action a, and we have f(n) = g(n) + h(n) = g(n) + c(n, a, n) + h(n) g(n) + h(n) = f(n) .

i.e. f(n) f(n)

1

B

C 4

D

E

8

3

2

F

6

2

4

G

2

8

A

0

(b)

Above is a section of a game tree for tic tac toe. Each node represents a board position, and the children of each

node are the legal moves from that position. To score each position, we will give each position which is

favorable for player 1 a positive number (the more positive, the more favorable). Similarly, we will give each

position which is favorable for player 2 a negative number (the more negative, the more favorable). In our tic

tac toe example, player 1 is 'X', player 2 is 'O', and the only three scores we will have are +1 for a win by 'X', -1

for a win by 'O', and 0 for a draw. Note here that the blue scores are the only ones that can be computed by

looking at the current position.

(c) Proof of Admissibility of A*: An admissible heuristic is one that never overestimates the cost to reach

the goal. Because g(n) is the actual cost to reach n along the current path, and f(n) = g(n) + h(n), we have as an

immediate consequence that f(n) never overestimates the true cost of a solution along the current path through

n.

We will show that A* is admissible if it uses a monotone heuristic.

A monotone heuristic is such that along any path the f-cost never decreases.

But if this property does not hold for a given heuristic function, we can make the f value monotone by making

use of the following trick (m is a child of n)

f(m) = max (f(n), g(m) + h(m))

Let G be an optimal goal state C* is the optimal path cost. G2 is a suboptimal goal state: g(G2) > C*

Suppose A* has selected G2 from OPEN for expansion. Consider a node n on OPEN on an optimal path to G.

Thus C* f(n) Since n is not chosen for expansion over G2, f(n) f(G2) G2 is a goal state. f(G2) = g(G2)

Hence C* g(G2). This is a contradiction. Thus A* could not have selected G2 for expansion before reaching the goal by an

optimal path.

Proof of Completeness of A*: Let G be an optimal goal state. A* cannot reach a goal state only if there

are infinitely many nodes where f(n) C*. This can only happen if either happens: o There is a node with infinite branching factor. The first condition takes care of this.

o There is a path with finite cost but infinitely many nodes. But we assumed that Every arc in the graph has

a cost greater than some > 0. Thus if there are infinitely many nodes on a path g(n) > f*, the cost of that path will be infinite.

Lemma: A* expands nodes in increasing order of their f values.

A* is thus complete and optimal, assuming an admissible and consistent heuristic function (or using the

pathmax equation to simulate consistency). A* is also optimally efficient, meaning that it expands only the

minimal number of nodes needed to ensure optimality and completeness.

2010 8). b) (ii)

Prove that if a heuristic is consistent it must be admissible but the converse is not True.

Ans.

Part 1 - Let k(n) be the cost of the cheapest path from n to the goal node. We will

proove by induction on the number of steps to the goal that h(n) k(n). Base case: If there are 0 steps to the goal from node n, then n is a goal and therefore

h(n) = 0 k(n). Induction step: If n is i steps away from the goal, there must exist some successor n of n generated by some action a s.t. n is on the optimal path from n to the goal (via action a) and n is i 1 steps away from the goal. Therefore,

h(n) c(n, a, n) + h(n) But by the induction hypothesis, h(n) k(n). Therefore, h(n) c(n, a, n) + k(n) = k(n) since n is on the optimal path from n to the goal via action a.

Part-2 Consider a search problem where the states are nodes along a path

P =n0, n1, . . . , nm where n0 is the start state, nm is the goal state and there is one action from each state ni which

gives ni+1 as a successor with cost 1. The cheapest cost to the goal from a state i is then k(ni) = m i. Dene a heuristic function as follows:

h(ni) = m 2i/2 For all states ni, h(ni) k(i), and so h is admissible. However, if i is odd, then h(ni) = h(ni+1) > 1 + h(ni+1). Thus h is not consistent

9. a) (i) Draw the complete search tree for NIM.

The search tree is shown below. The student might draw a search tree which duplicates some of the nodes. This

is acceptable.

Note : At this stage, only the search tree is required. The Min, Max and the Utility Functions are not required.

0

0 1

0 1 0

0 1 0 1

1 1 1

1

7

6-1 5-2 4-3

5-1-1 4-2-1 3-2-2 3-3-1

4-1-1-1 3-2-1-1 2-2-2-1

3-1-1-1-1 2-2-1-1-1

2-1-1-1-1-1

MIN

MAX

MIN

MAX

MIN

MAX

10. a) The solution is hinted for the following problem.

Consider the function f(n) = -(number of tiles out of place) . Now our aim is to maximize f(n) (Maximum

being 0). In this context the 8-Puzzle problem can be logically identical to Hill Climbing where f(n) which gives

the height at nth step needs to be maximized. Consider the following diagram for clarification.

Try to solve the problem in the same manner mentioned above.

A. Strategies for space search- Data driven and Goal driven

Goal driven search is suggested if:

1. A goal is given in the problem statement or can easily be formulated. In a mathematics theorem prover, for example, the goal is the theorem to be proved. Many diagnostics system consider potential diagnoses

in a systematic fashion.

2. There are large no. of rules that match the facts of the problem and thus produce an increase in no of conclusions or goals. In a mathematics theorem prover, for example, the total no of rules that may be

applied to the entire set of axioms.

3. Problem data are not given and must be acquired by the problem solver. In a medical diagnosis program, for example, a wide range of diagnostic tests can be applied. Doctors order only those that are necessary

to confirm or deny a particular hypothesis.

Data driven search

1. All or most of the data are given in the initial problem statement. Interpretation problems often fit this mold by presenting a collection of data and asking the system for interpretation.

2. There are large no. of potential goals, but there are only a few ways to use the facts and given information of a particular problem instance.

3. It is difficult to form a goal or hypothesis.

Data driven search uses the knowledge and constraints found in the given data to guide search along lines

known to be true.

B. Deterministic vs. stochastic. If the next state of the environment is completely determined by the current state and the action executed by the agent, then we say the environment is deterministic; otherwise, it is

stochastic. In principle, an agent need not worry about uncertainty in a fully observable, deterministic

environment. (In our definition, we ignore uncertainty that arises purely from the actions of other agents in a

multiagent environment; thus, a game can be deterministic even though each agent may be unable to predict

the actions of the others.) If the environment is partially observable, however, then it could appear to be

stochastic. Most real situations are so complex that it is impossible to keep track of all the unobserved

aspects; for practical purposes, they must be treated as stochastic. Taxi driving is clearly stochastic in this

sense, because one can never predict the behavior of traffic exactly; moreover, ones tires blow out and ones engine seizes up without warning. The vacuum world as we described it is deterministic, but variations can include stochastic elements such as randomly appearing dirt and an unreliable suction

mechanism. We say an environment is uncertain if it is not fully observable or not deterministic. One final

note: our use of the word stochastic generally implies that uncertainty about outcomes is quantified in terms of probabilities; a nondeterministic environment is one in which actions are characterized by their

possible outcomes, but no probabilities are attached to them. Nondeterministic environment descriptions are

usually associated with performance measures that require the agent to succeed for all possible outcomes of

its actions.

C. Single-layer feed-forward neural networks (perceptrons)

[Read from Russel-Norvig 3rd

edition section 18.7.2 of page 729]

D. Optimality of BFS:

For unit-step cost, breadth-first search is optimal. In general breadth-first search is not optimal since it

always returns the result with the fewest edges between the start node and the goal node. If the graph is a

weighted graph, and therefore has costs associated with each step, a goal next to the start does not have to be

the cheapest goal available. This problem is solved by improving breadth-first search to uniform-cost

search which considers the path costs. Nevertheless, if the graph is not weighted, and therefore all step costs

are equal, breadth-first search will find the nearest and the best solution.

E. Optimality of A*:

The main idea is that when A* finds a path, it has a found a path that has an estimate lower then the estimate

of any other possible paths. Since the estimates are optimistic, the other paths can be safely ignored. Also,

A* is only optimal if two conditions are met: 1. The heuristic is admissible, as in, it will never over-estimate

the cost. 2. The heuristic is monotonic, meaning, if H(1) < H(2) then RealCost(1) < RealCost(2). One can

prove the optimality to be correct by assuming the opposite, and expanding the implications. Assume that

the path give by A* is not optimal with an admissible and monotonic heuristic, and think about what that

means in terms of implications, and thus, our original assumption does not remain valid. From that one can

conclude that the original assumption was false, that is, A* is optimal with the above conditions.

2010

8. (b) (i) The heuristic function sum of manhattan distances for 8 puzzle problem is consistent

Ans: Suppose n and n are two intermediate positions of a single tile of the 8-Puzzle problem in its transit to reach the goal position. Cost of each horizontal and vertical step is 1 and that of each diagonal step is 2. If we only allow horizontal and vertical movement then h(n) = |xg - xn| + |yg - yn| where (xn,yn) and (xg,yg) are the current and final position of the current

block. Now from n to n the possible change is only a single horizontal or vertical movement with cost 1 i.e. c(n, n) = 1. So either |xn - xn| = 1 or |yn - yn| = 1 the other distance being 0.

So, h(n) - h(n) = |xn - xn| + |yn - yn| c(n,n) i.e. h(n) c(n, a, n) + h(n)

This means that this heuristic is consistent.

[Here we have considered a single tile but with all the 8 tiles and the sum of distances this argument can be suitably extended].

(ii) Prove that if a heuristic is consistent it must be admissible but the converse is not True.

Ans: Part 1

Let k(n) be the cost of the cheapest path from n to the goal node. We will prove by induction on the number of steps to the

goal that h(n) k(n). Base case: If there are 0 steps to the goal from node n, then n is a goal and therefore

h(n) = 0 k(n). Induction step: If n is i steps away from the goal, there must exist some successor n of n generated by some action a s.t. n is on the optimal path from n to the goal (via action a) and n is i 1 steps away from the goal. Therefore,

h(n) c(n, a, n) + h(n) But by the induction hypothesis, h(n) k(n). Therefore, h(n) c(n, a, n) + k(n) = k(n) since n is on the optimal path from n to the goal via action a.

Part-2 Consider a search problem where the states are nodes along a path P =n0, n1, . . . , nm where n0 is the start state, nm is the

goal state and there is one action from each state ni which gives ni+1 as a successor with cost 1. The cheapest cost to the

goal from a state i is then k(ni) = m i. Dene a heuristic function as follows: h(ni) = m 2i/2 For all states ni, h(ni) k(i), and so h is admissible. However, if i is odd, then h(ni) = h(ni+1) > 1 + h(ni+1). Thus h is not consistent.

2011

2. (2nd

Part)

Common decision tree Pruning Algorithm is described here.

1. Consider all internal nodes in the tree.

2. For each node check if removing it (along with the subtree below it) and assigning the most common class to it does not harm accuracy on the validation set.

3. Pick the node n* that yields the best performance and prune its subtree. 4. Go back to (2) until no more improvements are possible.

[The principle for decision tree construction may be stated as follows: Order the splits (attribute and value of the

attribute) in decreasing order of information gain. Practical issues while building a decision tree can be enumerated as follows:

1) How deep should the tree be?

2) How do we handle continuous attributes?

3) What is a good splitting function? 4) What happens when attribute values are missing?

5) How do we improve the computational efficiency?

The depth of the tree is related to the generalization capability of the tree. If not carefully chosen it may lead to

overfitting. A tree overfits the data if we let it grow deep enough so that it begins to capture aberrations in the data that harm the predictive power on unseen examples. There are two main solutions to overfitting in a decision tree:

(1) Stop the tree early before it begins to overfit the data. (2) Grow the tree until the algorithm stops even if the overfitting problem shows up. Then prune the tree as a

post processing step].

** Four Approaches of defining AI systems:

Systems that think like

humans

Systems that think

rationally

Systems that act like

humans.

Systems that act

rationally.

Russell and Norvig define AI as the study and construction of rational (intelligent) agents. This is a broader definition of intelligence than human intelligence (we should not expect computer intelligence to be the same as human intelligence

anymore than we expect airplanes to fly the same as birds). Intelligent behavior is also a broader concept than intelligent

thought (intelligent behavior may depend on reflex, not thinking).

Things AI systems still cannot do properly:

Understand natural language robustly (e.g., read and understand articles in a newspaper) Surf the web Interpret an arbitrary visual scene Learn a natural language Play Go well Construct plans in dynamic real-time domains Refocus attention in complex environments Perform life-long learning

*** Basic structure of a rule-based expert system

The knowledge base contains the domain knowledge useful for problem solving. In a rule-based expert system, the knowledge is represented as a set of rules. Each rule specifies a relation, recommendation,

directive, strategy or heuristic and has the IF (condition) THEN (action) structure. When the condition part of a rule is satisfied, the rule is said to fire and the action part is executed.

The database includes a set of facts used to match against the IF (condition) parts of rules stored in the knowledge base.

Inference engine

The inference engine carries out the reasoning whereby the expert system reaches a solution. It links the rules given in the knowledge base with the facts provided in the database.

The inference engine is a generic control mechanism for navigating through and manipulating knowledge and deduce results in an organized manner.

Inference engine the other key component of all expert systems.

Just a knowledge base alone is not of much use if there are no facilities for navigating through and manipulating the

knowledge to deduce something from knowledge base.

A knowledge base is usually very large, it is necessary to have inferencing mechanisms that search through the database

and deduce results in an organized manner.

The Forward chaining, Backward chaining and Tree searches are some of the techniques used for drawing inferences from

the knowledge base.

Forward Chaining Algorithm

Forward chaining is a techniques for drawing inferences from Rule base. Forward-chaining inference is often called data

driven.

The algorithm proceeds from a given situation to a desired goal, adding new assertions (facts) found.

A forward-chaining, system compares data in the working memory against the conditions in the IF parts of the rules and

determines which rule to fire.

Inference Engine

Knowledge Base

Rule: IF-THEN

Database

Fact

Explanation Facilities

User Interface

User

Data Driven

Example : Forward Channing

Given : A Rule base contains following Rule set

Rule 1: If A and C Then F

Rule 2: If A and E Then G

Rule 3: If B Then E

Rule 4: If G Then D

Problem : Prove

If A and B true Then D is true

Solution :

(i) Start with input given A, B is true and then

start at Rule 1 and go forward/down till a rule

fires'' is found.

First iteration :

(ii) Rule 3 fires : conclusion E is true

new knowledge found

(iii) No other rule fires;

end of first iteration.

(iv) Goal not found;

new knowledge found at (ii);

go for second iteration

Second iteration :

(v) Rule 2 fires : conclusion G is true

new knowledge found

(vi) Rule 4 fires : conclusion D is true

Goal found;

Proved

Backward Chaining Algorithm

Backward chaining is a techniques for drawing inferences from Rule base. Backward-chaining inference is often called

goal driven.

The algorithm proceeds from desired goal, adding new assertions found.

A backward-chaining, system looks for the action in the THEN clause of the rules that matches the specified goal.

Goal Driven

Example : Backward Channing

Given : Rule base contains following Rule set

Rule 1: If A and C Then F

Rule 2: If A and E Then G

Rule 3: If B Then E

Rule 4: If G Then D

Problem : Prove

If A and B true Then D is true

Solution :

(i) Start with goal i.e. D is true

go backward/up till a rule "fires'' is found.

First iteration :

(ii) Rule 4 fires :

new sub goal to prove G is true

go backward

(iii) Rule 2 "fires''; conclusion: A is true

new sub goal to prove E is true

go backward;

(iv) no other rule fires; end of first iteration.

new sub goal found at (iii);

go for second iteration

Second iteration :

(v) Rule 3 fires :

conclusion B is true (2nd input found)

both inputs A and B ascertained . (Proved)

**Branch and Bound Algoritm:

General purpose method to solve discrete optimization problems Takes exponential time in the worst-case Useful to solve small instances of hard problems

Can be applied to all scheduling problems

Need to specify: 1. A lower bounding scheme 2. Branching rule 3. Search rule (subproblem selection rule)

Overview: For a minimization problem, at a given branch and bound tree (b&b) node i: 1. Obtain a lower bound, lbi 2. (Optional) Obtain a candidate solution and an upper bound ubi 3. If (ubi < GLOBAL UB) then set ubi as the GLOBAL UB 4. If (lbi >= GLOBAL UB) then prune the node and go to 6. 5. Branch into subproblems (create child nodes) 6. Pick the next active subproblem.

If none exist, stop. Else, go to 1.

Example 1

Problem: Single machine, n jobs arriving at different times, preemptions not allowed, minimize maximum lateness (Lmax)

A b&b node corresponds to a partial schedule

At level k of the b&b tree, the first k jobs in the schedule have been fixed

Branching Create a child node of a node at level k-1 by fixing each remaining job at kth position EXCEPT:

If a job c satisfies )),(max(min ll

Jlc prtr

, do not create a child for that job

Lower bounding: Schedule remaining jobs according to the preemptive EDD rule: Every time the machine is freed or a new job is released,

pick the uncompleted job with minimum due date

Numeric Example:

Jobs 1 2 3 4

pj 4 2 6 5

dj 8 12 11 10

rj 0 1 3 5

Lower bound at node (1,-) is obtained by applying preemptive EDD to jobs 2, 3 and 4 with starting time 4

At t=4, available jobs: 2, 3, pick 3

At t=5, available jobs: 2, 3,4 pick 4

0

1, 3, 2,

1,3,4,2

4,

1,3, 1,2,

lb= 5

lb= 6

lb= 7

lb= 5

ub= 5

candidate

prune prune

Level 3

Level 2

Level 1

Level 0

At t=10, available jobs: 2, 3, pick 3

At t=15, available jobs: 2, pick 2

L1 = -4, L2 = 5, L3 = 4, L4 = 0, Lmax = 5

Exercise: Calculate the lower bound at node (2,-)

Preemptive EDD at node (1,3,-) gives a non-preemptive schedule 1, 3, 4, 2 with Lmax = 5 and it is an optimal solution to

the problem

3 1 3 4 2

4 5 10

0

15 17