Documentation

Linglib.Theories.Syntax.Minimalist.HeadFunction

Head Functions for Minimalist Syntactic Objects (MCB §1.12-§1.13) #

@cite{marcolli-chomsky-berwick-2025}

What MCB say #

Per @cite{marcolli-chomsky-berwick-2025} §1.12 (book pp. 105-108), Externalization is modelled as a section σ_L : 𝔗_{SO_0} → 𝔗^{pl}_{SO_0} of the projection Π : 𝔗^{pl}_{SO_0} → 𝔗_{SO_0} from planar to nonplanar binary rooted trees. The section satisfies Π ∘ σ_L = id and is:

A head function (Def 1.13.6) is a partial map h defined on a subdomain Dom(h) ⊂ 𝔗_{SO_0} that assigns to each T ∈ Dom(h) a function h_T : V^o(T) → L(T) from non-leaf vertices of T to leaves, satisfying coherence: T_v ⊆ T_w ∧ h_T(w) ∈ L(T_v) ⊆ L(T_w) ⟹ h_T(w) = h_T(v) (Def 1.13.3).

Per Lemma 1.13.5, head functions on T are in bijection with planar embeddings of T — under either the harmonic head-initial convention (head daughter to the LEFT) or the harmonic head-final convention (head daughter to the RIGHT). The choice between conventions inverts the bijection.

Encoding #

HeadFunction is a FreeCommMagma.Section (the σ_L part) plus head-side convention (initial vs final per Lemma 1.13.5) plus partial domain (Def 1.13.6):

structure HeadFunction where
  section_  : FreeCommMagma.Section (LIToken ⊕ Nat)
  headSide  : ConventionDir
  Dom       : SyntacticObject → Prop
  decDom    : DecidablePred Dom

The substrate primitive is headAtVertex h T v (MCB Def 1.13.3): the head leaf at vertex v of T. The root special case head h T is derived as headAtVertex h T T.

Per Lemma 1.13.5, the head leaf at vertex v is:

Key definitions #

Out of scope (queued for §1.14+) #

Convention direction (MCB Lemma 1.13.5) #

The harmonic head-side convention. Per @cite{marcolli-chomsky-berwick-2025} Lemma 1.13.5 (book p. 127), head functions on T are in bijection with planar embeddings of T, under one of two equally valid conventions:

  • .initial (harmonic head-initial): the head daughter is to the LEFT of each binary node. The head leaf is the leftmost-leaf of the planar tree. Canonical for English-like analyses.
  • .final (harmonic head-final): the head daughter is to the RIGHT. The head leaf is the rightmost-leaf. Canonical for Japanese/Korean/Turkish.

A head function bundles a planar section + a side convention. Mixed-direction languages (e.g. German with head-final VP and head-initial CP) require a refinement (headSide : Cat → ConventionDir) that is currently out of scope.

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

      A head function in the @cite{marcolli-chomsky-berwick-2025} sense: a planar Externalization (MCB §1.12.1 section σ_L of Π) plus a head-side convention (Lemma 1.13.5) plus a partial domain (Def 1.13.6).

      Per Lemma 1.13.5, the planar embedding chosen by σ_L IS the head function, once a head-side convention is fixed. The head leaf h(T) is the leftmost-leaf (.initial) or rightmost-leaf (.final) of σ_L(T).

      The bundle records:

      • section_: the underlying section σ_L
      • headSide: harmonic head-initial vs head-final
      • Dom: the subdomain on which h is "well defined" linguistically
      • decDom: decidability of Dom membership
      Instances For

        The head leaf token at vertex v of T under head function h (MCB Def 1.13.3).

        Substrate primitive. The root special case head h T := headAtVertex h T T is derived below.

        Under harmonic head-initial (.initial), this is the leftmost-leaf of h.section_.σ v. Under harmonic head-final (.final), the rightmost-leaf.

        Note on the (T, v) signature: per MCB Def 1.13.3, head functions are indexed by the containing tree T and quantify vertices "of T". The T parameter here is currently unused in the body (we descend into v's own representative), but it is load-bearing for the COHERENCE theorem headAtVertex_coherent below, which requires v ⊆ T. This signals "this head reading is about T's structure"; consumer theorems add the v ∈ T.subtrees hypothesis. Section's σ is defined on the whole quotient, so headAtVertex h T v is well-defined for any v; the T-relativity is a documentary constraint enforced by consumers.

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

          The head leaf at the root of T (MCB notation h(T)). Derived from headAtVertex at v = T.

          Equations
          Instances For

            The head's outer categorial feature, when defined.

            Equations
            Instances For

              The head's selectional stack, when defined.

              Equations
              Instances For

                A section is injective; routed through FreeCommMagma.Section.injective which derives via mathlib's Function.LeftInverse.injective.

                The trivial head function: defined only on leaves, where every vertex is its own head. The section choice is irrelevant since the only SOs in Dom are leaves (which have a unique planar representative via the singleton-class structure). Convention is .initial by default (irrelevant on leaves).

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

                  Default head function: harmonic head-initial with planar representative via Quot.out. Defined on all SOs. Use a custom section_ for linguistically-meaningful planar choices.

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

                    Right-headed dual to leftSpine: same Quot.out section, but .final head-side convention. Models a harmonic head-final language (Japanese, Korean, Turkish). Genuinely distinct from leftSpinerightSpine.head returns the rightmost-leaf where leftSpine.head returns the leftmost-leaf of the same planar representative.

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

                      For a leaf SO, headAtVertex returns the leaf token (independent of head function choice — leaves are their own head, and singleton-class structure means the section returns the canonical .of (.inl tok)).

                      Routes through Section.σ_of which absorbs the singleton-class case-analysis once for all consumers.

                      @[simp]

                      For a trace SO, headAtVertex returns the synthetic trace token.

                      @[simp]

                      For a leaf SO, head returns the leaf token. Derived from headAtVertex_leaf at v = T.

                      @[simp]

                      For a trace SO, head returns the synthetic trace token.

                      @[simp]

                      For a leaf SO, outerCat reduces to the leaf token's outer category.

                      @[simp]

                      For a leaf SO, outerSel reduces to the leaf token's outer selectional stack.

                      def Minimalist.leafTokensPlanar :
                      FreeMagma (LIToken )List LIToken

                      Underlying leaf-token enumeration on a planar FreeMagma representative. Used by HeadFunction.leafTokens (parameterized below) and by the coherence theorem statement.

                      Equations
                      Instances For

                        The leaves of so under head function h's planar representative, as a list of LITokens. Computable when h.section_.σ is.

                        Equations
                        Instances For

                          Linearize so under head function h: collect leaf tokens in the left-to-right order of h.section_.σ so. Per @cite{marcolli-chomsky-berwick-2025} book p. 123, "linearization" in linguistics IS planarization (= section choice); the term is reserved for the resulting word ordering on leaves.

                          Equations
                          Instances For

                            Phonological yield of so under head function h: the non-empty phonForm strings of leaves in left-to-right order.

                            Equations
                            Instances For

                              Terminal nodes of so under head function h: the leaf-position SOs of the planar representative, in left-to-right order.

                              Equations
                              Instances For

                                leftmostLeafPlanar fm is always one of the leaves enumerated by leafTokensPlanar fm. Substrate for the §5 coherence proof: when the head leaf of w (= leftmost of σ w) is constrained to appear in σ v's leaves, this lemma anchors what "head leaf appears in v" means.

                                rightmostLeafPlanar fm is always one of the leaves enumerated by leafTokensPlanar fm. Mirror of leftmostLeafPlanar_mem_leafTokens.

                                theorem Minimalist.leafTokensPlanar_mul (l r : FreeMagma (LIToken )) :

                                leafTokensPlanar distributes structurally over mul: by definition.

                                For a section σ, the local-coherence property at T: σ respects binary nodes structurally on T's subtrees (with possible left/right swap).

                                Per @cite{marcolli-chomsky-berwick-2025} §1.12.3 (book p. 116), σ is NOT a magma morphism globally (Lemma 1.13.1), but it can be locally coherent at specific subtrees. This is the property that makes MCB Def 1.13.3 coherence (headAtVertex_coherent below) provable.

                                The leaf-distinctness property (Nodup on planar leaves of σ T), which is also needed for the §5 coherence proof, is supplied as a separate hypothesis to the consumer theorems rather than baked in here — keeping LocallyCoherent purely about σ's structural behavior, decoupled from derivation-specific token uniqueness.

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

                                  Under LocallyCoherent h T, descent into a subtree w ∈ T.subtrees preserves the structural property: LocallyCoherent h w follows by transitivity of subtrees.

                                  theorem Minimalist.σ_leafMultiset_at_mul (h : HeadFunction) {a b : SyntacticObject} (hsplit : h.section_.σ (a * b) = h.section_.σ a * h.section_.σ b h.section_.σ (a * b) = h.section_.σ b * h.section_.σ a) :

                                  Under LocallyCoherent h T, the planar leaves of σ T are a permutation of the planar leaves of σ a followed by those of σ b whenever (a*b) ∈ T.subtrees. This is the multiset-version of the structural decomposition (see also leafTokensPlanar_mul).

                                  Under LocallyCoherent h T, the planar leaf-multiset of any subtree w ⊆ T is ≤ (multiset-wise) the planar leaf-multiset of σ T.

                                  This is the descent lemma that makes the §5 coherence proof tractable: σ on T's subtrees produces leaf-lists whose token-counts are bounded by σ T's leaf-list. Combined with Nodup on σ T's leaves, this gives: (a) Nodup on σ w's leaves for any w ∈ T.subtrees (via Multiset.nodup_of_le); (b) Disjointness of σa's and σb's leaves at any (a*b) ∈ T.subtrees.

                                  Under LocallyCoherent h T with Nodup on σ T's planar leaves, every subtree w ⊆ T also has Nodup planar leaves. Direct corollary of σ_leafMultiset_le_root plus Multiset.nodup_of_le.

                                  theorem Minimalist.σ_leafTokens_disjoint_at_mul (h : HeadFunction) (T : SyntacticObject) (hCoh : h.LocallyCoherent T) (hNodup : (leafTokensPlanar (h.section_.σ T)).Nodup) {a b : SyntacticObject} (hab : a * b T.subtrees) {x : LIToken} (hxa : x leafTokensPlanar (h.section_.σ a)) (hxb : x leafTokensPlanar (h.section_.σ b)) :
                                  False

                                  Under LocallyCoherent h T with Nodup on σ T's planar leaves, the leaf-lists of σa and σb at any (a*b) ∈ T.subtrees are DISJOINT (no shared token). Direct consequence of Nodup on σ(a*b)'s leaves (which decomposes into σa's leaves ++ σb's leaves modulo swap).

                                  theorem Minimalist.HeadFunction.headAtVertex_coherent (h : HeadFunction) (T : SyntacticObject) (hCoh : h.LocallyCoherent T) (hNodup : (leafTokensPlanar (h.section_.σ T)).Nodup) {v w : SyntacticObject} (hw : w T.subtrees) (hvw : v w.subtrees) (hmem : h.headAtVertex T w leafTokensPlanar (h.section_.σ v)) :

                                  @cite{marcolli-chomsky-berwick-2025} Def 1.13.3 coherence: under a head function h on a tree T (locally coherent on T, with planar leaves Nodup), if vertex v is contained in vertex w (both vertices of T) and the head leaf of w appears among the leaves of v, then the head leaves of v and w agree.

                                  Why a Nodup hypothesis is needed: in the swap case σ(ab) = σbσa with v ⊆ a, the head leaf of (a*b) is leftmost(σ b). For it to appear in σ v's leaves (⊆ σ a's leaves), σa and σb would need to share a token. Nodup on σ T's leaves rules this out (via σ_leafTokens_disjoint_at_mul), making the case vacuous.

                                  The Nodup hypothesis is satisfied by any well-formed derivation where each LI is uniquely instantiated (the typical linguistic case).

                                  Proof: structural induction on w.

                                  • Base: w is a leaf/trace; w.subtrees = {w}, so v = w trivially.
                                  • Step: w = ab. By LocallyCoherent, σ(ab) = σaσb or σbσa. Under headSide × swap × v's side (8 cases total): • Head-from-a + v⊆a: apply iha. • Head-from-b + v⊆b: apply ihb. • Head-from-a + v⊆b OR Head-from-b + v⊆a: contradiction via σ_leafTokens_disjoint_at_mul.

                                  @cite{marcolli-chomsky-berwick-2025} Def 1.15.1, clause (i) (the Dom-closure clause):

                                  For any T ∈ Dom(h) and any subtree v ⊂ T such that h(T) = h(T/^d v) (the mover doesn't carry the head of T), the IM result M(v, T/^c v) is in Dom(h), with h(M(v, T/^c v)) = h(T/^d v).

                                  The Dom-membership in the conclusion is a non-trivial closure assertion independent of clause (ii) — Internal Merge preserves the head function's domain in this configuration.

                                  Encoded using Step.im from Derivation.lean. The deletion-quotient T/^d v is T.replace v (mkTrace n); the contraction-quotient T/^c v is the same in our encoding.

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

                                    @cite{marcolli-chomsky-berwick-2025} Def 1.15.1, clause (ii) (the head-equation clause):

                                    For arbitrary T and any subtree v ⊂ T such that both M(v, T/^c v) ∈ Dom(h) and T/^d v ∈ Dom(h), we have h(M(v, T/^c v)) = h(T/^d v).

                                    No Dom-closure claim — just the head equation under both Dom-membership hypotheses.

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

                                      A head function is raising when both Def 1.15.1 clauses hold.

                                      Equations
                                      Instances For

                                        The trivial leafOnly head function satisfies clause (ii) vacuously: the IM result is always a .node, never a leaf, so the Dom (.node ...) precondition fails for leafOnly.Dom = isLeaf.

                                        Note on clause (i) for leafOnly: leafOnly does NOT satisfy clause (i). Counterexample: when T is a leaf and v doesn't occur in T, T.replace v (mkTrace _) = T (no occurrence to replace), so the precondition head T = head (T/^d v) holds vacuously, but the conclusion Dom (.node v T) requires isLeaf (v * T) which is False. leafOnly violates the Dom-closure aspect of clause (i): its domain is not closed under the IM construction.

                                        This is a substantive linguistic fact, not a formalization artifact: Internal Merge always produces a node, but leafOnly only labels leaves. Honest head functions for §1.15.2 Labeling will define Dom to be IM-closed.

                                        @cite{marcolli-chomsky-berwick-2025} Def 1.14.2 (book p. 134): a complemented (abstract) head function h_{T,Z} extends a head function to additionally assign each non-leaf vertex its complement:

                                        h_{T,Z} : V^o(T) → L(T) × (Acc(T) ∪ {1}) h_{T,Z}(v) = (h_T(v), Z_v)

                                        where Z_v ⊂ T_{s_{h_T(v)}} is a (possibly empty) subset of the sister vertex's subtree. The cases:

                                        • Z_v = ∅: head has no complement at v; sister is purely modifier.
                                        • Z_v ≠ ∅: head has complement Z_v at v; remaining sister content is modifier.

                                        "Modifiers" (per MCB book p. 134): structures merged that retain the head's projection — going from T_v to T_{w'} where h_T(w') = h_T(v).

                                        This is the substrate Phase Theory needs (MCB §1.14): the phase edge ∂Φ_ℓ is defined relative to the head's complement Z_v (not its full sister subtree), per Def 1.14.3 step 4-5.

                                        Encoding: extends HeadFunction with complementOf : SO → SO → Option SO indexed by (T, v) pair. Returns none for the empty-complement case, some Z for the non-empty case.

                                        Instances For

                                          The trivial complemented head function: extends leafOnly with complementOf := fun _ _ => none (no complement, since leaves have no complement structure to begin with).

                                          Equations
                                          Instances For

                                            The trivial complemented version of leftSpine: assumes no complement structure beyond the planar embedding (consumers needing complements should supply a custom complementOf).

                                            Equations
                                            Instances For

                                              The complemented version of rightSpine.

                                              Equations
                                              Instances For

                                                @cite{marcolli-chomsky-berwick-2025} Lemma 1.13.4 (book p. 127): there are exactly 2^|V^o(T)| head functions on T, where V^o(T) is the set of non-leaf vertices of T.

                                                Under the externalize-based encoding, head functions on T are in bijection with planar embeddings of T (Lemma 1.13.5), which are in bijection with markings of left/right at each non-leaf vertex.

                                                Statement deferred until Phase 3.B+ when V^o(T) is a properly enumerable substrate primitive (currently Multiset SyntacticObject via T.Acc). The vacuous-True placeholder previously here was deleted as an anti-pattern.