Event Structure Templates

Verbs decompose into templates (structural meaning that determines argument realization) filled by roots (idiosyncratic content). Templates compose via CAUSE; which sub-predicate determines argument realization yields different syntactic frames.

Key insight from @cite{rappaport-hovav-levin-2024}: verbs of motion + sustained contact (sweep, rub, scrape) have two grammatically relevant predicates — MOVE and CONTACT. Which predicate determines argument realization yields variable agentivity and distinct syntactic frames.

Bridges

• Template.toAspectualProfile → AspectualProfile (aspect)
• motionContact_variable_agentivity → sweepBasicSubjectProfile (proto-roles)
• contact_determines_implies_effector_subject → isEffector (proto-roles)
• lexicalize_increases_agentivity → pAgentScore ordering (proto-roles)
• HasResultState → bieventive sub-event boundary (@cite{krejci-2012}; @cite{dowty-1979})
• cause_implies_resultState → CAUSE entails result state
• intransitiveVariant → causative/inchoative alternation (@cite{krejci-2012}; @cite{rappaport-hovav-levin-1998})

inductive Features.EventStructure.Template : Type

Canonical event structure templates. The first four are from @cite{rappaport-hovav-levin-1998}. motionContact is from @cite{rappaport-hovav-levin-2024} for the sweep/rub/scrape class: [x MOVE y] WHILE [x CONTACT y].

• state : Template
• activity : Template
• achievement : Template
• accomplishment : Template
• motionContact : Template

@[implicit_reducible]

instance Features.EventStructure.instDecidableEqTemplate : DecidableEq Template

Equations

• Features.EventStructure.instDecidableEqTemplate x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

@[implicit_reducible]

instance Features.EventStructure.instReprTemplate : Repr Template

Equations

• Features.EventStructure.instReprTemplate = { reprPrec := Features.EventStructure.instReprTemplate.repr }

def Features.EventStructure.instReprTemplate.repr : Template → ℕ → Std.Format

Equations

• One or more equations did not get rendered due to their size.

def Features.EventStructure.Template.HasCause : Template → Prop

Does the template involve CAUSE?

Equations

• Features.EventStructure.Template.accomplishment.HasCause = True
• x✝.HasCause = False

@[implicit_reducible]

instance Features.EventStructure.instDecidableHasCause (t : Template) : Decidable t.HasCause

Equations

• One or more equations did not get rendered due to their size.

def Features.EventStructure.Template.HasExternalCauser : Template → Prop

Does the template have an external causer position?

Equations

• Features.EventStructure.Template.accomplishment.HasExternalCauser = True
• x✝.HasExternalCauser = False

@[implicit_reducible]

instance Features.EventStructure.instDecidableHasExternalCauser (t : Template) : Decidable t.HasExternalCauser

Equations

• One or more equations did not get rendered due to their size.

def Features.EventStructure.Template.predicateCount : Template → ℕ

How many grammatically relevant predicates?

Equations

• Features.EventStructure.Template.state.predicateCount = 1
• Features.EventStructure.Template.activity.predicateCount = 1
• Features.EventStructure.Template.achievement.predicateCount = 1
• Features.EventStructure.Template.accomplishment.predicateCount = 2
• Features.EventStructure.Template.motionContact.predicateCount = 2

def Features.EventStructure.Template.toAspectualProfile : Template → AspectualProfile

Predicted aspectual profile for each template.

Equations

• Features.EventStructure.Template.state.toAspectualProfile = Features.stateProfile
• Features.EventStructure.Template.activity.toAspectualProfile = Features.activityProfile
• Features.EventStructure.Template.achievement.toAspectualProfile = Features.achievementProfile
• Features.EventStructure.Template.accomplishment.toAspectualProfile = Features.accomplishmentProfile
• Features.EventStructure.Template.motionContact.toAspectualProfile = Features.activityProfile

def Features.EventStructure.Template.vendlerClass (t : Template) : VendlerClass

Predicted Vendler class for each template (derived from profile).

Equations

• t.vendlerClass = t.toAspectualProfile.toVendlerClass

Templates with complex internal structure — multiple sub-events connected by CAUSE or embedding BECOME — license scopal ambiguities that mono-eventive templates do not.

At the template level, three diagnostics from @cite{dowty-1979} reduce
to two structural properties already defined above:

1. ***again*/*re-* ambiguity** tracks `HasResultState`: templates
   embedding [BECOME [STATE]] allow restitutive readings where a
   scopal modifier targets just the result sub-event.
2. **Negation over CAUSE** (@cite{koontz-garboden-2009}) tracks
   `HasCause`: negation can scope narrowly over CAUSE, denying
   the causal link while maintaining the result.
3. **"By itself" licensing** (@cite{koontz-garboden-2009}) also tracks
   `HasCause`: "without outside help" requires CAUSE in the meaning.

@cite{krejci-2012}'s insight is that some verbs assigned simpler templates
(eat, wash, dress, learn) nonetheless pass all three diagnostics — evidence
that they have bieventive, causative event structures in their simple forms.
This verb-level property is captured in `RootTypology` and `ArgDerivation`,
not at the template level here. 

def Features.EventStructure.Template.HasResultState : Template → Prop

Does the template embed a result state under BECOME? Templates with [BECOME [STATE]] have a sub-event boundary that scopal modifiers (again, re-, almost) can target independently.

Equations

• Features.EventStructure.Template.achievement.HasResultState = True
• Features.EventStructure.Template.accomplishment.HasResultState = True
• x✝.HasResultState = False

@[implicit_reducible]

instance Features.EventStructure.instDecidableHasResultState (t : Template) : Decidable t.HasResultState

Equations

• One or more equations did not get rendered due to their size.

theorem Features.EventStructure.cause_implies_resultState (t : Template) : t.HasCause → t.HasResultState

CAUSE implies a result state (accomplishment embeds BECOME).

Causative/Inchoative Alternation

The accomplishment template [[x ACT] CAUSE [BECOME [y STATE]]]
has an intransitive variant. On the **deletion** analysis
(@cite{krejci-2012}; @cite{rappaport-hovav-levin-1998}), this is
the achievement [BECOME [x STATE]], obtained by stripping the
external cause — yielding a monoeventive representation.

On the competing **reflexivization** analysis (@cite{koontz-garboden-2009};
@cite{chierchia-2004}), anticausativization does NOT delete CAUSE.
Instead, the reflexive clitic (*se*, *sich*) identifies the EFFECTOR
with the THEME: the derived inchoative retains the full causative
structure [∃v[CAUSE(v,e) ∧ EFFECTOR(v,x) ∧ BECOME(e,s) ∧ THEME(s,x)]].
This preserves the Monotonicity Hypothesis and explains why
anticausative morphology cross-linguistically coincides with reflexive
morphology (Haspelmath 1990: 9/13 languages).

`Template.intransitiveVariant` below implements the deletion view at the
template level. The reflexivization analysis is formalized in
`KoontzGarboden2009`. 

def Features.EventStructure.Template.intransitiveVariant : Template → Option Template

The intransitive variant of a template on the deletion analysis, stripping the external cause. Only accomplishments have an alternation partner.

NOTE: this implements one specific analysis. On the reflexivization analysis (@cite{koontz-garboden-2009}), the intransitive variant retains CAUSE with reflexivized arguments.

Equations

• Features.EventStructure.Template.accomplishment.intransitiveVariant = some Features.EventStructure.Template.achievement
• x✝.intransitiveVariant = none

theorem Features.EventStructure.intransitive_has_resultState (t t' : Template) : t.intransitiveVariant = some t' → t'.HasResultState

The intransitive variant retains the result state (BECOME STATE survives stripping of ACT CAUSE).

theorem Features.EventStructure.intransitive_no_cause (t t' : Template) : t.intransitiveVariant = some t' → ¬t'.HasCause

The intransitive variant loses CAUSE (on the deletion analysis). @cite{koontz-garboden-2009} disputes this on Monotonicity-Hypothesis grounds; see Phenomena/Causation/Studies/KoontzGarboden2009.lean.

theorem Features.EventStructure.only_accomplishment_alternates (t : Template) : t.intransitiveVariant.isSome = true → t = Template.accomplishment

Only accomplishments have an intransitive variant (only templates with CAUSE can undergo the alternation).

def Features.EventStructure.Template.subjectProfile : Template → Semantics.ArgumentStructure.EntailmentProfile.EntailmentProfile

Predicted subject entailment profile for each template.

Equations

• One or more equations did not get rendered due to their size.
• Features.EventStructure.Template.motionContact.subjectProfile = Semantics.ArgumentStructure.EntailmentProfile.sweepBasicSubjectProfile

def Features.EventStructure.Template.objectProfile : Template → Option Semantics.ArgumentStructure.EntailmentProfile.EntailmentProfile

Predicted object entailment profile (if any).

Equations

• One or more equations did not get rendered due to their size.
• Features.EventStructure.Template.state.objectProfile = none
• Features.EventStructure.Template.activity.objectProfile = none
• Features.EventStructure.Template.achievement.objectProfile = none

theorem Features.EventStructure.accomplishment_subject_is_agent : Template.accomplishment.subjectProfile.pAgentScore = 5

Accomplishment subject is a full agent (5 P-Agent entailments).

theorem Features.EventStructure.motionContact_variable_agentivity : Template.motionContact.subjectProfile = Semantics.ArgumentStructure.EntailmentProfile.sweepBasicSubjectProfile

motionContact subject has the same profile as basic sweep (movement + IE, underspecified for agentivity).

inductive Features.EventStructure.DeterminingPredicate : Type

For motionContact verbs, which sub-predicate determines argument realization (@cite{rappaport-hovav-levin-2024} §3.3–3.4).

• motion : DeterminingPredicate
• contact : DeterminingPredicate

@[implicit_reducible]

instance Features.EventStructure.instDecidableEqDeterminingPredicate : DecidableEq DeterminingPredicate

Equations

• Features.EventStructure.instDecidableEqDeterminingPredicate x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

def Features.EventStructure.instReprDeterminingPredicate.repr : DeterminingPredicate → ℕ → Std.Format

Equations

• One or more equations did not get rendered due to their size.

@[implicit_reducible]

instance Features.EventStructure.instReprDeterminingPredicate : Repr DeterminingPredicate

Equations

• Features.EventStructure.instReprDeterminingPredicate = { reprPrec := Features.EventStructure.instReprDeterminingPredicate.repr }

theorem Features.EventStructure.contact_determines_implies_effector_subject : Semantics.ArgumentStructure.EntailmentProfile.IsEffector Template.motionContact.subjectProfile

When CONTACT determines argument realization, the subject is an effector (movement + IE → external argument). This yields the simple transitive frame: "The wind swept the deck".

theorem Features.EventStructure.motionContact_object_is_forceRecipient : ∃ (p : Semantics.ArgumentStructure.EntailmentProfile.EntailmentProfile), Template.motionContact.objectProfile = some p ∧ Semantics.ArgumentStructure.EntailmentProfile.IsForceRecipient p

The motionContact object profile exists and is a force recipient.

def Features.EventStructure.Template.lexicalizeInstrument : Template → Semantics.ArgumentStructure.EntailmentProfile.EntailmentProfile

Instrument lexicalization adds agentivity to a template by restricting the moving entity to a specific instrument, forcing volition + sentience

• causation. The result is the broom-sweep subject profile.

Equations

• Features.EventStructure.Template.motionContact.lexicalizeInstrument = Semantics.ArgumentStructure.EntailmentProfile.sweepBroomSubjectProfile
• x✝.lexicalizeInstrument = x✝.subjectProfile

theorem Features.EventStructure.lexicalize_increases_agentivity : Template.motionContact.lexicalizeInstrument.pAgentScore > Template.motionContact.subjectProfile.pAgentScore

Instrument lexicalization strictly increases agentivity for motionContact templates (@cite{rappaport-hovav-levin-2024} §3.5: broom-sweep is more agentive than basic sweep).

theorem Features.EventStructure.lexicalized_is_full_agent : Template.motionContact.lexicalizeInstrument.pAgentScore = 5

Lexicalized motionContact has full proto-agent profile (5 entailments).

Levin classes map to event structure templates via meaning components. The core correspondence (@cite{rappaport-hovav-levin-1998} §3; @cite{rappaport-hovav-levin-2010} §2):

| Meaning component pattern | Template | Example class |
|---|---|---|
| CoS + causation | accomplishment | break (45.1), destroy (44) |
| CoS, no causation | achievement | appear (48.1), calve (28) |
| No CoS, no motion | state | exist (47.1), admire (31.2) |
| Otherwise | activity | hit (18.1), run (51.3) |

The `motionContact` template is specific to the sweep/rub/scrape
class and requires a class-specific override. 

inductive Features.EventStructure.EventType : Type

The fundamental binary distinction in event types: whether a predicate encodes a process (PROC only) or a state change (involves CHANGE).

This crosscuts Vendler's four-way classification: degree achievements are Vendler activities or accomplishments depending on scale boundedness but are event-structurally state-change predicates (@cite{bohnemeyer-2004} §5).

@cite{bohnemeyer-2004} argues this is the primary semantic distinction governing verb classification in Yukatek Maya — more fundamental than Vendler classes for predicting argument linking and transitivization.

• process : EventType
• stateChange : EventType

@[implicit_reducible]

instance Features.EventStructure.instDecidableEqEventType : DecidableEq EventType

Equations

• Features.EventStructure.instDecidableEqEventType x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

def Features.EventStructure.instReprEventType.repr : EventType → ℕ → Std.Format

Equations

• One or more equations did not get rendered due to their size.

@[implicit_reducible]

instance Features.EventStructure.instReprEventType : Repr EventType

Equations

• Features.EventStructure.instReprEventType = { reprPrec := Features.EventStructure.instReprEventType.repr }

def Features.EventStructure.Template.eventType : Template → EventType

Derive event type from template. Activities and motionContact are processes; states, achievements, and accomplishments involve state change.

Equations

• Features.EventStructure.Template.activity.eventType = Features.EventStructure.EventType.process
• Features.EventStructure.Template.motionContact.eventType = Features.EventStructure.EventType.process
• x✝.eventType = Features.EventStructure.EventType.stateChange

inductive Features.EventStructure.CausationType : Type

Whether a process is internally caused — the event is instigated by a participant — or externally caused — occurring "spontaneously" without an instigator.

This is a per-verb property of the ROOT, not of the template. Two activity verbs can differ: sing (internal) vs roll (external).

@cite{levin-hovav-1995} §4; @cite{bohnemeyer-2004} §2,6.

@cite{koontz-garboden-2009} §4.1: externally caused COS verbs have CAUSE+EFFECTOR in their LSR and license por sí solo 'by itself'. Internally caused COS verbs (empeorar, hervir, crecer) lack CAUSE in their LSR and reject por sí solo.

• internal : CausationType
• external : CausationType

@[implicit_reducible]

instance Features.EventStructure.instDecidableEqCausationType : DecidableEq CausationType

Equations

• Features.EventStructure.instDecidableEqCausationType x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

def Features.EventStructure.instReprCausationType.repr : CausationType → ℕ → Std.Format

Equations

• One or more equations did not get rendered due to their size.

@[implicit_reducible]

instance Features.EventStructure.instReprCausationType : Repr CausationType

Equations

• Features.EventStructure.instReprCausationType = { reprPrec := Features.EventStructure.instReprCausationType.repr }

def Features.EventStructure.CausationType.HasCauseInLSR : CausationType → Prop

Externally caused COS verbs have CAUSE in their LSR; internally caused COS verbs do not (@cite{koontz-garboden-2009} §4.1; @cite{levin-hovav-1995} §4).

This determines whether derived inchoatives (on the reflexivization analysis) retain a CAUSE operator.

Equations

• Features.EventStructure.CausationType.external.HasCauseInLSR = True
• Features.EventStructure.CausationType.internal.HasCauseInLSR = False

@[implicit_reducible]

instance Features.EventStructure.instDecidableHasCauseInLSR (c : CausationType) : Decidable c.HasCauseInLSR

Equations

• One or more equations did not get rendered due to their size.

def Features.EventStructure.CausationType.LicensesBySelf : CausationType → Prop

por sí solo / by itself is licensed iff CAUSE is present in the LSR (@cite{koontz-garboden-2009} §4.1). Stative predicates and internally caused COS verbs reject it.

Equations

• Features.EventStructure.CausationType.external.LicensesBySelf = True
• Features.EventStructure.CausationType.internal.LicensesBySelf = False

@[implicit_reducible]

instance Features.EventStructure.instDecidableLicensesBySelf (c : CausationType) : Decidable c.LicensesBySelf

Equations

• One or more equations did not get rendered due to their size.

def Semantics.Lexical.MeaningComponents.predictedTemplate : MeaningComponents → Features.EventStructure.Template

Predicted event structure template from meaning components.

Equations

• One or more equations did not get rendered due to their size.

def Semantics.Lexical.LevinClass.eventTemplate : LevinClass → Features.EventStructure.Template

Predicted template for a Levin class, with class-specific overrides.

Equations

• Semantics.Lexical.LevinClass.wipe.eventTemplate = Features.EventStructure.Template.motionContact
• x✝.eventTemplate = x✝.meaningComponents.predictedTemplate

Verification: canonical quadruple

theorem Features.EventStructure.break_is_accomplishment : Semantics.Lexical.LevinClass.break_.eventTemplate = Template.accomplishment

Break → accomplishment (CoS + causation → [ACT CAUSE BECOME]).

theorem Features.EventStructure.hit_is_activity : Semantics.Lexical.LevinClass.hit.eventTemplate = Template.activity

Hit → activity (contact + motion, no CoS → [ACT]).

theorem Features.EventStructure.touch_is_activity : Semantics.Lexical.LevinClass.touch.eventTemplate = Template.activity

Touch → activity (contact only, no CoS).

theorem Features.EventStructure.cut_is_accomplishment : Semantics.Lexical.LevinClass.cut.eventTemplate = Template.accomplishment

Cut → accomplishment (CoS + causation).

Change-of-state classes → accomplishment

theorem Features.EventStructure.cos_classes_accomplishment : Semantics.Lexical.LevinClass.break_.eventTemplate = Template.accomplishment ∧ Semantics.Lexical.LevinClass.bend.eventTemplate = Template.accomplishment ∧ Semantics.Lexical.LevinClass.cooking.eventTemplate = Template.accomplishment ∧ Semantics.Lexical.LevinClass.otherCoS.eventTemplate = Template.accomplishment ∧ Semantics.Lexical.LevinClass.destroy.eventTemplate = Template.accomplishment

All §45 CoS classes map to accomplishment.

Motion classes → activity

theorem Features.EventStructure.motion_is_activity : Semantics.Lexical.LevinClass.mannerOfMotion.eventTemplate = Template.activity ∧ Semantics.Lexical.LevinClass.inherentlyDirectedMotion.eventTemplate = Template.activity

Motion verbs are activities (no CoS, have motion).

Stative classes → state

theorem Features.EventStructure.stative_classes_state : Semantics.Lexical.LevinClass.exist.eventTemplate = Template.state ∧ Semantics.Lexical.LevinClass.admire.eventTemplate = Template.state ∧ Semantics.Lexical.LevinClass.want.eventTemplate = Template.state

Perception/psych statives map to state template.

Achievement classes

theorem Features.EventStructure.appear_is_achievement : Semantics.Lexical.LevinClass.appear.eventTemplate = Template.achievement

Appear (CoS without causation) → achievement.

theorem Features.EventStructure.calve_is_achievement : Semantics.Lexical.LevinClass.calve.eventTemplate = Template.achievement

Calve (CoS without causation) → achievement.

Special: motionContact

theorem Features.EventStructure.wipe_is_motionContact : Semantics.Lexical.LevinClass.wipe.eventTemplate = Template.motionContact

Wipe class → motionContact (class-specific override).

Template → aspectual class consistency

theorem Features.EventStructure.break_telic : Semantics.Lexical.LevinClass.break_.eventTemplate.vendlerClass = VendlerClass.accomplishment

Accomplishment classes (break, cut) are predicted telic.

theorem Features.EventStructure.hit_atelic : Semantics.Lexical.LevinClass.hit.eventTemplate.vendlerClass = VendlerClass.activity

Activity classes (hit, run) are predicted atelic.

theorem Features.EventStructure.exist_stative : Semantics.Lexical.LevinClass.exist.eventTemplate.vendlerClass = VendlerClass.state

State classes (exist, admire) are predicted stative.

§ 9. Bridge: Event Structure ↔ Diathesis Alternation

predictedTemplate and predictedAlternation are two predictions computed from the same MeaningComponents feature vector. This section proves their agreement and shows that MeaningComponents.fuse simultaneously derives both template shift and new alternation predictions from a single componentwise OR operation.

The central theorem — ci_alternation_iff_template_alternates — says the causative/inchoative alternation is exactly the syntactic reflex of having an accomplishment event template (which has an intransitive variant), modulo instrumentSpec. This connects @cite{levin-1993}'s diathesis alternation diagnostics to @cite{rappaport-hovav-levin-1998}'s event structure decomposition.

theorem Features.EventStructure.ci_alternation_iff_template_alternates (mc : Semantics.Lexical.MeaningComponents) (h_inst : mc.instrumentSpec = false) : mc.predictedAlternation Semantics.Lexical.DiathesisAlternation.causativeInchoative = true ↔ mc.predictedTemplate.intransitiveVariant.isSome = true

The causative/inchoative alternation is available iff the verb's event template has an intransitive variant (i.e., is an accomplishment), given no instrumentSpec.

Both conditions reduce to changeOfState ∧ causation, making the alternation prediction and the event structure prediction two views of a single semantic fact.

theorem Features.EventStructure.instrumentSpec_breaks_correspondence : Semantics.Lexical.LevinClass.cut.eventTemplate = Template.accomplishment ∧ Semantics.Lexical.LevinClass.cut.eventTemplate.intransitiveVariant = some Template.achievement ∧ Semantics.Lexical.LevinClass.cut.meaningComponents.predictedAlternation Semantics.Lexical.DiathesisAlternation.causativeInchoative = false

instrumentSpec breaks the template↔alternation correspondence: cut verbs have accomplishment template (they cause state change) but cannot undergo causative/inchoative alternation (instrument specification requires an agent).

This is why ci_alternation_iff_template_alternates requires instrumentSpec = false — the hypothesis is necessary, not just sufficient.

theorem Features.EventStructure.fuse_cos_caus_yields_accomplishment (v c : Semantics.Lexical.MeaningComponents) (hCoS : c.changeOfState = true) (hCaus : c.causation = true) : (v.fuse c).predictedTemplate = Template.accomplishment

Fusion with CoS + causation yields accomplishment template regardless of the verb's original template. The resultative construction adds [CAUSE [BECOME [STATE]]], upgrading any verb to accomplishment.

theorem Features.EventStructure.fuse_dual_prediction (v c : Semantics.Lexical.MeaningComponents) (hCoS : c.changeOfState = true) (hCaus : c.causation = true) (hInstV : v.instrumentSpec = false) (hInstC : c.instrumentSpec = false) : (v.fuse c).predictedTemplate = Template.accomplishment ∧ (v.fuse c).predictedAlternation Semantics.Lexical.DiathesisAlternation.causativeInchoative = true ∧ (v.fuse c).predictedTemplate.intransitiveVariant = some Template.achievement

One fusion, three consequences: accomplishment template, causative/inchoative alternation, and intransitive variant — all from a single componentwise OR.

theorem Features.EventStructure.fuse_vendler_class_shift (v c : Semantics.Lexical.MeaningComponents) (hCoS : c.changeOfState = true) (hCaus : c.causation = true) : (v.fuse c).predictedTemplate.vendlerClass = VendlerClass.accomplishment

Fusion-induced Vendler class shift: fusion with CoS + causation yields accomplishment Vendler class (telic, bounded).

theorem Features.EventStructure.fuse_cos_caus_has_result_state (v c : Semantics.Lexical.MeaningComponents) (hCoS : c.changeOfState = true) (hCaus : c.causation = true) : (v.fuse c).predictedTemplate.HasResultState

Fusion with CoS + causation yields result state, enabling again/re- restitutive readings (@cite{dowty-1979}).

theorem Features.EventStructure.fuse_cos_caus_has_cause (v c : Semantics.Lexical.MeaningComponents) (hCoS : c.changeOfState = true) (hCaus : c.causation = true) : (v.fuse c).predictedTemplate.HasCause

Fusion with CoS + causation yields CAUSE structure, enabling negation-over-CAUSE readings and by itself modification (@cite{koontz-garboden-2009}).