Documentation

MIPRE.Foundations.GameAdapt

Playing a strategy for one game as a strategy for another #

MIPRE.Foundations.GameTransport compares games that share their question alphabets and their distribution. This file drops both assumptions, which is what a reduction between two genuinely different games needs: given a strategy S for G, a map qA of the target game's questions into G's and a coarse-graining rA of G's answers into the target's, S.adapt plays S through them.

The conditional success probability #

Everything is organized around succAt S x y, the probability that S is accepted given the question pair (x, y), and its complement failAt. The value is the μ-average of succAt (value_eq_sum_succAt), so

1 - S.value = ∑ x y, μ x y * failAt S x y (one_sub_value_eq_sum_failAt),

which is the form a reduction compares across two games: an inequality between failure probabilities, each weighted by its own game's distribution.

What the adapter costs #

failAt_adapt_le says the adapted strategy fails no more often at (x', y') than S does at (qA x', qB y'), provided every tuple G accepts is still accepted after coarse-graining (hD). The summed statements ask hD only where G'.μ is nonzero, and that is not a convenience: a question pair outside the target's support may well be one the target rejects and the source accepts --- for the seeded CL test, a pair of two line questions, which the canonical-line test has no subtest for --- so the unrestricted hypothesis would be false. Summing, the price is entirely in the distributions: one_sub_value_adapt_le asks that the push-forward of G''s distribution along (qA, qB) be dominated by C times G's, and concludes 1 - (S.adapt …).value ≤ C * (1 - S.value).

Derandomization #

A reduction usually cannot choose the question map canonically: the target's question is typically a coarser object than G's — a line rather than a seeded description of a line — so one has to pick a preimage, and for any fixed choice the push-forward bound is off by the size of the fibre. exists_one_sub_value_adapt_le is the averaged form. It asks only that the push-forward bound hold on average over a finite family of question maps, and returns one member of the family achieving the conclusion. That is the "choose the best seed" step, and the averaging is exactly where the fibre size is paid back.

In a bipartite model #

A strategy in a bipartite model is a POVM family in each player's algebra and its value is BipartiteModel.povmValue; the adapted strategy is fun x' => (MA (qA x')).map (rA x'), and every statement above is proved once for it (BipartiteModel.condWin_adapt, BipartiteModel.one_sub_povmValue_adapt_le, ...). A tensor-product strategy is the strategy of its measurements in its tensor-product model (TensorProductStrategy.value_eq_tensor_povmValue), and its adapted strategy the model's (TensorProductStrategy.value_adapt), so the statements about TensorProductStrategy.adapt are instances.

theorem MIPRE.sum_sum_fiberwise₂ {A : Type u_3} {B : Type u_4} [Fintype A] [Fintype B] {A' : Type u_7} {B' : Type u_8} [Fintype A'] [Fintype B'] {M : Type u_9} [AddCommMonoid M] [DecidableEq A'] [DecidableEq B'] (rA : A → A') (rB : B → B') (f : A → B → M) :
∑ a' : A', ∑ b' : B', ∑ a : A with rA a = a', ∑ b : B with rB b = b', f a b = ∑ a : A, ∑ b : B, f a b

A double sum over the fibres of two coarse-grainings is the double sum.

Question-dependent merging of outcomes #

def MIPRE.ProjectiveMeasurement.mergeAt {X : Type u_9} {X' : Type u_10} {A : Type u_11} {A' : Type u_12} [Fintype A] [Fintype A'] [DecidableEq A'] {n : Type u_13} [Fintype n] [DecidableEq n] (P : ProjectiveMeasurement X A (Matrix n n ℂ)) (qX : X' → X) (r : X' → A → A') :

Merge the outcomes of P along a coarse-graining that may depend on the question, while reindexing the questions. GameTransport's merge is the case of a coarse-graining that does not depend on the question; a reduction generally needs the dependence, because how an answer must be converted can depend on which question was asked --- the reparametrization of a line answer depends on the line.

Equations
  • P.mergeAt qX r = { M := fun (x' : X') (a' : A') => ∑ a : A with r x' a = a', P.M (qX x') a, selfAdjoint := ⋯, projective := ⋯, normalized := ⋯ }
Instances For
    @[simp]
    theorem MIPRE.ProjectiveMeasurement.mergeAt_M {X : Type u_9} {X' : Type u_10} {A : Type u_11} {A' : Type u_12} [Fintype A] [Fintype A'] [DecidableEq A'] {n : Type u_13} [Fintype n] [DecidableEq n] (P : ProjectiveMeasurement X A (Matrix n n ℂ)) (qX : X' → X) (r : X' → A → A') (x' : X') (a' : A') :
    (P.mergeAt qX r).M x' a' = ∑ a : A with r x' a = a', P.M (qX x') a

    Playing a strategy through maps, in a bipartite model #

    A strategy in a bipartite model is a family of POVMs in each player's algebra, and its value is BipartiteModel.povmValue (TensorProductStrategy.value_eq_povmValue and povmValue_eq_tensor in the tensor-product model; CommutingOperatorStrategy.value_eq_povmValue in the commuting-operator model). Playing it on another game through a map of questions and a coarse-graining of answers is fun x' => (MA (qA x')).map (rA x'), and everything below is proved once for it; the statements about TensorProductStrategy.adapt further down are its instances.

    theorem MIPRE.BipartiteModel.condWin_adapt {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {𝒞 : Type u_9} {𝒜 : Type u_10} {ℬ : Type u_11} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] (M : BipartiteModel 𝒞 𝒜 ℬ) [PartialOrder 𝒜] [StarOrderedRing 𝒜] [PartialOrder ℬ] [StarOrderedRing ℬ] (MA : X → POVMIn A 𝒜) (MB : Y → POVMIn B ℬ) [DecidableEq A'] [DecidableEq B'] (G' : Game X' Y' A' B') (qA : X' → X) (qB : Y' → Y) (rA : X' → A → A') (rB : Y' → B → B') (x' : X') (y' : Y') :
    M.condWin G' (fun (x' : X') => POVMIn.map (rA x') (MA (qA x'))) (fun (y' : Y') => POVMIn.map (rB y') (MB (qB y'))) x' y' = ∑ a : A, ∑ b : B, (if G'.D x' y' (rA x' a) (rB y' b) = true then 1 else 0) * M.bornProb ((MA (qA x')).op a) ((MB (qB y')).op b)

    The adapted conditional acceptance, as a sum over the original answers: the coarse-graining disappears into the decision predicate.

    theorem MIPRE.BipartiteModel.condWin_le_condWin_adapt {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {𝒞 : Type u_9} {𝒜 : Type u_10} {ℬ : Type u_11} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] (M : BipartiteModel 𝒞 𝒜 ℬ) [PartialOrder 𝒜] [StarOrderedRing 𝒜] [PartialOrder ℬ] [StarOrderedRing ℬ] {G : Game X Y A B} (MA : X → POVMIn A 𝒜) (MB : Y → POVMIn B ℬ) [DecidableEq A'] [DecidableEq B'] (G' : Game X' Y' A' B') (qA : X' → X) (qB : Y' → Y) (rA : X' → A → A') (rB : Y' → B → B') (x' : X') (y' : Y') (hD : ∀ (a : A) (b : B), G.D (qA x') (qB y') a b = true → G'.D x' y' (rA x' a) (rB y' b) = true) :
    M.condWin G MA MB (qA x') (qB y') ≤ M.condWin G' (fun (x' : X') => POVMIn.map (rA x') (MA (qA x'))) (fun (y' : Y') => POVMIn.map (rB y') (MB (qB y'))) x' y'

    The adapter does not lose acceptance where every tuple G accepts is still accepted after coarse-graining.

    theorem MIPRE.BipartiteModel.condFail_adapt_le {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {𝒞 : Type u_9} {𝒜 : Type u_10} {ℬ : Type u_11} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] (M : BipartiteModel 𝒞 𝒜 ℬ) [PartialOrder 𝒜] [StarOrderedRing 𝒜] [PartialOrder ℬ] [StarOrderedRing ℬ] {G : Game X Y A B} (MA : X → POVMIn A 𝒜) (MB : Y → POVMIn B ℬ) [DecidableEq A'] [DecidableEq B'] (G' : Game X' Y' A' B') (qA : X' → X) (qB : Y' → Y) (rA : X' → A → A') (rB : Y' → B → B') (x' : X') (y' : Y') (hD : ∀ (a : A) (b : B), G.D (qA x') (qB y') a b = true → G'.D x' y' (rA x' a) (rB y' b) = true) :
    M.condFail G' (fun (x' : X') => POVMIn.map (rA x') (MA (qA x'))) (fun (y' : Y') => POVMIn.map (rB y') (MB (qB y'))) x' y' ≤ M.condFail G MA MB (qA x') (qB y')

    Equivalently: the adapted strategy fails no more often.

    theorem MIPRE.BipartiteModel.povmValue_relabel {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {𝒞 : Type u_9} {𝒜 : Type u_10} {ℬ : Type u_11} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] (M : BipartiteModel 𝒞 𝒜 ℬ) [PartialOrder 𝒜] [StarOrderedRing 𝒜] [PartialOrder ℬ] [StarOrderedRing ℬ] {G : Game X Y A B} (MA : X → POVMIn A 𝒜) (MB : Y → POVMIn B ℬ) [DecidableEq A'] [DecidableEq B'] (G' : Game X' Y' A' B') (eX : X' ≃ X) (eY : Y' ≃ Y) (eA : A' ≃ A) (eB : B' ≃ B) (hμ : ∀ (x' : X') (y' : Y'), G'.μ x' y' = G.μ (eX x') (eY y')) (hD : ∀ (x' : X') (y' : Y') (a' : A') (b' : B'), G'.D x' y' a' b' = G.D (eX x') (eY y') (eA a') (eB b')) :
    (M.povmValue G' (fun (x' : X') => POVMIn.map (⇑eA.symm) (MA (eX x'))) fun (y' : Y') => POVMIn.map (⇑eB.symm) (MB (eY y'))) = M.povmValue G MA MB

    Relabeling a strategy along equivalences keeps its value: the model form of TensorProductStrategy.value_relabel, and the content of ValueModel.eq_of_equiv for a strategy in a model.

    theorem MIPRE.BipartiteModel.one_sub_povmValue_adapt_le_sum {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {𝒞 : Type u_9} {𝒜 : Type u_10} {ℬ : Type u_11} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] (M : BipartiteModel 𝒞 𝒜 ℬ) [PartialOrder 𝒜] [StarOrderedRing 𝒜] [PartialOrder ℬ] [StarOrderedRing ℬ] {G : Game X Y A B} (MA : X → POVMIn A 𝒜) (MB : Y → POVMIn B ℬ) [DecidableEq A'] [DecidableEq B'] [DecidableEq X] [DecidableEq Y] (G' : Game X' Y' A' B') (qA : X' → X) (qB : Y' → Y) (rA : X' → A → A') (rB : Y' → B → B') (hD : ∀ (x' : X') (y' : Y') (a : A) (b : B), G'.μ x' y' ≠ 0 → G.D (qA x') (qB y') a b = true → G'.D x' y' (rA x' a) (rB y' b) = true) :
    (1 - M.povmValue G' (fun (x' : X') => POVMIn.map (rA x') (MA (qA x'))) fun (y' : Y') => POVMIn.map (rB y') (MB (qB y'))) ≤ ∑ x : X, ∑ y : Y, (∑ x' : X' with qA x' = x, ∑ y' : Y' with qB y' = y, G'.μ x' y') * M.condFail G MA MB x y

    The failure of the adapted strategy, bounded by G's conditional failures weighted by the push-forward of G''s distribution.

    theorem MIPRE.BipartiteModel.one_sub_povmValue_adapt_le {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {𝒞 : Type u_9} {𝒜 : Type u_10} {ℬ : Type u_11} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] (M : BipartiteModel 𝒞 𝒜 ℬ) [PartialOrder 𝒜] [StarOrderedRing 𝒜] [PartialOrder ℬ] [StarOrderedRing ℬ] {G : Game X Y A B} (MA : X → POVMIn A 𝒜) (MB : Y → POVMIn B ℬ) [DecidableEq A'] [DecidableEq B'] [DecidableEq X] [DecidableEq Y] (hψ : ‖M.ψ‖ = 1) (G' : Game X' Y' A' B') (qA : X' → X) (qB : Y' → Y) (rA : X' → A → A') (rB : Y' → B → B') (C : ℝ) (hD : ∀ (x' : X') (y' : Y') (a : A) (b : B), G'.μ x' y' ≠ 0 → G.D (qA x') (qB y') a b = true → G'.D x' y' (rA x' a) (rB y' b) = true) (hμ : ∀ (x : X) (y : Y), ∑ x' : X' with qA x' = x, ∑ y' : Y' with qB y' = y, G'.μ x' y' ≤ C * G.μ x y) :
    (1 - M.povmValue G' (fun (x' : X') => POVMIn.map (rA x') (MA (qA x'))) fun (y' : Y') => POVMIn.map (rB y') (MB (qB y'))) ≤ C * (1 - M.povmValue G MA MB)

    The cost of the adapter. If the push-forward of G''s question distribution along (qA, qB) is dominated by C times G's, the adapted strategy's failure is at most C times the original's.

    theorem MIPRE.BipartiteModel.sum_one_sub_povmValue_adapt_le {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {𝒞 : Type u_9} {𝒜 : Type u_10} {ℬ : Type u_11} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] (M : BipartiteModel 𝒞 𝒜 ℬ) [PartialOrder 𝒜] [StarOrderedRing 𝒜] [PartialOrder ℬ] [StarOrderedRing ℬ] {G : Game X Y A B} (MA : X → POVMIn A 𝒜) (MB : Y → POVMIn B ℬ) [DecidableEq A'] [DecidableEq B'] [DecidableEq X] [DecidableEq Y] {Seed : Type u_12} [Fintype Seed] (hψ : ‖M.ψ‖ = 1) (G' : Game X' Y' A' B') (qA : Seed → X' → X) (qB : Seed → Y' → Y) (rA : Seed → X' → A → A') (rB : Seed → Y' → B → B') (C : ℝ) (hD : ∀ (σ : Seed) (x' : X') (y' : Y') (a : A) (b : B), G'.μ x' y' ≠ 0 → G.D (qA σ x') (qB σ y') a b = true → G'.D x' y' (rA σ x' a) (rB σ y' b) = true) (hμ : ∀ (x : X) (y : Y), ∑ σ : Seed, ∑ x' : X' with qA σ x' = x, ∑ y' : Y' with qB σ y' = y, G'.μ x' y' ≤ ↑(Fintype.card Seed) * (C * G.μ x y)) :
    ∑ σ : Seed, (1 - M.povmValue G' (fun (x' : X') => POVMIn.map (rA σ x') (MA (qA σ x'))) fun (y' : Y') => POVMIn.map (rB σ y') (MB (qB σ y'))) ≤ ↑(Fintype.card Seed) * (C * (1 - M.povmValue G MA MB))

    The summed form of one_sub_povmValue_adapt_le over a finite family of question maps, when the push-forward bound holds on average.

    theorem MIPRE.BipartiteModel.exists_one_sub_povmValue_adapt_le {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {𝒞 : Type u_9} {𝒜 : Type u_10} {ℬ : Type u_11} [Ring 𝒞] [StarRing 𝒞] [Algebra ℂ 𝒞] [Ring 𝒜] [StarRing 𝒜] [Algebra ℂ 𝒜] [Ring ℬ] [StarRing ℬ] [Algebra ℂ ℬ] (M : BipartiteModel 𝒞 𝒜 ℬ) [PartialOrder 𝒜] [StarOrderedRing 𝒜] [PartialOrder ℬ] [StarOrderedRing ℬ] {G : Game X Y A B} (MA : X → POVMIn A 𝒜) (MB : Y → POVMIn B ℬ) [DecidableEq A'] [DecidableEq B'] [DecidableEq X] [DecidableEq Y] {Seed : Type u_12} [Fintype Seed] [Nonempty Seed] (hψ : ‖M.ψ‖ = 1) (G' : Game X' Y' A' B') (qA : Seed → X' → X) (qB : Seed → Y' → Y) (rA : Seed → X' → A → A') (rB : Seed → Y' → B → B') (C : ℝ) (hD : ∀ (σ : Seed) (x' : X') (y' : Y') (a : A) (b : B), G'.μ x' y' ≠ 0 → G.D (qA σ x') (qB σ y') a b = true → G'.D x' y' (rA σ x' a) (rB σ y' b) = true) (hμ : ∀ (x : X) (y : Y), ∑ σ : Seed, ∑ x' : X' with qA σ x' = x, ∑ y' : Y' with qB σ y' = y, G'.μ x' y' ≤ ↑(Fintype.card Seed) * (C * G.μ x y)) :
    ∃ (σ : Seed), (1 - M.povmValue G' (fun (x' : X') => POVMIn.map (rA σ x') (MA (qA σ x'))) fun (y' : Y') => POVMIn.map (rB σ y') (MB (qB σ y'))) ≤ C * (1 - M.povmValue G MA MB)

    The averaged form of one_sub_povmValue_adapt_le: some member of a finite family of question maps achieves the conclusion when the push-forward bound holds on average.

    Born-rule probabilities and the conditional success probability #

    noncomputable def MIPRE.TensorProductStrategy.born {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {G : Game X Y A B} (S : TensorProductStrategy G) (x : X) (y : Y) (a : A) (b : B) :

    The Born-rule probability that S answers (a, b) to the question pair (x, y).

    Equations
    Instances For
      theorem MIPRE.TensorProductStrategy.born_eq_bornProb {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {G : Game X Y A B} (S : TensorProductStrategy G) (x : X) (y : Y) (a : A) (b : B) :
      S.born x y a b = (BipartiteModel.tensor S.ψ).bornProb ((S.PA.toPOVM x).toIn.op a) ((S.PB.toPOVM y).toIn.op b)

      The Born probability of a strategy is that of its tensor-product model.

      theorem MIPRE.TensorProductStrategy.sum_born {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {G : Game X Y A B} (S : TensorProductStrategy G) (x : X) (y : Y) :
      ∑ a : A, ∑ b : B, S.born x y a b = 1
      noncomputable def MIPRE.TensorProductStrategy.succAt {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {G : Game X Y A B} (S : TensorProductStrategy G) (x : X) (y : Y) :

      The probability that S is accepted, given the question pair (x, y).

      Equations
      Instances For
        noncomputable def MIPRE.TensorProductStrategy.failAt {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {G : Game X Y A B} (S : TensorProductStrategy G) (x : X) (y : Y) :

        The probability that S is rejected, given the question pair (x, y).

        Equations
        Instances For
          theorem MIPRE.TensorProductStrategy.succAt_eq_tensor_condWin {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {G : Game X Y A B} (S : TensorProductStrategy G) (x : X) (y : Y) :
          S.succAt x y = (BipartiteModel.tensor S.ψ).condWin G (fun (x : X) => (S.PA.toPOVM x).toIn) (fun (y : Y) => (S.PB.toPOVM y).toIn) x y

          The conditional success probability is that of the tensor-product model.

          theorem MIPRE.TensorProductStrategy.failAt_eq_tensor_condFail {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {G : Game X Y A B} (S : TensorProductStrategy G) (x : X) (y : Y) :
          S.failAt x y = (BipartiteModel.tensor S.ψ).condFail G (fun (x : X) => (S.PA.toPOVM x).toIn) (fun (y : Y) => (S.PB.toPOVM y).toIn) x y
          theorem MIPRE.TensorProductStrategy.succAt_le_one {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {G : Game X Y A B} (S : TensorProductStrategy G) (x : X) (y : Y) :
          S.succAt x y ≤ 1
          theorem MIPRE.TensorProductStrategy.failAt_nonneg {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {G : Game X Y A B} (S : TensorProductStrategy G) (x : X) (y : Y) :
          0 ≤ S.failAt x y
          theorem MIPRE.TensorProductStrategy.value_eq_sum_succAt {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {G : Game X Y A B} (S : TensorProductStrategy G) :
          S.value = ∑ x : X, ∑ y : Y, G.μ x y * S.succAt x y

          The value is the μ-average of the conditional success probability.

          theorem MIPRE.TensorProductStrategy.value_eq_tensor_povmValue {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {G : Game X Y A B} (S : TensorProductStrategy G) :
          S.value = (BipartiteModel.tensor S.ψ).povmValue G (fun (x : X) => (S.PA.toPOVM x).toIn) fun (y : Y) => (S.PB.toPOVM y).toIn

          The value of a strategy is the value of its measurements in its tensor-product model.

          theorem MIPRE.TensorProductStrategy.one_sub_value_eq_sum_failAt {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {G : Game X Y A B} (S : TensorProductStrategy G) :
          1 - S.value = ∑ x : X, ∑ y : Y, G.μ x y * S.failAt x y

          The failure probability, decomposed by question pair.

          The adapted strategy #

          noncomputable def MIPRE.TensorProductStrategy.adapt {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {G : Game X Y A B} [DecidableEq A'] [DecidableEq B'] (S : TensorProductStrategy G) (G' : Game X' Y' A' B') (qA : X' → X) (qB : Y' → Y) (rA : X' → A → A') (rB : Y' → B → B') :

          Play S on G', through a map qA, qB of G''s questions into G's and a coarse-graining rA, rB of G's answers into G''s that may depend on the question: the measurement at a question x' of G' is the one S uses at qA x', with its outcomes merged along rA x'.

          Equations
          Instances For
            theorem MIPRE.ProjectiveMeasurement.mergeAt_toIn {X : Type u_9} {X' : Type u_10} {A : Type u_11} {A' : Type u_12} [Fintype A] [Fintype A'] [DecidableEq A'] {n : Type u_13} [Fintype n] [DecidableEq n] (P : ProjectiveMeasurement X A (Matrix n n ℂ)) (qX : X' → X) (r : X' → A → A') :
            (fun (x' : X') => ((P.mergeAt qX r).toPOVM x').toIn) = fun (x' : X') => POVMIn.map (r x') (P.toPOVM (qX x')).toIn

            The merged measurement is the coarse-graining of the original, as a POVM in the matrix algebra.

            theorem MIPRE.TensorProductStrategy.value_adapt {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {G : Game X Y A B} [DecidableEq A'] [DecidableEq B'] (S : TensorProductStrategy G) (G' : Game X' Y' A' B') (qA : X' → X) (qB : Y' → Y) (rA : X' → A → A') (rB : Y' → B → B') :
            (S.adapt G' qA qB rA rB).value = (BipartiteModel.tensor S.ψ).povmValue G' (fun (x' : X') => POVMIn.map (rA x') (S.PA.toPOVM (qA x')).toIn) fun (y' : Y') => POVMIn.map (rB y') (S.PB.toPOVM (qB y')).toIn

            The adapted strategy is the model's adapted strategy: its value is the value, in the tensor-product model of S, of the coarse-grained measurements.

            theorem MIPRE.TensorProductStrategy.succAt_adapt_eq_condWin {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {G : Game X Y A B} [DecidableEq A'] [DecidableEq B'] (S : TensorProductStrategy G) (G' : Game X' Y' A' B') (qA : X' → X) (qB : Y' → Y) (rA : X' → A → A') (rB : Y' → B → B') (x' : X') (y' : Y') :
            (S.adapt G' qA qB rA rB).succAt x' y' = (BipartiteModel.tensor S.ψ).condWin G' (fun (x' : X') => POVMIn.map (rA x') (S.PA.toPOVM (qA x')).toIn) (fun (y' : Y') => POVMIn.map (rB y') (S.PB.toPOVM (qB y')).toIn) x' y'
            theorem MIPRE.TensorProductStrategy.succAt_le_succAt_adapt {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {G : Game X Y A B} [DecidableEq A'] [DecidableEq B'] (S : TensorProductStrategy G) (G' : Game X' Y' A' B') (qA : X' → X) (qB : Y' → Y) (rA : X' → A → A') (rB : Y' → B → B') (x' : X') (y' : Y') (hD : ∀ (a : A) (b : B), G.D (qA x') (qB y') a b = true → G'.D x' y' (rA x' a) (rB y' b) = true) :
            S.succAt (qA x') (qB y') ≤ (S.adapt G' qA qB rA rB).succAt x' y'

            The adapter does not lose acceptance. If every tuple G accepts at (qA x', qB y') is still accepted by G' at (x', y') after coarse-graining, the adapted strategy succeeds at least as often there.

            theorem MIPRE.TensorProductStrategy.failAt_adapt_le {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {G : Game X Y A B} [DecidableEq A'] [DecidableEq B'] (S : TensorProductStrategy G) (G' : Game X' Y' A' B') (qA : X' → X) (qB : Y' → Y) (rA : X' → A → A') (rB : Y' → B → B') (x' : X') (y' : Y') (hD : ∀ (a : A) (b : B), G.D (qA x') (qB y') a b = true → G'.D x' y' (rA x' a) (rB y' b) = true) :
            (S.adapt G' qA qB rA rB).failAt x' y' ≤ S.failAt (qA x') (qB y')

            Equivalently: the adapted strategy fails no more often.

            The cost of the adapter is the push-forward of the distribution #

            theorem MIPRE.TensorProductStrategy.one_sub_value_adapt_le {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {G : Game X Y A B} [DecidableEq A'] [DecidableEq B'] [DecidableEq X] [DecidableEq Y] (S : TensorProductStrategy G) (G' : Game X' Y' A' B') (qA : X' → X) (qB : Y' → Y) (rA : X' → A → A') (rB : Y' → B → B') (C : ℝ) (hD : ∀ (x' : X') (y' : Y') (a : A) (b : B), G'.μ x' y' ≠ 0 → G.D (qA x') (qB y') a b = true → G'.D x' y' (rA x' a) (rB y' b) = true) (hμ : ∀ (x : X) (y : Y), ∑ x' : X' with qA x' = x, ∑ y' : Y' with qB y' = y, G'.μ x' y' ≤ C * G.μ x y) :
            1 - (S.adapt G' qA qB rA rB).value ≤ C * (1 - S.value)

            The cost of the adapter. If the push-forward of G''s question distribution along (qA, qB) is dominated by C times G's, the adapted strategy's failure is at most C times S's.

            Derandomization #

            theorem MIPRE.TensorProductStrategy.exists_one_sub_value_adapt_le {X : Type u_1} {Y : Type u_2} {A : Type u_3} {B : Type u_4} [Fintype X] [Fintype Y] [Fintype A] [Fintype B] {X' : Type u_5} {Y' : Type u_6} {A' : Type u_7} {B' : Type u_8} [Fintype X'] [Fintype Y'] [Fintype A'] [Fintype B'] {G : Game X Y A B} [DecidableEq A'] [DecidableEq B'] [DecidableEq X] [DecidableEq Y] {Seed : Type u_9} [Fintype Seed] [Nonempty Seed] (S : TensorProductStrategy G) (G' : Game X' Y' A' B') (qA : Seed → X' → X) (qB : Seed → Y' → Y) (rA : Seed → X' → A → A') (rB : Seed → Y' → B → B') (C : ℝ) (hD : ∀ (σ : Seed) (x' : X') (y' : Y') (a : A) (b : B), G'.μ x' y' ≠ 0 → G.D (qA σ x') (qB σ y') a b = true → G'.D x' y' (rA σ x' a) (rB σ y' b) = true) (hμ : ∀ (x : X) (y : Y), ∑ σ : Seed, ∑ x' : X' with qA σ x' = x, ∑ y' : Y' with qB σ y' = y, G'.μ x' y' ≤ ↑(Fintype.card Seed) * (C * G.μ x y)) :
            ∃ (σ : Seed), 1 - (S.adapt G' (qA σ) (qB σ) (rA σ) (rB σ)).value ≤ C * (1 - S.value)

            The averaged form of one_sub_value_adapt_le. The push-forward bound need only hold on average over a finite family of question maps; some member of the family then achieves the conclusion. This is how a reduction that must choose a preimage of each target question pays back the size of the fibre.