--- title: Logical Representations of Meaning module: Linguistic Structure moduleNumber: 6 lessonNumber: 11 order: 611 summary: > A meaning representation turns a sentence into a formal structure a machine can check against a world and reason over. We set the desiderata a good representation must meet, ground truth in a model, build up first-order logic for sentences with its connectives, quantifiers, and inference, and reify events with the neo-Davidsonian event variable to escape fixed predicate arity. The compositional lambda calculus, quantifier scope, and description logics follow in the companion lesson. topics: [Structure] sources: - book: Jurafsky ref: "Ch. 15 — Logical Representations of Sentence Meaning; §15.1 Computational Desiderata; §15.2 Model-Theoretic Semantics" - book: Jurafsky ref: "§15.3 First-Order Logic; §15.3.2 Variables and Quantifiers; §15.3.4 The Semantics of FOL; §15.3.5 Inference" - book: Jurafsky ref: "§15.4 Event and State Representations; §15.4.1 Representing Time" --- A [parse tree](/natural-language-processing/linguistic-structure/constituency-parsing) gives the grouping of a sentence's words into phrases, but not what the sentence _means_. To answer _Does Maharani serve vegetarian food?_ a system has to know what the question is asking and whether that is true of Maharani — and neither fact is in the syntax. What is needed is a **meaning representation**: a formal structure, built from a fixed vocabulary of symbols, that stands both for the meaning of the linguistic input and for a state of affairs in some world.[^jm-intro] A representation like $\text{Serves}(\text{Maharani}, \text{VegetarianFood})$ is at once a paraphrase of the English _and_ a claim about the world that a knowledge base can confirm or deny. This is a different theory of meaning from the [distributional one](/natural-language-processing/semantics/vector-semantics-and-embeddings). There, a word's meaning is a vector positioned by the company it keeps, and similarity is cosine distance; the representation is continuous, learned, and never _true_ or _false_ of anything. Here meaning is a symbolic structure with a truth value: it denotes objects and relations in a model, supports inference, and can be checked against facts. Embeddings show that _dog_ and _puppy_ are close; logic supports the conclusion that if every dog barks and Fido is a dog, then Fido barks. The two are complementary, and modern systems use both. ## What a meaning representation must do Before choosing a formalism, fix what the formalism is _for_. Jurafsky and Martin name five computational requirements, each motivated by a query a restaurant-advice system ought to answer.[^jm-desiderata] $$ % caption: The five desiderata for a meaning representation language: it must be % checkable against a world, unambiguous, canonical across paraphrases, able to % support inference, and expressive enough for real language. \begin{tikzpicture}[>=stealth, font=\footnotesize, d/.style={draw, minimum width=32mm, minimum height=10mm, align=center, font=\footnotesize}] \definecolor{acc}{HTML}{2348F2} \node[d, draw=acc, text=acc, thick] (v) at (0,1.6) {verif\/iability}; \node[d] (u) at (3.9,1.6) {unambiguous}; \node[d] (c) at (7.8,1.6) {canonical form}; \node[d] (i) at (1.95,0) {inference}; \node[d] (e) at (5.85,0) {expressiveness}; \node[font=\scriptsize, align=center, anchor=north] at (0,1.05) {check vs.\ a world}; \node[font=\scriptsize, align=center, anchor=north] at (3.9,1.05) {one meaning each}; \node[font=\scriptsize, align=center, anchor=north] at (7.8,1.05) {paraphrases agree}; \node[font=\scriptsize, align=center, anchor=north] at (1.95,-0.55) {derive new facts}; \node[font=\scriptsize, align=center, anchor=north] at (5.85,-0.55) {cover real language}; \end{tikzpicture} $$ - **Verifiability.** The system must be able to compare the state of affairs a representation describes against a world modeled in a knowledge base. Given $\text{Serves}(\text{Maharani}, \text{VegetarianFood})$, it matches the proposition against its facts and answers _yes_, _no_, or _don't know_. - **Unambiguous representation.** A sentence like _I wanna eat someplace close to ICSI_ has two readings (eat _at_ a nearby place, or, Godzilla-style, _devour_ a nearby place). The language is ambiguous, but each meaning representation must denote exactly one meaning, so the system can reason over a single unambiguous object. This is distinct from **vagueness**, where a representation is merely underspecified (_I want Italian food_ commits to a cuisine but not a dish) — a vague representation is still a single representation. - **Canonical form.** Distinct sentences that mean the same thing should map to the _same_ representation. _Does Maharani have vegetarian dishes?_, _Are vegetarian dishes served at Maharani?_, and _Does Maharani serve vegetarian fare?_ all ask one question; collapsing them onto one form means the knowledge base stores the fact once. The cost is pushed onto the parser, which must recognize that _serve_ and _have_, and _dishes_, _food_, and _fare_, coincide here. - **Inference and variables.** _Can vegetarians eat at Maharani?_ is not literally a stored fact, yet follows from one by common-sense reasoning; the system must **infer** it. And _find a restaurant where I can get vegetarian food_ names no restaurant at all, so it needs a **variable**: $\text{Serves}(x, \text{VegetarianFood})$, satisfied by any object that can replace $x$ and make the proposition match. - **Expressiveness.** Finally the language must cover a wide range of subject matter. No single scheme covers everything, but first-order logic covers a great deal, which is why it is the workbench for the rest of this lesson. ## Model-theoretic semantics A formal representation says something about the world through a **model**: a formal construct standing for a particular state of affairs.[^jm-model] The vocabulary of a representation splits in two. The **non-logical vocabulary** is the open-ended set of names for objects, properties, and relations — the predicates and constants. The **logical vocabulary** is the closed set of connectives, quantifiers, and operators that compose them. Every non-logical symbol must have a **denotation** in the model: - **Objects** denote elements of the **domain** $\mathcal{D}$, the set of things being represented. - **Properties** denote _sets_ of domain elements — the denotation of _red_ is the set of red things. - **Relations** denote _sets of tuples_ of domain elements — the denotation of _Married_ is the set of married pairs. This is the **extensional** view: a concept just _is_ its extension, the things it picks out. An **interpretation** is the function mapping each non-logical symbol to its denotation. Take a restaurant world with patrons Matthew, Franco, Katie, Caroline (domain elements $a,b,c,d$), restaurants Frasca, Med, Rio ($e,f,g$), and cuisines Italian, Mexican, Eclectic ($h,i,j$). A property like _Noisy_ denotes a subset of restaurants; _Likes_ and _Serves_ denote sets of tuples. $$ % caption: A model of the restaurant world. Constants map to domain elements; the % property Noisy denotes a set; the relations Likes and Serves denote sets of % ordered pairs. Truth is membership: "Matthew likes Frasca" holds iff (a, e) is in % the Likes set. \begin{tikzpicture}[>=stealth, font=\footnotesize] \definecolor{acc}{HTML}{2348F2} % language column \node[font=\small, text=acc] at (0,3.5) {language}; \node[align=left, anchor=north west] at (-1.4,3.1) {Matthew, Franco,\\ Katie, Caroline\\[3pt] Frasca, Med, Rio\\[3pt] Italian, Mexican}; % arrow \draw[->, acc, very thick] (2.5,1.9) -- (4.1,1.9); \node[font=\scriptsize, text=acc, anchor=south] at (3.3,1.95) {interpret}; % model column \node[font=\small] at (7.2,3.5) {model}; \node[align=left, anchor=north west, font=\footnotesize] at (4.5,3.1) {Domain: a, b, c, d, e, f, g, h, i, j\\[3pt] Noisy = -e, f, g-\\[3pt] Likes = -(a,f), (c,f), (c,g),\\ \hspace{9mm}(b,e), (d,f), (d,g)-\\[3pt] Serves = -(f,j), (g,i), (e,h)-}; % dashed frame around model \draw[black, dashed] (4.35,-0.9) rectangle (10.2,3.25); \end{tikzpicture} $$ To evaluate _Matthew likes Frasca_, map _Matthew_ to $a$, _Frasca_ to $e$, and _Likes_ to its set of pairs, then check whether $\langle a, e \rangle$ is in that set. It is, so the sentence is true; if it were absent, false. Truth has become set membership.[^jm-model] Non-mnemonic names ($a$ through $j$) are deliberate: whatever the system knows about these entities must come from the formal structure of the model, not from suggestive spellings. Complex sentences need more than lookup. _Katie likes the Rio and Matthew likes the Med_ is true exactly when _both_ conjuncts are true in the model. This is a **truth-conditional semantics**: the meaning of a compound is fixed by the meanings of its parts and the meaning of the operator joining them. Determining the truth of the whole reduces to set operations on the parts plus a truth table for _and_ — the principle we build on next, and the same **compositionality** that will let us build logical forms from parse trees later in the lesson. ## First-order logic for meaning **First-order logic** (FOL) is the well-understood, computationally tractable language that meets most of the desiderata and commits only to the mild ontology model theory already assumes — objects, properties, relations.[^jm-fol] Its syntax is itself a small [context-free grammar](/natural-language-processing/linguistic-structure/constituency-parsing). $$ % caption: A context-free grammar for the syntax of first-order logic. A formula is % an atomic formula, two formulas joined by a connective, a quantified formula, a % negation, or a parenthesized formula; terms are functions, constants, or % variables. \begin{tikzpicture}[>=stealth, font=\footnotesize] \definecolor{acc}{HTML}{2348F2} \node[align=left, anchor=north west, font=\small\ttfamily] at (0,0) {Formula -> AtomicFormula\\ \hphantom{Formula }| Formula Connective Formula\\ \hphantom{Formula }| Quantifier Variable, ... Formula\\ \hphantom{Formula }| not Formula\\ \hphantom{Formula }| ( Formula )\\[4pt] AtomicFormula -> Predicate ( Term, ... )\\ Term -> Function ( Term, ... ) | Constant | Variable\\[4pt] Connective -> and | or | implies\\ Quantifier -> forall | exists}; \end{tikzpicture} $$ **Terms** name objects and come in three kinds. **Constants** name specific objects ($\text{Maharani}$, $A$); like programming-language constants each refers to exactly one object, though one object may have several names. **Functions** name an object via another — $\text{LocationOf}(\text{Frasca})$ picks out Frasca's location without inventing a constant for it. **Variables** ($x$, $y$) let us assert and infer things about objects without naming any. **Predicates** name relations: the two-place $\text{Serves}(\text{Maharani}, \text{VegetarianFood})$ asserts a relation holds between two objects, while the one-place $\text{Restaurant}(\text{Maharani})$ asserts category membership — a property of one object. **Connectives** compose atomic formulas into larger ones, and because the grammar is recursive, a finite device generates infinitely many formulas. _I only have five dollars and I don't have a lot of time_ becomes $$ \text{Have}(\text{Speaker}, \text{FiveDollars}) \;\wedge\; \neg\,\text{Have}(\text{Speaker}, \text{LotOfTime}), $$ built straight from the two clauses with $\wedge$ and $\neg$. The semantics of every connective is a truth table, evaluated against the model just as _and_ was above. $$ % caption: The truth table defining the FOL connectives. Note that "or" is % inclusive and "implies" is the material conditional — true whenever its % antecedent P is false — neither of which matches English usage exactly. \begin{tikzpicture}[>=stealth, font=\footnotesize] \definecolor{acc}{HTML}{2348F2} \tikzset{c/.style={draw=black, minimum width=14mm, minimum height=7mm, anchor=center}} \foreach \x/\h in {0/P, 1/Q, 2/not P, 3/P and Q, 4/P or Q, 5/P implies Q} \node[c, fill=acc!10, text=acc] at (\x*1.5,0) {\h}; \foreach \r/\P/\Q/\np/\pq/\po/\pi [count=\y from 1] in {1/F/F/T/F/F/T, 2/F/T/T/F/T/T, 3/T/F/F/F/T/F, 4/T/T/F/T/T/T} { \foreach \x/\val in {0/\P, 1/\Q, 2/\np, 3/\pq, 4/\po, 5/\pi} \node[c] at (\x*1.5,-\y*0.7) {\val}; } \end{tikzpicture} $$ Two facts about the table matter for translating English. $\vee$ is _inclusive_ or, true when either or both disjuncts hold, unlike the exclusive _or_ English often intends; and $\Rightarrow$ is the **material conditional**, true whenever its antecedent is false, which only loosely tracks any common-sense notion of implication or cause.[^jm-fol-sem] ### Variables and quantifiers Variables become useful only under **quantifiers**, the operators that say _how_ to interpret them.[^jm-quant] The **existential** $\exists$ (_there exists_) asserts at least one object makes the formula true; the **universal** $\forall$ (_for all_) asserts every object does. An indefinite noun phrase usually signals $\exists$: _a restaurant that serves Mexican food near ICSI_ is $$ \exists x \;\; \text{Restaurant}(x) \wedge \text{Serves}(x, \text{MexicanFood}) \wedge \text{Near}\big(\text{LocationOf}(x), \text{LocationOf}(\text{ICSI})\big). $$ This is true if _some_ substitution for $x$ — say AyCaramba — makes all three conjuncts true. A universal reads differently. _All vegetarian restaurants serve vegetarian food_ is naturally written with an implication: $$ \forall x \;\; \text{VegetarianRestaurant}(x) \Rightarrow \text{Serves}(x, \text{VegetarianFood}). $$ For $\forall$ the formula must hold under _every_ substitution. Split the objects into vegetarian restaurants and everything else. For a vegetarian restaurant like Maharani, both antecedent and consequent are true, so the implication is true. For a non-vegetarian restaurant — or even an irrelevant object like a carburetor — the antecedent is false, and the material conditional makes the whole implication _vacuously_ true. So the universal is satisfied without making any absurd claim about carburetors. $$ % caption: Why "for all x, VegetarianRestaurant(x) implies Serves(x, veg)" holds % for every object. When the antecedent is true the consequent must be checked; % when it is false the material conditional is vacuously true, so irrelevant objects % never falsify the universal. \begin{tikzpicture}[>=stealth, font=\footnotesize, b/.style={draw, minimum width=30mm, minimum height=13mm, align=center, font=\scriptsize}] \definecolor{acc}{HTML}{2348F2} \definecolor{red}{HTML}{C0392B} \node[b, draw=acc, text=acc] (m) at (0,0) {x = Maharani\\antecedent TRUE\\check consequent}; \node[b] (a) at (4.5,0) {x = AyCaramba\\antecedent FALSE\\vacuously TRUE}; \node[b] (c) at (9.0,0) {x = Carburetor\\antecedent FALSE\\vacuously TRUE}; \node[font=\scriptsize, text=acc, anchor=south] at (0,0.85) {relevant}; \node[font=\scriptsize, anchor=south] at (6.75,0.85) {irrelevant: implication saves them}; \draw[black, dashed] (2.6,-1.0) -- (2.6,1.0); \end{tikzpicture} $$ The model-theoretic account of quantifiers reuses substitution: a formula with $\exists$ is true if _some_ substitution of a domain term for the variable yields a formula true in the model, and a formula with $\forall$ is true if _all_ such substitutions do.[^jm-fol-sem] #### Evaluating a quantified formula against the model Run one all the way through on the restaurant model from earlier, whose relevant facts were $\text{Serves} = \{(f,j), (g,i), (e,h)\}$ (restaurant, cuisine pairs) with Rio $=g$, Mexican $=i$. Evaluate _some restaurant serves Mexican food_, $\exists x\; \text{Restaurant}(x) \wedge \text{Serves}(x, \text{Mexican})$. The existential says: try every domain element in turn and stop at the first that makes the body true. $$ % caption: Evaluating "exists x. Restaurant(x) and Serves(x, Mexican)" against the % model by substitution. Each candidate for x is checked; e = Frasca fails the % Serves conjunct (it serves Italian h, not Mexican i), g = Rio satisfies both % conjuncts, so the existential is TRUE. \begin{tikzpicture}[>=stealth, font=\footnotesize, b/.style={draw, minimum width=33mm, minimum height=13mm, align=center, font=\scriptsize}] \definecolor{acc}{HTML}{2348F2} \definecolor{red}{HTML}{C0392B} \node[b, draw=red, text=red] (e) at (0,0) {x = e (Frasca)\\Restaurant TRUE\\Serves(e,i)? NO}; \node[b, draw=red, text=red] (f) at (4.2,0) {x = f (Med)\\Restaurant TRUE\\Serves(f,i)? NO}; \node[b, draw=acc, text=acc] (g) at (8.4,0) {x = g (Rio)\\Restaurant TRUE\\Serves(g,i)? YES}; \node[font=\scriptsize, text=acc, anchor=west] at (0,-1.2) {one witness suf\/f\/ices: the existential is TRUE}; \draw[->, black] (e) -- (f); \draw[->, black] (f) -- (g); \end{tikzpicture} $$ For $x=e$ (Frasca), $\text{Restaurant}(e)$ holds but $\langle e, i\rangle \notin \text{Serves}$ — Frasca serves Italian $h$, not Mexican $i$ — so the body is false. Same for $x=f$ (Med, which serves Eclectic $j$). At $x=g$ (Rio), both $\text{Restaurant}(g)$ and $\langle g, i\rangle \in \text{Serves}$ hold, so the body is true and the search halts: one witness proves the existential. The corresponding universal _every restaurant serves Mexican food_ would demand the body hold for $e$, $f$, _and_ $g$; it fails already at $e$, so the universal is false. The two quantifiers differ only in whether one satisfying substitution or all of them is required — the same substitution machinery, read with a different quantifier. ### Inference A representation must support **inference**: deriving propositions not explicitly stored. The most widely implemented rule is **modus ponens**: $$ \dfrac{\alpha \qquad \alpha \Rightarrow \beta}{\beta} $$ If the antecedent of an implication is known and the implication holds, the consequent follows. Given $\text{VegetarianRestaurant}(\text{Leaf})$ and the rule above, we conclude $\text{Serves}(\text{Leaf}, \text{VegetarianFood})$ — a fact never stored, now derived. Modus ponens runs two ways.[^jm-inference] **Forward chaining** fires every applicable rule as new facts arrive, so answers are precomputed and queries reduce to lookup, at the cost of inferring facts nobody asks for. **Backward chaining** runs the rule in reverse from a query: to prove a goal, find a rule whose consequent matches it, then recursively try to prove its antecedent — the strategy of the Prolog language. Both are _sound_ but neither is _complete_: some valid inferences elude them, which is why a sound-and-complete but far costlier method, **resolution**, exists as a fallback. The two directions reach the same conclusion by opposite motions. Suppose the knowledge base holds two rules and one fact: $$ \text{VegetarianRestaurant}(x) \Rightarrow \text{Serves}(x, \text{VegFood}), \qquad \text{Serves}(x, \text{VegFood}) \Rightarrow \text{OkFor}(x, \text{Vegetarians}), $$ plus the fact $\text{VegetarianRestaurant}(\text{Leaf})$, and ask _can vegetarians eat at Leaf?_ — the goal $\text{OkFor}(\text{Leaf}, \text{Vegetarians})$. $$ % caption: Forward chaining (left) starts from the stored fact and fires rules as % facts appear, deriving Serves then OkFor; backward chaining (right) starts from % the goal and unwinds rules in reverse, reducing OkFor to Serves to the stored % fact. Same chain, opposite directions. \begin{tikzpicture}[>=stealth, font=\footnotesize, b/.style={draw, minimum width=42mm, minimum height=8mm, align=center, font=\scriptsize}] \definecolor{acc}{HTML}{2348F2} % forward, left column top-down \node[font=\scriptsize\bfseries, text=acc] at (0,3.0) {forward chaining}; \node[b, draw=acc, text=acc] (f1) at (0,2.2) {VegRestaurant(Leaf) [fact]}; \node[b] (f2) at (0,0.9) {Serves(Leaf, VegFood)}; \node[b] (f3) at (0,-0.4) {OkFor(Leaf, Vegetarians)}; \draw[->, acc, thick] (f1) -- node[right, font=\scriptsize]{rule 1} (f2); \draw[->, acc, thick] (f2) -- node[right, font=\scriptsize]{rule 2} (f3); % backward, right column bottom-up \node[font=\scriptsize\bfseries] at (7.4,3.0) {backward chaining}; \node[b] (g1) at (7.4,-0.4) {OkFor(Leaf, Vegetarians) [goal]}; \node[b] (g2) at (7.4,0.9) {prove Serves(Leaf, VegFood)}; \node[b, draw=acc, text=acc] (g3) at (7.4,2.2) {prove VegRestaurant(Leaf): fact!}; \draw[->, thick] (g1) -- node[right, font=\scriptsize]{rule 2 backward} (g2); \draw[->, thick] (g2) -- node[right, font=\scriptsize]{rule 1 backward} (g3); \end{tikzpicture} $$ Forward chaining derives $\text{Serves}(\text{Leaf}, \text{VegFood})$ from the fact and the first rule, then $\text{OkFor}(\text{Leaf}, \text{Vegetarians})$ from that and the second rule — the query is now a stored fact and answering is a lookup. Backward chaining instead matches the goal against the consequent of rule 2, which reduces it to proving $\text{Serves}(\text{Leaf}, \text{VegFood})$; that matches the consequent of rule 1, reducing it to $\text{VegetarianRestaurant}(\text{Leaf})$, which is a stored fact, so the proof closes. Forward chaining precomputes and may derive facts nobody wanted; backward chaining stays goal-directed but re-derives on each query. ## Events, states, and the arity problem Representing _Leaf serves vegetarian fare_ as $\text{Serves}(\text{Leaf}, \text{VegetarianFare})$ quietly assumes the predicate's arity equals the verb's number of arguments. That assumption breaks. Consider _eat_:[^jm-events] $$ % caption: One verb, many arities. "eat" appears with anywhere from zero to four % explicit arguments; a fixed-arity predicate Eating(...) cannot represent them all % with a single symbol, which is the variable-arity problem. \begin{tikzpicture}[>=stealth, font=\footnotesize] \definecolor{acc}{HTML}{2348F2} \node[align=left, anchor=north west, font=\footnotesize] at (1.0,0) {0 roles:\hspace{5mm} I ate.\\ 1 role:\hspace{6mm} I ate a turkey sandwich.\\ 2 roles:\hspace{4mm} I ate a turkey sandwich at my desk.\\ 1 role:\hspace{6mm} I ate lunch.\\ 4 roles:\hspace{4mm} I ate a turkey sandwich for lunch at my desk.}; \draw[->, acc, thick] (0.55,-0.15) -- (0.55,-2.35); \node[text=acc, font=\scriptsize, rotate=90, anchor=south] at (0.25,-1.25) {more roles}; \end{tikzpicture} $$ These sentences pack anywhere from zero to four roles (eater, thing eaten, location, meal) in shifting combinations. But FOL predicates have **fixed arity**: they take a set number of arguments. Writing $\text{Eating}$ with two slots cannot represent _I ate a turkey sandwich for lunch at my desk_, and multiplying $\text{Eating}_2$, $\text{Eating}_3$, $\text{Eating}_4$ into separate predicates loses the fact that all are the same eating. To address this, **reify** the event: introduce an existentially quantified **event variable** $e$ that stands for the eating itself, then hang each role on $e$ with its own predicate.[^jm-events] _I ate a turkey sandwich_ becomes $$ \exists e \;\; \text{Eating}(e) \wedge \text{Eater}(e, \text{Speaker}) \wedge \text{Eaten}(e, \text{TurkeySandwich}), $$ and the four-role version simply glues on more conjuncts: $$ \exists e \;\; \text{Eating}(e) \wedge \text{Eater}(e, \text{Speaker}) \wedge \text{Eaten}(e, \text{TurkeySandwich}) \wedge \text{Meal}(e, \text{Lunch}) \wedge \text{Location}(e, \text{Desk}). $$ $$ % caption: The neo-Davidsonian move. Left: a fixed-arity predicate must commit to a % slot count in advance. Right: an event variable e binds an Eating predicate, and % each role (Eater, Eaten, Meal, Location) is a separate two-place predicate on e, % so roles are added only as the input provides them. \begin{tikzpicture}[>=stealth, font=\footnotesize, b/.style={draw, minimum width=52mm, minimum height=10mm, align=center, font=\scriptsize}] \definecolor{acc}{HTML}{2348F2} \definecolor{red}{HTML}{C0392B} \node[b, draw=red, text=red] (fix) at (0,1.4) {Eating(Speaker, Sandwich, ?, ?)}; \node[font=\scriptsize, text=red, anchor=north] at (0,0.7) {f\/ixed arity: which slots? how many?}; \node[b, draw=acc, text=acc] (ev) at (0,-1.2) {exists e : Eating(e)}; \node[b] (r1) at (6.0,-0.2) {Eater(e, Speaker)}; \node[b] (r2) at (6.0,-1.2) {Eaten(e, Sandwich)}; \node[b] (r3) at (6.0,-2.2) {Location(e, Desk)}; \draw[->, acc, thick] (ev.east) -- (r1.west); \draw[->, acc, thick] (ev.east) -- (r2.west); \draw[->, acc, thick] (ev.east) -- (r3.west); \node[font=\scriptsize, text=acc, anchor=north] at (0,-1.9) {glue on roles as provided}; \end{tikzpicture} $$ This is the **neo-Davidsonian** representation, after Donald Davidson, who first reified events, and Terry Parsons, who reified the participants too.[^jm-events] Its virtues restate the desiderata one for one: no predicate needs a fixed slot count, no more roles are postulated than the input mentions, and related sentences that share the event predicate stay logically connected for free — _I ate_ is entailed by _I ate a sandwich_ because dropping a conjunct is a valid inference. The role predicates ($\text{Eater}$, $\text{Eaten}$) are the **thematic roles** that [semantic role labeling](/natural-language-processing/linguistic-structure/semantic-roles-and-information-extraction) recovers from text; here they live inside the logical form as ordinary relations. ### Time and aspect, briefly Reifying the event also simplifies representing **time**. _I arrived_, _I am arriving_, and _I will arrive_ share the tenseless core $\exists e\; \text{Arriving}(e) \wedge \text{Arriver}(e, \text{Speaker}) \wedge \dots$; tense adds predicates about the event's interval.[^jm-time] Introduce an interval $i$ and its endpoint $n$: a past event has $\text{IntervalOf}(e,i) \wedge \text{EndPoint}(i,n) \wedge \text{Precedes}(n, \text{Now})$, a future event flips the ordering to $\text{Precedes}(\text{Now}, n)$, and a present event has $\text{MemberOf}(i, \text{Now})$. The mapping from tense to time is loose — _we fly at 10_ uses present tense for a future event — and complex tenses need a third coordinate, Reichenbach's **reference point**, separating event time, utterance time, and the vantage from which the event is viewed. Orthogonal to tense is **aspect**: whether an event is a momentary **achievement** (_she found her gate_), an extended **activity** (_John is flying_), a bounded **accomplishment** (_Sally booked her flight_), or an unchanging **state** (_I know my gate_) — Vendler's four classes.[^jm-time] ## Where this continues We have the symbolic core: a meaning representation must be checkable, unambiguous, canonical, inference-supporting, and expressive; a model gives its symbols a denotation so truth becomes set membership; first-order logic supplies terms, predicates, connectives, quantifiers, and modus-ponens inference; and the neo-Davidsonian event variable absorbs the shifting arity of real verbs so roles and tense attach as ordinary conjuncts. What we have _not_ done is compute a logical form from a sentence automatically. The lambda calculus that assembles a formula from a parse tree, the quantifier-scope ambiguity that one syntax tree leaves open, and the decidable description logics behind the Semantic Web continue in [compositional semantics and description logics](/natural-language-processing/linguistic-structure/compositional-semantics-and-description-logics). [^jm-intro]: **Jurafsky & Martin**, _Speech and Language Processing_ (3rd ed.), Ch. 15 opening — meaning representations as formal structures made of the same "stuff" as common-sense world knowledge, viewable both as the meaning of an input and as a state of affairs; the four sampler representations (FOL, AMR, frames) for _I have a car_. [^jm-desiderata]: **Jurafsky & Martin**, §15.1 — Computational Desiderata for Representations: verifiability, unambiguous representation (vs. vagueness), canonical form, inference and variables, and expressiveness, each motivated by a restaurant-advice query. [^jm-model]: **Jurafsky & Martin**, §15.2 — Model-Theoretic Semantics: models, domains, denotations, the non-logical vs. logical vocabulary, extensional properties/relations, interpretation functions, the restaurant-world model of Fig. 15.2, and truth-conditional semantics. [^jm-fol]: **Jurafsky & Martin**, §15.3 and §15.3.1 — First-Order Logic: the CFG for FOL syntax (Fig. 15.3), terms (constants, functions, variables), predicates as relations and category membership, and logical connectives. [^jm-fol-sem]: **Jurafsky & Martin**, §15.3.4 — The Semantics of First-Order Logic: terms denote domain elements, atomic formulas denote sets/tuples, the connective truth table (Fig. 15.4) with inclusive $\vee$ and the material conditional, and substitution semantics for quantifiers. [^jm-quant]: **Jurafsky & Martin**, §15.3.2 — Variables and Quantifiers: the existential and universal quantifiers, indefinite NPs signaling $\exists$, universally quantified implications, and the vacuous truth of the material conditional under irrelevant substitutions. [^jm-inference]: **Jurafsky & Martin**, §15.3.5 — Inference: modus ponens, forward vs. backward chaining (Prolog), soundness without completeness, and resolution as the sound-and-complete alternative. [^jm-events]: **Jurafsky & Martin**, §15.4 — Event and State Representations: the variable-arity problem for _eat_, fixed predicate arity, the event variable, and the neo-Davidsonian representation (Davidson 1967, Parsons 1990) with reified participants. [^jm-time]: **Jurafsky & Martin**, §15.4.1 Representing Time and §15.4.2 Aspect: interval/endpoint predicates with $\text{Precedes}$ and $\text{Now}$ for tense, Reichenbach's reference point, and Vendler's stative/activity/accomplishment/achievement aspectual classes.