# Chapter 10 - Strong Slot-and-Filler Structures

The slot-and-filler structures described in the previous chapter are very general. Individual semantic networks and frame systems may have specialized links and inference procedures, but there are no hard and fast rules about what kinds of objects and links are good in general for knowledge representation. Such decisions are left up to the builder of the semantic network or frame system.

The three structures discussed in this chapter, conceptual dependency, scripts, and CYC, on the other hand, embody specific notions of what types of objects and relations are permitted. They stand for powerful theories of how A1 programs can represent and use knowledge about common situations.

### 10.1 Conceptual Dependency

Conceptual dependency (often nicknamed CD) is a theory of how to represent the kind of knowledge about events that is usually contained in natural language sentences. The goal is to represent the knowledge in a way that

- Facilitates drawing inferences from the sentences.
- Is independent of the language in which the sentences were originally stated.

Because of the two concerns just mentioned, the CD representation of a sentence is built not out of primitives corresponding to the words used in the sentence, but rather out of conceptual primitives that can be combined to form the meanings of words in any particular language. The theory was first described in Schank [1973] and was further developed in Schank [1975]. It has since been implemented in a variety of programs that read and understand natural language text. Unlike semantic nets, which provide only a structure into which nodes representing information at any Ievel can be placed, conceptual dependency provides both a structure and a specific set of primitives, at a particular level of granularity, out of which representations of particular pieces of information can be constructed.

###### Figure 10.1: A Simple Conceptual Dependency Representation

As a simple example of the way knowledge is represented in CD, the event represented by the sentence

- I gave the man a book.

would be represented as shown in Figure 10.1.

In CD, represent:ctions of actions are built from a set of primitive acts. Although there :crc slight differenc:es in the exact set of primitive actions provided in the various sources on CD, a typical set is the following, taken from Sehank and Abelson [1977]:

ATRANS Transfer of an abstract relationship (e.g.,give)

PTRANS Transfer of the physical location of an object (e.g.,go)

PROPEL Application of physical force to an object (e.g.,push)

MOVE Movement of a body part by its owner (e.g.,kick)

GRASP Grasping of an object by an actor (e.g.,clutch)

INGEST Ingeslion of an object by an animal (e.g.,eat)

EXPEL Expulsion of socnething from the body of an animal (e.g.,cry)

MTRANS Transfer of mental information (e.g..tell)

MBUILD Building new information out of old (e.g.,decide)

SPEAK Production ot sounds (e.g.,say)

ATTEND Focusing of a sense organ toward a stimulus (e.g.,listen)

A second set of CD building blocks is the set of allowable dependencies among the conceptualizations deseribed in a sentence. There are four primitive conceptual categories from which dependency structures can be built. These are

ACTs Actions

PPs Objects (picture producers)

AAs Modifiers of actions (action aiders)

PAs Modifiers of PPs (picture aiders)

In addition, dependeney structures are themselves conceptualizations and can serve as components of larger dependency structu:es.

The dependencies among conceptual izations correspond to semantic relations among the underlying concepts. Figure 10.2 lists the most important ones allowed by CD. [Footnote:The table shown in the figure is adapted from several tables in Schank [1973]] The first column contains the rules; the second contains examples of their use; and the third contains an English version of each example. The rules shown in the figure can be interpreted as follows:

- Rule 1 describes the relationship between an actor and the event he or she causes. This is a two-way dependency since neither actor nor event can be considered primary. The letter p above the dependency link indicates past tense.
- Rule 2 describes the relationship between a PP and a PA that is being asserted to describe it. Many state descriptions, such as height, are represented in CD as numeric scales.
- Rule 3 describes the relationship between two PPs, one of which belongs to the set defined by the other.
- Rule 4 describes the relationship between a PP and an attribute that has already been predicated of it. The direction ofthe arrow is toward the PP being described.
- Rule 5 describes the relationship between two PPs, one of which provides a particular kind of information about the other. The three most common types of information to be provided in this way are possession (shown as POSS-BY), location (shown as LOC), and physical containment (shown as CONT). The direction of the arrow is again toward the concept being described.
- Rule 6 describes the relationship between an ACT and the PP that is the object of that ACT. The direction of the arrow is toward the ACT since the context of the specific ACT determines the meaning of the object relation.
- Rule 7 describes the relationship between an ACT and the source and the recipient of the ACT.
- Rule 8 describes the relationship between an ACT and the instrument with which it is performed. The instrument must always be a full conceptualization (i.e., it must contain an ACT), notjust a single physical object.

  ###### Figure 10.2: The Dependencies of CD

- Rule 9 describes the relationship between an ACT and its physical source and destination.
- Rule 10 represents the relationship between a PP and a state in which it started and another in which it ended.
- Rule 11 describes the relationship between one conceptualization and another that causes it. Notice that the arrows indicate dependency of one conceptualizažon on another and so point in the opposite direction of the implication arrows. The two forms of the rule describe the cause of an action and the cause of a state change.
- Rule 12 describes the relationship between a conceptualization and the time at which the event it describes occurred.
- Rule 13 describes the relationship between one conceptualization and another that is the time of the first. The example for this rule also shows how CD exploits a model of the human information processing system; see is represented as the transfer of information between the eyes and the conscious processor.
- Rule 14 describes the relationship between a conceptualization and the place at which it occurred.

Conceptualizations representing events can be modified in a variety of ways to supply infomiation normally indicated in language by the tense, mood, or aspect of a verb form. The use of the modifier p to indicate past tense has already been shown. The set of conceptual tenses proposed by Schank [1973] includes

p Past

f Future

t Transition

ts Start transition

tf Finished transition

k Continuing

? Interrogative

/ Negative

nil Present

delta Timeless

c Conditional

As an example of the use of these tenses, consider the CD representation shown in Figure 10.3 (taken from Schank [1973]) of the sentence

- Since smoking can kill you, I stopped.

The vertical causality link indicates that smoking kills one. Since it is marked c, however, we know only that smoking can kill one, not that it necessarily does. The horizontal causality link indicates that it is that first causality that made me stop smoking. The qualification tfp attached to the dcpendency between I and INGEST indicates that the smoking (an instance of INGESTING) has stopped and that the stopping happened in the past.

###### Figure 10.3: Using Conceptual Tenses

There are three important ways in which representing knowledge using the conceptual dependency model facilitates reasoning with the knowledge:

1. Fewer inference rules are needed than would be required if knowledge were not broken down into primitives.
2. Many inferences are already contained in the representation itself.
3. The initial structure that is built to represent the information contained in one sentence will have holes that need to be filled. These holes can serve as an attention focuser for the program that must understand ensuing sentences.

Each of these points merits further discussion.

The first argument in favor of representing knowledge in terms of CD primitives rather than in the higher-level terms in which it is normally described is that using the primitives makes it easier to describe the inference rules by which the knowledge can be manipulated. Rules need only be represented once for each primitive ACT rather than once for every word that describes that ACT. For example, all of the following verbs involve a transfer of ownership of an object:

- Give
- Take
- Steal
- Donate

lf any of them occurs, then inferences about who now has the object and who once had the object (and thus who may know something about it) may be important. ln a CD representation,those possible inferences can be stated once and associated with the primitive ACT ATRANS.

A second argument in favor of the use of CD representation is that to construct it, we must use not only the inforntation that is stated explicitly in a sentence but also a set

###### Figure 10.4: The CD Representation of a Threat

of inference rules associated with the specific information. Having applied these rules once, we store these results as part of the representation and they can be used repeatedly without the rules being reapplied. For example, consider the sentence

- Bill threatened John with a broken nose.

The CD representation of the information contained in this sentence is shown in Figure 10.4. (For simplicity, believe is shown as a single unit. In fact, it must be represented in terms of primitive ACTs and a model of the human information processing system.) It says that Bill informed John that he (Bill) will do something to break John's nose. Bill did this so that John will believe that if he (John) does some other thing (different from what Bill will do to break his nose), then Bill will break John's nose. In this representation, the word "believe" has been used to simplify the example. But the idea behind believe can be represented in CD as an MTRANS of a fact into John's memory. The actions do1 and do2 are dummy placeholders that refer to some as yet unspecified actions.

A third argument for the use of the CD representation is that unspecified elements of the representation ofone piece ofinformation can be used as a focus forthe understanding of later events as they are encountered. So, for example, after hearing that

- Bill threatened John with a broken nose.

we might expect to find out what action Bill was trying to prevent John from performing. That action could then be substituted for the dummy action represented in Figure 10.4 as do2 . The presence of such dummy objects provides clues as to what other events or objects are important for the understanding of the known event.

Of course, there are also arguments against the use of CD as a representation formalism. For one thing, it requires that all knowledge be decomposed into fairly low- level primitives. In Section 4.3.3 we discussed how this may be inefIicient or perhaps even impossible in some situations. As Schank and Owens [1987] put it,

- CD is a theory of representing fairly simple actions. To express, for exam- ple, "John bet Sam fifty dollars that the Mets would win the World Series" takes about two pages of CD forms. This does not seem reasonable.

Thus, although there are several arguments in favor of the use of CD as a model for representing events, it is not always completely appropriate to do so, and it may be worthwhile to seek out higher-level primitives.

Another difficulty with the theory of conceptual dependency as a general model for the representation of knowledge is that it is only a theory of the representation of events. But to represent aIl the information that a complex program may need, it must be able to represent otherthings besides events. There have been attempts to define a set of primitives, similar to those of CD for actions, that can be used to describe other kinds of knowledge. For example, physical objects, which in CD are simply represented as atomic units, have been analyzed in L,ehnert [1978]. A similar analysis of social actions is provided in Schank and Carbonell [1979). These theories continue the style of representation pioneered by CD, but they have not yet been subjected to the same amount of empirical investigation (i.e., use in real programs) as CD.

We have discussed the theory of conceptual dependency in some detail in order to illustrate the behavior of a knowledge representation system built around a fairly small set of specific primitive elements. But CD is not the only such theory to have been developed and used in AI programs. For another example of a primitive-based system, see Wilks [1972].

### 10.2 Scripts

CD is a mechanism for representing and reasoning about events. But rarely do events occur in isolation. In this section, we present a mechanism for representing knowledge about common sequences of events.

A script is a structure that describes a stereotyped sequence of events in a particular context. A script consists of a set of slots. Associated with each slot may be some information about what kinds of values it may contain as well as a default value to be used if no other infomiation is available. So far, this definition of a script looks very similar to that of a frame given in Section 9.2, and at this level of detail, the two structures are identical. But now, because ofthe specialized role to be played by a seript, we can make some more precise statements about its structure. Figure 10.5 shows part of a typical script, the restaurant script (taken from Schank and Abelson [1977]). It illustrates the important components of a script:

- Entry conditions: Conditions that must, in general, be satisfied before the events described in the script can occur.
- Result: Conditions that will, in general, be true after the events described in the script have occurred.
- Props: Slots representing objects that are involved in the events described in the script.The presence of these objects can be inferred even if they are not mentioned explicitly.
- Roles: Slots representing people who are involved in the events described in the script. The presence of these people, too, can be inferred even if they are not mentioned explicitly. If specific individuals are mentioned,they can be inserted into the appropriate slots.
- Track: The specific variation on a more general pattern that is represented by this particular script. Different tracks of the same script will share many but not all components.
- Scenes: The actual sequences of events that occuc.The events are repre- sented in conceptual dependency fomialism.

Scripts are useful because, in the real world, there are patterns to the occurrence of events. These patterns aase because of causal relationships between events. Agents will perfomi one action so that they will then be able to perform another. The events described in a script form a giant causal chain. The beginning of the chain is the set of entry conditions which enable the first events of the script to occur. The end of the chain is the set of results which may enable later events or event sequences (possibly described by other scripts) to occur. Within the chain, events are connected both to earlier events that make them possible and to later events that they enable.

If a particular script is known to be appropriate in a given situation, then it can be very useful in predicting the occurrence of events that were not explicitly mentioned. Scripts can also be useful by indicating how events that were mentioned relate to each other. For example, what is the connection between someone's ordering steak and someone's eating steak? But before a particular script can be applied, it must be activated (i.e., it must be selected as appropriate to the current situation). There are two ways in which it may be useful to activate a script, depending on how important the script is likely to be:

- For 8eeting scripts (ones that are mentioned briefly and may be ceferred to again but are not central to the situation), it may be sufficient merely to store a pointer to the script so that it can be accessed later if necessary. This would be an appropriate strategy to take with respect to the restaurant script when confronted with a story such as
  - Susan passed her favorite restaurant on her way to the museum. She really enjoyed the new Picasso exhibit.
- For nonfleeting scripts it is appropriate to activate tho script fully and to attempt to fill in its slots with particular objects and peoplo involved in the current situation.

  ###### Figure 10.5: The Restaurant Script

  The headers of a script (its preconditions, its preferred locations, its props, its roles, and its events) can all serve as indicators that the script should be activated. In order to cut down on the number of times a spurious script is activated, it has proved useful to require that a situation contain at least two of a script's headers before the script will be activated.

Once a script has been activated, there are, as we have already suggested, a variety of ways in which it can be useful in interpreting a particular situation. The most important of these is the ability to predict events that have not explicitly been observed. Suppose, for example, that you are told the following story:

- John went out to a restaurant last night. He ordered steak. When he paid for it, he noticed that he was running out of money. He hurried home since it had started to rain.

If you were then asked the question

- Did John eat dinner last night?

you would almost certainly respond thvt he did, even though you were not told so explicitly. By using the restaurant script, a computer question-answerer would also be able to infer that John ate dinner, since the restaurant script could have been activated. Since all ofthe events in the story correspond to the sequence ofevents predicted by the script, the program could infer that the entire sequence predicted by the script occurred normally. Thus it could conclude, in panicular, that John ate. In their ability to predict unobserved events, scripts are similar to frames and to other knowledge structures that represent stereotyped situations. Once one ofthese structures is activated in a panicular situation, many predictions can be made.

A second important use of scripts is to provide a way of building a single coherent interpretation from a collection of observations. Recall that a script can be viewed as a giant causal chain. Thus it provides information about how events are related to each other. Consider, for example, the following story:

- Susan went out to lunch. She sat down at a table and called the waitress. The waitress brought her a menu and she ordered a hamburger.

Now consider the question

- Why did the waitress bring Susan a menu?

The script provides two possible answers to that question:

- Because Susan asked her to. (This answer is gotten by going backward in the causal chain to find out what caused her to do it.)
- So that Susan could decide what she wanted to eat. (This answer is gotten by going forward in the causal chain to find out what event her action enables.)

A third way in which a script is useful is that it focuses attention on unusual events. Consider the following story:

- John went to a restaurant. He was shown to his table. He ordered a large steak. He sat there and waited for a long time. He got mad and left.

The important part of this story is the place in which it departs from the expected sequence of events in a restaurant. John did not get mad because he was shown to his table. He did get mad because he had to wait to be served. Once the typical sequence of events is interrupted, the script can no longer be used to predict other events. So, for example, in this story, we should not infer that John paid his bill. But we can infer that he saw a menu, since reading the menu would have occurred before the interruption. For a discussion of SAM, a program that uses scripts to perform this kind of reasoning, see Cullingford [1981].

From these examples, we can see how information about typical sequences ofevents, as represented in scripts, can be useful in interpreting a particular, observed sequence of events. Tbe usefulness of a script in some of these examples, such as the one in which unobserved events were predicted, is similar to the usefulness of other knowledge structures, such as frames. In other examples, we have relied on specific properties of the infomation stored in a script, such as the causal chain nepresented by the events it contains. Thus although scripts are less general structures than are frames, and so are not suitable for representing all kinds of knowledge, they can be very effective for representing the specific kinds of knowledge for which they were designed.

### 10.3 CYC

CYC [Lenat and Guha,1990] is a very large knowledge base project aimed at capturing human commonsense knowledge. Recall that in Section 5.1, our first attempt to prove that Marcus was not loyal to Caesar failed because we were missing the simple fact that all men are people. The goal of CYC is to encode the large body of knowledge that is so obvious that it is easy to forget to state it explicitly. Such a knowledge base could theri be combined with specialized knowledge bases to produce systems that are less brittle than most of the ones available today.

Like CD, CYC represents a specific theory of how to describe the world, and like CD, it can be used for AI tasks such as natural language understanding. CYC, however, is more comprehensive; while CD provided a speeific theory of representation for events, CYC contains representations of events, objects, attitudes, and so forth. In addition, CYC is particularly concerned with issues of scale, that is, what happens when we build knowledge bases that contain millions of objects.

##### 10.3.1 Motivations

Why should we want to build large knowledge bases at all? There are many reasons, among them:

- Brittleness-Specialized knowledge-based systems are brittle. They cannot cope with novel situations, and their perfom'rance dcgradetion is not graccful. Programs built on top of deep, commonsense knowledge sbout the world should rest on firmer foundations.
- Form and Content-The techniques we have seen so far for representing and using knowledge may or may not be sufficient for the purposes of AI. One good way to find out is to start coding large amounts of commonsense knowledge and see where the difficulties crop up. In other words, one strategy is to focus temporarily on the content of knowledge bases rather than on their form.
- Shared Knowledge-Small knowledge-based systems must make sirqplifying assumptions about how to represent things like space, time, motion, and siructure. If these things can be represented once at a very high Ievel, then domain-specific systems can gain leverage cheaply. Also, systems that share the same primitives can communicate easily with one another.

Building an immense knowledge base is a staggering task, however. We should ask whether there are any methods for acquiring this knowledge automatically. Here are two possibilities:

1. Machine learning- In Chapter 17, we discuss some techniques for automated learning. However, current techniques permit only modest extensions of a pro- gram's knowledge. In order for a system to learn a great deal, it must already know a great deal. In particular, systems with a lot of knowledge will be able to employ powerful analogical reasoning.
2. Natural Language Understanding-Humans extend their own knowledge by reading books and talking with other humans. Since we now have on-line versions of encyclopedias and dietionaries, why not feed these texts into an AI program and have it assimilate all the infomiation automatically? Although there are many techniques for building Ianguage understanding systems (see Chapter 15), these methods are themselves very knowledge-intensive. For example, when we hear the sentence
   - John went to the bank and withdrew $50.

   we easily decide that "bank" means a financial institution, and not a river bank. To do this, we apply fairly deep knowledge about what a financial institution is, what it means to withdraw money, etc. Unfortunately, for a program to assimilate the knowledge contained in an encyclopedia, that program must already know quite a bit about the world.

The approach taken by CYC is to hand-code (what its designers consider to be) the ten million or so facts that make up commonsense knowledge. It may then be possible to bootstrap into more automatic methods.

##### 10.3.2 CYCL

CYC's knowledge is encoded in a representation language called CYCL. CYCL is a frame-based system that incorporates most of the techniques described in Chapter9 (multiple inheritance, slots as full-fledged objects, transfers-through, mutually-disjoint-with, etc). CYCL generalizes the notion of inheritance so that properties can be inherited along any link, not just isa and instance. Consider the two statements:

###### Figure 10.6: Frames and Constraint Expressions in CYC

1. All birds have two legs.
2. All of Maty's friends speak Spanish.

We can easily encode the first fact using standard inheritance-any frame with Bird on its instance, slot inherits the value 2 on its legs slot. The second fact can be encoded in a similar fashion if we allow inheritance to proceed along the friend relation--any frame with Mary on its friend slot inherits the value Spanish on its languagesSpoken slot. CYC funher generalizes inheritance to apply to a chain of relations, allowing us to express facts likc, "All the parents of Mary's friends are rich," where the value Rich is inherited through a composition of the friend and parentOf links.

In addition to frames, CYCL contains a constraint language that allows the expression of arbitrary first-order logical expressions. For example, Figure 10.6 shows how we can express the fact "Mary likes people who program solely in Lisp." Mary has a constraint called lispConstraint, which restricts the values of her likes slot. The slotValueSubsemes attribute of lispConstraint ensures that Mary's likes slot will be filled with at least those individuals that satisfy the logical condition, namely that they program in LispLanguage and no others.

The time at which the default reasoning is actually performed is determined by the direction of the slotvalueSubsumes rules. If the direction is backward, the rule is an if-needed rule, and it is invoked whenever someone inquires as to the value of Mary's likes slot. (In this case, the rule infers that Mary likes Bob but not Jane.) If the direction is forward, the rule is an if-added rule, and additions are automatically propagated to Mary's likes slot. For example, after we place LISP on Bob's programsIn slot, then the system quickly places Bob on Mary's likes slot for us. A truth maintenance system (see Chapter 7) ensures that if Bob ceases to be a Lisp programmer (or if he starts using Pascal), then he will also cease to appear on Mary's likes slot.

While forward rules can be very useful, they can also require substantial time and space to propagate their values. If a rule is entered as backward, then the system defers reasoning until the information is specifically requested. CYC maintains a separate background process for accomplishing forward propagations. A knowledge engineer can continue entering knowtedge while its effects are propagated during idle keyboard time.[Footnote: Anothor idea is to have the system do forward propagation of knowledge during periods of infrequent use, such as at night].

Now let us return to the constraint language itself. Recall that it allows for the expression of facts as arbitrary logical expressions. Since first-order logic is much more powerful than CYC's frame language, why does CYC maintain both? The reason is that frame-based infetence is very efficient, while general logical reasoning is computationally hard. CYC actually supports about twenty types ofefficient inference mechanisms (including inheritance and transfers-through), each with its own truth maintenance facility. The constraint language atlows for the expression of facts that are too complex for any of these mechanisms to handle.

The constraint language also provides an elegant, abstract layer ofrepresentation. In reality, CYC maintains two levels of representation: the epistemological level (EL) and the heuristic level (HL). The EL contains facts stated in the logical constraint language, while the HL contains the same facts stored using efficient inference templates. There is a translation program for automatically converting an EL statement into an efficient HL tepresentation. The EL provides a clean; simple functionat interface to CYC so that users and computer programs can easily insert and retrieve information from the knowledge base. The EL/HL distinetion represents one way of combining the formal neatness of logic with the computational efficiency of frames.

In addition to frames, inference mechanisms, and the constraint language, CYCL performs consistency checking (e.g., detecting when an illegal value is placed on a slot) and conflict resolution (e.g., handling cases where multiple inference procedures assign incompatible values to a slot).

##### 10.3.3 Control and Meta-Knowtedge

Recall our discussion of control knowledge in Chapter 6, where we saw how to take information about control out of a production system interpreter and represent it declar- atively using rules. CYCL strives to accomplish the same thing with frames. We have already seen how to specify whether a fact is propagated in the forward or backward direction-this is a type of control infomiation. Associated with each slot is a set of inference mechanisms that can be used to compute values for it. For any given problem, CYC's reasoning is constrained to a small range of relevant, efficient procedures. A query in CYCL can be tagged with a level of effort. At the lowest level of effort, CYC merely checks whether the fact is stored in the knowledge base. At higher levels, CYC will invoke backward reasoning and even entertain metaphorical chains of inference. As the knowledge base grows, it will become necessary to use control knowledge to restrict reasoning to the most relevant portions of the knowledge base. This control knowledge can, of course, be stored in frames.

In the tradition of its predecessor RLL (Representation Language Language) [Greiner and Lenat,1980], many of the inference mechanisms used by CYC are stored explicitly as EL templates in the knowledge base. These templates can be modified like any other frames, and a user can create a new inference template by copying and editing an old one. CYC generates LISP code to handle the various aspects of an inference template. These aspects include recognizing when an EL statement can be transformed into an instance of the template, storing justifications of facts that are deduced (and retracting those facts when the justifications disappear), and applying the inference mechanism efficiently. As with production systems, we can build a more Hexible, reflective system by moving inference procedures into a declarative representation.

It should be clear that many of the same control issues exist for frames and rules. Unlike numerical heuristic evaluation functions, control knowledge often has a com- monsense, "knowledge about the world" flavor to it. It therefore begins to bridge the gap between two usually disparate types of knowledge: knowledge that is typically used for search control and knowledge that is typically used for natural language disambiguation.

##### 10.3.4 Global Ontology

Ontology is the philosophical study of what exists. In the AI context, ontology is concerned with which categories we can usefully quantify over and how those categories relate to each other. All knowledge-based systems refer to entities in the world, but in order to capture the breadth of human knowledge, we need a well-designed global ontology that specifies at a very high level what kinds of things exist and what their general properties are. As mentioned above, such a global ontology should provide a more solid foundation for domain-specific AI programs and should also allow them to communicate with each other.

The highest level concept in CYC is called Thing. Everything is an instance of Thing. Below this top-level concept, CYC makes several distinctions, including:

- IndividualObject versus Collection--The CYCL concept Collection corresponds to the class CLASS described in Chapter 9. Here are some examples of frames that are instances of Collection: Person, Nation, Nose. Some instances of IndividualObject are Fred, Greece, Fred's Nose. These two sets share no common instances, and any instance of Thing must be an instance of one of the two sets. Anything that is an instanee of Collection is a subset of Thing. Only Collections may have supersets and subsets; only IndividualObjects may have parts.
- Intangible, Tangible, and Composite--Instances of Intangible are things without mass, e.g., sets, numbers, laws, and events. Instances of TangibleObject are things with mass that have no intangible aspect, e.g., a person's body, an orange, and dirt. Every instance of TangibleObject is also an instance of IndividualObject since sets have no mass. Instances of CompositeObject have two key slots, physicalExtent and intangibleExtent. For example, a person is a CompositeObject whose physicalExtent is his body and whose intangibleExtent is his mind.
- Substance--Substance is a subclass of IndividualObject. Any subclass of Substance is something that retains its properties when it is cut up into smaller pieces. For example, Wood is a Substance.[Footnote: of course, if we cut a subtance uo too finely, it ceases to be the same substance. For each subtance type, CYC stores its granule size, e.g. Wood.granule= PlantCell, Crowd.granule=Person, etc.] A concept like Table34 can be an instance of both Wood (a Substance) and Table (an IndividualObject).
- Intrinsic versus Extrinsic properties--A property is intrinsic ifwhen an object has that property all parts of the object also have that property. For example, color is an intrinsic property. Objects tend to inherit their intrinsic properties from Subslonces. Extrinsic properties include things like number-of legs. Objects tend to inherit their extrinsic properties from IndividualObjects.
- Event and Process--An Event is anything with temporal extent, e.g., Walking. Process is a subclass of Event. If every temporal slice of an Event is essentially the same as the entire Event, then that Event is also a Process. For example, Walking is a Process, but WalkingTwoMiles is not. This relationship is analogous to Substance and IndividualObject.
- Slots--Slot is a subclass of Intangible. There are many types of Slot. BookkeepingSlots record such information as when a frame was created and by whom. DefiningSlots refer not to properties of the frame but to properties of the object represented by the frame. DefiningSlots are funher divided into intensional, taxonomic, and extensional categories. QuantitativeSlots are those which take on a scalar range of values, e.g., height, as opposed to gender.
- Time--Events can have temporal properties, such as duration and startsBefore. CYC deals with two basic types of temporal measures: intervals, and sets of intervals. A number of basic interval properties, such as endsDuring, are defined from the property before, which applies to starting and ending times for events. Sets of intervals are built up from basic intervals through operations like union and intersection. Thus, it is possible to state facts like "John goes to the movies at three o'clock every Sunday "
- Agent-An important subset of CompositeObject is Agent, the collection of intelligent beings. Agents can be collective (e.g., corporations) or individual (e.g., people). Agents have a number of properties, one of which is beliefs. Agents often ascribe their own beliefs to other agents in order to facilitate communication. An agent's beliefs may be inconect, so CYC must be able to distinguish between facts in its own knowledge base (CYC's beliefs) and "facts" that are possibly inconsistent with the knowledge base.

These are but a few of the ontological decisions that the builders of a large knowl- edge base must make. Other problems arise in the representation of space, causality, structures, and the persistence ofobjects through time. We return to some ofthese issues in Chapter 19.

##### 10.3.5 Tools

CYC is a multi-user system that provides each knowledge enterer with a textual and graphical interface to the knowledge base. Users' modifications to the knowledge base are transmitted to a central server, where they are checked and then propagated to other users.

We do not yet have much experience with the engineering problems of building and maintaining very large knowledge bases. In the future, it will be necessary to have tools that check consistency in the knowledge base, point out areas of incompleteness, and ensure that users do not step on each others' toes.

### 10.4 Exercises

1. Show a conceptual dependency representation of the sentence
   - John begged Mary for a pencil.

   How does this representation make it possible to answer the question

   - Did John talk to Mary?
2. One difficulty with representations that rely on a small set of semantic primitives, such as conceptual dependency, is that it is often difficult to represent distinc- tions between fine shades of meaning. Write CD representations for each of the following sentences. Try to capture the differences in meaning between the two sentences of each pair.

   John slapped Bill.

   John punched Bill

   Bill drank his Coke.

   Bill slurped his Coke.

   Sue likes Dickens.

   Sue adores Dickens.

3. Construct a script for going to a movie from the viewpoint of the movie goer.
4. Consider the following paragraph:
   - Jane was extremely hungry. She thought about going to her favorite restaurant for dinner, but it was the day before payday. So instead she decided to go home and pop a frozen pizza in the oven. On the way, though, she ran into her friend, Judy. Judy invited Jane to go out to dinner with her and Jane instantly agreed. When they got to their favorite place, they found a good table and relaxed over their meal.

   How could the restaurant script be invoked by the contents of this story? Trace the process throughout the story. Might any other scripts also be invoked? For example, how would you answer the question, "Did Jane pay for her dinner?"

5. Would conceptual dependency be a good way to represent the contents of a typical issue of National Geographic?
6. State where in the CYC ontology following concepts should fall
   - cat
   - court case
   - New York Tmes
   - France
   - glass of water