Documentation

MIPRE.Background.QLD.PaddedStrategy

The padded strategy for the seeded low individual degree test #

Stage 4 of the Pauli basis test's analysis (lem:qld-global-setup, lem:qld-global-success) assembles the padded point and line measurements of lem:qld-padded-points and lem:qld-padded-lines into a strategy for the seeded test clGame at parameters (q, 4m, d, 1), and shows that it succeeds with probability 1 - O(δ_combine + δ_Q + md/q). This file defines the strategy and bounds its conditional failure at each of the seeded test's question pairs by an agreement defect of the measurements it is built from; the averages over the verifier's samples, and the value bound, are in PaddedValue.lean.

The model, and why the strategy is a family of POVMs #

The strategy lives in the expanded model M.reg (Anc F m) of stage 2: each player's measurements are elements of Matrix (Anc F m) (Anc F m) R over the player's algebra R (the player's own algebra and the expansion's ancilla, register outer). There is no register for the combining coefficients: it was inert in every padded measurement. The point measurement is the sandwich M^Z_b M^X_a M^Z_b of the hatted point measurements (POVMIn.sand), coarse-grained along (a, b) ↦ α a + β b; its line measurements are the padded line measurements padLineMats, averaged over the raw directions. Both are POVMs --- the point elements are coarse-grainings of Gram elements (X_a Z_b)⋆ (X_a Z_b), the line elements averages of pasted sandwiches --- and neither is projective, so the strategy is a family of POVMs, and one Halmos dilation at the end makes it the projective strategy the soundness theorem takes. The dilated point measurement of lem:qld-padded-points is not used: every bound of stage 3 is stated for the sandwich itself (combined_points_pts, padded_lines_consistency).

In a bipartite model #

Stated in a bipartite model (Phase 5 of planning/mipco-track.md). The strategy of each player is padStrat hm hm4 hS for a projective family S : Question F m → POVMIn (Answer F m d) R (the design's padStratIn; the cited names padStrat, padPt, padPtPair, padLinePOVM, lineMeas are the model versions), the conditional failures are those of any bipartite model whose algebras are the two players' Matrix (Anc F m) (Anc F m) _ (in particular M.reg (Anc F m)), and polynomial separation holds in any bipartite model. The model forms of the matrix helpers POVM.ofPosSemidef, POVM.avgOn and the support lemmas of coarse-grainings are POVMIn.ofNonneg, POVMIn.avgOn, POVMIn.map_congr_of_support, POVMIn.map_op_eq_zero_of_forall_ne and POVMIn.map_const_op below.

A function of the question #

The seeded test asks for a measurement per question, while padLineMats is indexed by the data ⟨pt, s, raw⟩ a sample generates the question from. A line question carries the canonical base point u₀ of the line, the seed, and for a diagonal line the truncated direction v'; the strategy answers it with the padded line measurement at the data ⟨u₀, s, raw⟩, averaged over the raw directions that produce the question (rawFiber). Two things make this the right choice. The decider reads the answer polynomial at the parameter of the sampled point relative to u₀, and moving the data's point to the sampled point along the line does not change the padded line measurement (pasteLine_subPair_padShift), so what the decider reads is padLineMats at the sample's own data, coarse-grained by evaluation at the sample's point --- exactly the quantity lem:qld-padded-lines controls (lineMeas_map_eval_mats). And the sample distribution averages uniformly over the raw direction, so by linearity of the Born rule the strategy's failure at a question is the average of the per-sample quantities.

POVMs in a ⋆-algebra from nonnegative families, uniform averages, and supports #

The model forms of POVM.ofPosSemidef, POVM.avgOn and three facts about coarse-grainings (MIPRE/Foundations/POVMMix.lean), which the padded strategy needs in a player's algebra.

def MIPRE.POVMIn.ofNonneg {R : Type u_1} [Ring R] [StarRing R] [PartialOrder R] [StarOrderedRing R] {A : Type u_2} [Fintype A] (E : A → R) (hpos : ∀ (a : A), 0 ≤ E a) (hsum : ∑ a : A, E a = 1) :
POVMIn A R

A POVM from a family of nonnegative elements summing to one, in a star-ordered ring: a nonnegative element is self-adjoint.

Equations
Instances For
    @[simp]
    theorem MIPRE.POVMIn.ofNonneg_op {R : Type u_1} [Ring R] [StarRing R] [PartialOrder R] [StarOrderedRing R] {A : Type u_2} [Fintype A] (E : A → R) (hpos : ∀ (a : A), 0 ≤ E a) (hsum : ∑ a : A, E a = 1) (a : A) :
    (ofNonneg E hpos hsum).op a = E a
    theorem MIPRE.POVMIn.map_op_eq_zero_of_forall_ne {R : Type u_1} [Ring R] [StarRing R] [PartialOrder R] [StarOrderedRing R] {A : Type u_2} [Fintype A] {B : Type u_3} [Fintype B] [DecidableEq B] (f : A → B) (M : POVMIn A R) {b : B} (h : ∀ (a : A), f a ≠ b) :
    (map f M).op b = 0

    An outcome outside the range of the relabelling carries the zero element.

    theorem MIPRE.POVMIn.map_congr_of_support {R : Type u_1} [Ring R] [StarRing R] [PartialOrder R] [StarOrderedRing R] {A : Type u_2} [Fintype A] {B : Type u_3} [Fintype B] [DecidableEq B] {f g : A → B} (M : POVMIn A R) (h : ∀ (a : A), M.op a ≠ 0 → f a = g a) :
    map f M = map g M

    Two relabellings that agree on the support of a POVM relabel it the same way.

    theorem MIPRE.POVMIn.map_const_op {R : Type u_1} [Ring R] [StarRing R] [PartialOrder R] [StarOrderedRing R] {A : Type u_2} [Fintype A] (M : POVMIn A R) :
    (map (fun (x : A) => ()) M).op () = 1

    Forgetting the outcome altogether gives the identity.

    noncomputable def MIPRE.POVMIn.avgOn {R : Type u_1} [Ring R] [StarRing R] [PartialOrder R] [StarOrderedRing R] {A : Type u_2} [Fintype A] [Algebra ℂ R] [StarModule ℂ R] [DecidableEq A] {ι : Type u_3} [Fintype ι] [DecidableEq ι] (T : Finset ι) (Q : ι → POVMIn A R) (a₀ : A) :
    POVMIn A R

    The uniform average of POVMs over a finset, defaulting to the deterministic answer a₀ when the finset is empty.

    Equations
    Instances For
      theorem MIPRE.POVMIn.avgOn_op {R : Type u_1} [Ring R] [StarRing R] [PartialOrder R] [StarOrderedRing R] {A : Type u_2} [Fintype A] [Algebra ℂ R] [StarModule ℂ R] [DecidableEq A] {ι : Type u_3} [Fintype ι] [DecidableEq ι] {T : Finset ι} (hT : T.Nonempty) (Q : ι → POVMIn A R) (a₀ a : A) :
      (avgOn T Q a₀).op a = ↑(↑T.card)⁻¹ • ∑ i ∈ T, (Q i).op a

      The elements of a uniform average over a nonempty finset.

      The padded point measurement #

      noncomputable def MIPRE.QLD.padPtPair {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] {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (u : LIDT.Point F (4 * m)) :
      POVMIn (F × F) (Matrix (Anc F m) (Anc F m) R)

      The sandwich M^Z_b M^X_a M^Z_b of the hatted point measurements at the X and Z blocks of a padded point, as a POVM in the register's matrices over the player's algebra, with outcomes the pairs (a, b).

      Equations
      Instances For
        @[simp]
        theorem MIPRE.QLD.padPtPair_mats {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] {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (u : LIDT.Point F (4 * m)) (r : F × F) :
        (padPtPair hS u).op r = sand (hatMats S Bas.X (xBlk u)) (hatMats S Bas.Z (zBlk u)) r
        def MIPRE.QLD.padComb {F : Type u_1} [Field F] {m : ℕ} [NeZero m] (u : LIDT.Point F (4 * m)) (r : F × F) :
        F

        The combining coefficients' reading of a pair outcome at a padded point: (a, b) ↦ α a + β b.

        Equations
        Instances For
          noncomputable def MIPRE.QLD.padPt {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] {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (u : LIDT.Point F (4 * m)) :
          POVMIn F (Matrix (Anc F m) (Anc F m) R)

          The padded point measurement: the sandwich read through the combining coefficients, the strategy's answer to a point question as a POVM with outcomes in F.

          Equations
          Instances For
            theorem MIPRE.QLD.padPt_mats {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] {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (u : LIDT.Point F (4 * m)) (a : F) :
            (padPt hS u).op a = ptComb (sand (hatMats S Bas.X (xBlk u)) (hatMats S Bas.Z (zBlk u))) (alph u) (bet u) a

            The padded line measurements, as POVMs #

            noncomputable def MIPRE.QLD.padLinePOVM {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] {hm : m ∣ Fintype.card F} {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper 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) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (P : LPData F (4 * m)) :
            POVMIn (LIDT.LinePoly F (m * d + 1)) (Matrix (Anc F m) (Anc F m) R)

            padLineMats, bundled as a POVM in the register's matrices over the player's algebra.

            Equations
            Instances For
              @[simp]
              theorem MIPRE.QLD.padLinePOVM_mats {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] {hm : m ∣ Fintype.card F} {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper 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) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (P : LPData F (4 * m)) (f : LIDT.LinePoly F (m * d + 1)) :
              (padLinePOVM hm4 ty PX PZ hS P).op f = padLineMats hm4 ty PX PZ S P f
              noncomputable def MIPRE.QLD.presOf {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) (W : Bas) :
              LinePres F m hm W

              The presentation of a line type on side W: the diagonal one for dline, the axis-parallel one otherwise.

              Equations
              Instances For
                theorem MIPRE.QLD.factorsX_presOf {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) :
                theorem MIPRE.QLD.factorsZ_presOf {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) :
                theorem MIPRE.QLD.presOf_base_eq {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) (W : Bas) (c : Content F m) :
                (presOf hm ty W).base c = LIDT.CL.rep ((presOf hm ty W).dir c) (c.pt W)
                theorem MIPRE.QLD.presOf_dir_ofLPX {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) (hty : ty ≠ LIDT.CL.Ty.point) (D : LPData F m) (u : LIDT.Point F m) :
                (presOf hm ty Bas.X).dir (ofLPX D u) = LPData.dir hm ty D
                theorem MIPRE.QLD.presOf_dir_ofLPZ {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) (hty : ty ≠ LIDT.CL.Ty.point) (D : LPData F m) (u : LIDT.Point F m) :
                (presOf hm ty Bas.Z).dir (ofLPZ D u) = LPData.dir hm ty D
                noncomputable def MIPRE.QLD.lineMeas {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (u₀ : LIDT.Point F (4 * m)) (s : F) (T : Finset (LIDT.Point F (4 * m))) :
                POVMIn (LIDT.LinePoly F (m * d + 1)) (Matrix (Anc F m) (Anc F m) R)

                The line measurement of the padded strategy: the padded line POVM at the data ⟨u₀, s, raw⟩, averaged over the raw directions in T.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  theorem MIPRE.QLD.lineMeas_mats {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (u₀ : LIDT.Point F (4 * m)) (s : F) {T : Finset (LIDT.Point F (4 * m))} (hT : T.Nonempty) (f : LIDT.LinePoly F (m * d + 1)) :
                  (lineMeas hm hm4 ty hS u₀ s T).op f = ↑(↑T.card)⁻¹ • ∑ raw ∈ T, padLineMats hm4 ty (presOf hm ty Bas.X) (presOf hm ty Bas.Z) S { pt := u₀, s := s, raw := raw } f
                  noncomputable def MIPRE.QLD.rawFiber {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (s : F) (v' : LIDT.Point F (4 * m)) :
                  Finset (LIDT.Point F (4 * m))

                  The raw directions a sample with seed s can carry so that its diagonal question shows the truncated direction v'.

                  Equations
                  Instances For
                    theorem MIPRE.QLD.mem_rawFiber {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) {s : F} {v' raw : LIDT.Point F (4 * m)} :
                    raw ∈ rawFiber hm4 s v' ↔ LIDT.CL.zeroBelow (LIDT.CL.chi hm4 s) raw = v'

                    The questions of a sample #

                    noncomputable def MIPRE.QLD.lineDir {F : Type u_1} [Field F] [Fintype F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (s : F) (raw : LIDT.Point F (4 * m)) :
                    LIDT.Point F (4 * m)

                    The direction of the line of type ty a seed and raw direction describe; 0 for the point type.

                    Equations
                    Instances For
                      theorem MIPRE.QLD.LPData.dir_eq_lineDir {F : Type u_1} [Field F] [Fintype F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) :
                      dir hm4 ty { pt := u, s := s, raw := raw } = lineDir hm4 ty s raw
                      noncomputable def MIPRE.QLD.rawSet {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (s : F) (raw : LIDT.Point F (4 * m)) :
                      Finset (LIDT.Point F (4 * m))

                      The raw directions the strategy averages over at the line question of type ty a sample with seed s and raw direction raw generates: all of them for an axis-parallel line, the fibre of the truncated direction for a diagonal one.

                      Equations
                      Instances For
                        theorem MIPRE.QLD.rawSet_nonempty {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (s : F) (raw : LIDT.Point F (4 * m)) :
                        (rawSet hm4 ty s raw).Nonempty
                        theorem MIPRE.QLD.lineDir_of_mem_rawSet {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) {s : F} {raw raw' : LIDT.Point F (4 * m)} (h : raw' ∈ rawSet hm4 ty s raw) :
                        lineDir hm4 ty s raw' = lineDir hm4 ty s raw

                        Every raw direction the strategy averages over describes the sample's line.

                        noncomputable def MIPRE.QLD.lineQ {F : Type u_1} [Field F] [Fintype F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) :

                        The line question of type ty the sample (u, s, raw) generates, as the seeded test computes it.

                        Equations
                        Instances For
                          theorem MIPRE.QLD.lineQ_point {F : Type u_1} [Field F] [Fintype F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) :
                          theorem MIPRE.QLD.lineQ_aline {F : Type u_1} [Field F] [Fintype F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) :
                          theorem MIPRE.QLD.lineQ_dline {F : Type u_1} [Field F] [Fintype F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) :
                          noncomputable def MIPRE.QLD.lineTau {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) :
                          F

                          The parameter of the sample's point on the line it generates.

                          Equations
                          Instances For
                            theorem MIPRE.QLD.padShift_lineData {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) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) {raw' : LIDT.Point F (4 * m)} (h : raw' ∈ rawSet hm4 ty s raw) :
                            padShift hm4 ty (lineTau hm4 ty u s raw) { pt := LIDT.CL.rep (lineDir hm4 ty s raw) u, s := s, raw := raw' } = { pt := u, s := s, raw := raw' }

                            The strategy's line data, moved to the sample's point along the line, is the sample's own data, for every raw direction the strategy averages over.

                            The strategy #

                            def MIPRE.QLD.alineAns {F : Type u_1} [Field F] {m d : ℕ} (f : LIDT.LinePoly F (m * d + 1)) :
                            LIDT.CL.Answer F (4 * m) d 1

                            The answer a padded line outcome is read as, at an axis-parallel line question: the polynomial resized to degree d. On the support of a legally supported strategy this loses nothing (padLineMats_aline_eq_zero_of_not_degLE).

                            Equations
                            Instances For
                              def MIPRE.QLD.dlineAns {F : Type u_1} [Field F] {m d : ℕ} (f : LIDT.LinePoly F (m * d + 1)) :
                              LIDT.CL.Answer F (4 * m) d 1

                              The answer a padded line outcome is read as, at a diagonal line question: the polynomial resized to degree 4 m d, which loses nothing since m d + 1 ≤ 4 m d.

                              Equations
                              Instances For
                                def MIPRE.QLD.lineAns {F : Type u_1} [Field F] {m d : ℕ} (ty : LIDT.CL.Ty) (f : LIDT.LinePoly F (m * d + 1)) :
                                LIDT.CL.Answer F (4 * m) d 1

                                The answer map of a line type.

                                Equations
                                Instances For
                                  def MIPRE.QLD.rdEval {F : Type u_1} [Field F] {m d : ℕ} (t : F) :
                                  LIDT.CL.Answer F (4 * m) d 1 → F

                                  The value a line answer takes at the parameter t; a point answer reads as 0.

                                  Equations
                                  Instances For
                                    noncomputable def MIPRE.QLD.padStrat {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) :
                                    LIDT.CL.Question F (4 * m) → POVMIn (LIDT.CL.Answer F (4 * m) d 1) (Matrix (Anc F m) (Anc F m) R)

                                    The padded strategy of one player, as a family of POVMs in the register's matrices over the player's algebra, indexed by the seeded test's questions at (q, 4m, d, 1) (the design's padStratIn).

                                    Equations
                                    Instances For
                                      theorem MIPRE.QLD.padStrat_point {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (u : LIDT.Point F (4 * m)) :
                                      padStrat hm hm4 hS (LIDT.CL.Question.point u) = POVMIn.map (fun (a : F) => LIDT.CL.Answer.values fun (x : Fin 1) => a) (padPt hS u)
                                      theorem MIPRE.QLD.padStrat_lineQ {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (hty : ty ≠ LIDT.CL.Ty.point) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) :
                                      padStrat hm hm4 hS (lineQ hm4 ty u s raw) = POVMIn.map (lineAns ty) (lineMeas hm hm4 ty hS (LIDT.CL.rep (lineDir hm4 ty s raw) u) s (rawSet hm4 ty s raw))

                                      The support of the strategy's answers #

                                      theorem MIPRE.QLD.exists_of_padStrat_point_mats_ne_zero {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (u : LIDT.Point F (4 * m)) {a : LIDT.CL.Answer F (4 * m) d 1} (h : (padStrat hm hm4 hS (LIDT.CL.Question.point u)).op a ≠ 0) :
                                      ∃ (c : F), a = LIDT.CL.Answer.values fun (x : Fin 1) => c
                                      theorem MIPRE.QLD.exists_of_padStrat_lineQ_mats_ne_zero {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (hty : ty ≠ LIDT.CL.Ty.point) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) {a : LIDT.CL.Answer F (4 * m) d 1} (h : (padStrat hm hm4 hS (lineQ hm4 ty u s raw)).op a ≠ 0) :
                                      ∃ (f : LIDT.LinePoly F (m * d + 1)), a = lineAns ty f
                                      theorem MIPRE.QLD.eval_padLine_of_degLE {F : Type u_1} [Field F] {k n : ℕ} {f : LIDT.LinePoly F k} (hf : DegLE f n) (t : F) :
                                      (padLine n f).eval t = f.eval t

                                      Resizing to the degree bound a polynomial already satisfies does not change its values.

                                      theorem MIPRE.QLD.lineMeas_aline_mats_eq_zero_of_not_degLE {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) (hd : 1 ≤ d) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (hleg : LegalSupport S) (u₀ : LIDT.Point F (4 * m)) (s : F) (T : Finset (LIDT.Point F (4 * m))) {f : LIDT.LinePoly F (m * d + 1)} (hf : ¬DegLE f d) :
                                      (lineMeas hm hm4 LIDT.CL.Ty.aline hS u₀ s T).op f = 0

                                      On an axis-parallel line, the strategy's line measurement has no element off DegLE _ d.

                                      theorem MIPRE.QLD.padStrat_lineQ_map_rdEval {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (hty : ty ≠ LIDT.CL.Ty.point) (hd : 1 ≤ d) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (hleg : LegalSupport S) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) (t : F) :
                                      POVMIn.map (rdEval t) (padStrat hm hm4 hS (lineQ hm4 ty u s raw)) = POVMIn.map (fun (f : LIDT.LinePoly F (m * d + 1)) => f.eval t) (lineMeas hm hm4 ty hS (LIDT.CL.rep (lineDir hm4 ty s raw) u) s (rawSet hm4 ty s raw))

                                      Reading the strategy's line answer at a parameter is reading the line measurement there: the resizing in lineAns is invisible on the support.

                                      theorem MIPRE.QLD.padStrat_point_map_toValue {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (u : LIDT.Point F (4 * m)) :

                                      The strategy's point answer, read back as a field element, is the padded point measurement.

                                      The line measurement read at the sampled point #

                                      sum_filter_padLineMats reads the padded line measurement at the parameter of a point of the padded line as the pasted line measurement, at the data's own point, coarse-grained by the combining map at the shifted point. The strategy's line data carries the canonical base point of the line, while lem:qld-padded-lines is stated at the sample's point; the two are reconciled by the invariance of the pasted line measurement under moving the padded point along the padded line, which holds because each block of the padded point either moves along its own subline or does not move at all (xBlk_dir_sub, zBlk_dir_sub).

                                      theorem MIPRE.QLD.lineMats_pairCX_padShift {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) {S : Question F m → POVMIn (Answer F m d) R} (ty : LIDT.CL.Ty) (PX : LinePres F m hm Bas.X) (hfacX : FactorsX PX) (hdirX : ∀ (D : LPData F m) (u : LIDT.Point F m), PX.dir (ofLPX D u) = LPData.dir hm ty D) (tau : F) (P : LPData F (4 * m)) (e : SubRand F m) :
                                      PX.lineMats d S (pairCX (subPair hm4 hm ty (padShift hm4 ty tau P) e)) = PX.lineMats d S (pairCX (subPair hm4 hm ty P e))

                                      The X line measurement of the pair of sublines is unchanged by the padded shift.

                                      theorem MIPRE.QLD.lineMats_pairCZ_padShift {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) {S : Question F m → POVMIn (Answer F m d) R} (ty : LIDT.CL.Ty) (PZ : LinePres F m hm Bas.Z) (hfacZ : FactorsZ PZ) (hdirZ : ∀ (D : LPData F m) (u : LIDT.Point F m), PZ.dir (ofLPZ D u) = LPData.dir hm ty D) (tau : F) (P : LPData F (4 * m)) (e : SubRand F m) :
                                      PZ.lineMats d S (pairCZ (subPair hm4 hm ty (padShift hm4 ty tau P) e)) = PZ.lineMats d S (pairCZ (subPair hm4 hm ty P e))

                                      The Z line measurement of the pair of sublines is unchanged by the padded shift.

                                      theorem MIPRE.QLD.pasteLine_subPair_padShift {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) {S : Question F m → POVMIn (Answer F m d) R} (ty : LIDT.CL.Ty) (PX : LinePres F m hm Bas.X) (PZ : LinePres F m hm Bas.Z) (hfacX : FactorsX PX) (hfacZ : FactorsZ PZ) (hdirX : ∀ (D : LPData F m) (u : LIDT.Point F m), PX.dir (ofLPX D u) = LPData.dir hm ty D) (hdirZ : ∀ (D : LPData F m) (u : LIDT.Point F m), PZ.dir (ofLPZ D u) = LPData.dir hm ty D) (tau : F) (P : LPData F (4 * m)) (e : SubRand F m) (q : LIDT.LinePoly F (m * d) × LIDT.LinePoly F (m * d)) :
                                      pasteLine PX PZ d S (pairCX (subPair hm4 hm ty (padShift hm4 ty tau P) e)) (pairCZ (subPair hm4 hm ty (padShift hm4 ty tau P) e)) q = pasteLine PX PZ d S (pairCX (subPair hm4 hm ty P e)) (pairCZ (subPair hm4 hm ty P e)) q

                                      The pasted line measurement is unchanged by moving the padded point along the padded line.

                                      theorem MIPRE.QLD.sum_filter_padLineMats_eq_lineComb {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) {S : Question F m → POVMIn (Answer F m d) R} (ty : LIDT.CL.Ty) (PX : LinePres F m hm Bas.X) (PZ : LinePres F m hm Bas.Z) (hfacX : FactorsX PX) (hfacZ : FactorsZ PZ) (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, lineComb PX PZ d S (pairCX (subPair hm4 hm ty (padShift hm4 ty tau P) e)) (pairCZ (subPair hm4 hm ty (padShift hm4 ty tau P) e)) (alph (padShift hm4 ty tau P).pt) (bet (padShift hm4 ty tau P).pt) a

                                      The padded line measurement read at the parameter of a point of the padded line is the average over the fresh randomness of the pasted line measurement at that point, coarse-grained by the combining map there.

                                      theorem MIPRE.QLD.lineMeas_map_eval_mats {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) {R : Type u_2} [Ring R] [StarRing R] [Algebra ℂ R] [StarModule ℂ R] [PartialOrder R] [StarOrderedRing R] [StarProper R] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (hty : ty ≠ LIDT.CL.Ty.point) {S : Question F m → POVMIn (Answer F m d) R} (hS : ∀ (q : Question F m), IsPVMIn (S q).op) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) (a : F) :
                                      (POVMIn.map (fun (f : LIDT.LinePoly F (m * d + 1)) => f.eval (lineTau hm4 ty u s raw)) (lineMeas hm hm4 ty hS (LIDT.CL.rep (lineDir hm4 ty s raw) u) s (rawSet hm4 ty s raw))).op a = ↑(↑(rawSet hm4 ty s raw).card)⁻¹ • ∑ raw' ∈ rawSet hm4 ty s raw, ↑(↑(Fintype.card (SubRand F m)))⁻¹ • ∑ e : SubRand F m, lineComb (presOf hm ty Bas.X) (presOf hm ty Bas.Z) d S (pairCX (subPair hm4 hm ty { pt := u, s := s, raw := raw' } e)) (pairCZ (subPair hm4 hm ty { pt := u, s := s, raw := raw' } e)) (alph u) (bet u) a

                                      The strategy's line measurement, read at the parameter of the sample's point, is the average over the raw directions and the fresh randomness of the pasted line measurement at the sample's own data, coarse-grained by the combining map at the sample's point. This is the quantity lem:qld-padded-lines controls.

                                      The conditional failures of the strategy, question pair by question pair #

                                      theorem MIPRE.QLD.accepts_lineQ_point {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (hty : ty ≠ LIDT.CL.Ty.point) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) (f : LIDT.LinePoly F (m * d + 1)) (c : F) (h : rdEval (lineTau hm4 ty u s raw) (lineAns ty f) = c) :
                                      LIDT.CL.accepts hm4 (lineQ hm4 ty u s raw) (LIDT.CL.Question.point u) (lineAns ty f) (LIDT.CL.Answer.values fun (x : Fin 1) => c) = true

                                      A line answer read at the parameter of the sampled point, against the point answer there: the decider accepts.

                                      theorem MIPRE.QLD.accepts_point_lineQ {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (hty : ty ≠ LIDT.CL.Ty.point) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) (f : LIDT.LinePoly F (m * d + 1)) (c : F) (h : c = rdEval (lineTau hm4 ty u s raw) (lineAns ty f)) :
                                      LIDT.CL.accepts hm4 (LIDT.CL.Question.point u) (lineQ hm4 ty u s raw) (LIDT.CL.Answer.values fun (x : Fin 1) => c) (lineAns ty f) = true

                                      The same with the players exchanged.

                                      theorem MIPRE.QLD.accepts_lineQ_lineQ_self {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d : ℕ} [NeZero m] (hm4 : 4 * m ∣ Fintype.card F) (ty : LIDT.CL.Ty) (hty : ty ≠ LIDT.CL.Ty.point) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) (f : LIDT.LinePoly F (m * d + 1)) :
                                      LIDT.CL.accepts hm4 (lineQ hm4 ty u s raw) (lineQ hm4 ty u s raw) (lineAns ty f) (lineAns ty f) = true
                                      theorem MIPRE.QLD.condFail_lineQ_point_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (hm4 : 4 * m ∣ Fintype.card F) {𝒞 : Type u_3} {𝒜 : Type u_4} {ℬ : Type u_5} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [StarModule ℂ 𝒜] [PartialOrder 𝒜] [StarOrderedRing 𝒜] [StarProper 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] [StarModule ℂ ℬ] [PartialOrder ℬ] [StarOrderedRing ℬ] [StarProper ℬ] {PA : Question F m → POVMIn (Answer F m d) 𝒜} {PB : Question F m → POVMIn (Answer F m d) ℬ} (hPA : ∀ (q : Question F m), IsPVMIn (PA q).op) (hPB : ∀ (q : Question F m), IsPVMIn (PB q).op) (N : BipartiteModel 𝒞 (Matrix (Anc F m) (Anc F m) 𝒜) (Matrix (Anc F m) (Anc F m) ℬ)) (ty : LIDT.CL.Ty) (hty : ty ≠ LIDT.CL.Ty.point) (hd : 1 ≤ d) (hlegA : LegalSupport PA) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) :
                                      N.condFail (LIDT.CL.clGame hm4) (padStrat hm hm4 hPA) (padStrat hm hm4 hPB) (lineQ hm4 ty u s raw) (LIDT.CL.Question.point u) ≤ 1 - ∑ a : F, N.bornProb ((POVMIn.map (fun (f : LIDT.LinePoly F (m * d + 1)) => f.eval (lineTau hm4 ty u s raw)) (lineMeas hm hm4 ty hPA (LIDT.CL.rep (lineDir hm4 ty s raw) u) s (rawSet hm4 ty s raw))).op a) ((padPt hPB u).op a)

                                      The first player's line against the second player's point: the conditional failure is at most the disagreement of the first player's line measurement read at the sample's point with the second player's padded point measurement.

                                      theorem MIPRE.QLD.condFail_point_lineQ_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (hm4 : 4 * m ∣ Fintype.card F) {𝒞 : Type u_3} {𝒜 : Type u_4} {ℬ : Type u_5} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [StarModule ℂ 𝒜] [PartialOrder 𝒜] [StarOrderedRing 𝒜] [StarProper 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] [StarModule ℂ ℬ] [PartialOrder ℬ] [StarOrderedRing ℬ] [StarProper ℬ] {PA : Question F m → POVMIn (Answer F m d) 𝒜} {PB : Question F m → POVMIn (Answer F m d) ℬ} (hPA : ∀ (q : Question F m), IsPVMIn (PA q).op) (hPB : ∀ (q : Question F m), IsPVMIn (PB q).op) (N : BipartiteModel 𝒞 (Matrix (Anc F m) (Anc F m) 𝒜) (Matrix (Anc F m) (Anc F m) ℬ)) (ty : LIDT.CL.Ty) (hty : ty ≠ LIDT.CL.Ty.point) (hd : 1 ≤ d) (hlegB : LegalSupport PB) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) :
                                      N.condFail (LIDT.CL.clGame hm4) (padStrat hm hm4 hPA) (padStrat hm hm4 hPB) (LIDT.CL.Question.point u) (lineQ hm4 ty u s raw) ≤ 1 - ∑ a : F, N.bornProb ((padPt hPA u).op a) ((POVMIn.map (fun (f : LIDT.LinePoly F (m * d + 1)) => f.eval (lineTau hm4 ty u s raw)) (lineMeas hm hm4 ty hPB (LIDT.CL.rep (lineDir hm4 ty s raw) u) s (rawSet hm4 ty s raw))).op a)

                                      The first player's point against the second player's line.

                                      theorem MIPRE.QLD.condFail_point_point_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (hm4 : 4 * m ∣ Fintype.card F) {𝒞 : Type u_3} {𝒜 : Type u_4} {ℬ : Type u_5} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [StarModule ℂ 𝒜] [PartialOrder 𝒜] [StarOrderedRing 𝒜] [StarProper 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] [StarModule ℂ ℬ] [PartialOrder ℬ] [StarOrderedRing ℬ] [StarProper ℬ] {PA : Question F m → POVMIn (Answer F m d) 𝒜} {PB : Question F m → POVMIn (Answer F m d) ℬ} (hPA : ∀ (q : Question F m), IsPVMIn (PA q).op) (hPB : ∀ (q : Question F m), IsPVMIn (PB q).op) (N : BipartiteModel 𝒞 (Matrix (Anc F m) (Anc F m) 𝒜) (Matrix (Anc F m) (Anc F m) ℬ)) (u : LIDT.Point F (4 * m)) :
                                      N.condFail (LIDT.CL.clGame hm4) (padStrat hm hm4 hPA) (padStrat hm hm4 hPB) (LIDT.CL.Question.point u) (LIDT.CL.Question.point u) ≤ 1 - ∑ a : F, N.bornProb ((padPt hPA u).op a) ((padPt hPB u).op a)

                                      Identical points: the conditional failure is at most the disagreement of the two padded point measurements.

                                      theorem MIPRE.QLD.condFail_lineQ_lineQ_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (hm4 : 4 * m ∣ Fintype.card F) {𝒞 : Type u_3} {𝒜 : Type u_4} {ℬ : Type u_5} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [StarModule ℂ 𝒜] [PartialOrder 𝒜] [StarOrderedRing 𝒜] [StarProper 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] [StarModule ℂ ℬ] [PartialOrder ℬ] [StarOrderedRing ℬ] [StarProper ℬ] {PA : Question F m → POVMIn (Answer F m d) 𝒜} {PB : Question F m → POVMIn (Answer F m d) ℬ} (hPA : ∀ (q : Question F m), IsPVMIn (PA q).op) (hPB : ∀ (q : Question F m), IsPVMIn (PB q).op) (N : BipartiteModel 𝒞 (Matrix (Anc F m) (Anc F m) 𝒜) (Matrix (Anc F m) (Anc F m) ℬ)) (ty : LIDT.CL.Ty) (hty : ty ≠ LIDT.CL.Ty.point) (u : LIDT.Point F (4 * m)) (s : F) (raw : LIDT.Point F (4 * m)) :
                                      N.condFail (LIDT.CL.clGame hm4) (padStrat hm hm4 hPA) (padStrat hm hm4 hPB) (lineQ hm4 ty u s raw) (lineQ hm4 ty u s raw) ≤ 1 - ∑ f : LIDT.LinePoly F (m * d + 1), N.bornProb ((lineMeas hm hm4 ty hPA (LIDT.CL.rep (lineDir hm4 ty s raw) u) s (rawSet hm4 ty s raw)).op f) ((lineMeas hm hm4 ty hPB (LIDT.CL.rep (lineDir hm4 ty s raw) u) s (rawSet hm4 ty s raw)).op f)

                                      Identical lines: the conditional failure is at most the disagreement of the two line measurements, outcome polynomial by outcome polynomial.

                                      theorem MIPRE.QLD.condFail_aline_dline_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (hm4 : 4 * m ∣ Fintype.card F) {𝒞 : Type u_3} {𝒜 : Type u_4} {ℬ : Type u_5} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [StarModule ℂ 𝒜] [PartialOrder 𝒜] [StarOrderedRing 𝒜] [StarProper 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] [StarModule ℂ ℬ] [PartialOrder ℬ] [StarOrderedRing ℬ] [StarProper ℬ] {PA : Question F m → POVMIn (Answer F m d) 𝒜} {PB : Question F m → POVMIn (Answer F m d) ℬ} (hPA : ∀ (q : Question F m), IsPVMIn (PA q).op) (hPB : ∀ (q : Question F m), IsPVMIn (PB q).op) (N : BipartiteModel 𝒞 (Matrix (Anc F m) (Anc F m) 𝒜) (Matrix (Anc F m) (Anc F m) ℬ)) (hN : ‖N.ψ‖ = 1) (u : LIDT.Point F (4 * m)) (s : F) (raw u' : LIDT.Point F (4 * m)) (s' : F) (raw' : LIDT.Point F (4 * m)) :
                                      N.condFail (LIDT.CL.clGame hm4) (padStrat hm hm4 hPA) (padStrat hm hm4 hPB) (lineQ hm4 LIDT.CL.Ty.aline u s raw) (lineQ hm4 LIDT.CL.Ty.dline u' s' raw') ≤ 0

                                      The two cross type pairs are always accepted: the strategy answers in the right format, and the decider checks nothing else.

                                      theorem MIPRE.QLD.condFail_dline_aline_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod 2) F] {m d : ℕ} [NeZero m] (hm : m ∣ Fintype.card F) (hm4 : 4 * m ∣ Fintype.card F) {𝒞 : Type u_3} {𝒜 : Type u_4} {ℬ : Type u_5} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [StarModule ℂ 𝒜] [PartialOrder 𝒜] [StarOrderedRing 𝒜] [StarProper 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] [StarModule ℂ ℬ] [PartialOrder ℬ] [StarOrderedRing ℬ] [StarProper ℬ] {PA : Question F m → POVMIn (Answer F m d) 𝒜} {PB : Question F m → POVMIn (Answer F m d) ℬ} (hPA : ∀ (q : Question F m), IsPVMIn (PA q).op) (hPB : ∀ (q : Question F m), IsPVMIn (PB q).op) (N : BipartiteModel 𝒞 (Matrix (Anc F m) (Anc F m) 𝒜) (Matrix (Anc F m) (Anc F m) ℬ)) (hN : ‖N.ψ‖ = 1) (u : LIDT.Point F (4 * m)) (s : F) (raw u' : LIDT.Point F (4 * m)) (s' : F) (raw' : LIDT.Point F (4 * m)) :
                                      N.condFail (LIDT.CL.clGame hm4) (padStrat hm hm4 hPA) (padStrat hm hm4 hPB) (lineQ hm4 LIDT.CL.Ty.dline u s raw) (lineQ hm4 LIDT.CL.Ty.aline u' s' raw') ≤ 0

                                      Polynomial separation #

                                      Two distinct line polynomials of degree at most n agree at at most n parameters (card_agree_linePoly_le), so the disagreement of two polynomial-valued measurements is at most their disagreement when both are read at a uniformly random parameter, plus n / q. This is the paper's argument for the identical-line subtest.

                                      theorem MIPRE.QLD.one_sub_sum_bornProb_le_avg_eval {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {𝒞' : Type u_3} {𝒜' : Type u_4} {ℬ' : Type u_5} [Ring 𝒞'] [StarRing 𝒞'] [Algebra ℂ 𝒞'] [Ring 𝒜'] [StarRing 𝒜'] [Algebra ℂ 𝒜'] [Ring ℬ'] [StarRing ℬ'] [Algebra ℂ ℬ'] [PartialOrder 𝒜'] [StarOrderedRing 𝒜'] [PartialOrder ℬ'] [StarOrderedRing ℬ'] {n : ℕ} {N : BipartiteModel 𝒞' 𝒜' ℬ'} (hN : ‖N.ψ‖ = 1) (LA : POVMIn (LIDT.LinePoly F n) 𝒜') (LB : POVMIn (LIDT.LinePoly F n) ℬ') :
                                      1 - ∑ f : LIDT.LinePoly F n, N.bornProb (LA.op f) (LB.op f) ≤ (↑(Fintype.card F))⁻¹ * ∑ t : F, (1 - ∑ a : F, N.bornProb ((POVMIn.map (fun (f : LIDT.LinePoly F n) => f.eval t) LA).op a) ((POVMIn.map (fun (f : LIDT.LinePoly F n) => f.eval t) LB).op a)) + ↑n / ↑(Fintype.card F)

                                      Polynomial separation, in any bipartite model.