| import Mathlib |
| import OAI.Probability.BinarySweep.TensorBounds.TensorPhases |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| section |
|
|
| open scoped BigOperators Classical ComplexOrder |
| open Matrix |
|
|
| namespace BinaryCoordinateSweeps.Density |
| variable {A : Type*} [Fintype A] [DecidableEq A] |
|
|
| def tensorAmplitude (n : ℕ) (r : A → ℝ) (w : Fin n → A) : ℝ := ∏ i, Real.sqrt (r (w i)) |
|
|
| def tensorProductVector (n : ℕ) (v : A → ℂ) : (Fin n → A) → ℂ := fun w => ∏ i, v (w i) |
|
|
| def phasedVector (n : ℕ) (r : A → ℝ) (θ : A → ZMod (n+1)) : A → ℂ := |
| fun a => (Real.sqrt (r a) : ℂ) * ZMod.stdAddChar (θ a) |
|
|
| omit [Fintype A] [DecidableEq A] in |
| lemma tensorProductVector_phased (n : ℕ) (r : A → ℝ) (θ : A → ZMod (n+1)) (w : Fin n → A) : |
| tensorProductVector n (phasedVector n r θ) w = |
| (tensorAmplitude n r w : ℂ) * tensorPhase n θ w := by |
| simp only [tensorProductVector, phasedVector, tensorAmplitude, tensorPhase, |
| Finset.prod_mul_distrib, Complex.ofReal_prod] |
|
|
| lemma tensorAmplitude_counts (n : ℕ) (r : A → ℝ) (w : Fin n → A) : |
| tensorAmplitude n r w = ∏ a, Real.sqrt (r a)^wordCounts w a := |
| prod_wordCounts (fun a => Real.sqrt (r a)) w |
|
|
| lemma tensorAmplitude_sq (n : ℕ) (r : A → ℝ) (hr : ∀ a, 0 ≤ r a) (w : Fin n → A) : |
| tensorAmplitude n r w * tensorAmplitude n r w = ∏ a, (r a)^wordCounts w a := by |
| rw [tensorAmplitude_counts, ← Finset.prod_mul_distrib] |
| apply Finset.prod_congr rfl |
| intro a ha |
| rw [← mul_pow, Real.mul_self_sqrt (hr a)] |
|
|
| def phaseAverage (n : ℕ) (r : A → ℝ) : Matrix (Fin n → A) (Fin n → A) ℂ := |
| (((n+1 : ℕ) : ℂ)^Fintype.card A)⁻¹ • |
| ∑ θ : A → ZMod (n+1), rankOne (tensorProductVector n (phasedVector n r θ)) |
|
|
| lemma phaseAverage_psd (n : ℕ) (r : A → ℝ) : (phaseAverage n r).PosSemidef := by |
| apply Matrix.PosSemidef.smul (Matrix.posSemidef_sum _ (fun θ _ => rankOne_psd _)) |
| exact inv_nonneg.mpr (pow_nonneg (by exact_mod_cast Nat.zero_le (n+1)) _) |
|
|
| lemma phaseAverage_apply (n : ℕ) (r : A → ℝ) (hr : ∀ a, 0 ≤ r a) |
| (w v : Fin n → A) : |
| phaseAverage n r w v = if wordCounts w = wordCounts v then |
| ((∏ a, r a^wordCounts w a : ℝ) : ℂ) else 0 := by |
| simp only [phaseAverage, Matrix.smul_apply, Matrix.sum_apply, rankOne, vecMulVec, |
| Matrix.of_apply, Pi.star_apply, tensorProductVector_phased, star_mul, Complex.star_def, |
| Complex.conj_ofReal] |
| have hfactor : (∑ θ : A → ZMod (n+1), |
| ((tensorAmplitude n r w : ℂ) * tensorPhase n θ w) * |
| (star (tensorPhase n θ v) * (tensorAmplitude n r v : ℂ))) = |
| ((tensorAmplitude n r w : ℂ) * (tensorAmplitude n r v : ℂ)) * |
| ∑ θ : A → ZMod (n+1), tensorPhase n θ w * star (tensorPhase n θ v) := by |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro θ hθ |
| ring |
| change (((n+1 : ℕ) : ℂ)^Fintype.card A)⁻¹ * _ = _ |
| simp only [Complex.star_def] at hfactor |
| rw [hfactor] |
| change _ * (_ * ∑ θ : A → ZMod (n+1), tensorPhase n θ w * star (tensorPhase n θ v)) = _ |
| rw [phase_pair_sum] |
| by_cases h : wordCounts w = wordCounts v |
| · rw [ite_eq_left h, ite_eq_left h] |
| have ha : tensorAmplitude n r w = tensorAmplitude n r v := by |
| simp only [tensorAmplitude_counts, h] |
| rw [← ha, ← Complex.ofReal_mul, tensorAmplitude_sq n r hr w] |
| have hp : (((n+1 : ℕ) : ℂ)^Fintype.card A) ≠ 0 := pow_ne_zero _ (by exact_mod_cast Nat.succ_ne_zero n) |
| field_simp |
| · simp [h] |
|
|
| lemma phaseAverage_kernel (n : ℕ) (r : A → ℝ) (hr : ∀ a, 0 ≤ r a) : |
| phaseAverage n r = ∑ c : WordType A n, |
| ((∏ a, r a ^ c.val a : ℝ) : ℂ) • typeOnes (wordType n) c := by |
| ext w v |
| rw [phaseAverage_apply n r hr, sum_typeOnes] |
| simp only [wordType_eq_iff] |
| rfl |
|
|
| omit [Fintype A] [DecidableEq A] in |
| lemma phasedVector_norm (n : ℕ) (r : A → ℝ) (hr : ∀ a, 0 ≤ r a) |
| (θ : A → ZMod (n+1)) (a : A) : |
| phasedVector n r θ a * star (phasedVector n r θ a) = (r a : ℂ) := by |
| have he : ZMod.stdAddChar (θ a) * star (ZMod.stdAddChar (θ a)) = 1 := by |
| rw [phase_star, ← AddChar.map_add_eq_mul, add_neg_cancel, AddChar.map_zero_eq_one] |
| simp only [phasedVector, star_mul, Complex.star_def, Complex.conj_ofReal] |
| calc |
| _ = ((Real.sqrt (r a) : ℂ) * Real.sqrt (r a)) * |
| (ZMod.stdAddChar (θ a) * star (ZMod.stdAddChar (θ a))) := by simp only [Complex.star_def]; ring |
| _ = _ := by rw [he, mul_one, ← Complex.ofReal_mul, Real.mul_self_sqrt (hr a)] |
|
|
| omit [DecidableEq A] in |
| lemma phasedVector_trace (n : ℕ) (r : A → ℝ) (hr : ∀ a, 0 ≤ r a) |
| (hs : ∑ a, r a = 1) (θ : A → ZMod (n+1)) : |
| Matrix.trace (rankOne (phasedVector n r θ)) = 1 := by |
| simp only [Matrix.trace, Matrix.diag, rankOne, vecMulVec, Matrix.of_apply, Pi.star_apply, |
| phasedVector_norm n r hr, ← Complex.ofReal_sum, hs, Complex.ofReal_one] |
|
|
| end BinaryCoordinateSweeps.Density |
|
|
| end |
|
|
| open scoped BigOperators Classical ComplexOrder |
| open Matrix |
|
|
| namespace BinaryCoordinateSweeps.Density |
| variable {A : Type*} [Fintype A] [DecidableEq A] |
|
|
| def empirical (n : ℕ) (c : WordType A n) : A → ℝ := fun a => c.val a / (n : ℝ) |
|
|
| lemma empirical_nonneg (n : ℕ) (c : WordType A n) (a : A) : 0 ≤ empirical n c a := |
| div_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _) |
|
|
| lemma empirical_sum (n : ℕ) (hn : 0 < n) (c : WordType A n) : ∑ a, empirical n c a = 1 := by |
| simp only [empirical, ← Finset.sum_div, ← Nat.cast_sum, wordType_total, |
| div_self (by exact_mod_cast Nat.ne_of_gt hn : (n : ℝ) ≠ 0)] |
|
|
| lemma type_mass_inv (n : ℕ) (hn : 0 < n) (c : WordType A n) : |
| (Nat.multinomial Finset.univ c.val : ℝ)⁻¹ ≤ |
| ((n+1 : ℕ) : ℝ)^Fintype.card A * ∏ a, empirical n c a ^ c.val a := by |
| have hm : 0 < (Nat.multinomial Finset.univ c.val : ℝ) := by exact_mod_cast Nat.multinomial_pos _ _ |
| rw [inv_eq_one_div] |
| apply (div_le_iff₀ hm).mpr |
| have hh := type_mass_lower n hn c.val (wordType_total n c) |
| simpa only [empirical, mul_assoc, mul_left_comm, mul_comm] using hh |
|
|
| theorem finite_postselection (n : ℕ) (hn : 0 < n) : |
| ((((n+1 : ℕ) : ℂ)^Fintype.card A) • |
| (∑ c : WordType A n, phaseAverage n (empirical n c)) - symmetricProjector n).PosSemidef := by |
| let d : WordType A n → ℝ := fun t => ((n+1 : ℕ) : ℝ)^Fintype.card A * |
| ∑ c : WordType A n, ∏ a, empirical n c a ^ t.val a |
| have hd (t : WordType A n) : (Nat.multinomial Finset.univ t.val : ℝ)⁻¹ ≤ d t := by |
| refine (type_mass_inv n hn t).trans ?_ |
| apply mul_le_mul_of_nonneg_left _ (pow_nonneg (Nat.cast_nonneg _) _) |
| exact Finset.single_le_sum (f := fun c : WordType A n => ∏ a, empirical n c a ^ t.val a) |
| (fun c _ => Finset.prod_nonneg |
| (fun a _ => pow_nonneg (empirical_nonneg n c a) _)) (Finset.mem_univ t) |
| convert typeKernel_mono (wordType (A := A) n) |
| (fun t => (Nat.multinomial Finset.univ t.val : ℝ)⁻¹) d hd using 1 |
| apply Iff.of_eq |
| congr 1 |
| ext w v |
| simp only [Matrix.sub_apply, Matrix.smul_apply, Matrix.sum_apply, |
| phaseAverage_apply n _ (empirical_nonneg n _), symmetricProjector, smul_eq_mul, |
| wordType_eq_iff, Pi.sub_apply] |
| split_ifs with h |
| · simp only [d, Complex.ofReal_mul, Complex.ofReal_pow, Complex.ofReal_natCast, |
| Complex.ofReal_sum, Complex.ofReal_inv] |
| rfl |
| · simp |
|
|
| end BinaryCoordinateSweeps.Density |
|
|
| end |
|
|
| end OAI |
|
|
