Parts and Boundaries 4 - functions that map between values of B and I

Plural

• ∀x,y. plural(x,y) -> ~bounded(x) and complex(x) and bounded(y) and x=_$y
• ∀x. ~bounded(x) and complex(x) -> ∃y. plural(x,y)

Note that =_$ is an equivalence relation for conceptual parts of speech:

• ∀x,y. x=_$y <-> (matter(x) <-> matter(y) and event(x) <-> event(y) and place(x) <-> place(y) and event(x) <-> event(y))

e.g. (a) 'cattle/cows': plural(x,y), cow(y); (b) 'the light flashed (until dawn)': plural(e,f), lightflash(f).

Element

• ∀x,y. element(x,y) -> bounded(x) and ~complex(x) and ~bounded(y) and complex(y) and x=_$y

e.g. 'a grain of rice': element(x,y), rice(y). Note that 'element' is an extracting function - element(x,y) does not imply the existence of y, unlike its inverse plural(x,y).

This might also be used for substances (e.g. 'a drop of water'), but I think it'd be better to have another function that reanalyses substances as aggregates first.

Composition

• ∀x,y. composition(x,y) -> bounded(x) and ~complex(x) and ~bounded(y) and ~complex(y) and x=_$y

e.g. 'a coffee': composition(x,y), coffee(y); 'a house of wood': house(x), composition(x,y), wood(y). Further extensions are possible for 'a house of bricks', 'a pile of bricks/sand', 'a stack of bricks', 'a herd of cows'.

Grinder

• ∀x,y. grinder(x,y) -> ~bounded(x) and ~complex(x) and bounded(y) and ~complex(y)

e.g. 'beef': grinder(x,y), cow(y); 'Bill is writing a novel': grinder(x,y), write(y,bill,z), novel(z).

Parts and Boundaries 3 - the features b(ounded) and i(nternal structure)

It has frequently been noted (Bach 1986, Fiengo 1974, Gruber 1967, Talmy 1978, among others) that the distinction between count and mass nouns strongly parallels that between temporally bounded events and temporally unbounded processes.

This is to do with the property of being able to be divided up into subparts which are conceptually of the same type as the whole (e.g. 'an apple' vs. 'water'; 'the light flashed' vs. 'Bill slept').

Some entities are BOUNDED (meaning that the boundaries are in view or of concern) and some are not.

Some entities are COMPLEX (meaning that they have relevant internal membership) and some are not.

• ∀x. matter(x) xor event(x) xor place(x) xor path(x)
• ∀ x. individual(x) <-> matter(x) and bounded(x) & ~complex(x)
• ∀ x. substance(x) <-> matter(x) and ~bounded(x) & ~complex(x)
• ∀ x. aggregate(x) <-> matter(x) and ~bounded(x) & complex(x)
• ∀ x. group(x) <-> matter(x) and bounded(x) & complex(x)

Some examples: (a) 'a cow' denotes an individual; (b) 'cattle' denotes an aggregate; (c) 'beef' denotes a substance; and (d) 'a herd' denotes a group. Note that 'individual' is the only subtype of matter that has an inherent shape, hence physical boundaries.

Parts and Boundaries 2 - The puzzle and a preliminary solution

Consider the following sentence:

  The light flashed until dawn.

This sentence expresses repetition, despite the fact that neither of its component parts does - 'the light flashed' and 'until dawn'. Where does the sense of repetition come from, and why is it necessary here?

Here is a rough form of the explanation:

1. The sentence 'the light flashed' denotes a BOUNDED event.
2. The PP 'until dawn' combines with an UNBOUNDED event to form a BOUNDED event.
3. The lexico-syntactic conceptual structure of 'the light flashed until dawn' is thus INCONSISTENT with the ontology.
4. The inconsistent conceptual structure can be made consistent by COERCING the bounded event E denoted by 'the light flashed' into an UNBOUNDED event consisting of a plurality of events of the same type as E.

Here is the corresponding lexicon:

  the light flashed :- S1 : lightflash(1)
  until dawn :- S1\S2 : untildawn(1,2)

This lexicon is used to derive the following lexico-syntactic conceptual structure for the sentence 'the light flashed until dawn':

 untildawn(e,f), lightflash(f)

And here is the corresponding ontology:

               event
              /     \
            /         \
         bounded     plural
         /     \   
        /       \  
  lightflash  untildawn 

More formally:

• ∀x. lightflash(x) -> bounded(x)
• ∀x,y. untildawn(x,y) -> bounded(x) and ~bounded(y)
• ∀x,y. plural(x,y) -> ~bounded(x) and bounded(y)

It is clear that using the lexico-syntactic coceptual structure of 'the light flashed until dawn' and this ontology, we can derive the following contradiction:

  bounded(f) and ~bounded(f)

The interpretation is rescued by applying the following COERCION RULE to the interpretation of sentence 'the light flashed':

  Sx => Sy : plural(y,x)

This yields the following COERCED conceptual structure for the whole sentence, which is consistent with the ontology:

  untildawn(e,f)
  plural(f,g)
  lightflash(g)

This is not a million miles away from Jackendoff's own notation:

 [UNTIL([PLURAL([LIGHT FLASHED])],[DAWN])]

Note that there are two alternatives that do not require such post-derivational coercion:

1. Treat 'the light flashed' as lexico-syntactically ambiguous, i.e.
   1. S₁ : lightflash(1)
   2. S₁ : plural(1,2), lightflash(2)
2. Treat 'until dawn' as lexico-syntactically ambiguous, i.e.
   1. S₁/S₂ : untildawn(1,2)
   2. S₁/S₂ : untildawn(1,3), plural(3,2)

In both these cases, the lexico-syntactic conceptual structure will be consistent with the ontology.

Parts and Boundaries 1 - the technology of conceptual semantics

The following two sentences are synonymous:

  Bill went into the house.
  Bill entered the house.

This means that they encode the same underlying conceptual structure:

  go(e,bill,t)
  to(t,i)
  in(i,h)
  house(h)

This is equivalent to Jackendoff's notation, where the referential indices are left implicit:

  [GO([BILL],[TO([IN([HOUSE])])])]

The mapping between sentences and concepts is ensured by the following CCG lexicon:

  went :- S1\NP2/PP3 : go(1,2,3)
  entered :- S1\NP2/NP3 : go(1,2,4), to(4,5), in(5,3)
  Bill :- NPbill
  into :- PP1/NP2 : to(1,3), in(3,2)
  the house :- NP1 : house(1)

The conceptual predicates are organised into an ontology:

           entity
         /   / \  \
       /    /   \   \
     /     /     \    \
 thing  place  path  event
   |      |      |     |
   |      |      |     |
 house    in    to     go

This is to be understood as follows:

• Every entity belongs to exactly one of the following four categories: thing, place, path or event.
• Every 'house' is also a 'thing'.
• Every 'in' is also a 'place'.
• Every 'to' is also a 'path'.
• Every 'go' is also an 'event'.

More formally:

• ∀x. thing(x) xor place(x) xor path(x) xor event(x)
• ∀x. house(x) -> thing(x)
• ∀x,y. in(x,y) -> place(x) and thing(y)
• ∀x,y. to(x,y) -> path(x) and place(y)
• ∀x,y,z. go(x,y,z) -> event(x) and thing(y) and path(z)

Note that we do NOT NEED to decompose lexical concepts like 'into' or 'enter':

• ∀x,y. into(x,y) -> ∃z. to(x,z) and in(z,y)
• ∀x,y,z. to(x,y) and in(y,z) -> into(x,z)
• ∀x,y,z. enter(x,y,z) -> ∃w. go(x,y,w) and into(w,z)
• ∀x,y,z,w. go(x,y,z) and into(z,w) -> enter(x,y,w)

In other words, 'into' is a subtype of 'in', and 'enter' is a subtype of 'go'.

The semantic interpretation process takes place as follows:

1. The input sentence S is parsed using the lexicon/grammar, yielding a lexico-syntactic conceptual structure C (or a set of these if S is ambiguous).
2. C is tested for 'consistency' with the ontology.