Defining Adjectives through Contextual Vocabulary Acquisition Adam C. Lammert 8 August 2002 CVA in assoc. with SNeRG Abstract This paper examines knowledge representations used in the process of making an algorithm that will find dictionary-like definitions of specific adjectives from contextual information. The representation system used here is the SNePS knowledge representation system, and ÔcontextÕ refers to information supplied about an adjective by the text in which it is found, grammatical information, and background knowledge of the reader (Rapaport and Kibby 2000:3). Since it may be helpful to understanding how the adjective algorithm was formed, the discussion proceeds chronologically. The first section describes how an initial passage was used to build an understanding of adjectives and objects held in the ÒunlikeÓ relation and how that, in turn, allowed for the adjective algorithm to be started. The next section discusses the Òfleshing outÓ of the algorithm with the addition of certain fundamental information about adjectives. After that, another passage is presented and shown in SnePS, and the result of that work is then incorporated into the algorithm as well. The final section states ways in which work could be continued in the making of an algorithm for defining adjectives from contextual information. Adjective Acquisition and CVA Years of research on vocabulary expansion, such as that done by Nagy and Herman (1987), has led to the idea that perhaps most of the words that we add to our vocabularies are learned through encounters in lectures, reading, television, and other contextually rich places (Nagy and Herman 1987:24). Memorization and Òdefinition- testÓ type vocabulary acquisition simply cannot account for the huge estimates of how many words we learn every year. How does the human mind carry out the task of analyzing sentences for contextual information and producing on-the-fly definitions for unknown words? Beyond this, can we get a knowledge representation and reasoning system to do the same thing? The system we are using to represent knowledge and make inferences is called SNePS. SNePS is a knowledge representation system used for artificial intelligence research. It is a propositional, intensional reasoning system whose primary data structure is that of a semantic network. It uses a system of nodes connected by arcs to represent concepts and objects, which it can build and find. With the aid of an inference package called SNIP the system can also make inferences about the knowledge base it possesses (Shapiro and Rapaport 1995:79). This system will allow an insight into contextual vocabulary acquisition as work is completed to have SNePS mimic, in some form, the process as done by human beings. Now, the first step in making a definition for any given word is determining the part of speech. This grammatical information determines how the reader will then proceed to retrieve contextual information about the word. Searching for information about nouns, for instance, would be different from looking for adjective information. Different parts of speech are used in different ways with respect to their location in the sentence and their relation to other words. Information about adjectives seems to be held in the specific ways they relate to the nouns they describe. Also, special relations arise (such as ÒlikeÓ and ÒunlikeÓ) which lend us rare and informative insight into unknown adjectives. Examining specific passages for their content was the first step toward opening the world of adjective acquisition to SNePS. Representing Passages with ÒUnlikeÓ In order to begin thinking about an adjective algorithm, it was necessary to explore passages containing contextually rich information about adjectives. Doing this would allow insight into the types of information available from context. The passage chosen for this purpose, because of its rich context, was the following. (1) ÒUnlike his brothers, who were noisy, outgoing, and very talkative, Fred was quite taciturn.Ó (Dulin 1970:440) Assume that ÒtaciturnÓ is the unknown word in this passage. Context would seem to imply, through the use of ÒunlikeÓ, that taciturn is not noisy or not outgoing or not talkative. The human mind seems to quickly take this sentence apart in order to gather information about unknown words such as ÒtaciturnÓ. Figuring out how to do this process in SNePS is exactly what we want to explore. The literal translation of the passage into SNePS seems fairly straightforward. Attempts by Kawachi and, later, Garver to represent the passage in SNePS conveyed the general meaning of the passage. That representation is included in a diagram along with this paper, and it rightly simplifies matters without changing meaning (e.g., the removal of ÒquiteÓ from in front of ÒtaciturnÓ, along with other such changes). All case frames are clear and easy to follow. However, I argue that something of the meaning of the passage is lost without a closer examination of the ÒunlikeÓ relationship. In this case, but perhaps not all, the idea of one object being unlike another is conveying a deeper understanding of an ÒunlikeÓ relation with respect to certain properties mentioned in the same sentence. Without a way of specifying which properties are the ones that make the objects unlike each other, all meaning may be lost. For example, if passage (1) is taken in the same way, but it is added that Fred is tall, we have already lost all meaning of the ÒunlikeÓ relationship in the following way. Our SNePS representation affords us only one node representing Fred, and all properties that Fred has will be represented using the same ÒFredÓ node. We know that Fred is unlike his brothers. We also know that Fred is tall and taciturn, whereas his brothers are noisy, outgoing, and talkative. But, looking at the representation, is Fred unlike his brothers in that he is tall and they are talkative? There is no way to make the distinction of which properties determine that Fred and his brothers are unlike. We have lost all meaning of how and why the two objects are unlike, and what it is that makes them unlike one another. There must be a way to make distinct the idea that Fred is unlike his brothers because Fred is taciturn and his brothers are outgoing, etc. This distinction is not only necessary for allowing our system to understand the ÒunlikeÓ relationship, but I argue that it is absolutely implicit in any sentence of a form similar to passage (1). It is for this reason that I propose a new arc label called Òw.r.t.Ó or Òwith respect toÓ (consult diagram 1a). This makes it possible to use GarverÕs representation, but add an all-important assertion that states the following: Fred is unlike his brothers with respect to Fred being taciturn and the brothers being noisy. In this case, a similar assertion would have to be made twice more to cover the cases in which the brothers have other properties as well. This creates no problems or holes in conveying the new understanding of the ÒunlikeÓ relationship, which is now much more clear and can be worked with as contextually meaningful information. It is from this rich information that we can infer new knowledge about adjectives. This is a crucial step in moving towards an adjective algorithm. Background knowledge must be added to the system so that the system can, in turn, infer assertions about represented sentences like (1). What things need to be inferred from the passage? We would, ideally, like them to closely approximate what people would infer from the passage. It seems reasonable to assume that the information a person would infer from passage (1), with no previous knowledge of what ÒtaciturnÓ means, is that ÒtaciturnÓ means Ònot talkativeÓ. A person might also infer, after seeing the ÒunlikeÓ relationship stated in the passage, that objects which are ÒtaciturnÓ cannot also be ÒtalkativeÓ. The latter may be more useful for our purposes, as there are instances that arise in which the former interpretation may be untrue. Fred may be ecstatic and unlike this brothers, who are merely happy, which is still a grammatically correct sentence. Although, this sentence seems to tell us something different than one adjective being the antonym of the other. In fact, ÒhappyÓ does not mean Ònot ecstaticÓ at all. However, the latter still holds. If one object is happy, it cannot also be simultaneously ecstatic. After all, a person cannot have two moods at once (Garver 2002:4). With the new representation of the ÒunlikeÓ relationship, it is possible to get the useful inferences that we want with only one rule. This rule utilizes the structure of the new ÒunlikeÓ relation as its antecedent, and then asserts a rule based on that antecedent. (2) ÒFor any two objects x and y and properties r and s, if x is unlike y with respect to x being r, and y is unlike x with respect to y being s, then for any object z, if z has r then z cannot have s.Ó The consequent of the larger conditional stated in (2) is a rule that gets asserted. It relates the two properties ÔrÕ and ÔsÕ. The result of having this background information, in addition to the ÒunlikeÓ relationship asserted before, would be a new assertion that if an object is taciturn, it cannot be noisy. This information is exactly what we are looking for. It is, presumably, the same information that a human mind would take from passage (1). ÒUnlikeÓ Allows the Beginning of an Adjective Algorithm Algorithms are already in place that will, to a greater or lesser degree, traverse the net of representations in SNePS and return definitional information about nouns and verbs (consult Òhttp://www.cse.buffalo.edu/~rapaport/cva.htmlÓ). However, until the representation of passages and rules related to ÒunlikeÓ, there was no way to get useful information about adjectives. Thus, since this information had been worked out, the important following step was to create an algorithm for going over the semantic net and returning contextual definitional information about adjectives. After unlike properties could be determined, the simple algorithm was devised to return only that information. It seemed as though information like synonyms, for example, would be more useful to search for in the future. Nothing of that sort could be added to the definition so early in the process, however. The algorithm that resulted was one that would take, as input, an unknown adjective, and it would then proceed to search for the structure defined by the consequent of rule (2), more specifically the following. (3) ÒFor any object z, if z has the property r, then it cannot have the property sÓ So, in the language of the rule, if the algorithm were called to look for a definition of property s, it would return r. The property r would then be listed in the filler under the slot Òunlike_propsÓ (consult the printed definition at the end of the master demo). This name for the slot is preferred over something like ÒantonymsÓ because of the previously discussed issue of ÒunlikeÓ properties not always being opposites. The example of ÒFred was ecstatic, unlike his brothers who were happyÓ is still highly applicable here. At the very least, this simple definition gives us an idea of what adjectives cannot be used to describe a given object. In the future, this could lead to a more specific series of lists. Perhaps a refined version could have the slot ÒantonymsÓ as well as another slot for adjectives like ÒhappyÓ and ÒecstaticÓ. This would be possible, since both types of relationships fall under the broader relationship ÒunlikeÓ. Adding Basic Concepts to the Algorithm Ð Noun Types After the algorithm was officially started and contained the important ÒunlikeÓ information, it seemed as though some very basic ideas could be added to the algorithm to make it more informative. One idea that stuck out as important and fundamental was that of noun types. Since any given adjectiveÕs purpose is to modify a noun in some way, it stands to reason that an important fact about adjectives is what types of nouns they can describe. Not every adjective can describe all types of nouns. For instance, ÒoutgoingÓ is usually only used to describe people or, sometimes, animals. Never would it be used to talk about plants or houses. With that established, it also would be more helpful to have the general class of nouns that any given adjective describes. This seems more useful than having an endless list of objects, all of which can be described by the adjective of discourse. There might be cases in which knowing what specific objects the adjective describes might be useful. That cannot be totally discounted. For now, though, it seems more useful to know that ÒtaciturnÓ can describe ÒpeopleÓ than, ÒtaciturnÓ can describe ÒFredÓ. Fred might also be my oak tree, which is named after a human. Objects and their names can be misleading, and are thus not helpful for knowing which types of nouns we are able to describe with an adjective. Thus, a simple addition was made to the adjective algorithm. A new slot was made called Òtype_nounsÓ, which acts as a list of all classes described by a given adjective. The function that returns this list searches over all objects that the input adjective describes and looks for member arcs pointing to them from an assertion, which in turn points to a class. In other words, it looks for any Òclass-memberÓ relation that involves an object describes by the given adjective. The class is what gets returned and gets added to the, now more extensive, definition. Adding More Fundamentals to the Algorithm Ð Adjective Classes Looking at passage (1) again, there seems to be an implicit idea that all the adjectives can be included in the ÒunlikeÓ relationship because they are all members of the same class of adjectives. It would not make sense to say, ÒUnlike his brothers, who were noisy, Fred was quite shortÓ. Without some connection between adjectives, the ÒunlikeÓ relationship makes no sense. This is different from the previous discussion of noun types. Rather than dealing with what the adjectives describe, we now look at what the adjectives mean (i.e., how the modify their nouns and not what nouns they modify). All adjectives in English would seem to belong to a larger class of adjectives. All of the adjectives used in passage (1) could be placed in the category Òpersonality traitsÓ. ÒTallÓ could belong to the category ÒheightsÓ along with ÒshortÓ. Moreover, certain relationships (such as ÒunlikeÓ) would seem to make it clear that adjectives belong to the same class. This can be exploited to further our definition building. In the case of the ÒunlikeÓ relationship, this could also be expanded to explain different degrees of the same description type, such as the previously discussed ÒhappyÓ, and ÓecstaticÓ. Adjectives that are together in the ÒunlikeÓ relationship must be, also, in a common class of adjectives. Without this, it would be possible to use the ÒunlikeÓ relationship to make unacceptable sentences. ÒUnlike his brothers, who were noisy, Fred was quite shortÓ is a fine example of this. Given this fact, in combination with rule (3) that is now asserted for all ÒunlikeÓ properties, it is possible to now add membership of adjectives to classes to our working definitions. Take another look at passage (1). Assume, again, that ÒtaciturnÓ is the unknown word. We could, knowing that ÒnoisyÓ is a personality trait, make the inference that ÒtaciturnÓ is also a personality trait. If ÒtaciturnÓ is not known, this bit of information could be very useful for the readerÕs comprehension. First, there needs to be a rule that states the inference to be made. After that, we can add a new function to the algorithm to search for this information. As previously mentioned, we need to look for instances of rule (3), and conclude if such a situation arises concurrently with one property being a member of a adjective class, then the other property also belongs to that class. Such a rule looks like the following. (4) ÒFor all objects x, if x has property r and cannot have property s, and r is a member of class k, then s must be a member of class k.Ó The consequent of the rule is an assertion that property ÔsÕ is a member of class ÔkÕ. Expanding our algorithm in this case is then a simple matter of looking for the Òclass-memberÓ case-frame. That is exactly that information the algorithm searches for on any inputted adjective. Any class that the adjective might belong to is placed in the filler of the ÒclassÓ slot upon creating a definition. Representing Another Passage In order to gather more information about what contextual information to look for in expanding the algorithm, the necessary task is to work with more passages in which there is contextual information. From each additional passage that is represented and analyzed, more ways to take definitional information via the algorithm will present themselves. Our ideas on contextual definitions form in the same way as the definitions themselves, by studying more instances of word usage. To that end, another passage was chosen to see what information about ÒtaciturnÓ we could infer. (5) ÒHe talked very little, and seemed all the more mysterious for his taciturn manner.Ó (Verne) The representation of this passage in SNePS had a few tricks in it. There is an object whose proper name is Joe (an arbitrary name, added for convenience, and inconsequential to the meaning of the passage). It is asserted that Joe is the possessor of a manner, and then asserted that his manner is taciturn. Although this representation seems awkward, it is the easiest way to take into account both that the manner, about which we are speaking, is JoeÕs and that his manner is taciturn. Next, Joe is carrying out an act, in which the act is talking and the frequency is little. It is assumed that Verne meant to say Òhe talked little at the time we were conversingÓ rather than Òhe had the general property of being a person who talked littleÓ. In the former case, the ÒactionÓ and ÒactÓ arcs were much more appropriate. Joe has the property ÒmysteriousÓ, which is modified by the word ÒmoreÓ. However, it is not certain from the sentence whether he was mysterious definitely. Hence, this property is in the relationship ÒseemÓ with Joe, indicating that he only seems to be more mysterious. I hold that the sentence has the implication, through its structure and the use of Òall the moreÓ, that Òtalking littleÓ and Òhaving a taciturn mannerÓ both are causes with the effect that Joe seems more mysterious. This is represented in the system by the use of two assertions, utilizing a Òcause-effectÓ case-frame. These two assertions become the two most important in allowing us to infer information about the sentence. A sentence with this structure seems to indicate that the two causes are equivalent to each other. Indeed, in this case they are. However, they need not be, as in the case ÒHe wore a long trench coat and seemed all the more mysterious for his taciturn manner.Ó Although, in many cases, such as passage (5), it is the case that both causes are equivalent. This could be very helpful in that it gives a perfectly synonymous statement to the one using ÒtaciturnÓ. Thus, we would like to allow for the possibility that these two statements are equivalent. With this in mind, a rule was developed which states that if two causes have the same effect, then they should stand in the relationship Òpossibly_equivÓ. This makes a lot of sense even without the context of the sentence. The rule is put as follows. (6) ÒIf assertion r is the cause of effect x, and assertion s is the cause of effect x, then r and s stand in the relationship Òpossibly_equivÓ. This special relationship now becomes important information that can be searched for by the algorithm. Although it is not definite information, it is, at worst, helpful for further inferences to be made and, at best, exactly the right information for building a definition. It is obviously, in either case, not information that should be overlooked. The algorithm has been expanded to search out assertions that are in the Òpossibly_equivÓ relationship, and puts them as filler into the Òpossible_equivÓ slot. And thus, the algorithm gives us a fourth type of information. Conclusion and Future Possibilities The creation of an adjective algorithm is an important step towards a complete program for contextual vocabulary acquisition. With algorithms for nouns, verbs and adjectives in place, the bigger picture of CVA is a matter of expansion and refinement. Moreover, an adjective algorithm will, most likely, be the launching pad for an adverb algorithm because of the close relation of those parts of speech. The possibilities for the future of this adjective algorithm are many. Like the project as a whole, expansion and refinement are key ideas. The grouping of Òunlike propertiesÓ created by the algorithm could eventually be refined by breaking those properties down into more specific groups. All properties picked out by such a search will naturally include those that are antonyms (such as ÒtallÓ and ÒshortÓ) and those that are degrees of the same idea (i.e. ÒhappyÓ vs. ÒecstaticÓ). Both of these can be used in an ÒunlikeÓ relationship, and both convey very different meanings. Noun types that are picked out by the algorithm could be greatly expanded to include, not only Òclass-membershipÓ of objects but also Òsubclass- superclassÓ relationships and, perhaps, more abstract categories. The same idea can be applied to adjective classes, in that not all categories to in which an adjective might belong are states are Òclass-membershipÓ. Furthermore, adjective classes can, as previously discussed, be used to label adjectives which of the same type but of different degrees. Examples are those adjectives picked out by the ÒunlikeÓ relationship that are not antonyms. There are also some much more specific issues that need to be addressed with the representations. Rule (2) seems to need the accompaniment of a rule in which the converse of the consequent is the only change. If both rules are not included, however, there are some essential inferences that are missed by the system. Both rules are, for all intents and purposes, exactly the same. Perhaps rule (2) needs to be rethought or maybe there isnÕt anything missing in the inferences at all. I am confident, however, that both rules, thought seeming the same, are necessary. Most importantly, the grunt work of representing passages, finding the contextually rich information held within, and enabling the algorithm to retrieve that information is what most needs to be done. The more passages that are examined and used to expand the algorithm, the more specific and dictionary-like the definitions will become. More passages containing ÒtaciturnÓ can be found online at the CVA website (http://www.cse.buffalo.edu/~rapaport/CVA.html) along with the algorithm and information about the CVA project as a whole. Bibliography 1. Dulin, Kenneth L. (1970) ÒUsing context Clues in Word Recognition and Comprehension.Ó, The Reading Teacher 23(5): 440-445, 469. 2. Garver, Christopher. ÒAdjective Representation in Contextual Vocabulary Acquisition.Ó 2002. http://www.cse.buffalo.edu/~cjgarver/CVA/finalreport.doc. 3. Kawachi, Kazuhiro. ÒVocabulary Acquisition from the Context Containing unlike.Ó 2001. 4. Nagy, William E. & Herman, Patricia A. ÒBreadth and Depth of Vocabulary Knowledge: Implications for Acquisition and Instruction.Ó 1987. In Margaret G. McKeown & Mary E. Curtis (Eds.), The Nature of Vocabulary Acquisition (19- 35). Hillsdale, NJ: Erlbaum. 5. Rapaport, William J., and Michael W. Kibby. ÒContextual Vocabulary Acquisition: Development of a Computational Theory and Educational Curriculum.Ó 2000. http://www.cse.buffalo.edu/~rapaport/role.pdf. 6. Shapiro, Stuart C., and William J. Rapaport. ÒAn Introduction to a Computational Reader of Narratives.Ó 1995. In Judith F. Duchin, Gail A. Bruder & Lynne E. Hewitt (Eds.), Deixis In Narrative: A Cognitive Science Perspective (79-109), Hillsdale, NJ: Erlbaum. 7. Verne, Jules. ÒAround the World in 80 Days.Ó About Classic Literature Guide. 2002. About, Inc. 5 May 2002 http://classiclit.about.com/library/bl-etexts/jverne/bl- jver-80-1.htm?terms=taciturn. Appendix A (the adjective algorithm) (in-package :snepsul) (defstruct adj_info "A structure to store and report definitions of adjectives" adjective unlike_props class type_nouns possible_equiv) (defun define_adjective (adj) "Gives a definition of the adjective" (let (definition) (setf definition (make-adj_info)) (setf (adj_info-adjective definition) adj) (setf (adj_info-unlike_props definition) (findUnlikeProp adj)) (setf (adj_info-class definition) (findClass adj)) (setf (adj_info-type_nouns definition) (findNounTypes adj)) (setf (adj_info-possible_equiv definition) (findPossEquiv adj)) definition)) (defun findUnlikeProp (adj) "Find words that are unlike 'adj'." #3! ((find (compose lex- property- arg- min) 0 (compose lex- property- arg- max) 0 (compose lex- property- arg- cq- ! ant property lex) ~adj (compose lex- property- object object- property lex) ~adj))) (defun findClass (adj) "Find the class in which 'adj' is." #3! ((find (lex- class- member lex) ~adj))) (defun findNounTypes (adj) "Find types of nouns that the adjective can describe" #3! ((find (lex- class- member object- property lex) ~adj))) (defun findPossEquiv (adj) "Find any possible equivalences" #3! ((find (compose arg- rel lex) "possibly_equiv" (compose arg- arg property lex) ~adj))) Appendix B (master demo run) Enter a filename: ~alammert/algorithm/master.demo File /home/visitor/alammert/algorithm/master.demo is now the source of input. The demo will pause between commands, at that time press RETURN to continue, or ? to see a list of available commands CPU time : 0.03 * ;;;make sure that "algo.cl" has been loaded at the lisp prompt ;;;Welcome to the master demo about the adjective algorithm. ;;;What information can potentially be retrieved from ;;;context about a given adjective? ;;;Let's give SNePS something to think about first. ;;;After that, we can see what information the algorithm picks up for us. (resetnet); --- pause --- Net reset - Relations and paths are still defined CPU time : 0.02 * (define arg arg1 arg2 wrt1 wrt2 rel property proper-name object possessor lex cause cause1 cause2 effect object1 object2 act action frequency mod head equiv member class); --- pause --- (arg arg1 arg2 wrt1 wrt2 rel property proper-name object possessor lex cause cause1 cause2 effect object1 object2 act action frequency mod head equiv membe\ r class) CPU time : 0.01 * ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;\ ; ;;;"If two objects, x and y, are unlike with respect to x being r and ;;;y being s (r and s properties), then any object that is r cannot ;;;also be s. (describe (add forall ($x $y $r $s) ant (build arg1 *x rel (build lex "unlike") arg2 *y wrt1 (build object *x property *r) wrt2 (build object *y property *s)) cq (build forall $z ant (build object *z property *r) cq (build max 0 min 0 arg(build object *z property *s))))); --- pause --- I wonder if ((p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4))))) holds within the BS defined by context default-defaultct (m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex unlike))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4))))\ ) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4)))))))) (m2!) CPU time : 0.03 * ;;;"If two objects, x and y, are unlike with respect to x being r and ;;;y being s (r and s properties), then any object that is s cannot ;;;also be r. (describe (add forall ($x $y $r $s) ant (build arg1 *x rel (build lex "unlike") arg2 *y wrt1 (build object *x property *r) wrt2 (build object *y property *s)) cq (build forall $z ant (build object *z property *s) cq (build max 0 min 0 arg(build object *z property *r))))); --- pause --- I wonder if ((p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9))))) holds within the BS defined by context default-defaultct (m3! (forall v9 v8 v7 v6) (ant (p10 (arg1 v6) (arg2 v7) (rel (m1 (lex unlike))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9))))\ ) (cq (p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8)))))))) (m3!) CPU time : 0.11 * ;;;If an object x is r (a property), and consequently cannot be s, and ;;;s is a member of class k, then r must also be a member of class k. (describe (add forall ($x $r $s $k) &ant ((build ant (build object *x property *r) cq (build max 0 min 0 arg(build object *x property *s))) (build member *s class *k)) cq (build member *r class *k))); --- pause --- I wonder if ((p19 (class v14) (member v13))) holds within the BS defined by context default-defaultct I wonder if ((p18 (ant (p15 (object v11) (property v12))) (cq (p17 (min 0) (max 0) (arg (p16 (object v11) (property v13))))))) holds within the BS defined by context default-defaultct (m4! (forall v14 v13 v12 v11) (&ant (p19 (class v14) (member v13)) (p18 (ant (p15 (object v11) (property v12))) (cq (p17 (min 0) (max 0) (arg (p16 (object v11) (property v13))))))) (cq (p20 (class v14) (member v12)))) (m4!) CPU time : 0.03 * ;;;If an object x is r (a property), and consequently cannot be s, and ;;;r is a member of class k, then s must also be a member of class k. (describe (add forall ($x $r $s $k) &ant ((build ant (build object *x property *r) cq (build max 0 min 0 arg(build object *x property *s))) (build member *r class *k)) cq (build member *s class *k))); --- pause --- I wonder if ((p25 (class v18) (member v16))) holds within the BS defined by context default-defaultct I wonder if ((p24 (ant (p21 (object v15) (property v16))) (cq (p23 (min 0) (max 0) (arg (p22 (object v15) (property v17))))))) holds within the BS defined by context default-defaultct (m5! (forall v18 v17 v16 v15) (&ant (p25 (class v18) (member v16)) (p24 (ant (p21 (object v15) (property v16))) (cq (p23 (min 0) (max 0) (arg (p22 (object v15) (property v17))))))) (cq (p26 (class v18) (member v17)))) (m5!) CPU time : 0.03 * ;;;An object exists, that is named Fred. (describe (add object #Fred proper-name (build lex "Fred"))); --- pause --- (m7! (object b1) (proper-name (m6 (lex Fred)))) (m7!) CPU time : 0.01 * ;;;Fred is a member of the class People. (describe (add member #Fred class (build lex "People"))); --- pause --- (m9! (class (m8 (lex People))) (member b2)) (m9!) CPU time : 0.01 * ;;;Fred has brothers. (describe (add possessor *Fred rel (build lex "brothers") object #brothers)); --- pause --- (m11! (object b3) (possessor b2) (rel (m10 (lex brothers)))) (m11!) CPU time : 0.02 * ;;;Fred is taciturn. (describe (add object *Fred property (build lex "taciturn"))); --- pause --- I wonder if ((p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property (v3 <-- m12)))) (wrt2 (p2 (object v2) (property v4))))) holds within the BS defined by context default-defaultct I wonder if ((p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property (v9 <-- m12)))))) holds within the BS defined by context default-defaultct (m13! (object b2) (property (m12 (lex taciturn)))) (m13!) CPU time : 0.05 * ;;;Fred's brothers are noisy. (describe (add object *brothers property (build lex "noisy"))); --- pause --- I wonder if ((p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property (v3 <-- m14)))) (wrt2 (p2 (object v2) (property v4))))) holds within the BS defined by context default-defaultct I wonder if ((p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property (v9 <-- m14)))))) holds within the BS defined by context default-defaultct (m15! (object b3) (property (m14 (lex noisy)))) (m15!) CPU time : 0.10 * ;;;Noisy, like taciturn, is a member of the class of personality traits. (describe (add member (build lex "noisy") class (build lex "personality"))); --- pause --- (m17! (class (m16 (lex personality))) (member (m14 (lex noisy)))) (m17!) CPU time : 0.01 * ;;;Fred's brothers are talkative. (describe (add object *brothers property (build lex "talkative"))); --- pause --- I wonder if ((p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property (v3 <-- m19)))) (wrt2 (p2 (object v2) (property v4))))) holds within the BS defined by context default-defaultct I wonder if ((p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property (v9 <-- m19)))))) holds within the BS defined by context default-defaultct (m20! (object b3) (property (m19 (lex talkative)))) (m20!) CPU time : 0.10 * ;;;Talkative is also a member of the class of personality traits. (describe (add member (build lex "talkative") class (build lex "personality"))); --- pause --- (m21! (class (m14 (lex personality))) (member (m19 (lex talkative)))) (m21!) CPU time : 0.01 * ;;;Fred's brothers are outgoing. (describe (add object *brothers property (build lex "outgoing"))); --- pause --- I wonder if ((p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property (v3 <-- m22)))) (wrt2 (p2 (object v2) (property v4))))) holds within the BS defined by context default-defaultct I wonder if ((p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property (v9 <-- m22)))))) holds within the BS defined by context default-defaultct (m23! (object b3) (property (m22 (lex outgoing)))) (m23!) CPU time : 0.07 * ;;;Outgoing, in addition, is a member of the class of personalities. (describe (add member (build lex "outgoing") class (build lex "personality"))); --- pause --- (m24! (class (m14 (lex personality))) (member (m22 (lex outgoing)))) (m24!) CPU time : 0.02 * ;;;Fred is unlike is brothers, with respect to Fred being taciturn ;;;and his brothers being noisy. (describe (add arg1 *Fred arg2 *brothers rel (build lex "unlike") wrt1 (find object *Fred property (find lex "taciturn")) wrt2 (find object *brothers property (find lex "noisy")))); --- pause --- Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m16)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m16)))))))) Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m16)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m16)))))))) Since ((m3! (forall v9 v8 v7 v6) (ant (p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9)\ )))) (cq (p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))))) and ((p10 (arg1 (v6 <-- b2)) (arg2 (v7 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object (v6 <-- b2)) (property (v8 <-- m12)))) (wrt2 (p9 (object (v7 <-- b3)) (property (v9 <-- m16)))))) I infer ((p14 (forall v10) (ant (p11 (object v10) (property (v9 <-- m16)))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property (v8 <-- m12))))))\ )) Since ((m3! (forall v9 v8 v7 v6) (ant (p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9)\ )))) (cq (p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))))) and ((p10 (arg1 (v6 <-- b2)) (arg2 (v7 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object (v6 <-- b2)) (property (v8 <-- m12)))) (wrt2 (p9 (object (v7 <-- b3)) (property (v9 <-- m16)))))) I infer ((p14 (forall v10) (ant (p11 (object v10) (property (v9 <-- m16)))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property (v8 <-- m12))))))\ )) Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m16)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m16)))))))) Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m16)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m16)))))))) Since ((m5! (forall (v18 <-- m14) (v17 <-- m16) (v16 <-- m12) (v15 <-- v5)) (&ant (p25 (class (v18 <-- m14)) (member (v16 <-- m12))) (p24 (ant (p21 (object (v15 <-- v5)) (property (v16 <-- m12)))) (cq (p23 (min 0) (max 0) (arg (p22 (object (v15 <-- v5)) (property (v17 <-- m16)))))))) (cq (p26 (class (v18 <-- m14)) (member (v17 <-- m16)))))) and ((p25 (class (v18 <-- m14)) (member (v16 <-- m12)))) and ((p24 (ant (p21 (object (v15 <-- v5)) (property (v16 <-- m12)))) (cq (p23 (min 0) (max 0) (arg (p22 (object (v15 <-- v5)) (property (v17 <-- m16)))))))) I infer ((p26 (class (v18 <-- m14)) (member (v17 <-- m16)))) Since ((m5! (forall (v18 <-- m14) (v17 <-- m12) (v16 <-- m16) (v15 <-- v10)) (&ant (p25 (class (v18 <-- m14)) (member (v16 <-- m16))) (p24 (ant (p21 (object (v15 <-- v10)) (property (v16 <-- m16)))) (cq (p23 (min 0) (max 0) (arg (p22 (object (v15 <-- v10)) (property (v17 <-- m12)))))))) (cq (p26 (class (v18 <-- m14)) (member (v17 <-- m12)))))) and ((p25 (class (v18 <-- m14)) (member (v16 <-- m16)))) and ((p24 (ant (p21 (object (v15 <-- v10)) (property (v16 <-- m16)))) (cq (p23 (min 0) (max 0) (arg (p22 (object (v15 <-- v10)) (property (v17 <-- m12)))))))) I infer ((p26 (class (v18 <-- m14)) (member (v17 <-- m12)))) Since ((m4! (forall (v14 <-- m14) (v13 <-- m16) (v12 <-- m12) (v11 <-- v5)) (&ant (p19 (class (v14 <-- m14)) (member (v13 <-- m16))) (p18 (ant (p15 (object (v11 <-- v5)) (property (v12 <-- m12)))) (cq (p17 (min 0) (max 0) (arg (p16 (object (v11 <-- v5)) (property (v13 <-- m16)))))))) (cq (p20 (class (v14 <-- m14)) (member (v12 <-- m12)))))) and ((p19 (class (v14 <-- m14)) (member (v13 <-- m16)))) and ((p18 (ant (p15 (object (v11 <-- v5)) (property (v12 <-- m12)))) (cq (p17 (min 0) (max 0) (arg (p16 (object (v11 <-- v5)) (property (v13 <-- m16)))))))) I infer ((p20 (class (v14 <-- m14)) (member (v12 <-- m12)))) Since ((m4! (forall (v14 <-- m14) (v13 <-- m12) (v12 <-- m16) (v11 <-- v10)) (&ant (p19 (class (v14 <-- m14)) (member (v13 <-- m12))) (p18 (ant (p15 (object (v11 <-- v10)) (property (v12 <-- m16)))) (cq (p17 (min 0) (max 0) (arg (p16 (object (v11 <-- v10)) (property (v13 <-- m12)))))))) (cq (p20 (class (v14 <-- m14)) (member (v12 <-- m16)))))) and ((p19 (class (v14 <-- m14)) (member (v13 <-- m12)))) and ((p18 (ant (p15 (object (v11 <-- v10)) (property (v12 <-- m16)))) (cq (p17 (min 0) (max 0) (arg (p16 (object (v11 <-- v10)) (property (v13 <-- m12)))))))) I infer ((p20 (class (v14 <-- m14)) (member (v12 <-- m16)))) Since ((p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))) and ((p4 (object (v5 <-- b2)) (property (v3 <-- m12)))) I infer ((p6 (min 0) (max 0) (arg (p5 (object (v5 <-- b2)) (property (v4 <-- m16)))))\ ) Since ((p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))) and ((p11 (object (v10 <-- b3)) (property (v9 <-- m16)))) I infer ((p13 (min 0) (max 0) (arg (p12 (object (v10 <-- b3)) (property (v8 <-- m12))\ )))) I wonder if ((p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property (v4 <-- m16)))))) holds within the BS defined by context default-defaultct Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m16)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m16)))))))) I wonder if ((p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property (v8 <-- m12)))) (wrt2 (p9 (object v7) (property v9))))) holds within the BS defined by context default-defaultct Since ((m3! (forall v9 v8 v7 v6) (ant (p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9)\ )))) (cq (p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))))) and ((p10 (arg1 (v6 <-- b2)) (arg2 (v7 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object (v6 <-- b2)) (property (v8 <-- m12)))) (wrt2 (p9 (object (v7 <-- b3)) (property (v9 <-- m16)))))) I infer ((p14 (forall v10) (ant (p11 (object v10) (property (v9 <-- m16)))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property (v8 <-- m12))))))\ )) Since ((m3! (forall v9 v8 v7 v6) (ant (p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9)\ )))) (cq (p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))))) and ((p10 (arg1 (v6 <-- b2)) (arg2 (v7 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object (v6 <-- b2)) (property (v8 <-- m12)))) (wrt2 (p9 (object (v7 <-- b3)) (property (v9 <-- m16)))))) I infer ((p14 (forall v10) (ant (p11 (object v10) (property (v9 <-- m16)))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property (v8 <-- m12))))))\ )) Since ((m3! (forall v9 v8 v7 v6) (ant (p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9)\ )))) (cq (p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))))) and ((p10 (arg1 (v6 <-- b2)) (arg2 (v7 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object (v6 <-- b2)) (property (v8 <-- m12)))) (wrt2 (p9 (object (v7 <-- b3)) (property (v9 <-- m16)))))) I infer ((p14 (forall v10) (ant (p11 (object v10) (property (v9 <-- m16)))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property (v8 <-- m12))))))\ )) I know ((m25! (arg1 (b2)) (arg2 (b3)) (rel (m1 (lex (unlike)))) (wrt1 (m13! (object (b2)) (property (m12 (lex (taciturn)))))) (wrt2 (m17! (object (b3)) (property (m16 (lex (noisy)))))))) (m31! (min 0) (max 0) (arg (m30 (object b3) (property (m12 (lex taciturn)))))\ ) (m29! (min 0) (max 0) (arg (m28 (object b2) (property (m16 (lex noisy)))))) (p66! (ant (p62 (object v10) (property (m16)))) (cq (p64 (min 0) (max 0) (arg (p63 (object v10) (property (m12))))))) (p65! (ant (p59 (object v5) (property (m12)))) (cq (p61 (min 0) (max 0) (arg (p60 (object v5) (property (m16))))))) (m27! (forall v10) (ant (p62)) (cq (p64))) (m26! (forall v5) (ant (p59)) (cq (p61))) (m25! (arg1 b2) (arg2 b3) (rel (m1 (lex unlike))) (wrt1 (m13! (object b2) (property (m12)))) (wrt2 (m17! (object b3) (property (m16))))) (m18! (class (m14 (lex personality))) (member (m16))) (m15! (class (m14)) (member (m12))) (m31! m29! p66! p65! m27! m26! m25! m18! m15!) CPU time : 0.29 * ;;;Fred is unlike is brothers, with respect to Fred being taciturn ;;;and his brothers being outgoing. (describe (add arg1 *Fred arg2 *brothers rel (build lex "unlike") wrt1 (find object *Fred property (find lex "taciturn")) wrt2 (find object *brothers property (find lex "outgoing")))); --- pause --- Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m22)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m22)))))))) Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m22)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m22)))))))) Since ((m3! (forall v9 v8 v7 v6) (ant (p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9)\ )))) (cq (p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))))) and ((p10 (arg1 (v6 <-- b2)) (arg2 (v7 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object (v6 <-- b2)) (property (v8 <-- m12)))) (wrt2 (p9 (object (v7 <-- b3)) (property (v9 <-- m22)))))) I infer ((p14 (forall v10) (ant (p11 (object v10) (property (v9 <-- m22)))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property (v8 <-- m12))))))\ )) Since ((m3! (forall v9 v8 v7 v6) (ant (p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9)\ )))) (cq (p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))))) and ((p10 (arg1 (v6 <-- b2)) (arg2 (v7 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object (v6 <-- b2)) (property (v8 <-- m12)))) (wrt2 (p9 (object (v7 <-- b3)) (property (v9 <-- m22)))))) I infer ((p14 (forall v10) (ant (p11 (object v10) (property (v9 <-- m22)))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property (v8 <-- m12))))))\ )) Since ((m3! (forall v9 v8 v7 v6) (ant (p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9)\ )))) (cq (p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))))) and ((p10 (arg1 (v6 <-- b2)) (arg2 (v7 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object (v6 <-- b2)) (property (v8 <-- m12)))) (wrt2 (p9 (object (v7 <-- b3)) (property (v9 <-- m22)))))) I infer ((p14 (forall v10) (ant (p11 (object v10) (property (v9 <-- m22)))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property (v8 <-- m12))))))\ )) Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m22)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m22)))))))) Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m22)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m22)))))))) Since ((m5! (forall (v18 <-- m14) (v17 <-- m12) (v16 <-- m22) (v15 <-- v10)) (&ant (p25 (class (v18 <-- m14)) (member (v16 <-- m22))) (p24 (ant (p21 (object (v15 <-- v10)) (property (v16 <-- m22)))) (cq (p23 (min 0) (max 0) (arg (p22 (object (v15 <-- v10)) (property (v17 <-- m12)))))))) (cq (p26 (class (v18 <-- m14)) (member (v17 <-- m12)))))) and ((p25 (class (v18 <-- m14)) (member (v16 <-- m22)))) and ((p24 (ant (p21 (object (v15 <-- v10)) (property (v16 <-- m22)))) (cq (p23 (min 0) (max 0) (arg (p22 (object (v15 <-- v10)) (property (v17 <-- m12)))))))) I infer ((p26 (class (v18 <-- m14)) (member (v17 <-- m12)))) Since ((m4! (forall (v14 <-- m14) (v13 <-- m22) (v12 <-- m12) (v11 <-- v5)) (&ant (p19 (class (v14 <-- m14)) (member (v13 <-- m22))) (p18 (ant (p15 (object (v11 <-- v5)) (property (v12 <-- m12)))) (cq (p17 (min 0) (max 0) (arg (p16 (object (v11 <-- v5)) (property (v13 <-- m22)))))))) (cq (p20 (class (v14 <-- m14)) (member (v12 <-- m12)))))) and ((p19 (class (v14 <-- m14)) (member (v13 <-- m22)))) and ((p18 (ant (p15 (object (v11 <-- v5)) (property (v12 <-- m12)))) (cq (p17 (min 0) (max 0) (arg (p16 (object (v11 <-- v5)) (property (v13 <-- m22)))))))) I infer ((p20 (class (v14 <-- m14)) (member (v12 <-- m12)))) Since ((p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))) and ((p4 (object (v5 <-- b2)) (property (v3 <-- m12)))) I infer ((p6 (min 0) (max 0) (arg (p5 (object (v5 <-- b2)) (property (v4 <-- m22)))))\ ) Since ((p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))) and ((p4 (object (v5 <-- b2)) (property (v3 <-- m12)))) I infer ((p6 (min 0) (max 0) (arg (p5 (object (v5 <-- b2)) (property (v4 <-- m16)))))\ ) Since ((p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))) and ((p11 (object (v10 <-- b3)) (property (v9 <-- m22)))) I infer ((p13 (min 0) (max 0) (arg (p12 (object (v10 <-- b3)) (property (v8 <-- m12))\ )))) Since ((p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))) and ((p11 (object (v10 <-- b3)) (property (v9 <-- m22)))) I infer ((p13 (min 0) (max 0) (arg (p12 (object (v10 <-- b3)) (property (v8 <-- m12))\ )))) I wonder if ((p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property (v4 <-- m22)))))) holds within the BS defined by context default-defaultct Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m22)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m22)))))))) I know ((m32! (arg1 (b2)) (arg2 (b3)) (rel (m1 (lex (unlike)))) (wrt1 (m13! (object (b2)) (property (m12 (lex (taciturn)))))) (wrt2 (m23! (object (b3)) (property (m22 (lex (outgoing)))))))) (m36! (min 0) (max 0) (arg (m35 (object b2) (property (m22 (lex outgoing)))))\ ) (p71! (ant (p69 (object v10) (property (m22)))) (cq (p64 (min 0) (max 0) (arg (p63 (object v10) (property (m12 (lex taciturn)))\ ))))) (p70! (ant (p59 (object v5) (property (m12)))) (cq (p68 (min 0) (max 0) (arg (p67 (object v5) (property (m22))))))) (m34! (forall v10) (ant (p69)) (cq (p64))) (m33! (forall v5) (ant (p59)) (cq (p68))) (m32! (arg1 b2) (arg2 b3) (rel (m1 (lex unlike))) (wrt1 (m13! (object b2) (property (m12)))) (wrt2 (m23! (object b3) (property (m22))))) (m31! (min 0) (max 0) (arg (m30 (object b3) (property (m12))))) (m24! (class (m14 (lex personality))) (member (m22))) (m15! (class (m14)) (member (m12))) (m36! p71! p70! m34! m33! m32! m31! m24! m15!) CPU time : 0.23 * ;;;Fred is unlike his brothers, with respect to Fred being taciturn ;;;and his brothers being talkative. (describe (add arg1 *Fred arg2 *brothers rel (build lex "unlike") wrt1 (find object *Fred property (find lex "taciturn")) wrt2 (find object *brothers property (find lex "talkative"))))\ ; --- pause --- Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m19)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m19)))))))) Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m19)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m19)))))))) Since ((m3! (forall v9 v8 v7 v6) (ant (p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9)\ )))) (cq (p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))))) and ((p10 (arg1 (v6 <-- b2)) (arg2 (v7 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object (v6 <-- b2)) (property (v8 <-- m12)))) (wrt2 (p9 (object (v7 <-- b3)) (property (v9 <-- m19)))))) I infer ((p14 (forall v10) (ant (p11 (object v10) (property (v9 <-- m19)))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property (v8 <-- m12))))))\ )) Since ((m3! (forall v9 v8 v7 v6) (ant (p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9)\ )))) (cq (p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))))) and ((p10 (arg1 (v6 <-- b2)) (arg2 (v7 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object (v6 <-- b2)) (property (v8 <-- m12)))) (wrt2 (p9 (object (v7 <-- b3)) (property (v9 <-- m19)))))) I infer ((p14 (forall v10) (ant (p11 (object v10) (property (v9 <-- m19)))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property (v8 <-- m12))))))\ )) Since ((m3! (forall v9 v8 v7 v6) (ant (p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property v9)\ )))) (cq (p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))))) and ((p10 (arg1 (v6 <-- b2)) (arg2 (v7 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object (v6 <-- b2)) (property (v8 <-- m12)))) (wrt2 (p9 (object (v7 <-- b3)) (property (v9 <-- m19)))))) I infer ((p14 (forall v10) (ant (p11 (object v10) (property (v9 <-- m19)))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property (v8 <-- m12))))))\ )) Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m19)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m19)))))))) Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m19)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m19)))))))) Since ((m5! (forall (v18 <-- m14) (v17 <-- m12) (v16 <-- m19) (v15 <-- v10)) (&ant (p25 (class (v18 <-- m14)) (member (v16 <-- m19))) (p24 (ant (p21 (object (v15 <-- v10)) (property (v16 <-- m19)))) (cq (p23 (min 0) (max 0) (arg (p22 (object (v15 <-- v10)) (property (v17 <-- m12)))))))) (cq (p26 (class (v18 <-- m14)) (member (v17 <-- m12)))))) and ((p25 (class (v18 <-- m14)) (member (v16 <-- m19)))) and ((p24 (ant (p21 (object (v15 <-- v10)) (property (v16 <-- m19)))) (cq (p23 (min 0) (max 0) (arg (p22 (object (v15 <-- v10)) (property (v17 <-- m12)))))))) I infer ((p26 (class (v18 <-- m14)) (member (v17 <-- m12)))) Since ((m4! (forall (v14 <-- m14) (v13 <-- m19) (v12 <-- m12) (v11 <-- v5)) (&ant (p19 (class (v14 <-- m14)) (member (v13 <-- m19))) (p18 (ant (p15 (object (v11 <-- v5)) (property (v12 <-- m12)))) (cq (p17 (min 0) (max 0) (arg (p16 (object (v11 <-- v5)) (property (v13 <-- m19)))))))) (cq (p20 (class (v14 <-- m14)) (member (v12 <-- m12)))))) and ((p19 (class (v14 <-- m14)) (member (v13 <-- m19)))) and ((p18 (ant (p15 (object (v11 <-- v5)) (property (v12 <-- m12)))) (cq (p17 (min 0) (max 0) (arg (p16 (object (v11 <-- v5)) (property (v13 <-- m19)))))))) I infer ((p20 (class (v14 <-- m14)) (member (v12 <-- m12)))) Since ((p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))) and ((p4 (object (v5 <-- b2)) (property (v3 <-- m12)))) I infer ((p6 (min 0) (max 0) (arg (p5 (object (v5 <-- b2)) (property (v4 <-- m19)))))\ ) Since ((p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))) and ((p4 (object (v5 <-- b2)) (property (v3 <-- m12)))) I infer ((p6 (min 0) (max 0) (arg (p5 (object (v5 <-- b2)) (property (v4 <-- m22)))))\ ) Since ((p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))) and ((p11 (object (v10 <-- b3)) (property (v9 <-- m19)))) I infer ((p13 (min 0) (max 0) (arg (p12 (object (v10 <-- b3)) (property (v8 <-- m12))\ )))) Since ((p14 (forall v10) (ant (p11 (object v10) (property v9))) (cq (p13 (min 0) (max 0) (arg (p12 (object v10) (property v8))))))) and ((p11 (object (v10 <-- b3)) (property (v9 <-- m19)))) I infer ((p13 (min 0) (max 0) (arg (p12 (object (v10 <-- b3)) (property (v8 <-- m12))\ )))) I wonder if ((p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property (v4 <-- m19)))))) holds within the BS defined by context default-defaultct Since ((m2! (forall v4 v3 v2 v1) (ant (p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property v3))) (wrt2 (p2 (object v2) (property v4)\ )))) (cq (p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))))) and ((p3 (arg1 (v1 <-- b2)) (arg2 (v2 <-- b3)) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object (v1 <-- b2)) (property (v3 <-- m12)))) (wrt2 (p2 (object (v2 <-- b3)) (property (v4 <-- m19)))))) I infer ((p7 (forall v5) (ant (p4 (object v5) (property (v3 <-- m12)))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property (v4 <-- m19)))))))) I know ((m37! (arg1 (b2)) (arg2 (b3)) (rel (m1 (lex (unlike)))) (wrt1 (m13! (object (b2)) (property (m12 (lex (taciturn)))))) (wrt2 (m20! (object (b3)) (property (m19 (lex (talkative)))))))) (m41! (min 0) (max 0) (arg (m40 (object b2) (property (m19 (lex talkative))))\ )) (p76! (ant (p74 (object v10) (property (m19)))) (cq (p64 (min 0) (max 0) (arg (p63 (object v10) (property (m12 (lex taciturn)))\ ))))) (p75! (ant (p59 (object v5) (property (m12)))) (cq (p73 (min 0) (max 0) (arg (p72 (object v5) (property (m19))))))) (m39! (forall v10) (ant (p74)) (cq (p64))) (m38! (forall v5) (ant (p59)) (cq (p73))) (m37! (arg1 b2) (arg2 b3) (rel (m1 (lex unlike))) (wrt1 (m13! (object b2) (property (m12)))) (wrt2 (m20! (object b3) (property (m19))))) (m31! (min 0) (max 0) (arg (m30 (object b3) (property (m12))))) (m21! (class (m14 (lex personality))) (member (m19))) (m15! (class (m14)) (member (m12))) (m41! p76! p75! m39! m38! m37! m31! m21! m15!) CPU time : 0.27 * ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;; ;;;He talked little and seemed all the ;;;more mysterious for his taciturn manner. ;;;An object exists with the name Joe. (describe (add object #Joe proper-name (build lex "Joe"))); --- pause --- (m43! (object b4) (proper-name (m42 (lex Joe)))) (m43!) CPU time : 0.01 * ;;;Joe talks little. (describe (add object *Joe act (build action (build lex "talk") frequency (build lex "little")))); --- pause --- (m47! (act (m46 (action (m44 (lex talk))) (frequency (m45 (lex little))))) (object b4)) (m47!) CPU time : 0.01 * ;;;Joe has a manner. (describe (add object *Joe possessor (build lex "manner"))); --- pause --- (m49! (object b4) (possessor (m48 (lex manner)))) (m49!) CPU time : 0.02 * ;;;Joe's manner is taciturn. (describe (add object (find lex "manner") property (build lex "taciturn"))); --- pause --- Since ((p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))) and ((p4 (object (v5 <-- m48)) (property (v3 <-- m12)))) I infer ((p6 (min 0) (max 0) (arg (p5 (object (v5 <-- m48)) (property (v4 <-- m19))))\ )) Since ((p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))) and ((p4 (object (v5 <-- m48)) (property (v3 <-- m12)))) I infer ((p6 (min 0) (max 0) (arg (p5 (object (v5 <-- m48)) (property (v4 <-- m22))))\ )) Since ((p7 (forall v5) (ant (p4 (object v5) (property v3))) (cq (p6 (min 0) (max 0) (arg (p5 (object v5) (property v4))))))) and ((p4 (object (v5 <-- m48)) (property (v3 <-- m12)))) I infer ((p6 (min 0) (max 0) (arg (p5 (object (v5 <-- m48)) (property (v4 <-- m16))))\ )) Since ((p75! (ant (p59 (object v5) (property (m12 (lex (taciturn)))))) (cq (p73 (min 0) (max 0) (arg (p72 (object v5) (property (m19 (lex (talkative)))))))))) and ((p59 (object (v5 <-- m48)) (property (m12 (lex (taciturn)))))) I infer ((p73 (min 0) (max 0) (arg (p72 (object (v5 <-- m48)) (property (m19 (lex (talkative)))))))) Since ((m38! (forall v5) (ant (p59 (object v5) (property (m12 (lex (taciturn)))))) (cq (p73 (min 0) (max 0) (arg (p72 (object v5) (property (m19 (lex (talkative)))))))))) and ((p59 (object (v5 <-- m48)) (property (m12 (lex (taciturn)))))) I infer ((p73 (min 0) (max 0) (arg (p72 (object (v5 <-- m48)) (property (m19 (lex (talkative)))))))) Since ((p70! (ant (p59 (object v5) (property (m12 (lex (taciturn)))))) (cq (p68 (min 0) (max 0) (arg (p67 (object v5) (property (m22 (lex (outgoing)))))))))) and ((p59 (object (v5 <-- m48)) (property (m12 (lex (taciturn)))))) I infer ((p68 (min 0) (max 0) (arg (p67 (object (v5 <-- m48)) (property (m22 (lex (outgoing)))))))) Since ((m33! (forall v5) (ant (p59 (object v5) (property (m12 (lex (taciturn)))))) (cq (p68 (min 0) (max 0) (arg (p67 (object v5) (property (m22 (lex (outgoing)))))))))) and ((p59 (object (v5 <-- m48)) (property (m12 (lex (taciturn)))))) I infer ((p68 (min 0) (max 0) (arg (p67 (object (v5 <-- m48)) (property (m22 (lex (outgoing)))))))) Since ((p65! (ant (p59 (object v5) (property (m12 (lex (taciturn)))))) (cq (p61 (min 0) (max 0) (arg (p60 (object v5) (property (m16 (lex (noisy)))))\ ))))) and ((p59 (object (v5 <-- m48)) (property (m12 (lex (taciturn)))))) I infer ((p61 (min 0) (max 0) (arg (p60 (object (v5 <-- m48)) (property (m16 (lex (noisy)))))))) Since ((m26! (forall v5) (ant (p59 (object v5) (property (m12 (lex (taciturn)))))) (cq (p61 (min 0) (max 0) (arg (p60 (object v5) (property (m16 (lex (noisy)))))\ ))))) and ((p59 (object (v5 <-- m48)) (property (m12 (lex (taciturn)))))) I infer ((p61 (min 0) (max 0) (arg (p60 (object (v5 <-- m48)) (property (m16 (lex (noisy)))))))) Since ((m26! (forall v5) (ant (p59 (object v5) (property (m12 (lex (taciturn)))))) (cq (p61 (min 0) (max 0) (arg (p60 (object v5) (property (m16 (lex (noisy)))))\ ))))) and ((p59 (object (v5 <-- m48)) (property (m12 (lex (taciturn)))))) I infer ((p61 (min 0) (max 0) (arg (p60 (object (v5 <-- m48)) (property (m16 (lex (noisy)))))))) Since ((p65! (ant (p59 (object v5) (property (m12 (lex (taciturn)))))) (cq (p61 (min 0) (max 0) (arg (p60 (object v5) (property (m16 (lex (noisy)))))\ ))))) and ((p59 (object (v5 <-- m48)) (property (m12 (lex (taciturn)))))) I infer ((p61 (min 0) (max 0) (arg (p60 (object (v5 <-- m48)) (property (m16 (lex (noisy)))))))) Since ((m33! (forall v5) (ant (p59 (object v5) (property (m12 (lex (taciturn)))))) (cq (p68 (min 0) (max 0) (arg (p67 (object v5) (property (m22 (lex (outgoing)))))))))) and ((p59 (object (v5 <-- m48)) (property (m12 (lex (taciturn)))))) I infer ((p68 (min 0) (max 0) (arg (p67 (object (v5 <-- m48)) (property (m22 (lex (outgoing)))))))) Since ((p70! (ant (p59 (object v5) (property (m12 (lex (taciturn)))))) (cq (p68 (min 0) (max 0) (arg (p67 (object v5) (property (m22 (lex (outgoing)))))))))) and ((p59 (object (v5 <-- m48)) (property (m12 (lex (taciturn)))))) I infer ((p68 (min 0) (max 0) (arg (p67 (object (v5 <-- m48)) (property (m22 (lex (outgoing)))))))) Since ((m38! (forall v5) (ant (p59 (object v5) (property (m12 (lex (taciturn)))))) (cq (p73 (min 0) (max 0) (arg (p72 (object v5) (property (m19 (lex (talkative)))))))))) and ((p59 (object (v5 <-- m48)) (property (m12 (lex (taciturn)))))) I infer ((p73 (min 0) (max 0) (arg (p72 (object (v5 <-- m48)) (property (m19 (lex (talkative)))))))) Since ((p75! (ant (p59 (object v5) (property (m12 (lex (taciturn)))))) (cq (p73 (min 0) (max 0) (arg (p72 (object v5) (property (m19 (lex (talkative)))))))))) and ((p59 (object (v5 <-- m48)) (property (m12 (lex (taciturn)))))) I infer ((p73 (min 0) (max 0) (arg (p72 (object (v5 <-- m48)) (property (m19 (lex (talkative)))))))) (m56! (min 0) (max 0) (arg (m55 (object (m48 (lex manner))) (property (m16 (lex noisy)))))) (m54! (min 0) (max 0) (arg (m53 (object (m48)) (property (m22 (lex outgoing))\ )))) (m52! (min 0) (max 0) (arg (m51 (object (m48)) (property (m19 (lex talkative)\ ))))) (m50! (object (m48)) (property (m12 (lex taciturn)))) (m56! m54! m52! m50!) CPU time : 0.12 * ;;;Joe seems more mysterious. (describe (add object *Joe rel (build lex "seem") property (build mod (build lex "more") head (build lex "mysterious")))); --- pause --- I wonder if ((p3 (arg1 v1) (arg2 v2) (rel (m1 (lex (unlike)))) (wrt1 (p1 (object v1) (property (v3 <-- m60)))) (wrt2 (p2 (object v2) (property v4))))) holds within the BS defined by context default-defaultct I wonder if ((p10 (arg1 v6) (arg2 v7) (rel (m1 (lex (unlike)))) (wrt1 (p8 (object v6) (property v8))) (wrt2 (p9 (object v7) (property (v9 <-- m60)))))) holds within the BS defined by context default-defaultct (m62! (object b4) (property (m60 (head (m59 (lex mysterious))) (mod (m58 (lex more)))))) (m61! (object b4) (property (m60)) (rel (m57 (lex seem)))) (m62! m61!) CPU time : 0.15 * ;;;One cause of Joe seeming more mysterious is that his manner is taciturn. (describe (add cause (build object (build lex "manner") property (build lex "taciturn")) effect (build object *Joe rel (build lex "seem") property (build mod (build lex "more") head (build lex "mysterious"))))\ ); --- pause --- (m63! (cause (m50! (object (m48 (lex manner))) (property (m12 (lex taciturn))\ ))) (effect (m61! (object b4) (property (m60 (head (m59 (lex mysterious))) (mod (m58 (lex more))))) (rel (m57 (lex seem)))))) (m63!) CPU time : 0.02 * ;;;A second cause of Joe seeming more mysterious is that he talks little. (describe (add cause (build object *Joe act (build action (build lex "talk") frequency (build lex "little"))) effect (build object *Joe rel (build lex "seem") property (build mod (build lex "more") head (build lex "mysterious"))))\ ); --- pause --- (m64! (cause (m47! (act (m46 (action (m44 (lex talk))) (frequency (m45 (lex little))))) (object b4))) (effect (m61! (object b4) (property (m60 (head (m59 (lex mysterious))) (mod (m58 (lex more))))) (rel (m57 (lex seem)))))) (m64!) CPU time : 0.02 * ;;;Two assertions that are the cause a common effect may be equivalent (describe (add forall ($x $r $s) &ant (build cause *r effect *x) &ant (build cause *s effect *x) cq (build arg *r arg *s rel (build lex "possibly_equiv")))); --- pause --- I wonder if ((p86 (cause v21) (effect v19))) holds within the BS defined by context default-defaultct I wonder if ((p85 (cause v20) (effect v19))) holds within the BS defined by context default-defaultct I know ((m63! (cause (m50! (object (m48 (lex (manner)))) (property (m12 (lex (taciturn)))\ ))) (effect (m61! (object (b4)) (property (m60 (head (m59 (lex (mysterious)))) (mod (m58 (lex (more)))))) (rel (m57 (lex (seem)))))))) I know ((m64! (cause (m47! (act (m46 (action (m44 (lex (talk)))) (frequency (m45 (lex (little))\ )))) (object (b4)))) (effect (m61! (object (b4)) (property (m60 (head (m59 (lex (mysterious)))) (mod (m58 (lex (more)))))) (rel (m57 (lex (seem)))))))) Since ((m66! (forall (v21 <-- m50!) (v20 <-- m47!) (v19 <-- m61!)) (&ant (p86 (cause (v21 <-- m50!)) (effect (v19 <-- m61!))) (p85 (cause (v20 <-- m47!)) (effect (v19 <-- m61!)))) (cq (p87 (arg (v21 <-- m50!) (v20 <-- m47!)) (rel (m65 (lex (possibly_equiv)))\ ))))) and ((p86 (cause (v21 <-- m50!)) (effect (v19 <-- m61!)))) and ((p85 (cause (v20 <-- m47!)) (effect (v19 <-- m61!)))) I infer ((p87 (arg (v21 <-- m50!) (v20 <-- m47!)) (rel (m65 (lex (possibly_equiv)))))\ ) Since ((m66! (forall (v21 <-- m47!) (v20 <-- m50!) (v19 <-- m61!)) (&ant (p86 (cause (v21 <-- m47!)) (effect (v19 <-- m61!))) (p85 (cause (v20 <-- m50!)) (effect (v19 <-- m61!)))) (cq (p87 (arg (v21 <-- m47!) (v20 <-- m50!)) (rel (m65 (lex (possibly_equiv)))\ ))))) and ((p86 (cause (v21 <-- m47!)) (effect (v19 <-- m61!)))) and ((p85 (cause (v20 <-- m50!)) (effect (v19 <-- m61!)))) I infer ((p87 (arg (v21 <-- m47!) (v20 <-- m50!)) (rel (m65 (lex (possibly_equiv)))))\ ) I know ((p88! (arg (m66! (forall v21 v20 v19) (&ant (p86 (cause v21) (effect v19)) (p85 (cause v20) (effect v19))) (cq (p87 (arg v21 v20) (rel (m65 (lex (possibly_equiv))))))) v20) (rel (m65 (lex (possibly_equiv)))))) I know ((p89! (arg (m66! (forall v21 v20 v19) (&ant (p86 (cause v21) (effect v19)) (p85 (cause v20) (effect v19))) (cq (p87! (arg v21 v20) (rel (m65 (lex (possibly_equiv))))))) v21) (rel (m65 (lex (possibly_equiv)))))) I wonder if ((p86 (cause (v21 <-- p85)) (effect v19))) holds within the BS defined by context default-defaultct I wonder if ((p85 (cause (v20 <-- p86)) (effect v19))) holds within the BS defined by context default-defaultct I know ((p89! (arg (m66! (forall v21 v20 v19) (&ant (p86 (cause v21) (effect v19)) (p85 (cause v20) (effect v19))) (cq (p87! (arg v21 v20) (rel (m65 (lex (possibly_equiv))))))) v21) (rel (m65 (lex (possibly_equiv)))))) I know ((p87! (arg v21 v20) (rel (m65 (lex (possibly_equiv)))))) I know ((p88! (arg (m66! (forall v21 v20 v19) (&ant (p86 (cause v21) (effect v19)) (p85 (cause v20) (effect v19))) (cq (p87! (arg v21 v20) (rel (m65 (lex (possibly_equiv))))))) v20) (rel (m65 (lex (possibly_equiv)))))) (m68! (arg (m50! (object (m48 (lex manner))) (property (m12 (lex taciturn)))) (m47! (act (m46 (action (m44 (lex talk))) (frequency (m45 (lex little))))) (object b4))) (rel (m65 (lex possibly_equiv)))) (m67! (arg (m66! (forall v21 v20 v19) (&ant (p86 (cause v21) (effect v19)) (p85 (cause v20) (effect v19))) (cq (p87! (arg v21 v20) (rel (m65)))))) (rel (m65))) (p89! (arg (m66!) v21) (rel (m65))) (p88! (arg (m66!) v20) (rel (m65))) (m64! (cause (m47!)) (effect (m61! (object b4) (property (m60 (head (m59 (lex mysterious))) (mod (m58 (lex more))))) (rel (m57 (lex seem)))))) (m63! (cause (m50!)) (effect (m61!))) (m68! m67! p89! p88! m66! p87! v21 v20 m64! m63! m50! m47!) CPU time : 0.28 * ;;;Use the algorithm to describe the "unknown" adjective "taciturn". ^( --- pause --- --> define_adjective "taciturn"); --- pause --- #S(adj_info :adjective "taciturn" :unlike_props (outgoing talkative noisy) :class (personality) :type_nouns (People) :possible_equiv (m50! m\ 47!)) CPU time : 0.02 * End of /home/visitor/alammert/algorithm/master.demo demonstration. CPU time : 2.18