Documentation

Anderson4D.Continuum.PrimitiveEndpointAssembly

Endpoint-preserving primitive lattice assembly #

The endpoint values in paper (5.5) are fixed. They must therefore remain visible until Proposition 5.6 supplies the factor ⟨x₀-x₁⟩⁻⁴. This file provides the endpoint-preserving summation layer which is deliberately absent from primitiveAcrossLatticeSum.

The first theorem below closes one complete paired-incidence fibre. Unlike primitive_lattice_estimate, its denominator remains inside the genuine tuple sum; no constancy of the incidence denominator across supports or multiplicity profiles is assumed.

noncomputable def Anderson4D.primitiveDirectReductionWeight {n : ℕ} (hn : 1 ≤ n) (y : Fin (2 * n) → Z4) :

The (5.5) reduction weight on its natural even tuple carrier.

Equations
  • One or more equations did not get rendered due to their size.
Instances For
    def Anderson4D.primitiveEndpointLeft (n : ℕ) (hn : 1 ≤ n) :
    Fin (2 * n)

    First and last slots of the paper's even tuple.

    Equations
    Instances For
      def Anderson4D.primitiveEndpointRight (n : ℕ) (hn : 1 ≤ n) :
      Fin (2 * n)
      Equations
      Instances For
        def Anderson4D.primitiveTuplesAtEndpoints {n : ℕ} (hn : 1 ≤ n) (Y : Finset (Fin (2 * n) → Z4)) (x₀ x₁ : Z4) :
        Finset (Fin (2 * n) → Z4)

        Tuples in a finite family with prescribed endpoint lattice labels.

        Equations
        Instances For
          @[simp]
          theorem Anderson4D.mem_primitiveTuplesAtEndpoints {n : ℕ} {hn : 1 ≤ n} {Y : Finset (Fin (2 * n) → Z4)} {x₀ x₁ : Z4} {y : Fin (2 * n) → Z4} :
          y ∈ primitiveTuplesAtEndpoints hn Y x₀ x₁ ↔ y ∈ Y ∧ y (primitiveEndpointLeft n hn) = x₀ ∧ y (primitiveEndpointRight n hn) = x₁
          noncomputable def Anderson4D.primitiveFixedDataEndpointContribution {n : ℕ} (M : ℕ) (hn : 1 ≤ n) (t : PlaneTree) (Y : Finset (Fin (2 * n) → Z4)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :

          The actual fixed-datum endpoint contribution after finite incidence reindexing. Both the primitive-pairing multiplicity and the symmetry denominator are evaluated on each tuple.

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            theorem Anderson4D.primitiveFixedDataEndpointContribution_nonneg {n M : ℕ} (hn : 1 ≤ n) (t : PlaneTree) (Y : Finset (Fin (2 * n) → Z4)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :
            theorem Anderson4D.tupleSupport_mem_realizedSetsContainingPair {n M : ℕ} (hn : 1 ≤ n) {t : PlaneTree} (d : t.PairedValidRealizationData M (2 * n)) {y : Fin (2 * n) → Z4} (hy : PairedDataRealizes d y) {x₀ x₁ : Z4} (hy₀ : y (primitiveEndpointLeft n hn) = x₀) (hy₁ : y (primitiveEndpointRight n hn) = x₁) :

            A realized tuple with the displayed endpoints has support in the two-anchor carrier used by Proposition 5.6.

            Pointwise denominator estimate with the full realized-support cardinality kept on the left. The primitive-pairing cardinality may be zero; in the nonzero case one compatible pairing supplies positivity of the incidence denominator.

            theorem Anderson4D.primitive_inducedWord_diameter_le_rootScale {n M : ℕ} (hn : 1 ≤ n) {t : PlaneTree} (ht : t.isValid = true) (d : t.PairedValidRealizationData M (2 * n)) (Y : Finset (Fin (2 * n) → Z4)) (hYreal : ∀ y ∈ Y, PairedDataRealizes d y) {Z : Finset Z4} {w : SupportWord (2 * n) Z} (hw : w ∈ inducedWordsAtSupport Y Z) :

            Every induced word in a fixed paired fibre inherits the root-cluster diameter bound from its underlying realized tuple.

            noncomputable def Anderson4D.primitiveFixedDataEndpointNumerator {n : ℕ} (hn : 1 ≤ n) (Y : Finset (Fin (2 * n) → Z4)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :

            Numerator of the fixed-datum endpoint contribution, before the incidence denominator.

            Equations
            • One or more equations did not get rendered due to their size.
            Instances For
              theorem Anderson4D.primitiveFixedDataEndpointNumerator_nonneg {n : ℕ} (hn : 1 ≤ n) (Y : Finset (Fin (2 * n) → Z4)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :
              theorem Anderson4D.sum_inducedWords_primitiveDirectReductionWeight_le {C : ℝ} (hC : PermSumEstimate C) {n M : ℕ} {t : PlaneTree} (d : t.PairedValidRealizationData M (2 * n)) (Y : Finset (Fin (2 * n) → Z4)) (Z : Finset Z4) (A : Finset (Fin (2 * n))) (hn : 2 ≤ n) (ht : t.isValid = true) (hroot : t.rootV ∈ t.BranchNodes) (hYreal : ∀ y ∈ Y, PairedDataRealizes d y) :

              One realized support contributes at most the root-diameter factor times the complete Proposition 5.7 scale expression.

              theorem Anderson4D.primitiveFixedDataEndpointNumerator_le {C : ℝ} (hC : PermSumEstimate C) {n M : ℕ} {t : PlaneTree} (d : t.PairedValidRealizationData M (2 * n)) (Y : Finset (Fin (2 * n) → Z4)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) (hn : 2 ≤ n) (ht : t.isValid = true) (hroot : t.rootV ∈ t.BranchNodes) (hYreal : ∀ y ∈ Y, PairedDataRealizes d y) :
              primitiveFixedDataEndpointNumerator ⋯ Y A x₀ x₁ ≤ ↑(realizedSetsContainingPair (↑d).1 ⋯ x₀ x₁).card * ((1 + 2 * ↑t.leafCount) ^ 2 * ↑(scaleN (pairedMarking d) t.rootV) ^ 2 * primitiveScaleRHS (4 * C) n t (pairedMarking d))

              Summing one fixed datum over all endpoint-valid supports costs exactly the cardinality of the two-anchor realized-set carrier. This is the factor which Proposition 5.6 cancels against the incidence denominator.

              theorem Anderson4D.primitiveFixedDataEndpointContribution_le {C : ℝ} (hC : PermSumEstimate C) {n M : ℕ} {t : PlaneTree} (d : t.PairedValidRealizationData M (2 * n)) (Y : Finset (Fin (2 * n) → Z4)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) (hn : 2 ≤ n) (ht : t.isValid = true) (hroot : t.rootV ∈ t.BranchNodes) (hYreal : ∀ y ∈ Y, PairedDataRealizes d y) :

              Complete fixed-datum endpoint assembly.

              This is the denominator-correct version of the one-datum lattice estimate. The actual tuple-dependent incidence denominator remains under the sum. The cardinality of the two-anchor support carrier is introduced pointwise, cancelled by Proposition 5.6, and then cancelled again after summing the same carrier.

              Reindexing active paired data #

              Halving the positive even leaf multiplicities of paired data gives a positive assignment of total mass n. This is the exact 2^n carrier for the paper's choice of (m_l).

              Equations
              Instances For
                theorem Anderson4D.pairedLeafHalfAssignment_injective_on_fiber {n M : ℕ} {t : PlaneTree} {d d' : t.PairedValidRealizationData M (2 * n)} (hbranch : (↑d).1 = (↑d').1) (hhalf : pairedLeafHalfAssignment d = pairedLeafHalfAssignment d') :
                d = d'
                @[reducible, inline]
                abbrev Anderson4D.PrimitiveActiveEndpointData (t : PlaneTree) (M n : ℕ) (hn : 1 ≤ n) (Y : Finset (Fin (2 * n) → Z4)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :

                Paired incidence data which actually contribute to a prescribed endpoint family. The nonempty primitive-pairing fibre excludes all zero-contribution denominator data before the logarithmic reindexing.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  @[implicit_reducible]
                  noncomputable instance Anderson4D.instFintypePrimitiveActiveEndpointData (t : PlaneTree) (M n : ℕ) (hn : 1 ≤ n) (Y : Finset (Fin (2 * n) → Z4)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :
                  Fintype (PrimitiveActiveEndpointData t M n hn Y A x₀ x₁)
                  Equations
                  noncomputable def Anderson4D.primitiveActiveEndpointWitness {t : PlaneTree} {M n : ℕ} {hn : 1 ≤ n} {Y : Finset (Fin (2 * n) → Z4)} {A : Finset (Fin (2 * n))} {x₀ x₁ : Z4} (d : PrimitiveActiveEndpointData t M n hn Y A x₀ x₁) :
                  Fin (2 * n) → Z4
                  Equations
                  Instances For
                    theorem Anderson4D.primitiveActiveEndpointWitness_mem {t : PlaneTree} {M n : ℕ} {hn : 1 ≤ n} {Y : Finset (Fin (2 * n) → Z4)} {A : Finset (Fin (2 * n))} {x₀ x₁ : Z4} (d : PrimitiveActiveEndpointData t M n hn Y A x₀ x₁) :
                    theorem Anderson4D.primitiveActiveEndpointWitness_realizes {t : PlaneTree} {M n : ℕ} {hn : 1 ≤ n} {Y : Finset (Fin (2 * n) → Z4)} {A : Finset (Fin (2 * n))} {x₀ x₁ : Z4} (d : PrimitiveActiveEndpointData t M n hn Y A x₀ x₁) :
                    theorem Anderson4D.primitiveActiveEndpointScaleBound {t : PlaneTree} {M n : ℕ} {hn : 1 ≤ n} {Y : Finset (Fin (2 * n) → Z4)} {A : Finset (Fin (2 * n))} {x₀ x₁ : Z4} (d : PrimitiveActiveEndpointData t M n hn Y A x₀ x₁) (v : t.VPos) :
                    v ∈ t.BranchNodes → ↑(scaleN (pairedMarking ↑d) v) ≤ 4 * ↑M
                    def Anderson4D.primitiveActiveEndpointBranchData {t : PlaneTree} (ht : t.isValid = true) {M n : ℕ} {hn : 1 ≤ n} {Y : Finset (Fin (2 * n) → Z4)} {A : Finset (Fin (2 * n))} {x₀ x₁ : Z4} (d : PrimitiveActiveEndpointData t M n hn Y A x₀ x₁) :

                    The active datum's marking restricted to the genuine logarithmic scale window.

                    Equations
                    Instances For
                      def Anderson4D.primitiveActiveEndpointCode {t : PlaneTree} (ht : t.isValid = true) {M n : ℕ} {hn : 1 ≤ n} {Y : Finset (Fin (2 * n) → Z4)} {A : Finset (Fin (2 * n))} {x₀ x₁ : Z4} (d : PrimitiveActiveEndpointData t M n hn Y A x₀ x₁) :

                      Active paired data inject into the product of the logarithmic marking carrier and the positive half-multiplicity carrier.

                      Equations
                      Instances For
                        theorem Anderson4D.primitiveActiveEndpointCode_injective {t : PlaneTree} (ht : t.isValid = true) {M n : ℕ} {hn : 1 ≤ n} {Y : Finset (Fin (2 * n) → Z4)} {A : Finset (Fin (2 * n))} {x₀ x₁ : Z4} :
                        theorem Anderson4D.primitiveRatioRHS_activeBranchData {t : PlaneTree} (ht : t.isValid = true) {M n : ℕ} {hn : 1 ≤ n} {Y : Finset (Fin (2 * n) → Z4)} {A : Finset (Fin (2 * n))} {x₀ x₁ : Z4} (d : PrimitiveActiveEndpointData t M n hn Y A x₀ x₁) (C : ℝ) :
                        theorem Anderson4D.sum_activeEndpointData_primitiveRatioRHS_le {C : ℝ} (hC : 0 ≤ C) {t : PlaneTree} (ht : t.isValid = true) {M n : ℕ} {hn : 1 ≤ n} {Y : Finset (Fin (2 * n) → Z4)} {A : Finset (Fin (2 * n))} {x₀ x₁ : Z4} :
                        ∑ d : PrimitiveActiveEndpointData t M n hn Y A x₀ x₁, primitiveRatioRHS C n t (pairedMarking ↑d) ≤ ↑(2 ^ n) * primitiveMarkingRatioSum C n M t

                        Summing active paired data separates into a logarithmic marking sum and at most 2^n positive half-multiplicity assignments.

                        Summing the paired-incidence carrier #

                        noncomputable def Anderson4D.primitiveEndpointTreeIncidenceSum (M n : ℕ) (hn : 1 ≤ n) (t : PlaneTree) (Y : Finset (Fin (2 * n) → Z4)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :

                        The endpoint contribution attached to every paired realization datum. The tuple family is restricted to the actual incidence fiber before the fixed-datum estimate is applied.

                        Equations
                        • One or more equations did not get rendered due to their size.
                        Instances For
                          theorem Anderson4D.primitiveFixedDataEndpointContribution_eq_zero_of_inactive {M n : ℕ} {hn : 1 ≤ n} {t : PlaneTree} {Y : Finset (Fin (2 * n) → Z4)} {A : Finset (Fin (2 * n))} {x₀ x₁ : Z4} (d : t.PairedValidRealizationData M (2 * n)) (hinactive : ¬∃ y ∈ primitiveTuplesAtEndpoints hn Y x₀ x₁, PairedDataRealizes d y ∧ (primitiveCompatibleAcrossPairings A y).Nonempty) :
                          primitiveFixedDataEndpointContribution M hn t ({y ∈ Y | PairedDataRealizes d y}) A x₀ x₁ = 0

                          A datum outside the active endpoint subtype contributes zero. This is the precise justification for discarding the enormous ambient realization data carrier before the logarithmic marking sum.

                          theorem Anderson4D.primitiveEndpointTreeIncidenceSum_eq_active {M n : ℕ} {hn : 1 ≤ n} {t : PlaneTree} {Y : Finset (Fin (2 * n) → Z4)} {A : Finset (Fin (2 * n))} {x₀ x₁ : Z4} :
                          primitiveEndpointTreeIncidenceSum M n hn t Y A x₀ x₁ = ∑ d : PrimitiveActiveEndpointData t M n hn Y A x₀ x₁, primitiveFixedDataEndpointContribution M hn t ({y ∈ Y | PairedDataRealizes (↑d) y}) A x₀ x₁

                          Exact removal of the zero paired-incidence data.

                          theorem Anderson4D.primitiveEndpointTreeIncidenceSum_le_activeRatio {C : ℝ} (hC : PermSumEstimate C) {M n : ℕ} (hn : 2 ≤ n) {t : PlaneTree} (ht : t.isValid = true) (hroot : t.rootV ∈ t.BranchNodes) (Y : Finset (Fin (2 * n) → Z4)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :

                          Summation of the denominator-correct fixed-datum estimate over all active incidence data. This is the common branch before the extremal and non-extremal marking arguments diverge.

                          theorem Anderson4D.primitiveEndpointTreeIncidenceSum_le_of_card_lt_aux {C : ℝ} (hC : PermSumEstimate C) {M n K : ℕ} (hn : 2 ≤ n) {t : PlaneTree} (ht : t.isValid = true) (hroot : t.rootV ∈ t.BranchNodes) (mu : t.Multiplicities) (htotal : totalMultiplicity mu = 2 * n) (hcard : (nonrootBranches t).card < n - 2) (hnL : n ≤ K * (Nat.log 2 (4 * M) + 1)) (Y : Finset (Fin (2 * n) → Z4)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :
                          primitiveEndpointTreeIncidenceSum M n ⋯ t Y A x₀ x₁ ≤ volumeEstimateFinalConstant ^ t.leafCount * (1 + 2 * ↑t.leafCount) ^ 2 * latticeBracketInvFourth x₀ x₁ * (↑(2 ^ n) * ((32 * (4 * C) * (↑K + 1)) ^ n * ↑(Nat.log 2 (4 * M) + 1) ^ (n - 2)))

                          Non-extremal branch of the paper's (5.16)--(5.17) summation. The strict branch-cardinality inequality leaves enough room for the unrestricted logarithmic marking carrier.

                          Endpoint-preserving tree cover of the lattice sum #

                          noncomputable def Anderson4D.primitiveEndpointLatticeStatistic {n : ℕ} (hn : 1 ≤ n) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) (y : Fin (2 * n) → Z4) :

                          The primitive (5.5) statistic after summing all compatible primitive across pairings, while retaining the two fixed endpoint labels.

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For
                            theorem Anderson4D.primitiveEndpointLatticeStatistic_nonneg {n : ℕ} (hn : 1 ≤ n) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) (y : Fin (2 * n) → Z4) :
                            noncomputable def Anderson4D.primitiveEndpointLatticeSum (M n : ℕ) (hn : 1 ≤ n) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :

                            The finite endpoint-preserving version of the lattice sum (5.5).

                            Equations
                            Instances For
                              theorem Anderson4D.primitiveEndpointLatticeStatistic_eq_zero_of_not_repeated {M n : ℕ} (hn : 1 ≤ n) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) (y : Fin (2 * n) → Z4) (hybox : y ∈ rdec_boundedTuples M (2 * n)) (hynot : y ∉ rdec_repeatedTuples M (2 * n)) :

                              A nonzero primitive endpoint statistic lies in the repeated-value locus required by the weak Hepp-tree cover.

                              theorem Anderson4D.exists_pairedData_realizes_of_treeRealized_of_respectsAcross {t : PlaneTree} (ht : t.isValid = true) {M m : ℕ} {A : Finset (Fin m)} {κ : AcrossPairing A} {y : Fin m → Z4} (hytree : y ∈ rdec_treeRealized t M m) (hκ : RespectsWord A y κ) :

                              If a valid tree realizes a word carrying an across pairing, its restricted realization data can be promoted to the even paired carrier. This is the arithmetic-carrier version of the fixed-slice construction in PrimitiveAssembly.

                              noncomputable def Anderson4D.primitiveEndpointTreeTupleFamily (M n : ℕ) (hn : 1 ≤ n) (t : PlaneTree) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :
                              Finset (Fin (2 * n) → Z4)

                              The genuinely contributing endpoint tuples in one valid-tree slice.

                              Equations
                              • One or more equations did not get rendered due to their size.
                              Instances For
                                @[simp]
                                theorem Anderson4D.mem_primitiveEndpointTreeTupleFamily {M n : ℕ} {hn : 1 ≤ n} {t : PlaneTree} {A : Finset (Fin (2 * n))} {x₀ x₁ : Z4} {y : Fin (2 * n) → Z4} :
                                theorem Anderson4D.sum_treeRealized_primitiveEndpointLatticeStatistic_eq_incidence {M n : ℕ} (hn : 1 ≤ n) {t : PlaneTree} (ht : t.isValid = true) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :
                                ∑ y ∈ rdec_treeRealized t M (2 * n), primitiveEndpointLatticeStatistic hn A x₀ x₁ y = primitiveEndpointTreeIncidenceSum M n hn t (primitiveEndpointTreeTupleFamily M n hn t A x₀ x₁) A x₀ x₁

                                On a valid tree, the endpoint statistic is exactly the denominator-correct paired-incidence sum over the active tuple family.

                                theorem Anderson4D.primitiveEndpointLatticeSum_le_treeIncidence (M n : ℕ) (hn : 1 ≤ n) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :
                                primitiveEndpointLatticeSum M n hn A x₀ x₁ ≤ ∑ t ∈ rdec_treeEnum (2 * n), primitiveEndpointTreeIncidenceSum M n hn t (primitiveEndpointTreeTupleFamily M n hn t A x₀ x₁) A x₀ x₁

                                Endpoint-preserving master bridge from the finite lattice sum to valid trees and their exact even-multiplicity incidence denominators.

                                The bare-leaf slice #

                                theorem Anderson4D.primitiveDirectReductionWeight_eq_one_of_constant {n : ℕ} (hn : 1 ≤ n) (y : Fin (2 * n) → Z4) (x : Z4) (hy : ∀ (i : Fin (2 * n)), y i = x) :

                                The bare leaf contributes at most one constant endpoint tuple, and its primitive across-pairing multiplicity is at most n!.

                                theorem Anderson4D.primitiveEndpointTreeIncidenceSum_leaf_le_factorialLog {M n K : ℕ} (hn : 2 ≤ n) (hnL : n ≤ K * (Nat.log 2 (4 * M) + 1)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :
                                primitiveEndpointTreeIncidenceSum M n ⋯ PlaneTree.leaf (primitiveEndpointTreeTupleFamily M n ⋯ PlaneTree.leaf A x₀ x₁) A x₀ x₁ ≤ (8 * (↑K + 1)) ^ n * ↑(Nat.log 2 (4 * M) + 1) ^ (n - 2) * latticeBracketInvFourth x₀ x₁
                                theorem Anderson4D.primitiveEndpointTreeIncidenceSum_le_of_card_lt {C : ℝ} (hC : PermSumEstimate C) {M n K : ℕ} (hn : 2 ≤ n) {t : PlaneTree} (ht : t.isValid = true) (hroot : t.rootV ∈ t.BranchNodes) (hcard : (nonrootBranches t).card < n - 2) (hnL : n ≤ K * (Nat.log 2 (4 * M) + 1)) (Y : Finset (Fin (2 * n) → Z4)) (A : Finset (Fin (2 * n))) (x₀ x₁ : Z4) :
                                primitiveEndpointTreeIncidenceSum M n ⋯ t Y A x₀ x₁ ≤ volumeEstimateFinalConstant ^ t.leafCount * (1 + 2 * ↑t.leafCount) ^ 2 * latticeBracketInvFourth x₀ x₁ * (↑(2 ^ n) * ((32 * (4 * C) * (↑K + 1)) ^ n * ↑(Nat.log 2 (4 * M) + 1) ^ (n - 2)))

                                Non-extremal bound without requiring a multiplicity witness from the caller. If the active carrier is nonempty, any one active datum supplies the total-multiplicity witness; otherwise the incidence sum is exactly zero.