Find Relevant, Already-existing Constants

First of all, I will try and find relevant, already-existing constants - constants that I will be able to use to make the assertions about Billy and Peter that I want to make. Of course I could create every constant I wish to use to talk about Billy and Peter, but why reinvent the ontological wheel? (Beware: this task is often harder than it looks...many a cyclist has torn out hair having just worked hard to create a new constant which they perceived as filling a hole in the ontology (say..." moneyAmountOfCoin "), only to find an equivalent lurking in the KB under a name they did not expect (say..." tenderValue ")).

First and most obviously, I guess I will want to say that Billy and Peter are kittens. That is probably the most salient piece of information I have about them. Is there a Cyc term that means "kitten"?

Try it yourself! Enter this into your copy of OpenCyc.    Enter the word "kitten" in the text field on the left in the top frame and click on the "Search" button...  [ Show me ]

Unfortunately this turns up nothing. There is no constant called #$Kitten in the OpenCyc KB.

Click here for further explanation of why you just did the above.   What does the '#$' in front of "#$Kitten" mean?

Maybe, instead of saying that Billy and Peter are kittens, I can say that they are juvenile cats. So now let's try "cat".

Try it yourself! Enter this into your copy of OpenCyc.    Enter the word "cat" in the text field on the left in the top frame and click on the "Search" button.

No luck there, either....In cases such as this, my next step will be to try something more general. Hmmmm....how about "pet"?

Try it yourself! Enter this into your copy of OpenCyc.    Enter the word "pet" in the text field on the left in the top frame and click on the "Search" button.

Cyc presents a choice of two constants:

DomesticPet
NonPersonAnimal

How does Cyc produce these two constants from a string ("pet") which is different than both of them? The answer lies with Cyc's 'natural language support'. For example, the KB contains the following two "assertions" (or facts) related to #$DomesticPet:

Mt : GeneralEnglishMt
  (denotation Pet-TheWord SimpleNoun 0 DomesticPet)
  M(multiWordString ("domestic") Pet-TheWord SimpleNoun DomesticPet)

The first assertion above relates the word "pet" to the Cyc constant "#$DomesticPet". The second on relates the phrase "domestic pet" to the same Cyc constant.

Click here for suggested reading on this topic   Further reading on Cyc NL

#$DomesticPet is a more specific constant than #$NonPersonAnimal , since #$DomesticPet is a specialization of #$DomesticatedAnimal , which is a specialization of #$TameAnimal , which is a specialization of #$NonPersonAnimal .

Note: More specific collections 'inherit' the information that exists on the collections they are specializations of, and have further information as well. This hierarchy is ordered using the predicate #$genls.

#$DomesticPet is therefore better for me to use to describe Billy and Peter. The reason for this may be summarized in the 'Maxim of Efficient Ontologizing':

The Maxim Of Efficient Ontologizing: Be as specific as possible without being false.

I should say that, strictly speaking, this maxim applies to the writing of individual assertions (which state facts) and not to the writing of rules (which allow Cyc to deduce things from the facts it knows). When it comes to rules, the more general you can be (without being false) the better! But this is an introductory tutorial and we will therefore be confining ourselves to individual assertions.

#$DomesticPet is a collection, so to use this constant to make assertions about Billy and Peter I am going to have to assert that they are both members of this collection.

What are some other things I am likely to want to say about Billy and Peter? Well, another interesting fact about them is that they are brothers. Does this mean that, as was the case with #$DomesticPet , they should be asserted to be a member of a collection called, say, #$Brother ? (There is actually a problem with this. Can you see what it is?)

Click here for further explanation of why you just did the above.   What's wrong with making a collection called #$Brother?

Billy and Peter are not just brothers per se, they are brothers of each other. Such relationships between two or more things are handled in Cyc using predicates rather than collections.

Click here for suggested reading on this topic   Further reading on Predicates

Specific relationships between two or more things are handled in Cyc using predicates rather than collections.

Is there a predicate called #$brothers ?

Try it yourself! Enter this into your copy of OpenCyc.    Enter the word "brothers" in the text field next on the left in the top frame and click on the "Search" button..   [ Show me ]

No there is not.

Again, I realize that I better back up and try something more general. What is a more general version of the concept of brotherhood? Billy and Peter are...related to one another, i.e. they are relatives. Let's try "relatives"....

Try it yourself! Enter this into your copy of OpenCyc.    Enter the word "relatives" in the text field on the left in the top frame and click on the "Search" button.

Yes, there is a #$relatives ! However, don't forget the Maxim of Efficient Ontologizing. Perhaps there is something a bit more specific, if not as specific as "brothers" would be, that we can use.

Try it yourself! Enter this into your copy of OpenCyc.    From the "2 possible terms" page, click on the relatives link to get to view the details of#$relatives . With #$relatives up, look at the left-hand frame (the "Term Index Frame"), under Arg2, and click on "genlPreds".   [ Show me ]

Click here for further explanation of why you just did the above.   How do I use the Term Index Frame?

This presents a list of all the predicates which are direct specializations of #$relatives , as follows:

Mt : BiologicalSocialVocabularyMt
  (genlPreds grandchildren relatives)
  (genlPreds cohabitingFamilyMembers relatives)
  (genlPreds children relatives)
  (genlPreds coreRelatives relatives)

Mt : BiologyVocabularyMt
  (genlPreds siblings relatives)
  (genlPreds biologicalRelatives relatives)

Note: Just as Cyc collections are arranged in an information-inheriting hierarchy ordered using the predicate #$genls, Cyc predicates are arranged in an information-inheriting hierarchy ordered using the predicate #$genlPreds.

Click here for suggested reading on this topic   Tutorial lesson on predicates and the predicate hierarchy

Aha! #$siblings is more specific than #$relatives , and it is also true of Billy and Peter. So we can use that.

What else do I want to say about Billy and Peter? They like each other a lot (though they also roll around on the floor a lot biting each other...). So the next thing to do (which should not by now be too surprising) is to type in "likes", to see if there is some term (probably a predicate) I can use to say that Billy and Peter like each other.

Try it yourself! Enter this into your copy of OpenCyc.    Enter the word "likes" in the text field on the left in the top frame and click on the "Search" button.  [ Show me ]

You should see Cyc produce a constant with the somewhat bizarre name of #$likes-Generic . Some background information is in order here: making a name of the form "[X]-generic" is something of a Cyc convention which means that the constant in question tops a hierarchy of terms regarding [X], which have been defined more specifically.

A constant with a name of the form "[X]-generic" tops a hierarchy of more specifically defined terms regarding [X].

In our case, obviously, [X] will be something to do with 'liking'). Such a term is often an 'umbrella term', designed to gather together more specific terms, rather than having actual assertions made on it. Let's therefore look for something more specific. With #$likes-Generic up, let's see how its comment echoes my remark above:

Try it yourself! Enter this into your copy of OpenCyc.    The right frame should say "Predicate : likes-Generic" at the top. Scroll down in the right frame until you reach "comment:".   [ Show me ]

(likes-Generic SUBJ OBJ) means that SUBJ likes OBJ. This
         is a very general liking relation which is most useful for
         organising liking relations and for use during inference; for
         representation purposes, use a spec-Pred.

So let's find the appropriate 'spec-Pred' (this is Cyc-talk for 'more specialized predicate') for#$likes-Generic .

'Spec-Pred' is Cyc-talk for 'more specialized predicate'.

Here we could just do what we did for #$relatives , which was to look at the left-hand frame, under Arg2, and click on "genlPreds".

Try it yourself! Enter this into your copy of OpenCyc.    With #$likes-Generic still up , look at the left-hand frame, under Arg2, and click on "genlPreds".  [ Show me ]

You should see just one assertion:

Mt : AgentGVocabularyMt
  (genlPreds likesObject likes-Generic)

What is this #$likesObject ? Let's have a look:

Try it yourself! Enter this into your copy of OpenCyc.    Click on the word "likesObject" in the assertion.   [ Show me ]

Mt : AgentGVocabularyMt
comment : "(likesObject AGT OBJ) means that when the sentient agent
AGT is interacting in some way with OBJ, that agent feels some measure
of Enjoyment --- that is, (feelsEmotion AGT Enjoyment). The kinds of
interactions that produce Enjoyment depend largely on what kind of thing
OBJ is. Thus, `Joe likes the Mona Lisa' implies that Joe feels Enjoyment
when viewing the Mona Lisa. But `Joe likes pizza' implies that Joe feels
Enjoyment when eating that kind of food. There are some specialized
predicates of likesObject that give more information about the kind of
interaction between AGT and OBJ that results in Enjoyment; see, e.g.,
#$likesSensorially and #$likesAsFriend." 

I'm not sure that I want to assert #$likesObject of Billy and Peter. Billy doesn't quite like Peter in the way that Joe likes pizza (Billy's frequent biting of Peter notwithstanding). Hmmmm.....And what are these#$likesSensorially and #$likesAsFriend that appear in the comment? Why did they not appear when I clicked on "genlPreds"? (Can you figure it out?)

In fact the answers are different for the two different predicates. The answer for #$likesSensorially is that it is a Cyc constant that was not made public - it thus does not exist in the OpenCyc KB. (You can tell this because it is printed in black, not clickable blue).

The Cyc constants you see which are not links were not made public and therefore do not exist in the OpenCyc KB.

The answer for #$likesAsFriend is a little more complicated. Merely clicking on the "genlPreds" under "Arg2" produces all assertions directly made of the form (genlPreds ?X likes-Generic) , but a list of all such ?X is not a list of all the spec-Preds of #$likes-Generic . This is because #$genlPreds is a transitive predicate (i.e. if X is a spec of Y and Y is a spec of Z then X is a spec of Z). So there can be many more specs of a given constant than there are 'direct specs' (specs linked to that constant by specific assertions).

#$genlPreds is a transitive predicate (i.e. if X is a spec of Y and Y is a spec of Z then X is a spec of Z). So there can be many more specs of a given constant than there are 'direct specs' (specs linked to that constant by specific assertions).

There is actually a cool tool for viewing all the specs of a given constant, though. If you look slightly to the right of the "genlPreds", you will see a green plus.

Try it yourself! Enter this into your copy of OpenCyc.    Click on the green plus  slightly to the right of "genlPreds".   [ Show me ]

You should see the following:

Last query in AgentGVocabularyMt :
(genlPreds ?ARG1 likes-Generic)

3 answers for ?ARG1 :
likes-Generic   likesAsFriend   likesObject

Now #$likesAsFriend appears.

Click here for further explanation of why you just did the above.   Why does #$likes-Generic also appear in the list?

By the way, you probably noticed that as well as the green plus  next to "genlPreds", there is also a red diamond . This is in some ways an even cooler tool. You might like to click on it and see what it does....

So let's have a look at #$likesAsFriend :

Try it yourself! Enter this into your copy of OpenCyc.    Click on the word "likesAsFriend" in the main frame of the KB browser.   [ Show me ]

Mt : AgentGVocabularyMt
comment : "(likesAsFriend AGT1 AGT2) means that AGT1 enjoys
interacting socially with AGT2. See also the #$FeelingAttributeTypes
Friendliness. Note: this predicate does not imply that AGT1 likes AGT2
only as a friend -- there may be romantic feelings, and other feelings, as
well." 

This sounds more like Billy and Peter to me, if "interacting socially" is not just restricted to human society and also covers such activities as eating together and rolling around on the floor chewing one another's ears. This does seem plausible to me. To be sure, let's check what are called the 'argument-constraints' on#$likesAsFriend . If this predicate is intended only to apply to human beings, then next to the#$arg1Isa and #$arg2Isa predicates in the main frame for #$likesAsFriend (assuming it has been well-ontologized) #$Person should appear. Let's check that...

Try it yourself! Enter this into your copy of OpenCyc.    Look immediately above the comment I just quoted and find arg1Isa and arg2Isa.   [ Show me ]

In fact #$Person does not appear there, only #$PerceptualAgent . Will Billy and Peter meet this criterion? Yes they will, once they have been asserted to be members of the collection #$DomesticPet , as(#$genls #$DomesticPet #$PerceptualAgent) is true. (Can you verify this? Hint: you can do this using the green plus  you just learned about). So I will use #$likesAsFriend .

Lastly, how about saying how old Billy and Peter are? They are currently 11 weeks old. Let's type in "age".

Try it yourself! Enter this into your copy of OpenCyc.    Enter the word "age" in the text field on the left in the top frame and click on the "Search" button.

There is an #$age ! It too turns out to be a predicate. Here are some of its defining assertions:

Mt : BaseKB
arg1Isa : SomethingExisting 
arg2Isa : Time-Quantity 
arg1Format : SetTheFormat 
arg2Format : IntervalEntry

What does this mean? It means that the predicate #$age takes two arguments and the first argument (the thing which has the age) must be an instance of #$SomethingExisting , and the second argument (the age of the thing) must be an instance of #$Time-Quantity . Are Billy and Peter instances of#$SomethingExisting ? Yes they are. (You might like to verify this - again, using the green plus .)

The "formats" of the two arguments are a somewhat more technical affair. The #$arg1Format assertion basically means that different things may occupy the arg1 position for any given arg2 (Thus, not just one but an arbitrary number of creatures may be, say, 10 years old at any given time). The #$arg2Format assertion means that the age given may be a single, discrete value, or it may be a range (say, between 3 and 4 years). See the comment on #$IntervalEntry for more details on this.

Click here for suggested reading on this topic   Further reading on argument formats (#$arg1Format)

What exactly is a #$Time-Quantity , though? Is '11 weeks' an instance of it? Let's take a look at this constant. I can't find any assertion of the form (#$isa "11weeks" #$Time-Quantity) . Hmmmm.... What I do find out, however (with the help of some considerable experience with such matters :-)) is that instances of #$Time-Quantity are the results of a set of functions (functions which are gathered together in a collection called #$UnitOfTime ). We have so far encountered collections, individual instances of collections, predicates and microtheories. A function is yet another Cyc animal (a "new beast for our zoo [of logical forms]", as Bertrand Russell once put it).

Click here for suggested reading on this topic   Further reading on functions in Cyc

Let's browse the list of functions collected under #$UnitOfTime (by looking under "Arg2" in the frame on the left, and clicking on "isa").

Try it yourself! Enter this into your copy of OpenCyc.    Enter the word "UnitOfTime" in the text field on the left in the top frame and click on the "Search" button.. When its definitional information appears in the main frame, look at the left-hand frame, under Arg2, and click on "isa".   [ Show me ]

You should see the following:

Collection : UnitOfTime
GAF Arg : 2
Mt : BaseKB

(isa DaysDuration UnitOfTime)
  (isa SecondsDuration UnitOfTime)
  (isa QuartersDuration UnitOfTime)
  (isa HoursDuration UnitOfTime)
  (isa WeeksDuration UnitOfTime)
  (isa DecadesDuration UnitOfTime)
  (isa YearsDuration UnitOfTime)
  (isa MonthsDuration UnitOfTime)
  (isa MinutesDuration UnitOfTime)

#$WeeksDuration looks promising. Let's take a look at that.

Try it yourself! Enter this into your copy of OpenCyc.    Click on the word "WeeksDuration" in the main frame of the KB browser.   [ Show me ]

Its comment says:

            "A UnitOfTime function that takes one or two real numbers as
          arguments and returns, as its value, a comparable Time-Quantity
          attribute measured in weeks. More precisely, an expression of the
          form (WeeksDuration NUM) denotes the ("point-value")
          Time-Quantity of being exactly NUM weeks in duration, and an
          expression of the form (WeeksDuration MIN MAX) denotes the
          (properly interval-like) Time-Quantity of being at least MIN
          weeks and at most MAX weeks in duration." 

What this means is that I can use " (#$WeeksDuration 11) " to represent 11 weeks, and that the result of applying the function in this way will be an instance of #$Time-Quantity (which is what I need, since I want to plug it into an assertion using the predicate #$age , in the second argument position. The exact way in which this will happen will be explained in Step 3.).

Step One Summary: We have now identified the following constants which can be used to make assertions about Billy and Peter:

  • #$DomesticPet
  • #$siblings
  • #$likesAsFriend
  • #$age
  • #$WeeksDuration