Documentation

Studies.Snyder2026

Snyder (2026): Numbers as Kinds #

This file formalizes [Sny26]'s Polymorphic Contextualism: the lexical meaning of two is an atomic predicate applying to different countable entities in different contexts, numeral tokens, subkinds of the kind TWO, or TWO itself, and every other meaning of the word derives from it by type-shifting. The rival polymorphic analyses take the lexical meaning to be a numeral, an entity from which the cardinality predicate derives by CARD (Substantivalism), or the cardinality predicate itself, from which the numeral derives by NOM and Rothstein's schematic equation (Adjectivalism). The three analyses are derivation maps from a lexical type through the type-shifters CARD, PM, A, NOM, IOTA and IDENT to the semantic functions of (1) and (76) (PolymorphicAnalysis.path), each of which composes to the function's type (analyses_well_typed); Contextualism derives every function while the two rivals derive none of the token, kind and taxonomic uses (contextualism_covers_all, substantivalism_gap, adjectivalism_gap, contextualism_strictly_extends). Numbers are kinds formed as in [Men20] by a salient equivalence relation on their tokens, here the number system a token belongs to (kfTWO), so distinct subkinds of TWO are disjoint (subkinds_distinct); a close appositive is the Sharvy definite over the conjunction of its two nouns (closeAppositive), and definites over disjoint restrictions of the extension of two refer to distinct subkinds, which dissolves Benacerraf's Identification Problem for (20) (closeAppositive_ne_of_disjoint, identification_problem_resolved). Section 6 extends the analysis to colour words, RED having subkinds such as crimson and maroon (kfRed, red_subkinds_distinct). The examples are rows of Data/Examples/Snyder2026, each of which carries its semantic function, and every function is attested (functions_attested).

Implementation notes #

References #

The three polymorphic analyses and the semantic functions #

Semantic types: entities, predicates and generalized quantifiers.

Instances For
    @[instance_reducible]
    Equations

    The three polymorphic analyses: the lexical meaning of two is a numeral (5), a cardinality predicate (9), or an atomic predicate over relativized atoms (73).

    Instances For
      @[instance_reducible]
      Equations

      The semantic functions of two: the six of (1) and the token, kind and taxonomic uses of (76g) to (76j).

      Instances For
        @[instance_reducible]
        Equations

        The type-shifters of the diagrams: CARD (6a), Predicate Modification (7a), A (8a), NOM (10a), IOTA (74a) and IDENT (17a).

        Instances For
          @[instance_reducible]
          Equations
          def Snyder2026.wellTyped :
          SemTy → List Operator → Option SemTy

          The type a chain of type-shifters reaches from a type, if each composes with the last.

          Equations
          Instances For

            The derivation map of each analysis, the diagrams of sections 2 and 5: the chain of type-shifters from the lexical meaning to a function, or none where the analysis does not derive it. Substantivalism derives the cardinal uses by CARD and the close appositive by IDENT and IOTA; Adjectivalism nominalizes the cardinality predicate for the numeral and passes through it for the close appositive; Contextualism reaches the numeral, kind and token references by IOTA, the taxonomic and token predications by the lexical predicate itself, the cardinal uses through the numeral, and the close appositive by PM with number and IOTA (87).

            Equations
            Instances For

              An analysis covers a function when it derives it.

              Equations
              Instances For
                theorem Snyder2026.analyses_well_typed (a : PolymorphicAnalysis) (sf : SemanticFunction) (ops : List Operator) :
                ops ∈ a.path sf → wellTyped a.lexicalType ops = some sf.targetType

                Every derivation composes from the lexical type to the function's type.

                Substantivalism derives none of the token, kind and taxonomic uses, the problem cases of section 3.

                Contextualism covers whatever either rival covers, and more.

                Numbers as kinds, sections 4 and 5 #

                A kind is formed by partitioning a domain by a salient equivalence relation; TWO is partitioned into the subkinds two-of-the-naturals, two-of-the-integers, two-of-the-rationals and two-of-the-reals by the number system a numeral token belongs to (section 4.3).

                The number systems of the paper's board.

                Instances For
                  @[instance_reducible]
                  Equations

                  A numeral token: the number system it belongs to and an index distinguishing tokens of the same system.

                  Instances For
                    def Snyder2026.instDecidableEqTwoToken.decEq (x✝ x✝¹ : TwoToken) :
                    Decidable (x✝ = x✝¹)
                    Equations
                    Instances For
                      @[reducible, inline]
                      abbrev Snyder2026.kfTWO :
                      Setoid TwoToken

                      The kind formation for TWO: tokens are equivalent when they belong to the same number system, and each class is a subkind of TWO.

                      Equations
                      Instances For
                        theorem Snyder2026.subkinds_distinct {t₁ t₂ : TwoToken} (h : t₁.system ≠ t₂.system) :
                        ⟦t₁⟧ ≠ ⟦t₂⟧

                        Tokens of distinct number systems instantiate distinct subkinds of TWO, the distinctness of twos from different systems that section 3.4 draws from the Disjointness Condition.

                        def Snyder2026.sharvyIota {α : Type u_1} (domain : List α) (P : α → Bool) :
                        Option α

                        Sharvy's definite (16a) over a finite domain: the unique satisfier of the restriction, if there is exactly one.

                        Equations
                        Instances For
                          def Snyder2026.closeAppositive {α : Type u_1} (domain : List α) (n₁ n₂ : α → Bool) :
                          Option α

                          A close appositive (16b): the definite over the conjunction of its two nouns.

                          Equations
                          Instances For
                            theorem Snyder2026.sharvyIota_eq_some_iff {α : Type u_1} {domain : List α} {P : α → Bool} {j : α} :
                            sharvyIota domain P = some j ↔ List.filter P domain = [j]
                            theorem Snyder2026.closeAppositive_ne_of_disjoint {α : Type u_1} {domain : List α} {m₁ m₂ n : α → Bool} {j₁ j₂ : α} (hDisj : ∀ (x : α), ¬(m₁ x = true ∧ m₂ x = true)) (h₁ : closeAppositive domain m₁ n = some j₁) (h₂ : closeAppositive domain m₂ n = some j₂) :
                            j₁ ≠ j₂

                            Close appositives whose first nouns are disjoint refer to distinct entities when both are defined: the modifiers von Neumann ordinal and Zermelo ordinal restrict the extension of two to disjoint subkinds.

                            Membership in the subkind of TWO of a number system.

                            Equations
                            Instances For

                              The board of section 1: one token of two per number system.

                              Equations
                              • One or more equations did not get rendered due to their size.
                              Instances For
                                theorem Snyder2026.closeAppositive_board (s : MathSystem) :
                                (closeAppositive board (inSubkind s) fun (x : TwoToken) => true) = some { system := s, idx := 0 }

                                The close appositive the s number two on the board refers to the token of that system.

                                theorem Snyder2026.identification_problem_resolved {s₁ s₂ : MathSystem} (h : s₁ ≠ s₂) :
                                ∃ (j₁ : TwoToken) (j₂ : TwoToken), (closeAppositive board (inSubkind s₁) fun (x : TwoToken) => true) = some j₁ ∧ (closeAppositive board (inSubkind s₂) fun (x : TwoToken) => true) = some j₂ ∧ j₁ ≠ j₂

                                The Identification Problem dissolved, section 5.2: the close appositives formed with the modifiers of two number systems are both defined on the board and refer to distinct subkinds, so (20a) and (20b) are jointly coherent.

                                Colour words, section 6 #

                                The kind RED has the shades of the paint swatches as subkinds, and the colour word is an atomic predicate over them and their tokens (97).

                                The shades of red on the swatches.

                                Instances For
                                  @[instance_reducible]
                                  Equations

                                  A colour token, a swatch of a shade.

                                  Instances For
                                    def Snyder2026.instDecidableEqRedToken.decEq (x✝ x✝¹ : RedToken) :
                                    Decidable (x✝ = x✝¹)
                                    Equations
                                    Instances For
                                      @[reducible, inline]
                                      abbrev Snyder2026.kfRed :
                                      Setoid RedToken

                                      The kind formation for RED: tokens are equivalent when they are of the same shade.

                                      Equations
                                      Instances For
                                        theorem Snyder2026.red_subkinds_distinct {t₁ t₂ : RedToken} (h : t₁.shade ≠ t₂.shade) :
                                        ⟦t₁⟧ ≠ ⟦t₂⟧

                                        Tokens of distinct shades instantiate distinct subkinds of RED, the taxonomy under (94).

                                        The examples #

                                        theorem Snyder2026.functions_attested (sf : SemanticFunction) :
                                        ∃ ex ∈ Examples.all, ex.feature? "function" = some sf.label

                                        Every semantic function is attested by an example row carrying its label.