#reload_lamb() # may be useful if you edit this notebook
The classic account of verb meaning is that it a verb relates individuals. A transitive verb is a two-place relation in type e.
type_e = types.type_e
type_t = types.type_t
type_n = types.type_n
%%lamb
||smokes|| = L x_e : Smokes(x)
||sees|| = L y_e : L x_e : Sees(x, y)
||alfonso|| = Alfonso_e
||joanna|| = Joanna_e
INFO (meta): Coerced guessed type for 'Smokes_t' into <e,t>, to match argument 'x_e' INFO (meta): Coerced guessed type for 'Sees_t' into <(e,e),t>, to match argument '(x_e, y_e)'
smokes * alfonso
alfonso * (sees * joanna)
(alfonso * (sees * joanna)).tree()
There are many things that are tricky on this classical account. The best argument is probably from adverbs. I will not repeat the arguments in detail here, but the most basic one is what is sometimes called the 'diamond' entailment pattern (see e.g. Parsons 1990). (1) illustrates the basic pattern, and (2)-(5) illustrate the diamond pattern.
(1) Alfonso danced slowly $\leadsto$ Alfonso danced
(2) Alfonso danced slowly in the kitchen.
(3) $\leadsto$ Alfonso danced slowly.
(4) $\leadsto$ Alfonso danced in the kitchen.
(5) $\leadsto$ Alfonso danced.
In general, core arguments do not show this sort of pattern, and it is not straightforward to handle under the relation account. The pattern in (2)-(5) in fact resembles what happens with conjunction, which led Davidson to propose a somewhat different logical form for sentences like (2):
(6) $\exists e : Dancing(e, Alfonso) \wedge Slow(e) \wedge In(e, kitchen)$
$e$ here is an event variable, and on Davidson's original account, verbs denote a relation on events and event participants. In the neo-Davidsonian account, developed below, even participant combination is separated out.
First we add a type for events ($v$):
type_v = types.BasicType("v")
ts = meta.get_type_system()
ts.add_atomic(type_v)
ts
On this neo-Davidsonian treatment, VPs denote properties of events. Predicates such as $Agent$ and $Patient$ in the meta-language relate events with participants. Composition with a subject is mediated by a Kratzer-inspired little v, and composition with a direct object happens classically (though still mediated by a thematic predicate).
To keep things simple, I have done everything here via Function Application.
%%lamb
agent = Agent_<(v,e),t> # this is a way of enforcing consistent types for this predicate.
patient = Patient_<(v,e),t>
||smokes|| = L e_v : Smoking(e)
||sees|| = L y_e : L e_v : Seeing(e) & patient(e,y)
||ACTIVE|| = L f_<v,t> : L x_e : L e_v : f(e) & agent(e,x)
INFO (meta): Coerced guessed type for 'Smoking_t' into <v,t>, to match argument 'e_v' INFO (meta): Coerced guessed type for 'Seeing_t' into <v,t>, to match argument 'e_v'
v = ACTIVE
r = (alfonso * (v * smokes))
r
r2 = (alfonso * (v * (sees * joanna)))
r2
r2.tree()
Despite the complicated sequence of composition, the end result is just a conjunction of event properties (more or less).
Now, adverbs have a simple treatment, analogous to adjectives:
%%lamb
||dance|| = L e_v : Dancing(e)
||slowly|| = L f_<v,t> : L e_v : f(e) & Slow(e)
||inP|| = L x_e : L f_<v,t> : L e_v : f(e) & Loc(e, x)
||the|| = L f_<e,t> : Iota x_e : f(x)
||kitchen|| = L x_e : Kitchen(x)
INFO (meta): Coerced guessed type for 'Dancing_t' into <v,t>, to match argument 'e_v' INFO (meta): Coerced guessed type for 'Slow_t' into <v,t>, to match argument 'e_v' INFO (meta): Coerced guessed type for 'Loc_t' into <(v,e),t>, to match argument '(e_v, x_e)' INFO (meta): Coerced guessed type for 'Kitchen_t' into <e,t>, to match argument 'x_e'
itk = inP * (the * kitchen)
itk
dance0 = (alfonso * (v * dance))
dance1 = (alfonso * (v * (dance * slowly)))
dance2 = (alfonso * (v * (dance * itk)))
dance3 = (alfonso * (v * ((dance * slowly) * itk)))
ltx_print(dance0, dance1, dance2, dance3)
dance3.tree()
The denotations above remain unsaturated. Part of Davidson's idea is that the truth-conditions of an "action sentence" involve existentially quantifying over an event. There are a number of proposals as to how these existential quantifier is introduced compositionally, but the simplest is to treat it as a type shift (or unary composition operation).
We can first do this by defining a function that performs "existential closure", and then defining a composition operation using that function.
ec_fun = te("L f_<v,t> : Exists e_v : f(e)")
ec_fun
(ec_fun(dance3[0].content)).reduce_all()
system = lang.td_system.copy()
system.add_unary_rule(ec_fun, "EC")
lang.set_system(system)
system
The way to force unary composition (at the moment) is to compose with None.
dance4 = (dance3 * None)
dance4
dance4.tree()
The above treatment uses Function Application for every stage. The alternative is to use a (generalized) version of Predicate Modification, or some similar operation (e.g. Chung and Ladusaw's Restrict).
The version of PM provided by the lambda notebook library is specific to type $\langle e,t \rangle$, so we will need to generalize. The library implemention of PM uses the function shown below as basic_pm_fun
, and to generalize, one can construct such an operator for arbitrary input types. The function construct_gpm_fun
does this, with two example property types shown.
basic_pm_fun = lang.te("L f_<e,t> : L g_<e,t> : L x_e : f(x) & g(x)")
basic_pm_fun
gpm_fun = %te L f_<X,t> : L g_<X,t> : L x_X : f(x) & g(x)
gpm_fun
system = lang.td_system.copy()
system.add_unary_rule(ec_fun, "EC")
system.add_binary_rule(gpm_fun, "GPM", commutative=True)
lang.set_system(system)
system
(dance * slowly).tree()
Note that PM is redundant with GPM, so we may want to remove PM: (and if you re-run this code without a full reset, may need to remove extra GPMs)
system.remove_rule("PM")
system
Now with those preliminaries out of the way, we are in good shape to reformulate the neo-Davidsonian account using mainly GPM.
Just to demonstrate what this could involve, I'll alter the assumption about little-v. The early implementation assumed that the subject composed in Spec,TP; now we can even assume it is in Spec,vP. This leads to much simpler entries all around, and is close to Kratzer's original proposal.
%%lamb
# redo everything
||smokes|| = L e_v : Smoking(e)
||sees|| = L y_e : L e_v : Seeing(e) & patient(e,y)
||ACTIVE|| = L x_e : L e_v : agent(e,x)
||dance|| = L e_v : Dancing(e)
||slowly|| = L e_v : Slow(e)
||inP|| = L x_e : L e_v : Loc(e, x)
||the|| = L f_<e,t> : Iota x_e : f(x)
||kitchen|| = L x_e : Kitchen(x)
INFO (meta): Coerced guessed type for 'Smoking_t' into <v,t>, to match argument 'e_v' INFO (meta): Coerced guessed type for 'Seeing_t' into <v,t>, to match argument 'e_v' INFO (meta): Coerced guessed type for 'Dancing_t' into <v,t>, to match argument 'e_v' INFO (meta): Coerced guessed type for 'Slow_t' into <v,t>, to match argument 'e_v' INFO (meta): Coerced guessed type for 'Loc_t' into <(v,e),t>, to match argument '(e_v, x_e)' INFO (meta): Coerced guessed type for 'Kitchen_t' into <e,t>, to match argument 'x_e'
v = ACTIVE
((alfonso * v) * smokes).tree()
((alfonso * v) * ((dance * slowly) * (inP * (the * kitchen)))) * None
(((alfonso * v) * ((dance * slowly) * (inP * (the * kitchen)))) * None).tree()
Of course, this raises many questions that are not answered by the basic compositional architecture. What is an agent/patient? What does it mean for an event to be Slow
? Etc. However, the basic desiderata of the diamond entailment now follow, assuming any reasonable treatment of $\wedge$; see Parsons, Landman, and many many others for development of the Davidsonian program.
In the remainder of the notebook I discuss the conjunction of action sentences, such as Alfonso talked quickly and Alfonso danced slowly.
%%lamb
||quickly|| = L e_v : Quick(e)
||talk|| = L e_v : Talking(e)
||and_|| = L p_t : L q_t : p & q
INFO (meta): Coerced guessed type for 'Quick_t' into <v,t>, to match argument 'e_v' INFO (meta): Coerced guessed type for 'Talking_t' into <v,t>, to match argument 'e_v'
((alfonso * v) * (dance * quickly)) * None
((alfonso * v) * (talk * slowly)) * None
((((alfonso * v) * (dance * quickly)) * None)) * (and_ * (((alfonso * v) * (talk * slowly)) * None))
Notice that the current system gets a wrong result (though it does get a result) for something like: Alfonso talked slowly and danced quickly unless the syntax is treated as conjunction of full sentences.
If you want to handle this without saying this, you basically need to get existential closure to somehow scope under the subject. Two strategies for doing so:
Introduce existential closure in v itself, and have one v per conjunct. This requires a higher-typed version of and
.
Introduce existential closure inside the lexical items (proposed by e.g. Lucas Champollion). This leads to complications for the modifiers (which could be solved by e.g. an existential disclosure operation).
A different strategy would be to have a different type for conjunction that interacts directly with the event structure. The idea would be to build a property of plural events that has a part that is a slow talking, and a part that is a quick dancing. Then Alfonso would be the agent of the plural event; you'd want to be able to infer also that he's the agent of the parts.
Here's a version of solution 1.
%%lamb
||ACTIVE2|| = L f_<v,t> : L x_e : Exists e_v : agent(e,x) & f(e)
||and2|| = L f_<e,t> : L g_<e,t> : L x_e : f(x) & g(x)
r = alfonso * ((ACTIVE2 * (dance * quickly)) * (and2 * (ACTIVE2 * (talk * slowly))))
r
r.tree()