Download data/lean/OAI/Probability/EntangledGames/BlockStates.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 13 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/EntangledGames/BlockStates.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/EntangledGames/BlockStates.lean
-
curl -L -o BlockStates.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/EntangledGames/BlockStates.lean
13 kB
| import OAI.Probability.EntangledGames.ExposureChain | |
| namespace OAI | |
| universe u_m u_n u_R u_A u_B u_Z | |
| noncomputable section | |
| open scoped BigOperators MatrixOrder ComplexOrder | |
| open Matrix | |
| namespace ThresholdParallelRepetition.QuantumSampling | |
| section Blocks | |
| variable {m : Type u_m} {n : Type u_n} {R : Type u_R} [Fintype m] [Fintype n] [Fintype R] [DecidableEq R] | |
| lemma trace_blockDiagonal (C : R β Matrix m m β) : | |
| Matrix.trace (Matrix.blockDiagonal C) = β r, Matrix.trace (C r) := by | |
| simp only [Matrix.trace, Matrix.diag, Fintype.sum_prod_type, Matrix.blockDiagonal_apply_eq] | |
| exact Finset.sum_comm | |
| lemma hsSq_blockDiagonal (C : R β Matrix m n β) : | |
| hsSq (Matrix.blockDiagonal C) = β r, hsSq (C r) := by | |
| simp only [hsSq_eq_trace, Matrix.blockDiagonal_conjTranspose, β Matrix.blockDiagonal_mul, | |
| trace_blockDiagonal, Complex.re_sum] | |
| lemma prob_blockDiagonal (C : R β Matrix m n β) (A : R β Matrix m m β) | |
| (B : R β Matrix n n β) : | |
| prob (Matrix.blockDiagonal C) (Matrix.blockDiagonal A) (Matrix.blockDiagonal B) = | |
| β r, prob (C r) (A r) (B r) := by | |
| simp only [prob, eval_eq_trace, Matrix.blockDiagonal_conjTranspose, β Matrix.blockDiagonal_mul, | |
| Matrix.blockDiagonal_transpose, trace_blockDiagonal, Complex.re_sum] | |
| variable [DecidableEq m] | |
| lemma posSemidef_blockDiagonal (A : R β Matrix m m β) (hA : β r, (A r).PosSemidef) : | |
| (Matrix.blockDiagonal A).PosSemidef := by | |
| let B := Matrix.blockDiagonal (fun r => CFC.sqrt (A r)) | |
| have he : Bα΄΄*B = Matrix.blockDiagonal A := by | |
| simp only [B, Matrix.blockDiagonal_conjTranspose, β Matrix.blockDiagonal_mul] | |
| congr 1 | |
| funext r | |
| rw [(Matrix.nonneg_iff_posSemidef.mp (CFC.sqrt_nonneg (A r))).isHermitian.eq, | |
| CFC.sqrt_mul_sqrt_self _ (hA r).nonneg] | |
| rw [β he] | |
| exact Matrix.posSemidef_conjTranspose_mul_self B | |
| variable {A : Type u_A} {B : Type u_B} [Fintype A] [Fintype B] [DecidableEq n] | |
| def POVM.blocks (P : R β POVM m A) : POVM (mΓR) A where | |
| effect a := Matrix.blockDiagonal (fun r => (P r).effect a) | |
| pos a := posSemidef_blockDiagonal _ (fun r => (P r).pos a) | |
| total := by | |
| change (β a, (Matrix.blockDiagonalAddMonoidHom m m R β) (fun r => (P r).effect a)) = _ | |
| rw [β map_sum] | |
| have he : (β a, fun r => (P r).effect a) = 1 := by | |
| funext r; simpa only [Finset.sum_apply, Pi.one_apply] using (P r).total | |
| rw [he] | |
| exact Matrix.blockDiagonal_one | |
| lemma payoff_blockDiagonal (C : R β Matrix m n β) (P : R β POVM m A) (Q : R β POVM n B) | |
| (V : A β B β Bool) : | |
| payoff (Matrix.blockDiagonal C) (POVM.blocks P) (POVM.blocks Q) V = | |
| β r, payoff (C r) (P r) (Q r) V := by | |
| simp only [payoff, POVM.blocks, prob_blockDiagonal] | |
| calc | |
| _ = β a, β b, β r, if V a b then prob (C r) ((P r).effect a) ((Q r).effect b) else 0 := by | |
| apply Finset.sum_congr rfl; intro a _ | |
| apply Finset.sum_congr rfl; intro b _ | |
| split <;> simp_all | |
| _ = _ := by | |
| conv_rhs => | |
| rw [Finset.sum_comm] | |
| arg 2 | |
| ext a | |
| rw [Finset.sum_comm] | |
| end Blocks | |
| section Normalization | |
| open scoped Matrix.Norms.Frobenius | |
| variable {m : Type u_m} {n : Type u_n} [Fintype m] [Fintype n] | |
| lemma hsSq_eq_zero_iff (C : Matrix m n β) : hsSq C = 0 β C = 0 := by | |
| constructor | |
| Β· intro h | |
| apply norm_eq_zero.mp | |
| rw [norm_eq_sqrt_hsSq, h, Real.sqrt_zero] | |
| Β· rintro rfl; exact hsSq_zero | |
| def unitize (C D : Matrix m n β) : Matrix m n β := | |
| if hsSq C = 0 then D else (Real.sqrt (hsSq C))β»ΒΉ β’ C | |
| lemma hsSq_unitize (C D : Matrix m n β) (hD : hsSq D = 1) : hsSq (unitize C D) = 1 := by | |
| unfold unitize | |
| split_ifs with h | |
| Β· exact hD | |
| Β· rw [hsSq_smul, inv_pow, Real.sq_sqrt (hsSq_nonneg C)] | |
| exact inv_mul_cancelβ h | |
| lemma unitize_distance (C D : Matrix m n β) (hD : hsSq D = 1) : | |
| hsSq (C-unitize C D) = (Real.sqrt (hsSq C)-1)^2 := by | |
| unfold unitize | |
| split_ifs with h | |
| Β· have hz := (hsSq_eq_zero_iff C).mp h | |
| simp only [hz, hsSq_zero, Real.sqrt_zero, zero_sub, hsSq_neg, hD] | |
| norm_num | |
| Β· have hs : Real.sqrt (hsSq C) β 0 := (Real.sqrt_pos.2 (lt_of_le_of_ne (hsSq_nonneg C) (Ne.symm h))).ne' | |
| have he : C - (Real.sqrt (hsSq C))β»ΒΉ β’ C = (1-(Real.sqrt (hsSq C))β»ΒΉ) β’ C := by | |
| rw [sub_smul, one_smul] | |
| rw [he, hsSq_smul] | |
| calc | |
| _ = (1-(Real.sqrt (hsSq C))β»ΒΉ)^2 * (Real.sqrt (hsSq C))^2 := by rw [Real.sq_sqrt (hsSq_nonneg C)] | |
| _ = _ := by field_simp | |
| lemma hsSq_difference_unbounded (C D : Matrix m n β) (hD : hsSq D β€ 1) : | |
| hsSq C - hsSq D β€ 2*Real.sqrt (hsSq (C-D)) + hsSq (C-D) := by | |
| have ht : βCβ β€ βDβ + βC-Dβ := by | |
| simpa only [norm_sub_rev] using norm_le_insert D C | |
| have hd := hsSq_le_one_norm hD | |
| have hc0 := norm_nonneg C | |
| have hd0 := norm_nonneg D | |
| have he0 := norm_nonneg (C-D) | |
| have ht2 := sq_le_sqβ hc0 (add_nonneg hd0 he0) |>.2 ht | |
| simp only [norm_eq_sqrt_hsSq] at ht2 hd hd0 he0 | |
| have hmul := mul_le_mul_of_nonneg_right hd he0 | |
| rw [Real.sq_sqrt (hsSq_nonneg C)] at ht2 | |
| nlinarith [Real.sq_sqrt (hsSq_nonneg D), Real.sq_sqrt (hsSq_nonneg (C-D))] | |
| end Normalization | |
| 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] | |
| lemma payoff_difference_unbounded (C D : Matrix m n β) (P : POVM m A) (Q : POVM n B) | |
| (V : A β B β Bool) (hD : hsSq D β€ 1) : | |
| payoff C P Q V - payoff D P Q V β€ 2*Real.sqrt (hsSq (C-D)) + hsSq (C-D) := by | |
| have hsd := (hsSq_mul_contraction (winSqrt_contraction P Q V) (flat D)).trans | |
| (le_trans (le_of_eq (hsSq_flat D)) hD) | |
| rw [payoff_eq_hsSq, payoff_eq_hsSq] | |
| refine (hsSq_difference_unbounded _ _ hsd).trans ?_ | |
| have he : hsSq (CFC.sqrt (winEffect P Q V)*flat C-CFC.sqrt (winEffect P Q V)*flat D) β€ hsSq (C-D) := by | |
| rw [β Matrix.mul_sub, β flat_sub] | |
| exact (hsSq_mul_contraction (winSqrt_contraction P Q V) _).trans_eq (hsSq_flat _) | |
| exact add_le_add (mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt he) (by norm_num)) he | |
| end Payoff | |
| end ThresholdParallelRepetition.QuantumSampling | |
| end | |
| noncomputable section | |
| open scoped BigOperators MatrixOrder ComplexOrder | |
| open Matrix | |
| namespace ThresholdParallelRepetition.QuantumSampling | |
| variable {m : Type u_m} {n : Type u_n} [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n] | |
| lemma posSemidef_fromBlocks_diag {A : Matrix m m β} {B : Matrix n n β} | |
| (hA : A.PosSemidef) (hB : B.PosSemidef) : | |
| (Matrix.fromBlocks A 0 0 B).PosSemidef := by | |
| let T := Matrix.fromBlocks (CFC.sqrt A) (0 : Matrix m n β) 0 (CFC.sqrt B) | |
| have he : Tα΄΄*T = Matrix.fromBlocks A 0 0 B := by | |
| simp only [T, Matrix.fromBlocks_conjTranspose, Matrix.conjTranspose_zero, | |
| Matrix.fromBlocks_multiply, Matrix.mul_zero, Matrix.zero_mul, add_zero, zero_add, | |
| (Matrix.nonneg_iff_posSemidef.mp (CFC.sqrt_nonneg A)).isHermitian.eq, | |
| (Matrix.nonneg_iff_posSemidef.mp (CFC.sqrt_nonneg B)).isHermitian.eq, | |
| CFC.sqrt_mul_sqrt_self _ hA.nonneg, CFC.sqrt_mul_sqrt_self _ hB.nonneg] | |
| rw [β he] | |
| exact Matrix.posSemidef_conjTranspose_mul_self T | |
| def squareState (C : Matrix m n β) : Matrix (mβn) (mβn) β := Matrix.fromBlocks 0 C 0 0 | |
| omit [DecidableEq m] [DecidableEq n] in | |
| lemma hsSq_squareState (C : Matrix m n β) : hsSq (squareState C) = hsSq C := by | |
| simp only [squareState, hsSq_blocks, hsSq_zero, zero_add, add_zero] | |
| omit [Fintype m] [Fintype n] [DecidableEq m] [DecidableEq n] in | |
| lemma squareState_sub (C D : Matrix m n β) : squareState (C-D) = squareState C-squareState D := by | |
| simp only [squareState, fromBlocks_sub, sub_self] | |
| variable {A : Type u_A} {B : Type u_B} [Fintype A] [Fintype B] | |
| def POVM.sum (P : POVM m A) (Q : POVM n A) : POVM (mβn) A where | |
| effect a := Matrix.fromBlocks (P.effect a) 0 0 (Q.effect a) | |
| pos a := posSemidef_fromBlocks_diag (P.pos a) (Q.pos a) | |
| total := by | |
| have he : (β a, Matrix.fromBlocks (P.effect a) (0 : Matrix m n β) 0 (Q.effect a)) = | |
| Matrix.fromBlocks (β a, P.effect a) 0 0 (β a, Q.effect a) := by | |
| ext i j | |
| cases i <;> cases j <;> simp [Matrix.sum_apply] | |
| rw [he, P.total, Q.total, Matrix.fromBlocks_one] | |
| omit [DecidableEq m] [DecidableEq n] in | |
| lemma prob_squareState (C : Matrix m n β) (Aβ : Matrix m m β) (Aβ : Matrix n n β) | |
| (Bβ : Matrix m m β) (Bβ : Matrix n n β) : | |
| prob (squareState C) (Matrix.fromBlocks Aβ 0 0 Aβ) (Matrix.fromBlocks Bβ 0 0 Bβ) = | |
| prob C Aβ Bβ := by | |
| simp only [prob, eval_eq_trace, squareState, Matrix.fromBlocks_conjTranspose, | |
| Matrix.fromBlocks_transpose, Matrix.conjTranspose_zero, Matrix.transpose_zero, | |
| Matrix.fromBlocks_multiply, Matrix.mul_zero, Matrix.zero_mul, add_zero, zero_add] | |
| simp only [Matrix.trace, Matrix.diag, Fintype.sum_sum_type, Matrix.fromBlocks_applyββ, | |
| Matrix.fromBlocks_applyββ, Matrix.zero_apply, Finset.sum_const_zero, zero_add] | |
| lemma payoff_squareState (C : Matrix m n β) (P : POVM m A) (Q : POVM n B) | |
| (aβ : A) (bβ : B) (V : A β B β Bool) : | |
| payoff (squareState C) (P.sum (POVM.default aβ)) ((POVM.default bβ).sum Q) V = payoff C P Q V := by | |
| simp only [payoff, POVM.sum, prob_squareState] | |
| end ThresholdParallelRepetition.QuantumSampling | |
| end | |
| noncomputable section | |
| open scoped BigOperators MatrixOrder ComplexOrder | |
| open Matrix | |
| namespace ThresholdParallelRepetition.QuantumSampling | |
| open FiniteProbability Law | |
| section Stack | |
| variable {m : Type u_m} {n : Type u_n} {R : Type u_R} [Fintype m] [Fintype n] [Fintype R] [DecidableEq R] | |
| def weightedBlock (w : R β β) (C : R β Matrix m n β) : Matrix (mΓR) (nΓR) β := | |
| Matrix.blockDiagonal (fun r => Real.sqrt (w r) β’ C r) | |
| lemma hsSq_weightedBlock (w : R β β) (hw : β r, 0 β€ w r) (C : R β Matrix m n β) : | |
| hsSq (weightedBlock w C) = β r, w r*hsSq (C r) := by | |
| simp only [weightedBlock, hsSq_blockDiagonal, hsSq_smul, Real.sq_sqrt (hw _)] | |
| omit [Fintype m] [Fintype n] [Fintype R] in | |
| lemma weightedBlock_sub (w : R β β) (C D : R β Matrix m n β) : | |
| weightedBlock w (fun r => C r-D r) = weightedBlock w C-weightedBlock w D := by | |
| simp only [weightedBlock, smul_sub] | |
| exact Matrix.blockDiagonal_sub _ _ | |
| lemma hsSq_weightedBlock_sub (w : R β β) (hw : β r, 0 β€ w r) (C D : R β Matrix m n β) : | |
| hsSq (weightedBlock w C-weightedBlock w D) = β r, w r*hsSq (C r-D r) := by | |
| rw [β weightedBlock_sub, hsSq_weightedBlock w hw] | |
| variable {A : Type u_A} {B : Type u_B} [Fintype A] [Fintype B] [DecidableEq m] [DecidableEq n] | |
| lemma payoff_weightedBlock (w : R β β) (hw : β r, 0 β€ w r) (C : R β Matrix m n β) | |
| (P : R β POVM m A) (Q : R β POVM n B) (V : A β B β Bool) : | |
| payoff (weightedBlock w C) (POVM.blocks P) (POVM.blocks Q) V = | |
| β r, w r*payoff (C r) (P r) (Q r) V := by | |
| simp only [weightedBlock, payoff_blockDiagonal, payoff_smul, Real.sq_sqrt (hw _)] | |
| end Stack | |
| lemma correlated_sampling_value_rect {m n : Type} [Fintype m] [DecidableEq m] [Nonempty m] | |
| [Fintype n] [DecidableEq n] [Nonempty n] | |
| {x y a b : β} (G : Game x y a b) | |
| (M : Fin (x+1) β Matrix m n β) (N : Fin (y+1) β Matrix m n β) | |
| (hM : β x, hsSq (M x) = 1) (hN : β y, hsSq (N y) = 1) | |
| (P : Fin (x+1) β POVM m (Fin (a+1))) (Q : Fin (y+1) β POVM n (Fin (b+1))) | |
| {Ξ΅ : β} (hΞ΅ : 0 < Ξ΅) (hΞ΅1 : Ξ΅ β€ 1) : | |
| (β z : Fin (x+1) Γ Fin (y+1), G.questionProb z * | |
| payoff (M z.1) (P z.1) (Q z.2) (G.accepts z.1 z.2)) β€ entangledValue G + | |
| 4*Real.sqrt (2*Ξ΅^2+(12/Ξ΅)*Real.sqrt (2*β z : Fin (x+1) Γ Fin (y+1), | |
| G.questionProb z * hsSq (M z.1-N z.2))) := by | |
| have hh := correlated_sampling_value G (fun x => squareState (M x)) (fun y => squareState (N y)) | |
| (fun x => (hsSq_squareState _).trans (hM x)) (fun y => (hsSq_squareState _).trans (hN y)) | |
| (fun x => (P x).sum (POVM.default 0)) (fun y => (POVM.default 0).sum (Q y)) hΞ΅ hΞ΅1 | |
| simpa only [payoff_squareState, β squareState_sub, hsSq_squareState] using hh | |
| lemma avg_payoff_difference_unbounded {Z : Type u_Z} {m : Type u_m} {n : Type u_n} {A : Type u_A} {B : Type u_B} [Fintype Z] [Fintype m] [Fintype n] | |
| [Fintype A] [Fintype B] [DecidableEq m] [DecidableEq n] | |
| (ΞΌ : Law Z) (C D : Z β Matrix m n β) (hD : β z, hsSq (D z) β€ 1) | |
| (P : Z β POVM m A) (Q : Z β POVM n B) (V : Z β A β B β Bool) : | |
| ΞΌ.avg (fun z => payoff (C z) (P z) (Q z) (V z)) - | |
| ΞΌ.avg (fun z => payoff (D z) (P z) (Q z) (V z)) β€ | |
| 2*Real.sqrt (ΞΌ.avg (fun z => hsSq (C z-D z))) + ΞΌ.avg (fun z => hsSq (C z-D z)) := by | |
| rw [β avg_sub] | |
| have he := ΞΌ.avg_mono (fun z => payoff_difference_unbounded (C z) (D z) (P z) (Q z) (V z) (hD z)) | |
| apply he.trans | |
| rw [avg_add] | |
| apply add_le_add _ (le_refl _) | |
| rw [show (fun z => 2*Real.sqrt (hsSq (C z-D z))) = (fun z => (2:β) β’ Real.sqrt (hsSq (C z-D z))) from rfl, | |
| avg_smul] | |
| exact mul_le_mul_of_nonneg_left (weighted_sqrt_le _ _ ΞΌ.nonneg (fun z => hsSq_nonneg _) ΞΌ.total) (by norm_num) | |
| end ThresholdParallelRepetition.QuantumSampling | |
| end | |
| end OAI | |