Documentation

MIPRE.Background.LIDT.Adapter.Weights

The seeded-CL adapter, part 5: both tests' distributions, as counts #

The reduction's remaining obligation is a push-forward bound between the two tests' question distributions, and both are defined as sums over a Sample type against an indicator. So the first thing to do is to turn each into a count, after which the bound is arithmetic on cardinalities rather than on sums.

theorem MIPRE.LIDT.Adapter.lidtGame_μ_eq {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d : ℕ} [NeZero m] (x y : Question F m) :
(lidtGame F m d).μ x y = ∑ s : Sample F m with s.questions = (x, y), s.weight

The canonical-line test's distribution, as a sum of sample weights.

theorem MIPRE.LIDT.Adapter.clGame_μ_eq {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d ldc : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (x y : CL.Question F m) :
(CL.clGame hm).μ x y = ↑{sm : CL.Sample F m | (CL.Sample.question hm sm sm.tyA, CL.Sample.question hm sm sm.tyB) = (x, y)}.card / ↑(Fintype.card (CL.Sample F m))

The seeded test's distribution, as a count. It is uniform over its samples, so the weight of a question pair is the number of samples producing it over the total.

The canonical-line test, shape by shape #

Each shape needs the set of samples producing a given question pair. For the point and axis-parallel shapes it is a singleton and the weight is read off directly; the diagonal shape is the one where several samples contribute.

The diagonal shape #

Here several samples contribute, so the weight is a sum. It does not have to be evaluated: in the push-forward bound the canonical-line weight appears only on the larger side, so an upper bound suffices, and bounding the sum by count × largest term costs only a factor m in the constant --- which δ_CL absorbs, being allowed a prefactor polynomial in m and d. What it may not absorb is a factor growing with q, so the q-exponent has to be right, and that is what le_rev_diagIdx_of_questions pins down.

theorem MIPRE.LIDT.Adapter.of_questions_diag {F : Type u_1} [Field F] [DecidableEq F] {m : ℕ} {ℓ : Line F m} {u : Point F m} {s : Sample F m} (hℓ : ∃ (k : Fin m), ℓ.2 k ≠ 0) (hs : s.questions = (Question.diagLine ℓ, Question.point u)) :
∃ (j : Fin m) (v : Fin (↑j + 1) → F), s = Sample.diag false u j v ∧ ∃ (c : F), c ≠ 0 ∧ Sample.extend v = c • ℓ.2

A sample producing a given diagonal line against a given point is a diag sample at that point whose direction is a nonzero multiple of the line's.

theorem MIPRE.LIDT.Adapter.le_rev_diagIdx_of_questions {F : Type u_1} [Field F] [DecidableEq F] {m : ℕ} [NeZero m] {ℓ : Line F m} {u : Point F m} {j : Fin m} {v : Fin (↑j + 1) → F} (hℓ : ∃ (k : Fin m), ℓ.2 k ≠ 0) (hs : (Sample.diag false u j v).questions = (Question.diagLine ℓ, Question.point u)) :
↑(diagIdx ℓ).rev ≤ ↑j

The direction pins the q-exponent. A sample producing the line has j at least the reversal of diagIdx ℓ: its direction vanishes above j, hence so does the line's, hence the reversed direction vanishes below rev j, so its first nonzero coordinate is at least rev j.

theorem MIPRE.LIDT.Adapter.extend_apply_coe {F : Type u_1} [Field F] {m : ℕ} {j : Fin m} (v : Fin (↑j + 1) → F) (i : Fin (↑j + 1)) :
Sample.extend v ⟨↑i, ⋯⟩ = v i

Sample.extend is the extension by zero, so it recovers v on v's own indices.

noncomputable def MIPRE.LIDT.Adapter.diagKey {F : Type u_1} [Field F] {m : ℕ} [NeZero m] (p : Fin m) :
Sample F m → Fin m × F

The key (j, c) of a diagonal sample, read at a coordinate p. Two samples producing the same line with the same key are equal, which is what bounds the count.

Equations
Instances For
    theorem MIPRE.LIDT.Adapter.card_filter_diag_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] {ℓ : Line F m} (hℓ : ∃ (k : Fin m), ℓ.2 k ≠ 0) (u : Point F m) :

    At most m q samples produce a given diagonal line against a given point. A sample is pinned by its j together with the scalar relating its direction to the line's, and there are m values of the first and q of the second.

    theorem MIPRE.LIDT.Adapter.weight_le_of_questions_diag {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] {ℓ : Line F m} (hℓ : ∃ (k : Fin m), ℓ.2 k ≠ 0) {u : Point F m} {s : Sample F m} (hsq : s.questions = (Question.diagLine ℓ, Question.point u)) :
    s.weight ≤ 1 / (6 * ↑m * ↑(Fintype.card (Point F m)) * ↑(Fintype.card F) ^ (↑(diagIdx ℓ).rev + 1))

    Every sample producing a given diagonal line against a point has weight at most 1/(6 m q^m q^{rev (diagIdx ℓ) + 1}). This is where the q-exponent of the bound is fixed: le_rev_diagIdx_of_questions says a contributing sample's j is at least rev (diagIdx ℓ).

    The seeded test, shape by shape #

    Only lower bounds are needed here, since the seeded weight sits on the smaller side of the push-forward bound, and a lower bound on a count is an injection into the set of contributing samples. That is much cheaper than an exact count, and it is why this section is short.

    The samples of the seeded test that ask the same point twice include one for every seed and every raw direction, so there are at least q · q^m of them.

    theorem MIPRE.LIDT.Adapter.card_filter_clAxis_ge {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (xp : Point F m) (s₀ : F) :

    Likewise for an axis-parallel line against a point: one sample for every raw direction.

    theorem MIPRE.LIDT.Adapter.card_filter_clDiag_ge {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (xp : Point F m) (s₀ : F) (w : Point F m) (hw : ∀ (k : Fin m), ↑k < ↑(CL.chi hm s₀) → w k = 0) :

    And for a diagonal line against a point, provided the direction really does vanish below the seed's block --- which it must, for the question to be in the seeded test's support. There is one sample for every completion of the direction below that block, hence at least q^{χ s}.

    From fibres of the question map to samples #

    The push-forward bound is stated over fibres of the question map, but the canonical-line test's weight lives on samples, and only five shapes of question pair carry any weight at all. This lemma moves the whole thing onto samples, where the case analysis is a case analysis on a constructor.

    theorem MIPRE.LIDT.Adapter.sum_fibre_μ_eq_sum_samples {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d : ℕ} [NeZero m] (f g : Question F m → CL.Question F m) (x y : CL.Question F m) :
    ∑ x' : Question F m with f x' = x, ∑ y' : Question F m with g y' = y, (lidtGame F m d).μ x' y' = ∑ s : Sample F m with f s.questions.1 = x ∧ g s.questions.2 = y, s.weight

    Counting the seed choices #

    With the push-forward on samples, the average over the family becomes a weight times a count of family members, and that is what the shapes differ in: a point question's image does not depend on the family member at all, while a line question's pins the seed at one index (and, for a diagonal, the scale).

    theorem MIPRE.LIDT.Adapter.sum_sum_filter_eq_sum_card {Seed : Type u_2} {ι : Type u_3} [Fintype Seed] [Fintype ι] [DecidableEq ι] (w : ι → ℝ) (cond : Seed → ι → Prop) [(σ : Seed) → (i : ι) → Decidable (cond σ i)] :
    ∑ σ : Seed, ∑ i : ι with cond σ i, w i = ∑ i : ι, w i * ↑{σ : Seed | cond σ i}.card

    Averaging over a family, as a weight times a count of family members.

    @[reducible, inline]
    abbrev MIPRE.LIDT.Adapter.Seed (F : Type u_2) [Field F] [Fintype F] (m : ℕ) :
    Type u_2

    The averaging family: a fibre position for each direction index, and one global nonzero direction scale. The scale is there because of the second correction in planning/lidt-cl-adapter.md.

    Equations
    Instances For
      noncomputable def MIPRE.LIDT.Adapter.qmapS {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) :
      Question F m → CL.Question F m

      The seeded question a canonical-line question is played through, for a family member.

      Equations
      Instances For
        @[simp]
        theorem MIPRE.LIDT.Adapter.qmapS_point {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) (u : Point F m) :

        The point shape #

        Only the self-consistency sample can contribute, and its image does not depend on the family member, so averaging neither helps nor hurts here: the requirement is the unaveraged 1/(3 q^m) ≤ C · 1/(9 q^m), i.e. C ≥ 3.

        theorem MIPRE.LIDT.Adapter.filter_qmapS_point_subset {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) (xp yp : Point F m) :

        The samples whose images are a pair of point questions: at most the self-consistency sample at the reversed point.

        theorem MIPRE.LIDT.Adapter.filter_qmapS_point_eq_empty {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) {xp yp : Point F m} (hxy : xp ≠ yp) :

        And if the two points differ, nothing contributes: the one candidate fails the second condition.

        Cardinalities #

        Three counts enter the arithmetic: the point space, the seeded test's sample space and the averaging family. Only the first has to be known as a power of q; the other two enter as symbols that cancel.

        The seeded test's sample space: nine ordered type pairs against (u, s, v).

        theorem MIPRE.LIDT.Adapter.card_seed_eq {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} :

        The averaging family: a fibre position per direction index, and one nonzero scale.

        theorem MIPRE.LIDT.Adapter.nonempty_seed {F : Type u_1} [Field F] [Fintype F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) :

        The family is nonempty, which the derandomization needs.

        The shape of every one of the bounds #

        All four nonzero shapes are bounded the same way: the contributing samples lie in one finite set T that does not depend on the family member, each of them has weight at most B, and each is picked out by at most M family members.

        theorem MIPRE.LIDT.Adapter.sum_sum_le_card_mul {S : Type u_2} {ι : Type u_3} [Fintype S] [Fintype ι] [DecidableEq ι] (w : ι → ℝ) (hw : ∀ (i : ι), 0 ≤ w i) (cond : S → ι → Prop) [(σ : S) → (i : ι) → Decidable (cond σ i)] (T : Finset ι) (B : ℝ) (M : ℕ) (hsub : ∀ (σ : S) (i : ι), cond σ i → i ∈ T) (hB : ∀ i ∈ T, w i ≤ B) (hM : ∀ i ∈ T, {σ : S | cond σ i}.card ≤ M) :
        ∑ σ : S, ∑ i : ι with cond σ i, w i ≤ ↑T.card * (B * ↑M)

        Count times weight times count.

        The mirrored shapes come for free #

        Both tests are symmetric under exchanging the two players --- lidtGame's swap bit and clGame's ordered type pair --- so a bound for (x, y) is a bound for (y, x), and only the shapes with the line on the left have to be done by hand.

        @[simp]
        theorem MIPRE.LIDT.Adapter.swapSample_weight {F : Type u_1} [Fintype F] {m : ℕ} (s : Sample F m) :
        @[simp]
        def MIPRE.LIDT.Adapter.swapEquiv {F : Type u_1} {m : ℕ} :
        Sample F m ≃ Sample F m

        The swap as an equivalence of samples.

        Equations
        Instances For
          theorem MIPRE.LIDT.Adapter.sum_filter_swap {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} (f : Question F m → CL.Question F m) (x y : CL.Question F m) :
          ∑ s : Sample F m with f s.questions.1 = x ∧ f s.questions.2 = y, s.weight = ∑ s : Sample F m with f s.questions.1 = y ∧ f s.questions.2 = x, s.weight

          The canonical-line side is symmetric.

          def MIPRE.LIDT.Adapter.clSwap {F : Type u_1} {m : ℕ} (sm : CL.Sample F m) :

          Exchanging the two players' types in a seeded sample.

          Equations
          Instances For
            @[simp]
            theorem MIPRE.LIDT.Adapter.clSwap_clSwap {F : Type u_1} {m : ℕ} (sm : CL.Sample F m) :
            clSwap (clSwap sm) = sm

            The type exchange as an equivalence of seeded samples.

            Equations
            Instances For
              theorem MIPRE.LIDT.Adapter.clGame_μ_symm {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d ldc : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (x y : CL.Question F m) :
              (CL.clGame hm).μ x y = (CL.clGame hm).μ y x

              The seeded side is symmetric too, the nine ordered type pairs being equally likely.

              The seed counts #

              A line question's image pins the family's fibre position at exactly one index --- and, for a diagonal, the scale as well. That is the whole content of the averaging: the family has (q/m)^m (q-1) members and only (q/m)^{m-1} (q-1) or (q/m)^{m-1} of them can contribute.

              theorem MIPRE.LIDT.Adapter.card_filter_seed_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} (hm : m ∣ Fintype.card F) (i : Fin m) (s₀ : F) (P : Seed F m → Prop) [DecidablePred P] (hP : ∀ (σc : Seed F m), P σc → seedOf hm i (σc.1 i) = s₀) :

              A pinned seed index costs a factor q/m.

              @[simp]
              theorem MIPRE.LIDT.Adapter.qmapS_axis {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) (ℓ : Line F m) :
              qmapS hm σc (Question.axisLine ℓ) = CL.Question.aline (revPoint ℓ.1) (seedOf hm (axisIdx ℓ).rev (σc.1 (axisIdx ℓ).rev))
              @[simp]
              theorem MIPRE.LIDT.Adapter.qmapS_diag {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) (ℓ : Line F m) :
              qmapS hm σc (Question.diagLine ℓ) = CL.Question.dline (revPoint ℓ.1 - shiftOf ℓ • revPoint ℓ.2) (seedOf hm (diagIdx ℓ) (σc.1 (diagIdx ℓ))) (↑σc.2 • revPoint ℓ.2)

              The axis-parallel shape #

              The seed determines the direction index, so the contributing sample is unique and the constraint on the family is at one index.

              theorem MIPRE.LIDT.Adapter.filter_qmapS_axis_subset {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) (u₀ : Point F m) (s₀ : F) (yp : Point F m) :
              {s : Sample F m | qmapS hm σc s.questions.1 = CL.Question.aline u₀ s₀ ∧ qmapS hm σc s.questions.2 = CL.Question.point yp} ⊆ {Sample.axis false (revPoint yp) (CL.chi hm s₀).rev}

              At most one sample maps to an axis-parallel question against a point.

              The adapter's axis-parallel base point, unreversed: exactly the seeded test's own.

              theorem MIPRE.LIDT.Adapter.base_of_qmapS_axis {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) {u₀ : Point F m} {s₀ : F} {yp : Point F m} {s : Sample F m} (h1 : qmapS hm σc s.questions.1 = CL.Question.aline u₀ s₀) (h2 : qmapS hm σc s.questions.2 = CL.Question.point yp) :
              u₀ = CL.rep (Pi.single (CL.chi hm s₀) 1) yp

              The base point the contributing sample forces. If anything contributes to an axis-parallel question against a point, the question is the one the seeded test itself would have asked at that point and seed: revPoint_rep_single unreverses the adapter's base point.

              theorem MIPRE.LIDT.Adapter.card_filter_axis_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (u₀ : Point F m) (s₀ : F) (yp : Point F m) (s : Sample F m) (hs : s ∈ {Sample.axis false (revPoint yp) (CL.chi hm s₀).rev}) :
              {σc : Seed F m | qmapS hm σc s.questions.1 = CL.Question.aline u₀ s₀ ∧ qmapS hm σc s.questions.2 = CL.Question.point yp}.card ≤ (Fintype.card F / m) ^ (m - 1) * (Fintype.card F - 1)

              The family members that can contribute to an axis-parallel question: the seed index is pinned, so there are at most (q/m)^{m-1} (q-1) of them.

              The arithmetic facts #

              Each shape ends in an inequality between two explicit rationals in q, m and q/m. These are the casts and positivity facts they all need.

              @[reducible, inline]
              noncomputable abbrev MIPRE.LIDT.Adapter.blk (F : Type u_2) [Fintype F] (m : ℕ) :

              The block size, as a real.

              Equations
              Instances For
                theorem MIPRE.LIDT.Adapter.blk_pos {F : Type u_1} [Field F] [Fintype F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) :
                0 < blk F m
                theorem MIPRE.LIDT.Adapter.m_mul_blk {F : Type u_1} [Fintype F] {m : ℕ} (hm : m ∣ Fintype.card F) :
                ↑m * blk F m = ↑(Fintype.card F)
                theorem MIPRE.LIDT.Adapter.card_seed_real {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} :
                ↑(Fintype.card (Seed F m)) = blk F m ^ m * (↑(Fintype.card F) - 1)

                The averaging family's size, as a real.

                theorem MIPRE.LIDT.Adapter.cast_card_clSample {F : Type u_1} [Fintype F] {m : ℕ} :
                ↑(Fintype.card (CL.Sample F m)) = 9 * (↑(Fintype.card (Point F m)) * (↑(Fintype.card F) * ↑(Fintype.card (Point F m))))

                The seeded test's sample space, as a real.

                The axis-parallel bound #

                theorem MIPRE.LIDT.Adapter.pushforward_axis {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d ldc : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (u₀ : Point F m) (s₀ : F) (yp : Point F m) :
                ∑ σc : Seed F m, ∑ x' : Question F m with qmapS hm σc x' = CL.Question.aline u₀ s₀, ∑ y' : Question F m with qmapS hm σc y' = CL.Question.point yp, (lidtGame F m d).μ x' y' ≤ ↑(Fintype.card (Seed F m)) * (3 * ↑m * (CL.clGame hm).μ (CL.Question.aline u₀ s₀) (CL.Question.point yp))

                The axis-parallel shape of the push-forward bound. The one contributing sample has weight 1/(6 m q^m), the family pins one seed index, and the seeded test puts at least 1/(9 q^{m+1}) on the pair; the three combine with room to spare at C = 3m (3/2 would do).

                The point bound #

                Here the averaging is neutral: the image of a point question does not depend on the family member, so both sides carry the same factor |Seed| and the requirement is the unaveraged 1/(3 q^m) ≤ C/(9 q^m).

                theorem MIPRE.LIDT.Adapter.pushforward_point {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d ldc : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (xp yp : Point F m) :
                ∑ σc : Seed F m, ∑ x' : Question F m with qmapS hm σc x' = CL.Question.point xp, ∑ y' : Question F m with qmapS hm σc y' = CL.Question.point yp, (lidtGame F m d).μ x' y' ≤ ↑(Fintype.card (Seed F m)) * (3 * ↑m * (CL.clGame hm).μ (CL.Question.point xp) (CL.Question.point yp))

                The point shape of the push-forward bound.

                The diagonal shape #

                Two cases, and they are genuinely different. A nondegenerate diagonal question determines the line, the scale and the seed index, so the family is pinned twice over and only (q/m)^{m-1} of its members contribute. A singleton question (direction zero) pins the seed index but not the scale --- scaling the zero direction does nothing --- and is paid for instead by diagIdx sending singleton lines to χ = m - 1, where the seeded test has q^{m-1} samples rather than one.

                @[simp]
                theorem MIPRE.LIDT.Adapter.revPoint_zero {F : Type u_1} [Field F] {m : ℕ} :
                @[simp]
                theorem MIPRE.LIDT.Adapter.extend_zero {F : Type u_1} [Field F] {m : ℕ} (j : Fin m) :
                @[simp]
                theorem MIPRE.LIDT.Adapter.through_zero {F : Type u_1} [Field F] [DecidableEq F] {m : ℕ} (u : Point F m) :
                theorem MIPRE.LIDT.Adapter.exists_diag_of_qmapS_dline {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) {u₀ : Point F m} {s₀ : F} {w yp : Point F m} {s : Sample F m} (h1 : qmapS hm σc s.questions.1 = CL.Question.dline u₀ s₀ w) (h2 : qmapS hm σc s.questions.2 = CL.Question.point yp) :
                ∃ (j : Fin m) (v : Fin (↑j + 1) → F), s = Sample.diag false (revPoint yp) j v

                Only a diagonal sample with the line on the left maps to a DLine question against a point, and the point pins its point.

                theorem MIPRE.LIDT.Adapter.eq_diag_zero_of_qmapS {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) {u₀ : Point F m} {s₀ : F} {yp : Point F m} {s : Sample F m} (h1 : qmapS hm σc s.questions.1 = CL.Question.dline u₀ s₀ 0) (h2 : qmapS hm σc s.questions.2 = CL.Question.point yp) :
                ∃ (j : Fin m), s = Sample.diag false (revPoint yp) j 0

                A singleton DLine question comes only from a sample with zero direction.

                theorem MIPRE.LIDT.Adapter.qmapS_diag_zero {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) (u : Point F m) (j : Fin m) :

                The adapter's image of a singleton diagonal line.

                theorem MIPRE.LIDT.Adapter.base_of_qmapS_dline_zero {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) {u₀ : Point F m} {s₀ : F} {yp : Point F m} {s : Sample F m} (h1 : qmapS hm σc s.questions.1 = CL.Question.dline u₀ s₀ 0) (h2 : qmapS hm σc s.questions.2 = CL.Question.point yp) :
                u₀ = yp ∧ seedOf hm idx0.rev (σc.1 idx0.rev) = s₀

                What a contributing sample forces, for a singleton DLine question.

                theorem MIPRE.LIDT.Adapter.rep_zero {F : Type u_1} [Field F] {m : ℕ} (u : Point F m) :
                CL.rep 0 u = u

                rep of the zero direction is the identity: a singleton line is its own base point.

                theorem MIPRE.LIDT.Adapter.pushforward_diag_zero {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d ldc : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (u₀ : Point F m) (s₀ : F) (yp : Point F m) :
                ∑ σc : Seed F m, ∑ x' : Question F m with qmapS hm σc x' = CL.Question.dline u₀ s₀ 0, ∑ y' : Question F m with qmapS hm σc y' = CL.Question.point yp, (lidtGame F m d).μ x' y' ≤ ↑(Fintype.card (Seed F m)) * (3 * ↑m * (CL.clGame hm).μ (CL.Question.dline u₀ s₀ 0) (CL.Question.point yp))

                The singleton diagonal shape of the push-forward bound. The m contributing samples have weight at most 1/(6 m q^m q), the family pins the seed index but not the scale, and the seeded test has q^{m-1} samples for this question --- which is why diagIdx sends singleton lines to the last block. The three combine at C = 3m with a factor 2 to spare.

                The nondegenerate diagonal shape #

                Here the question determines the line, the scale and the seed index, so the family is pinned twice and only (q/m)^{m-1} of its members contribute. That second pinning is what the scale averaging bought.

                theorem MIPRE.LIDT.Adapter.exists_ne_zero {F : Type u_1} [Field F] [DecidableEq F] {m : ℕ} {x : Point F m} (h : x ≠ 0) :
                ∃ (k : Fin m), x k ≠ 0
                theorem MIPRE.LIDT.Adapter.revPoint_ne_zero {F : Type u_1} [Field F] {m : ℕ} {x : Point F m} (h : x ≠ 0) :
                theorem MIPRE.LIDT.Adapter.ne_zero_of_exists {F : Type u_1} [Field F] {m : ℕ} {x : Point F m} (h : ∃ (k : Fin m), x k ≠ 0) :
                x ≠ 0
                theorem MIPRE.LIDT.Adapter.card_filter_pinned_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} (i : Fin m) (P : Seed F m → Prop) [DecidablePred P] (hP : ∀ a ∈ Finset.filter P Finset.univ, ∀ b ∈ Finset.filter P Finset.univ, a.1 i = b.1 i ∧ ↑a.2 = ↑b.2) :

                A set of family members agreeing at one seed index and on the scale has at most (q/m)^{m-1} elements.

                theorem MIPRE.LIDT.Adapter.adapter_base_eq_rep {F : Type u_1} [Field F] [DecidableEq F] {m : ℕ} {ℓ : Line F m} {x : Point F m} (hx : ∃ (t : F), revPoint x = ℓ.1 + t • ℓ.2) {c : F} (hc : c ≠ 0) :
                revPoint ℓ.1 - shiftOf ℓ • revPoint ℓ.2 = CL.rep (c • revPoint ℓ.2) x

                Rescaling a reversed direction does not move the adapter's base point off the seeded test's. This is the diagonal analogue of revPoint_through_single_eq_rep: the seeded question carries c · ρℓ₂ as its direction and rep of that is the adapter's ρℓ₁ - sh · ρℓ₂.

                theorem MIPRE.LIDT.Adapter.smul_revPoint_eq_zero_below {F : Type u_1} [Field F] [DecidableEq F] {m : ℕ} [NeZero m] {ℓ : Line F m} (hℓ : ∃ (k : Fin m), ℓ.2 k ≠ 0) (c : F) {k : Fin m} (hk : ↑k < ↑(diagIdx ℓ)) :
                (c • revPoint ℓ.2) k = 0

                A seeded direction vanishes below its own χ-index, which is what puts the question in the seeded test's support.

                theorem MIPRE.LIDT.Adapter.exists_dir_through {F : Type u_1} [Field F] [DecidableEq F] {m : ℕ} {u z : Point F m} (hz : ∃ (k : Fin m), z k ≠ 0) :
                ∃ (k : Fin m), (Line.through u z).2 k ≠ 0

                A canonical presentation has a nonzero direction as soon as its input direction is nonzero.

                theorem MIPRE.LIDT.Adapter.through_eq_through_revPoint {F : Type u_1} [Field F] [DecidableEq F] {m : ℕ} {u z w : Point F m} {c : F} (hc : c ≠ 0) (hz : ∃ (k : Fin m), z k ≠ 0) (h : c • revPoint (Line.through u z).2 = w) :

                Rescaling the reversed direction identifies the two canonical presentations.

                theorem MIPRE.LIDT.Adapter.data_of_questions_diagLine {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) {u₀ : Point F m} {s₀ : F} {w yp : Point F m} {s : Sample F m} {ℓ : Line F m} (hq : s.questions = (Question.diagLine ℓ, Question.point (revPoint yp))) (h1 : qmapS hm σc s.questions.1 = CL.Question.dline u₀ s₀ w) :
                revPoint ℓ.1 - shiftOf ℓ • revPoint ℓ.2 = u₀ ∧ seedOf hm (diagIdx ℓ) (σc.1 (diagIdx ℓ)) = s₀ ∧ ↑σc.2 • revPoint ℓ.2 = w

                The data a contributing sample carries, read off the question.

                theorem MIPRE.LIDT.Adapter.forced_of_qmapS_dline {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) {u₀ : Point F m} {s₀ : F} {w yp : Point F m} {s : Sample F m} (hw : w ≠ 0) (h1 : qmapS hm σc s.questions.1 = CL.Question.dline u₀ s₀ w) (h2 : qmapS hm σc s.questions.2 = CL.Question.point yp) :

                A sample mapping to a nondegenerate DLine question asks the reversed line at the reversed point.

                theorem MIPRE.LIDT.Adapter.base_of_qmapS_dline {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) {u₀ : Point F m} {s₀ : F} {w yp : Point F m} {s : Sample F m} (hw : w ≠ 0) (h1 : qmapS hm σc s.questions.1 = CL.Question.dline u₀ s₀ w) (h2 : qmapS hm σc s.questions.2 = CL.Question.point yp) :
                u₀ = CL.rep w yp ∧ CL.chi hm s₀ = diagIdx (Line.through (revPoint yp) (revPoint w)) ∧ ∀ (k : Fin m), ↑k < ↑(CL.chi hm s₀) → w k = 0

                What a contributing sample forces, for a nondegenerate DLine question.

                theorem MIPRE.LIDT.Adapter.pushforward_diag_ne {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d ldc : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (u₀ : Point F m) (s₀ : F) {w : Point F m} (hw : w ≠ 0) (yp : Point F m) :
                ∑ σc : Seed F m, ∑ x' : Question F m with qmapS hm σc x' = CL.Question.dline u₀ s₀ w, ∑ y' : Question F m with qmapS hm σc y' = CL.Question.point yp, (lidtGame F m d).μ x' y' ≤ ↑(Fintype.card (Seed F m)) * (3 * ↑m * (CL.clGame hm).μ (CL.Question.dline u₀ s₀ w) (CL.Question.point yp))

                The nondegenerate diagonal shape of the push-forward bound. At most m q samples contribute, each of weight at most 1/(6 m q^m q^{J+1}), and the family is pinned both at the seed index and on the scale, so only (q/m)^{m-1} of its members can contribute. Against the seeded test's q^{χ} samples, with J + 1 + χ = m, the constant comes out 3q/(2(q-1)), which C = 3m covers for every q ≥ 2.

                The pairs of lines, and the assembly #

                lidtGame's only same-type subtest is point self-consistency, so no sample asks two lines and the four remaining shapes carry no weight at all. That is the piece of luck this route runs on: it needs no line-synchronicity transfer, hence no Schwartz--Zippel and no d/q term.

                theorem MIPRE.LIDT.Adapter.filter_qmapS_line_line_eq_empty {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (σc : Seed F m) (x y : CL.Question F m) (hx : ∀ (u : Point F m), x ≠ CL.Question.point u) (hy : ∀ (u : Point F m), y ≠ CL.Question.point u) :
                {s : Sample F m | qmapS hm σc s.questions.1 = x ∧ qmapS hm σc s.questions.2 = y} = ∅

                No sample of the canonical-line test asks two lines.

                theorem MIPRE.LIDT.Adapter.pushforward_line_line {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d ldc : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (x y : CL.Question F m) (hx : ∀ (u : Point F m), x ≠ CL.Question.point u) (hy : ∀ (u : Point F m), y ≠ CL.Question.point u) :
                ∑ σc : Seed F m, ∑ x' : Question F m with qmapS hm σc x' = x, ∑ y' : Question F m with qmapS hm σc y' = y, (lidtGame F m d).μ x' y' ≤ ↑(Fintype.card (Seed F m)) * (3 * ↑m * (CL.clGame hm).μ x y)

                The shapes with a line on both sides carry no weight.

                theorem MIPRE.LIDT.Adapter.pushforward_swap {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d ldc : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (x y : CL.Question F m) (h : ∑ σc : Seed F m, ∑ x' : Question F m with qmapS hm σc x' = y, ∑ y' : Question F m with qmapS hm σc y' = x, (lidtGame F m d).μ x' y' ≤ ↑(Fintype.card (Seed F m)) * (3 * ↑m * (CL.clGame hm).μ y x)) :
                ∑ σc : Seed F m, ∑ x' : Question F m with qmapS hm σc x' = x, ∑ y' : Question F m with qmapS hm σc y' = y, (lidtGame F m d).μ x' y' ≤ ↑(Fintype.card (Seed F m)) * (3 * ↑m * (CL.clGame hm).μ x y)

                The bound for (x, y) is the bound for (y, x), both tests being symmetric under exchanging the players.

                theorem MIPRE.LIDT.Adapter.pushforward_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d ldc : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (x y : CL.Question F m) :
                ∑ σc : Seed F m, ∑ x' : Question F m with qmapS hm σc x' = x, ∑ y' : Question F m with qmapS hm σc y' = y, (lidtGame F m d).μ x' y' ≤ ↑(Fintype.card (Seed F m)) * (3 * ↑m * (CL.clGame hm).μ x y)

                The push-forward bound, assembled. The average over the family of the canonical-line test's mass on the fibre of a seeded question pair is at most 3m times the seeded test's mass on it. This is the hypothesis exists_one_sub_value_adapt_le asks for, and 3m is the constant thm:lidt-cl-soundness multiplies its ε by --- polynomial in m, as δ_CL allows, and free of q, which it does not.