Documentation

MIPRE.Background.QLD.Combine

The combining map and the padded line measurement #

Blueprint lem:qld-padded-lines, the definitional half. The pairs-of-lines stage measures a pair of line polynomials, one per basis; the low-degree test over the padded space F_q^{4m} wants a single polynomial on a single padded line. The bridge is the paper's combining map: on the padded point u = (x, z, alpha, beta, w) the combined polynomial takes the value

alpha * f_X(x) + beta * f_Z(z).

Three things have to be said about it, and this file says them.

What is not here is the consistency bound delta_combine; see the blueprint.

In a bipartite model #

Stated in a bipartite model (Phase 5 of planning/mipco-track.md). Only the measurement changes: the pasted line measurement (MIPRE/Background/QLD/Lines.lean) is a family of elements of Matrix (Anc F m) (Anc F m) R over a player's ordered ⋆-algebra R, with no combining register F × F (it was inert in every padded measurement), so padLineMats is an average of pasted sandwiches there. Completeness is IsPVMIn.sum_conj' and nonnegativity is the Gram form IsPVMIn.conj_eq_gram of a sandwich, averaged with nonnegative real weights (real_smul_nonneg); the name posSemidef_* is kept for these nonnegativity statements. The combinatorics of the combining map is unchanged.

The affine data, and why the whole geometry is in xBlk_dir_sub #

The one calculation behind the affine substitutions is this. Moving along the padded line moves the X block by tau * xBlk(dir), and xBlk_dir_sub says that block is either the X subline's own direction or zero. In the first case the parameter on the subline moves by exactly tau, in the second it does not move at all --- so in both cases it is p0 + c * tau with c one or zero, and subAff is that pair. Nothing else about the construction is used.

Affine maps of the line parameter #

def MIPRE.QLD.affEval {F : Type u_1} [Field F] (a : F × F) (t : F) :
F

An affine map t |-> a.1 + a.2 * t of the line parameter, as the pair of its coefficients.

Equations
Instances For
    theorem MIPRE.QLD.affEval_of_snd_eq_zero {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {a : F × F} (h : a.2 = 0) (t : F) :
    affEval a t = a.1
    noncomputable def MIPRE.QLD.affPoly {F : Type u_1} [Field F] (a : F × F) :

    The degree-one polynomial an affine map is.

    Equations
    Instances For
      theorem MIPRE.QLD.eval_affPoly {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] (a : F × F) (t : F) :
      theorem MIPRE.QLD.affPoly_of_snd_eq_zero {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {a : F × F} (h : a.2 = 0) :

      A constant affine map is a constant polynomial.

      theorem MIPRE.QLD.natDegree_affPoly_eq_zero {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {a : F × F} (h : a.2 = 0) :

      Coefficient vectors and polynomials, the other way #

      toPoly (in Lines.lean) reads a coefficient vector as a polynomial; ofPoly truncates a polynomial to a coefficient vector, and agrees with it in value as soon as the degree fits.

      def MIPRE.QLD.ofPoly {F : Type u_1} [Field F] (n : ℕ) (p : Polynomial F) :

      The coefficient vector of degree at most n a polynomial truncates to.

      Equations
      Instances For
        theorem MIPRE.QLD.eval_ofPoly {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {n : ℕ} {p : Polynomial F} (hp : p.natDegree ≤ n) (t : F) :
        def MIPRE.QLD.DegLE {F : Type u_1} [Field F] {n : ℕ} (f : LIDT.LinePoly F n) (k : ℕ) :

        Degree at most k, as a predicate on coefficient vectors: everything above k vanishes. The answer alphabet is LinePoly F (m d) throughout, so a sharper degree bound on an axis-parallel line is a property of the vector rather than a change of type.

        Equations
        Instances For
          theorem MIPRE.QLD.DegLE.mono {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {n : ℕ} {f : LIDT.LinePoly F n} {k k' : ℕ} (h : DegLE f k) (hk : k ≤ k') :
          DegLE f k'
          theorem MIPRE.QLD.degLE_ofPoly {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {n k : ℕ} {p : Polynomial F} (h : p.natDegree ≤ k) :
          DegLE (ofPoly n p) k
          theorem MIPRE.QLD.natDegree_toPoly_le_of_degLE {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {n : ℕ} {f : LIDT.LinePoly F n} {k : ℕ} (h : DegLE f k) :

          The combining map #

          noncomputable def MIPRE.QLD.combinePoly {F : Type u_1} [Field F] {n : ℕ} (aAff bAff xAff zAff : F × F) (fX fZ : LIDT.LinePoly F n) :

          The polynomial alpha(t) f_X(x(t)) + beta(t) f_Z(z(t)) with all four substitutions affine.

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            theorem MIPRE.QLD.natDegree_comp_affPoly_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {n k : ℕ} (a : F × F) {f : LIDT.LinePoly F n} (hf : (toPoly f).natDegree ≤ k) :
            theorem MIPRE.QLD.natDegree_combinePoly_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {n : ℕ} (aAff bAff xAff zAff : F × F) (fX fZ : LIDT.LinePoly F n) :
            (combinePoly aAff bAff xAff zAff fX fZ).natDegree ≤ n + 1
            noncomputable def MIPRE.QLD.combine {F : Type u_1} [Field F] {n : ℕ} (aAff bAff xAff zAff : F × F) (fX fZ : LIDT.LinePoly F n) :

            The combining map. The four affine maps are, in order: alpha and beta along the padded line, and the parameter of the X and Z blocks on their sublines.

            Equations
            Instances For
              theorem MIPRE.QLD.eval_combine {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {n : ℕ} (aAff bAff xAff zAff : F × F) (fX fZ : LIDT.LinePoly F n) (t : F) :
              (combine aAff bAff xAff zAff fX fZ).eval t = affEval aAff t * fX.eval (affEval xAff t) + affEval bAff t * fZ.eval (affEval zAff t)

              The defining property of the combining map: at the padded parameter t its value is alpha(t) f_X(x(t)) + beta(t) f_Z(z(t)).

              theorem MIPRE.QLD.degLE_combine_of_blocks_const {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {n : ℕ} {aAff bAff xAff zAff : F × F} (fX fZ : LIDT.LinePoly F n) (hx : xAff.2 = 0) (hz : zAff.2 = 0) :
              DegLE (combine aAff bAff xAff zAff fX fZ) 1

              When both blocks are constant along the padded line the combined polynomial is affine. This is the case of a padded direction in the alpha, beta or dummy block.

              theorem MIPRE.QLD.degLE_combine_of_ab_const {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {n : ℕ} {aAff bAff xAff zAff : F × F} {fX fZ : LIDT.LinePoly F n} {k : ℕ} (ha : aAff.2 = 0) (hb : bAff.2 = 0) (hX : DegLE fX k) (hZ : DegLE fZ k) :
              DegLE (combine aAff bAff xAff zAff fX fZ) k

              When alpha and beta are constant along the padded line the combined polynomial inherits the degree of the two inputs. This is the case of a padded direction in the X or Z block.

              The affine substitution a subline induces #

              theorem MIPRE.QLD.lineParam_dir_zero {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (u₀ y : LIDT.Point F m) :
              LIDT.CL.lineParam u₀ 0 y = 0

              A degenerate line assigns every point the parameter zero.

              theorem MIPRE.QLD.lineParam_self {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (u₀ w : LIDT.Point F m) :
              LIDT.CL.lineParam u₀ w u₀ = 0

              The base point has parameter zero.

              noncomputable def MIPRE.QLD.subAff {F : Type u_1} [Field F] [DecidableEq F] {m : ℕ} (W w x : LIDT.Point F m) :
              F × F

              The affine substitution the subline's parametrization induces. The constant term is the parameter of the unshifted block, and the linear term is 1 exactly when the padded direction moves the block along a nondegenerate subline.

              Equations
              Instances For
                theorem MIPRE.QLD.subAff_snd_of_eq_zero {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (W x : LIDT.Point F m) :
                (subAff W 0 x).2 = 0
                theorem MIPRE.QLD.on_line_affEval {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] {W w : LIDT.Point F m} (h : w = W ∨ w = 0) (x : LIDT.Point F m) (tau : F) :
                x + tau • w = LIDT.CL.rep W x + affEval (subAff W w x) tau • W

                The shifted block lies on the subline at the affine parameter.

                theorem MIPRE.QLD.lineParam_affEval {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] {W w : LIDT.Point F m} (h : w = W ∨ w = 0) (x : LIDT.Point F m) (tau : F) :
                LIDT.CL.lineParam (LIDT.CL.rep W x) W (x + tau • w) = affEval (subAff W w x) tau

                The parameter of the shifted block on the subline is affine in the padded parameter.

                The affine data of a padded line and its sublines #

                theorem MIPRE.QLD.alph_single_of_ne {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] {j : Fin (4 * m)} (h : j ≠ aIdx m) (c : F) :
                alph (Pi.single j c) = 0

                The alpha coordinate of a single coordinate vector away from alpha vanishes.

                theorem MIPRE.QLD.bet_single_of_ne {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] {j : Fin (4 * m)} (h : j ≠ bIdx m) (c : F) :
                bet (Pi.single j c) = 0
                theorem MIPRE.QLD.LPData.dir_congr {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (ty : LIDT.CL.Ty) {c c' : LPData F m} (hs : c.s = c'.s) (hr : c.raw = c'.raw) :
                dir hm ty c = dir hm ty c'

                The direction a data presents does not depend on its point.

                noncomputable def MIPRE.QLD.padShift {F : Type u_1} [Field F] [Fintype F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (tau : F) (P : LPData F (4 * m)) :
                LPData F (4 * m)

                Moving the padded point along the padded line by tau.

                Equations
                Instances For
                  @[simp]
                  theorem MIPRE.QLD.padShift_pt {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (tau : F) (P : LPData F (4 * m)) :
                  (padShift hm4 ty tau P).pt = P.pt + tau • LPData.dir hm4 ty P
                  @[simp]
                  theorem MIPRE.QLD.padShift_s {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (tau : F) (P : LPData F (4 * m)) :
                  (padShift hm4 ty tau P).s = P.s
                  @[simp]
                  theorem MIPRE.QLD.padShift_raw {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (tau : F) (P : LPData F (4 * m)) :
                  (padShift hm4 ty tau P).raw = P.raw
                  theorem MIPRE.QLD.subX_padShift {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (tau : F) (P : LPData F (4 * m)) (e : F × LIDT.Point F m) :
                  subX hm4 hm (padShift hm4 ty tau P) e = have __src := subX hm4 hm P e; { pt := xBlk (padShift hm4 ty tau P).pt, s := __src.s, raw := __src.raw }

                  The subline data is unchanged by the padded shift except in its point, because the seed and the raw direction it reads are.

                  theorem MIPRE.QLD.subZ_padShift {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty ty' : LIDT.CL.Ty) (tau : F) (P : LPData F (4 * m)) (e : F × LIDT.Point F m) :
                  subZ hm4 hm ty' (padShift hm4 ty tau P) e = have __src := subZ hm4 hm ty' P e; { pt := zBlk (padShift hm4 ty tau P).pt, s := __src.s, raw := __src.raw }
                  theorem MIPRE.QLD.subX_padShift_dir {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty ty' : LIDT.CL.Ty) (tau : F) (P : LPData F (4 * m)) (e : F × LIDT.Point F m) :
                  LPData.dir hm ty' (subX hm4 hm (padShift hm4 ty tau P) e) = LPData.dir hm ty' (subX hm4 hm P e)
                  theorem MIPRE.QLD.subZ_padShift_dir {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty ty' : LIDT.CL.Ty) (tau : F) (P : LPData F (4 * m)) (e : F × LIDT.Point F m) :
                  LPData.dir hm ty' (subZ hm4 hm ty' (padShift hm4 ty tau P) e) = LPData.dir hm ty' (subZ hm4 hm ty' P e)
                  theorem MIPRE.QLD.rep_xBlk_padShift {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (tau : F) (P : LPData F (4 * m)) (e : F × LIDT.Point F m) :
                  LIDT.CL.rep (LPData.dir hm ty (subX hm4 hm P e)) (xBlk (padShift hm4 ty tau P).pt) = LIDT.CL.rep (LPData.dir hm ty (subX hm4 hm P e)) (xBlk P.pt)

                  The subline's base point is unchanged by the padded shift, which is where the containment of lem:qld-sublines is used: the block either moves along the subline or does not move.

                  theorem MIPRE.QLD.rep_zBlk_padShift {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (tau : F) (P : LPData F (4 * m)) (e : F × LIDT.Point F m) :
                  LIDT.CL.rep (LPData.dir hm ty (subZ hm4 hm ty P e)) (zBlk (padShift hm4 ty tau P).pt) = LIDT.CL.rep (LPData.dir hm ty (subZ hm4 hm ty P e)) (zBlk P.pt)

                  The four affine maps #

                  noncomputable def MIPRE.QLD.aAffOf {F : Type u_1} [Field F] [Fintype F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (P : LPData F (4 * m)) :
                  F × F

                  alpha along the padded line.

                  Equations
                  Instances For
                    noncomputable def MIPRE.QLD.bAffOf {F : Type u_1} [Field F] [Fintype F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (P : LPData F (4 * m)) :
                    F × F

                    beta along the padded line.

                    Equations
                    Instances For
                      noncomputable def MIPRE.QLD.xAffOf {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (P : LPData F (4 * m)) (e : F × LIDT.Point F m) :
                      F × F

                      The parameter of the X block on the X subline, along the padded line.

                      Equations
                      Instances For
                        noncomputable def MIPRE.QLD.zAffOf {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (P : LPData F (4 * m)) (e : F × LIDT.Point F m) :
                        F × F

                        The parameter of the Z block on the Z subline, along the padded line.

                        Equations
                        Instances For
                          theorem MIPRE.QLD.affEval_aAffOf {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (P : LPData F (4 * m)) (tau : F) :
                          affEval (aAffOf hm4 ty P) tau = alph (padShift hm4 ty tau P).pt
                          theorem MIPRE.QLD.affEval_bAffOf {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (P : LPData F (4 * m)) (tau : F) :
                          affEval (bAffOf hm4 ty P) tau = bet (padShift hm4 ty tau P).pt

                          The parameter identity #

                          A line presentation reads the subline data through ofLPX / ofLPZ; the two hypotheses say it reads it as the seeded test does --- the base point is the canonical representative of the point in the direction, and the direction is the one the data presents. Both hold for aPres and dPres by rfl.

                          theorem MIPRE.QLD.aPres_base_eq {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (W : Bas) (c : Content F m) :
                          (aPres hm W).base c = LIDT.CL.rep ((aPres hm W).dir c) (c.pt W)
                          theorem MIPRE.QLD.dPres_base_eq {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (W : Bas) (c : Content F m) :
                          (dPres hm W).base c = LIDT.CL.rep ((dPres hm W).dir c) (c.pt W)
                          theorem MIPRE.QLD.aPres_dir_ofLPX {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (D : LPData F m) (u : LIDT.Point F m) :
                          theorem MIPRE.QLD.aPres_dir_ofLPZ {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (D : LPData F m) (u : LIDT.Point F m) :
                          theorem MIPRE.QLD.dPres_dir_ofLPX {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (D : LPData F m) (u : LIDT.Point F m) :
                          theorem MIPRE.QLD.dPres_dir_ofLPZ {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (D : LPData F m) (u : LIDT.Point F m) :
                          theorem MIPRE.QLD.param_subX_padShift {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (PX : LinePres F m hm Bas.X) (hbase : ∀ (c : Content F m), PX.base c = LIDT.CL.rep (PX.dir c) (c.pt Bas.X)) (hdir : ∀ (D : LPData F m) (u : LIDT.Point F m), PX.dir (ofLPX D u) = LPData.dir hm ty D) (P : LPData F (4 * m)) (e : F × LIDT.Point F m) (u : LIDT.Point F m) (tau : F) :
                          PX.param (ofLPX (subX hm4 hm (padShift hm4 ty tau P) e) u) = affEval (xAffOf hm4 hm ty P e) tau

                          The X subline parameter of the shifted point is xAffOf at the padded parameter.

                          theorem MIPRE.QLD.param_subZ_padShift {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (PZ : LinePres F m hm Bas.Z) (hbase : ∀ (c : Content F m), PZ.base c = LIDT.CL.rep (PZ.dir c) (c.pt Bas.Z)) (hdir : ∀ (D : LPData F m) (u : LIDT.Point F m), PZ.dir (ofLPZ D u) = LPData.dir hm ty D) (P : LPData F (4 * m)) (e : F × LIDT.Point F m) (u : LIDT.Point F m) (tau : F) :
                          PZ.param (ofLPZ (subZ hm4 hm ty (padShift hm4 ty tau P) e) u) = affEval (zAffOf hm4 hm ty P e) tau

                          The Z subline parameter of the shifted point is zAffOf at the padded parameter.

                          The padded combining map #

                          noncomputable def MIPRE.QLD.padCombine {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (d : ℕ) (P : LPData F (4 * m)) (eX eZ : F × LIDT.Point F m) (q : LIDT.LinePoly F (m * d) × LIDT.LinePoly F (m * d)) :
                          LIDT.LinePoly F (m * d + 1)

                          The combining map at a padded line and its two sublines.

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For
                            theorem MIPRE.QLD.eval_padCombine {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (PX : LinePres F m hm Bas.X) (PZ : LinePres F m hm Bas.Z) (hbaseX : ∀ (c : Content F m), PX.base c = LIDT.CL.rep (PX.dir c) (c.pt Bas.X)) (hdirX : ∀ (D : LPData F m) (u : LIDT.Point F m), PX.dir (ofLPX D u) = LPData.dir hm ty D) (hbaseZ : ∀ (c : Content F m), PZ.base c = LIDT.CL.rep (PZ.dir c) (c.pt Bas.Z)) (hdirZ : ∀ (D : LPData F m) (u : LIDT.Point F m), PZ.dir (ofLPZ D u) = LPData.dir hm ty D) (P : LPData F (4 * m)) (eX eZ : F × LIDT.Point F m) (q : LIDT.LinePoly F (m * d) × LIDT.LinePoly F (m * d)) (uZ uX : LIDT.Point F m) (tau : F) :
                            (padCombine hm4 hm ty d P eX eZ q).eval tau = alph (padShift hm4 ty tau P).pt * q.1.eval (PX.param (ofLPX (subX hm4 hm (padShift hm4 ty tau P) eX) uZ)) + bet (padShift hm4 ty tau P).pt * q.2.eval (PZ.param (ofLPZ (subZ hm4 hm ty (padShift hm4 ty tau P) eZ) uX))

                            The paper's defining property of the combining map: at the padded parameter tau the combined polynomial takes the value alpha * f_X(x) + beta * f_Z(z) at the corresponding point of the padded line, x and z being read on their own sublines.

                            The degree bound on an axis-parallel padded line #

                            theorem MIPRE.QLD.degLE_padCombine_aline {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (hd : 1 ≤ d) (P : LPData F (4 * m)) (eX eZ : F × LIDT.Point F m) (q : LIDT.LinePoly F (m * d) × LIDT.LinePoly F (m * d)) (hX : DegLE q.1 d) (hZ : DegLE q.2 d) :
                            DegLE (padCombine hm4 hm LIDT.CL.Ty.aline d P eX eZ q) d

                            On an axis-parallel padded line the combined polynomial has degree at most d. The three branches are the paper's: a direction in the X or the Z block leaves alpha and beta constant, and a direction at alpha, beta or a dummy coordinate leaves both blocks constant, which gives degree at most one.

                            The padded line measurement #

                            The paper's Q-hat^l_f is the conditional average, over the sublines the construction of lem:qld-sublines draws for the given padded line, of the pasted line measurement T^{l_X,l_Z}_{f_X,f_Z}, coarse-grained by the combining map. Conditioning on the padded line means averaging over the fresh randomness the construction draws --- a seed and a raw direction per side --- and nothing else, so the conditional average is a plain uniform average over SubRand.

                            theorem MIPRE.QLD.sum_pasteLine {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] {hm : m ∣ Fintype.card F} {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (PX : LinePres F m hm Bas.X) (PZ : LinePres F m hm Bas.Z) (cX cZ : Content F m) :
                            ∑ q : LIDT.LinePoly F (m * d) × LIDT.LinePoly F (m * d), pasteLine PX PZ d S cX cZ q = 1

                            The pasted line measurement is complete: the inner family sums away against the outer one's projectivity (IsPVMIn.sum_conj'), the outer line measurement being the conjugating one.

                            theorem MIPRE.QLD.posSemidef_pasteLine {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] {hm : m ∣ Fintype.card F} {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (PX : LinePres F m hm Bas.X) (PZ : LinePres F m hm Bas.Z) (cX cZ : Content F m) (q : LIDT.LinePoly F (m * d) × LIDT.LinePoly F (m * d)) :
                            0 ≤ pasteLine PX PZ d S cX cZ q

                            Each element of the pasted line measurement is nonnegative: a sandwich of projections is a Gram element (Z X)⋆ (Z X) (IsPVMIn.conj_eq_gram), nonnegative in the model's order.

                            @[reducible, inline]
                            abbrev MIPRE.QLD.SubRand (F : Type u_3) (m : ℕ) :
                            Type u_3

                            The fresh randomness the subline construction draws: a seed and a raw direction per side.

                            Equations
                            Instances For
                              noncomputable def MIPRE.QLD.subPair {F : Type u_1} [Field F] [Fintype F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (hm : m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (P : LPData F (4 * m)) (e : SubRand F m) :
                              LPData F m × LPData F m

                              The pair of subline data a padded line and the fresh randomness produce --- the sample the product form of lem:qld-pairs-of-lines is stated over.

                              Equations
                              Instances For
                                noncomputable def MIPRE.QLD.padLineMats {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] {hm : m ∣ Fintype.card F} (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (PX : LinePres F m hm Bas.X) (PZ : LinePres F m hm Bas.Z) (S : Question F m → POVMIn (Answer F m d) R) (P : LPData F (4 * m)) (f : LIDT.LinePoly F (m * d + 1)) :
                                Matrix (Anc F m) (Anc F m) R

                                The padded line measurement Q-hat^l, in the register's matrices over the player's algebra. Its outcomes are line polynomials of degree at most md + 1 on the padded line, and on an axis-parallel padded line degLE_padCombine_aline sharpens that to d.

                                Equations
                                • One or more equations did not get rendered due to their size.
                                Instances For
                                  theorem MIPRE.QLD.sum_padLineMats {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] {hm : m ∣ Fintype.card F} {S : Question F m → POVMIn (Answer F m d) R} (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (PX : LinePres F m hm Bas.X) (PZ : LinePres F m hm Bas.Z) (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (P : LPData F (4 * m)) :
                                  ∑ f : LIDT.LinePoly F (m * d + 1), padLineMats hm4 ty PX PZ S P f = 1

                                  The padded line measurement is complete. The fibres of the combining map partition the pairs of line polynomials, so the outcome sum is the pasted measurement's own.

                                  theorem MIPRE.QLD.posSemidef_padLineMats {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] {hm : m ∣ Fintype.card F} {S : Question F m → POVMIn (Answer F m d) R} (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (PX : LinePres F m hm Bas.X) (PZ : LinePres F m hm Bas.Z) (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (P : LPData F (4 * m)) (f : LIDT.LinePoly F (m * d + 1)) :
                                  0 ≤ padLineMats hm4 ty PX PZ S P f

                                  Each outcome of the padded line measurement is nonnegative: an average of pasted sandwiches, each a Gram element (real_smul_nonneg).

                                  theorem MIPRE.QLD.sum_filter_fiber {α : Type u_3} {β : Type u_4} {N : Type u_5} [Fintype α] [Fintype β] [DecidableEq β] [AddCommMonoid N] (g : α → β) (p : β → Prop) [DecidablePred p] (T : α → N) :
                                  ∑ b : β with p b, ∑ a : α with g a = b, T a = ∑ a : α with p (g a), T a

                                  Coarse-graining a fibre sum again: summing the fibres of g over a set of values is summing over the preimage of that set.

                                  theorem MIPRE.QLD.sum_filter_padLineMats {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] {hm : m ∣ Fintype.card F} {S : Question F m → POVMIn (Answer F m d) R} (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (PX : LinePres F m hm Bas.X) (PZ : LinePres F m hm Bas.Z) (hbaseX : ∀ (c : Content F m), PX.base c = LIDT.CL.rep (PX.dir c) (c.pt Bas.X)) (hdirX : ∀ (D : LPData F m) (u : LIDT.Point F m), PX.dir (ofLPX D u) = LPData.dir hm ty D) (hbaseZ : ∀ (c : Content F m), PZ.base c = LIDT.CL.rep (PZ.dir c) (c.pt Bas.Z)) (hdirZ : ∀ (D : LPData F m) (u : LIDT.Point F m), PZ.dir (ofLPZ D u) = LPData.dir hm ty D) (P : LPData F (4 * m)) (tau a : F) :
                                  ∑ f : LIDT.LinePoly F (m * d + 1) with f.eval tau = a, padLineMats hm4 ty PX PZ S P f = ↑(↑(Fintype.card (SubRand F m)))⁻¹ • ∑ e : SubRand F m, ∑ q : LIDT.LinePoly F (m * d) × LIDT.LinePoly F (m * d) with alph (padShift hm4 ty tau P).pt * q.1.eval (PX.param (pairCX (subPair hm4 hm ty (padShift hm4 ty tau P) e))) + bet (padShift hm4 ty tau P).pt * q.2.eval (PZ.param (pairCZ (subPair hm4 hm ty (padShift hm4 ty tau P) e))) = a, pasteLine PX PZ d S (pairCX (subPair hm4 hm ty P e)) (pairCZ (subPair hm4 hm ty P e)) q

                                  The padded line measurement, coarse-grained by evaluation at the sampled padded point, is the pasted line measurement coarse-grained by the combined evaluation. This is the data-processing step the paper's proof of lem:qld-padded-lines ends with, and it is the form in which pairs_of_lines_prod applies: on the right each side's polynomial is read at the parameter of its own subline, which is the outcome map the product form of the pairs-of-lines lemma bounds.