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”?
Enter the word “kitten” in the text field on the left in the top frame and click on the “Search” button…
Unfortunately this turns up nothing. There is no constant called #$Kitten in the OpenCyc KB.
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”.
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”?
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:
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.
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.
|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?)
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.
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 ?
Enter the word “brothers” in the text field next on the left in the top frame and click on the “Search” button..
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”….
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.
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”.
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.
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.
Enter the word “likes” in the text field on the left in the top frame and click on the “Search” button.
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:
The right frame should say “Predicate : likes-Generic” at the top. Scroll down in the right frame until you reach “comment:“.
(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”.
With #$likes-Generic still up , look at the left-hand frame, under Arg2, and click on “genlPreds”.
You should see just one assertion:
Mt : AgentGVocabularyMt (genlPreds likesObject likes-Generic)
What is this #$likesObject ? Let’s have a look:
Click on the word “likesObject” in the assertion.
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.
Click on the green plus slightly to the right of “genlPreds”.
You should see the following:
Last query in AgentGVocabularyMt : (genlPreds ?ARG1 likes-Generic) 3 answers for ?ARG1 : likes-Generic likesAsFriend likesObject
Now #$likesAsFriend appears.
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 :
Click on the word “likesAsFriend” in the main frame of the KB browser.
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…
Look immediately above the comment I just quoted and find arg1Isa and arg2Isa.
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”.
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.
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).
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”).
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”.
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.
Click on the word “WeeksDuration” in the main frame of the KB browser.
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: