Argument Structure Derivation Pipeline #
@cite{beavers-koontz-garboden-2020} @cite{rappaport-hovav-levin-1998} @cite{rappaport-hovav-levin-2024} @cite{dowty-1991}
The derivational chain from root content to argument structure, made explicit as composed functions:
RootEntailments → Template → ArgTemplate → ThetaRole
Each step exists in the literature: @cite{beavers-koontz-garboden-2020} define root entailments; @cite{rappaport-hovav-levin-1998} define event structure templates; @cite{dowty-1991} defines proto-role entailment profiles. But nobody has written down the full pipeline as a single computable derivation. This file does so.
Key insight (Beavers SAG 2023, Lecture 3 §8) #
Root and template meanings are not ontologically distinct — both are sets of lexical entailments about events and participants. They differ in degree of specificity: templates have general meanings shared across many roots; roots have specific meanings that can include templatic content (contra the Bifurcation Thesis, @cite{embick-2009}).
The template determines structural argument positions (subject, object). The root determines WHICH template the verb fills, and class membership can further refine the entailment profiles within those positions.
Overrides #
Three classes of systematic override exist where class membership adds information beyond what root entailments + template predict:
- Psych-causal (amuse): stimulus subject instead of agent — the nature of causation (volitional vs. non-volitional) is not encoded in root entailments or template structure
- Creation (build): object has dependent existence + incremental theme — these are additional entailments about the object's ontological status
- Consumption (eat): object has incremental theme without dependent existence — the object pre-exists but measures the event
Can a root fill this template?
A root licenses a template when it provides content for the template's structural positions. Templates provide operators (ACT, CAUSE, BECOME); roots fill the content slots (STATE, MANNER).
@cite{beavers-koontz-garboden-2020} (SAG Lectures 2023 §6): roots fall into types based on how much templatic meaning they entail, and these types predict which templates they can fill.
Licensing conditions:
- state
[x STATE]: root must describe a state - activity
[x ACT]: root must describe an action manner - achievement
[BECOME [x STATE]]: root provides state for BECOME to apply to (template adds the change) - accomplishment
[[x ACT] CAUSE [BECOME [y STATE]]]: root provides state for the caused result - motionContact
[x MOVE y] WHILE [x CONTACT y]: root must describe manner (motion + contact are manner-based)
Equations
- Semantics.Lexical.Verb.ArgDerivation.rootLicensesTemplate re Semantics.Lexical.Verb.EventStructure.Template.state = re.state
- Semantics.Lexical.Verb.ArgDerivation.rootLicensesTemplate re Semantics.Lexical.Verb.EventStructure.Template.activity = re.manner
- Semantics.Lexical.Verb.ArgDerivation.rootLicensesTemplate re Semantics.Lexical.Verb.EventStructure.Template.achievement = re.state
- Semantics.Lexical.Verb.ArgDerivation.rootLicensesTemplate re Semantics.Lexical.Verb.EventStructure.Template.accomplishment = re.state
- Semantics.Lexical.Verb.ArgDerivation.rootLicensesTemplate re Semantics.Lexical.Verb.EventStructure.Template.motionContact = re.manner
Instances For
All templates licensed by a root (captures alternation).
Equations
- One or more equations did not get rendered due to their size.
Instances For
PC roots (FLAT) license state, achievement, accomplishment — the three state-based templates. Not activity (no manner).
Pure manner roots (JOG) license activity and motionContact only. Not state-based templates (no state entailment).
Pure result roots (BLOSSOM) license state, achievement, accomplishment — same as PC roots, since both have state.
Causative result roots (BREAK) license state-based templates.
Full-spec roots (CUT) license ALL five templates — they have both state and manner, so they can fill any structural position.
PC roots license 3 templates → predict causative alternation. "The rug is flat" (state) / "The rug flattened" (achievement) / "Kim flattened the rug" (accomplishment).
Pure manner roots license 2 templates — no alternation into state-based frames (*"Kim jogged the ball broken").
Full-spec roots license all 5 templates — maximal flexibility (conative, causative/inchoative, locative, etc.).
Default ArgTemplate from an event structure template.
Wraps Template.subjectProfile/Template.objectProfile into
an ArgTemplate. This is the TEMPLATE-LEVEL prediction, before
any class-level refinement.
Known divergences from class-level named templates:
- Activity subject gets C=true (assumes transitive activity like "hit"); intransitive activities (selfMotion) override to C=false
- Accomplishment object gets IT=true (incremental theme); resultChange object overrides to IT=false (not all CoS objects are incremental themes)
- State template has no object; perception verbs add one at the class level
Equations
- Semantics.Lexical.Verb.ArgDerivation.templateArgTemplate t = { subjectProfile := t.subjectProfile, objectProfile := t.objectProfile }
Instances For
A root's primary (natural) template — the template whose structural complexity matches the root's entailment level.
This is the template the root "wants" to fill by default:
- cause → accomplishment (inherently causative verb)
- result without cause → achievement (entails change, no external cause)
- manner without result → activity (specifies action manner)
- state only → state (names a property/state)
@cite{beavers-koontz-garboden-2020} (SAG Lectures 2023 §6, table 32): the root typology mirrors the template typology.
| Root type | Primary template |
|---|---|
| propertyConcept (FLAT) | state |
| pureResult (CRACK) | achievement |
| causativeResult (BREAK) | accomplishment |
| pureManner (JOG) | activity |
| fullSpec (CUT) | accomplishment |
Equations
- One or more equations did not get rendered due to their size.
Instances For
For canonical root types, the primary template is licensed.
The full derivational pipeline: root entailments → primary template → template-level ArgTemplate.
Equations
Instances For
All ArgTemplates derivable from a root (one per licensed template). Multiple entries represent alternation possibilities: e.g., a causativeResult root derives both an accomplishment ArgTemplate (transitive) and a state ArgTemplate (bare stative).
Equations
Instances For
causativeResult roots derive 3 ArgTemplates (state, achievement, accomplishment variants).
fullSpec roots derive 5 ArgTemplates (all templates).
The template determines structural argument positions, but for
activity verbs, the ROOT contributes the object. In R&HL's notation,
[x ACT<HIT> y] — the y is an argument of the root (HIT), not of
the template (ACT).
This means activity objects come from meaning components (contact, motion), not from template structure. When a root involves contact with another entity, the activity becomes transitive, and the subject gains causation (C) from the causal interaction with the object.
Root-contributed object profile for activity verbs. Contact in meaning components → transitive activity with a contacted, stationary object (CA+St). No contact → intransitive.
Equations
- One or more equations did not get rendered due to their size.
Instances For
Root-enriched derivation: combines template-level profiles with root-contributed objects.
For activity templates, the root's meaning components determine whether there's a contacted object. When there is one, the subject also gains C (causation) — causal interaction with the object is a Dowty P-Agent entailment that comes from having an affected participant, not from the template.
For other templates, the template's own profiles are used directly.
Returns none for roots with no structural entailments (minimal).
Equations
- One or more equations did not get rendered due to their size.
Instances For
Hit-class: enriched derivation gives mannerContact (full agent + contacted object). The root's contact meaning component contributes the object and adds C to the subject.
MannerOfMotion: enriched derivation gives selfMotion (no contact, no object). The root contributes no object.
Break: enriched derivation gives resultChange (full agent + CoS+CA object). Accomplishment template used directly — the root doesn't modify it for non-activity templates.
Cut: enriched derivation gives resultChange (same as break). The manner component doesn't affect the accomplishment template.
For hit-class, the enriched derivation matches the hand-specified argTemplate exactly — no override needed.
For break-class, same exact match.
For cut-class, same exact match.
For mannerOfMotion, same exact match.
The toArgTemplate shortcut (§7 of LevinClassProfiles) maps
root entailments directly to named ArgTemplates. The pipeline goes
through an intermediate Template step.
After fixing the template defaults (activity subject C=false, accomplishment object IT=false), the pipeline and shortcut now AGREE on 4 of 5 canonical root types:
| Root type | Pipeline subject | Shortcut subject | Agree? |
|---|---|---|---|
| causativeResult | V+S+C+M+IE | V+S+C+M+IE | yes |
| fullSpec | V+S+C+M+IE | V+S+C+M+IE | yes |
| pureManner | V+S+M+IE | V+S+M+IE | yes |
| propertyConcept | S+IE | S+IE | yes |
| pureResult | M+IE+CoS | CoS+CA | no |
The pureResult divergence reflects genuinely different theoretical emphases on what characterizes unaccusatives: the template emphasizes movement and change (M+IE+CoS), while the shortcut emphasizes being affected (CoS+CA).
causativeResult: pipeline and shortcut AGREE on subject profile. Both give the accomplishment subject = full agent (V+S+C+M+IE).
fullSpec: pipeline and shortcut AGREE on subject profile.
propertyConcept: pipeline and shortcut AGREE on subject profile (both S+IE).
pureManner: pipeline and shortcut AGREE on subject profile. Both give V+S+M+IE (no causation): the activity template does not entail causal interaction with another participant, matching selfMotion verbs like run and jog.
pureResult: pipeline and shortcut DISAGREE on subject. Pipeline: achievement subject = M+IE+CoS (moves, changes). Shortcut: unaccusativeCoS subject = CoS+CA (changed, affected). Different theoretical emphases on what characterizes unaccusatives.
causativeResult: pipeline and shortcut AGREE on object profile. Both give CoS+CA (change of state, causally affected). The template default correctly excludes IT (incremental theme) — not all caused-change objects measure the event.
The LevinClass.argTemplate mapping hand-specifies ArgTemplates for each class. The pipeline derives them from root entailments through a template intermediate. Where do they agree?
For break-class, the pipeline's PRIMARY subject matches the hand-specified subject. Both are full agent (V+S+C+M+IE).
For cut-class, same agreement on subject.
Pipeline's primary template for break matches the event-structure-predicted template. The two independent derivations (root entailments → primaryTemplate, and meaningComponents → predictedTemplate) agree.
Amuse-class: pipeline gives full agent subject (V+S+C+M+IE), but hand-specified gives stimulus subject (C+IE). The nature of causation (volitional vs. non-volitional) is not encoded in root entailments or template structure — it's a class-level semantic property.
Build-class: pipeline and hand-specified agree on subject (both full agent), but diverge on object (creation object has dependent existence).
@cite{beavers-koontz-garboden-2020} (SAG Lectures 2023 §6): roots fall into three types based on how much templatic meaning they entail. This predicts morphological and semantic properties cross-linguistically (validated across 88 languages).
| Type | Entails | Morphology | Simple stative |
|---|---|---|---|
| PC (FLAT) | state only | marked verbs (-en) | yes |
| Result (CRACK) | state + change | unmarked verbs | no |
| Caused result (FRY) | state + change + cause | unmarked verbs | no |
PC roots entail state but NOT result — they name properties without inherent change. "Flat" is a simple state.
Result roots entail both state AND result — the state is inseparable from prior change. "Cracked" entails having been cracked.
Caused-result roots entail state + result + cause — the change must have been externally caused. "Break" entails external causation.
The root typology forms an implicational hierarchy: cause → result → state. Each type INCLUDES the entailments of simpler types.
PC and result roots differ in licensing predictions: PC roots can fill stative templates (simple statives exist); result roots also license stative BUT the root itself entails change, so the "stative" use still presupposes prior change.
The enriched pipeline (deriveEnriched) captures the field consensus:
Template determines structural positions: CAUSE introduces an external argument; BECOME introduces an internal argument. The template-level
templateArgTemplategives DEFAULT profiles.Root contributes additional participants: for activity verbs, the root's meaning components (contact, motion) determine whether there's a contacted object. This adds transitivity and causation to the subject — effects that come from the ROOT, not the template.
Class overrides remain for irreducible properties: psych-causal (amuse), creation (build), consumption (eat) require class-level information not in root entailments or meaning components.
The enriched pipeline covers hit, break, cut, mannerOfMotion classes
exactly — deriveEnriched matches LevinClass.argTemplate with no
override needed. Only amuse, build/create, eat/devour, perception,
directedMotion, and minimal-rootEntailments classes need overrides.
The full derivational chain:
Root entailments → Template → Template profiles → Root enrichment → Class override
(RootEntailments) (primary) (templateArg) (deriveEnriched) (LevinClass.argTemplate)