Documentation

Studies.Haspelmath2021

Haspelmath (2021): Role-reference associations and the explanation of argument coding splits #

Haspelmath's role-reference association universal (Universal 1, (5)) says that deviations from the usual associations of role rank and referential prominence are coded by longer grammatical forms. RoleReferenceUniversal states it for any usualness relation on situations. Its single-argument instance is SingleArgumentUniversal (Universal 3, whose role instances are Universals 4, 6, 7 and 8), and its scenario instance over Clause.Scenario is ScenarioUniversal (Universal 5, which yields Universals 9b, 10 and 11). Universal 12 reads Universal 1 with the usage rate of the longer alternant of an alternation as the coding, and Universals 13 and 14 are its scenario instances. The explanation of §11.2 is roleReferenceUniversal_of_formFrequency, by which Universal 2 and the form-frequency correspondence universal (68) of Haspelmath's companion paper entail Universal 1.

The coding splits the paper cites are coding-length functions on the prominence scales of (8), checked against the universals and against the paper's own examples (Reproduces), together with the anti-efficient language of §11.3 that the universals exclude.

Implementation notes #

TODO #

References #

Referential prominence scales (8) #

Each scale is a linear order whose greater element is the more prominent. The person scale of (8a), locuphoric above aliophoric, is Person.Class; the definiteness scale of (8b) without its optional specific-indefinite level is Reference.Definiteness, with Eastern Khanty's specific P (37) read at the definite end; the givenness scale is BinaryGivenness; and the focus scale of (8b), background above focus, is the dual of focus marking, Focus.Markᵒᵈ, its more prominent end the unfocused one.

The ternary person scale of (47a) ranks first above second above third, as Person.prominence does through ofPerson; Person.Class is its coarsening at the locuphoric cut.

Instances For
    @[instance_reducible]
    Equations
    @[instance_reducible]
    Equations
    • One or more equations did not get rendered due to their size.
    Equations
    • One or more equations did not get rendered due to their size.
    Instances For

      A person's rank is read off its prominence, so the clusivity-marked firsts rank first.

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

        The nominality scale of (8a) ranks person forms, independent or index, above full nominals; the ternary scale of (49a) is Reference.Nominality.

        Instances For
          @[instance_reducible]
          Equations
          @[instance_reducible]
          Equations
          • One or more equations did not get rendered due to their size.
          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            @[instance_reducible]

            ⊥ = fullNominal, ⊤ = personForm.

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

            The animacy scale of (8a) without its optional animal level, the ternary Animacy cut at the animates.

            Instances For
              @[instance_reducible]
              Equations
              @[instance_reducible]
              Equations
              • One or more equations did not get rendered due to their size.
              Equations
              • One or more equations did not get rendered due to their size.
              Instances For
                @[instance_reducible]

                ⊥ = inanimate, ⊤ = animate.

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

                Cutoff splits #

                A coding split codes the values of a scale on one side of a cutoff specially, the coding length 1 there and 0 elsewhere.

                def Haspelmath2021.atLeast {α : Type u_1} [LinearOrder α] (x y : α) :
                ℕ

                The split that codes the values from x up specially is 1 at and above the cutoff and 0 below it.

                Equations
                Instances For
                  def Haspelmath2021.below {α : Type u_1} [LinearOrder α] (x y : α) :
                  ℕ

                  The split that codes the values below x specially is 1 below the cutoff and 0 at and above it.

                  Equations
                  Instances For
                    theorem Haspelmath2021.atLeast_monotone {α : Type u_1} [LinearOrder α] (x : α) :
                    Monotone (atLeast x)
                    theorem Haspelmath2021.below_antitone {α : Type u_1} [LinearOrder α] (x : α) :
                    Antitone (below x)

                    Scenarios (10), (11) #

                    def Haspelmath2021.Scenario.MoreUsual {α : Type u_1} [LinearOrder α] (s t : Clause.Scenario α) :

                    s is a more usual scenario than t under the tendencies (11).

                    Equations
                    Instances For
                      @[reducible, inline]
                      abbrev Haspelmath2021.Monadic {α : Type u_1} {L : Type u_2} (coargument : Clause.Scenario α → α) (c : Clause.Scenario α → L) :

                      A scenario split is monadic (fn. 18) when only the prominence coargument s of the coargument decides the coding; a dyadic split is one that is monadic in neither argument.

                      Equations
                      Instances For
                        @[instance_reducible]
                        instance Haspelmath2021.instDecidableMonadicOfForallForallForallEq {α : Type u_1} {L : Type u_2} (coargument : Clause.Scenario α → α) (c : Clause.Scenario α → L) [i : Decidable (∀ (s t : Clause.Scenario α), coargument s = coargument t → c s = c t)] :
                        Decidable (Monadic coargument c)
                        Equations
                        @[reducible, inline]
                        abbrev Haspelmath2021.Relative {α : Type u_1} {L : Type u_2} [LinearOrder α] (c : Clause.Scenario α → L) :

                        A scenario split is relative (§8) when the relation between the prominence levels of the two arguments determines the coding. On a binary scale this admits the dyadic splits of Yurok's type, which fn. 20 allows are "just like" Kashmiri's.

                        Equations
                        Instances For
                          @[instance_reducible]
                          instance Haspelmath2021.instDecidableRelativeOfForallForallForallEq {α : Type u_1} {L : Type u_2} [LinearOrder α] (c : Clause.Scenario α → L) [i : Decidable (∀ (s t : Clause.Scenario α), s.kind = t.kind → c s = c t)] :
                          Decidable (Relative c)
                          Equations
                          theorem Haspelmath2021.relative_comp_kind {α : Type u_1} {L : Type u_2} [LinearOrder α] (g : Clause.Scenario.Kind → L) :

                          A split that is a function of the kind is relative.

                          Universal 1 and its instances #

                          def Haspelmath2021.RoleReferenceUniversal {S : Type u_1} {L : Type u_2} [Preorder L] (r : S → S → Prop) (c : S → L) :

                          Universal 1 (5) says that a situation more usual under r is never coded longer by c.

                          Equations
                          Instances For
                            @[instance_reducible]
                            instance Haspelmath2021.instDecidableRoleReferenceUniversalOfForallForallForallLe {S : Type u_1} {L : Type u_2} [Preorder L] (r : S → S → Prop) (c : S → L) [i : Decidable (∀ (s t : S), r s t → c s ≤ c t)] :
                            Decidable (RoleReferenceUniversal r c)
                            Equations
                            theorem Haspelmath2021.RoleReferenceUniversal.mono {S : Type u_1} {L : Type u_2} [Preorder L] {r r' : S → S → Prop} {c : S → L} (hr : r ≤ r') (h : RoleReferenceUniversal r' c) :

                            Universal 1 for a usualness relation holds for every relation it contains.

                            def Haspelmath2021.FormFrequencyCorrespondence {S : Type u_1} {L : Type u_2} {F : Type u_3} [Preorder L] [Preorder F] (freq : S → F) (c : S → L) :

                            The grammatical form-frequency correspondence universal (68) says that a pattern more frequent under freq is never coded longer by c.

                            Equations
                            Instances For
                              def Haspelmath2021.UsualIsFrequent {S : Type u_1} {F : Type u_3} [Preorder F] (r : S → S → Prop) (freq : S → F) :

                              Universal 2 (6) says that the association more usual under r is the more frequent one in language use.

                              Equations
                              Instances For
                                theorem Haspelmath2021.roleReferenceUniversal_of_formFrequency {S : Type u_1} {L : Type u_2} {F : Type u_3} [Preorder L] [Preorder F] {r : S → S → Prop} {freq : S → F} {c : S → L} (hu : UsualIsFrequent r freq) (h : FormFrequencyCorrespondence freq c) :

                                Universal 1 follows from Universal 2 and the form-frequency correspondence universal (68), which is Universal 1 for the relation of being more frequent (§11.2).

                                def Haspelmath2021.SingleArgumentUniversal {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] (r : ArgumentRole) (c : α → L) :

                                Universal 3 (13), the single-argument flagging universal, is Universal 1 for the usual associations ArgumentRole.MoreUsualFor of the role r in (9), which are vacuous for S.

                                Equations
                                Instances For
                                  @[instance_reducible]
                                  instance Haspelmath2021.instDecidableSingleArgumentUniversalOfForallForallForallMoreUsualForLe {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] (r : ArgumentRole) (c : α → L) [i : Decidable (∀ (x y : α), r.MoreUsualFor x y → c x ≤ c y)] :
                                  Decidable (SingleArgumentUniversal r c)
                                  Equations
                                  theorem Haspelmath2021.singleArgumentUniversal_iff_antitone {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] {r : ArgumentRole} (h : r.IsHighDefault) {c : α → L} :
                                  SingleArgumentUniversal r c ↔ Antitone c

                                  For A and R, Universal 3 says the coding is longer for the less prominent argument, which is Universal 6 (21) and Universal 7 (26).

                                  theorem Haspelmath2021.singleArgumentUniversal_iff_monotone {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] {r : ArgumentRole} (h : r.IsLowDefault) {c : α → L} :
                                  SingleArgumentUniversal r c ↔ Monotone c

                                  For P and T, Universal 3 says the coding is longer for the more prominent argument, which is Universal 4 (14) and Universal 8 (27).

                                  def Haspelmath2021.ScenarioUniversal {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] (c : Clause.Scenario α → L) :

                                  Universal 5 (16), the scenario universal, says that coding is longest for upstream, shortest for downstream and intermediate for balanced scenarios. Universal 10 (54) is its restriction to Relative splits, with the same prediction.

                                  Equations
                                  Instances For
                                    @[instance_reducible]
                                    instance Haspelmath2021.instDecidableScenarioUniversalOfForallForallForallLtLe {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] (c : Clause.Scenario α → L) [i : Decidable (∀ (s t : Clause.Scenario α), t.kind < s.kind → c s ≤ c t)] :
                                    Decidable (ScenarioUniversal c)
                                    Equations
                                    theorem Haspelmath2021.ScenarioUniversal.downstream_le {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] {c : Clause.Scenario α → L} (h : ScenarioUniversal c) {s t : Clause.Scenario α} (hs : s.kind = Clause.Scenario.Kind.downstream) (ht : t.kind ≠ Clause.Scenario.Kind.downstream) :
                                    c s ≤ c t

                                    Under Universal 5 a downstream scenario is coded no longer than any scenario that is not downstream.

                                    theorem Haspelmath2021.scenarioUniversal_iff_antitone {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] [BoundedOrder α] [IsSimpleOrder α] {c : Clause.Scenario α → L} :
                                    ScenarioUniversal c ↔ Antitone c

                                    On a binary scale Universal 5 says that coding is antitone in the order of scenarios, since there one scenario is of a more usual kind than another exactly when it lies above it.

                                    theorem Haspelmath2021.scenarioUniversal_comp_high {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] [BoundedOrder α] [IsSimpleOrder α] {f : α → L} (hf : Antitone f) :

                                    On a binary scale, a split monadic in the higher-ranked argument and antitone in its prominence obeys Universal 5, so it is coded longest at the upstream ⟨⊥, ⊤⟩ and shortest at the downstream ⟨⊤, ⊥⟩.

                                    theorem Haspelmath2021.ScenarioUniversal.comp_high_le {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] {f : α → L} (h : ScenarioUniversal (f ∘ Clause.Scenario.high)) {a b c : α} (hab : a < b) (hbc : b < c) (x y : α) :
                                    f x ≤ f y

                                    On a scale with three levels, a split monadic in the higher-ranked argument obeys Universal 5 only if it is constant, since a balanced scenario is coded no longer than an upstream one at the middle level and no shorter than a downstream one there.

                                    theorem Haspelmath2021.ScenarioUniversal.comp_low_le {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] {g : α → L} (h : ScenarioUniversal (g ∘ Clause.Scenario.low)) {a b c : α} (hab : a < b) (hbc : b < c) (x y : α) :
                                    g x ≤ g y

                                    On a scale with three levels, a split monadic in the lower-ranked argument obeys Universal 5 only if it is constant.

                                    theorem Haspelmath2021.scenarioUniversal_comp_low {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] [BoundedOrder α] [IsSimpleOrder α] {g : α → L} (hg : Monotone g) :

                                    On a binary scale, a split monadic in the lower-ranked argument and monotone in its prominence obeys Universal 5.

                                    Universal 9b (42), the ditransitive person-role universal, says that the scenario with a locuphoric R and an aliophoric T is coded no longer than any other.

                                    Equations
                                    Instances For

                                      Universal 9b is a special case of Universal 5 (§7.1).

                                      def Haspelmath2021.InverseUniversal {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] (v : Clause.Scenario α → L) :

                                      Universal 11 (57), the inverse universal, says that under the verb coding v the inverse form of an upstream scenario is no shorter than the direct form of a downstream one.

                                      Equations
                                      Instances For
                                        theorem Haspelmath2021.inverseUniversal_of_scenarioUniversal {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] {v : Clause.Scenario α → L} (h : ScenarioUniversal v) :

                                        Verb coding that obeys the scenario universal obeys the inverse universal.

                                        Universals 13 (62) and 14 (63) say that across the givenness scenarios of A and P, or of R and T, the usage rate rate of the longer alternant, the passive or the dative, is lowest when the higher-ranked argument is given and the lower-ranked one new.

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

                                          Universals 13 and 14 are special cases of the alternation universal (61), Universal 5 read with the usage rate of the longer alternant as its coding (§10.1).

                                          def Haspelmath2021.SplittingAlternation {α : Type u_4} (short long : Clause.Scenario α → Prop) :

                                          A shorter and a longer construction form a splitting alternation (§10.2) when they alternate in some scenarios and are in complementary distribution in others.

                                          Equations
                                          Instances For
                                            @[instance_reducible]
                                            instance Haspelmath2021.instDecidableSplittingAlternationOfAndExistsScenarioXor {α : Type u_4} (short long : Clause.Scenario α → Prop) [i : Decidable ((∃ (s : Clause.Scenario α), short s ∧ long s) ∧ ∃ (s : Clause.Scenario α), Xor (short s) (long s))] :
                                            Decidable (SplittingAlternation short long)
                                            Equations
                                            def Haspelmath2021.minimalCoding {α : Type u_4} (short : Clause.Scenario α → Prop) [DecidablePred short] (s : Clause.Scenario α) :
                                            ℕ

                                            The shortest coding available in a scenario is 0 where the shorter construction is available and 1 otherwise.

                                            Equations
                                            Instances For

                                              Cutoff splits #

                                              The cited splits are cutoffs on a scale (atLeast x, below x); a scenario split is a cutoff on one argument's prominence or on the kind.

                                              theorem Haspelmath2021.singleArgumentUniversal_atLeast {α : Type u_4} [LinearOrder α] {r : ArgumentRole} (h : r.IsLowDefault) (x : α) :

                                              A P or T split from a cutoff up obeys Universal 3, hence Universals 4 and 8.

                                              theorem Haspelmath2021.singleArgumentUniversal_below {α : Type u_4} [LinearOrder α] {r : ArgumentRole} (h : r.IsHighDefault) (x : α) :

                                              An A or R split below a cutoff obeys Universal 3, hence Universals 6 and 7.

                                              theorem Haspelmath2021.scenarioUniversal_comp_kind {L : Type u_2} [Preorder L] {α : Type u_4} [LinearOrder α] {g : Clause.Scenario.Kind → L} (hg : Antitone g) :

                                              A relative split antitone in usualness obeys Universal 5, hence Universal 10.

                                              Single-argument splits (§4, §5) #

                                              Sakha flags a definite P with the accusative, as in (2); Punjabi's nũũ (18) is alike.

                                              Equations
                                              Instances For

                                                Nuorese Sardinian flags a human P with a, as in (17).

                                                Equations
                                                Instances For

                                                  Persian flags a topical P with -râ, as in (19).

                                                  Equations
                                                  Instances For

                                                    Abruzzese flags a locuphoric P with a, as in (20).

                                                    Equations
                                                    Instances For

                                                      English distinguishes P from A only on person forms (he ~ him, §4.1.3), a split in indexes rather than flags, which fn. 12 allows may have a different explanation.

                                                      Equations
                                                      Instances For

                                                        Godoberi has an ergative form only for aliophoric A, as in (22); Kham (1) is alike.

                                                        Equations
                                                        Instances For

                                                          Warrgamay flags a full-nominal A with the ergative, as in (23).

                                                          Equations
                                                          Instances For

                                                            Mangarrayi flags an inanimate (neuter) A with the ergative, as in (24).

                                                            Equations
                                                            Instances For

                                                              Read through the cut, Mangarrayi's split is the split below the animates of the ternary scale, humans and animals alike escaping the ergative.

                                                              Central Tibetan flags a focused A with the ergative -ki', as in (25).

                                                              Equations
                                                              Instances For

                                                                French dative clitics are longer than accusative ones only for aliophoric R, as in (28) (lui le, leur les); they are person indexes, so fn. 17 keeps the case outside split flagging proper.

                                                                Equations
                                                                Instances For

                                                                  Telkepe Neo-Aramaic flags a full-nominal R with ta, as in (29).

                                                                  Equations
                                                                  Instances For

                                                                    Yakkha puts an inanimate R in the locative, as in (30).

                                                                    Equations
                                                                    Instances For

                                                                      Wolof flags an indefinite R with ci, as in (31).

                                                                      Equations
                                                                      Instances For

                                                                        Ewe flags a person-form T with the serial verb tsɔ́, as in (32).

                                                                        Equations
                                                                        Instances For

                                                                          Akan flags a definite T with the serial verb de, as in (33).

                                                                          Equations
                                                                          Instances For

                                                                            Georgian requires the reinforced form (šeni tavi) for a locuphoric T, as in (34).

                                                                            Equations
                                                                            Instances For

                                                                              Scenario splits (§6, §7) #

                                                                              Kolyma Yukaghir flags P with the accusative when A is aliophoric, as in (35); Teop's object marker ben- (3) is alike.

                                                                              Equations
                                                                              Instances For

                                                                                Yurok flags P with the accusative when A is aliophoric and P locuphoric (§6.1).

                                                                                Equations
                                                                                Instances For

                                                                                  Sahaptin flags A with the ergative when P is locuphoric, as in (36).

                                                                                  Equations
                                                                                  Instances For

                                                                                    Eastern Khanty flags A with the ergative when P is specific, as in (37).

                                                                                    Equations
                                                                                    Instances For

                                                                                      Spanish flags P with a when the construction is not animacy-downstream, as in (38), which subsumes the human P of §4.1.1.

                                                                                      Equations
                                                                                      Instances For

                                                                                        Bulgarian flags R with na when T is a locuphoric clitic, as in (39).

                                                                                        Equations
                                                                                        Instances For

                                                                                          Shambala flags R with kwa when T is locuphoric, as in (40).

                                                                                          Equations
                                                                                          Instances For

                                                                                            English requires to on R in the N > pers scenario, as in (4).

                                                                                            Equations
                                                                                            Instances For

                                                                                              The American varieties of English require to on R whenever T is a person form, as in (44).

                                                                                              Equations
                                                                                              Instances For

                                                                                                Modern Greek has the T proclitic in downstream and aliophoric balanced scenarios and the independent pronoun otherwise, so whenever T is locuphoric, as in (45).

                                                                                                Equations
                                                                                                Instances For

                                                                                                  The monotransitive scenario splits obey Universal 5 (§6); the monadic ones by fn. 18 on a binary scale, Spanish as a relative split, the dyadic Yurok by inspection.

                                                                                                  Bulgarian's split of (39) obeys Universal 9b.

                                                                                                  Kolyma Yukaghir's and Greek's rules on the ternary person scale are antitone in the order of scenarios, as the binary rules are.

                                                                                                  Kolyma Yukaghir's rule on the ternary person scale, P flagged whenever A is third person, violates Universal 5, as every non-constant monadic split on a ternary scale does (ScenarioUniversal.comp_high_le).

                                                                                                  Modern Greek's rule on the ternary person scale (47a) violates Universal 5 likewise, since the downstream 1 > 2 is coded longer than the balanced 3 > 3.

                                                                                                  Relative scenario splits (§8) #

                                                                                                  Kashmiri puts P in the dative unless A outranks P on the ternary person scale, as in (47).

                                                                                                  Equations
                                                                                                  Instances For

                                                                                                    Fore flags A with the ergative only when P outranks A in animacy (§8).

                                                                                                    Equations
                                                                                                    Instances For

                                                                                                      Awtuw flags P with the accusative only when P is not lower than A in animacy (§8).

                                                                                                      Equations
                                                                                                      Instances For

                                                                                                        Baule flags T with the serial verb fà unless R outranks T on the scale of (49a), as in (49).

                                                                                                        Equations
                                                                                                        Instances For

                                                                                                          Kashmiri's full probe ranks a person by the segments it bears, one more than its rank on the ternary person scale.

                                                                                                          Kashmiri's dative P of (47) falls on the scenarios that the cyclic Agree of [BR09] makes inverse, where their Table 11 puts the internal argument in R-Case, so the relative split and the failed licensing of the external argument pick out the same scenarios, those that are not downstream on the person scale, by which the full probe ranks persons.

                                                                                                          The relative scenario splits are relative and obey Universal 10 (§8).

                                                                                                          Kolyma Yukaghir's monadic split is not relative, since the two balanced person scenarios are coded differently (§8).

                                                                                                          Verbal voice coding (§9) #

                                                                                                          Itonama's inverse prefix k'i- appears in upstream scenarios, as in (55).

                                                                                                          Equations
                                                                                                          Instances For

                                                                                                            Itonama's inverse of (55) obeys the inverse universal.

                                                                                                            Makassarese requires the applicative -ang on the verb for a definite T, as in (56).

                                                                                                            Equations
                                                                                                            Instances For

                                                                                                              Makassarese requires the applicative -ang on the verb for a person-form T, as in (56c).

                                                                                                              Equations
                                                                                                              Instances For

                                                                                                                Splitting alternations (§10.2) #

                                                                                                                Lummi's active construction is available unless the scenario is upstream, as (64) and (65) show.

                                                                                                                Equations
                                                                                                                Instances For

                                                                                                                  Lummi's passive construction of (64) and (65) is available when A is a full nominal, the common condition of the obligatory (64c) and optional (65b) passives.

                                                                                                                  Equations
                                                                                                                  Instances For

                                                                                                                    Koyra Chiini's double object construction is available only in downstream scenarios, as (66) and (67) show; the postpositional dative construction is always available.

                                                                                                                    Equations
                                                                                                                    Instances For

                                                                                                                      The English double object construction is available except in the N > pers scenario, as (4) and (60) show; the prepositional dative construction is always available.

                                                                                                                      Equations
                                                                                                                      Instances For
                                                                                                                        @[instance_reducible]
                                                                                                                        Equations
                                                                                                                        • One or more equations did not get rendered due to their size.

                                                                                                                        The anti-efficient language (§11.3) #

                                                                                                                        The hypothetical language flags the usual associations and leaves the rare ones bare, so it has less potential ambiguity than the attested mirror image; its non-existence is the paper's argument that efficient coding, not ambiguity avoidance, explains the splits.

                                                                                                                        The hypothetical language of §11.3 puts the ergative on every topical A and zero coding on a focused A.

                                                                                                                        Equations
                                                                                                                        Instances For

                                                                                                                          The hypothetical language of §11.3 puts the accusative on every indefinite P and zero coding on a definite P.

                                                                                                                          Equations
                                                                                                                          Instances For

                                                                                                                            The unattested anti-efficient language violates Universals 6 and 4 (§11.3).

                                                                                                                            The paper's examples #

                                                                                                                            Each cited system is checked against the rows of its language: every row reads to a prominence value or scenario on the system's scale, and the coding the row shows is acceptable exactly when it is the coding the system requires, or, for a splitting alternation, when the construction shown is available in the row's scenario.

                                                                                                                            def Haspelmath2021.codingShown (e : Datum) :
                                                                                                                            Option ℕ

                                                                                                                            The coding an example shows is 0 for zero coding and 1 for the special coding.

                                                                                                                            Equations
                                                                                                                            Instances For
                                                                                                                              def Haspelmath2021.rows (lang role scale : String) :
                                                                                                                              List Datum

                                                                                                                              The rows on the split of role role on scale scale in the language with glottocode lang.

                                                                                                                              Equations
                                                                                                                              • One or more equations did not get rendered due to their size.
                                                                                                                              Instances For
                                                                                                                                def Haspelmath2021.prominence? {α : Type u_1} (table : List (String × α)) (e : Datum) :
                                                                                                                                Option α

                                                                                                                                The prominence value of a single-argument row, read through table.

                                                                                                                                Equations
                                                                                                                                Instances For
                                                                                                                                  def Haspelmath2021.splitGt :
                                                                                                                                  List Char → Option (List Char × List Char)

                                                                                                                                  The two sides of X > Y, by a structural scan so that decide can evaluate it.

                                                                                                                                  Equations
                                                                                                                                  Instances For
                                                                                                                                    def Haspelmath2021.scenario? {α : Type u_1} (table : List (String × α)) (e : Datum) :
                                                                                                                                    Option (Clause.Scenario α)

                                                                                                                                    The scenario X > Y of a scenario row, its sides read through table.

                                                                                                                                    Equations
                                                                                                                                    • One or more equations did not get rendered due to their size.
                                                                                                                                    Instances For
                                                                                                                                      def Haspelmath2021.Reproduces {α : Type u_1} (rs : List Datum) (x? : Datum → Option α) (c : α → ℕ) :

                                                                                                                                      The rows rs reproduce the split c on the values x? reads off them when each row reads to a value at which the coding it shows is acceptable exactly when it is the coding c requires.

                                                                                                                                      Equations
                                                                                                                                      Instances For
                                                                                                                                        @[instance_reducible]
                                                                                                                                        instance Haspelmath2021.instDecidableReproduces {α : Type u_1} (rs : List Datum) (x? : Datum → Option α) (c : α → ℕ) :
                                                                                                                                        Decidable (Reproduces rs x? c)
                                                                                                                                        Equations
                                                                                                                                        def Haspelmath2021.ReproducesAlternation {α : Type u_1} (rs : List Datum) (s? : Datum → Option (Clause.Scenario α)) (short long : Clause.Scenario α → Prop) [DecidablePred short] [DecidablePred long] :

                                                                                                                                        The rows rs reproduce the alternation between short and long when a row showing zero coding is acceptable exactly when the shorter construction is available in its scenario, and one showing the special coding exactly when the longer one is.

                                                                                                                                        Equations
                                                                                                                                        • One or more equations did not get rendered due to their size.
                                                                                                                                        Instances For
                                                                                                                                          @[instance_reducible]
                                                                                                                                          instance Haspelmath2021.instDecidableReproducesAlternation {α : Type u_1} (rs : List Datum) (s? : Datum → Option (Clause.Scenario α)) (short long : Clause.Scenario α → Prop) [DecidablePred short] [DecidablePred long] :
                                                                                                                                          Decidable (ReproducesAlternation rs s? short long)
                                                                                                                                          Equations

                                                                                                                                          The person tags of the rows, as the binary scale.

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

                                                                                                                                            The person tags of the rows, as the ternary scale.

                                                                                                                                            Equations
                                                                                                                                            Instances For

                                                                                                                                              The nominality tags of the rows.

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

                                                                                                                                                The animacy tags of the rows, as the binary scale.

                                                                                                                                                Equations
                                                                                                                                                Instances For

                                                                                                                                                  The animacy tags of the rows, as the ternary scale.

                                                                                                                                                  Equations
                                                                                                                                                  Instances For

                                                                                                                                                    The definiteness tags of the rows.

                                                                                                                                                    Equations
                                                                                                                                                    • One or more equations did not get rendered due to their size.
                                                                                                                                                    Instances For
                                                                                                                                                      def Haspelmath2021.focusTable :
                                                                                                                                                      List (String × Focus.Markᵒᵈ)

                                                                                                                                                      The focus tags of the rows lie on the focus scale of (8b), which ranks background above focus as the dual of the focus-marking order.

                                                                                                                                                      Equations
                                                                                                                                                      Instances For

                                                                                                                                                        The nominal-type tags of the rows.

                                                                                                                                                        Equations
                                                                                                                                                        Instances For
                                                                                                                                                          theorem Haspelmath2021.rows_splitP_splitA :
                                                                                                                                                          Reproduces (rows "yaku1245" "P" "definiteness") (prominence? Definiteness.table) sakhaP ∧ Reproduces (rows "nuor1238" "P" "animacy") (prominence? Animacy.table) sardinianP ∧ Reproduces (rows "panj1256" "P" "definiteness") (prominence? Definiteness.table) sakhaP ∧ Reproduces (rows "west2369" "P" "givenness") (prominence? BinaryGivenness.table) persianP ∧ Reproduces (rows "neap1235" "P" "person") (prominence? Person.Class.table) abruzzeseP ∧ Reproduces (rows "taka1261" "A" "person") (prominence? Person.Class.table) godoberiA ∧ Reproduces (rows "warr1255" "A" "nominality") (prominence? BinaryNominality.table) warrgamayA ∧ Reproduces (rows "mang1381" "A" "animacy") (prominence? BinaryAnimacy.table) mangarrayiA ∧ Reproduces (rows "cent2346" "A" "focus") (prominence? focusTable) tibetanA

                                                                                                                                                          The single-argument P and A splits of §4.1 and §4.2 reproduce the paper's examples, the Punjabi and Kham rows those of the Sakha and Godoberi rules they share.

                                                                                                                                                          theorem Haspelmath2021.rows_splitR_splitT :
                                                                                                                                                          Reproduces (rows "telk1238" "R" "nominality") (prominence? BinaryNominality.table) neoAramaicR ∧ Reproduces (rows "yakk1236" "R" "animacy") (prominence? BinaryAnimacy.table) yakkhaR ∧ Reproduces (rows "nucl1347" "R" "definiteness") (prominence? Definiteness.table) wolofR ∧ Reproduces (rows "ewee1241" "T" "nominality") (prominence? BinaryNominality.table) eweT ∧ Reproduces (rows "akan1250" "T" "definiteness") (prominence? Definiteness.table) akanT ∧ Reproduces (rows "nucl1302" "T" "person") (prominence? Person.Class.table) georgianT ∧ Reproduces (rows "maka1311" "T" "definiteness") (prominence? Definiteness.table) makassarV ∧ Reproduces (rows "maka1311" "T" "nominality") (prominence? BinaryNominality.table) makassarVNominality

                                                                                                                                                          The single-argument R and T splits of §5 and Makassarese's verb coding of §9 reproduce the paper's examples.

                                                                                                                                                          theorem Haspelmath2021.rows_scenario :
                                                                                                                                                          Reproduces (rows "teop1238" "P" "person") (scenario? Person.Class.table) yukaghirP ∧ Reproduces (rows "sout2750" "P" "person") (scenario? Person.Class.table) yukaghirP ∧ Reproduces (rows "saha1240" "A" "person") (scenario? Person.Class.table) sahaptinA ∧ Reproduces (rows "east2774" "A" "definiteness") (scenario? Definiteness.table) khantyA ∧ Reproduces (rows "stan1288" "P" "animacy") (scenario? Animacy.table) spanishP ∧ Reproduces (rows "bulg1262" "R" "person") (scenario? Person.Class.table) bulgarianR ∧ Reproduces (rows "sham1280" "R" "person") (scenario? Person.Class.table) shambalaR ∧ Reproduces (List.filter (fun (x : Datum) => decide (x.feature? "variety" = none)) (rows "stan1293" "R" "nominality")) (scenario? BinaryNominality.table) englishR ∧ Reproduces (List.filter (fun (x : Datum) => decide (x.feature? "variety" = some "American")) (rows "stan1293" "R" "nominality")) (scenario? BinaryNominality.table) americanEnglishR ∧ Reproduces (rows "mode1248" "T" "person") (scenario? Person.Class.table) greekT ∧ Reproduces (rows "icel1247" "R" "animacy") (scenario? BinaryAnimacy.table) icelandicR ∧ Reproduces (rows "kash1277" "P" "person") (scenario? PersonRank.table) kashmiriP ∧ Reproduces (rows "baou1238" "T" "nominal type") (scenario? Nominality.table) bauleT ∧ Reproduces (rows "iton1250" "verb" "person") (scenario? Person.Class.table) itonamaV

                                                                                                                                                          The scenario splits of §6 and §7 and Itonama's inverse of §9 reproduce the paper's examples; the Teop rows reproduce those of the Yukaghir rule, and the rows of (43) and (44) are the American varieties'.

                                                                                                                                                          theorem Haspelmath2021.rows_alternations :
                                                                                                                                                          ReproducesAlternation (rows "lumm1243" "A" "nominality") (scenario? BinaryNominality.table) lummiActive lummiPassive ∧ (ReproducesAlternation (rows "koyr1240" "R" "nominality") (scenario? BinaryNominality.table) koyraChiiniDoubleObject fun (x : Clause.Scenario BinaryNominality) => True) ∧ ReproducesAlternation (List.filter (fun (x : Datum) => decide (x.feature? "variety" = none)) (rows "stan1293" "R" "nominality")) (scenario? BinaryNominality.table) englishDoubleObject fun (x : Clause.Scenario BinaryNominality) => True

                                                                                                                                                          The splitting alternations of §10.2 and (4) reproduce the paper's examples.