• There are other types of ambiguity:

  referential ambiguity:	Jon is angry with Jim. He bites him.
  structural ambiguity:	Happy cats and dogs live on the farm.	syntactic structure
  	Every man loves a woman.	semantic structure
  there can be mixes:	The major exhibits age.

• Co-occurrence constraints on meaning: sometimes ambiguity can be resolved by the company the word keeps, or the syntax of the sentence: Jack ran in the park vs Jack ran in the election.

The Basic Logical Form Language

This section defines a formal language of logical forms, resembling FOPC (first order predicate calculus):

terms

constants or expressions that describe objects: fido1, jack1

The main purpose of the lower case, and the number "1", in fido1, jack1, and bites1, is to distinguish between the words "Fido", "Jack", and "bites" and the semantic symbols fido1, jack1, and bites1. If we needed to distinguish between different word senses, as we might with the word "dog", we would use dog1, dog2, dog3, etc.

predicates

constants or expressions that describe relations or properties: bites1.

Each predicate has an associated number of arguments - bites1 is binary (unary = 1 argument; ternary = 3 arguments; n-ary = n arguments).

Logical Form Language 2

propositions

a predicate followed by the appropriate number of arguments:

bites1(fido1, jack1) - Fido bites Jack
dog1(fido1) - Fido is a dog.

More complex propositions can be constructed using logical operators:

not(loves1(sue1, jack1))
(& bites1(fido1, jack1), dog1(fido1))

Note that and does not always "translate" as logical & - e.g. it may suggest temporal sequence: I went home and had a drink compared to I had a drink and went home.

Logical Form Language Part 3

quantifiers

In FOPC, only forall and exists.
English has vaguer quantifiers, too: most, many, a few, a, the, ...

Variables are introduced here, as in FOPC.

However variables in logical form language persist beyond the "scope" of the quantifier.

A man came in. He went to the table.

The first sentence introduces a new object of type man1. The He in the second sentence refers to this object.

Quantifiers continued

 

NL quantifiers are typically restricted in the range of objects that the variable ranges over. In Most dogs bark the variable in the most1 quantifier is restricted to dog1 objects:
(most1 D1 : (dog1 D1) (barks1 D1))

Note that D1 is a variable.

the and a give rise to important NL quantifiers - the dog barks has logical form

the(X, dog1(X), barks1(X))

The schema for this is: the(X, Restriction on X, Proposition about X)

which would be true only if we can determine a unique dog in context, and that dog barks. How we find the unique dog is discussed in the section on Reference.

Logical Form Language Part 4

predicate operator

We also need a way to handle plurals as in the dogs bark.

A new type of thing called a predicate operatoris introduced that takes a predicate as an argument and produces a new predicate.

For plurals, plur: if dog1 is true of any dog, then the predicate plur(dog1) is true of any set of dogs with more than one member:

the(X, plur(dog1)(X), barks1(X)).

Logical Form Language Part 5

modal operator

used for verbs like believe, know, want, for tense, and other purposes. Sue believes Jack is happy becomes

believe1(sue1, happy(jack1)).

Modal operators may exhibit failure of substitutivity:

jack1 may = john22 (i.e. the individual known as Jack may also be called John, e.g. by other people)

However, Sue believes John is happy may not be true, e.g. because Sue may not know that jack1 = john22.

Logical Form Language Part 6

Tense operators: use modals pres, past, fut:

pres(sees1(john1, fido1)) - John sees Fido
past(sees1(john1, fido1)) - John saw Fido
fut(sees1(john1, fido1)) - John will see Fido

Again, substitutivity may fail.

john1 may = minister1, and past(owns1(john1, fido1)) may be true, but past(owns1(minister1, fido1)) can still be false because John was not minister when he owned Fido.

Converting Logical Forms between Allen's notation and our Prolog-type Notation

• If you use the book by James Allen to clarify the material in these lecture notes, you will need to figure out how to translate between his LISP-style notation and our Prolog-style notation.

• To convert a Lisp list to a Prolog term:

• Example:
  (OWNS1 o1 (NAME m1 "Mary") (THE p1 PIZZA1))
  

  1. take the first item in the list and place it outside (before) the leading parenthesis, and separate the rest of the items with commas.

     ⇒ OWNS1(o1, (NAME m1 'Mary'), (THE p1 PIZZA))
     

Converting LISP-style Logical Forms to Prolog 2

2. If there are any lists among the items, recursively convert them to terms, as above.

   ⇒ OWNS1(o1, NAME(m1, 'Mary'), THE(p1, PIZZA))
   

3. Look at the role played by the items in the Lisp-style list.
   • If they are constants, change them so that they begin with lower case letters (it may make more sense to down-case the whole word).
   • If they are variables, change them so that they begin with upper case letters.

   ⇒ owns1(O1, name(M1, 'Mary'), the(P1, pizza))
   

Encoding Ambiguity in the Logical Form

• Because ambiguity often cannot be resolved at the logical form level, it must be possible to represent ambiguities in the logical form language.

• Sue watched the ball becomes

  the(B1, (or(ball_dance(B1), ball_sphere(B1))), past(watch1(sue1, B1)))

Encoding Ambiguity in the Logical Form 2

• Every child loves a pet becomes

  loves1(every<C1, child1> <a(P1, pet1(P1)>))

• The quantifiers look like terms. This represents the two possibilities:

  every(C1, child1(C1), a(P1, pet1(P1), loves1(C1, P1)))
  ... For every child there is a pet, and the child loves their pet.
  a(P1, pet1(P1), every(C1, child1(C1), loves1(C1, P1)))
  ... There is a single pet in the world, and every child loves that pet.

Abbreviation: every<C1, child1>= every(C1, child1(C1))

Encoding Ambiguity in the Logical Form 3

• Every child didn't run becomes

  not(run1)(every<C1, child1>), encompassing

  not(every(C1, child1(C1), run1(C1))) and
  every(C1, child1(C1), not(run1(C1))).

Term Constructors: Proper Names

• Proper names need to be interpreted in context - John could refer to many different Johns.

• This is handled in logical forms via

  name(Variable, the_name): for example John ran becomes

  past(run1)(name(J1, "John")).

Term Constructors: Pronouns

• Similarly for pronouns and related phenomena like here and yesterday, we use

  pro(Variable, some_proposition_restricting_the_pronoun).

  Mary liked him becomes

  past(like1)(name(M1, 'Mary'), pro(M2, male1(M2)))

  Here male1 is the sense restricting proposition for the pronouns he and him.

Verbs and States in Logical Form

1. John broke it
   
2. John broke it with the hammer

• This seems to say that there are two predicates for broke, one binary and one ternary. Messy.

• A suitable solution is to convert the "breaking" into an event and assert suitable properties of that event.

  1.	exists(E1,	break(E1, name(J1, "John"), pro(I1, neuter1))
  2.	exists(E1,	&(break(E1, name(J1, "John"), pro(I1, neuter1)),
  		instr(E1, the<H1, hammer1>)))

Verbs and States in Logical Form 2

• Extra modifiers can be added as needed, e.g. for in the hallway

• Part of the intuition here is that a breaking has three fundamental roles associated with it - an agent, a theme or victim or object, and an instrument.

Verbs and States in Logical Form 3

• It is common to label the objects in the logical form with these roles or cases:

  2'.	exists(E1,	&(break1(E1),
  		agent(E1, name(J1, 'John')),
  		theme(E1, pro(I1, neuter1)),
  		instr(E1, the<H1, hammer1>)))

Verbs and States in Logical Form 4

• Because the pattern in 1 and 2 above is common, it is usual to abbreviate, by leaving out the "exists(E1 :" and the "&(" and write 2', for example, as

  2''.	break1(E1,	agent[name(J1, 'John')],
  		theme[pro(I1, neuter1)],
  		instr[the(<H1, hammer1>)])

  Strictly the break1 should be past(break1).

Verbs and States in Logical Form 5

• Similarly, Mary was unhappy could initially be

  past(unhappy1)(name(M1, 'Mary'))

  but how do we handle modifiers like in the meeting?

• Answer: Introduce states S and use

  past(unhappy1)(S,	experiencer[name(M1, 'Mary')],
  	at-loc[the<M2, meeting1>])

• Allen tends to switch between various notations as convenient. In particular, the angle brackets < > vs round parentheses ( ) seem to be a bit random.

Thematic Roles

• These include agent, theme, instr, experiencer, and at-loc, already met, and

  roles related to at-loc: on-loc, in-loc, under-loc)
  from-loc (e.g. from here)
  to-loc (to the ground)
  path (along the gorge).

• In the domain of ownership, there are

  to-poss (gave a book to John)
  from-poss
  at-poss(John owns a book).

Thematic Roles 2

• In the domain of time, there are

  at-time
  from-time
  to-time.

• In the domain of values, there are

  at-value
  from-value
  to-value(The temperature reached 43 degrees).

Thematic Roles 3

• There are also

  experiencer, already met, for when the subject is not acting (John believed it was raining)
  beneficiary (Mary bought a present for her mother)
  co-agent (Mary lifted the table with her sister)

Preposition and Thematic Roles

• Prepositions cue thematics roles: e.g. with can indicate either instr(ument) or co-agent.
  Grey section below is non-examinable

• When these are mixed, as in ? She ate the ice-cream with a large spoon and her best friend we have a linguistic phenomenon called zeugma.

• The thematic roles listed above are not the lowest level of meaning: there can, for example, be different sub-types of beneficiary:

  [Father is pushing heavy trolley along back of supermarket ...]
  Mother: You go and get the ice-cream cones for Daddy.
  3-year-old: No! They're for meeeee!

  The mother means that "Daddy" will benefit by not having to push the trolley down the isle to the ice-cream cones; the child is thinking about the ultimate benefit of getting to eat the (filled) ice-cream cones.

Speech Acts and Embedded Sentences

• Each major sentence type - assertion, yes/no-question, wh-question, command - corresponds to a surface speech act.

• We extend the logical form language by wrapping the surface speech act operator around the rest of the logical form: e.g. for the man ate a peach:

  assert(past(eat1)(E1,	agent[the<M1, man1>],
  	theme[a<P1, peach1>]))

Speech Acts and Embedded Sentences 2

• Similarly for Did the man eat a peach?

  (yn_query(past(eat1)(E1,	agent[the<M1, man1>],
  	theme[a<P1, peach1>]))

• and Eat the peach:

  command(eat1(E1

  theme[the<P1, peach1>]))

Wh-Questions and Beyond

• Wh-questions are more complicated, and require a new generalized quantifier WH, with variants for

  who	wh(P1, person1)
  what	wh(P1, anything1)
  which dog	wh(P1, dog1)

  and extra quantifiers how_many and how_much

Wh-Questions and Beyond 2

• E.g. What did the man eat?

  wh_query(past(eat1)(E1,	agent[the<M1, man1>]
  	theme[wh(W1, physobj)]))

• Finally for embedded sentences like relative clauses:

  e.g. The man who ate a peach left.

  assert(
  	past(leave1)(L1,
  	agent[the<M1, (&	man1(M1),
  		past(eat1)(E2,
  		agent[M1],
  		theme[a<P1, peach1>]))]))

Summary: Semantics and Logical Form

We have described a logical form language that includes terms, predicates, propositions, logical operators, quantifiers (including special NL quantifiers such as THE), and shown how this language can be used to represent ambiguous sentences.

CRICOS Provider Code No. 00098G

Copyright (C) Bill Wilson, 2009, except where another source is acknowledged.