12.2 Compositional analysis in Montague Grammar

Compositional Analysis in Montague Grammar

Montague Grammar provides a formal system for deriving sentence meaning from the meanings of individual words and how they combine syntactically. It matters because it shows how a finite set of rules and word meanings can generate interpretations for an infinite number of sentences. The system works by assigning semantic types to words, then using compositional rules to combine those types step by step.

Principle of Compositionality in Montague Grammar

The principle of compositionality states that the meaning of a complex expression is determined entirely by the meanings of its parts and the way those parts are syntactically combined. In other words, if you know what each word means and you know the syntactic structure, you can compute the meaning of the whole sentence.

This is what gives natural language its productivity: speakers can understand and produce sentences they've never encountered before. You can interpret a bizarre sentence like colorless green ideas sleep furiously precisely because compositionality lets you build up meaning from familiar pieces, even when the combination is novel.

Montague Grammar leans on this principle as its foundation. Every step in the analysis computes meaning from smaller parts, so interpretation is fully systematic rather than requiring a separate rule for each possible sentence.

Type-Driven Translation for Semantic Mapping

Montague Grammar connects syntax to semantics through type-driven translation. Every syntactic category gets a corresponding semantic type, and translation rules specify how to derive a semantic representation from the syntactic structure.

The two basic types are:

• e (entity): the type of things in the world (individuals like John or Mary)
• t (truth value): the type of a proposition that is either true or false

Complex types are built from these using the function type constructor. For example, $\langle e, t \rangle$ is the type of a function that takes an entity and returns a truth value.

Translation proceeds bottom-up: you start at the lexical items (the leaves of the syntactic tree), assign each one its semantic type and representation, and then combine representations step by step according to the syntactic rules until you reach a complete sentence meaning of type $t$.

Semantic Types of Lexical Items

Each word in the lexicon is assigned a semantic type based on its syntactic category and what it contributes to meaning.

• Proper names (John, Mary): type $e$, denoting individual entities
• Intransitive verbs (sleep, run): type $\langle e, t \rangle$, functions that take an entity and return a truth value. sleep applied to John tells you whether "John sleeps" is true or false.
• Transitive verbs (love, see): type $\langle e, \langle e, t \rangle \rangle$, functions that take an entity (the object) and return a function of type $\langle e, t \rangle$ (which then takes the subject). So love first takes Mary, producing a one-place predicate loves Mary, which then applies to John.

These type assignments are what drive composition. A transitive verb needs two entity-type arguments before it yields a complete truth value, and the types tell you exactly in what order those arguments get filled in.

Compositional Rules for Complex Sentences

Two key rules govern how semantic representations combine as you move up the syntactic tree:

1. Function Application: If one constituent has type $\langle a, b \rangle$ and an adjacent constituent has type $a$, you apply the function to the argument to get a result of type $b$.
2. Lambda Abstraction: When a constituent contains a free variable, lambda abstraction binds that variable, creating a function. This is how the system builds up predicate meanings from open expressions.

These rules apply recursively until the full sentence receives a semantic representation of type $t$.

Worked example: "John loves Mary"

1. Start with the lexical items and their types:

   • John: type $e$
   • loves: type $\langle e, \langle e, t \rangle \rangle$
   • Mary: type $e$

2. Apply loves to Mary (function application): $\langle e, \langle e, t \rangle \rangle$ applied to type $e$ yields $\langle e, t \rangle$. The result is the one-place predicate loves Mary.

3. Apply loves Mary to John (function application): $\langle e, t \rangle$ applied to type $e$ yields type $t$. The result is a truth value representing the proposition that John loves Mary.

At each step, the types guide which constituents can combine and what the result will be. If the types don't match, the combination is blocked, which is part of how the system rules out ill-formed interpretations.