Documentation

MIPRE.Background.LIDT.Extraction

Extracting exactly linear combined codewords #

Blueprint lem:lidt-ldc-extraction, the paper's Step 4 of the proof of lem:ld-soundness for general ldc (ldt.tex, Claims 4 and 5 and the measurements H, G). The simultaneous test with r codewords is reduced to the single-codeword test in K + m variables by combining: a point (x, y) ∈ F^K × F^m is answered by ∑_{j < r} x_j b_j, where b ∈ F^r is the original point answer at y. The single-codeword theorem then returns a measurement R of polynomials g in the K + m variables, consistent with the combined point answers. This file turns R back into a measurement of r-tuples of polynomials in the m original variables.

The extraction #

A polynomial g(x, y) is exactly x-linear (IsXLin) if it is ∑_i x_i g_i(y): every monomial has exactly one x-variable, to the first power. extract reads off (g_1, …, g_r) from such a g and returns 0 otherwise; it is a deterministic relabelling of outcomes, so applied to a projective measurement it gives a projective measurement.

The estimate #

inconsistency_extract_right_le (and _left_le, the extracted measurement on the other party): the extracted tuple, evaluated at a uniform y, disagrees with the original point answer at most (K + m) d / q more often than g(x, y) disagrees with the combined answer at a uniform (x, y). Fix y, the original answer b and the outcome g, and average over x alone --- the Born probabilities do not see x, since the original point measurement is asked y only and R is asked nothing:

The paper splits the last case the same way (its Claims 4 and 5). The linear-forms case costs K d / q here rather than the paper's 1 / q: the same Schwartz--Zippel lemma serves all three cases, and the difference is absorbed by the final constants.

The partial evaluation #

pevY g y is the coefficient vector, in the K combining variables, of x ↦ g(x, y) (eval_pevY). It is what lets Schwartz--Zippel in K variables be applied with y fixed.

Polynomials in the combining and original variables #

def MIPRE.LIDT.Simul.pevY {F : Type u_1} [Field F] {K m d : ℕ} (g : LowIndDegPoly) (y : Point F m) :

The partial evaluation at y: the coefficient vector, in the K combining variables, of x ↦ g(x, y).

Equations
Instances For
    theorem MIPRE.LIDT.Simul.eval_pevY {F : Type u_1} [Field F] {K m d : ℕ} (g : LowIndDegPoly) (x : Point F K) (y : Point F m) :
    (pevY g y).eval x = g.eval (Fin.append x y)
    theorem MIPRE.LIDT.Simul.eval_sub {F : Type u_1} [Field F] {K d : ℕ} (p q : LowIndDegPoly) (x : Point F K) :
    (p - q).eval x = p.eval x - q.eval x

    Evaluation of coefficient vectors is additive in the vector.

    def MIPRE.LIDT.Simul.unitExp {K d : ℕ} (hd : 1 ≤ d) (i : Fin K) :
    Fin K → Fin (d + 1)

    The exponent vector of the variable x_i.

    Equations
    Instances For
      theorem MIPRE.LIDT.Simul.prod_pow_unitExp {F : Type u_1} [Field F] {K d : ℕ} (hd : 1 ≤ d) (i : Fin K) (x : Point F K) :
      ∏ k : Fin K, x k ^ ↑(unitExp hd i k) = x i
      def MIPRE.LIDT.Simul.linPoly {F : Type u_1} [Field F] {K d : ℕ} (hd : 1 ≤ d) (c : Point F K) :

      The linear form x ↦ ∑_i c_i x_i, as a coefficient vector.

      Equations
      Instances For
        theorem MIPRE.LIDT.Simul.eval_linPoly {F : Type u_1} [Field F] {K d : ℕ} (hd : 1 ≤ d) (c x : Point F K) :
        (linPoly hd c).eval x = ∑ i : Fin K, c i * x i
        theorem MIPRE.LIDT.Simul.linPoly_unitExp {F : Type u_1} [Field F] {K d : ℕ} (hd : 1 ≤ d) (c : Point F K) (i : Fin K) :
        linPoly hd c (unitExp hd i) = c i
        theorem MIPRE.LIDT.Simul.linPoly_of_forall_ne {F : Type u_1} [Field F] {K d : ℕ} (hd : 1 ≤ d) (c : Point F K) {ex : Fin K → Fin (d + 1)} (hex : ∀ (i : Fin K), ex ≠ unitExp hd i) :
        linPoly hd c ex = 0
        def MIPRE.LIDT.Simul.IsXLin {F : Type u_1} [Field F] {K m d : ℕ} (hd : 1 ≤ d) (g : LowIndDegPoly) :

        Exactly x-linear: every monomial with a nonzero coefficient has an x-part equal to a single variable to the first power.

        Equations
        Instances For
          def MIPRE.LIDT.Simul.xCoef {F : Type u_1} {K m d : ℕ} (hd : 1 ≤ d) (g : LowIndDegPoly) (i : Fin K) :

          The coefficient of x_i, a polynomial in y.

          Equations
          Instances For
            theorem MIPRE.LIDT.Simul.pevY_eq_linPoly {F : Type u_1} [Field F] {K m d : ℕ} {hd : 1 ≤ d} {g : LowIndDegPoly} (hg : IsXLin hd g) (y : Point F m) :
            pevY g y = linPoly hd fun (i : Fin K) => (xCoef hd g i).eval y

            An exactly x-linear polynomial is, at each y, the linear form of its coefficients.

            theorem MIPRE.LIDT.Simul.exists_badCoef {F : Type u_1} [Field F] {K m d : ℕ} {hd : 1 ≤ d} {g : LowIndDegPoly} (hg : ¬IsXLin hd g) :
            ∃ (ex : Fin K → Fin (d + 1)), (∀ (i : Fin K), ex ≠ unitExp hd i) ∧ (fun (ey : Fin m → Fin (d + 1)) => g (Fin.append ex ey)) ≠ 0

            A forbidden coefficient. A polynomial that is not exactly x-linear has a monomial with a forbidden x-part and a nonzero coefficient; that coefficient, as a polynomial in y, is nonzero, and where it does not vanish the partial evaluation is no linear form.

            theorem MIPRE.LIDT.Simul.pevY_apply {F : Type u_1} [Field F] {K m d : ℕ} (g : LowIndDegPoly) (y : Point F m) (ex : Fin K → Fin (d + 1)) :
            pevY g y ex = LowIndDegPoly.eval (fun (ey : Fin m → Fin (d + 1)) => g (Fin.append ex ey)) y
            def MIPRE.LIDT.Simul.padB {F : Type u_1} [Field F] {K r : ℕ} (b : Fin r → F) :
            Point F K

            The answer b ∈ F^r, padded with zeros to the K combining coordinates.

            Equations
            Instances For
              theorem MIPRE.LIDT.Simul.padB_castLE {F : Type u_1} [Field F] {K r : ℕ} (hr : r ≤ K) (b : Fin r → F) (j : Fin r) :
              padB b (Fin.castLE hr j) = b j
              noncomputable def MIPRE.LIDT.Simul.extract {F : Type u_1} [Field F] {K m d r : ℕ} (hd : 1 ≤ d) (hr : r ≤ K) (g : LowIndDegPoly) :

              The extraction: the first r coefficients of an exactly x-linear polynomial, and the zero tuple otherwise.

              Equations
              Instances For
                noncomputable def MIPRE.LIDT.Simul.extEval {F : Type u_1} [Field F] {K m d r : ℕ} (hd : 1 ≤ d) (hr : r ≤ K) (g : LowIndDegPoly) (y : Point F m) :
                Fin r → F

                The extracted tuple, evaluated at y.

                Equations
                Instances For
                  noncomputable def MIPRE.LIDT.Simul.badQ {F : Type u_1} [Field F] {K m d : ℕ} (hd : 1 ≤ d) (g : LowIndDegPoly) :

                  The forbidden coefficient of a polynomial that is not exactly x-linear (0 for one that is).

                  Equations
                  Instances For
                    theorem MIPRE.LIDT.Simul.badQ_ne_zero {F : Type u_1} [Field F] {K m d : ℕ} {hd : 1 ≤ d} {g : LowIndDegPoly} (hg : ¬IsXLin hd g) :
                    badQ hd g ≠ 0
                    theorem MIPRE.LIDT.Simul.pevY_badQ {F : Type u_1} [Field F] {K m d : ℕ} {hd : 1 ≤ d} {g : LowIndDegPoly} (hg : ¬IsXLin hd g) (y : Point F m) :
                    ∃ (ex : Fin K → Fin (d + 1)), (∀ (i : Fin K), ex ≠ unitExp hd i) ∧ pevY g y ex = (badQ hd g).eval y

                    Schwartz--Zippel at a fixed y #

                    theorem MIPRE.LIDT.Simul.card_agree_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K d : ℕ} {p p' : LowIndDegPoly} (h : p ≠ p') :
                    ↑{x : Point F K | p.eval x = p'.eval x}.card / ↑(Fintype.card F) ^ K ≤ ↑K * ↑d / ↑(Fintype.card F)

                    Two different coefficient vectors in K variables agree at a uniform point with probability at most K d / q.

                    noncomputable def MIPRE.LIDT.Simul.agreeX {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d r : ℕ} (hd : 1 ≤ d) (g : LowIndDegPoly) (y : Point F m) (b : Fin r → F) :

                    The agreement, at a uniform x, of the combined answer with the outcome g evaluated at (x, y), as a fraction.

                    Equations
                    Instances For
                      theorem MIPRE.LIDT.Simul.agreeX_le_one {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d r : ℕ} (hd : 1 ≤ d) (g : LowIndDegPoly) (y : Point F m) (b : Fin r → F) :
                      agreeX hd g y b ≤ 1
                      noncomputable def MIPRE.LIDT.Simul.badInd {F : Type u_1} [Field F] [DecidableEq F] {K m d : ℕ} (hd : 1 ≤ d) (g : LowIndDegPoly) (y : Point F m) :

                      The indicator that g is not exactly x-linear and its forbidden coefficient vanishes at y.

                      Equations
                      Instances For
                        theorem MIPRE.LIDT.Simul.agreeX_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d r : ℕ} (hd : 1 ≤ d) (hr : r ≤ K) (g : LowIndDegPoly) (y : Point F m) (b : Fin r → F) :
                        agreeX hd g y b ≤ (if extEval hd hr g y = b then 1 else 0) + ↑K * ↑d / ↑(Fintype.card F) + badInd hd g y

                        The pointwise bound. At a fixed y, answer b and outcome g, the combined answer and g(·, y) agree at a uniform x with probability at most: one if the extracted tuple is b; one if g is not exactly x-linear and its forbidden coefficient vanishes at y; and K d / q otherwise.

                        theorem MIPRE.LIDT.Simul.sum_uniform_badInd_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d : ℕ} (hd : 1 ≤ d) (g : LowIndDegPoly) :
                        ∑ y : Point F m, uniform (Point F m) y * badInd hd g y ≤ ↑m * ↑d / ↑(Fintype.card F)

                        The forbidden coefficient vanishes at a uniform y with probability at most m d / q.

                        theorem MIPRE.LIDT.Simul.sum_uniform_one (X : Type u_2) [Fintype X] [Nonempty X] :
                        ∑ x : X, uniform X x = 1
                        theorem MIPRE.LIDT.Simul.sum_agreeX_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d r : ℕ} (hd : 1 ≤ d) (hr : r ≤ K) (β : Point F m → (Fin r → F) → LowIndDegPoly → ℝ) (hβ0 : ∀ (y : Point F m) (b : Fin r → F) (g : LowIndDegPoly), 0 ≤ β y b g) (w : LowIndDegPoly → ℝ) (hw : ∀ (y : Point F m) (g : LowIndDegPoly), ∑ b : Fin r → F, β y b g = w g) (hw1 : ∑ g : LowIndDegPoly, w g = 1) :
                        ∑ y : Point F m, uniform (Point F m) y * ∑ b : Fin r → F, ∑ g : LowIndDegPoly, β y b g * agreeX hd g y b ≤ (∑ y : Point F m, uniform (Point F m) y * ∑ b : Fin r → F, ∑ g : LowIndDegPoly, β y b g * if extEval hd hr g y = b then 1 else 0) + (↑K + ↑m) * ↑d / ↑(Fintype.card F)

                        The weighted bound. For nonnegative weights β y b g whose sum over the answer b does not depend on y and totals one over the outcomes, the average agreement of the combined answer exceeds the average agreement of the extracted tuple by at most (K + m) d / q.

                        The operator form #

                        theorem MIPRE.LIDT.Simul.inconsistency_eq_one_sub {dA : Type u_2} {dB : Type u_3} [Fintype dA] [DecidableEq dA] [Fintype dB] [DecidableEq dB] {X : Type u_4} {A : Type u_5} [Fintype X] [Fintype A] [DecidableEq A] {μ : X → ℝ} (hμ1 : ∑ x : X, μ x = 1) {ψ : dA × dB → ℂ} (hψ : star ψ ⬝ᵥ ψ = 1) (M : X → POVM A dA) (N : X → POVM A dB) :
                        inconsistency μ ψ M N = 1 - ∑ x : X, μ x * ∑ a : A, bornProb ψ ↑((M x).mats a) ↑((N x).mats a)

                        inconsistency is one minus the average agreement, for POVMs on a unit vector and a probability distribution on the questions.

                        theorem MIPRE.LIDT.Simul.sum_bornProb_map_right {dA : Type u_2} {dB : Type u_3} [Fintype dA] [DecidableEq dA] [Fintype dB] [DecidableEq dB] {A : Type u_4} {C : Type u_5} [Fintype A] [Fintype C] [DecidableEq C] (ψ : dA × dB → ℂ) (P : C → Matrix dA dA ℂ) (N : POVM A dB) (f : A → C) :
                        ∑ c : C, bornProb ψ (P c) ↑((POVM.map f N).mats c) = ∑ a : A, bornProb ψ (P (f a)) ↑(N.mats a)

                        Relabelling the second family: ∑_c ⟨P_c ⊗ (N.map f)_c⟩ = ∑_a ⟨P_{f a} ⊗ N_a⟩.

                        theorem MIPRE.LIDT.Simul.sum_bornProb_map_left {dA : Type u_2} {dB : Type u_3} [Fintype dA] [DecidableEq dA] [Fintype dB] [DecidableEq dB] {A : Type u_4} {C : Type u_5} [Fintype A] [Fintype C] [DecidableEq C] (ψ : dA × dB → ℂ) (M : POVM A dA) (Q : C → Matrix dB dB ℂ) (f : A → C) :
                        ∑ c : C, bornProb ψ (↑((POVM.map f M).mats c)) (Q c) = ∑ a : A, bornProb ψ (↑(M.mats a)) (Q (f a))

                        Relabelling the first family.

                        def MIPRE.LIDT.Simul.xOf {F : Type u_1} {K m : ℕ} (u : Point F (K + m)) :
                        Point F K

                        The combining coordinates of a padded point.

                        Equations
                        Instances For
                          def MIPRE.LIDT.Simul.yOf {F : Type u_1} {K m : ℕ} (u : Point F (K + m)) :
                          Point F m

                          The original coordinates of a padded point.

                          Equations
                          Instances For
                            theorem MIPRE.LIDT.Simul.sum_uniform_pad {F : Type u_1} [Fintype F] {K m : ℕ} (f : Point F K → Point F m → ℝ) :
                            ∑ u : Point F (K + m), uniform (Point F (K + m)) u * f (xOf u) (yOf u) = ∑ y : Point F m, uniform (Point F m) y * ∑ x : Point F K, uniform (Point F K) x * f x y

                            The uniform padded point is a uniform pair.

                            theorem MIPRE.LIDT.Simul.sum_uniform_agree {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d r : ℕ} (hd : 1 ≤ d) (g : LowIndDegPoly) (y : Point F m) (b : Fin r → F) :
                            (∑ x : Point F K, uniform (Point F K) x * if (linPoly hd (padB b)).eval x = g.eval (Fin.append x y) then 1 else 0) = agreeX hd g y b

                            The average of an indicator over a uniform x, as agreeX.

                            theorem MIPRE.LIDT.Simul.inconsistency_extract_right_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d r : ℕ} {dA : Type u_2} {dB : Type u_3} [Fintype dA] [DecidableEq dA] [Fintype dB] [DecidableEq dB] (hd : 1 ≤ d) (hr : r ≤ K) {ψ : dA × dB → ℂ} (hψ : star ψ ⬝ᵥ ψ = 1) (A : Point F m → POVM (Fin r → F) dA) (R : POVM LowIndDegPoly dB) :
                            (inconsistency (uniform (Point F m)) ψ A fun (y : Point F m) => POVM.map (fun (g : LowIndDegPoly) => extEval hd hr g y) R) ≤ (inconsistency (uniform (Point F (K + m))) ψ (fun (u : Point F (K + m)) => POVM.map (fun (b : Fin r → F) => (linPoly hd (padB b)).eval (xOf u)) (A (yOf u))) fun (u : Point F (K + m)) => POVM.map (fun (g : LowIndDegPoly) => g.eval u) R) + (↑K + ↑m) * ↑d / ↑(Fintype.card F)

                            The extraction bound, the extracted measurement on the second party.

                            theorem MIPRE.LIDT.Simul.inconsistency_extract_left_le {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d r : ℕ} {dA : Type u_2} {dB : Type u_3} [Fintype dA] [DecidableEq dA] [Fintype dB] [DecidableEq dB] (hd : 1 ≤ d) (hr : r ≤ K) {ψ : dA × dB → ℂ} (hψ : star ψ ⬝ᵥ ψ = 1) (R : POVM LowIndDegPoly dA) (B : Point F m → POVM (Fin r → F) dB) :
                            inconsistency (uniform (Point F m)) ψ (fun (y : Point F m) => POVM.map (fun (g : LowIndDegPoly) => extEval hd hr g y) R) B ≤ (inconsistency (uniform (Point F (K + m))) ψ (fun (u : Point F (K + m)) => POVM.map (fun (g : LowIndDegPoly) => g.eval u) R) fun (u : Point F (K + m)) => POVM.map (fun (b : Fin r → F) => (linPoly hd (padB b)).eval (xOf u)) (B (yOf u))) + (↑K + ↑m) * ↑d / ↑(Fintype.card F)

                            The extraction bound, the extracted measurement on the first party.

                            The extracted measurements, and the three conclusions #

                            theorem MIPRE.LIDT.Simul.inconsistency_map_le {dA : Type u_2} {dB : Type u_3} [Fintype dA] [DecidableEq dA] [Fintype dB] [DecidableEq dB] {X : Type u_4} {A : Type u_5} {C : Type u_6} [Fintype X] [Fintype A] [DecidableEq A] [Fintype C] [DecidableEq C] {μ : X → ℝ} (hμ0 : ∀ (x : X), 0 ≤ μ x) (hμ1 : ∑ x : X, μ x = 1) {ψ : dA × dB → ℂ} (hψ : star ψ ⬝ᵥ ψ = 1) (M : X → POVM A dA) (N : X → POVM A dB) (f : A → C) :
                            (inconsistency μ ψ (fun (x : X) => POVM.map f (M x)) fun (x : X) => POVM.map f (N x)) ≤ inconsistency μ ψ M N

                            Data processing for inconsistency: relabelling both families' outcomes the same way can only decrease the disagreement.

                            theorem MIPRE.LIDT.Simul.isPVM_pm {X : Type u_4} {A : Type u_5} [Fintype A] {n : Type u_6} [Fintype n] [DecidableEq n] (P : ProjectiveMeasurement X A (Matrix n n ℂ)) (x : X) :
                            IsPVM (P.M x)

                            A projective measurement's matrices form a projective family.

                            noncomputable def MIPRE.LIDT.Simul.extractPM {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d r : ℕ} (hd : 1 ≤ d) (hr : r ≤ K) {n : Type u_4} [Fintype n] [DecidableEq n] (R : ProjectiveMeasurement Unit LowIndDegPoly (Matrix n n ℂ)) :

                            The extracted measurement: R coarse-grained by extract, still projective.

                            Equations
                            Instances For
                              theorem MIPRE.LIDT.Simul.extractPM_toPOVM {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d r : ℕ} (hd : 1 ≤ d) (hr : r ≤ K) {n : Type u_4} [Fintype n] [DecidableEq n] (R : ProjectiveMeasurement Unit LowIndDegPoly (Matrix n n ℂ)) :
                              (extractPM hd hr R).toPOVM () = POVM.map (extract hd hr) (R.toPOVM ())
                              noncomputable def MIPRE.LIDT.Simul.evalTuplePOVM {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {m d r : ℕ} {n : Type u_4} [Fintype n] [DecidableEq n] (G : ProjectiveMeasurement Unit (Fin r → LowIndDegPoly) (Matrix n n ℂ)) (y : Point F m) :
                              POVM (Fin r → F) n

                              A measurement of r-tuples of polynomials, evaluated at y.

                              Equations
                              Instances For
                                theorem MIPRE.LIDT.Simul.evalTuplePOVM_extractPM {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d r : ℕ} (hd : 1 ≤ d) (hr : r ≤ K) {n : Type u_4} [Fintype n] [DecidableEq n] (R : ProjectiveMeasurement Unit LowIndDegPoly (Matrix n n ℂ)) (y : Point F m) :
                                evalTuplePOVM (extractPM hd hr R) y = POVM.map (fun (g : LowIndDegPoly) => extEval hd hr g y) (R.toPOVM ())
                                noncomputable def MIPRE.LIDT.Simul.combPOVM {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d r : ℕ} {n : Type u_4} [Fintype n] [DecidableEq n] (hd : 1 ≤ d) (A : Point F m → POVM (Fin r → F) n) (u : Point F (K + m)) :
                                POVM F n

                                The combined point measurement: at the padded point (x, y), measure the original point measurement at y and answer ∑_{j < r} x_j b_j.

                                Equations
                                Instances For
                                  theorem MIPRE.LIDT.Simul.extracted_conclusions {F : Type u_1} [Field F] [Fintype F] [DecidableEq F] {K m d r : ℕ} {dA : Type u_2} {dB : Type u_3} [Fintype dA] [DecidableEq dA] [Fintype dB] [DecidableEq dB] (hd : 1 ≤ d) (hr : r ≤ K) {ψ : dA × dB → ℂ} (hψ : star ψ ⬝ᵥ ψ = 1) (A : Point F m → POVM (Fin r → F) dA) (B : Point F m → POVM (Fin r → F) dB) (RA : ProjectiveMeasurement Unit LowIndDegPoly (Matrix dA dA ℂ)) (RB : ProjectiveMeasurement Unit LowIndDegPoly (Matrix dB dB ℂ)) {δ : ℝ} (h1 : inconsistency (uniform (Point F (K + m))) ψ (combPOVM hd A) (evalPOVM RB) ≤ δ) (h2 : inconsistency (uniform (Point F (K + m))) ψ (evalPOVM RA) (combPOVM hd B) ≤ δ) (h3 : (inconsistency (uniform Unit) ψ (fun (x : Unit) => RA.toPOVM ()) fun (x : Unit) => RB.toPOVM ()) ≤ δ) :
                                  inconsistency (uniform (Point F m)) ψ A (evalTuplePOVM (extractPM hd hr RB)) ≤ δ + (↑K + ↑m) * ↑d / ↑(Fintype.card F) ∧ inconsistency (uniform (Point F m)) ψ (evalTuplePOVM (extractPM hd hr RA)) B ≤ δ + (↑K + ↑m) * ↑d / ↑(Fintype.card F) ∧ (inconsistency (uniform Unit) ψ (fun (x : Unit) => (extractPM hd hr RA).toPOVM ()) fun (x : Unit) => (extractPM hd hr RB).toPOVM ()) ≤ δ

                                  From the single-codeword conclusions to the simultaneous ones (the paper's Step 4). If the two players' measurements RA, RB of polynomials in the K + m variables satisfy the three conclusions of the single-codeword theorem against the combined point measurements, with error δ, then their extractions satisfy the three conclusions of the simultaneous theorem against the original point measurements, with error δ + (K + m) d / q for the two point conclusions and δ for the full-tuple one.