inductive Semantics.Lexical.Verb.Aspect.Telicity : Type

Telicity: whether an event has a natural endpoint.

• telic : Telicity
• atelic : Telicity

instance Semantics.Lexical.Verb.Aspect.instDecidableEqTelicity : DecidableEq Telicity

Equations

• Semantics.Lexical.Verb.Aspect.instDecidableEqTelicity x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

instance Semantics.Lexical.Verb.Aspect.instReprTelicity : Repr Telicity

Equations

• Semantics.Lexical.Verb.Aspect.instReprTelicity = { reprPrec := Semantics.Lexical.Verb.Aspect.instReprTelicity.repr }

def Semantics.Lexical.Verb.Aspect.instReprTelicity.repr : Telicity → ℕ → Std.Format

Equations

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

instance Semantics.Lexical.Verb.Aspect.instBEqTelicity : BEq Telicity

Equations

• Semantics.Lexical.Verb.Aspect.instBEqTelicity = { beq := Semantics.Lexical.Verb.Aspect.instBEqTelicity.beq }

def Semantics.Lexical.Verb.Aspect.instBEqTelicity.beq : Telicity → Telicity → Bool

Equations

• Semantics.Lexical.Verb.Aspect.instBEqTelicity.beq x✝ y✝ = (x✝.ctorIdx == y✝.ctorIdx)

instance Semantics.Lexical.Verb.Aspect.instInhabitedTelicity : Inhabited Telicity

Equations

• Semantics.Lexical.Verb.Aspect.instInhabitedTelicity = { default := Semantics.Lexical.Verb.Aspect.instInhabitedTelicity.default }

def Semantics.Lexical.Verb.Aspect.instInhabitedTelicity.default : Telicity

Equations

• Semantics.Lexical.Verb.Aspect.instInhabitedTelicity.default = Semantics.Lexical.Verb.Aspect.Telicity.telic

inductive Semantics.Lexical.Verb.Aspect.Duration : Type

Duration: whether an event takes time or is instantaneous.

• durative : Duration
• punctual : Duration

instance Semantics.Lexical.Verb.Aspect.instDecidableEqDuration : DecidableEq Duration

Equations

• Semantics.Lexical.Verb.Aspect.instDecidableEqDuration x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

instance Semantics.Lexical.Verb.Aspect.instReprDuration : Repr Duration

Equations

• Semantics.Lexical.Verb.Aspect.instReprDuration = { reprPrec := Semantics.Lexical.Verb.Aspect.instReprDuration.repr }

def Semantics.Lexical.Verb.Aspect.instReprDuration.repr : Duration → ℕ → Std.Format

Equations

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

instance Semantics.Lexical.Verb.Aspect.instBEqDuration : BEq Duration

Equations

• Semantics.Lexical.Verb.Aspect.instBEqDuration = { beq := Semantics.Lexical.Verb.Aspect.instBEqDuration.beq }

def Semantics.Lexical.Verb.Aspect.instBEqDuration.beq : Duration → Duration → Bool

Equations

• Semantics.Lexical.Verb.Aspect.instBEqDuration.beq x✝ y✝ = (x✝.ctorIdx == y✝.ctorIdx)

instance Semantics.Lexical.Verb.Aspect.instInhabitedDuration : Inhabited Duration

Equations

• Semantics.Lexical.Verb.Aspect.instInhabitedDuration = { default := Semantics.Lexical.Verb.Aspect.instInhabitedDuration.default }

def Semantics.Lexical.Verb.Aspect.instInhabitedDuration.default : Duration

Equations

• Semantics.Lexical.Verb.Aspect.instInhabitedDuration.default = Semantics.Lexical.Verb.Aspect.Duration.durative

inductive Semantics.Lexical.Verb.Aspect.Dynamicity : Type

Dynamicity: whether the event involves change.

• dynamic : Dynamicity
• stative : Dynamicity

instance Semantics.Lexical.Verb.Aspect.instDecidableEqDynamicity : DecidableEq Dynamicity

Equations

• Semantics.Lexical.Verb.Aspect.instDecidableEqDynamicity x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

def Semantics.Lexical.Verb.Aspect.instReprDynamicity.repr : Dynamicity → ℕ → Std.Format

Equations

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

instance Semantics.Lexical.Verb.Aspect.instReprDynamicity : Repr Dynamicity

Equations

• Semantics.Lexical.Verb.Aspect.instReprDynamicity = { reprPrec := Semantics.Lexical.Verb.Aspect.instReprDynamicity.repr }

instance Semantics.Lexical.Verb.Aspect.instBEqDynamicity : BEq Dynamicity

Equations

• Semantics.Lexical.Verb.Aspect.instBEqDynamicity = { beq := Semantics.Lexical.Verb.Aspect.instBEqDynamicity.beq }

def Semantics.Lexical.Verb.Aspect.instBEqDynamicity.beq : Dynamicity → Dynamicity → Bool

Equations

• Semantics.Lexical.Verb.Aspect.instBEqDynamicity.beq x✝ y✝ = (x✝.ctorIdx == y✝.ctorIdx)

def Semantics.Lexical.Verb.Aspect.instInhabitedDynamicity.default : Dynamicity

Equations

• Semantics.Lexical.Verb.Aspect.instInhabitedDynamicity.default = Semantics.Lexical.Verb.Aspect.Dynamicity.dynamic

instance Semantics.Lexical.Verb.Aspect.instInhabitedDynamicity : Inhabited Dynamicity

Equations

• Semantics.Lexical.Verb.Aspect.instInhabitedDynamicity = { default := Semantics.Lexical.Verb.Aspect.instInhabitedDynamicity.default }

def Semantics.Lexical.Verb.Aspect.Telicity.toMereoTag : Telicity → Core.Scale.MereoTag

Telicity → MereoTag: telic = quantized. Telic predicates are QUA (no proper part of a telic event is telic); atelic predicates are CUM (the sum of two atelic events is atelic).

Equations

• Semantics.Lexical.Verb.Aspect.Telicity.telic.toMereoTag = Core.Scale.MereoTag.qua
• Semantics.Lexical.Verb.Aspect.Telicity.atelic.toMereoTag = Core.Scale.MereoTag.cum

inductive Semantics.Lexical.Verb.Aspect.VendlerClass : Type

Vendler's four-way classification of eventualities.

• state : VendlerClass
• activity : VendlerClass
• achievement : VendlerClass
• accomplishment : VendlerClass

instance Semantics.Lexical.Verb.Aspect.instDecidableEqVendlerClass : DecidableEq VendlerClass

Equations

• Semantics.Lexical.Verb.Aspect.instDecidableEqVendlerClass x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯

instance Semantics.Lexical.Verb.Aspect.instReprVendlerClass : Repr VendlerClass

Equations

• Semantics.Lexical.Verb.Aspect.instReprVendlerClass = { reprPrec := Semantics.Lexical.Verb.Aspect.instReprVendlerClass.repr }

def Semantics.Lexical.Verb.Aspect.instReprVendlerClass.repr : VendlerClass → ℕ → Std.Format

Equations

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

instance Semantics.Lexical.Verb.Aspect.instBEqVendlerClass : BEq VendlerClass

Equations

• Semantics.Lexical.Verb.Aspect.instBEqVendlerClass = { beq := Semantics.Lexical.Verb.Aspect.instBEqVendlerClass.beq }

def Semantics.Lexical.Verb.Aspect.instBEqVendlerClass.beq : VendlerClass → VendlerClass → Bool

Equations

• Semantics.Lexical.Verb.Aspect.instBEqVendlerClass.beq x✝ y✝ = (x✝.ctorIdx == y✝.ctorIdx)

def Semantics.Lexical.Verb.Aspect.instInhabitedVendlerClass.default : VendlerClass

Equations

• Semantics.Lexical.Verb.Aspect.instInhabitedVendlerClass.default = Semantics.Lexical.Verb.Aspect.VendlerClass.state

instance Semantics.Lexical.Verb.Aspect.instInhabitedVendlerClass : Inhabited VendlerClass

Equations

• Semantics.Lexical.Verb.Aspect.instInhabitedVendlerClass = { default := Semantics.Lexical.Verb.Aspect.instInhabitedVendlerClass.default }

def Semantics.Lexical.Verb.Aspect.VendlerClass.telicity : VendlerClass → Telicity

Get the telicity of a Vendler class (states treated as atelic).

Equations

• Semantics.Lexical.Verb.Aspect.VendlerClass.state.telicity = Semantics.Lexical.Verb.Aspect.Telicity.atelic
• Semantics.Lexical.Verb.Aspect.VendlerClass.activity.telicity = Semantics.Lexical.Verb.Aspect.Telicity.atelic
• Semantics.Lexical.Verb.Aspect.VendlerClass.achievement.telicity = Semantics.Lexical.Verb.Aspect.Telicity.telic
• Semantics.Lexical.Verb.Aspect.VendlerClass.accomplishment.telicity = Semantics.Lexical.Verb.Aspect.Telicity.telic

def Semantics.Lexical.Verb.Aspect.VendlerClass.duration : VendlerClass → Duration

Get the duration of a Vendler class.

Equations

• Semantics.Lexical.Verb.Aspect.VendlerClass.state.duration = Semantics.Lexical.Verb.Aspect.Duration.durative
• Semantics.Lexical.Verb.Aspect.VendlerClass.activity.duration = Semantics.Lexical.Verb.Aspect.Duration.durative
• Semantics.Lexical.Verb.Aspect.VendlerClass.achievement.duration = Semantics.Lexical.Verb.Aspect.Duration.punctual
• Semantics.Lexical.Verb.Aspect.VendlerClass.accomplishment.duration = Semantics.Lexical.Verb.Aspect.Duration.durative

def Semantics.Lexical.Verb.Aspect.VendlerClass.dynamicity : VendlerClass → Dynamicity

Get the dynamicity of a Vendler class.

Equations

• Semantics.Lexical.Verb.Aspect.VendlerClass.state.dynamicity = Semantics.Lexical.Verb.Aspect.Dynamicity.stative
• Semantics.Lexical.Verb.Aspect.VendlerClass.activity.dynamicity = Semantics.Lexical.Verb.Aspect.Dynamicity.dynamic
• Semantics.Lexical.Verb.Aspect.VendlerClass.achievement.dynamicity = Semantics.Lexical.Verb.Aspect.Dynamicity.dynamic
• Semantics.Lexical.Verb.Aspect.VendlerClass.accomplishment.dynamicity = Semantics.Lexical.Verb.Aspect.Dynamicity.dynamic

theorem Semantics.Lexical.Verb.Aspect.state_is_stative : VendlerClass.state.dynamicity = Dynamicity.stative

States are stative.

theorem Semantics.Lexical.Verb.Aspect.activity_is_atelic : VendlerClass.activity.telicity = Telicity.atelic

Activities are atelic.

theorem Semantics.Lexical.Verb.Aspect.activity_is_durative : VendlerClass.activity.duration = Duration.durative

Activities are durative.

theorem Semantics.Lexical.Verb.Aspect.achievement_is_punctual : VendlerClass.achievement.duration = Duration.punctual

Achievements are punctual.

theorem Semantics.Lexical.Verb.Aspect.achievement_is_telic : VendlerClass.achievement.telicity = Telicity.telic

Achievements are telic.

theorem Semantics.Lexical.Verb.Aspect.accomplishment_is_telic : VendlerClass.accomplishment.telicity = Telicity.telic

Accomplishments are telic.

theorem Semantics.Lexical.Verb.Aspect.accomplishment_is_durative : VendlerClass.accomplishment.duration = Duration.durative

Accomplishments are durative.

theorem Semantics.Lexical.Verb.Aspect.dynamic_classes_are_dynamic (c : VendlerClass) : c ≠ VendlerClass.state → c.dynamicity = Dynamicity.dynamic

All dynamic classes involve change.

theorem Semantics.Lexical.Verb.Aspect.telic_classes (c : VendlerClass) : c.telicity = Telicity.telic ↔ c = VendlerClass.achievement ∨ c = VendlerClass.accomplishment

All telic classes have endpoints.

structure Semantics.Lexical.Verb.Aspect.AspectualProfile : Type

An aspectual profile bundles telicity, duration, and dynamicity.

• telicity : Telicity

  Whether the eventuality has a natural endpoint

• duration : Duration

  Whether the eventuality takes time

• dynamicity : Dynamicity

  Whether the eventuality involves change

def Semantics.Lexical.Verb.Aspect.instDecidableEqAspectualProfile.decEq (x✝ x✝¹ : AspectualProfile) : Decidable (x✝ = x✝¹)

Equations

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

instance Semantics.Lexical.Verb.Aspect.instDecidableEqAspectualProfile : DecidableEq AspectualProfile

Equations

• Semantics.Lexical.Verb.Aspect.instDecidableEqAspectualProfile = Semantics.Lexical.Verb.Aspect.instDecidableEqAspectualProfile.decEq

def Semantics.Lexical.Verb.Aspect.instReprAspectualProfile.repr : AspectualProfile → ℕ → Std.Format

Equations

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

instance Semantics.Lexical.Verb.Aspect.instReprAspectualProfile : Repr AspectualProfile

Equations

• Semantics.Lexical.Verb.Aspect.instReprAspectualProfile = { reprPrec := Semantics.Lexical.Verb.Aspect.instReprAspectualProfile.repr }

instance Semantics.Lexical.Verb.Aspect.instBEqAspectualProfile : BEq AspectualProfile

Equations

• Semantics.Lexical.Verb.Aspect.instBEqAspectualProfile = { beq := Semantics.Lexical.Verb.Aspect.instBEqAspectualProfile.beq }

def Semantics.Lexical.Verb.Aspect.instBEqAspectualProfile.beq : AspectualProfile → AspectualProfile → Bool

Equations

• One or more equations did not get rendered due to their size.
• Semantics.Lexical.Verb.Aspect.instBEqAspectualProfile.beq x✝¹ x✝ = false

def Semantics.Lexical.Verb.Aspect.AspectualProfile.toVendlerClass (p : AspectualProfile) : VendlerClass

Convert an aspectual profile to a Vendler class (semelfactives mapped to activity).

Equations

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

def Semantics.Lexical.Verb.Aspect.VendlerClass.toProfile (c : VendlerClass) : AspectualProfile

Convert a Vendler class to its canonical aspectual profile.

Equations

• c.toProfile = { telicity := c.telicity, duration := c.duration, dynamicity := c.dynamicity }

def Semantics.Lexical.Verb.Aspect.stateProfile : AspectualProfile

Canonical profile for states.

Equations

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

def Semantics.Lexical.Verb.Aspect.activityProfile : AspectualProfile

Canonical profile for activities.

Equations

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

def Semantics.Lexical.Verb.Aspect.achievementProfile : AspectualProfile

Canonical profile for achievements.

Equations

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

def Semantics.Lexical.Verb.Aspect.accomplishmentProfile : AspectualProfile

Canonical profile for accomplishments.

Equations

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

theorem Semantics.Lexical.Verb.Aspect.vendler_profile_roundtrip (c : VendlerClass) : c.toProfile.toVendlerClass = c

Converting a Vendler class to a profile and back is identity.

theorem Semantics.Lexical.Verb.Aspect.stateProfile_toClass : stateProfile.toVendlerClass = VendlerClass.state

The canonical state profile maps to the state class.

theorem Semantics.Lexical.Verb.Aspect.activityProfile_toClass : activityProfile.toVendlerClass = VendlerClass.activity

The canonical activity profile maps to the activity class.

theorem Semantics.Lexical.Verb.Aspect.achievementProfile_toClass : achievementProfile.toVendlerClass = VendlerClass.achievement

The canonical achievement profile maps to the achievement class.

theorem Semantics.Lexical.Verb.Aspect.accomplishmentProfile_toClass : accomplishmentProfile.toVendlerClass = VendlerClass.accomplishment

The canonical accomplishment profile maps to the accomplishment class.

def Semantics.Lexical.Verb.Aspect.AspectualProfile.telicize (p : AspectualProfile) : AspectualProfile

Telicize: add a natural endpoint to an atelic predicate.

Equations

• p.telicize = { telicity := Semantics.Lexical.Verb.Aspect.Telicity.telic, duration := p.duration, dynamicity := p.dynamicity }

def Semantics.Lexical.Verb.Aspect.AspectualProfile.atelicize (p : AspectualProfile) : AspectualProfile

Atelicize: remove the natural endpoint (progressive effect).

Equations

• p.atelicize = { telicity := Semantics.Lexical.Verb.Aspect.Telicity.atelic, duration := p.duration, dynamicity := p.dynamicity }

def Semantics.Lexical.Verb.Aspect.AspectualProfile.duratize (p : AspectualProfile) : AspectualProfile

Duratize: stretch a punctual event over time (iterative).

Equations

• p.duratize = { telicity := p.telicity, duration := Semantics.Lexical.Verb.Aspect.Duration.durative, dynamicity := p.dynamicity }

def Semantics.Lexical.Verb.Aspect.AspectualProfile.statify (p : AspectualProfile) : AspectualProfile

Statify: convert to a stative reading.

Equations

• p.statify = { telicity := p.telicity, duration := p.duration, dynamicity := Semantics.Lexical.Verb.Aspect.Dynamicity.stative }

theorem Semantics.Lexical.Verb.Aspect.telicize_activity : activityProfile.telicize.toVendlerClass = VendlerClass.accomplishment

Telicizing an activity yields an accomplishment.

theorem Semantics.Lexical.Verb.Aspect.atelicize_accomplishment : accomplishmentProfile.atelicize.toVendlerClass = VendlerClass.activity

Atelicizing an accomplishment yields an activity.

theorem Semantics.Lexical.Verb.Aspect.duratize_achievement : achievementProfile.duratize.toVendlerClass = VendlerClass.accomplishment

Duratizing an achievement yields an accomplishment.

theorem Semantics.Lexical.Verb.Aspect.telicize_idempotent (p : AspectualProfile) : p.telicize.telicize = p.telicize

Telicize is idempotent.

theorem Semantics.Lexical.Verb.Aspect.atelicize_idempotent (p : AspectualProfile) : p.atelicize.atelicize = p.atelicize

Atelicize is idempotent.

def Semantics.Lexical.Verb.Aspect.AspectualProfile.isHomogeneous (p : AspectualProfile) : Bool

Whether a predicate is homogeneous (has the subinterval property).

Equations

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

theorem Semantics.Lexical.Verb.Aspect.state_is_homogeneous : stateProfile.isHomogeneous = true

States are homogeneous.

theorem Semantics.Lexical.Verb.Aspect.activity_is_homogeneous : activityProfile.isHomogeneous = true

Activities are homogeneous.

theorem Semantics.Lexical.Verb.Aspect.achievement_not_homogeneous : achievementProfile.isHomogeneous = false

Achievements are not homogeneous.

theorem Semantics.Lexical.Verb.Aspect.accomplishment_not_homogeneous : accomplishmentProfile.isHomogeneous = false

Accomplishments are not homogeneous.

theorem Semantics.Lexical.Verb.Aspect.homogeneous_iff_atelic (p : AspectualProfile) : p.isHomogeneous = true ↔ p.toVendlerClass.telicity = Telicity.atelic

Homogeneous iff atelic.

def Semantics.Lexical.Verb.Aspect.VendlerClass.predictsAtomDist : VendlerClass → Bool

Whether a VendlerClass predicts ATOM-DIST_t (@cite{zhao-2025}, Def. 5.3). States satisfy ATOM-DIST_t (distribute over temporal subintervals); dynamic classes do not. Stricter than isHomogeneous: activities are homogeneous but fail ATOM-DIST_t.

• Zhao, Z. (2025). Cross-Linguistic and Cross-Domain Temporal Expressions. NYU dissertation, Ch. 5.

Equations

• Semantics.Lexical.Verb.Aspect.VendlerClass.state.predictsAtomDist = true
• Semantics.Lexical.Verb.Aspect.VendlerClass.activity.predictsAtomDist = false
• Semantics.Lexical.Verb.Aspect.VendlerClass.achievement.predictsAtomDist = false
• Semantics.Lexical.Verb.Aspect.VendlerClass.accomplishment.predictsAtomDist = false

theorem Semantics.Lexical.Verb.Aspect.predictsAtomDist_iff_stative (c : VendlerClass) : c.predictsAtomDist = true ↔ c.dynamicity = Dynamicity.stative

ATOM-DIST_t prediction coincides with stative dynamicity.

theorem Semantics.Lexical.Verb.Aspect.state_predictsAtomDist : VendlerClass.state.predictsAtomDist = true

States predict ATOM-DIST_t holds.

theorem Semantics.Lexical.Verb.Aspect.dynamic_predictsAtomDist_false (c : VendlerClass) (h : c.dynamicity = Dynamicity.dynamic) : c.predictsAtomDist = false

All dynamic classes predict ATOM-DIST_t failure.

theorem Semantics.Lexical.Verb.Aspect.atomDist_implies_homogeneous (c : VendlerClass) (h : c.predictsAtomDist = true) : c.toProfile.isHomogeneous = true

ATOM-DIST_t implies homogeneity (but not vice versa). Activities are homogeneous but do NOT satisfy ATOM-DIST_t — this is Zhao's point: ATOM-DIST_t discriminates states from activities, while the classical subinterval property does not.

theorem Semantics.Lexical.Verb.Aspect.predictsAtomDist_iff_not_dynamic (c : VendlerClass) : c.predictsAtomDist = false ↔ c.dynamicity = Dynamicity.dynamic

ATOM-DIST_t prediction is the negation of dynamicity =.dynamic.