Questions: Lambda Calculus for Linguistic Semantics

Question 1

The transitive verb 'loves' has the representation λy.λx.love(x,y). The object 'Maria' (denoted m) combines first, then the subject 'John' (denoted j) combines. What is the final result after both beta reductions?

• A. λx.love(x,j) — John becomes the new bound variable after combining with the object
• B. love(m,j) — the arguments are placed in the order they were applied
• C. love(j,m) — beta reduction first yields λx.love(x,m), then substituting j for x gives love(j,m), meaning 'John loves Maria'
• D. λj.love(j,m) — a new lambda abstraction is formed over the subject variable j

Answer: (C)

Step by step: applying λy.λx.love(x,y) to m (Maria) substitutes m for y, yielding λx.love(x,m) — a function meaning 'x loves Maria.' Applying that to j (John) substitutes j for x, yielding love(j,m) — the proposition 'John loves Maria.' Notice that argument order matters: the lambda expression is constructed so the object combines first (inner lambda over y), then the subject (outer lambda over x). This mirrors the syntactic structure: the verb phrase 'loves Maria' forms before combining with the subject 'John.' Beta reduction is simply function application — substitute the argument for the bound variable wherever it appears in the body.

Question 2

Why can't the quantifier phrase 'every student' be represented as an individual entity (type e) that gets plugged into the argument slot of a predicate?

• A. Because 'every student' refers to multiple individuals simultaneously, so it should be represented as a set of entities
• B. Because 'every student' is a generalized quantifier — a higher-order function that takes a property as its argument and returns a truth value — not an individual that occupies a predicate's argument slot
• C. Because lambda calculus is unable to represent plural or distributive expressions at all
• D. Because quantifiers like 'every' are handled by a separate proof-theoretic system outside the lambda framework

Answer: (B)

This is the central insight of generalized quantifier theory. An individual (type e) can be plugged into a predicate like λx.sleep(x) to get a proposition (type t): sleep(m). But 'every student' doesn't denote a specific individual — it expresses a relationship between two sets: the set of students and the set of things with some property. Its denotation is λP.∀x[student(x)→P(x)] — a function from properties (type ⟨e,t⟩) to truth values (type t), i.e., type ⟨⟨e,t⟩,t⟩. Applying it to the VP λx.sleep(x) yields ∀x[student(x)→sleep(x)] compositionally. This higher-order treatment is what makes quantification tractable within a fully compositional framework.

Question 3

In lambda calculus semantics for linguistics, the expression λx.sleep(x) represents a specific individual who is sleeping.

• T. True
• F. False

Answer: False

λx.sleep(x) is a *function* — specifically, a predicate of type ⟨e,t⟩ (a function from entities to truth values). It represents the *property* of sleeping: given any individual, it returns 'true' if that individual sleeps and 'false' otherwise. It is the denotation of a verb or verb phrase, not of an individual. To get a proposition about a specific individual, you must apply the function to an entity: (λx.sleep(x))(m) beta-reduces to sleep(m), the proposition that Maria sleeps. The confusion between functions/predicates and individuals is a common conceptual error when first encountering formal semantics.

Question 4

Beta reduction in lambda calculus for linguistics corresponds to the semantic operation of combining a predicate with its argument — for example, a verb phrase combining with its subject to form a complete proposition.

• T. True
• F. False

Answer: True

Yes — this correspondence between syntactic combination and semantic beta reduction is the heart of compositional semantics. When the subject NP (an entity or generalized quantifier) combines with the VP (a function), the semantic operation is function application, and computing the result is beta reduction. This parallelism — syntax drives semantics, and semantic combination is precisely function application — is what makes the lambda calculus framework both precise and systematically compositional. It removes the need for ad hoc semantic rules: every semantic composition step is the same operation (function application), differing only in the types of expressions involved.

Question 5

How does treating a quantifier like 'every student' as a higher-order function (rather than an individual) allow it to compose with a verb phrase within the same lambda calculus framework used for proper names?

Model answer: A proper name (type e) combines with a predicate (type ⟨e,t⟩) by simple function application: (λx.sleep(x))(m) → sleep(m). A generalized quantifier like 'every student' has type ⟨⟨e,t⟩,t⟩ — it takes a predicate and returns a truth value. Applying λP.∀x[student(x)→P(x)] to λx.sleep(x) yields ∀x[student(x)→sleep(x)] by the same beta reduction operation. Both compose via function application; only the types differ.

The uniformity is the key achievement. Rather than having one rule for how names combine with predicates and a different rule for how quantifiers combine, the entire grammar operates by a single principle: type-driven function application. Type theory keeps track of what can combine with what (you can only apply a function to an argument of the right type), and every semantic composition step is just beta reduction. This is why Montague's grammar was such a breakthrough: it showed that natural language semantics could be given a mathematically rigorous, fully compositional treatment using tools from formal logic and the lambda calculus.