Q-1

(a) Solve The following Crypt arithmetic problem :

C R O S S

+ R O A D S

D E N G E R

Ans :

D has to be 1 because when you do your addition by hand:

CROSS

+ROADS

-----------

DANGER

You see that the D in DANGER must have been carried over from the addition of C and R in CROSS

and ROADS, respectively. Thus, we have:

CROSS

+ROA1S

------------

1ANGER

This, by some fairly weird algebra and modular arithmetic, leads to the following relationships:

R = 2S mod 10

E = (3S + 1 - (2S mod 10)) mod 10

A = (C + 2R - (R + O mod 10)) mod 10

A = G - O mod 10

N = (R + 2O - (O + A mod 10)) mod 10

C = A - R mod 10

O = N - R mod 10

O = G - A mod 10

G = (O + A + S + 1 - (S + 1 mod 10)) mod 10

Obviously, this is of no help whatsoever to anyone, so we do trial and error.

So now we try things.

12344

+25614

------

3NO! D has to be 1

92344

+25614

------

11NO! A cannot be 1 because D is 1

96233

+62513

------

158746

(b) Give the problem space for the following :

(i) Monkey Banana problem

(ii) Water Jug problem

Ans:

(i) Monkey Banana problem

A monkey is in a cage and bananas are suspended from the ceiling, the monkey

wants to eat a banana but cannot reach them

in the room are a chair and a stick

if the monkey stands on the chair and waves the stick, he can knock a banana

down to eat it

what are the actions the monkey should take?

Initial state:

monkey on ground with empty hand bananas suspended

Goal state:

monkey eating bananas.

Actions:

climb chair/get off

grab X

wave X

eat X

(ii) Water Jug problem

The state space for this problem can be described as the set of ordered pairs of

integers (x, y) such that x = 0, 1,2, 3 or 4 and y = 0,1,2 or 3; x represents the number of

gallons of water in the 4-gallon jug and y represents the quantity of water in 3-gallon jug

The start state is (0,0)

The goal state is (2,n)

Production rules for Water Jug Problem

The operators to be used to solve the problem can be described as follows:

Sr. No Current state Next State Description

1 (x, y) if x < 4 (4,y) Fill the 4 gallon jug

2 (x, y) if y 0 (x-d, y) Pour some water out of the 4 gallon jug

4 (x, y) if y > 0 (x, y-d) Pour some water out of the 3-gallon jug

5 (x, y) if x>0 (0, y) Empty the 4 gallon jug

6 (x, y) if y >0 (x,0) Empty the 3 gallon jug on the ground

7 (x, y) if x + y

>= 4 and y >0

(4, y-(4-x)) Pour water from the 3 gallon jug into the 4

gallon jug until the 4-gallon jug is full

8 (x, y) if x + y

>= 3 and x>0

(x-(3-y), 3) Pour water from the 4-gallon jug into the 3-

gallon jug until the 3-gallon jug is full

9 (x, y) if x + y

0

(x + y, 0) Pour all the water from the 3-gallon jug into the

4-gallon jug

10 (x, y) if x + y

0

(0, x + y) Pour all the water from the 4-gallon jug into the

3-gallon jug

11 (0,2) (2,0) Pour the 2 gallons from 3-gallon jug into the 4-

gallon jug

12 (2,y) (0,y) Empty the 2 gallons in the 4-gallon jug on the

ground

To solve the water jug problem

Required a control structure that loops through a simple cycle in which some

rule whose left side matches the current state is chosen, the appropriate change

to the state is made as described in the corresponding right side, and the

resulting state is checked to see if it corresponds to goal state.

One solution to the water jug problem

Shortest such sequence will have a impact on the choice of appropriate

mechanism to guide the search for solution.

Gallons in the

4-gallon jug

Gallons in the 3-

gallon jug

Rule applied

0 0 2

0 3 9

3 0 2

3 3 7

4 2 5 or 12

0 2 9 0r 11

2 0

(c) Solve the following 8-puzzle using breadth first search

2 8 3

1 6 4

7 5

Ans :

2 8 3

1 6 4

7 5

1 2 3

8 4

7 6 5

2 8 3

1 6 4

7 5 2 8 3

1 6 4 7 5

2 8 3

Left 1

Up 2

Right 3

1 4

7 6 5

Left 1

2 8 3

1 6 4

7 5

2 8 3

6 4

1 7 5

UP 2

2 8 3

1 4

7 6 5

2 8 3

1 4

7 6 5

2 3

1 8 4

7 6 5

2 8 3

1 4

7 6 5

Right 3

2 8 3

1 6 4

7 5

Up 3.1 2 8 3

1 6

7 5 4

Up 1.1

2 8 3

6 4

1 7 5

8 3

2 6 4

Right

1.1.2 2 8 3

6 4

1 7 5

Up 1.1

Up 2.2 Left 2.1 Right 2.3

Left 2.1

2 8 3

1 4

7 6 5

Up

2.1.1

8 3

2 1 4

7 6 5

Down

2.1.2

2 8 3

7 1 4

6 5

Up 2.2

2 3

1 8 4

7 6 5

Left

2.2.1

2 3

1 8 4

7 6 5

Right

2.2.2

2 3

1 8 4

7 6 5

Right 2.3

2 8 3

1 4

7 6 5

Up 2.3.1

2 8

1 4 3

7 6 5

Down 2.3.2

2 8 3

1 4 5

7 6

Up 3.1

2 8 3

1 6

7 5 4

Left

3.1.1

2 8 3

1 6

7 5 4

Up

3.1.2

2 8

1 6 3

7 5 4

Up

1.1.1

8 3

2 6 4

1 7 5

Right

1.1.1.1

8 3

2 6 4

1 7 5

Right

1.1.2

2 8 3

6 4

1 7 5

2 3

6 8 4

Right

1.1.2.2 2 8 3

6 4

1 7 5

Down

1.1.2.3 2 8 3

6 7 4

1 5

Left

2.2.1

2 3

1 8 4

7 6 5

Down

2.2.1.1

1 2 3

8 4

7 6 5

Right

2.2.1.1.1 1 2 3

8 4

7 6 5

Down

2.2.1.1.2 1 2 3

7 8 4

6 5

Final goal state find and ans is Block Right 2.2.1.1.1

Q-2

(a) Explain Problem Decomposability with example.

Suppose we want to solve the problem of computing the expression

(x2 + 3x + sin2;c cos2*) dx

We can solve this problem by breaking it down into three smaller problems;

each of which we can then solve by using a small collection of specific rules.

Figure-2;9 shows the problem tree that will be generated by the process of

problem decomposition as it can be exploited by a simple recursive integration

program that worksras follows: At each step, it checks tojsee whether the

problem if is working on is immediately solvable.' If-so, then the answer is

returned directly. If the problem is not easily solvable, the integrator checks to

see whether it can decompose the problem into smaller problems. If it can, it

creates those problems and calls itself recursively on them. Using: thistechnique

of problem decomposition, we can often solvevery large problemseasily; v .

Now consider the problem illustrated in Figure 2.10. This problem is drawn

firom.the domain often referred to in AMiterature as the blocks world. Assume

that the following operators are available:

Figure 2.10: A Simple Blocks World Problem

Figure 2.11 : A Proposed Solution for the Blocks Problem

1. CLEARQc) [block x has nothing on it] -+ ON(JC, Table) [pick up x and put it

on the table]

/

2 8 3

1 6 4

7 5

1 2 3

8 4

7 6 5

2. CLEAR(x)andCLEAR(y)->ON(jt,;y) [put* on y]

Applying the technique of problem decomposition to this simple blocks world

example would lead to a solution tree such as that shown in Figure 2.11. In the

figure, goals are underlined. States that have been achieved are not underlined.

The idea of this solution is to reduce the problem of getting B on C and A on B to

two separate problems. The first of these new problems, getting B on C, is

simple, given the start state. Simply put B on C. The second subgoal is not quite

so simple. Since the only operators we have allow us to pick up single blocks at

a time, we have to clear off A by removing C before we can pick up A and put it

on B. This can easily be done. However, if we now try to combine the two

subsolutions into one solution, we will fail. Regardless of which one we do first,

we will not be able to do the second as we had planned. In this problem, the two

subproblems are not independent. They interact and those interactions must be

considered in order to arrive at a solution for the entire problem.

These two examples, symbolic integration and the blocks world, illustrate the

difference between decomposable and nondecomposable problems. In Chapter.

3^ we present a specific algorithm for problem decomjposition, and in Chapter

13, we look at what happens when decomposition'is'impossible.

(b) Write and explain Means-End Analysis algorithm.

So far, we have presented a collection of search strategies that can reason

either forward or backward, but for a given problem, one direction or the other

must be chosen. Often, however, a mixture of the two directions is appropriate.

Such a mixed strategy would make it possible to solve the major parts of a

problem first and then go back and solve the small problems that arise in

"gluing" the big pieces together. A technique known as means-ends analysis

allows us to do that.

The means-ends analysis process centers around the'detection of differences

between the current state and the goal state. Once such a difference is isolated,

an operator that can reduce the difference must be found. But perhaps that

operator cannot be applied to the current state. So we set up a subproblem of

getting to a state-in which it can be applied. The kind of backward chaining in

which operators are selected and then subgoals are set up to establish the

preconditions of the'operators is called operator subgoaling. But maybe the

operator does not produce exactly the goal state we want. Then we have a

second subproblem of getting from the state it does produce to the goal. But if

the difference was chosen correctly and if the operator is really effective at

reducing the difference,, then the two subproblems should be easier to solve

than the

Algorithm: Means-Ends Analysis (CURRENT, GOAL)

1. Compare CURRENT to GOAL. If there are no differences between them then

return.

2. Otherwise, select the most important difference and reduce it by doing the

following until success or failure is signaled:

(a) Select an as yet untried operator O that is applicable to the current difference. If there are no such operators, then signal failure.

(b) Attempt to apply O to CURRENT. Generate descriptions of two states: O-START, a state in which O's preconditions are satisfied and O-RESULT,

the state that would result if O were applied in O-START.

(c) If (FIRST-PART

is not done, a great deal of effort may be wasted on situations that take care of

themselves once the main parts of the problem are solved.

The simple process we have described is usually not adequate for solving

complex problems. The number of permutations of differences may get too

large. Working on one difference may interfere with the plan for reducing

another. And in complex worlds, the required difference tables would be

immense. In Chapter 13 we look at some ways in which the basic means-ends

analysis approach can be extended to tackle some of these problems.

(c) Write and explain Generate-and-Test algorithm.

The generate-and-test strategy is the simplest of all the approaches we discuss.

It consists of the following steps:

Algorithm: Generate-and-Test

1. Generate a possible solution. For some problems, this means generating a

particular point in the problem space. For others, it means generating a

path from a start state.

2. Test to see if this is actually a solution by comparing the chosen point or

the endpoint of the chosen path to the set of acceptable goal states.

3. If a solution has been found, quit. Otherwise, return to step 1.

If the generation of possible solutions is done systematically, then this

procedure ( will find a solution eventually, if one exists. Unfortunately, if the

problem space is very \arge, "eventually" may be a very long time.

The generate-and-test algorithm is a depth-first search procedure since

complete solutions must be generated before they can be tested. In its most

systematic form, it is simply an exhaustive search of the problem space.

Generate-and-test can, of course, also operate by generating solutions

randomly, but then there is no guarantee that a solution will ever be found. In

this form, it is also known as the British Museum algorithm, a reference to a

method for finding an object in the British Museum by wandering randomly.1

Between these two extremes lies a practical middle ground in which the search

process proceeds systematically, but some paths are not considered because

they seem Unlikely to lead to a solution. This evaluation is performed by a

heuristic function, as described in Section 2.2.2.

The most straightforward way to implement systematic generate-and-test is

as a depth-first search tree with backtracking. If some intermediate states are

likely to appear often in the tree/however, it may be better to modify that

procedure, as described above; to traverse a graph rather than a tree.

For simple problems; exhaustive generate-and-test is often a reasonable

technique. For example, consider the puzzle that consists of four six-sided

cubes, with each side of each cube painted one of four colors. A

sojutjpjuothe'puzzle consists of an arrangement of the cubes in a row such that

on all four sides of the row one block face of each color is showing. This

probJejrjLcan_be_^olved by a person (who is a much slower processor for this

sort of thin^ffhan even a very cheap computer) in several minutes by

systematically and exhaustively trying all possibilities. It can be solved even

.more quickly using a heuristic generate-and-test procedure.. A quick glance at

the four blocks reveals.that there are moret say, red faces than there are of

other colors. Thus when placing a block with several fed faces, it would be a

good idea to use as few of them as possible as outside faces. As many of them

as possible should be placed to abut the next block. \Using this heuristic, many

configurations need never be explored and a solution can be found quite quickly.

'Or, as another story goes, if a sufficient number of monkeys were

placed in front of a set of typewriters and left alone long enough, then

they would eventually produce all of the works of Shakespeare.

Unfortunately, for problems much harder than this, even heuristic generate-

and-test, all by itself, is not a very effective technique. Bat when combined

with other techniques to restrict the space in which to search even further, the

technique can be very effective.

For example, one early example of a successful AI program is DENDRAL

[Lindsay et ai, 1980], which infers the structure of organic compounds using

mass spectrogram and nuclear magnetic resonance (NMR) data. It uses a

strategy called plan-generate-test in which a planning process that uses

constraint-satisfaction techniques (see Section 3.5)if creates lists of

recommended and contraindicated substructures. The generate-and-test

procedure then uses those lists so that it can explore only a fairly limited set of

structures. Constrained in this way the generate-and-test procedure has

proved highly effective..

This combination of planning, using one problem-solving method (in this

case, constraint satisfaction) with the use of the plan by another problem-

solving method, generate-and-test, is an excellent example of the way

techniques can be combined to overcome the limitations that each possesses

individually. A "^n>r""*akness ofplanning is that it often produces somewhat

inaccurate solutions since there is no feedback from the world. But by using it

only to produce pieces of solutions-thai: will then be exploited in the generate-

and-test process, the lack of detailed accuracy becomes unimportant. And, at

the same time, the combinatorial problems that arise in simple generate-and-

test are avoided by judicious reference to the plans.

(c) Write and explain Hill Climbing algorithm.

Hill climbing is a variant of generate-and-test in which feedback from the test

procedure is used to help the generator decide which direction to move in the

search space. In a pure generate-and-test procedure, the test function

responds with only a yes or no. But if the test function is augmented with a

heuristic function2 that provides an estimate of how close a given state is to a

goal state, the generate procedure can exploit it .as shown in the procedure

below. This is particularly nice because often the computation of the heuristic

function can be done at almost no cost at the same time that the test for a

solution is being performed. Hill climbing is often used when a good heuristic

function is available for evaluating stateTEut when nrJother useful

knowledgelFavailable. For example, suppose you are in an unfamiliar city

without a map and you want to get downtown. You simply aim for the tall

buildings. The heuristic function is just distance between the current location

and the location of the tall buildings and the desirablestates are those in which

this distance is minimized.

Recall from Section 2.3.4 that one way to characterize problems is according

to their answer to the question, "Is a good solution absolute or relative?"

Absolute solutions exist whenever it is possible to recognize a goal state just

by examining it. Getting downtown is an example of such a problem. For these

problems, hill climbing can terminate whenever a goal state is reached. Only

relative solutions exist, however, for maximization (or minimization) problems,

suchjs the traveling salesman problem. In these problems, there is no a priori

goal state. For problems of this sort, it makes -sense to terminate hill climbing

when there is no reasonable alternative state to move to.

What we are calling the heuristic function is sometimes also called

the objective function, particularly in the literature of mathematical

optimization.

Simple Hill Climbing

The simplest way to implement hill climbing is as follows.

Algorithm: Simple Hill Climbing

1. Evaluate the initial state. If it is also a goal state, then return it and quit.

Otherwise, continue with the initial state as the current state.

2. Loop until a solution is found or until there are no new operators left to be

applied in the current state:

Select an operator that has riot yet been applied to the current state and apply

it to produce a new state.

Evaluate the new state, i. If it is a goal state, then return it and quit, ii. If it is

not a goal state but it is better than the current state, then make it

the current state, iii. If it is not better than the current state, then continue

in the loop.

The key difference between this algorithm and the one we gave for generate-

and test is the use of an evaluation function as a way to inject task-specific

knowledge into the control process. It is the use of such knowledge that makes

this and the other methods discussed in the rest of this chapter heuristic search

methods, and it is that same knowledge that gives these methods their power to

solve some otherwise intractable problems.

Notice that in this algorithm, we have asked the felativelvjrapue question, "Is

one state better than another?" For the algorithm to work, a precise definition

of better must be provided. In some cases, .it meiuis a higher value of the

heuristic function. In others, it means a lower value. It does not matter'which,

as long as a particular hill-climbing program is consistent in its interpretatidh."

To see how hill climbing works, let's return to the puzzle of the four colored

blocks. To solve the problem, we first need to define a heuristic function that

describes how close a particular configuration is to being a solution. One,such

function 1$ Simply the sum of the number of different colors on each of the four

sides. A solution to the puzzle will have a value of 16. Next we need to define a

set of rules that describe ways of transforming one configuration into another.

Actually, one rule will suffice. It says simply pick a block and rotate it 90

degrees in any direction. Having provided these definitions, the next step is to

generate a starting configuration. This can either be done at random or with the

aid of the heuristic function described in the last section. Now hill climbing can

begin. We generate a new state by selecting a block and rotating it. If the

resulting state is better, then we keep it. If not, we return to the previous state

and try a different perturbation.

(a) Can Solution Steps Be Ignored or Undone? Explain with example,

Suppose we are trying to prove a mathematical theorem. We proceed by first

proving a lemma that we think will be useful. Eventually, we realize that the

lemma is no help at all. Are we in trouble?

No. Everything we need to know to prove the theorem is still, true and in

memory, if it ever was. Any rules that could have been applied at the outse?

can still be applied. We can just proceed as we should have in the first place.

All we have lost is the effort that was spent exploring the blind alley.

Now consider a different problem.

jf The 8-Puzzle: The 8-puzzle is a square tray in which are placed, eight \s

square tiles. The remaining ninth square is uncovered. Each tile has a

Nurnberg on it. A tile that is adjacent to the blank space can be slid into

that space. A game consists of a starting position and a specified goal

position. The goal is to transform the starting position into the goal position

by sliding the tiles around.

A sample game using the 8-puzzle is shown in Figure 2.12. In attempting to

solve the 8-puzzle, we might make a stupid move. For example, in the game

shown above, we might start by sliding tile 5 into the empty space. Having

done that, we cannot change our mind and immediately slide tile 6 into the

empty space since the empty space will essentially have moved. But we can

backtrack and undo the first move, sliding tile.5 back to where it was. Then we

can move tile, 6. Mistakes can still be recovered from but not quite as easily as

in the theorem-proving problem. An additional step must

be performed to undo each incorrect step, whereas no action was required to

"undo" a useless lemma. In addition, the control mechanism for an .8puzzle

solver must keep track of the order in which operations are performed so that

the operations can be undone one at a time if necessary. The control structure

for a theorem prover does, not need to record all that information.

Now consider again the problem of playing chess. Suppose a chess-playing

program makes a stupid move and realizes it a couple of moves later. It

cannot fcimply play as though it had never made the stupid move. Nor can it

simply back up and start the game over from that point. All it can do is to try

to make the best of the,current situation and go on from there.

(b)Write and explain agenda driven algorithm. 1

Algorithm: Agenda-Driven Search

1. Do until a goal state is reached or the agenda is empty:

(a) Choose the most promising task from the agenda. Notice that this task

can be represented in any desired form. It can be thought of as an

explicit statement of what to do next or simply as an indication of the

next node to be expanded.

(b) Execute the task by devoting to it the number of resources determined by its importance. The important resources to consider are time and

space. Executing the task will probably generate additional tasks

(successor nodes). For each of them, do the following:

i. See if it is already on the agenda. If so, then see if this same reason

for doing it is already on its list of justifications. If so, ignore this

current evidence. If this justification was not already present, add it

to the list. If the task was not on the agenda, insert it.

ii. Compute the new task's rating, combining the evidence from all its

justifications. Not all justifications need have equal weight. It is often

useful to'associate with each justification a measure of how strong a

reason it is. These measures are then combined at this step to

produce an overall rating for the task.

One important question that arises in agenda-driven systems is how to find

the most promising task on each cycle. One way to do this is simple. Maintain

the agenda sorted by rating. When a new task is created, insert it into the

agenda in-its proper place. When a task has its justifications changed,

recompute its rating and move it to the correct place in the list. But this method

causes a great deal of time to be spent keeping the agenda in perfect order

Much of this time is wasted since we do not need perfect order. We only need to

know the proper first element. The following modified strategy may occasionally

cause a task other than the best to be executed, but it is significantly cheaper

than the perfect method. When a task is proposed, or a new justification is

added to an existing task, compute the new rating and compare it against the

top few Xe.g., five or ten) elements on the agenda. If it is better, insert the

node into its proper position at the top of the list. Otherwise, leave it where it is

or simply insert it at the end of the agenda. At the beginning of each cycle,

choose the first task on the agenda. In addition, once in a while, go through the

agenda and reorder it properly.

An agenda-driven control structure is also useful if some tasks (or nodes)

provide negative evidence about the merits of other tasks (or nodes). This can

be represented by justifications with negative weightings. If these negative

weightings are used, it may be important to check not only for the possibility of

moving a task to the head of the agenda but also of moving a top task to the

bottom if new, negative justifications appear. But this is easy tq.do.

As you can see, the agenda mechanism provides a good way of focusing the

attention of a complex system in the areas suggested by the greatest number of

positive indicators. But the overhead for each task executed may be fairly high.

This raises the question of (he proper grain size for the division of the entire

problem-solving process into individual tasks. Suppose each task is very small.

Then we will never do even a very small thing unless it realjy is the best thing to

do. But we will spend a large percentage of our total effort on figuring out what

to do next. If, on the other hand, the size of an individual task is very large,

then some effort may be spent finishing one task when there are more

promising ones that could be done. But a smaller percentage of the total time

will be" spent on the overhead of figuring out what to do. The exact choice of

task size for a particular system depends on the extent to which doing one small

thing really means that a set of other small things is likely to be very good to do

too. It often requires some experimentation to get right.

There are some problem domains for which an agenda mechanism is

inappropriate. The agenda"mechanism assumes that if there is good reason to

do something now, then there will also be the same good reason to do

something later unless something better comes along in the interim. But this is

not always the case, particularly for systems that are interacting with people.

The following dialogue would not be acceptable to most people:

Person: I don't want to read any more about China. Give me something ejse.

Computer: OK. What else are you interested in?

Person: How about Italy? I think I'd find Italy fascinating.

Computer: What things about Italy are you interested in reading about?

Q-3(a) Explain heuristic Search. Ans:

Definition:

A Heuristic is an operationally-effective nugget of information on how to direct search in a problem space. Heuristics are only approximately correct. Their purpose is to minimize search on average.

Common Types of Heuristics

"If-then" rules for state-transition selection

Macro-operator formation [discussed later]

Problem decomposition [e.g. hypothesizing islands on the search path]

Estimation of distance between Scurr and SG. (e.g. Manhattan, Euclidian, topological distance)

Value function on each Succ(Scurr)

cost(path(S0, Scurr)) + E[cost(path(Scurr,SG))]

Utility: value(S) cost(S)

Heuristic Search

Value function: E(o-Path(S0, Scurr), Scurr, SG) Since S0 and SG are constant, we abbreviate E(Scurr) General Form:

1. Quit if done (with success or failure), else: 2. s-Queue:= F(Succ(Scurr),s-Queue) 3. Snext:= Argmax[E(s-Queue)] 4. Go to 1, with Scurr:= Snext

Steepest-Ascent Hill-Climbing

F(Succ(Scurr), s-Queue) = Succ(Scurr) Snext:= Argmax[E(Succ(Scurr))] If Succ(Snext) is null, then stop Quintessential greedy search

Max-Gradient Search

"Informed" depth-first search

Snext:= Argmax[E(Succ(Scurr))] But if Succ(Snext) is null, then backtrack Alternative: backtrack if E(Snext)

Q-3(c) List out merits & demerits of DFS & BFS. Ans:

Depth first search is another way of traversing graphs, which is closely related to preorder traversal of a tree. Recall that preorder traversal simply visits each node before its children. It is most easy to program as a recursive routine

BFS: This can be throught of as being like Dijkstra's algorithm for shortest paths, but with every edge having the same length. However it is a lot simpler and doesn't need any data structures. We just keep a tree (the breadth first search tree), a list of nodes to be added to the tree, and markings (Boolean variables) on the vertices to tell whether they are in the tree or list.

Q-3(d)(i)Construct The Semantic Net For The All Indian Likes Football Q-3(e) Ans:

A Tree structure is a way of representing the hierarchical nature of a structure in a graphical form. In computer science, a tree is a widely-used data structure that emulates a hierarchical tree structure with a set of linked nodes.

A node is a structure which may contain a value, a condition, or represent a separate data structure (which could be a tree of its own). Each node in a tree has zero or more child nodes, which are below it in the tree (by convention, trees are drawn growing downwards). A node that has a child is called the child's parent node (or ancestor node, or superior). A node has at most one parent.

Nodes that do not have any children are called leaf nodes. They are also referred to as terminal nodes.

A free tree is a tree that is not rooted.

The height of a node is the length of the longest downward path to a leaf from that node. The height of the root is the height of the tree. The depth of a node is the length of the path to its root (i.e., its root path). This is commonly needed in the manipulation of the various self balancing trees, AVL Trees in particular. Conventionally, the value -1 corresponds to a subtree with no nodes, whereas zero corresponds to a subtree with one node.

The topmost node in a tree is called the root node. Being the topmost node, the root node will not have parents. It is the node at which operations on the tree commonly begin (although some algorithms begin with the leaf nodes and work up ending at the root). All other nodes can be reached from it by following edges or links. (In the formal definition, each such path is also unique). In diagrams, it is typically drawn at the top. In some trees, such as heaps, the root node has special properties. Every node in a tree can be seen as the root node of the subtree rooted at that node.

An internal node or inner node is any node of a tree that has child nodes and is thus not a leaf node. A sub tree of a tree T is a tree consisting of a node in T and all of its descendants in T.

Tree representations

There are many different ways to represent trees; common representations represent the nodes as records allocated on the heap (not to be confused with the heap data structure) with pointers to their children, their parents, or both, or as items in an array, with relationships between them determined by their positions in the array

Trees and graphs

The tree data structure can be generalized to represent directed graphs by removing the constraints that a node may have at most one parent, and that no cycles are allowed. Edges are still abstractly considered as pairs of nodes, however, the terms parent and child are usually replaced by different terminology.

Relationship with trees in graph theory

In graph theory, a tree is a connected acyclic graph; unless stated otherwise, trees and graphs are undirected. There is no one-to-one correspondence between such trees and trees as data structure. We can take an arbitrary undirected tree, arbitrarily pick one of its vertices as the root, make all its edges directed by making them point away from the root node - producing an arborescence - and assign an order to all the nodes. The result corresponds to a tree data structure. Picking a different root or different ordering produces a different one.

Q-4(A) Explain Expert System Architecture In Artificial Intelligence.

An expert system is, typically, composed of two major components, the Knowledge-base and the Expert System Shell. The Knowledge-base is a collection of rules encoded as metadata in a file system, or more often in a relational database. The Expert System Shell is

a problem-independent component housing facilities for creating, editing, and executing rules. A software architecture for an expert system is illustrated in Figure 2.

The shell portion includes software modules whose purpose it is to,

Process requests for service from system users and application layer modules; Support the creation and modification of business rules by subject matter experts; Translate business rules, created by a subject matter experts, into machine-readable

forms; Execute business rules; and Provide low-level support to expert system components (e.g., retrieve metadata from

and save metadata to knowledge base, build Abstract Syntax Trees during rule translation of business rules, etc.).

4.1 Client Interface

The Client Interface processes requests for service from system-users and from application layer components. Client Interface logic routes these requests to an appropriate shell program unit. For example, when a subject matter expert wishes to create or edit a rule, they use the Client Interface to dispatch the Knowledge-base Editor. Other service requests might schedule a rule, or a group of rules, for execution by the Rule Engine.

4.2 Knowledge Base Editor

The Knowledge-base Editor is a simple text editor, a graphical editor, or some hybrid of these two types. It provides facilities that enable a subject matter expert to compose and add rules to the Knowledge-base.

4.3 Rule Translator

Rules, as they are composed by subject matter experts, are not directly executable. They must first be converted from their human-readable form into a form that can be interpreted by the Rule Engine. Converting rules from one form to another is a function performed by the Rule Translator.

The translation of rules in their original form to a machine-readable form requires parsing the textual representation to obtain a data structure referred to as an Abstract Syntax Tree (AST). The AST representation of rules is the memory-resident data structure that guides execution of the inference engine when it comes time to apply a rule. The AST is an abstract data type designed to make its interpretation by the Rule Engine simple and efficient. This abstract data type is very expressive and permits the construction of very complex and powerful rules. There is a third form in which rules may be expressed. A rule AST is converted into an equivalent form suitable for storage in the Knowledge-base. The way in which this information appears in the Knowledge-base depends on the storage technology. Relational databases provide an especially convenient and efficient means for storing metadata. The metadata corresponding to an AST in this case would reside in a collection of tables. The specific scheme chosen for saving the metadata must permit the ASTs to be rapidly reconstructed using database queries.

The diagram in Figure 3 summarizes the several conversion operations the Rule Translator must perform as it adds rules to the Knowledge-base and as it retrieves rules from the Knowledge-base for execution.

To make these ideas concrete, consider the arithmetic espression,

(a-b) / [x*(c-d)] ,

that might form some part of a rule. In the AST representation, this portion of the rule would be expressed as a binary tree, like the one in Figure 4, whose nodes are either arithmetic operators or operands.

Once created, AST representations are converted into rule metadata and stored in the Knowledge-base. Rule metadata is simply a compact representation of ASTs. The role of the Rule Translator in the rule editing process is illustrated in the data flow diagram of Figure 5.

In translating rules from one form to another, the structure of the original rule is never lost. It is always possible to recreate a human-readable rule, exactly, from its Knowledge-base representation or from its AST representation.

4.4 Rule Engine

The Rule Engine (often referred to as an inference engine in AI literature) is responsible for executing Knowledge-base rules. It retrieves rules from the Knowledge-base, converts them to ASTs, and then provides them to its rule interpreter for execution. The Rule Engine interpreter traverses the AST, executing actions specified in the rule along the way. This process is depicted in Figure 6.

4.5 Rule Object Classes The shell component, Rule Object Classes, is a container for object classes supporting,

Rule editing; AST construction; Conversion of ASTs to rule metadata; Conversion of rule metadata to ASTs; and Knowledge-base operations (query, update, insert, delete).

Q-4(b)Explain NLP

A Closure View:

Evaluation Of natural-language-understanding Systems:

Q-4(c)Explain AO* Algoritms. Data Structure

Graph

Marked Connectors (down; unlike A*) Costs q() maintained on nodes SOLVED markings

Note: Well discuss on acyclic graphs.

Basic Idea Of AO*

First top-down graph growing picks out best available partial solution sub-graph from explicit graph.

One leaf node of this graph is expanded

Second, bottom-up cost-revising, connector-marking, SOLVE-labeling

AO* Algorithm:

1. Create G = ; q(s) = h (s) If s e TERM mark s SOLVED

2. Until s labeled SOLVED do:

1. Compute G partial solution subgraph of G by tracing down marked connectors in G from s.

2. Select n in G, n not in TERM, n a leaf.

3. Expand n , place successors in G, for each successor not already in G let q(successor)=h (successor). Label SOLVED all successors in TERM. (If no successors, reset q(n) := infinity ).

4. Let S := {n}. 5. Until S = f do :

1. Remove a node, m, from S which has no descendent in G also in S (minimal node).

2. Revise cost for m, (check each connector from m) q(m)=min [c +q(n1)++q(nk )]. Mark chosen connector. If all successors their connectors are SOLVED then mark m SOLVED.

3. If m SOLVED or changed q(m) then add to S all preferred parents of m.

4. End.

6. End.

Tracing the Algorithm:

Que.6

A. Explain nearest neighbour algorithm with example. Ans.

The nearest neighbor algorithm and the closely related repetitive nearest neighbor algorithm is a greedy algorithm for finding candidate solutions to the traveling salesman problem. The nearest neighbor algorithm begins at the first city in your list of cities to visit. It then selects the closest city to visit next. From the remaining unvisited cities it selects the city closest to city two and so on.

The nearest neighbour algorithm was one of the first algorithms used to determine a solution to the travelling salesman problem. It quickly yields a short tour, but usually not the optimal one.

Below is the application of nearest neighbour algorithm on TSP

These are the steps of the algorithm:

1. stand on an arbitrary vertex as current vertex. 2. find out the lightest edge connecting current vertex and an unvisited vertex V. 3. set current vertex to V. 4. mark V as visited. 5. if all the vertices in domain are visited, then terminate. 6. Go to step 2.

The sequence of the visited vertices is the output of the algorithm.

The nearest neighbour algorithm is easy to implement and executes quickly, but it can sometimes miss shorter routes which are easily noticed with human insight, due to its "greedy" nature. As a general guide, if the last few stages of the tour are comparable in length to the first stages, then the tour is reasonable; if they are much greater, then it is likely that there are much better tours. Another check is to use an algorithm such as the lower bound algorithm to estimate if this tour is good enough.

In the worst case, the algorithm results in a tour that is much longer than the optimal tour. To be precise, for every constant r there is an instance of the traveling salesman problem such that the length of the tour length computed by the nearest neighbour algorithm is greater than r times the length of the optimal tour. Moreover, for each number of cities there is an assignment of distances between the cities for which the nearest neighbor heuristic produces the unique worst possible tour

B. Explain architecture of ANN. Ans. 1.1 Feed-forward networks

Feed-forward ANNs (figure 1) allow signals to travel one way only; from input to output. There is no feedback (loops) i.e. the output of any layer does not affect that same layer. Feed-forward ANNs tend to be straight forward networks that associate inputs with outputs. They are extensively used in pattern recognition. This type of organisation is also referred to as bottom-up or top-down.

1.2 Feedback networks Feedback networks (figure 1) can have signals travelling in both directions by introducing loops in the network. Feedback networks are very powerful and can get extremely complicated. Feedback networks are dynamic; their 'state' is changing continuously until they reach an equilibrium point. They remain at the equilibrium point until the input changes and a new equilibrium needs to be found. Feedback architectures are also referred to as interactive or recurrent, although the latter term is often used to denote feedback connections in single-layer organisations.

Figure 1.1 An example of a simple feedforward network

Figure 1.2 An example of a complicated network

1.3 Network layers The commonest type of artificial neural network consists of three groups, or layers, of units: a layer of "input" units is connected to a layer of "hidden" units, which is connected to a layer of "output" units. (see Figure 1.1)

The activity of the input units represents the raw information that is fed into the network. The activity of each hidden unit is determined by the activities of the input units and the weights on the

connections between the input and the hidden units. The behaviour of the output units depends on the activity of the hidden units and the weights between

the hidden and output units.

This simple type of network is interesting because the hidden units are free to construct their own representations of the input. The weights between the input and hidden units determine when each hidden unit is active, and so by modifying these weights, a hidden unit can choose what it represents

We also distinguish single-layer and multi-layer architectures. The single-layer organisation, in which all units are connected to one another, constitutes the most general case and is of more potential computational power than hierarchically structured multi-layer organisations. In multi-layer networks, units are often numbered by layer, instead of following a global numbering.

1.4 Perceptrons The most influential work on neural nets in the 60's went under the heading of 'perceptrons' a term coined by Frank Rosenblatt. The perceptron (figure 4.4) turns out to be an MCP model ( neuron with weighted inputs ) with some additional, fixed, pre--processing. Units labelled A1, A2, Aj ,Ap are called association units and their task is to extract specific, localised featured from the input images. Perceptrons mimic the basic idea behind the mammalian visual system. They were mainly used in pattern recognition even though their capabilities extended a lot more.

Figure 1.4

C. Explain fuzzy set and crisp set. Mention application of fuzzy logic. Ans.

Fuzzy set: A fuzzy set is a pair (A,m) where A is a set and . For each , m(x) is called the grade of membership of x in (A,m). For a finite set A =

{x1,...,xn}, the fuzzy set (A,m) is often denoted by {m(x1) / x1,...,m(xn) / xn}. Let . Then x is called not included in the fuzzy set (A,m) if m(x) = 0, x is called fully

included if m(x) = 1, and x is called fuzzy member if 0

The point of an ABS is to monitor the braking system on the vehicle and release the brakes just before the wheels lock. A computer is involved in determining when the best time to do this is. Two main factors that go into determining this are the speed of the car when the brakes are applied, and how fast the brakes are depressed. Usually, the times you want the ABS to really work are when you're driving fast and slam on the brakes. There is, of course, a margin for error. It is the job of the ABS to be "smart" enough to never allow the error go past the point when the wheels will lock

D. Explain cut predicate in detail. Ans. Prolog provides a predicate that performs this function. It is called the cut/1, represented by an exclamation point (!).

The cut/1 effectively tells Prolog to freeze all the decisions made so far in this predicate. That is, if required to backtrack, it will automatically fail without trying other alternatives. We will first examine the effects of the cut/1 and then look at some practical reasons to use it . When the cut/1 is encountered, it re-routes backtracking. It short-circuits backtracking in the goals to its left on its level, and in the level above, which contained the cut/1. That is, both the parent goal and the goals of the particular rule being execut/1ed are affected by the cut/1. The effect is undone if a new route is taken into the parent goal. We will write some simple predicates that illustrate the behavior of the cut/1, first adding some data to backtrack over. data(pentiumIII) data(athlon). Here is the first test case. It has no cut/1 and will be used for comparison purposes. compare_cut_1(X) :- data(X). compare_cut_1('last chip'). This is the control case, which exhibits the normal behavior. ?- compare_cut_1(X), write(X), nl, fail. pentiumIII Athlon last chip no

Next, we put a cut/1 at the end of the first clause. compare_cut_2(X) :- data(X), !. compare_cut_2('last chip'). Note that it stops backtracking through both the data subgoal (left), and the compare_cut_2/1 parent (above). ?- compare_cut_2(X), write(X), nl, fail. pentiumIII no

Next we put a cut/1 in the middle of two subgoals. compare_cut_3(X,Y) :- data(X), !, data(Y). compare_cut_3('last chip'). Note that the cut inhibits backtracking in the parent compare_cut_3/2 and in the goals to the left of before) the cut (first data). The second data/1 to the right of (after) the cut is still free to backtrack. ?- compare_cut_3(X,Y), write(X-Y), nl, fail. pentiumIIIpentiumIII

pentiumIIIAthlon no

Performance is the main reason to use the cut/1. This separates the logical purists from the pragmatists. Various arguments can also be made as to its effect on code readability and maintainability. It is often called the 'goto' of logic programming. You will most often use the cut/1 when you know that at a certain point in a given predicate, Prolog has either found the only answer, or if it hasn't, there is no answer. In this case you insert a cut/1 in the predicate at that point. Similarly, you will use it when you want to force a predicate to fail in a certain situation, and you don't want it to look any further.

E. Explain properties of good knowledge representation system. Ans. The following properties should be possessed by a knowledge representation system.

Representational Adequacy

->the ability to represent the required knowledge; inferential Adequacy

- the ability to manipulate the knowledge represented to produce new knowledge corresponding to that inferred from the original;

Inferential Efficiency - the ability to direct the inferential mechanisms into the most productive directions by storing appropriate guides;

Acquisitional Efficiency - the ability to acquire new knowledge using automatic methods wherever possible rather than reliance on human intervention.

Que.5 A. Explain how file operation can be done in prolog?

Ans. When one writes a Prolog program, usually the facts and rules of the program are stored in a (text) file, and then loaded into the Prolog interpreter. Files have other uses in Prolog, too.

For example, we may wish to write out a table of results that have been computed for us by our Prolog program. One can use built-in predicates like write, nl, putc, tab and others to write out the table, but by default it will appear on the computer screen. To direct this output to a file, we use the tell built-in predicate. Suppose that we wish to write the table to a file called "mytable.data". By executing the (pseudo-)goal tell("mytable.data"), we tell Prolog that the new current output stream is to be the file "mytable.data". Subsequent writes will go to this file. When one wishes to stop writing to the file and resume writing on the screen, one uses the built-in predicate told (with no arguments). Also, the query ?- telling(X).bindsX to the name of the current output file. If the current output stream is not a file, then X will be bound to something that indicates that the current output stream is the screen - for example, in Unix, X may be bound to the atom stdout (standard output, which is normally the screen). Example:

?- tell('mytable.data'), write('***** Table of results *****'), nl, told. % the file mytable.data should now contain a single line of text as above

The built-in Prolog predicate append/1 is like tell, except that it arranges for subsequent write operations to add data to the end of the specified file, rather than overwriting the file with the first subsequent write operation. If myothertable.data initially contains, say, a single line, This is the first line, then append/1 works as follows:

?- append('myotherfile.dat'), write('Here is another line'), nl. true. ?- halt. % cat myotherfile.dat # - # is Unix comment char, cat lists file contents This is the first line Here is another line

%

The situation for reading from a file is analogous to writing (except that there is no analogue for append/1). One can use built-in predicates like read, getc and others to read, by default from the keyboard. By executing the (pseudo-)goal see('mydata.text'), we tell Prolog that the new current input stream is to be the file mydata.text. Subsequent reads will come from this file. When one wishes to stop reading from the file and resume reading from the keyboard, one uses the built-in predicate seen (with no arguments). Also, the query ?- seeing(X).bindsX to the name of the current input file. If the current input stream is not a file, then X will be bound to something that indicates that the current output stream is the screen - for example, in Unix, X may be bound to the atom stdin (standard input, which is normally the keyboard). Example:

?- see('mydata.text'), read(X), seen, write(X), nl. % the first Prolog term in the file mydata.text should now appear % on the screen, having been read from the file with read(X), and then % written to the screen with write(X) and nl.

What happens if you try to read from a file and there is nothing (left) to read, either because the file is empty, or you have previously read everything there was to read in this file? In this case, Prolog binds the variable that was the argument to read to the special atom end_of_file. Knowing this means that you can test after a read to make sure that you did not hit end of file. Example:

?- see('empty.dat'), read(Term). Term = end_of_file

B. Explain back tracing with example. Ans.

Backtracking is a general algorithm for finding all (or some) solutions to some computational problem, that incrementally builds candidates to the solutions, and abandons each partial candidate c ("backtracks") as soon as it determines that c cannot possibly be completed to a valid solution.

Example:Constraint satisfaction

The general constraint satisfaction problem consists in finding a list of integers x = (x[1],x[2], , x[n]), each in some range {1, 2, , m}, that satisfies some arbitrary constraint (boolean function) F.

For this class of problems, the instance data P would be the integersm and n, and the predicate F. In a typical backtracking solution to this problem, one could define a partial candidate as a list of integers c = (c[1],c[2], c[k]), for any k between 0 and n, that are to be assigned to the first k variables x[1],x[2], , x[k]). The root candidate would then be the empty list (). The first and next procedures would then be

functionfirst(P,c) k length(c) ifk = n thenreturn elsereturn (c[1], c[2], , c[k], 1)

functionnext(P,s) k length(s) ifs[k] = m thenreturn elsereturn (s[1], s[2], , s[k-1], 1 + s[k])

Here "length(c)" is the number of elements in the list c.

The call reject(P,c) should return true if the constraint F cannot be satisfied by any list of n integers that begins with the k elements of c. For backtracking to be effective, there must be a way to detect this situation, at least for some candidatesc, without enumerating all those mn-kn-tuples.

For example, if F is the conjunction of several boolean predicates, F = F[1] F[2] F[p], and each F[i] depends only on a small subset of the variables x[1], , x[n], then the reject procedure could simply check the terms F[i] that depend only on variables x[1], , x[k], and return trueif any of those terms returns false. In fact, reject needs only check those terms that do depend on x[k], since the terms that depend only on x[1], , x[k-1] will have been tested further up in the search tree.

Assuming that reject is implemented as above, then accept(P,c) needs only check whether c is complete, that is, whether it has n elements.

It is generally better to order the list of variables so that it begins with the most critical ones (i.e. the ones with fewest value options, or which have a greater impact on subsequent choices).

One could also allow the next function to choose which variable should be assigned when extending a partial candidate, based on the values of the variables already assigned by it. Further improvements can be obtained by the technique of constraint propagation.

In addition to retaining minimal recovery values used in backing up, backtracking implementations commonly keep a variable trail, to record value change history. An efficient implementation will avoid creating a variable trail entry between two successive changes when there is no choice point, as the backtracking will erase all of the changes as a single operation.

An alternative to the variable trail is to keep a timestamp of when the last change was made to the variable. The timestamp is compared to the timestamp of a choice point. If the choice point has an associated time later than that of the variable, it is unnecessary to revert the variable when the choice point is backtracked, as it was changed before the choice point occurred.

Or

Que.5 A. WAP to form the union of two list.

Ans.

domains

integerlist=integer*

predicates

inter_union(integerlist,integerlist)

intersect(integerlist,integerlist,integerlist)

union(integerlist,integerlist,integerlist)

delete(integer,integerlist,integerlist)

member(integer,integerlist)

clauses

inter_union(L1,L2):-

write("Intersection\n"),

intersect(L1,L2,L4),

write(L4),

write("\n Union\n"),

union(L1,L2,L4),

write(L4),

nl.

intersect([H|Tail1],L2,[H|Tail3]):- member(H,L2),

intersect(Tail1,L2,Tail3).

intersect([H|Tail1],L2,Tail3):- not(member(H,L2)),

intersect(Tail1,L2,Tail3).

intersect([],_,[]).

member(X,[X|_]). member(X,[Head|Tail]):- not(X=Head),

member(X,Tail).

union([],L,L).

union([H|Tail1],L2,[H|Tail3]):- member(H,L2),

delete(H,L2,L3),

union(Tail1,L3,Tail3).

union([H|Tail1],L2,[H|Tail3]):- not(member(H,L2)),

union(Tail1,L2,Tail3).

delete(X,[X|Tail],Tail):- !.

delete(X,[Y|Tail],[Y|Z]):-

delete(X,Tail,Z).

B. WAP to reverse the given list. Ans.

domains

list=integer* predicates seln_sort(list,list) minimum(list,integer,integer) efface(list,integer,list) clauses seln_sort([X|Xs],[Y|Ys]):-minimum(Xs,X,Y),efface([X|Xs],Y,Zs),seln_sort(Zs,Ys). seln_sort([],[]). minimum([Y|Ys],X,Z):-Y