On Feb 10, 2009, at 7:59 PM, Rich Cooper wrote:
Then how should I represent, for relational DB update purposes, the sentence
“Mary was given (or received) a book earlier.
Well, first, to put temporal information into an RDB you ought to be following the conventions of temporal RDBs, and distinguishing valid time from transaction time. "Earlier" confuses these, since "now" is a transaction time, but the information is temporally located using a valid time. So lets assume that this RDB entry was being made at time T, and that 'earlier' means at some time T' < T. The RDB needs to have a value of some kind for T'; it can't just encode it as "earlier than T".
which I encoded in a way you are not happy with as:
Earlier( Give(nil, Mary, book) )
Which doesn't look like RDB to me. What does the nesting here mean in RDB terms?
I want to refer to that specific act of giving “Give (nil, Mary, book)” not to some other act of giving which may also be in the RDB.
Right, so you need to actually introduce that specific act as an object. Or, have the time T' as yet another "argument", which in RDB terms is another column in the giving-event table. Both ways work.
I also want to state that the action happened when time was “earlier” than when the act happened. The act happened just Now.
Then you need a valid-time value corresponding to Now. "Now" itself isn't a time, its a temporal indexical. Its meaning changes every time the clock ticks.
I also want to state the same without giving any more specificity to the actual time at which the action happened
Then you can't use an RDB, unless it has some clever temporal machinery built into it. As stated, this needs an existential quantifier applied to the times. In RDF you could use a blank node.
, or more detail to what the action was.
So (TheTime, (Give(nil, Mary, book) ), < Now) is sorta what I’m after. Can you make it look more like standard FOL without otherwise damaging the NLP meanings?
In FOL its easy:
(exists (x)(Giving(x) & Recipient(x, Mary) & Object(x, book) & (exists (T')(Time(T') & When(x, T') & Earlier(T', T) ) )
where T is the "Now" time.
But please keep it still compatible with RDB representations of natural language sentences.
Im not aware that many NL sentences can be represented in RDBs, or that there are any accepted conventions for doing so.
Rich AT EnglishLogicKernel DOT com On Feb 10, 2009, at 2:25 PM, Rich Cooper wrote: ---------------------------- ---------------------------- ---------------------------- Long before Strawson, linguists had observed a distinction between
obligatory and optional (AKA inner and outer) participants in the
action or state expressed by a verb. For 'give', the number of
inner or obligatory participants is 3, and there is an open-ended
number of optional relationships for the time, place, manner, etc.
True, but this distinction is purely grammatical. I have to say "XX gave YY to ZZ", with all three grammatically required phrases in place (and Im not obliged similarly to say where or when or how), but Im not obliged to actually provide the information. I can say 'someone' or 'something' as a filler which satisfies the grammatical constraint without actually providing information, when the information is missing. Or I can use the passive voice and say "Mary was given a book" without saying "by XX". When sentences like these are converted to logic, the missing arguments are still missing. Its notable than if one pushes this exercise to the limit, you find the English words naming the case roles. To describe this event without mentioning John or the book, we have to say "Mary received a gift" ----------------- ------------------------ ---------------------------- ------------------------- This multi-signatured form of the statement still works with a 3-ary relation: Mary was given a book” Give( nil, Mary, book ) ^ Earlier( Give(nil, Mary, book) ) This isn't legal logical syntax, for several reasons. First, what does 'nil' mean? In logic, this has to be a name, and hence a name of something. If 'nil' means here what it means in LISP, then this says that the empty list gave a book to Mary, which I doubt is what was intended. I presume you want to use 'nil' as a kind of blank pseudo-name which can be used to indicate that no real name is available, but this isn't a construct in any logic I've ever seen. The proper way to do this in logic is to use a quantifier: (exists (x)( Give(x, Mary, book) ... ) but this is getting closer to the case-role form. (BTW, I notice you have permuted the order of the three arguments, thereby illustrating one of the main problems with the n-ary argument form: keeping track of which argument is supposed to be which, when there are no syntactic labels to help you remember.) Second, more seriously, you can't make a sentence into an argument, as you do here with "GIve(nil, Mary, Book)". And even if you could, a sentence in logic denotes a truth-value (and asserting the sentence, as your first conjunct here does, asserts that this value is true.) This means that predicating a property of the sentence, as you do in the second conjunct, amounts to the assertion about the truth-value. So here you are saying that true has the property called "Earlier", which doesn't make sense. (We developed an extended logic, IKL, in which there are expressions of the form: (that (Give x Mary Book)) which contain embedded sentences, but they denote propositions, not events: it still doesn't make sense to say that a proposition is 'earlier'.) Third, "Earlier" isn't a property. Consider: logical assertions are timeless: they aren't made "at" a time, like assertions in a tensed language. So "Earlier" doesn't make sense (earlier than when?). To convey the "pastness" of a tensed assertion in a nonindexical logic, one has to de-indexicalize it by putting times in explicitly, and then "Earlier" is a relationship between the time of assertion (the "now") and the time of the event or being described. Someone gave mary a book Give( nil, Mary, book ) ^ Earlier( Give(nil, Mary, book) ) John gave Mary a book Give( John, Mary, book ) ^ Earlier( Give(John, Mary, book) ) When extra modifiers are present, the form is still 3-adic with extra predicates recording the event of giving: You miss the point. Those extra predicates have to be applied to something, and what they then say is that that thing has a certain property. If "Give" is a relation, then the form "Give(A, B, C)" has to be a sentence. And a sentence does not denote an event. In order to say the extra things, you must use a name of the event. Once you do this, the trinary form has to itself be related to the event somehow. The simple use of the same verb ("give") isnt enough to connect to a particular event. Logic isn't just a mathematical-looking notation. It comes with a clearly defined set of semantic conditions, which have to be respected. WIthout these, it isn't saying anything. One can't just write down some stuff and declare that it means what you want it to mean. The meanings have to be built up from the meanings of the syntactic parts in a uniform, principled way, in order for it all to work as a coherent logic. Herb gave Mary a book yesterday ^ Earlier( Give(Herb, Mary, book) ) ^ TimeOf( Give(Herb, Mary, book), Yesterday ) Pete gave Marsha a book in the library Give( Pete, Marsha, book) ^ Earlier( Give(Pete, Marsha, book) ) PlaceOf( Give(Pete, Marsha, book), Library) The point is that the 3-adic representations can be used for all the cases you’ve mentioned. You aren't using 3-adic relations here. Im not sure what all this means, formally, but it certainly isn't made up of 3-adic relations. Other information is related to the action of Give( x, y, z ) If this is an action, in what sense is Give a relation? And what does it mean to assert an action? to describe the conditions under which the act took place, and the condition of x, y and z at the time of the act. A more interesting question is how to be sure that the sentence translations to logic are 100% consistent with whatever logical form that was specified, even with the (estimated) forty seven everyday ways of modulating that fact in sentences. That is, how do we validate a knowledge base so that every meaning of each input phrase is properly represented in the database? Validation, to me, is more important than any national/international/industrial standardization effort. Standardization will proceed AFTER database representations of these functions become well understood, and well validated in practice. A standard without proper validation is simply a dream that won’t come true. Rich AT EnglishLogicKernel DOT com ------------------------------------------------------------ IHMC (850)434 8903 or (650)494 3973 40 South Alcaniz St. (850)202 4416 office Pensacola (850)202 4440 fax FL 32502 (850)291 0667 mobile
Message Archives: http://ontolog.cim3.net/forum/ontolog-forum/
Config Subscr: http://ontolog.cim3.net/mailman/listinfo/ontolog-forum/
Shared Files: http://ontolog.cim3.net/file/
Community Wiki: http://ontolog.cim3.net/wiki/
To join: http://ontolog.cim3.net/cgi-bin/wiki.pl?WikiHomePage#nid1J
To Post: mailto:ontolog-forum@xxxxxxxxxxxxxxxx
IHMC (850)434 8903 or (650)494 3973
40 South Alcaniz St. (850)202 4416 office
Pensacola (850)202 4440 fax
FL 32502 (850)291 0667 mobile