| import Mathlib |
| import OAI.Computability.MinUncut.Estimates.Density |
| import OAI.Computability.MinUncut.Estimates.Convolution |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped Topology NNReal |
| open scoped BigOperators |
| open MeasureTheory ProbabilityTheory Polynomial Filter |
| open scoped BigOperators Topology |
| open MeasureTheory ProbabilityTheory WithLp |
| open scoped BigOperators RealInnerProductSpace |
| namespace MinUncut.RowNoise |
| open BinaryFourier |
| open scoped BigOperators |
| local instance maskRowKernelDualFintype {U : Type*} [AddCommGroup U] [Module F₂ U] [Fintype U] : |
| Fintype (Module.Dual F₂ U) := BinaryFourier.dualFintype |
| variable {R W : Type*} [Fintype R] [DecidableEq R] [Fintype W] [DecidableEq W] |
| [AddCommGroup W] [Module F₂ W] |
|
|
| def maskRowKernel (active : Bool) (b c : W) : ℝ := |
| if active then rowDensity 0 b c-1 else 1 |
|
|
| omit [AddCommGroup W] [Module F₂ W] in |
| lemma maskRowKernel_symmetric (active : Bool) (b c : W) : |
| maskRowKernel active b c = maskRowKernel active c b := by |
| simp only [maskRowKernel, rowDensity_symmetric] |
|
|
| omit [Module F₂ W] in |
| lemma maskRowKernel_abs_mean (active : Bool) (b : W) : |
| (𝔼 c, |maskRowKernel active b c|) ≤ if active then 2 else 1 := by |
| cases active |
| · simp [maskRowKernel] |
| · dsimp only [maskRowKernel] |
| calc |
| _ ≤ 𝔼 c, (rowDensity 0 b c+1) := by |
| apply Finset.expect_le_expect |
| intro c _ |
| exact (abs_sub _ _).trans (by rw [abs_of_nonneg (rowDensity_nonneg (by norm_num) (by norm_num) _ _), abs_one]) |
| _ = 2 := by rw [Finset.expect_add_distrib, rowDensity_mean] |
|
|
| lemma maskRowKernel_character (active : Bool) (b : W) (α : Module.Dual F₂ W) : |
| (𝔼 c, maskRowKernel active b c * character α c) = |
| if active = decide (α ≠ 0) then character α b else 0 := by |
| cases active |
| · simp [maskRowKernel, character_mean] |
| split_ifs with h |
| · simp [h] |
| · rfl |
| · simp only [maskRowKernel, ↓reduceIte, sub_mul, one_mul, |
| Finset.expect_sub_distrib, row_character_eigen, character_mean] |
| by_cases h : α=0 < |
|
|
| def maskKernel (S : Finset R) (B C : R → W) : ℝ := |
| ∏ r, maskRowKernel (decide (r ∈ S)) (B r) (C r) |
|
|
| omit [AddCommGroup W] [Module F₂ W] in |
| lemma maskKernel_symmetric (S : Finset R) (B C : R → W) : |
| maskKernel S B C = maskKernel S C B := by simp only [maskKernel, maskRowKernel_symmetric] |
|
|
| omit [Module F₂ W] in |
| lemma maskKernel_abs_mean (S : Finset R) (B : R → W) : |
| (𝔼 C, |maskKernel S B C|) ≤ (2 : ℝ)^Fintype.card R := by |
| simp only [maskKernel, Finset.abs_prod] |
| rw [expect_prod (f := fun r (c : W) => |maskRowKernel (decide (r ∈ S)) (B r) c|)] |
| calc |
| _ ≤ ∏ r : R, (2:ℝ) := by |
| apply Finset.prod_le_prod₀ |
| · intro r _ |
| · intro r _ |
| exact (maskRowKernel_abs_mean _ _).trans (by split_ifs < |
| _ = _ := by simp |
|
|
| lemma maskKernel_character (S : Finset R) (B : R → W) (α : Module.Dual F₂ (R → W)) : |
| (𝔼 C, maskKernel S B C * character α C) = if mask α=S then character α B else 0 := by |
| simp only [maskKernel, character_product, ← Finset.prod_mul_distrib] |
| rw [expect_prod (f := fun r (c : W) => maskRowKernel (decide (r ∈ S)) (B r) c * character (frequency α r) c)] |
| simp only [maskRowKernel_character] |
| have he (r : R) : (decide (r ∈ S) = decide (frequency α r ≠ 0)) ↔ |
| (r ∈ S ↔ r ∈ mask α) := by |
| by_cases h₁ : r ∈ S < |
| by_cases hs : mask α=S |
| · rw [ite_eq_left hs] |
| apply Finset.prod_congr rfl |
| intro r _ |
| rw [ite_eq_left ((he r).mpr (by rw [hs]))] |
| · rw [ite_eq_right hs] |
| have hh : ∃ r, ¬(r ∈ S ↔ r ∈ mask α) := by |
| by_contra hn |
| push Not at hn |
| exact hs (Finset.ext (fun r => (hn r).symm)) |
| obtain ⟨r,hr⟩ := hh |
| exact Finset.prod_eq_zero (Finset.mem_univ r) (ite_eq_right (fun h => hr ((he r).mp h))) |
|
|
| def maskProject (S : Finset R) (f : (R → W) → ℝ) (B : R → W) : ℝ := |
| 𝔼 C, maskKernel S B C * f C |
|
|
| lemma maskProject_expansion (S : Finset R) (f : (R → W) → ℝ) (B : R → W) : |
| maskProject S f B = ∑ α : Module.Dual F₂ (R → W), |
| if mask α=S then coefficient f α * character α B else 0 := by |
| unfold maskProject |
| conv_lhs => arg 2 |
| simp only [Finset.mul_sum] |
| rw [Finset.expect_sum_comm] |
| apply Finset.sum_congr rfl |
| intro α _ |
| simp_rw [mul_left_comm _ (coefficient f α), ← Finset.mul_expect, maskKernel_character] |
| split_ifs < |
|
|
| lemma coefficient_maskProject (S : Finset R) (f : (R → W) → ℝ) (α : Module.Dual F₂ (R → W)) : |
| coefficient (maskProject S f) α = if mask α=S then coefficient f α else 0 := by |
| have he (B : R → W) : maskProject S f B = |
| ∑ β ∈ Finset.univ.filter (fun β : Module.Dual F₂ (R → W) => mask β=S), coefficient f β*character β B := by |
| rw [maskProject_expansion, Finset.sum_filter] |
| unfold coefficient |
| simp_rw [he, Finset.sum_mul, Finset.expect_sum_comm, mul_assoc, ← Finset.mul_expect, |
| character_orthogonality] |
| simp [Finset.mem_filter, coefficient] |
|
|
| omit [Module F₂ W] in |
| lemma maskProject_l1 (S : Finset R) (f : (R → W) → ℝ) : |
| (𝔼 B, |maskProject S f B|) ≤ (2:ℝ)^Fintype.card R * (𝔼 B, |f B|) := by |
| calc |
| _ ≤ 𝔼 B, 𝔼 C, |maskKernel S B C| * |f C| := by |
| apply Finset.expect_le_expect |
| intro B _ |
| simpa only [maskProject, abs_mul] using Finset.abs_expect_le Finset.univ (fun C => maskKernel S B C*f C) |
| _ = 𝔼 C, (𝔼 B, |maskKernel S C B|)*|f C| := by |
| rw [Finset.expect_comm] |
| simp only [maskKernel_symmetric, Finset.expect_mul] |
| _ ≤ 𝔼 C, (2:ℝ)^Fintype.card R * |f C| := by |
| apply Finset.expect_le_expect |
| intro C _ |
| exact mul_le_mul_of_nonneg_right (maskKernel_abs_mean S C) (abs_nonneg _) |
| _ = _ := (Finset.mul_expect _ _ _).symm |
| end MinUncut.RowNoise |
|
|
| end |
|
|
| end OAI |
|
|
