| import OAI.Probability.EntangledGames.CoherentFilters |
|
|
| namespace OAI |
|
|
| universe u_n u_A u_m u_ι u_p u_q u_B |
|
|
| open scoped BigOperators ComplexOrder |
| open scoped MatrixOrder |
| open Matrix |
| open MeasureTheory Filter Set |
| open scoped Topology |
| open scoped Matrix.Norms.Elementwise |
| open scoped Interval |
| open scoped Kronecker |
|
|
| noncomputable section |
| namespace ThresholdParallelRepetition.QuantumSampling |
|
|
| structure POVM (n : Type u_n) (A : Type u_A) [Fintype n] [DecidableEq n] [Fintype A] where |
| effect : A → Matrix n n ℂ |
| pos : ∀ a, (effect a).PosSemidef |
| total : ∑ a, effect a = 1 |
|
|
| variable {m : Type u_m} {n : Type u_n} {A : Type u_A} [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n] |
| [Fintype A] |
|
|
| def POVM.default (a₀ : A) : POVM n A := by |
| classical |
| exact { effect := fun a => if a = a₀ then 1 else 0 |
| pos := fun a => by split <;> first | exact Matrix.PosSemidef.one | exact Matrix.PosSemidef.zero |
| total := by simp } |
|
|
| def POVM.pull (P : POVM m A) (K : Matrix m n ℂ) (a : A) : Matrix n n ℂ := |
| Kᴴ * P.effect a * K |
|
|
| omit [DecidableEq n] in |
| lemma POVM.pull_pos (P : POVM m A) (K : Matrix m n ℂ) (a : A) : |
| (P.pull K a).PosSemidef := (P.pos a).conjTranspose_mul_mul_same K |
| omit [Fintype n] [DecidableEq n] in |
| lemma POVM.pull_sum (P : POVM m A) (K : Matrix m n ℂ) : |
| ∑ a, P.pull K a = Kᴴ * K := by |
| simp only [POVM.pull, ← Matrix.sum_mul, ← Matrix.mul_sum, P.total, Matrix.mul_one] |
|
|
| omit [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n] in |
| lemma kronecker_sum_left {ι : Type u_ι} [Fintype ι] (M : ι → Matrix m m ℂ) |
| (N : Matrix n n ℂ) : (∑ i, M i) ⊗ₖ N = ∑ i, M i ⊗ₖ N := by |
| ext i j; simp only [Matrix.kroneckerMap_apply, Matrix.sum_apply, Finset.sum_mul] |
| omit [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n] in |
| lemma kronecker_sum_right {ι : Type u_ι} [Fintype ι] (M : Matrix m m ℂ) |
| (N : ι → Matrix n n ℂ) : M ⊗ₖ (∑ i, N i) = ∑ i, M ⊗ₖ N i := by |
| ext i j; simp only [Matrix.kroneckerMap_apply, Matrix.sum_apply, Finset.mul_sum] |
|
|
| @[reducible] def Copies (n : Type) : ℕ → Type |
| | 0 => Unit |
| | t+1 => n × Copies n t |
| instance copiesFintype {n : Type} [Fintype n] : (t : ℕ) → Fintype (Copies n t) |
| | 0 => inferInstanceAs (Fintype Unit) |
| | t+1 => by |
| letI := copiesFintype (n := n) t |
| exact inferInstanceAs (Fintype (n × Copies n t)) |
| instance copiesDecidableEq {n : Type} [DecidableEq n] : (t : ℕ) → DecidableEq (Copies n t) |
| | 0 => inferInstanceAs (DecidableEq Unit) |
| | t+1 => @instDecidableEqProd n (Copies n t) _ (copiesDecidableEq t) |
| instance copiesNonempty {n : Type} [Nonempty n] : (t : ℕ) → Nonempty (Copies n t) |
| | 0 => inferInstanceAs (Nonempty Unit) |
| | t+1 => by |
| let := copiesNonempty (n := n) t |
| exact inferInstanceAs (Nonempty (n × Copies n t)) |
|
|
| def tensorPower {m n : Type} (D : Matrix m n ℂ) : (t : ℕ) → Matrix (Copies m t) (Copies n t) ℂ |
| | 0 => fun _ _ => 1 |
| | t+1 => D ⊗ₖ tensorPower D t |
|
|
| lemma hsSq_tensorPower {m n : Type} [Fintype m] [Fintype n] (D : Matrix m n ℂ) (t : ℕ) : |
| hsSq (tensorPower D t) = hsSq D ^ t := by |
| induction t with |
| | zero => simp [tensorPower, hsSq] |
| | succ t ih => rw [tensorPower, hsSq_kronecker, ih, pow_succ'] |
|
|
| def firstSuccess {m n : Type} [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n] |
| {A : Type} [Fintype A] (P : POVM m A) (K : Matrix m n ℂ) |
| (hK : Kᴴ*K ≤ 1) (a₀ : A) : (t : ℕ) → POVM (Copies n t) A |
| | 0 => POVM.default a₀ |
| | t+1 => { |
| effect := fun a => P.pull K a ⊗ₖ 1 + (1-Kᴴ*K) ⊗ₖ (firstSuccess P K hK a₀ t).effect a |
| pos := fun a => ((P.pull_pos K a).kronecker Matrix.PosSemidef.one).add |
| ((Matrix.nonneg_iff_posSemidef.mp (sub_nonneg.mpr hK)).kronecker |
| ((firstSuccess P K hK a₀ t).pos a)) |
| total := by |
| rw [Finset.sum_add_distrib, ← kronecker_sum_left, ← kronecker_sum_right, |
| P.pull_sum, (firstSuccess P K hK a₀ t).total, ← Matrix.add_kronecker] |
| simp only [add_sub_cancel, Matrix.one_kronecker_one] } |
|
|
| lemma eval_submatrix {m : Type u_m} {n : Type u_n} {p : Type u_p} {q : Type u_q} [Fintype m] [Fintype n] [Fintype p] [Fintype q] |
| (C : Matrix m n ℂ) (U : Matrix m m ℂ) (V : Matrix n n ℂ) (e : p ≃ m) (f : q ≃ n) : |
| eval (C.submatrix e f) (U.submatrix e e) (V.submatrix f f) = eval C U V := by |
| simp only [eval_eq_sum, Matrix.submatrix_apply] |
| apply Fintype.sum_equiv e |
| intro i |
| apply Fintype.sum_equiv f |
| intro j |
| apply Fintype.sum_equiv e |
| intro k |
| exact Fintype.sum_equiv f _ _ (fun _ => rfl) |
|
|
| lemma exists_strategy_of_finite {m n X Y A B : Type} |
| [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n] [Nonempty m] [Nonempty n] |
| [Fintype A] [Fintype B] (C : Matrix m n ℂ) (hC : hsSq C = 1) |
| (P : X → POVM m A) (Q : Y → POVM n B) : |
| ∃ S : Strategy X Y A B, ∀ x y a b, S.born x y a b = prob C ((P x).effect a) ((Q y).effect b) := by |
| let e : Fin (Fintype.card m - 1 + 1) ≃ m := |
| (Fintype.equivFinOfCardEq (Nat.sub_add_cancel Fintype.card_pos).symm).symm |
| let f : Fin (Fintype.card n - 1 + 1) ≃ n := |
| (Fintype.equivFinOfCardEq (Nat.sub_add_cancel Fintype.card_pos).symm).symm |
| let S : Strategy X Y A B := { |
| dimA := Fintype.card m - 1 |
| dimB := Fintype.card n - 1 |
| state := vec (C.submatrix e f) |
| state_unit := by |
| simp only [vec, Matrix.submatrix_apply, Fintype.sum_prod_type] |
| rw [show (∑ i, ∑ j, Complex.normSq (C (e i) (f j))) = hsSq C by |
| unfold hsSq |
| apply Fintype.sum_equiv e |
| intro i |
| exact Fintype.sum_equiv f _ _ (fun _ => rfl)] |
| exact hC |
| alice := fun x a => ((P x).effect a).submatrix e e |
| bob := fun y b => ((Q y).effect b).submatrix f f |
| alice_pos := fun x a => ((P x).pos a).submatrix e |
| bob_pos := fun y b => ((Q y).pos b).submatrix f |
| alice_total := fun x => by |
| calc |
| _ = (∑ a, (P x).effect a).submatrix e e := by ext i j; simp [Matrix.sum_apply] |
| _ = 1 := by rw [(P x).total, Matrix.submatrix_one_equiv] |
| bob_total := fun y => by |
| calc |
| _ = (∑ b, (Q y).effect b).submatrix f f := by ext i j; simp [Matrix.sum_apply] |
| _ = 1 := by rw [(Q y).total, Matrix.submatrix_one_equiv] } |
| refine ⟨S, ?_⟩ |
| intro x y a b |
| rw [Strategy.born_eq_quadratic] |
| change prob (C.submatrix e f) (((P x).effect a).submatrix e e) |
| (((Q y).effect b).submatrix f f) = _ |
| exact congrArg Complex.re (eval_submatrix C _ _ e f) |
|
|
| lemma prob_first_step_ge {m : Type u_m} {n : Type u_n} {p : Type u_p} {q : Type u_q} [Fintype m] [Fintype n] [Fintype p] [Fintype q] |
| [DecidableEq p] [DecidableEq q] |
| (C : Matrix m n ℂ) (D : Matrix p q ℂ) (hD : hsSq D = 1) |
| {G F : Matrix m m ℂ} {H J : Matrix n n ℂ} {E : Matrix p p ℂ} {T : Matrix q q ℂ} |
| (hG : G.PosSemidef) (hF : F.PosSemidef) (hH : H.PosSemidef) (hJ : J.PosSemidef) |
| (hE : E.PosSemidef) (hT : T.PosSemidef) : |
| prob C G H + prob C F J * prob D E T ≤ |
| prob (C ⊗ₖ D) (G ⊗ₖ 1 + F ⊗ₖ E) (H ⊗ₖ 1 + J ⊗ₖ T) := by |
| rw [prob_add_left, prob_add_right, prob_add_right, |
| prob_kronecker C D hG hH Matrix.PosSemidef.one Matrix.PosSemidef.one, |
| prob_one, hD, mul_one, prob_kronecker C D hF hJ hE hT] |
| have h1 := prob_nonneg (C := C ⊗ₖ D) (hG.kronecker Matrix.PosSemidef.one) (hJ.kronecker hT) |
| have h2 := prob_nonneg (C := C ⊗ₖ D) (hF.kronecker hE) (hH.kronecker Matrix.PosSemidef.one) |
| linarith |
|
|
| lemma firstSuccess_prob_succ {m n p q A B : Type} [Fintype m] [Fintype n] |
| [Fintype p] [Fintype q] [DecidableEq m] [DecidableEq n] [DecidableEq p] [DecidableEq q] |
| [Fintype A] [Fintype B] |
| (D : Matrix n q ℂ) (hD : hsSq D = 1) (P : POVM m A) (Q : POVM p B) |
| (K : Matrix m n ℂ) (L : Matrix p q ℂ) (hK : Kᴴ*K ≤ 1) (hL : Lᴴ*L ≤ 1) |
| (a₀ : A) (b₀ : B) (t : ℕ) (a : A) (b : B) : |
| prob (K*D*Lᵀ) (P.effect a) (Q.effect b) + |
| prob D (1-Kᴴ*K) (1-Lᴴ*L) * |
| prob (tensorPower D t) ((firstSuccess P K hK a₀ t).effect a) |
| ((firstSuccess Q L hL b₀ t).effect b) ≤ |
| prob (tensorPower D (t+1)) ((firstSuccess P K hK a₀ (t+1)).effect a) |
| ((firstSuccess Q L hL b₀ (t+1)).effect b) := by |
| change _ ≤ prob (D ⊗ₖ tensorPower D t) |
| (P.pull K a ⊗ₖ 1 + (1-Kᴴ*K) ⊗ₖ (firstSuccess P K hK a₀ t).effect a) |
| (Q.pull L b ⊗ₖ 1 + (1-Lᴴ*L) ⊗ₖ (firstSuccess Q L hL b₀ t).effect b) |
| have hnorm : hsSq (tensorPower D t) = 1 := by rw [hsSq_tensorPower, hD, one_pow] |
| have h := prob_first_step_ge D (tensorPower D t) hnorm (P.pull_pos K a) |
| (Matrix.nonneg_iff_posSemidef.mp (sub_nonneg.mpr hK)) (Q.pull_pos L b) |
| (Matrix.nonneg_iff_posSemidef.mp (sub_nonneg.mpr hL)) |
| ((firstSuccess P K hK a₀ t).pos a) ((firstSuccess Q L hL b₀ t).pos b) |
| simpa only [POVM.pull, prob_pullback] using h |
|
|
| lemma prob_sum_left {m : Type u_m} {n : Type u_n} {ι : Type u_ι} [Fintype m] [Fintype n] [Fintype ι] |
| (C : Matrix m n ℂ) (A : ι → Matrix m m ℂ) (B : Matrix n n ℂ) : |
| prob C (∑ i, A i) B = ∑ i, prob C (A i) B := by |
| simp only [prob, eval_eq_trace, Matrix.sum_mul, Matrix.mul_sum, Matrix.trace_sum, Complex.re_sum] |
| lemma prob_sum_right {m : Type u_m} {n : Type u_n} {ι : Type u_ι} [Fintype m] [Fintype n] [Fintype ι] |
| (C : Matrix m n ℂ) (A : Matrix m m ℂ) (B : ι → Matrix n n ℂ) : |
| prob C A (∑ i, B i) = ∑ i, prob C A (B i) := by |
| simp only [prob, eval_eq_trace, Matrix.transpose_sum, Matrix.mul_sum, |
| Matrix.trace_sum, Complex.re_sum] |
|
|
| section Payoff |
| variable {m : Type u_m} {n : Type u_n} {A : Type u_A} {B : Type u_B} [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n] |
| [Fintype A] [Fintype B] |
|
|
| def payoff (C : Matrix m n ℂ) (P : POVM m A) (Q : POVM n B) (V : A → B → Bool) : ℝ := |
| ∑ a, ∑ b, if V a b then prob C (P.effect a) (Q.effect b) else 0 |
| lemma prob_total (C : Matrix m n ℂ) (P : POVM m A) (Q : POVM n B) : |
| ∑ a, ∑ b, prob C (P.effect a) (Q.effect b) = hsSq C := by |
| simp_rw [← prob_sum_right, ← prob_sum_left, P.total, Q.total, prob_one] |
| lemma payoff_nonneg (C : Matrix m n ℂ) (P : POVM m A) (Q : POVM n B) (V : A → B → Bool) : |
| 0 ≤ payoff C P Q V := by |
| apply Finset.sum_nonneg; intro a _ |
| apply Finset.sum_nonneg; intro b _ |
| split |
| · exact prob_nonneg (P.pos a) (Q.pos b) |
| · exact le_rfl |
| lemma payoff_le_hsSq (C : Matrix m n ℂ) (P : POVM m A) (Q : POVM n B) (V : A → B → Bool) : |
| payoff C P Q V ≤ hsSq C := by |
| rw [← prob_total C P Q] |
| apply Finset.sum_le_sum; intro a _ |
| apply Finset.sum_le_sum; intro b _ |
| split |
| · exact le_rfl |
| · exact prob_nonneg (P.pos a) (Q.pos b) |
| end Payoff |
|
|
| lemma firstSuccess_prob_geometric {m n p q A B : Type} [Fintype m] [Fintype n] |
| [Fintype p] [Fintype q] [DecidableEq m] [DecidableEq n] [DecidableEq p] [DecidableEq q] |
| [Fintype A] [Fintype B] |
| (D : Matrix n q ℂ) (hD : hsSq D = 1) (P : POVM m A) (Q : POVM p B) |
| (K : Matrix m n ℂ) (L : Matrix p q ℂ) (hK : Kᴴ*K ≤ 1) (hL : Lᴴ*L ≤ 1) |
| (a₀ : A) (b₀ : B) (t : ℕ) (a : A) (b : B) : |
| prob (K*D*Lᵀ) (P.effect a) (Q.effect b) * |
| (∑ j ∈ Finset.range t, (prob D (1-Kᴴ*K) (1-Lᴴ*L))^j) ≤ |
| prob (tensorPower D t) ((firstSuccess P K hK a₀ t).effect a) |
| ((firstSuccess Q L hL b₀ t).effect b) := by |
| let z := prob D (1-Kᴴ*K) (1-Lᴴ*L) |
| have hz : 0 ≤ z := prob_nonneg |
| (Matrix.nonneg_iff_posSemidef.mp (sub_nonneg.mpr hK)) |
| (Matrix.nonneg_iff_posSemidef.mp (sub_nonneg.mpr hL)) |
| induction t with |
| | zero => |
| simpa only [Finset.range_zero, Finset.sum_empty, mul_zero] using |
| (prob_nonneg ((firstSuccess P K hK a₀ 0).pos a) ((firstSuccess Q L hL b₀ 0).pos b) |
| (C := tensorPower D 0)) |
| | succ t ih => |
| calc |
| _ = prob (K*D*Lᵀ) (P.effect a) (Q.effect b) + z * |
| (prob (K*D*Lᵀ) (P.effect a) (Q.effect b) * ∑ j ∈ Finset.range t, z^j) := by |
| change _ * (∑ j ∈ Finset.range (t+1), z^j) = _ |
| rw [Finset.sum_range_succ'] |
| simp only [pow_succ', ← Finset.mul_sum, pow_zero] |
| ring |
| _ ≤ prob (K*D*Lᵀ) (P.effect a) (Q.effect b) + z * |
| prob (tensorPower D t) ((firstSuccess P K hK a₀ t).effect a) |
| ((firstSuccess Q L hL b₀ t).effect b) := |
| add_le_add le_rfl (mul_le_mul_of_nonneg_left ih hz) |
| _ ≤ _ := firstSuccess_prob_succ D hD P Q K L hK hL a₀ b₀ t a b |
|
|
| lemma firstSuccess_payoff_geometric {m n p q A B : Type} [Fintype m] [Fintype n] |
| [Fintype p] [Fintype q] [DecidableEq m] [DecidableEq n] [DecidableEq p] [DecidableEq q] |
| [Fintype A] [Fintype B] |
| (D : Matrix n q ℂ) (hD : hsSq D = 1) (P : POVM m A) (Q : POVM p B) |
| (K : Matrix m n ℂ) (L : Matrix p q ℂ) (hK : Kᴴ*K ≤ 1) (hL : Lᴴ*L ≤ 1) |
| (a₀ : A) (b₀ : B) (t : ℕ) (V : A → B → Bool) : |
| payoff (K*D*Lᵀ) P Q V * |
| (∑ j ∈ Finset.range t, (prob D (1-Kᴴ*K) (1-Lᴴ*L))^j) ≤ |
| payoff (tensorPower D t) (firstSuccess P K hK a₀ t) (firstSuccess Q L hL b₀ t) V := by |
| simp only [payoff, Finset.sum_mul] |
| apply Finset.sum_le_sum; intro a _ |
| apply Finset.sum_le_sum; intro b _ |
| split |
| · exact firstSuccess_prob_geometric D hD P Q K L hK hL a₀ b₀ t a b |
| · simp |
|
|
| lemma finite_filter_geometric_value {m n p q : Type} [Fintype m] [Fintype n] |
| [Fintype p] [Fintype q] [DecidableEq m] [DecidableEq n] [DecidableEq p] [DecidableEq q] |
| [Nonempty n] [Nonempty q] {x y a b : ℕ} (G : Game x y a b) |
| (D : Matrix n q ℂ) (hD : hsSq D = 1) |
| (P : Fin (x+1) → POVM m (Fin (a+1))) (Q : Fin (y+1) → POVM p (Fin (b+1))) |
| (K : Fin (x+1) → Matrix m n ℂ) (L : Fin (y+1) → Matrix p q ℂ) |
| (hK : ∀ x, (K x)ᴴ*K x ≤ 1) (hL : ∀ y, (L y)ᴴ*L y ≤ 1) (t : ℕ) : |
| (∑ z : Fin (x+1) × Fin (y+1), G.questionProb z * |
| (payoff (K z.1*D*(L z.2)ᵀ) (P z.1) (Q z.2) (G.accepts z.1 z.2) * |
| ∑ j ∈ Finset.range t, (prob D (1-(K z.1)ᴴ*K z.1) (1-(L z.2)ᴴ*L z.2))^j)) ≤ |
| entangledValue G := by |
| have hnorm : hsSq (tensorPower D t) = 1 := by rw [hsSq_tensorPower, hD, one_pow] |
| obtain ⟨S, hS⟩ := exists_strategy_of_finite (tensorPower D t) hnorm |
| (fun x => firstSuccess (P x) (K x) (hK x) 0 t) |
| (fun y => firstSuccess (Q y) (L y) (hL y) 0 t) |
| apply le_trans ?_ (successProbability_le_value G S) |
| unfold successProbability |
| apply Finset.sum_le_sum; intro z _ |
| apply mul_le_mul_of_nonneg_left _ (G.questionProb_nonneg z) |
| rw [Fintype.sum_prod_type] |
| simp_rw [hS] |
| exact firstSuccess_payoff_geometric D hD (P z.1) (Q z.2) (K z.1) (L z.2) |
| (hK z.1) (hL z.2) 0 0 t (G.accepts z.1 z.2) |
|
|
| section FilterMass |
| variable {m : Type u_m} {n : Type u_n} {p : Type u_p} {q : Type u_q} [Fintype m] [Fintype n] [Fintype p] [Fintype q] |
| [DecidableEq m] [DecidableEq n] [DecidableEq p] [DecidableEq q] |
|
|
| omit [Fintype p] [Fintype q] [DecidableEq m] [DecidableEq n] [DecidableEq p] [DecidableEq q] in |
| lemma prob_sub_left (C : Matrix m n ℂ) (A A' : Matrix m m ℂ) (B : Matrix n n ℂ) : |
| prob C (A-A') B = prob C A B - prob C A' B := by |
| simp only [prob, eval_eq_trace, Matrix.sub_mul, Matrix.mul_sub, Matrix.trace_sub, Complex.sub_re] |
| omit [Fintype p] [Fintype q] [DecidableEq m] [DecidableEq n] [DecidableEq p] [DecidableEq q] in |
| lemma prob_sub_right (C : Matrix m n ℂ) (A : Matrix m m ℂ) (B B' : Matrix n n ℂ) : |
| prob C A (B-B') = prob C A B - prob C A B' := by |
| simp only [prob, eval_eq_trace, Matrix.transpose_sub, Matrix.mul_sub, Matrix.trace_sub, Complex.sub_re] |
|
|
| omit [DecidableEq n] [DecidableEq q] in |
| lemma prob_gram (D : Matrix n q ℂ) (K : Matrix m n ℂ) (L : Matrix p q ℂ) : |
| prob D (Kᴴ*K) (Lᴴ*L) = hsSq (K*D*Lᵀ) := by |
| simpa only [Matrix.mul_one, prob_one] using prob_pullback D K L (1 : Matrix m m ℂ) (1 : Matrix p p ℂ) |
| omit [Fintype p] [DecidableEq p] [DecidableEq n] in |
| lemma prob_left_gram (D : Matrix n q ℂ) (K : Matrix m n ℂ) : |
| prob D (Kᴴ*K) 1 = hsSq (K*D) := by |
| simpa only [Matrix.conjTranspose_one, Matrix.one_mul, Matrix.transpose_one, Matrix.mul_one] using |
| prob_gram D K (1 : Matrix q q ℂ) |
| omit [Fintype m] [DecidableEq m] [DecidableEq q] in |
| lemma prob_right_gram (D : Matrix n q ℂ) (L : Matrix p q ℂ) : |
| prob D 1 (Lᴴ*L) = hsSq (D*Lᵀ) := by |
| simpa only [Matrix.conjTranspose_one, Matrix.one_mul] using |
| prob_gram D (1 : Matrix n n ℂ) L |
|
|
| lemma prob_fail (D : Matrix n q ℂ) (K : Matrix m n ℂ) (L : Matrix p q ℂ) : |
| prob D (1-Kᴴ*K) (1-Lᴴ*L) = |
| hsSq D - hsSq (K*D) - hsSq (D*Lᵀ) + hsSq (K*D*Lᵀ) := by |
| rw [prob_sub_left, prob_sub_right, prob_sub_right, prob_one, prob_right_gram, |
| prob_left_gram, prob_gram] |
| ring |
|
|
| lemma filter_mass_bounds (D : Matrix n q ℂ) (K : Matrix m n ℂ) (L : Matrix p q ℂ) |
| (hK : Kᴴ*K ≤ 1) (hL : Lᴴ*L ≤ 1) : |
| hsSq (K*D*Lᵀ) ≤ hsSq (K*D) ∧ hsSq (K*D*Lᵀ) ≤ hsSq (D*Lᵀ) ∧ |
| hsSq (K*D) ≤ hsSq D ∧ hsSq (D*Lᵀ) ≤ hsSq D := by |
| have hF := Matrix.nonneg_iff_posSemidef.mp (sub_nonneg.mpr hK) |
| have hJ := Matrix.nonneg_iff_posSemidef.mp (sub_nonneg.mpr hL) |
| have hG := Matrix.posSemidef_conjTranspose_mul_self K |
| have hH := Matrix.posSemidef_conjTranspose_mul_self L |
| have h1 := prob_nonneg (C := D) hG hJ |
| have h2 := prob_nonneg (C := D) hF hH |
| have h3 := prob_nonneg (C := D) hF Matrix.PosSemidef.one |
| have h4 := prob_nonneg (C := D) Matrix.PosSemidef.one hJ |
| rw [prob_sub_right, prob_left_gram, prob_gram] at h1 |
| rw [prob_sub_left, prob_right_gram, prob_gram] at h2 |
| rw [prob_sub_left, prob_one, prob_left_gram] at h3 |
| rw [prob_sub_right, prob_one, prob_right_gram] at h4 |
| exact ⟨sub_nonneg.mp h1, sub_nonneg.mp h2, sub_nonneg.mp h3, sub_nonneg.mp h4⟩ |
|
|
| lemma prob_fail_le (D : Matrix n q ℂ) (K : Matrix m n ℂ) (L : Matrix p q ℂ) |
| (hK : Kᴴ*K ≤ 1) (hL : Lᴴ*L ≤ 1) : |
| prob D (1-Kᴴ*K) (1-Lᴴ*L) ≤ hsSq D := by |
| rw [prob_fail] |
| have h := (filter_mass_bounds D K L hK hL).1 |
| have hb := hsSq_nonneg (D*Lᵀ) |
| linarith |
|
|
| lemma output_zero_of_fail_full (D : Matrix n q ℂ) (K : Matrix m n ℂ) (L : Matrix p q ℂ) |
| (hK : Kᴴ*K ≤ 1) (hL : Lᴴ*L ≤ 1) |
| (h : prob D (1-Kᴴ*K) (1-Lᴴ*L) = hsSq D) : hsSq (K*D*Lᵀ) = 0 := by |
| rw [prob_fail] at h |
| obtain ⟨h1,h2,_,_⟩ := filter_mass_bounds D K L hK hL |
| have h0 := hsSq_nonneg (K*D*Lᵀ) |
| linarith |
| end FilterMass |
|
|
| open Filter Topology |
| lemma geometric_contribution_tendsto {w z : ℝ} (hz0 : 0 ≤ z) (hz1 : z ≤ 1) |
| (hw : z = 1 → w = 0) : |
| Tendsto (fun t : ℕ => w * ∑ j ∈ Finset.range t, z^j) atTop (𝓝 (w/(1-z))) := by |
| by_cases hz : z = 1 |
| · simp only [hw hz, zero_mul, zero_div] |
| exact tendsto_const_nhds |
| · simpa only [div_eq_mul_inv] using |
| ((hasSum_geometric_of_lt_one hz0 (lt_of_le_of_ne hz1 hz)).tendsto_sum_nat.const_mul w) |
|
|
| theorem finite_filter_value {m n p q : Type} [Fintype m] [Fintype n] |
| [Fintype p] [Fintype q] [DecidableEq m] [DecidableEq n] [DecidableEq p] [DecidableEq q] |
| [Nonempty n] [Nonempty q] {x y a b : ℕ} (G : Game x y a b) |
| (D : Matrix n q ℂ) (hD : hsSq D = 1) |
| (P : Fin (x+1) → POVM m (Fin (a+1))) (Q : Fin (y+1) → POVM p (Fin (b+1))) |
| (K : Fin (x+1) → Matrix m n ℂ) (L : Fin (y+1) → Matrix p q ℂ) |
| (hK : ∀ x, (K x)ᴴ*K x ≤ 1) (hL : ∀ y, (L y)ᴴ*L y ≤ 1) : |
| (∑ z : Fin (x+1) × Fin (y+1), G.questionProb z * |
| (payoff (K z.1*D*(L z.2)ᵀ) (P z.1) (Q z.2) (G.accepts z.1 z.2) / |
| (1-prob D (1-(K z.1)ᴴ*K z.1) (1-(L z.2)ᴴ*L z.2)))) ≤ entangledValue G := by |
| apply le_of_tendsto' (x := atTop) (f := fun t : ℕ => ∑ z : Fin (x+1) × Fin (y+1), G.questionProb z * |
| (payoff (K z.1*D*(L z.2)ᵀ) (P z.1) (Q z.2) (G.accepts z.1 z.2) * |
| ∑ j ∈ Finset.range t, (prob D (1-(K z.1)ᴴ*K z.1) (1-(L z.2)ᴴ*L z.2))^j)) |
| · apply tendsto_finsetSum |
| intro z _ |
| apply Filter.Tendsto.const_mul |
| apply geometric_contribution_tendsto |
| · exact prob_nonneg (Matrix.nonneg_iff_posSemidef.mp (sub_nonneg.mpr (hK z.1))) |
| (Matrix.nonneg_iff_posSemidef.mp (sub_nonneg.mpr (hL z.2))) |
| · rw [← hD]; exact prob_fail_le D (K z.1) (L z.2) (hK z.1) (hL z.2) |
| · intro hz |
| have hn := output_zero_of_fail_full D (K z.1) (L z.2) (hK z.1) (hL z.2) (hz.trans hD.symm) |
| exact le_antisymm ((payoff_le_hsSq _ _ _ _).trans_eq hn) (payoff_nonneg _ _ _ _) |
| · exact fun t => finite_filter_geometric_value G D hD P Q K L hK hL t |
|
|
| lemma prob_smul {m : Type u_m} {n : Type u_n} [Fintype m] [Fintype n] |
| (r : ℝ) (C : Matrix m n ℂ) (A : Matrix m m ℂ) (B : Matrix n n ℂ) : |
| prob (r • C) A B = r^2 * prob C A B := by |
| simp only [prob, eval_eq_trace, Matrix.conjTranspose_smul, star_trivial, |
| Matrix.smul_mul, Matrix.mul_smul, Matrix.trace_smul, Complex.real_smul, |
| Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero] |
| ring |
|
|
| lemma payoff_smul {m : Type u_m} {n : Type u_n} {A : Type u_A} {B : Type u_B} [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n] |
| [Fintype A] [Fintype B] (r : ℝ) (C : Matrix m n ℂ) (P : POVM m A) (Q : POVM n B) |
| (V : A → B → Bool) : payoff (r • C) P Q V = r^2 * payoff C P Q V := by |
| simp only [payoff, prob_smul, Finset.mul_sum, mul_ite, mul_zero] |
|
|
| theorem finite_filter_value_unnormalized {m n p q : Type} [Fintype m] [Fintype n] |
| [Fintype p] [Fintype q] [DecidableEq m] [DecidableEq n] [DecidableEq p] [DecidableEq q] |
| [Nonempty n] [Nonempty q] {x y a b : ℕ} (G : Game x y a b) |
| (D : Matrix n q ℂ) (hD : 0 < hsSq D) |
| (P : Fin (x+1) → POVM m (Fin (a+1))) (Q : Fin (y+1) → POVM p (Fin (b+1))) |
| (K : Fin (x+1) → Matrix m n ℂ) (L : Fin (y+1) → Matrix p q ℂ) |
| (hK : ∀ x, (K x)ᴴ*K x ≤ 1) (hL : ∀ y, (L y)ᴴ*L y ≤ 1) : |
| (∑ z : Fin (x+1) × Fin (y+1), G.questionProb z * |
| (payoff (K z.1*D*(L z.2)ᵀ) (P z.1) (Q z.2) (G.accepts z.1 z.2) / |
| (hsSq (K z.1*D) + hsSq (D*(L z.2)ᵀ) - hsSq (K z.1*D*(L z.2)ᵀ)))) ≤ |
| entangledValue G := by |
| let r : ℝ := (Real.sqrt (hsSq D))⁻¹ |
| have hr : r^2 = (hsSq D)⁻¹ := by |
| dsimp [r] |
| rw [inv_pow, Real.sq_sqrt hD.le] |
| have hnorm : hsSq (r • D) = 1 := by |
| rw [hsSq_smul, hr, inv_mul_cancel₀ hD.ne'] |
| have hv := finite_filter_value G (r • D) hnorm P Q K L hK hL |
| convert hv using 1 |
| apply Finset.sum_congr rfl; intro z _ |
| congr 1 |
| rw [Matrix.mul_smul, Matrix.smul_mul, payoff_smul, prob_smul, hr] |
| have hden : (1 - (hsSq D)⁻¹ * prob D (1-(K z.1)ᴴ*K z.1) (1-(L z.2)ᴴ*L z.2)) = |
| (hsSq D - prob D (1-(K z.1)ᴴ*K z.1) (1-(L z.2)ᴴ*L z.2)) / hsSq D := by |
| field_simp |
| rw [hden, inv_mul_eq_div, div_div_div_cancel_right₀ hD.ne', prob_fail] |
| congr 1 |
| ring |
|
|
| end ThresholdParallelRepetition.QuantumSampling |
|
|
| end |
|
|
| end OAI |
|
|
