🚀 go-pugleaf

From following this discussion I am still not sure what the 
problem is, but here is my contribution to the confusion.

First, I think we agree that a sentence is not a string of 
words but a highly structured object (sign/complex AVM 
containing all kinds of information/c+f-
structure/d+s+...structure/etc. depending on your favourite 
linguistic model).  It is this structure that has an 
associated meaning (and an associated string), not the 
string.  (If the string has a meaning I see no problem in 
claiming that it has more than one).  The "mean" relation 
between string and meaning can then be taken to be a 
derived one

mean(String, Meaning) :- hsf(Struc, String), carries(Struc, 
Meaning).

where hsf(Struc, String) can be read "Struc has the surface 
form String".

Minimal assumptions on the sentence structure is that one 
can derive the string and the meaning from it:

hsf(a,b) & hsf(a,c) -> b=c
carries(a,b) & carries(a,c) -> b=c

If one then for a particular string, s, makes the call

hsf(Struc, s), carries(Struc, M1), carries(Struc, M2)

M1 and M2 have to return the same value.  The call that 
makes them return different values

mean(s,M1), mean(s,M2)

is equivalent to

hsf(Struc1, s), carries(Struc1, M1), hsf(Struc2, s), 
carries(Struc2, M2)

It means something different, and it is not the one we are 
after.


Someone might say that I am begging the question here.  
Isn't it the same type of problem with the call

hsf(Struc1,s), hsf(Struc2,s).

How can the same string have two associated structures?  
The easiest is to answer by an analogy.  Suppose Ann and 
Mary both has red hair.  This can be represented by

red_hair(mary).
red_hair(ann).

But an equally good representation seems to be

has_hair(mary, red_hair).
has_hair(ann, red_hair).

Everything works fine if we ask something like "Who has red 
hair?"   Then it is ok to get the answer "Ann and Mary".  
But we get problems if we saw someone with red hair and we 
ask who we saw.  Now, "Ann or Mary" is correct, but "Ann 
and Mary" is not.  This is not particular to "see" (no 
intentionality lurking around).  Given a portion of red 
hair we cannot use the prolog representation to answer who 
it belongs to (again both girls).  The point here is that 
in

has_hair(mary, red_hair).

red_hair does not refer to a specific object, the girls 
don't have the same hair, it refers to a certain property 
the girls share.

Similarly, I think the string of words we give to our DCG-
parser does not represent a particular object, but a 
property that several sentences share.  If the goal is from 
a string, s, to get the result "struc1 or struc2 or ... 
strucn" where these are all the structures such that 
hsf(struci, s), then this can be compared to the following 
task. From an instance of red-hair r and knowledge of who 
is red-haired to determine who this hair belongs to and get 
the answer "mary or ann or ..".  One way to obtain this is 
by the axiom

(i) instance_of(r, red_hair) -> Ey(has_hair(y, red_hair) & 
belongs_to(r, y))

(here E is the existential quantifier) and an axiom of the 
form

(ii) Ay(has_hair(y, red_hair) <-> y=ann or y=mary or .. or 
                                       y=bill)

The list of names must be conclusive.  From (i) and (ii), 
(iii) follows

(iii) instance_of(r, red_hair) -> 
             (belongs_to(r,ann) or .... belongs_to(r, bill))

I don't know whether simpler solutions are possible.  We can 
think of a similar axiomatization of  grammars.  But it is not 
obvious how one shall give a Prolog-implementation of the existence 
quantifier in (i), in particular not in combination with (ii).

Jan Tore Loenning
University of Oslo
jtl@ulrik.uio.no