math / data /lean /OAI /Probability /EntangledGames /BlockStates.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
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