Documentation

Linglib.Syntax.Minimalist.Merge.Basic

The Merge operator on workspaces #

The Merge operator of Marcolli, Chomsky and Berwick (their Definition 1.3.4) acts on the workspace algebra ConnesKreimer R (UnorderedTree α). For a pair S, S' of accessible terms,

M_{S,S'} = ⊔ ∘ (B ⊗ id) ∘ δ_{S,S'} ∘ Δ,

where Δ is a coproduct extracting accessible terms, δ_{S,S'} keeps the terms whose left channel is the forest {S, S'} (Definition 1.3.1), B grafts that forest under a new root (Definition 1.3.2), and ⊔ multiplies the two channels back into one workspace. Only Δ depends on how accessible terms are cut out, so the operator is defined over an arbitrary cut enumeration cuts (mergeOpG), with the pruning instance mergeOp and the trace instance mergeOpC. The unit stage M_{β,1} of Internal Merge (Proposition 1.4.2) has no grafting step (mergeOpUnitG).

On a workspace F, Merge grafts {S, S'} beside the trunk of each forest cut of F whose crown is {S, S'}, summed over all such cuts (mergeOpG_apply_of', the book's (1.3.11)). Each form of Merge in their §1.4 is this sum on a particular workspace.

External, Internal and Sideward Merge are in Merge/External.lean, Merge/Internal.lean and Merge/Sideward.lean; the Minimal-Search weighting is in Merge/MinimalSearch.lean.

Main definitions #

Main results #

Implementation notes #

Definition 1.3.4 uses the deletion coproduct Δ^d, which contracts the unary vertex a cut leaves. mergeOp uses the pruning coproduct Δ^ρ, which keeps it. The two extract the same accessible terms and differ only in the remainder, so the forest B grafts is the same.

References #

Cut enumerations that admit Merge #

A cut enumeration admits Merge when its crowns are subtrees with fewer edges in total than their tree, and its only empty cut is the tree itself. The edge bound makes External Merge of a pair exact (mergeOpG_pair); the other two let a spectator component pass through (mergeOpG_ofTree_mul).

Instances
    theorem Minimalist.Merge.IsMergeCuts.notMem_crown {α : Type u_2} {cuts : UnorderedTree α → Multiset (UnorderedTree.Forest (UnorderedTree α) × UnorderedTree α)} [IsMergeCuts cuts] {T : UnorderedTree α} {p : UnorderedTree.Forest (UnorderedTree α) × UnorderedTree α} (hp : p ∈ cuts T) :
    T ∉ p.1

    No cut of an enumeration admitting Merge has its own tree in the crown.

    theorem Minimalist.Merge.IsMergeCuts.crown_ne_singleton {α : Type u_2} {cuts : UnorderedTree α → Multiset (UnorderedTree.Forest (UnorderedTree α) × UnorderedTree α)} [IsMergeCuts cuts] {T : UnorderedTree α} {p : UnorderedTree.Forest (UnorderedTree α) × UnorderedTree α} (hp : p ∈ cuts T) :
    p.1 ≠ {T}

    No cut of an enumeration admitting Merge extracts the whole tree.

    Every crown member of a cut in treeCutsG cuts T, the whole tree included, is a subtree of T.

    Products in the two channels #

    The matching projections #

    noncomputable def Minimalist.Merge.forestProj {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (F₀ : UnorderedTree.Forest (UnorderedTree α)) :

    The projection onto the basis element F₀ keeps its coefficient and sends every other basis element to zero.

    Equations
    Instances For
      theorem Minimalist.Merge.forestProj_apply_of' {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (F₀ F : UnorderedTree.Forest (UnorderedTree α)) :
      (forestProj F₀) (ConnesKreimer.of' F) = if F = F₀ then ConnesKreimer.of' F else 0
      theorem Minimalist.Merge.forestProj_mul_eq_zero_of_not_le {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] {F₀ F : UnorderedTree.Forest (UnorderedTree α)} (hF : ¬F ≤ F₀) (a : ConnesKreimer R (UnorderedTree α)) :
      (forestProj F₀) (ConnesKreimer.of' F * a) = 0

      The projection onto F₀ kills every product with a forest that does not fit inside F₀.

      noncomputable def Minimalist.Merge.gammaMatch {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (S S' : UnorderedTree α) :

      The matching projection γ_{S,S'} ([MCB25] Definition 1.3.1) is the projection onto {S, S'}.

      Equations
      Instances For
        theorem Minimalist.Merge.gammaMatch_apply_singleton {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (S S' : UnorderedTree α) (F : UnorderedTree.Forest (UnorderedTree α)) :
        (gammaMatch S S') (ConnesKreimer.of' F) = if F = {S, S'} then ConnesKreimer.of' F else 0
        noncomputable def Minimalist.Merge.deltaMatch {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (S S' : UnorderedTree α) :
        TensorProduct R (ConnesKreimer R (UnorderedTree α)) (ConnesKreimer R (UnorderedTree α)) →ₗ[R] TensorProduct R (ConnesKreimer R (UnorderedTree α)) (ConnesKreimer R (UnorderedTree α))

        The matching operator δ_{S,S'} = γ_{S,S'} ⊗ id acts on the left channel of a coproduct.

        Equations
        Instances For

          Grafting #

          noncomputable def Minimalist.Merge.graftBinaryAt {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (lbl : α) (S S' : UnorderedTree α) :

          The grafting operator B at the pair S, S' sends the basis element {S, S'} to the tree node lbl {S, S'} and every other basis element to zero. Merge applies it only after δ_{S,S'}, so this restriction of [MCB25]'s B suffices.

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            theorem Minimalist.Merge.graftBinaryAt_apply_singleton {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (lbl : α) (S S' : UnorderedTree α) (F : UnorderedTree.Forest (UnorderedTree α)) :
            (graftBinaryAt lbl S S') (ConnesKreimer.of' F) = if F = {S, S'} then ConnesKreimer.of' {UnorderedTree.node lbl {S, S'}} else 0

            The Merge operator #

            noncomputable def Minimalist.Merge.mergePost {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (lbl : α) (S S' : UnorderedTree α) :
            TensorProduct R (ConnesKreimer R (UnorderedTree α)) (ConnesKreimer R (UnorderedTree α)) →ₗ[R] ConnesKreimer R (UnorderedTree α)

            The post-coproduct chain ⊔ ∘ (B ⊗ id) ∘ δ_{S,S'}, shared by every cut enumeration.

            Equations
            • One or more equations did not get rendered due to their size.
            Instances For
              noncomputable def Minimalist.Merge.mergeOp {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (lbl : α) (S S' : UnorderedTree α) :

              The Merge operator M_{S,S'} of [MCB25] Definition 1.3.4 at the pruning coproduct, with root label lbl.

              Equations
              Instances For
                theorem Minimalist.Merge.mergePost_basis_tensor {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (lbl : α) (S S' : UnorderedTree α) (F : UnorderedTree.Forest (UnorderedTree α)) (r : ConnesKreimer R (UnorderedTree α)) :
                (mergePost lbl S S') (ConnesKreimer.of' F ⊗ₜ[R] r) = if F = {S, S'} then ConnesKreimer.of' {UnorderedTree.node lbl {S, S'}} * r else 0

                On a basis tensor of' F ⊗ r, the post-coproduct chain grafts F if it is {S, S'} and vanishes otherwise.

                theorem Minimalist.Merge.gammaMatch_mul_eq_zero_of_not_le {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (S S' : UnorderedTree α) (F : UnorderedTree.Forest (UnorderedTree α)) (hF : ¬F ≤ {S, S'}) (a : ConnesKreimer R (UnorderedTree α)) :
                (gammaMatch S S') (ConnesKreimer.of' F * a) = 0

                γ_{S,S'} kills every product with a forest F that does not fit inside {S, S'}.

                theorem Minimalist.Merge.gammaMatch_singleton_mul_eq_zero {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (S S' T : UnorderedTree α) (hT_ne_S : T ≠ S) (hT_ne_S' : T ≠ S') (a : ConnesKreimer R (UnorderedTree α)) :
                (gammaMatch S S') (ConnesKreimer.of' {T} * a) = 0

                γ_{S,S'} kills every product with a tree other than S and S'.

                theorem Minimalist.Merge.mergePost_left_mul_eq_zero_of_not_le {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (lbl : α) (S S' : UnorderedTree α) (F : UnorderedTree.Forest (UnorderedTree α)) (b : ConnesKreimer R (UnorderedTree α)) (hF : ¬F ≤ {S, S'}) (z : TensorProduct R (ConnesKreimer R (UnorderedTree α)) (ConnesKreimer R (UnorderedTree α))) :
                (mergePost lbl S S') (ConnesKreimer.of' F ⊗ₜ[R] b * z) = 0

                The post-coproduct chain kills every term whose left channel carries a forest that does not fit inside {S, S'}.

                theorem Minimalist.Merge.mergePost_right_one_tmul {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (lbl : α) (S S' : UnorderedTree α) (z : TensorProduct R (ConnesKreimer R (UnorderedTree α)) (ConnesKreimer R (UnorderedTree α))) (y : ConnesKreimer R (UnorderedTree α)) :
                (mergePost lbl S S') (z * 1 ⊗ₜ[R] y) = (mergePost lbl S S') z * y

                The post-coproduct chain commutes with right multiplication by a right-channel factor 1 ⊗ y, so a spectator workspace passes through it unchanged.

                The unit stage M_{β,1} #

                The first stage of Internal Merge (Proposition 1.4.2) moves an accessible term β to the left channel and leaves T/β on the right. Its grafting step is the identity, since B(β ⊔ 1) = M(β, 1) = β. It is not a Merge in its own right: it occurs only composed with M_{T/β,β} ([MCB25] Remark 1.4.3).

                noncomputable def Minimalist.Merge.gammaMatchSingle {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (β : UnorderedTree α) :

                The single-tree matching projection γ_{β,1} keeps the coefficient of the basis element {β}.

                Equations
                Instances For
                  theorem Minimalist.Merge.gammaMatchSingle_apply_singleton {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (β : UnorderedTree α) (F : UnorderedTree.Forest (UnorderedTree α)) :
                  (gammaMatchSingle β) (ConnesKreimer.of' F) = if F = {β} then ConnesKreimer.of' F else 0
                  noncomputable def Minimalist.Merge.deltaMatchSingle {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (β : UnorderedTree α) :
                  TensorProduct R (ConnesKreimer R (UnorderedTree α)) (ConnesKreimer R (UnorderedTree α)) →ₗ[R] TensorProduct R (ConnesKreimer R (UnorderedTree α)) (ConnesKreimer R (UnorderedTree α))

                  The matching operator δ_{β,1} = γ_{β,1} ⊗ id.

                  Equations
                  Instances For
                    noncomputable def Minimalist.Merge.mergePostUnit {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (β : UnorderedTree α) :
                    TensorProduct R (ConnesKreimer R (UnorderedTree α)) (ConnesKreimer R (UnorderedTree α)) →ₗ[R] ConnesKreimer R (UnorderedTree α)

                    The post-coproduct chain ⊔ ∘ δ_{β,1} of the unit stage.

                    Equations
                    Instances For
                      noncomputable def Minimalist.Merge.mergeOpUnit {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (β : UnorderedTree α) :

                      The unit stage M_{β,1} at the pruning coproduct.

                      Equations
                      Instances For
                        theorem Minimalist.Merge.mergePostUnit_basis_tensor {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (β : UnorderedTree α) (F : UnorderedTree.Forest (UnorderedTree α)) (r : ConnesKreimer R (UnorderedTree α)) :
                        (mergePostUnit β) (ConnesKreimer.of' F ⊗ₜ[R] r) = if F = {β} then ConnesKreimer.of' {β} * r else 0
                        theorem Minimalist.Merge.mergePostUnit_left_mul_eq_zero_of_not_le {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (β : UnorderedTree α) (F : UnorderedTree.Forest (UnorderedTree α)) (b : ConnesKreimer R (UnorderedTree α)) (hF : ¬F ≤ {β}) (z : TensorProduct R (ConnesKreimer R (UnorderedTree α)) (ConnesKreimer R (UnorderedTree α))) :
                        (mergePostUnit β) (ConnesKreimer.of' F ⊗ₜ[R] b * z) = 0

                        The unit chain kills every term whose left channel carries a forest that does not fit inside {β}.

                        theorem Minimalist.Merge.mergePostUnit_right_one_tmul {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (β : UnorderedTree α) (z : TensorProduct R (ConnesKreimer R (UnorderedTree α)) (ConnesKreimer R (UnorderedTree α))) (y : ConnesKreimer R (UnorderedTree α)) :
                        (mergePostUnit β) (z * 1 ⊗ₜ[R] y) = (mergePostUnit β) z * y

                        The unit chain commutes with right multiplication by a right-channel factor 1 ⊗ y.

                        Merge over a cut enumeration #

                        noncomputable def Minimalist.Merge.mergeOpG {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (cuts : UnorderedTree α → Multiset (UnorderedTree.Forest (UnorderedTree α) × UnorderedTree α)) (lbl : α) (S S' : UnorderedTree α) :

                        Merge M_{S,S'} over a cut enumeration cuts, whose coproduct is comulAlgHomNG cuts.

                        Equations
                        Instances For
                          noncomputable def Minimalist.Merge.mergeOpUnitG {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (cuts : UnorderedTree α → Multiset (UnorderedTree.Forest (UnorderedTree α) × UnorderedTree α)) (β : UnorderedTree α) :

                          The unit stage M_{β,1} over a cut enumeration cuts.

                          Equations
                          Instances For
                            theorem Minimalist.Merge.mergeOp_eq_G {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (lbl : α) (S S' : UnorderedTree α) :
                            theorem Minimalist.Merge.mergeOpUnit_eq_G {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (β : UnorderedTree α) :
                            theorem Minimalist.Merge.mergeOpG_apply_of' {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (cuts : UnorderedTree α → Multiset (UnorderedTree.Forest (UnorderedTree α) × UnorderedTree α)) (lbl : α) (S S' : UnorderedTree α) (F : UnorderedTree.Forest (UnorderedTree α)) :
                            (mergeOpG cuts lbl S S') (ConnesKreimer.of' F) = ConnesKreimer.of' {UnorderedTree.node lbl {S, S'}} * (Multiset.map (fun (p : Multiset (UnorderedTree α) × Multiset (UnorderedTree α)) => ConnesKreimer.of' p.2) (Multiset.filter (fun (x : Multiset (UnorderedTree α) × Multiset (UnorderedTree α)) => x.1 = {S, S'}) (ConnesKreimer.forestCutsG cuts F))).sum

                            Merge on a workspace F grafts {S, S'} beside the trunk of each forest cut of F with crown {S, S'} ([MCB25] (1.3.11)).

                            theorem Minimalist.Merge.mergeOpG_apply_of'_eq_sum {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (cuts : UnorderedTree α → Multiset (UnorderedTree.Forest (UnorderedTree α) × UnorderedTree α)) (lbl : α) (S S' : UnorderedTree α) (F : UnorderedTree.Forest (UnorderedTree α)) :
                            (mergeOpG cuts lbl S S') (ConnesKreimer.of' F) = (Multiset.map (fun (s : ConnesKreimer.CutChoice α) => ConnesKreimer.of' ({UnorderedTree.node lbl {S, S'}} + s.trunk)) (Multiset.filter (fun (x : ConnesKreimer.CutChoice α) => x.crown = {S, S'}) (ConnesKreimer.forestCutChoicesG cuts F))).sum

                            Merge on a workspace F is a sum of workspaces, one for each choice of a cut of each tree of F whose crowns together are {S, S'}.

                            theorem Minimalist.Merge.mergeOpUnitG_apply_of'_eq_sum {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (cuts : UnorderedTree α → Multiset (UnorderedTree.Forest (UnorderedTree α) × UnorderedTree α)) (β : UnorderedTree α) (F : UnorderedTree.Forest (UnorderedTree α)) :
                            (mergeOpUnitG cuts β) (ConnesKreimer.of' F) = (Multiset.map (fun (s : ConnesKreimer.CutChoice α) => ConnesKreimer.of' ({β} + s.trunk)) (Multiset.filter (fun (x : ConnesKreimer.CutChoice α) => x.crown = {β}) (ConnesKreimer.forestCutChoicesG cuts F))).sum

                            The unit stage on a workspace F is a sum of workspaces, one for each choice of a cut of each tree of F whose crowns together are {β}.

                            theorem Minimalist.Merge.mergeOpG_comm {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (cuts : UnorderedTree α → Multiset (UnorderedTree.Forest (UnorderedTree α) × UnorderedTree α)) (lbl : α) (S S' : UnorderedTree α) :
                            mergeOpG cuts lbl S S' = mergeOpG cuts lbl S' S

                            Merge does not depend on the order of the pair.

                            theorem Minimalist.Merge.mergeOpUnitG_one {R : Type u_1} [CommSemiring R] {α : Type u_2} [DecidableEq (UnorderedTree α)] (cuts : UnorderedTree α → Multiset (UnorderedTree.Forest (UnorderedTree α) × UnorderedTree α)) (β : UnorderedTree α) :
                            (mergeOpUnitG cuts β) 1 = 0

                            The unit stage vanishes on the empty workspace, which has no β to extract.

                            Merge at the trace cuts #

                            noncomputable def Minimalist.Merge.mergeOpC {R : Type u_1} [CommSemiring R] {α : Type u_2} {β : Type u_3} [DecidableEq (UnorderedTree (α ⊕ β))] (τ : UnorderedTree (α ⊕ β) → β) (lbl : α ⊕ β) (S S' : UnorderedTree (α ⊕ β)) :
                            ConnesKreimer R (UnorderedTree (α ⊕ β)) →ₗ[R] ConnesKreimer R (UnorderedTree (α ⊕ β))

                            The trace Merge operator is Merge at the trace cuts cutSummandsCN τ, whose trunks carry a trace leaf at each cut site.

                            Equations
                            Instances For
                              noncomputable def Minimalist.Merge.mergeOpUnitC {R : Type u_1} [CommSemiring R] {α : Type u_2} {β : Type u_3} [DecidableEq (UnorderedTree (α ⊕ β))] (τ : UnorderedTree (α ⊕ β) → β) (S : UnorderedTree (α ⊕ β)) :
                              ConnesKreimer R (UnorderedTree (α ⊕ β)) →ₗ[R] ConnesKreimer R (UnorderedTree (α ⊕ β))

                              The unit stage M_{S,1} at the trace cuts cutSummandsCN τ.

                              Equations
                              Instances For