Documentation

Anderson4D.Continuum.PrimitiveCopiedLabels

Copied paired labels in the bounded lattice box #

This file implements the finite reindexing used literally in paper §5.1: choose the label at one endpoint of each covariance pair, copy it to the other endpoint, and retain the resulting tuple in one bounded box. No occurrence-wise path unwrapping is used.

The main conclusions have no fiber-cardinality or winding amplification: the copied-label carrier embeds injectively into the bounded tuple carrier used by the lattice estimate, and its full primitive-pairing sum is bounded by the existing all-cuts primitive across-pairing sum.

The paper's finite box #

noncomputable def Anderson4D.primitiveCopiedBoxRadius (ε : ℝ) :

Natural half-width of the canonical copied-label box.

Equations
Instances For
    theorem Anderson4D.mem_torusGrid_compatible_abs_le {ε : ℝ} (hε : 0 < ε) {y : Z4} (hy : y ∈ torusGrid (compatibleMeshSize ε)) (i : Fin dim) :

    Every label in the canonical torus grid lies in the single natural integer box consumed by rdec_boundedTuples.

    theorem Anderson4D.primitiveCanonicalCellCarrier_mem_bounded {ε : ℝ} (hε : 0 < ε) {n : ℕ} {κ : PartialPairing (Fin (2 * n))} {y : Fin (2 * n) → Z4} (hy : y ∈ primitiveCanonicalCellCarrier ε n κ) :

    Tuple form of the preceding bounded-box inclusion.

    Choose once, copy to the paired occurrence #

    theorem Anderson4D.card_pairingLowerHalf_eq {n : ℕ} (κ : PartialPairing (Fin (2 * n))) (hfull : κ.IsFull) :

    A full pairing on 2n positions has exactly n independently chosen labels; the other n labels are literal copies.

    def Anderson4D.copiedPairingLabels {m : ℕ} (κ : PartialPairing (Fin m)) (hfull : κ.IsFull) (a : ↥(pairingLowerHalf κ) → Z4) :
    Fin m → Z4

    Extend labels chosen only at the smaller endpoint of each pair by copying the chosen value to its mate.

    Equations
    Instances For

      Restriction to the canonical smaller endpoint of each pair.

      Equations
      Instances For
        def Anderson4D.copiedPairingLabelsEquiv {m : ℕ} (κ : PartialPairing (Fin m)) (hfull : κ.IsFull) :
        (↥(pairingLowerHalf κ) → Z4) ≃ { y : Fin m → Z4 // RespectsPairing κ y }

        Literal formulation of the paper's copied-label sentence: for a full pairing, choosing one label per lower endpoint is equivalent to a full tuple satisfying y_{κ(i)} = y_i.

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

          Lossless arithmetic reindexing #

          @[reducible, inline]
          abbrev Anderson4D.primitiveCopiedReductionTuple (n : ℕ) (hn : 1 ≤ n) (y : Fin (2 * n) → Z4) :
          Fin (2 * n - 1 + 1) → Z4

          The copied tuple, cast to the arithmetically equal carrier on which reductionWeight (2n-1) is defined.

          Equations
          Instances For
            def Anderson4D.primitiveCopiedSourceTuple (n : ℕ) (hn : 1 ≤ n) (u : Fin (2 * n - 1 + 1) → Z4) :
            Fin (2 * n) → Z4

            Inverse arithmetic cast, from the reduction carrier back to the paper's Fin (2n) labels.

            Equations
            Instances For
              noncomputable def Anderson4D.primitiveCopiedReductionCarrier (ε : ℝ) (n : ℕ) (hn : 1 ≤ n) (κ : PartialPairing (Fin (2 * n))) :
              Finset (Fin (2 * n - 1 + 1) → Z4)

              Image of the copied-label carrier on the literal reduction carrier.

              Equations
              Instances For
                @[simp]
                theorem Anderson4D.mem_primitiveCopiedReductionCarrier {ε : ℝ} {n : ℕ} {hn : 1 ≤ n} {κ : PartialPairing (Fin (2 * n))} {u : Fin (2 * n - 1 + 1) → Z4} :

                Reindexing preserves the copied-pair equalities literally.

                The copied carrier enters the bounded lattice box injectively, with no winding-sector multiplicity.

                Exact carrier identity: after the arithmetic cast, the paper's copied grid is precisely the bounded box filtered by the transported pairing constraint.

                noncomputable def Anderson4D.primitiveCopiedReductionFiberMultiplicity (ε : ℝ) (n : ℕ) (hn : 1 ≤ n) (κ : PartialPairing (Fin (2 * n))) (u : Fin (2 * n - 1 + 1) → Z4) :

                Exact fiber multiplicity of the copied-label arithmetic reindexing.

                Equations
                Instances For
                  theorem Anderson4D.primitiveCopiedReductionFiberMultiplicity_le_one (ε : ℝ) (n : ℕ) (hn : 1 ≤ n) (κ : PartialPairing (Fin (2 * n))) (u : Fin (2 * n - 1 + 1) → Z4) :
                  theorem Anderson4D.sum_copiedLabels_filter_eq_boundedPairing_filter {ε : ℝ} (hε : 0 < ε) (n : ℕ) (hn : 1 ≤ n) (κ : PartialPairing (Fin (2 * n))) (P : (Fin (2 * n - 1 + 1) → Z4) → Prop) [DecidablePred P] (f : (Fin (2 * n - 1 + 1) → Z4) → ℝ) :

                  Lossless reindexing remains exact after imposing any decidable support predicate on the reduction tuple. In particular, the continuous layer may retain its fixed-endpoint (or bounded endpoint-neighbourhood) constraint instead of enlarging to all translations in the box.

                  Finite sums without amplification #

                  noncomputable def Anderson4D.primitiveCopiedReductionCellRealSum (ε : ℝ) (n : ℕ) (hn : 1 ≤ n) (κ : PartialPairing (Fin (2 * n))) :

                  The exact real-valued copied-label sum for one pairing.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    theorem Anderson4D.primitiveCopiedReductionCellRealSum_eq_latticeChainSum {ε : ℝ} (hε : 0 < ε) (n : ℕ) (hn : 1 ≤ n) (κ : PartialPairing (Fin (2 * n))) :

                    Exact fixed-pairing reindexing into the bounded lattice sum.

                    theorem Anderson4D.primitiveCopiedReductionCellRealSum_le_latticeChainSum {ε : ℝ} (hε : 0 < ε) (n : ℕ) (hn : 1 ≤ n) (κ : PartialPairing (Fin (2 * n))) :

                    For a fixed paper pairing, the copied-label sum is a literal subsum of the bounded lattice sum for the transported pairing. There is no fiber-cardinality multiplier and no comparison of unrelated weights.

                    The fixed-pairing copied sum enters its canonical primitive across carrier without any M- or ε-dependent prefactor.

                    The full primitive-pairing carrier #

                    noncomputable def Anderson4D.primitiveCopiedPrimitiveRealSum (ε : ℝ) (n : ℕ) (hn : 1 ≤ n) :

                    Paper (5.5), before fixing the lower-endpoint set A: sum the copied bounded-box statistic over every primitive full pairing.

                    Equations
                    Instances For

                      Lossless passage from all source pairings to the literal PartialPairing bounded-lattice carrier. The outer transport is injective, so this step introduces no pairing-count factor either.

                      Final copied-label finite reindexing: the full primitive sum is bounded by the existing all-cuts across-pairing machine with coefficient exactly one. The only overcount is the paper's harmless choice of A; no factor depends on the box radius or on ε.

                      ENNReal form consumed by the cell-integral layer #

                      noncomputable def Anderson4D.primitiveCopiedReductionCellSum (ε : ℝ) (n : ℕ) (hn : 1 ≤ n) (κ : PartialPairing (Fin (2 * n))) :

                      Nonnegative extended-real form of one copied-pairing sum.

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

                        Drop-in scalar ledger for a direct copied-cell proof of paper (5.3).

                        noncomputable def Anderson4D.primitiveCopiedPrimitiveSum (ε : ℝ) (n : ℕ) (hn : 1 ≤ n) :

                        Extended-real sum over all primitive pairings.

                        Equations
                        Instances For

                          Analytic boundary #

                          The finite step is lossless. A direct proof of the paper's cell estimate (5.3) uses primitiveCopiedReductionTuple n hn y, while retaining the endpoint support predicate supplied by the endpoint-fixed integral. The current theorem primitiveInsertedIntegrand_fiber_exhaustive_order instead produces primitiveUnwrappedReductionTuple; its weight cannot be transported to the copied tuple uniformly because path unwrapping destroys literal pairing. sum_copiedLabels_filter_eq_boundedPairing_filter is the corresponding finite regrouping identity.