full_report_ms.doc
>u
D¹tÖƒ¹tÖƒ
•• ƒ
Adjectives through Contextual Vocabulary Acquisition
Adam C. Lammert
8 August 2002
CVA in assoc. with SNeRG
TEXTMSWD
Defining
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
ÒdefinitiontestÓ 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 ÒclassmemberÓ 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
ÒsubclasssuperclassÓ 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.
Containing unlike.Ó
2001.
ÒVocabulary Acquisition from the Context
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
(1935). 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 (79109),
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/bletexts/jverne/bljver-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
(cq (p6 (min 0) (max 0)
and
((p4 (object (v5 <-- b2))
I infer
((p6 (min 0) (max 0) (arg
m16)))))\
)
Since
((p14 (forall v10)
(cq (p13 (min 0)
and
((p11 (object (v10
I infer
((p13 (min 0) (max
m12))\
))))
(object v5) (property v3)))
(arg (p5 (object v5) (property v4)))))))
(property (v3 <-- m12))))
(p5 (object (v5 <-- b2)) (property (v4 <--
(ant (p11 (object v10) (property v9)))
(max 0) (arg (p12 (object v10) (property v8)))))))
<-- b3)) (property (v9 <-- m16))))
0) (arg (p12 (object (v10 <-- b3)) (property (v8 <--
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
(cq (p6 (min 0) (max 0)
and
((p4 (object (v5 <-- b2))
I infer
((p6 (min 0) (max 0) (arg
m22)))))\
)
(object v5) (property v3)))
(arg (p5 (object v5) (property v4)))))))
(property (v3 <-- m12))))
(p5 (object (v5 <-- b2)) (property (v4 <--
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)
(cq (p13 (min 0)
and
((p11 (object (v10
I infer
((p13 (min 0) (max
m12))\
))))
Since
((p14 (forall v10)
(cq (p13 (min 0)
and
((p11 (object (v10
I infer
((p13 (min 0) (max
m12))\
))))
(ant (p11 (object v10) (property v9)))
(max 0) (arg (p12 (object v10) (property v8)))))))
<-- b3)) (property (v9 <-- m22))))
0) (arg (p12 (object (v10 <-- b3)) (property (v8 <--
(ant (p11 (object v10) (property v9)))
(max 0) (arg (p12 (object v10) (property v8)))))))
<-- b3)) (property (v9 <-- m22))))
0) (arg (p12 (object (v10 <-- b3)) (property (v8 <--
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
(cq (p6 (min 0) (max 0)
and
((p4 (object (v5 <-- b2))
I infer
((p6 (min 0) (max 0) (arg
m19)))))\
)
Since
((p7 (forall v5) (ant (p4
(cq (p6 (min 0) (max 0)
and
((p4 (object (v5 <-- b2))
I infer
((p6 (min 0) (max 0) (arg
m22)))))\
)
Since
((p14 (forall v10)
(cq (p13 (min 0)
and
((p11 (object (v10
I infer
((p13 (min 0) (max
m12))\
))))
Since
((p14 (forall v10)
(cq (p13 (min 0)
and
((p11 (object (v10
I infer
((p13 (min 0) (max
m12))\
))))
(object v5) (property v3)))
(arg (p5 (object v5) (property v4)))))))
(property (v3 <-- m12))))
(p5 (object (v5 <-- b2)) (property (v4 <--
(object v5) (property v3)))
(arg (p5 (object v5) (property v4)))))))
(property (v3 <-- m12))))
(p5 (object (v5 <-- b2)) (property (v4 <--
(ant (p11 (object v10) (property v9)))
(max 0) (arg (p12 (object v10) (property v8)))))))
<-- b3)) (property (v9 <-- m19))))
0) (arg (p12 (object (v10 <-- b3)) (property (v8 <--
(ant (p11 (object v10) (property v9)))
(max 0) (arg (p12 (object v10) (property v8)))))))
<-- b3)) (property (v9 <-- m19))))
0) (arg (p12 (object (v10 <-- b3)) (property (v8 <--
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
1
1
2
Susan Lammert
¿ãÿÿ
¼hL
2
¼jt Ú
2
STR