Lexical Rules in HPSG

@cite{pollard-sag-1987} @cite{pollard-sag-1994}

Formalization of valence-changing lexical rules in HPSG.

@cite{mueller-2013} argues that valence-changing operations (passive, resultative, causative) are best analyzed as lexical rules — operations that transform a sign's valence (subj/comps lists) while preserving its head features. This is the HPSG tradition from @cite{pollard-sag-1987}.

Key types

• LexicalRule — a transformation on a sign's valence
• passiveRule — promotes object to subject, optionally adds by-PP
• resultativeRule — adds a result-predicate argument

Key theorems

• passive_preserves_head: passive doesn't change head features
• passive_changes_valence: passive modifies the argument structure

Lexical Rule infrastructure

structure HPSG.LexicalRule : Type

A lexical rule transforms a sign's valence while preserving head features.

Lexical rules operate on the lexical entry before it enters the syntax. They capture generalizations about argument structure alternations (passive, dative shift, resultative, etc.).

• name : String

  Name of the rule

• transformVal : Valence → Valence

  Transform the valence (subj + comps)

• preservesHead : Bool

  Lexical rules preserve head features (Müller's key claim)

def HPSG.applyLexRule (rule : LexicalRule) : Sign → Sign

Apply a lexical rule to a sign, producing a new sign with transformed valence and preserved head features.

Equations

• HPSG.applyLexRule rule (HPSG.Sign.word w ss) = HPSG.Sign.word w { cat := ss.cat, head := ss.head, val := rule.transformVal ss.val, cont := ss.cont, mod := ss.mod }
• HPSG.applyLexRule rule (HPSG.Sign.phrase children ss) = HPSG.Sign.phrase children { cat := ss.cat, head := ss.head, val := rule.transformVal ss.val, cont := ss.cont, mod := ss.mod }

Specific lexical rules

def HPSG.passiveRule : LexicalRule

Passive lexical rule.

Passive promotes the first complement (direct object) to subject position and optionally adds a by-PP to the complement list.

Input: SUBJ ⟨NP⟩, COMPS ⟨NP,...⟩ Output: SUBJ ⟨NP⟩, COMPS ⟨(PP_by),...⟩

Equations

• HPSG.passiveRule = { name := "passive", transformVal := fun (val : HPSG.Valence) => match val.comps with | obj :: rest => { subj := [obj], comps := rest } | [] => val }

def HPSG.resultativeRule : LexicalRule

Resultative lexical rule.

Adds a result predicate argument (AP or PP) to the complement list.

Input: SUBJ ⟨NP⟩, COMPS ⟨NP⟩ (e.g., "hammer the metal") Output: SUBJ ⟨NP⟩, COMPS ⟨NP, AP⟩ (e.g., "hammer the metal flat")

Equations

• HPSG.resultativeRule = { name := "resultative", transformVal := fun (val : HPSG.Valence) => { subj := val.subj, comps := val.comps ++ [UD.UPOS.ADJ] } }

def HPSG.dativeShiftRule : LexicalRule

Dative shift lexical rule.

Transforms prepositional dative to double object construction.

Input: SUBJ ⟨NP⟩, COMPS ⟨NP, PP_to⟩ (e.g., "give a book to Mary") Output: SUBJ ⟨NP⟩, COMPS ⟨NP, NP⟩ (e.g., "give Mary a book")

Equations

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

Key theorems

theorem HPSG.passive_preserves_head (s : Sign) : (applyLexRule passiveRule s).synsem.head = s.synsem.head

Passive preserves head features (Müller's argument for lexical rules).

The passive operation changes argument structure but not the category or head features of the verb. This is why Müller argues passive is lexical rather than phrasal: it doesn't change what projects.

theorem HPSG.passive_changes_valence_transitive (w : Word) (head : HeadFeatures) (subjCat objCat : UD.UPOS) (rest : List UD.UPOS) : have ss := { cat := UD.UPOS.VERB, head := head, val := { subj := [subjCat], comps := objCat :: rest } }; have s := Sign.word w ss; (applyLexRule passiveRule s).synsem.val.subj = [objCat]

Passive changes the valence (specifically, the subject list).

For a transitive verb, passive promotes the object to subject position.

theorem HPSG.resultative_preserves_head (s : Sign) : (applyLexRule resultativeRule s).synsem.head = s.synsem.head

Head features are preserved by all standard lexical rules.

theorem HPSG.same_rule_same_cat (rule : LexicalRule) (s1 s2 : Sign) (h : s1.synsem.cat = s2.synsem.cat) : (applyLexRule rule s1).synsem.cat = (applyLexRule rule s2).synsem.cat

Two signs derived from the same base by the same rule share a category.

This supports Müller's coordination argument: passivized verbs can coordinate because they share a category (both are V).

Iterable Lexical Rules (@cite{mueller-2013} §1)

Müller argues that valence-changing operations must be iterable: Turkish and Lithuanian allow double passivization (personal passive of an impersonal passive). Lexical rules handle this naturally — each application independently transforms valence while preserving head features. Phrasal approaches that unify a core representation with a passive-specific structure cannot iterate this way (§1, pp. 926–927).

theorem HPSG.double_passive_preserves_head (s : Sign) : (applyLexRule passiveRule (applyLexRule passiveRule s)).synsem.head = s.synsem.head

Double passivization preserves head features.

Applying the passive rule twice (as in Turkish double passives, e.g., "Bu şato-da bo-ul-un-ur" = 'One is strangled in this chateau') still preserves the verb's head features.

theorem HPSG.lexrule_chain_preserves_head (rules : List LexicalRule) (s : Sign) : (List.foldl (fun (s' : Sign) (r : LexicalRule) => applyLexRule r s') s rules).synsem.head = s.synsem.head

Any finite chain of lexical rule applications preserves head features.

Each rule independently transforms valence while leaving head features untouched — so the composition of any sequence of rules also preserves head features. This generalizes double passivization to arbitrary combinations of passive, resultative, dative shift, etc.