Documentation

Linglib.Phonology.Segmental.Defs

Segmental representation: definitions #

The distinctive feature and the segment built over it. A feature is one of the 26 binary distinctive features of [Hay09]; a segment is a partial specification of those features — each +, , or unspecified — ordered by specificity (the unification-grammar subsumption order, inherited as a feature bundle), with the unspecified archisegment least and natural-class generalization as meet.

This file collects definitions only — the feature inventory, the segment and its valuation/construction/change API, the natural-class predicates, and the sonority scales. The theorems about them live in Phonology/Segmental/Basic.lean.

Feature inventory #

A binary distinctive phonological feature, following [Hay09]'s segmental inventory. (The stress and length features are excluded: [Hay09] treats stress as a syllable-level property, not a segmental feature.)

Instances For
    @[implicit_reducible]
    Equations
    @[implicit_reducible]
    Equations
    def Phonology.instReprFeature.repr :
    FeatureStd.Format
    Equations
    Instances For

      Feature classification #

      The articulator category of a feature: manner/root, laryngeal, or place.

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

          The articulator category of each distinctive feature.

          Equations
          Instances For
            @[reducible, inline]

            Is this a laryngeal feature?

            Equations
            Instances For
              @[reducible, inline]

              Is this a dorsal place feature?

              Equations
              Instances For
                @[reducible, inline]

                Is this a place feature (any articulator node)?

                Equations
                Instances For

                  Enumeration #

                  All features, in declaration order.

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

                    allFeatures is the canonical enumeration: completeness is the Fintype law, not a theorem re-proved beside it.

                    Equations

                    The segment bundle #

                    @[reducible, inline]

                    A segment: a partial specification of the distinctive features — each feature is +, , or left unspecified. Segments are ordered by specificity: one refines another when it agrees on every feature the other commits to, and possibly more. The fully unspecified segment is least; the most specific class common to two segments is their meet.

                    Equations
                    Instances For

                      Valuation #

                      def Phonology.Segment.HasValue (s : Segment) (f : Feature) (v : Bool) :

                      Does feature f have value v?

                      Equations
                      Instances For
                        @[implicit_reducible]
                        instance Phonology.Segment.instDecidableHasValue (s : Segment) (f : Feature) (v : Bool) :
                        Decidable (s.HasValue f v)
                        Equations

                        A segment is unspecified for feature f iff its value there is none.

                        Equations
                        Instances For

                          Construction #

                          def Phonology.Segment.ofSpecs (specs : List (Feature × Bool)) :

                          Build a segment from a list of (feature, value) pairs. Unmentioned features are unspecified (none), giving natural-class semantics: ofSpecs [(continuant, false)] matches all [-cont] segments.

                          Equations
                          Instances For

                            Natural-class predicates #

                            Language-neutral natural-class membership predicates, by the SPE feature decompositions standard since [CH68] and codified in textbook form by [Hay09]. Pure substrate: they project information already encoded in a segment, consumed by per-language Fragment files rather than redefined locally.

                            A segment is a vowel iff it is [+syllabic].

                            Equations
                            Instances For
                              @[implicit_reducible]
                              Equations

                              A segment is a consonant iff it is [+consonantal].

                              Equations
                              Instances For
                                @[implicit_reducible]
                                Equations

                                A segment is an oral stop iff it is [+cons, -son, -cont].

                                Equations
                                Instances For
                                  @[implicit_reducible]
                                  Equations

                                  A segment is a fricative iff it is [+cons, -son, +cont].

                                  Equations
                                  Instances For
                                    @[implicit_reducible]
                                    Equations

                                    A segment is a nasal iff it is [+nasal].

                                    Equations
                                    Instances For
                                      @[implicit_reducible]
                                      Equations

                                      A segment is a liquid iff it is [+cons, +son] and one of [+lateral], [+trill], [+tap] — the lateral /l/, the trill /r/, and the flap /ɾ/ under one class.

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

                                        A segment is a glide iff it is [-cons, -syllabic, +approximant].

                                        Equations
                                        Instances For
                                          @[implicit_reducible]
                                          Equations

                                          Feature changes #

                                          The segment-level operations are thin lifts of the shared Features.Bundle algebra. Three-valued (+ / − / ∅) specification is standard in [Kea88], [IO95], and [Ste95]; fillFromContext is default-fill, preserving existing values per [Kip82] [Arc88], while setFeature overrides. The Latin coda /l/ analysis in [Sen15] is a worked example.

                                          Set feature f to value v, overriding any existing specification (the Features.Bundle.set slot operation). For default-fill semantics that only assign when f is currently unspecified, use fillFromContext.

                                          Equations
                                          Instances For

                                            Categorical feature spreading from context: the target s, when unspecified for f, takes the f-value of ctx; already-specified targets and features other than f are untouched. When ctx is itself unspecified for f, the target stays unspecified.

                                            This is a [Kea88] context rule: the target acquires a categorical feature value from its neighbour and that value blocks further interactions. It is distinct from her gradient phonetic interpolation (her unspecified /h/ example), in which an unspecified segment stays unspecified and the phonetics builds a continuous trajectory through it; gradient phonetic interpolation is out of scope at this categorical-featural substrate.

                                            Equations
                                            Instances For

                                              Sonority #

                                              The abstract sonority hierarchy ([Cle90]): what the synchronic grammar operates on, ordering segments from least to most sonorous.

                                              RankClass
                                              0Stop
                                              1Fricative
                                              2Nasal
                                              3Liquid
                                              4Glide
                                              5Vowel

                                              For the finer 8-level scale that splits obstruents by voice, see Sonority.Class.

                                              Instances For
                                                @[implicit_reducible]
                                                Equations
                                                def Phonology.instReprSonority.repr :
                                                SonorityStd.Format
                                                Equations
                                                Instances For
                                                  @[implicit_reducible]
                                                  Equations

                                                  The sonority of a segment, read off its features ([Hay09], [Cle90]).

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

                                                    The Parker sonority scale #

                                                    The 8-level Parker sonority partition ([Par02]) — a refinement of Sonority that splits obstruents by [±continuant] and [±voice]. This is the sonority scale; it is distinct from the natural-class predicates above (Segment.IsVowel &c.), which are feature membership.

                                                    Crucially [Par02] ranks voiced stops above voiceless fricatives (vds = 3 > vlf = 2) — his intensity-based default universal, reversible in particular languages. The finer granularity is needed for sonority-conditioned gradient phenomena such as Tarifit intrusive vowels ([AZ25b]).

                                                    Instances For
                                                      @[implicit_reducible]
                                                      Equations
                                                      def Phonology.Sonority.instReprClass.repr :
                                                      ClassStd.Format
                                                      Equations
                                                      • One or more equations did not get rendered due to their size.
                                                      Instances For

                                                        Classify a segment on the Parker 8-level scale: as Sonority.ofSegment, but additionally splitting obstruents by [±voice] ([Par02]).

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