UNIT-IVKnowledge Representation: Introduction, approaches to knowledge representation, knowledge representation using semantic network, extended semantic networks for KR, knowledge representation using frames, Advanced knowledge representation techniques: Introduction, conceptual dependency theory, script structure, cyc theory, case grammars, semantic web

4.1 Introduction

In the preceding chapters, we have discussed problem-solving techniques using search graphs of solution paths; predicate logic for storing knowledge and inferencing new knowledge while solving problems requiring concepts of artificial intelligence (AI). We now proceed to familiarize ourselves with various other knowledge representation (KR) techniques. Knowledge representation is an important issue in both cognitive science and AI. In cognitive science, it is concerned with the way in which information is stored and processed by humans, while in AI, the main focus is on storing knowledge or information in such a manner that programs can process it and achieve human intelligence. Traditionally, knowledge representation was concerned with the ways in which knowledge was stored in an information system to accomplish a given task. In AI, knowledge representation is an important area because intelligent problem solving can be achieved and simplified by choosing an appropriate knowledge representation technique. Representing knowledge in some specific ways makes certain problems easier to solve. In computer science, particularly in AI, a number of representations have been devised to structure information. Since knowledge needs to be utilized to achieve intelligent behaviour, the fundamental goal of knowledge representation is to represent knowledge in a manner that facilitates the process of inferencing (i.e., drawing conclusions) from it.

Several programming languages oriented to knowledge representation have been developed till date. The languages such as SGML,XML,RDF, etc., for handling electronic documents in web systems, have been developed in order to represent the structure of documents more explicitly. These languages facilitate processes such as information retrieval, data mining, etc., which are also related to the field of KR. Any knowledge representation system should possess properties such as learning, efficiency in acquisition, representational adequacy, and inferential adequacy. These properties may be defined as follows:

Learning refers to a capability that acquires new knowledge, behaviours, understanding, etc. It does not simply involve adding new facts to a knowledge base but new information may have to be classified to avoid redundancy and replication in the existing knowledge prior to storage to enable easy retrieval. There are a number of ways in which knowledge may be gained such as by reasoning and logic, by experience, by observing the world, by mathematical proofs, and by scientific methods.

Efficiency in acquisition refers to the ability to acquire new knowledge using automatic methods wherever possible rather than relying on human intervention.

Representational adequacy refers to the ability to represent the required knowledge.

Inferential adequacy refers to the ability of manipulating knowledge to produce new knowledge from the existing one.

Efficiency of a method depends greatly on the representation scheme of the knowledge. Many Al methods have tried to model human intelligence. Knowledge representation is a core component of a number of applications such as expert systems, machine translation systems, computer-aided maintenance systems, information retrieval systems, and database front-ends. In expert systems there are various ways of representing knowledge, namely, predicate logic, semantic networks frames, conceptual dependency, etc., which have originated from theories of human information processing. In predicate logic, knowledge is represented in the form of rules and facts. An expert system that incorporates knowledge in the form of rules and facts is called a rule-based expert system (discussed in the next chapter). Other representation schemes offer the ability to represent structured knowledge regarding physical or conceptual objects more easily than rules.

4.2 Approaches to Knowledge Representation

AI programs use structures known as knowledge structures to represent objects, facts, relationships, and procedures. The main function of these knowledge structures is to provide expertise and information so that a program can operate in an intelligent way. Knowledge structures are usually composed of both traditional and complex structures such as semantic network, frames, scripts, conceptual dependency structures, and so on. A knowledge base is a special type of database that holds knowledge of the domain. Knowledge bases share some of the functions of the database systems such as storing, updating, and retrieving information; however, they are much powerful and more structured. They are organized in hierarchical structures with in-built inheritance and inferencing capabilities. In the following subsections, we briefly survey some basic knowledge representation schemes.

4.2.1 Relational Knowledge

Relational knowledge comprises objects consisting of attributes and associated values. The simplest way of storing facts is to use a relational method. In this method, each fact is stored in a row of a relational table as done in relational database. A table is defined as a set of data values that is organized using a model of horizontal rows and vertical columns. The columns are identified by attribute names, while the rows are identified by the corresponding values appearing in a particular column subset. For example, a fact John is a male whose age is 38 years and who is a graduate with a salary of Rs 20000 may be easily represented as one row in a table with attributes the facts but gives little opportunity for inferencing; however, such structures can be used by {Name, Age, Sex, Qualification, and Salary} (Table 4.1). This representation helps in storing inference engines.

Table 4.1 Relational Table

Name Age (in years)

Sex Qualification Salary (in Rupees)

John 38 Male Graduate 20000

Mike 25 Male Undergraduate 15000

Mary 30 Female Ph D 25000

James 29 Male Graduate 18000

We can easily obtain the answers of the following queries (explicit) from Table 4.1:

What is the age of John? How much does Mary earn? What is the qualification of Mike?

However, we cannot obtain answers for queries (implicit) such as Does a person having a PhD qualification earn more? So, inferencing new knowledge is not possible from such structures.

4.2.2 Knowledge Represented as Logic

Inferential capability can be achieved if knowledge is represented in the form of formal logic. For example, knowledge regarding mortality such as All humans are mortal cannot be represented using relational approach; instead, it can be easily represented in predicate logic as follows:

(ĂX) human(X) + mortal(X)

If we have a fact John is human, then we can easily infer that John is mortal. The advantages of this approach are that we can represent a set of rules, derive more facts, truths, and verify the correctness of new statements. This topic is dealt in detail in Chapter 3.

4.2.3 Procedural Knowledge

Procedural knowledge is encoded in the form of procedures which carry out specific tasks based on relevant knowledge. For example, an interpreter for a programming language interprets a program on the basis of the available knowledge regarding the syntax and semantics of the language. The advantages of this approach are that domain-specific knowledge can be easily represented and side effects of actions may also be modelled. However, there is a problem of completeness and consistency. Completeness means that all cases may not be represented, while consistency means that all deductions may not be correct.

We can extend the approaches mentioned above for storing knowledge in the knowledge base by organizing data into a hierarchical structure that allows inheritance mechanism. Knowledge organized in the form of semantic network and frames is referred to as inheritable knowledge.

4.3 Knowledge Representation using Semantic Network

The basic idea applied behind using a semantic network is that the meaning of a concept is derived from its relationship with other concepts, and that, the information is stored by interconnecting nodes with labelled arcs. For example, consider the following knowledge:

• Every human, animal, and birds are living things who can breathe and eat. All birds can fly. Every man and woman are human who have two legs. A cat has fur and is an animal. All animals have skin and can move. A giraffe is an animal and has long legs and is tall. A parrot is a bird and is green in colour John is a man.

We can represent such knowledge using a structure called a semantic network (or semantic net,in short). It is conveniently represented in a graphical notation where nodes represent concepts or objects and arcs represent relation between two concepts. Alternatively, it can be described as a directed graph consisting of vertices representing concepts and edges that represent semantic relations between the concepts. Nodes can be easily added in this network. The graphical representation of this knowledge in semantic net is shown in Fig. 4.1.

In Fig. 4.1, we notice that the concepts or objects are related to each other by certain relations.The relations are represented in the figure by bold directed links. They may be defined as follows:

• isa This relation connects two classes (generic concepts), where one concept is a kind or subclass of the other concept. For example, Man isa Human, that is, Man is a subclass of the Human class.

• inst This relation relates specific members of a class, such as John is an instance of Man

Other relations such as {can, has, colour, height} are known as property relations. These have been represented by dotted lines pointing from the concept to its property. In this structure,

property inheritance is easily achieved. For example, the query Does a parrot breathe? can be easily answered as 'yes' even though this property is not associated directly with a parrot. It inherits this property from its super class named Living_Thing.

Figure 4.2 Concepts Connected with prop links

We notice that isa and inst links have well-defined meaning, whereas other links which connect the attributes of class vary in their interpretations. The semantic net interpreter cannot understand all the attribute links unless their semantics are encoded into it. Since all the attributes of the class are the properties, we can designate a unique name to such relations, say, prop link. The interpretation of prop link will be simple that the attribute attached to a class is one of its properties. The information encoded above can be represented as a directed graph as shown in Fig. 4.2. In this figure, the square nodes represent concepts or objects connected with isa or inst links, whereas oval nodes represent property attributes attached to the square nodes. Property links are shown as dotted lines for more clarity.

4.3.1 Inheritance in Semantic Net

Hierarchical structure of knowledge representation allows knowledge to be stored at the highest possible level of abstraction which reduces the size of the knowledge base. Since semantic net is stored as hierachical structure, the inheritence mechanism is in-built and facilitates inferencing of information associated with nodes in semantic net. It is a natural tool for representing taxonomically structured information and ensures that all the members and sub-concepts of a concept share common properties. It also helps us to maintain the consistency of the knowledge base by adding new concepts and members to existing ones. Properties attached to a particular

concept can easily inherited by all sub-concepts and their members. The algorithm to retrieve a property of an object (concept or instance) is given below

Algorithm 4.1 Property Inheritance Algorithm

Input: Object and property to be found from Semantic Net:

Output: returns yes, if the object has the desired property else returns false;

Procedure:

• Find an object in the semantic net;

. Found = false;

• While [(object + root) OR Found] DO

{

• If there is an attribute attached with an object then Found true;

else {object isa (object, class) or object inst (object class)}

};

• If Found true then report ‘Yes' else report 'No':

Prolog Facts

The facts in Prolog would be written as shown in Table 4.2.

Table 4.2 Prolog Facts

Isa facts Instance facts Property facts

isa(living_thing, nil). inst(john, man). prop(breathe, living_thing)

isa(human, living_thing). inst(giraffe, animal) prop(eat, living_thing).

isa(animals, living_thing). inst(parrot, bird) prop(two_legs, human).

isa(birds, living_thing) prop(skin, animal).

isa(man, human ). prop(move, animal)

isa(woman, human). prop(fur, bird).

isa(cat, animal). prop(tall, giraffe).

prop(long_legs, giraffe).

prop(tall, animal)

prop(green, parrot)

Inheritance Rules in Prolog

We know that in class hierarcy structure, a member subclass of a class is also a member of all super classes connected through isa link. For example, if man is a member of subclass human, then man is also member of living_class. Similarly, an instance of subclass is also an instance of all super classes connected by isa link. It should be noted that we cannot define an instance of an instance, that is, if john is an individual instance, then there cannot be another individual as an instance of john. Further, if john is an instance of man, then we can infer that john is human and also living_thing. Similarly, a property of a class can be inherited by lower sub-classes. A simple Prolog rule for handling inheritance in semantic net is given below. Varoius queries can be answered by the following inheritance program and are mentioned in Table 4.3.

Instance rules

instance(X, Y) - inst(X, Y).

instance (X, Y)- inst(X, Z), subclass(Z, Y).

Subclass rules

subclass(X, Y) - isa(X, Y).

subclass(X, Y)- isa(X, Z), subclass(Z, Y).

Property rules

property(X, Y)- prop(X, Y).

property(X, Y)- instance(Y,Z), property(X, Z).

property(X, Y)- subclass(Y, Z), property(X, Z).

Table 4.3 Various Queries for Inheritance Program

English query Prolog goal Output

Is john human? ?- instance(john, humans) Yes

Is parrot a living thing? 2- instance (parrot, living_thing).

Yes

Is giraffe an animal? ?- instance (giraffe, animal). Yes

Is woman a subclass of living thing?

?-subclass(woman, living_thing).

Yes

Does parrot fly? ?- property(fly, parrot). Yes

Does parrot have fur? ?- Does parrot have fur? No

Does john breathe? ?- property (john, breathe) Yes

Does cat fly? ?- property(fly, cat). No

4.4 Extended Semantic Networks for KR

Logic and semantic networks are two different formalisms that can be used for knowledge representations. Simple semantic network is represented as a directed graph whose nodes represent concepts or objects and arcs represent relationships between concepts or objects. It can only express collections of variable-free assertions (Kowalski, 1979). The English sentences john gives an apple to mike and john and mike are human may be represented in semantic network as shown in Fig.4.3, which shows alternative way of representing semantic net in detail with more semantic links

Figure 4.3 Semantic Net

Here, 'E' represents an event which is an act of giving, whose actor is John, the object is an apple, and recipient is mike. It should be noted that semantic net can hold semantic information about situation such as actor of an event giving is john and object is apple, in the sentence John gives an apple to mike. The relationships in the network shown in Fig. 4.3 can be expressed in clausal form of logic as follows:

object (E, apple).

action(E, give).

actor (E, john).

recipient(E, mike).

isa (john, human).

isa (mike, human)

Predicate relations corresponding to labels on the arcs of semantic networks always have two

arguments. Therefore, the entire semantic net can be coded using binary representation (two-

argument representation). Such representation is advantageous when additional information is

added to the given system. For example, in the sentence john gave an apple to mike in the

kitchen, it is easy to add location(E, kitchen) to the set of facts given above

In first-order predicate logic, predicate relation can have n arguments, where n ≥ 1. For example,

the sentence john gives an apple to mike is easily represented in predicate logic by give(john,

mike, apple). Here, john, mike, and apple are arguments, while give represents a predicate rela-

tion. The predicate logic representation has greater advantages compared to semantic net repre-

sentation as it can express general propositions, in addition to simple assertions. For example, the

sentence john gives an apple to everyone he likes is expressed in predicate logic by the clause

as follows:

give(john, X, apple) ←likes (john, X)

Here, the symbol X is a variable representing any individual. The arrow represents the logical

connective implied by. The left side of ← contains conclusion(s), while the right side contains

condition(s).

Despite all the advantages, it is not convenient to add new information in an n-ary representation of predicate logic. For example, if we have 3-ary relationship give(john, mike, apple) representing

john gives an apple to mike and to capture an additional information about kitchen in the sentence

john gave an apple to mike in the kitchen, we would have to replace the 3-ary representation

give(john, mike, apple) with a new 4-ary representation such as give(john, mike, apple, kitchen).

Further, a clause in logic can have several conditions, all of which must hold for the conclusion

to be true and can have several alternative conclusions, at least one of which must hold if all the

conditions are true. For example,

The sentence if john gives something he likes to a person, then he also likes that person can be expressed in clausal representation in logic as

likes(john, X) ← give(john, X, Y), likes(john, Y)

The sentence every human is either male or female is expressed by the following clause

male(X), female(X) ←human(X)

In conventional semantic network, we cannot express clausal form of logic. To overcome this

shortcoming, R Kowalski and his colleagues (1979) proposed an extended semantic network

(ESNet) that combines the advantages of both logic and semantic networks. ESNet can be inter-

preted as a variant syntax for the clausal form of logic; it has the same expressive power as that of

predicate logic with well-defined semantics, inference rules, and a procedural interpretation. It also

incorporates the advantages of using binary relation as in semantic network rather than n-ary

relations of logic. Therefore, ESNet is a much powerful representation as compared to logic and

semantic network. In ESNet, the terms are represented by nodes similar to as done in conventional

semantic network; constant, variable, and functional terms are represented by constant, variable

and functional nodes, respectively.

Binary predicate symbols in clausal logic are represented by labels on arcs of ESNet. An atom of

the form love(john, mary) is an arc labelled as love with its two end nodes representing john and

mary. The direction of the arc (link) indicates the order of the arguments of the predicate symbol

which labels the arc as follows:

Conclusions and conditions of clausal form are represented in ESNet by different kinds of arcs.

The arcs denoting conditions (negative atoms) are drawn with dotted arrow lines. These are called

denial links (------>), while the arcs denoting conclusions (positive atom) are drawn with continuous arrow lines. These are known as assertion links ( ). For example, the clausal representation (or rule) grandfather(X, Y) ← father(X, Z), parent(Z, Y) for grandfather in logic

can be represented in ESNet as given in Fig. 4.4. Here, X and Y are variables; grandfather(X, Y) is the consequent (conclusion), and father(X, Z) and parent(Z, Y) are the antecedents (conditions).

Figure 4.4 ESNet Representation

Similarly, the clausal rule male(X), female(X) ← human(X) can be represented using binary

representation as isa(X, male), isa(X, female) ← isa( X, human) and subsequently in ESNet as

shown in Fig. 4.5.

Figure 4.5 ESNet Representation

So, we have seen that any clause can be easily represented using ESNet which was not possible in

ordinary Semantic Net. Now, we will discuss the inferencing rules associated with ESNet.

4.4.1 Inference Rules

Inference rules are embedded in the representation itself. Some of the inference rules are being

discussed as follows:

The representation of the inference for every action of giving, there is an action of taking in clausal logic is action (f(x), take) ← action(X, give). The interpretation of this rule is that the event of taking action is a function of the event of giving action. In the ESNet representation, functional terms, such as f(X), are represented by a single node. The

representation of the statement action(f(X), take) ← action( X, give) in ESNet is as shown in Fig. 4.6,

Figure 4.6 ESNet Representation

The inference rule that an actor who performs a taking action is also the recipient of this action and can be easily represented in clausal logic; ESNet as given below. Here, E is a variable representing an event of an action of taking.

recipient(E, X) ← acton(E, take), actor (E, X)

ne representation of the above clause in ESNet is shown in Fig. 4.7.

Figure 4.7 ESNet Representation

Example 4.1 Represent the following clauses in ESNet:

recipient(E,X) ← action(E, take), actor (E, X)

object(e, apple).

action(e, take).

actor(e, john).

Solution: Here, E is a variable for some event and ‘e' is an actual event. ESNet representation of the clauses is shown in Fig. 4.8. Here, the partition is shown to delimit the clause pictorially by enclosing the clausal rule in an ellipse

Figure 4.8 ESNet Representation

The hierarchy links, isa, inst, and part_of (or prop), are available in semantic networks and are

also available as special cases in ESNet. It is important to note that part_of link has a hidden

existential quantifier. For example, the assertion every human has two legs could be represented

using part_of link as follows:

The interpretation of above representation is that for every human, there exist two legs which

are part of that human.

The contradiction in ESNet can be represented as shown in Fig. 4.9. Here P part of X is conclusion and P part_of Y is condition, where Y is linked with X via isa link. Such kind of representation is contradictory and hence there is a contradiction in ESNet.

Figure 4.9 Contradiction in ESNet

4.4.2 Deduction in Extended Semantic Networks

Inference rules discussed in subsection 4.4.1 along with its semantics, form a part of ESNet. We know that in logic there are two types of inference mechanisms, namely

forward reasoning inference mechanism backward reasoning inference mechanism

Forward reasoning inference mechanism (also called bottom-up approach) in clausal logic

derives new assertion from old ones, that is, in this mechanism, we start with the given assertions

and derive new assertions using clausal rule. On the other hand, in backward reasoning inference

mechanism (or top-down approach), we prove the query from the set of clauses using resolution

refutation method in clausal logic. Both these inference rules are available in ESNet also.

Forward Reasoning Inference

Given an ESNet, apply the following reduction (resolution) using modus ponen rule of logic {i.e.,given (A ← B) and B, then conclude A}. For example, consider the following set of clauses:

isa (X, human) ← isa(X, man)

isa(john, man).

Using modus ponen rule of logic, we can easily derive that isa(john, human) holds true. Now, let us derive or inference isa(john, human) using ESNet representation. The clauses are represented in ESNet as shown Table 4.4. The new assertion isa(john, human) is inferred by elimination of assertion and their denial links with the help of appropriate substitution. Here isa(X, human) is an assertion link and isa(X, man) is denial link.

Table 4.4 Forward Reasoning Inference Mechanism

Here the contradiction is enclosed in a rectangular box

Backward Reasoning Inference

In backward inferencing mechanism, we can prove a conclusion or goal from a given ESNet by adding the denial of the conclusion to the network and show that the resulting set of clauses in the network gives contradiction. This is done by performing successive steps of resolution until an explicit contradiction is generated. It is similar to proof by resolution refutation in clausal form of logic. Consider the set of clauses (given in Table 4.5) represented in clausal form. We need to prove isa(john, human) using the same network. The proof is shown in Table 4.5.

Table 4.5 Backward Reasoning Inference

After adding denial link in ESNet, we get the reduction in ESNet as shown in Table 4.6 by elimination of assertion and their denial link with the help of appropriate substitution.

Table 4.6 Reduction of ESNet

4.4.3 Example for Illustrating Inferencing Methods

Consider the following example, represented in clausal form:

isa(X, living_thing) ← isa(X, animate)

isa(X, animate) ← isa(X, human)

isa(X, human) ← isa(X, man)

isa(john, man)

The corresponding ESNet representation is shown in Fig. 4.10. Since the variables in different clauses are different, we choose different variables in ESNet to avoid confusion in the representation. Now, we proceed to illustrate both inferencing methods, namely, forward reasoning inference and backward reasoning inference, with the help of suitable examples.

Figure 4.10 ESNet Representation

Forward Reasoning Inference

The new assertion john is human can be inferred or derived as discussed in previous example. The steps for inferring that john is animate are given in Fig. 7:11. The assertion john is a living_thing can be inferred similarly.

Figure 7:11 Derivation of John is animate (iii)

Further, John is living_thing can be derived by binding X with John.

Backward Reasoning Inference

Let us solve a query isa(john, living thing) (i.e., Is John a living thing?) using backward inferencing mechanism. In this mechanism, we add the denial of the fact that John is not a living_thing in ESNet and see if we can derive inconsistency or an empty network. In Fig. 4.12, each part shows reduction in the network by elimination of assertions and their denial links with

the help of appropriate substitutions. Here denial links are enclosed in rectangular box to distinguish it from rest of network. Note that dotted lines are denial links, while continuous lines are assertion links. These are removed after substitution of actual value of a variable, if possible.

(i)

(ii)

Figure 4.12 Solving Query isal john, living_thing)

Hence, we can prove the query that john is an animate.

Let us consider another example. The sentences, “Anyone who gives something he likes to a

person likes that person also. John gives an apple to Mike. John likes an apple”, can be expressed

in both binary clausal form and ESNet representation as given below.

Clausal Representation

The clausal representation of the sentences given above may be written as

likes(X, Z) ← action(E, give), object(E, Y), actor(E, X), recipient(E, Z), likes(X, Y)

action(e, give).

object(e, apple).

actor(e, john).

recipient(e, mike).

likes(john, apple).

Here, E is a variable which will be bound to an actual event 'e' in the process of resolution.

ESNet Representation

The extended semantic network for the clauses described above is given in Fig. 4.13.

Figure 4.13 ESNet Representation

From ESNet given in Fig. 4.13, we will prove likes(john, mike). It can be proved by both forward and backward reasoning inference mechanisms. Proof of likes (john, mike) is shown below using both the methods.

Forward Reasoning Inference

Here we have to reduce the network by resolving clauses till we obtain the desired assertion. The network is given in Fig. 4.14. We can easily eliminate assertion and its corresponding denial with likes links by unifying Y = apple and X = john. The ESNet is reduced to the one shown in Fig. 4.14.

Figure 4.14 Reduced ESNet

The network shown in Fig. 4.14 is further reduced to the following conclusion by unifying E=e and Z = mike.

We can clearly see that a link likes between john and mike is deduced after eliminating all links which are assertions and denials. For example, action(e, give) is an assertion and action(E, give) is a denial, which is a contradiction and is hence eliminated. Similarly, other such eliminations take place and we are left with the final assertion likes (john, mike).

Backward Reasoning Inference

Let us now prove likes (john, mike) using backward reasoning method. In order to prove likes (john, mike), add the denial link to the network and try to reduce the network to empty. The denial link is shown as follows:

The reduction of the network is shown step by step in Fig. 4.15. Denial link is enclosed in

rectangular box.

(i)

(ii)

Figure 4.15 Reduction to Empty ESNet (iii)

When E is unified with ‘e’, then entire ESNet is reduced to contradiction and hence, the query likes(john,mike) is proved using backward reasoning inference process.

4.5 Knowledge Representation using Frames

Many of the ideas about frames and frame systems and how they can be used for the process of

knowledge representation were first introduced by Marvin Minsky (1975). Frames are regarded

as an extension to semantic nets; each node of a semantic net is represented by a frame. A frame

may be defined as a data structure that is used for representing a stereotyped situation. It

consists of a collection of attributes or slots and associated values that describe some real-world

entity. There are several types of information attached to each frame. Although frames are not

particularly helpful on their own, frame systems form a powerful way of encoding information that

supports reasoning. With the increase in complexity of a problem, the representation

should become more structured for more beneficial use. Therefore, frames may be considered to

represent the ways of organizing as well as packaging knowledge in a more structured form.

Frames are slightly similar to the concept of class of object-oriented paradigm; class also contains

attributes and methods. In frames, it consists of attributes or slots; slots are described with

attribute-value pairs <slot_name, value> Slots are generally complex structures that have facets

(or fillers) describing their properties. The value of a slot may be a primitive, such as a text string,

constant or an integer, or it may be another frame. So, slots may contain value, refer to other

frames (relations) or contain methods. Most of the frame systems allow multiple values for slots

and some systems support procedural attachments as well. These procedural attachments (meth-

ods) can be used for computing the slot value whenever required. Frames may contain triggers for

checking consistency or obtaining updates of other slots. Therefore, frames are basically a

machine-usable formalization of concepts or schemata. The general structure of a frame is given

in Table 4.7.

A frame may contain as many <slots-filler> pairs as required to describe an object. Fillers are also

known as facets. Each slot may contain one or more facets or fillers from the list given in Table 4.8.

A class frame generally has certain default values which can be redefined at lower levels. In case

a class frame possesses an actual value facet, then decedent frames cannot modify that value; this

value then remains unchanged for all subclasses and instances of that class. The related frames

are linked together into frame systems and are organized into hierarchies or network of frames,

Each frame in the network is either a class frame or an instance frame. As an example, a hospital

frame has been defined in Table 4.9 (Bedi, 1999).

Table 4.9 Hospital Frame

Ako: this link connects two class frames, one of which is kind of the other class, e.g., the class

child_hospital is a kind of the class hospital. A class can define its own slots and also inherits

slot-value pairs from its super class. It gives a sub-typing hierarchy where all instances of class

frame are instances of super class frames. For example, all child hospitals are hospitals but all

hospitals may not be child hospitals. With the help of this link, knowledge representation becomes

more structured and memory efficient.

Inst: This link connects a particular instance frame to a class frame, e.g., AIIMS is an

instance of the class frame hospital. An instance class possesses the same structure as its

class frame.

Part_of: This link connects two class frames one of which is contained in the other class, e.g.,

ward is Part_of the class hospital.

Frame Descriptions

The following are descriptions of some frames of the network.

Hospital Frame (Root of the Network)

F_name: hospital

Country: (value - India)

Phone_No: (default-23456778)

Address: (default - New Delhi)

Director (default – xyz)

Labs: lab (Lab Frame )

Wards: ward (Ward Frame)

Doctors: doctor (Doctor Frame)

Child Hospital Frame

F_name: child_hospital

Ako: hospital (Hospital Frame)

Age: (range – [0–12]), (rule- if_added)

Heart Hospital Frame

F_name: heart_hospital

Ako: hospital (Hospital Frame)

Lab Frame

F_name: lab

Part_of: hospital (Hospital Frame)

Pathology: pathology (Pathology Frame)

X_Ray: X_ray (X_Ray Frame)

Ward Frame

F name: ward

Part_of: hospital (Hospital Frame)

Ortho: orthopaedic (Orthopaedic Ward Frame)

Doctor Frame

F_name: doctor

Part_of: hospital

Qualification: (default - MBBS)

Pathology Frame

F_name: pathology

Part_of : lab (Lab Frame)

Incharge: (default - xyz)

Types of tests: (.....)

X_ray Frame

F_name: x_ray

Part_of: lab (Lab Frame)

Incharge: (default - par)

Orthopaedic Ward Frame

F_name: orthopeadic

Ako: ward (Ward Frame)

Frame Instance Descriptions

Hospital Frame Instance

F_name: AIIMS

Inst: Hospital Frame

Phone_No: (value - 91 11 6591425)

Address: (value - Central_Delhi))

City: (value - New Delhi)

Director: (value - Dr. Smith)

Labs: (Lab-name)

Wards: Wards Frame Inst

Doctors: Doctors Frame Inst

Labs Frame Instance

F_name: lab-name

Inst: lab (Lab Frame)

Part_of: AIIMS (Hospital Frame Instance)

Pathology: Pathology Frame Instance

X Ray: x_ray Frame Instance

Pathology Frame Instance

F_name: pathology-lab-name

Inst: pathology (Pathology Frame)

Part_of: lab-names (Labs Frame Inst)

Incharge: (value-Mr John)

Types of tests: (value- [ECG, Blood Test, Urine] )

Child Hospital Frame Instance

F_name: kalawati

Inst: Child_hospital (Child Hospital Frame)

Address: (value-1234 New Delhi)

Phone: (value-0116573891)

Director: Dr Mike

Heart Hospital Frame Instance

F name: escorts

Inst: heart_hospital (Heart Hospital Frame)

Phone_No:(value-0114563732)

Address: (value-Faridabad)

The graphical representation of a frame network for the class ‘hospital’ described above is shown below Fig:

Figure 4.19 A Simple Frame System

A network of frames can be viewed as a three-dimensional figure: one dimension is concerned

with the description of a class along with all the classes contained in it and connected with Part of

link. The second dimension in the hierarchy is of Ako links, while the third dimension contains the

instances of all classes connected with Inst links. It is important to note that each frame can have

at most two links with the following combinations:

A frame can be an instance of some frame and a part of another frame. So, it can have both Inst and Part_of links.

A frame can be a-kind-of frame of one frame and a part of another frame. So, it can have Ako and Part_of links.

However, it is not possible to have a frame which is both an instance and a-kind-of some class at the same time. So, the links Inst and Ako in a frame are not possible.

Figure 4.20 Three-Dimensional view of the class ‘Hospital’

An instance of a hospital is a specific hospital, such as AIIMS, which will have instances of all the classes in the network of hospital frame, that is, instances of the lab, doctor, and ward. Further, if we wish to represent the three-dimensional structure of a network of frames in first- order predicate logic (Chen, et al. 1986), it could be done as follows:∀X (frame(X) = ∃ Y, Y2,..., Yn. ((Ako(X, Y1) V Inst(X, Y1)) Λ Part_of(X, Y2) Λ slot3(X, Y3) Λ Slot4(X, Y4) Λ ...Λ slotn(X, Yn))),

where, frame(X) means that X is a frame, slot1 € {Inst, Ako); slot2 = Part_of, and sloti(X, Yi) means that Yi is value of sloti; of frame X.

4.5.1 Inheritance in Frames Inheritance is defined as a mechanism which is utilized for passing knowledge from one frame to other frames down through the taxonomy from general to specific frame. It is a good way of obtaining information that is not stored in the place we first looked. It leads to cognitive economy, where information is only stored in one place, while it can be retrieved from different parts of the network

Attachment of Demons (Rules)

Demons allow us to invoke rules within the frames and are considered to be a powerful style of programming. These can be attached with a slot along with other required facets. For example, an attached demon if_needed may be used for monitoring the behaviour of the system. Another demon if_added may be used to validate data when the data is added in the value slot. For example, if value of slot age is to be entered for a patient of child hospital, it will check whether it lies in the specified range.

Another use of attaching demons is that they allow dynamic information retrieval and storage. Here, one may get the value directly from the slot or may have to dynamically calculate the value of the required slot on the basis of other values. For example, the doctor frame can have a slot for tax that contains a demon if_needed for calculating tax using salary information available with each doctor instances. There is no need to store the tax calculated for each doctor separately, instead it can be calculated using the demon stored in doctor frame at the tax slot. Let us consider another example. If date_of_birth slot for a doctor is given and we are interested in knowing his/ age, a demon that calculates age from date-of-birth value and the current date (which can be obtained from the system) could be easily calculated.

4.5.2 Implementation of Frame Knowledge

Frames can be easily implemented using object-oriented programming (OOP) languages. The concept of class in OOP can be directly used to code frames that has the concept of subclass(Ako) and containment (Part_of link) of a class within another class. Instances of the frames can be declared as objects of the relevant classes. Slots can be defined as variables and procedural attachment as methods. Inheritance is inbuilt in these languages.

Representation of Frames in Prolog Frames can also be easily implemented using Prolog language. Each frame is represented as a fact in Prolog as frame(F_name, [ slot 1 (facet(value)....), slot2(facet(value), ...), ...]). Let us represent part of the network of frame system for hospital in Prolog as follows.

frame(hospital. [nil, country(default(india)). phone(default(9111234567)), address(nil).labs(labs), wards (ward), doctors(doctor)]).

frame(child_hospital,[ako(hospital). age(value(0,12). demon(if needed))]). frame (heart_hospital.[ako(hospital)]).

frame(labs. [part_of(hospital). pathology(pathology), x_ray(x_ray}]} frame (aiims, [inst(hospital). phone(value(91116591425)), address(value(central delhi)),

city(value(delhi)), labs(labs_inst), wards(ward_inst), doctors([list of doctors])]). frame (1abs_inst. [inst(labs), part_of(aiims), pathology(pathology_inst).X_ray(x_ray_inst)] ). frame(pathology_inst, [inst(pathology), incharge(value(pqr)), test([ecg. blood_test.urine])) ). frame(kalawati, [inst(child_hospital), address(value("1234. new delhi")).

phone(value(0116573891)), director(value (Dr Mike))]. frame (escort. [inst(heart_hospital). phone(value(0114563732)).address(value(faridabad))].

Inheritance Rules in Prolog

Since we have coded network of frames in Prolog, we need to write inheritance rules as well to obtain relevant information either directly available in the frame or through inheritance. Suppose we wish to know the country of ‘escort hospital, which is not given in this frame directly. We can travel starting from escort upward till root to know that country of escort hospital is India. An inheritance rules for frames might look like the one given below.

find(X, Y) :- frame (X. Z). search(Y. Z). !.

find(X, Y) :- frame (X. [inst(Z)|_]). find(Y. Z). !.

find(X. Y) :- frame (X. [ako(Z)| _]). find(Y. Z). !.

findx, y) :- frame(X. [part_of(Z)| _]). find y. Z).

Predicate search will basically retrieve the list of slots-facet pair and will try to match Y for slot. If a match is found then its facet value is retrieved, otherwise the process is continued till we reach the root frame.

15.1 Introduction

We have discussed various knowledge representation formalisms in Chapter 7 and seen thatknowledge can be represented in the declarative structures, viz. Predicate Logic, Production rulesSemantic Networks, Extended Semantic Nets and Frames. Basically, knowledge representation is an area of artificial intelligence whose fundamental goal is to represent knowledge in a manner that helps drawing conclusions from that knowledge. Generally, the knowledge representation system should not only hold knowledge but also set of basic inference rules. Inference rules are syntactic procedures or functions that operate on knowledge and derive new information. Syntactic information of rules is also used by the production system to decide which rule is applicable to be fired, Predicate logic and production rules are syntactic in nature. Syntactic-structure-based knowledge representation methods are weak methods but at the same time are adequate for general problem solving. Semantically oriented approaches for knowledge representation are quite useful to guide searches more efficiently. Semantic nets capture semantic relationship among concepts (entities) and are used with set of inference rules, which interpret the specific arcs showing relationship. The frame system is found to be more structured than semantic net and contains larger set of inference rules with the capability of integrating other

knowledge structures (such as predicate rules, semantic nets, and production rules etc.) within frames in order to make it more powerful The inheritance capability is much faster than resolution-based theorem proving in predicate logic. A hybrid structure can be created that combines the advantages of slot-and-filler structure of semantic net with the advantages of predicate logic. Extended semantic network (ESNet), CYC, and ontology are some examples of such structures. The ESNet incorporates clausal rules in semantic net; thus enhancing the capabilities of semantic nets using advantages of predicate logic.There is another system called KRYPTON (Brachman et al., 1985) in which knowledge is divided into two distinct repositories: TBox and ABox. Here TBox is a slot-and-filler structure containing concept information, whereas ABox contains logical assertions. The atomic predicates used in ABox assertions refer to concept defined in TBox.

These representations are inadequate for representing knowledge required for core Natural Language understanding applications. We require structures to hold deep sense and meaning of the sentences. For capturing indented semantics of the knowledge, there are various approaches, viz., Conceptual Dependency, Scripts, and Case Frames.

This chapter discusses Conceptual Dependency, Scripts, CYC, Case Frames, Semantic web, and Ontology frameworks. Conceptual Dependency is a semantic representation rather than a syntactic representation. It provides abstract structure with actions and the dependency relationship. Script structure is similar to frames except that slots in script keep information by using conceptual dependency primitives that are useful for reasoning about situations. The CYC uses both frames and logic to encode specific types of knowledge and inferences for commonsense reasoning. It provides the most built-in knowledge to manipulate specific kinds of knowledge structures. Ontology is again a structure holding detailed semantic knowledge and can be viewed as an extension of semantic net.

15.2 Conceptual Dependency Theory

Conceptual Dependency (CD) is a theory of deep semantics for concepts used for natural language understanding, which was developed by Roger Schank at Stanford University in 1969. It mainly focuses on the concept and meaning rather than on syntax or structure. Conceptual Dependency uses the basic hypothesis, that the ACTION is the basis of any proposition. All propositions that describe events are made up of conceptualizations that comprise an actor, an action, and a set of cases that depends on that action. The main important concept of the CD theory is that there must be a canonical form for meaning representations, i.e., different words and structures having same meaning should also have the same representation. The types of conceptual roles in this canonical form do not correspond to syntactic roles; rather the words are broken down into their conceptual parts and are then placed in a meaning representation with respect to their conceptual role instead of the syntactic role. It should be noted that the words do not appear in conceptualizations. Similarities and overlaps in meaning of words are handled by the concept of the PRIMITIVE ACTION. The primitives are not category names but rather elements that can be used in varied combinations to express the underlying meaning of a given word.

Conceptual Dependency representations use eleven primitive acts as the basis for most activities.These acts were designed by Schank by observing the structural similarities in the sentences

represented in actor-action-object framework (Schank R., 1969). A large set of states and a set ofconceptual roles can be expressed using this minimal set of primitive actions.

15.2.1 Conceptual Primitive ActionsActions in natural languages are generally specified by the verbs. Most of the verbs (in Englishlanguage) have been categorized under the following eleven primitive actions. Sometimes one verb may fall into two categories and in that case the most relevant in the context might be chosen at the time of interpreting sentences. For example, verbs push, throw, and kick require physical force to be applied to an object and may fall under PROPEL Act. But MOVE and GRASP primitives are more specific where the verb kick falls under MOVE and verb throw falls under GRASP. These primitives ACTIONS are listed as follows:1. ATRANS2. PTRANS3. PROPEL4. MOVE5. GRASP6. INGEST7. MTRANS8. MBUILD9. EXPEL10. SPEAK11. ATTEND

Let us describe all the primitives proposed by Schank as follows:

ATRANS: Transfer of an abstract relationship such as possession, control, or ownership. It re-

quires an actor, object, and recipient. For example,

• The verb.giveis represented by an act ATRANS which transfers an object from an actor to the

ecipient

• The verb 'take' is represented by an act ATRANS which transfers an object from someone to an

actor.

The verb 'purchase can be represented by two ATRANS acts, each causing the other. First, act

ATRANS is used for transfering money from the first actor to the second actor, and, second, act

ATRANS is used for transfering of an object from the second to the first actor.

PTRANS: Transfer of the physical location of an object (or actor) that requires an actor, object,

and direction. For example,

The verbs ‘go' or 'walk' are type of act PTRANS where an actor is moving himself to some location.

The verb 'fly' is represented by an act PTRANS where an actor is transferring himself to a location.

It can use another act as its instrument such as airplane, etc.

PROPEL: Application of physical force to an object (e.g., push, pull). For example,

• The verb push' is a PROPEL act that pushes an object in a direction by an actor.

• The verb 'pull' is represented by an act PROPEL where an object is pulled in a direction (towards actor) by an actor.

• The verb 'throw' is represented by PROPEL act where an object is moving in a direction by an actor using MOVE action whose instrument is hand.

MOVE: Movement of a body part by its owner (e.g., kick, throw, hit). For example,

• 'kick' is represented by MOVE owner's foot to PTRANS an object in a direction by owner of foot.

GRASP: Grasping of an object by an actor (e.g., catch, clutch). For example,

• 'catch' is represented by GRASP of an object by an actor. The object was PROPEL before GRASP.

INGEST: Ingesting of an object by an animal (e.g., eat, drink, smoke). It requires an actor, object, and direction. For example,

• INGEST (eat or drink) a solid eatable or liquid into the body through the mouth.• INGEST smoke from a cigarette into the mouth by INGEST air through the cigarette.• INGEST (breathe) air into the body through the mouth.

MTRANS: Transfer of mental information between animals or within an animal itself (e.g., tell,read, speak, sing). In MTRANS action, the various sense organs serve as the origins. Recipient,object, and actor are required, although here these cases refer to the above mental locations asrecipients and mental information as possible objects. For example,• 'tell", 'speak', and 'sing' mean that an actor MTRANS information to another actor.• "reaď MTRANS information from a book to memory (IM: intermediate memory where current contextis kept) of actor by means of ATTEND eye to the book for reading purpose.• remember MTRANS information from memory (LTM: long term memory) to IM of the same actor.

MBUILD: The construction of new information from old information within an actor, i.e. to create or combine thoughts internally. It takes place within IM and receives its inputs from the CP (the conscious processor) and from IM. It transforms them into a new idea and places that idea in the CP. For example,

• 'decide' MBUILD new information out of old information.• 'describe' MBUILD a description of a new state.• 'imagine' MBUILD a new idea that is hypothetical.. consider' MBUILD from a mentioned input into an unspecified output.• "answer' MBUILD a specific output to input given by other that was just received in the CP.

EXPEL: Expulsion of something from the body of an animal. For example,• 'weep' EXPEL tears (discharge liquid) from eyes.• 'cry' EXPEL tears and produce sound from mouth.• 'sweat' EXPEL moisture out of the pores of the skin.

SPEAK: Producing sounds (e.g. say, tell, and sing). For example,'sayº, 'tell", or "sing' SPEAK words so as to communicate something to other by vocal cord of an actor.

ATTEND: Focusing of a sense organ toward a stimulus (e.g. listen, watch, see, and look)All these primitives are grouped and classified in the broad categories as shown in Table 15.1.

The primitive ACT's are so powerful that they can not only point out similarities between wordssuch as the use of ATRANS for ‘give', 'take', and 'buy' but also highlight their differences. Inaddition, CD structure also helps in disambiguating ambiguous words. We have described aboveonly one sense of each verb.For example, take in take a medicine or juice would be INGEST rather than ATRANS. Here theknowledge about how words fit together in English and some general knowledge about the physical world are used to make such distinctions. The correct conceptual structure to an input sentence can be assigned by asking series of questions about the nature of object around it: Whether an object is something to be ingested or can be ATRANS or is really an action such as take a blow? In this case, it is neither ATRANS or INGEST but a causal structure.Similarly, smoke in the jungle is smoking (even though not a usual usage) would not haveINGEST but should have description of a state involving smoke and heat.15.2.2 Conceptual CategoryCD provides specific set of building blocks from which representations can be made rather thanonly a structure in which knowledge can be represented. Building blocks are the set of allowabledependencies among the conceptualizations for different events. There are four primitive concep-tual categories from which dependency structures can be built.

• АСТ Actions {one of the CD primitives representing verb}• PP Objects {picture producers or noun/pronoun)• AA Modifiers of actions {action aiders or adverb}• PA Modifiers of PP's {picture aiders or adjective)

The relationships between concepts are called dependencies. The main conceptualization of aclause is a two-way dependency between a PP (the actor) and an action. It is important to notethat actions are broken down into sequence of primitive ACT's.A set of rules describe the syntax of the conceptual level, and these rules specify which type ofconcepts can depend on which other type, as well as the different kinds of dependency relation-ships between concepts. Specific concepts depending on other concepts based on the particularmeaning of these concepts is determined by the semantics of the conceptual level. There exists adictionary of ACT's which specifies different meanings with its conceptual structure for eachverb.

Example: The CD representation for sentences such as “I took a book from the man”, “The man gave me a book ", and “The book was given by man to me” having the same intended meaning is given as follows:.

Here we notice that some special notations and symbols are used. These will be explained as we move ahead,but the conventions used throughout this chapter are as follows:• Arrows indicate directions of dependency.• Double arrow indicates two-way links between actor and action.• Following characters are used to represent different conceptso- for the object case relationr- for the recipient case relationd - destination

Conceptual relations, at a higher level, indicate dependencies between conceptualizations, anno-tated with conceptual tenses such as past, future, and conditional. Other types of conceptual rela-tions are the time and location of a conceptualization. So the conceptualizations representing events can be modified in various ways to supply information normally indicated in languages by the tense, mood, or aspect of a verb form. The set of conceptual tenses includesp - Pastf- Futuret - Transitionts - Start transitiontf- Finished transitionk- Continuingc- Conditional

15.2.3 Rules for Conceptualization Blocks in CDDependency structures are themselves conceptualization and therefore can serve as componentsfor larger dependency structures. The dependencies among conceptualization correspond to semantic relations among the underlying concepts. Here different types of arrows are used to represent different underlying semantics. Following is the list of the most important allowable structures or the rules:

Rule 1: Rule representing relationship between an actor and the event caused by him or her iscalled a two-way dependency, as neither actor nor event can be considered primary. The letter pin the dependency link indicates that the event occurred in the past.

Rule 2: Rule representing relationship between an ACT and the PP (object) of the ACT is shownby the direction of an arrow toward the ACT, since the context of the specific ACT determines the meaning of the object relation.

Rule 3: This rule shows relationship both ways between two PPs. One PP belongs to the setdefined by the other PP. For example, John belongs to a set of doctors in the sentence “John is adoctor".

Rule 4: It shows a relationship between two PPs. One of the PP provides a particular kind ofinformation about the other PP. The most common types of information to be encoded in this ways are possession (shown as “poss-by') and location (shown as “loc'). The direction of the arrow is again toward the concept being described.

Rule 5: It shows a relationship between a PP and a PA that is asserted to describe it. In this case,PA represents the states of PP such as height, weight, health, etc. on numeric scales and has bothways arrows.

Rule 6: It shows a relationship between a PP and an attribute that already has been predicated ofit. The direction of the arrow is toward the PP being described.

Rule 7: It shows a relationship between an ACT and its physical source and destination locationsof ACT. Here 'd' indicates the source and destination case relation, as this representation is alsoused for recipient case relation later.

Rule 8: It shows a relationship between an ACT and its source and the recipient of ACT. Theletter 'r' indicates source and recipient case relation.

Rule 9: It shows a relationship between an ACT and the instrument using which it is performed. In the simplest form, instrument can be represented by just a single physical object or must beexpanded to a full conceptualization. Here DO represents some act done by actor using instru-ment. The letter 'i' represents instrument. Here we can use 'v' for vehicle which can be single object or full conceptualization.

Rule 10: It shows a relationship that describes the change in state between PP and a statein which it started and another state in which it ended. Here states of object are describedusing numerical values. For example, for health, range could be - 10 to 10 describing varioushealth conditions {(dead, - 10), (seriously ill, - 9), (sick, [-1, - 8]), (alright, 0), (fine, 5), (perfectheath, 10)}

Rule 11: Relationship between one conceptualization and other conceptualization that causesit. Here {x} and {y} represent two full conceptualizations where {y} is caused by {x}. It isconditional representation as 'if x then y'. Alternatively, we can say that 'y' is a consequenceof 'x'.

Rule 12: It shows a relationship between one conceptualization with another that is happening atthe time of the first. Here event 'y' is happening while event 'x' simultaneously.

Rule 13: It shows a relationship between conceptualization and the place at which it happened.

These rules of CD representation help in drawing inferences and are independent of the language, as it is built using conceptual primitives which give the intended meanings of the words. There should be only unique representation of the meaning conveyed by two or more sentences. Sentences are represented as a series of diagrams depicting actions using both abstract and real physical situations. The actions are built up from a set of primitive acts which can be modified by tense. CD provides a structure that contains node representing information using a specific set of primitive acts. It is basically an Interlingua representation in which sentences in different languages having same meaning will have same CD representation.

15.2.4 Generation of CD representationThe following table shows CD representations of English sentences having simple but deepintended meanings.

CD Representations for Deep Meaning Sentences and Text

Let us see the systematic way of constructing CD representations for the sentence having

inherent meaning (Rich and Knight, 2003). Consider the following examples.

Example 1: Since drugs can kill, I stopped.The intended meaning of the sentence is that drugs are harmful and can kill a person. Because of this, Istopped taking drugs. Clearly, there are two causalities where one is caused by other. These causalities arerepresented in CD form as follows.Causality1: Killing can be caused by drugs:

Causality2: Stopped taking drugs:Since Causality is the cause of Causality2, CD representation to represent the relation between thesecausalities is as follows using rule 11 (Tables 15.4 and 15.5)

Now let us expand both the causalities as follows:The CD representation of Causalityl is developed using actions, namely, taking drugs and killing can becaused by taking drugs.Causality 2 is about an action of “I stopped taking drugs”. The conceptual tense tęp means the finishing oftransition in the past. Table 15.4 contains the CD representations developed stepwise.

Example 2: John warned Mike with dire consequence.The interpretation of the above sentence may be as follows:"John warned Mike that if Mike does something which is different from what John wants, then Mike will getinto trouble” (Refer Table 15.6)"John warned Mike that John will do something very bad to Mike. John did this so that Mike will believe orunderstand that if Mike does something different from what John wants, then Mike will get into trouble".

15.2.5 Conceptual ParsingConceptual parsing is required for generating CD representation from source sentences in naturallanguage. The main steps involved in CD parsing are as follows:

Syntactic processor extracts main verb and noun along with syntactic category of the verb(transitive or intransitive) from the sentence.• Conceptual processor then makes use of verb-ACT dictionary. Once the correct entry from diction-ary is chosen, CD processor analyses the rest of sentence looking for arguments for empty slots ofthe verb. CD processor examines possible interpretation in a well-defined order.

Let us consider following cases to handle 'with PP' phrase and formulate strategies todisambiguate the meanings. If CD processor finds 'with PP' phrase (PP is picture producer), itindicates one of the following cases showing relationship between PP and the conceptualization ofwhich it is a part. Let us consider two sentences syntactically same with same words accept PPof 'with PP' phraseCasel: The sentences having 'with PP' phrase with non-animate PP in one sentence and animatePP in other sentence as given in the following sentences.

1. John broke the door with hammer – Typel2. John broke the door with Mike - Type2

• Rule 1: If PP in 'with PP' phrase is non-animate and CD Act requires instrument then thesentence is of Typel, where PP (hammer) is resolved to instrument.• Rule 2: If PP in 'with PP phrase is animate and CD Act requires instrument then the sentence isof Type2, where PP (Mike) is resolved as co-actor.

Case2: In the sentences having 'with PP' phrase, if PPs in both the sentences are non-animate,then they have to be resolved using semantic lexicon. Consider the following examples.

1. John went to the garden with flowers - Type32. John went to the garden with bag - Type4

In Type3, non-animate noun 'flowers' is part of garden, whereas in Type4, non-animate 'bag'issome object not related to garden. Such association of word senses could be found in WordNet andthen disambiguation is possible. Here noun 'bag' is treated as possession by John.

Case3: In the sentences having 'with PP' phrase, if PPs the sentences are animate, then theyhave to be resolved using semantic lexicon and context. Consider the following examples.

1. John went to the garden with Mike - Type52. John went to the garden with butterflies- Type63. John went to the garden with dog - Type7

n these sentences, Mike, butterflies and dog are animate PPs and can be resolved as follows:

• Mike is easily resolved to co-actor of John as both are human and have similar characteristics

• WordNet can be used to check if butterfly and garden has some common sense.

. Dog is still ambiguous as it may be treated as possession of actor or may be a part of garden as

animals many wonder in garden. Such situations can be further resolved by considering the context

of sentences.

We can use semantic lexicon dictionary to resolve some of the ambiguities. WordNet is a semantic

lexicon for the English language. It groups English words into sets of synonyms called synsets,

provides short, general definitions, and records the various semantic relations between these

synonym sets. The purpose is WordNet is to produce a combination of dictionary and thesaurus.

15.2.6 Inferences Associated with Primitive Act

General inferences are stored with each primitive Act and reduce the number of inferences that

need to be stored explicitly. The meaning of the concept consists of the meaning of the primitive

itself and its associated inferences. Basically, inference is a conceptualization that is inferred by

another conceptualization. For example, from a sentence “John killed Mike”, we can infer that

“Mike is dead”. So conceptualization for inferences is embedded in CD representation for

primitive Act of killing. Let us take another example of primitive Act INGEST. The following

inferences can be associated with it.

• The object ingested is no longer available in its original form.

• If object is eatable, then the actor has less hunger.

• If object is toxic, then the actor's heath is bad.

• The physical position of object has changed. So PTRANS is inferred.

For a sentence "John took drug yesterday", we can infer that John's health is bad whereas for the

sentence "John ate food”, we can infer that John has less hunger.

The words in the dictionary are maintained with the following information.

• Syntactic category with all possible attributes and properties.

• The verbs with all possible senses and primitive Acts.

• With each primitive Act, inference rules are stored.

15.2.7 Usefulness of CD Representation

CD representation proves to be of greater use for storing implicit and explicit knowledge in the

sentence or text in natural language in a more compact way.

It is easier to describe inference rules that are represented only once for each primitive action.

For example, inference rule with ATRANS (transfer of ownership of an object) can be used to know who has an object after the action and who had it earlier, and also what is the object involved in this transfer.

Similarly, inference rule with INGEST can be used to know what has been ingested by whom Implicit information is deduced and stored as a part of CD representation for future use.

It is achieved by applying set of inference rules associated with specific information. Once such knowledge is generated, it can be repeatedly used without applying rules again and again.

• CD representation is good a model for representing simple events. In CD representation all

knowledge in the event is decomposed into very low level primitives.

• In CD representation, unspecified elements of the representation of one piece of information can be

used as a focus for the understanding of later events as they are encountered.

Schank et al, using CD representation theory, developed a number of programs, such as MARGIE

(Meaning Analysis, Response Generation and Inference on English) as a model for Natural Lan-

guage Understanding, and SAM and PAM (Script/Plan Applier Mechanism) to understand stories.

But there are problems with CD representation as well.

• It is difficult to construct original sentence from its corresponding CD representation.

It is difficult to use CD representation as a general model for knowledge representation, because thistheory is based on representation of events as well as all the information related to events.• Rules are to be carefully designed for each primitive action in order to obtain semantically correctinterpretation• Many verbs may fall under different primitive ACTs, and it becomes difficult to find correct primitivein the given context.• The CD representation becomes complex requiring lot of storage for many simple actions. Forexample, the sentence "John bet Mike that Indian cricket team will win incoming world cup" willrequire huge CD structure.

15.3 Script Structure

Schank and Abelson introduced the concepts of scripts in 1977 that were build upon CD frame-work to handle story understanding by organizing episodes in a sequence or a chain of situationswhich could be anticipated using personal experiences rather than semantic categories. Scripts arestructures representing procedural knowledge by describing a set of stereotyped events in aparticular situation or context which could be expected to be followed from one to another event.It consists of set of slots which may contain default values along with some information about thetype of values they might contain. It looks similar to frames, except that the values of the slots mustbe ordered and have more specialized roles. Script structure allows individual to make inferencesneeded for understanding by filling in missing information. In real world situations, we see that event tends to occur in known patterns because of clausal relationship to the occurrence of events. So scripts are useful structure in such situations. A number of computer programs have been developed to

demonstrate the theory. Schank applied his theoretical framework to story telling and the development of intelligent tutors. The classic example of Schank's theory is the restaurant script.

Each script contains the following main components.

Entry Conditions: Must be satisfied before events in the script can occur.

Results: Conditions that will be true after events in script occur.

Props :Slots representing objects involved in the events.

Roles :Persons involved in the events.

Track :Specific variation on more general pattern in the script. Different tracks

may share many components of the same script but not all.

Scenes:The sequence of events that occur. Events are represented in conceptual

dependency form.

The scripts are useful in describing certain stereotyped situations such as going to theater or

cinema hall, going to market, robbery in the bank, etc, To understand this concept better, let us

consider another example of developing a script for going to theater to see a play. This might

involve the following scenes:

• Going to theater.• Buying ticket.• Going inside hall and sitting on a seat• Watching play• Exiting from theaterVarious components of script for going to theater are described as follows:Entry Conditions:. P wants to see a play. P has moneyResults:• P saw play• P has less money

Props:

Ticket; Seat;Play

Roles:

Person Ticket distributor Ticket checker

Entire Script is encoded in the table, where we have considered 5 scenes

For example, given “John enjoyed the play in theater", a script “Play in Theater” suggested aboveis invoked and all implicit questions can be answered correctly. Here the significance of this scriptis high.• Did john go to theater?• Did he buy ticket?• Did he have money?If we have a sentence like "John went to theater to pick his daughter”, then invoking this script willlead to many wrong answers. Here significance of the script theater is less.Getting significance from the story is not straightforward. However, some heuristics can beapplied to get the value.If events follow a known track, we can use scripts to answer implicit or explicit questions. Differ-ent tracks may allow different outcomes of scripts (for example, the play was cancelled becauseof unseen situations, could not see play as it was full and no tickets were available, came out of thehall as bomb exploded, etc).The main advantages of script structures are that they are capable of predicting implicit events andthat a single coherent interpretation may be build up from a collection of observations. The disad-vantage of script structures is that they are more specific and less general than frames. Further-more, it is not suitable to represent all kinds of knowledge, because scripts are inflexible. To dealwith inflexibility, smaller modules called memory organization packets (MOP) can be combined ina way that is appropriate for the situation.

15.4 CYC Theory

The CYC is a theory designed for describing the world knowledge (commonsense knowledge) to

be useful in AI applications and more specifically in natural language understanding similar to CD

theory. The CYC is more comprehensive, whereas CD is more specific theory for representing

events. CYC was conceived by Lenat and Guha for capturing commonsense knowledge from the

project to capture a large knowledge from 100 randomly selected articles in the EnCYClopedia

Britannica (Lenat and Guha, 1990). CYC name came from this project. The CYC structure

contains representations of events, objects, attitudes, space, time, motion, etc. and tends to be huge

in structure. It is required to store special implicit knowledge or commonsense. So CYC is particu-

larly concerned with the issues of scale. But the question is that why we build such large knowl-

edge bases (KBs). Some of the reasons for large KBs are as follows:

Brittleness: Specialized knowledge bases are brittle. It is hard to encode new situations and there

is degradation in the performance. Commonsense-based knowledge bases should have a firmer

foundation.

Form and Content: Knowledge representation so far seen may not be sufficient for AI applica-

tions where main focus is comprehension. Commonsense strategies could point out where

difficulties in content may affect the form and temporarily focus on content of KBs rather than on

their form.

Shared Knowledge: Small Knowledge Base system should allow greater communication among

themselves with common bases and assumptions.

It is a huge task to build such a large KB. Initially, the approach taken by CYC was to encode 10

millions of facts that make commonsense knowledge, and then make itself a learning system,

There are some methods and languages in Al which can be used for acquiring this knowledge

automatically. Machine learning methods can be employed. Special language based on frame-

based system is called CYCL using which CYC knowledge is encoded. CYCL generalizes the

notion of inheritance so that properties can be inherited along any link rather than only “isa" and

"instance” links. In addition to frames, CYCL contains a constraint language that allows the

expression of arbitrary first-order logical expressions.

15.5 Case Grammars

Case Grammar theory was proposed by the American linguist Charles J. Fillmore in 1968 for

representing linguistic knowledge that removed the strong distinction between syntactic and

semantic knowledge of a language (Fillmore C., 1968). He initially introduced six cases (called

thematic cases or roles): AGENTIVE (Agent), OBJECTIVE (Object), INSTRUMENTAL

(Instrument), DATIVE (which covers EXPERIENCER), FACTIVE (which covers result of an

action), and LOCATIVE (Location of an action). The ultimate goal of case grammar theory was

to extract deep meanings of the sentences and express in the form of cases mentioned above.

Different meanings would lead to different case structures, but different syntactic structures with

same meaning would map to similar structure. For example, in the sentences, the door was

broken by John with hammer, using hammer John broke the door, John broke the door with

hammer, the hammer (instrument), John (actor), and the door (object) play the same semantic

roles in each of these sentences. Here the act is of "breaking of door" and will have same case

frame.

The case frame contains semantic relation rather than syntactic ones. The semantic roles such as

agent, action, object, and instrument are extracted from the sentence straightaway and stored in

case frame which represents semantic form of a sentence. For example, the sentences such as

John ate an apple and An apple was eaten by John will produce the same case frame, i.e., there

is same case frame for active and passive forms of the sentence. One can use a Boolean flag

indicating whether a sentence is active or passive in case there is a need.

Sentences having same syntactic parse structure but having different meanings are stored differently in case frame.

An example of syntactically same but semantically different sentences is as follows:

Mother baked for one hour and Cake baked for one hour will have same syntactic parse

structure (NP VP PP), but case grammar analysis of these sentences will show the difference. In the

first sentence, 'Mother' is agent, whereas in the second sentence, 'Cake' is object of baking action.

Furthermore, the following three sentences have the same syntactic structure except the last word

but differ significantly in their meanings.

• Mike saw the girl in the garden with a telescope.

• Mike saw the girl in the garden with a cat.

• Mike saw the girl in the garden with a fountain.

However, they can be seen to differ in important ways if we use our linguistic knowledge to

determine which part of the sentence the prepositional phrase 'with a x' modifies in each case. In

the first sentence, the seeing is being accomplished using a telescope. In the second, it is the girl

who is with a cat; in the third, it is the garden that contains a fountain.

There are two levels of every sentence structure, viz. surface structure that is basically a spoken/

written sentence and deep structure that gives underlying meaning of the sentence. The linguistic

knowledge (semantic knowledge) is organized around verbs and its senses. A verb may have more

than one sense or meaning and these are represented separately using two different representa-

tions in a case grammar. For example, 'run' in John runs an Industry has a different sense of run

in John runs in the field. Therefore, there is one case frame per sentence containing deep cases.

The semantic rules are to be coded carefully so that deep cases are found unambiguously. It is not

a trivial task.

Some of the cases are mandatory and others are optional. Each verb sense selects a subset of

these cases. Some of optional cases such as TIME, BENEFICIARY, FROM_LOC (Source),

TO_LOC (Destination), CO_AGENT, and TENSE, are introduced to capture more surface

knowledge.

Agent (instigator of action):

Noun phrase of a sentence generally fills the Agent case if it describes the instigator of the action.

Not all animate in the NP at subject possible fill Agent case. For example, in the sentences John

died or John was given a book, the proper name John is not an Agent case but may be Dative or

Beneficiary.

Object (identity on which action is performed)

The noun (object) being acted upon by action is used to fill up Object case. For example, in the

sentences The door broke, John broke the door, the noun door is Object case in both the

sentences.

. Dative (animate entity affected by the action)It basically refers to object of an action that is animate (noun which is living thing). For example, inthe sentence John killed Mike, Mike is Dative case.Experiencer (Animate subject in an active sentence with no Agent)Sometimes we have sentences having intransitive verbs (i.e., verbs with no object), and then thesubject of such sentences is Experiencer. For example, in sentences John cried, Mike laughs,John and Mike fill Experiencer Case.Beneficiary (animate who was benefited by action)It is an animate person for whom a certain event is performed for its benefit. For example, in thesentence I gave an apple to Mike, Mike is Beneficiary case whereas in I gave an apple toMike for Mary, Mary is Beneficiary case and Mike is Dative case.• Location (place of action)Location case can be further enhanced by having Source_Location, Destination_Location, etcFor example,

The man was killed in the garden – garden is Location case.

John went to school from home - home is a Source_Loc case, whereas school is Destination

Loc Case.

• Instrument (entity used for performing an action),

If some instrument is used to perform an action, then it fills Instrument case. For example, in the

sentences John ate an ice-cream with spoon, John saw a star with telescope, spoon and

telescope fill Instrument case. Instrument case sometimes can be used as the surface subject

depending

on the verb when the Agent case is not specified. For example, The sun dried the

fruits, Sun is Instrument case, as it acted as an instrument in drying the fruits.