| import Mathlib |
| import OAI.Computability.MinUncut.Search.Parameters |
| import OAI.Computability.MinUncut.Estimates.AnalyticOuter |
| import OAI.Computability.MinUncut.Analysis.GaussianAssembly |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators |
| namespace MinUncut.Inner |
| open MeasureTheory ProbabilityTheory BinaryFourier RowNoise GaussianHermite Subbox BoxGaussian |
| attribute [local instance] Classical.propDecidable |
| attribute [local irreducible] gradient selectedProject retainedClass Slice.centeredClip |
| variable {V A : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A] |
| variable {m n : ℕ} |
|
|
| def zeroProcessed (f : FoldedProof A) (σ η : ℝ) (x : Point m n) |
| {k : ℕ} (Y : PointedBox x k) (J : Finset (Finset (Row m n) × (Point m n → ℕ))) (A₀ : ℝ) |
| (B : FaceArray A m n) (c : Point m n → ℝ) : ℝ := |
| Slice.centeredClip γ A₀ (gaussianSlice f σ η x Y J B c) (c x) |
|
|
| lemma zeroProcessed_measurable (f : FoldedProof A) (σ η : ℝ) (x : Point m n) |
| {k : ℕ} (Y : PointedBox x k) (J : Finset (Finset (Row m n) × (Point m n → ℕ))) (A₀ : ℝ) |
| (B : FaceArray A m n) : Measurable (zeroProcessed f σ η x Y J A₀ B) := |
| centered_gaussianSlice_diagonal_measurable f σ η x Y J B A₀ |
|
|
| lemma zeroProcessed_memLp (f : FoldedProof A) (σ η : ℝ) (x : Point m n) |
| {k : ℕ} (Y : PointedBox x k) (J : Finset (Finset (Row m n) × (Point m n → ℕ))) |
| {A₀ : ℝ} (hA : 0≤A₀) (B : FaceArray A m n) : |
| MemLp (zeroProcessed f σ η x Y J A₀ B) 2 (γpi (Point m n)) := by |
| unfold zeroProcessed gaussianSlice |
| exact centered_resample_memLp x _ (selectedProject_continuous _ _ _).measurable hA |
|
|
| lemma zero_processing_loss_integral (f : FoldedProof A) (σ η : ℝ) (x : Point m n) |
| {k : ℕ} (Y : PointedBox x k) (J : Finset (Finset (Row m n) × (Point m n → ℕ))) |
| (hJ : ∀ j ∈ J, j.1.card < (m-(∑ u, j.2 u)).choose 2) |
| {A₀ : ℝ} (hA : 0<A₀) : |
| jointL1 (fun B c => selectedProject (retainedClass x Y none J) (fun B c => gradient f B σ η c x) B c - |
| zeroProcessed f σ η x Y J A₀ B c) ≤ |
| 2*jointEnergy (selectedProject (retainedClass x Y none J) (fun B c => gradient f B σ η c x))/A₀ := by |
| have hB (B : FaceArray A m n) := centered_resample_loss x |
| (selectedProject (retainedClass x Y none J) (fun B c => gradient f B σ η c x) B) |
| (selectedProject_continuous _ _ _).measurable (memLp_selectedProject _ _ _) |
| (fun C => gaussianSlice_memLp f σ η x Y J B C) |
| (fun C => gaussianSlice_mean f σ η x Y J hJ B C) hA |
| unfold jointL1 jointEnergy |
| simp only [Finset.mul_expect, Finset.expect_div] |
| apply Finset.expect_le_expect |
| intro B _ |
| unfold zeroProcessed |
| exact hB B |
|
|
| lemma zero_processing_loss_average (f : FoldedProof A) {σ : ℝ} (hσ : σ≠0) (η : ℝ) |
| (hn : 0<n) {k : ℕ} (hk : k≤n-1) |
| (J : Finset (Finset (Row m n) × (Point m n → ℕ))) |
| (hJ : ∀ j ∈ J, j.1.card < (m-(∑ u, j.2 u)).choose 2) |
| {A₀ : ℝ} (hA : 0<A₀) : |
| (𝔼 x : Point m n, 𝔼 Y : PointedBox x k, jointL1 (fun B c => |
| selectedProject (retainedClass x Y none J) (fun B c => gradient f B σ η c x) B c - |
| zeroProcessed f σ η x Y J A₀ B c)) ≤ 2*(σ⁻¹^2)/A₀ := by |
| have : NeZero n := ⟨by omega⟩ |
| have (x : Point m n) (i : Fin m) : Nonempty (OuterSmoothness.FixedSets (Away (x i)) k) := |
| OuterSmoothness.fixedSets_nonempty (by simpa [card_away] using hk) |
| calc |
| _ ≤ 𝔼 x : Point m n, 𝔼 Y : PointedBox x k, |
| 2*jointEnergy (selectedProject (retainedClass x Y none J) (fun B c => gradient f B σ η c x))/A₀ := |
| Finset.expect_le_expect (fun x _ => Finset.expect_le_expect (fun Y _ => zero_processing_loss_integral f σ η x Y J hJ hA)) |
| _ ≤ 𝔼 x : Point m n, 𝔼 _Y : PointedBox x k, |
| 2*jointEnergy (fun B c => gradient f B σ η c x)/A₀ := by |
| apply Finset.expect_le_expect |
| intro x _ |
| apply Finset.expect_le_expect |
| intro Y _ |
| exact div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_left (retained_energy_le f hσ η x Y none J) (by norm_num)) hA.le |
| _ = 2*averagedEnergy (fun B c => gradient (m := m) (n := n) f B σ η c)/A₀ := by |
| simp only [Fintype.expect_const, ← Finset.expect_div, ← Finset.mul_expect] |
| rw [averagedEnergy_eq_expect_joint _ (fun B x => gradient_memLp f B hσ η x)] |
| _ ≤ _ := div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_left (averagedEnergy_gradient_le f hn hσ η) (by norm_num)) hA.le |
|
|
| open MeasureTheory ProbabilityTheory BinaryFourier RowNoise GaussianHermite Subbox |
| attribute [local instance] Classical.propDecidable |
| attribute [local irreducible] classField pairSlice Slice.processed gaussianSlice |
| variable {V A : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A] |
| variable {m n : ℕ} |
|
|
| lemma class_correlation_processing (f : FoldedProof A) {σ : ℝ} (hσ : 0 < σ) (η : ℝ) |
| (hn : 2 ≤ n) {k s D : ℕ} (hk : k ≤ n-1) (a : Option (PairClass m)) |
| (J : Finset (Finset (Row m n) × (Point m n → ℕ))) |
| (hJ : ∀ j∈ J, (∑ u, j.2 u) ≤ s ∧ j.1.card ≤ D) |
| (v : (x : Point m n) → PointedBox x k → FaceArray A m n → (Point m n → ℝ) → ℝ) |
| (hvm : ∀ x Y B, Measurable (v x Y B)) |
| (hv : ∀ x Y B, MemLp (v x Y B) 2 (γpi (Point m n))) : |
| averagedCorrelation (classField f σ η J a) ≤ |
| σ⁻¹*Real.sqrt (((s+D:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1))) + |
| (𝔼 x : Point m n, 𝔼 Y : PointedBox x k, jointL1 (fun B c => |
| selectedProject (retainedClass x Y a J) (fun B c => gradient f B σ η c x) B c-v x Y B c)) + |
| (𝔼 Y : UnpointedBox (Fin m) (Fin n) k, 𝔼 B : FaceArray A m n, |
| ∫ c, faceCorrelation (fun t : Point m (k+1) => v (pointEmbed Y t) (pointBox Y t) B c) ∂γpi (Point m n)) := by |
| have hcmp := averagedCorrelation_pointed_compare hk (classField f σ η J a) v |
| (classField_measurable f σ η J a) (fun B x => (classField_memLp f σ η J a B x).integrable (by norm_num)) |
| hvm (fun x Y B => (hv x Y B).integrable (by norm_num)) |
| have ht (x : Point m n) (Y : PointedBox x k) := jointL1_sub_triangle |
| (fun B c => classField f σ η J a B c x) |
| (selectedProject (retainedClass x Y a J) (fun B c => gradient f B σ η c x)) (v x Y) |
| (fun B => classField_memLp f σ η J a B x) (memLp_selectedProject _ _) (hv x Y) |
| have hta := Finset.expect_le_expect (fun x (_ : x∈(Finset.univ : Finset (Point m n))) => |
| Finset.expect_le_expect (fun Y (_ : Y∈(Finset.univ : Finset (PointedBox x k))) => ht x Y)) |
| simp only [Finset.expect_add_distrib] at hta |
| have hl := class_localization_l1 f hσ η hn hk J hJ a |
| linarith only [hcmp,hta,hl] |
|
|
| lemma pair_class_correlation (f : FoldedProof A) {σ : ℝ} (hσ : 0 < σ) (η : ℝ) |
| (hn : 2 ≤ n) {k s D : ℕ} (hk : k ≤ n-1) (p : PairClass m) |
| (J : Finset (Finset (Row m n) × (Point m n → ℕ))) |
| (hJ : ∀ j∈ J, (∑ u, j.2 u) ≤ s ∧ j.1.card ≤ D) |
| {H γ A₀ : ℝ} (hH : 0 < H) (hγ : 0 < γ) (hA : 0 < A₀) : |
| averagedCorrelation (classField f σ η J (some p)) ≤ |
| σ⁻¹*Real.sqrt (((s+D:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1))) + |
| Slice.lossBound H γ A₀ (σ⁻¹^2) (𝔼 x : Point m n, 𝔼 Y : PointedBox x k, pairAtomMean f σ η x Y p J) + |
| A₀*((m:ℝ)/(k+1))^(((2^m:ℕ):ℝ)⁻¹) + Real.sqrt (H*(γ+H^2/A₀)) := by |
| have : Nonempty (OuterSmoothness.FixedSets (Fin n) (k+1)) := |
| OuterSmoothness.fixedSets_nonempty (by simp only [Fintype.card_fin]; omega) |
| have hc := class_correlation_processing f hσ η hn hk (some p) J hJ |
| (fun x Y => pairProcessed f σ η x Y p J H γ A₀) |
| (fun x Y B => pairProcessed_measurable f σ η x Y p J H γ A₀ B) |
| (fun x Y B => pairProcessed_memLp f σ η x Y p J H γ hA.le B) |
| have hl := pair_processing_loss_average f hσ η (by omega : 0 < n) hk p J hH hγ hA |
| have hb (Y : UnpointedBox (Fin m) (Fin n) k) : |
| (𝔼 B : FaceArray A m n, ∫ c, faceCorrelation (pairProcessedOnBox f σ η Y p J H γ A₀ B c) ∂γpi (Point m n)) ≤ |
| A₀*((m:ℝ)/(k+1))^(((2^m:ℕ):ℝ)⁻¹) + Real.sqrt (H*(γ+H^2/A₀)) := by |
| have hi (B : FaceArray A m n) : Integrable (fun c => |
| faceCorrelation (pairProcessedOnBox f σ η Y p J H γ A₀ B c)) (γpi (Point m n)) := by |
| apply faceCorrelation_integrable _ (fun t => pairProcessedOnBox_c_measurable f σ η Y p J H γ A₀ B t) |
| intro t |
| exact |
| (pairProcessed_memLp f σ η (pointEmbed Y t) (pointBox Y t) p J H γ hA.le B).integrable (by norm_num : (1:ENNReal) ≤ 2) |
| rw [← integral_expect _ hi] |
| exact actual_pair_box_average f hσ.ne' η Y p J hH.le hA hγ.le |
| have hba := Finset.expect_le_expect (fun Y (_ : Y∈(Finset.univ : Finset (UnpointedBox (Fin m) (Fin n) k))) => hb Y) |
| rw [Fintype.expect_const] at hba |
| unfold pairProcessedOnBox at hba |
| dsimp only [pairProcessed] at hc hl |
| linarith only [hc,hl,hba] |
|
|
| lemma zero_class_correlation (f : FoldedProof A) {σ : ℝ} (hσ : 0 < σ) (η : ℝ) |
| (hm : 0 < m) (hn : 2 ≤ n) {k s D : ℕ} (hk : k ≤ n-1) |
| (J : Finset (Finset (Row m n) × (Point m n → ℕ))) |
| (hJ : ∀ j∈ J, (∑ u, j.2 u) ≤ s ∧ j.1.card ≤ D) |
| (hJ0 : ∀ j∈ J, j.1.card < (m-(∑ u, j.2 u)).choose 2) |
| {A₀ : ℝ} (hA : 0 < A₀) : |
| averagedCorrelation (classField f σ η J none) ≤ |
| σ⁻¹*Real.sqrt (((s+D:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1))) + 2*(σ⁻¹^2)/A₀ + |
| 2*A₀*((m:ℝ)/(k+1))^(((2^m:ℕ):ℝ)⁻¹) := by |
| have : Nonempty (OuterSmoothness.FixedSets (Fin n) (k+1)) := |
| OuterSmoothness.fixedSets_nonempty (by simp only [Fintype.card_fin]; omega) |
| have hc := class_correlation_processing f hσ η hn hk none J hJ |
| (fun x Y => zeroProcessed f σ η x Y J A₀) |
| (fun x Y B => zeroProcessed_measurable f σ η x Y J A₀ B) |
| (fun x Y B => zeroProcessed_memLp f σ η x Y J hA.le B) |
| have hl := zero_processing_loss_average f hσ.ne' η (by omega : 0 < n) hk J hJ0 hA |
| have hb (Y : UnpointedBox (Fin m) (Fin n) k) : |
| (𝔼 B : FaceArray A m n, ∫ c, faceCorrelation (zeroProcessedOnBox f σ η Y J A₀ B c) ∂γpi (Point m n)) ≤ |
| 2*A₀*((m:ℝ)/(k+1))^(((2^m:ℕ):ℝ)⁻¹) := by |
| have hi (B : FaceArray A m n) : Integrable (fun c => |
| faceCorrelation (zeroProcessedOnBox f σ η Y J A₀ B c)) (γpi (Point m n)) := by |
| apply faceCorrelation_integrable _ |
| · intro t |
| exact |
| zeroProcessed_measurable f σ η (pointEmbed Y t) (pointBox Y t) J A₀ B |
| · intro t |
| exact |
| (zeroProcessed_memLp f σ η (pointEmbed Y t) (pointBox Y t) J hA.le B).integrable (by norm_num : (1:ENNReal) ≤ 2) |
| rw [← integral_expect _ hi] |
| exact actual_zero_box_average f σ η hm Y J hA.le |
| have hba := Finset.expect_le_expect (fun Y (_ : Y∈(Finset.univ : Finset (UnpointedBox (Fin m) (Fin n) k))) => hb Y) |
| rw [Fintype.expect_const] at hba |
| unfold zeroProcessedOnBox at hba |
| dsimp only [zeroProcessed] at hc hl |
| linarith only [hc,hl,hba] |
|
|
| open MeasureTheory ProbabilityTheory BinaryFourier RowNoise GaussianHermite Subbox |
| attribute [local instance] Classical.propDecidable |
| attribute [local irreducible] oddAtom rowAtom pairAtomMean lowGradient |
| variable {Ξ : Type*} [Fintype Ξ] (V A : Ξ → Type*) |
| [∀ ξ, AddCommGroup (V ξ)] [∀ ξ, Module F₂ (V ξ)] [∀ ξ, AddTorsor (V ξ) (A ξ)] |
| [∀ ξ, Fintype (A ξ)] {m n : ℕ} |
|
|
| lemma weighted_pair_class_correlation (w : Ξ → ℝ) (hw : ∀ ξ, 0 ≤ w ξ) (hw1 : ∑ ξ, w ξ=1) |
| (f : ∀ ξ, FoldedProof (A ξ)) {σ θ p : ℝ} (hσ : 0 < σ) (hθ : 0 ≤ θ) (η : ℝ) |
| (hn : 2 ≤ n) {k s D : ℕ} (hk : k ≤ n-1) (r : PairClass m) |
| (J : Finset (Finset (Row m n) × (Point m n → ℕ))) |
| (hJ : ∀ j∈ J, (∑ u, j.2 u) ≤ s ∧ j.1.card ≤ D) |
| {H γ A₀ : ℝ} (hH : 0 < H) (hγ : 0 < γ) (hA : 0 < A₀) |
| (hp : (∑ ξ, w ξ*atomProbability (m := m) (n := n) (f ξ) σ η θ) ≤ p) : |
| (∑ ξ, w ξ*averagedCorrelation (classField (n := n) (f ξ) σ η J (some r))) ≤ |
| σ⁻¹*Real.sqrt (((s+D:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1))) + |
| Slice.lossBound H γ A₀ (σ⁻¹^2) |
| ((4:ℝ)^Fintype.card (Row m n)*((Fintype.card (Point m n)+s).choose s:ℝ)* |
| Real.sqrt (θ^2+(m:ℝ)*p*(n^m:ℕ)/σ^2)) + |
| A₀*((m:ℝ)/(k+1))^(((2^m:ℕ):ℝ)⁻¹) + Real.sqrt (H*(γ+H^2/A₀)) := by |
| let q (ξ : Ξ) := 𝔼 x : Point m n, 𝔼 Y : PointedBox x k, pairAtomMean (f ξ) σ η x Y r J |
| have hq ξ : 0 ≤ q ξ := Finset.expect_nonneg (fun x _ => |
| Finset.expect_nonneg (fun Y _ => pairAtomMean_nonneg _ _ _ _ _ _ _)) |
| have hcls := Finset.sum_le_sum (s := (Finset.univ : Finset Ξ)) (fun ξ _ => |
| mul_le_mul_of_nonneg_left (pair_class_correlation (f ξ) hσ η hn hk r J hJ hH hγ hA) (hw ξ)) |
| simp only [mul_add,Finset.sum_add_distrib,← Finset.sum_mul,hw1,one_mul] at hcls |
| rw [← mul_add] at hcls |
| have hloss := Slice.lossBound_weighted H γ A₀ w (fun _ : Ξ => σ⁻¹^2) q hw hγ.le |
| (fun _ => sq_nonneg _) hq |
| rw [← Finset.sum_mul,hw1,one_mul] at hloss |
| have hatom := weighted_pairAtomMean V A w hw hw1 f hσ hθ η (by omega) hk r J |
| (fun j hj => (hJ j hj).1) hp |
| have hloss' := Slice.lossBound_mono hH.le hγ.le hA.le (le_refl (σ⁻¹^2)) hatom |
| dsimp only [q] at hloss |
| linarith only [hcls, hloss, hloss'] |
|
|
| lemma weighted_zero_class_correlation (w : Ξ → ℝ) (hw : ∀ ξ, 0 ≤ w ξ) (hw1 : ∑ ξ, w ξ=1) |
| (f : ∀ ξ, FoldedProof (A ξ)) {σ : ℝ} (hσ : 0 < σ) (η : ℝ) |
| (hm : 0 < m) (hn : 2 ≤ n) {k s D : ℕ} (hk : k ≤ n-1) |
| (J : Finset (Finset (Row m n) × (Point m n → ℕ))) |
| (hJ : ∀ j∈ J, (∑ u, j.2 u) ≤ s ∧ j.1.card ≤ D) |
| (hJ0 : ∀ j∈ J, j.1.card < (m-(∑ u, j.2 u)).choose 2) |
| {A₀ : ℝ} (hA : 0 < A₀) : |
| (∑ ξ, w ξ*averagedCorrelation (classField (n := n) (f ξ) σ η J none)) ≤ |
| σ⁻¹*Real.sqrt (((s+D:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1))) + 2*(σ⁻¹^2)/A₀ + |
| 2*A₀*((m:ℝ)/(k+1))^(((2^m:ℕ):ℝ)⁻¹) := by |
| have hh := Finset.sum_le_sum (s := (Finset.univ : Finset Ξ)) (fun ξ _ => |
| mul_le_mul_of_nonneg_left (zero_class_correlation (f ξ) hσ η hm hn hk J hJ hJ0 hA) (hw ξ)) |
| rwa [← Finset.sum_mul,hw1,one_mul] at hh |
|
|
| lemma weighted_lowGradient_classes (w : Ξ → ℝ) (hw : ∀ ξ, 0 ≤ w ξ) |
| (D s : ℕ) (f : ∀ ξ, FoldedProof (A ξ)) (σ η : ℝ) : |
| (∑ ξ, w ξ*averagedCorrelation (lowGradient (m := m) (n := n) D s (f ξ) σ η)) ≤ |
| ∑ a : Option (PairClass m), ∑ ξ, w ξ*averagedCorrelation (classField (n := n) (f ξ) σ η (rectangle D s) a) := by |
| have hh := Finset.sum_le_sum (s := (Finset.univ : Finset Ξ)) (fun ξ _ => |
| mul_le_mul_of_nonneg_left (lowGradient_classes_correlation (m := m) (n := n) D s (f ξ) σ η) (hw ξ)) |
| simp only [Finset.mul_sum] at hh |
| rwa [Finset.sum_comm] at hh |
|
|
| open MeasureTheory ProbabilityTheory BinaryFourier RowNoise GaussianHermite Subbox |
| attribute [local instance] Classical.propDecidable |
| variable {m n : ℕ} |
|
|
| def classTarget (T : ℝ) (m : ℕ) : ℝ := 1/(4*T*(Fintype.card (Option (PairClass m)):ℝ)) |
|
|
| lemma classTarget_pos {T : ℝ} (hT : 0 < T) (m : ℕ) : 0 < classTarget T m := by |
| unfold classTarget |
| positivity |
|
|
| lemma classes_times_target {T : ℝ} (hT : 0 < T) (m : ℕ) : |
| (Fintype.card (Option (PairClass m)):ℝ)*classTarget T m = 1/(4*T) := by |
| have hc : (Fintype.card (Option (PairClass m)):ℝ) ≠ 0 := by positivity |
| unfold classTarget |
| field_simp |
|
|
| lemma rectangle_bounds (D s : ℕ) (j : Finset (Row m n) × (Point m n → ℕ)) |
| (hj : j ∈ rectangle D s) : (∑ u, j.2 u) ≤ s ∧ j.1.card ≤ D := by |
| obtain ⟨hS,hI⟩ := Finset.mem_product.mp hj |
| exact ⟨(mem_low _ _).mp hI,(Finset.mem_filter.mp hS).2⟩ |
|
|
| lemma rectangle_pair_room {D s : ℕ} (hroom : D < (m-s).choose 2) |
| (j : Finset (Row m n) × (Point m n → ℕ)) (hj : j ∈ rectangle D s) : |
| j.1.card < (m-(∑ u, j.2 u)).choose 2 := by |
| obtain ⟨hi,hS⟩ := rectangle_bounds D s j hj |
| exact lt_of_le_of_lt hS (lt_of_lt_of_le hroom (Nat.choose_le_choose 2 (by omega))) |
|
|
| theorem inner_atom_of_errors {Ξ : Type*} [Fintype Ξ] (V A : Ξ → Type*) |
| [∀ ξ, AddCommGroup (V ξ)] [∀ ξ, Module F₂ (V ξ)] [∀ ξ, AddTorsor (V ξ) (A ξ)] |
| [∀ ξ, Fintype (A ξ)] (w : Ξ → ℝ) (hw : ∀ ξ, 0 ≤ w ξ) (hw1 : ∑ ξ, w ξ=1) |
| (f : ∀ ξ, FoldedProof (A ξ)) {J : ℝ} (hJ : 1 ≤ J) {m n k s : ℕ} |
| (hm : 2 ≤ m) (hn : 2 ≤ n) (hk : k ≤ n-1) |
| (hs : ∀ t : ℕ, s+2 ≤ t → (t:ℝ)*(smoothingRho (sourceSigma J))^(2*t) ≤ 1/16) |
| (hroom : sourceR J*m < (m-s).choose 2) |
| {H γ A₀ θ p : ℝ} (hH : 0 < H) (hγ : 0 < γ) (hA : 0 < A₀) (hθ : 0 ≤ θ) |
| (hloc : (sourceSigma J)⁻¹*Real.sqrt (((s+sourceR J*m:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1))) < |
| classTarget (sourceT J) m/10) |
| (henergy : (sourceSigma J)⁻¹^2/H < classTarget (sourceT J) m/10) |
| (hclip : 2*((sourceSigma J)⁻¹^2)/A₀ < classTarget (sourceT J) m/10) |
| (hcollision : 2*A₀*((m:ℝ)/(k+1))^(((2^m:ℕ):ℝ)⁻¹) < classTarget (sourceT J) m/10) |
| (hfourth : Real.sqrt (H*(γ+H^2/A₀)) < classTarget (sourceT J) m/10) |
| (hatom : Real.sqrt ((sourceSigma J)⁻¹^2)*Real.sqrt |
| (((4:ℝ)^Fintype.card (Row m n)*((Fintype.card (Point m n)+s).choose s:ℝ)* |
| Real.sqrt (θ^2+(m:ℝ)*p*(n^m:ℕ)/(sourceSigma J)^2))/γ) < classTarget (sourceT J) m/10) |
| (h1 : (∑ ξ, w ξ*firstError (m := m) (n := n) (f ξ) (sourceSigma J) (sourceEta J)) ≤ |
| J*(10*sourceSigma J)) |
| (h2 : (∑ ξ, w ξ*secondError (m := m) (n := n) (f ξ) |
| ((sourceEta J)^2/(m:ℝ)) (sourceSigma J) (sourceEta J)) ≤ J*(10*(sourceEta J+sourceEta J))) |
| (h3 : (∑ ξ, w ξ*thirdError (m := m) (n := n) (f ξ) (sourceSigma J) (sourceEta J)) ≤ |
| J/(Fintype.card (Code m n):ℝ)) : |
| p ≤ ∑ ξ, w ξ*atomProbability (m := m) (n := n) (f ξ) (sourceSigma J) (sourceEta J) θ := by |
| by_contra hp |
| have hp' := le_of_lt (lt_of_not_ge hp) |
| have hσ := sourceSigma_pos hJ |
| have hT : (0:ℝ) < sourceT J := by exact_mod_cast sourceT_pos hJ |
| have hd := classTarget_pos hT m |
| have heA : 0 ≤ (sourceSigma J)⁻¹^2/A₀ := by positivity |
| have hcol0 : 0 ≤ A₀*((m:ℝ)/(k+1))^(((2^m:ℕ):ℝ)⁻¹) := by positivity |
| have hclip' : (sourceSigma J)⁻¹^2/A₀ < classTarget (sourceT J) m/10 := by |
| have hh : 2*((sourceSigma J)⁻¹^2/A₀) < classTarget (sourceT J) m/10 := by |
| simpa only [mul_div_assoc] using hclip |
| linarith only [hh,heA] |
| have hcollision' : A₀*((m:ℝ)/(k+1))^(((2^m:ℕ):ℝ)⁻¹) < classTarget (sourceT J) m/10 := by |
| have hh : 2*(A₀*((m:ℝ)/(k+1))^(((2^m:ℕ):ℝ)⁻¹)) < classTarget (sourceT J) m/10 := by |
| simpa only [mul_assoc] using hcollision |
| linarith only [hh,hcol0] |
| have hcls (a : Option (PairClass m)) : |
| (∑ ξ, w ξ*averagedCorrelation (classField (n := n) (f ξ) (sourceSigma J) (sourceEta J) |
| (rectangle (sourceR J*m) s) a)) < classTarget (sourceT J) m := by |
| cases a with |
| | none => |
| have hh := weighted_zero_class_correlation V A w hw hw1 f hσ (sourceEta J) (by omega : 0 < m) |
| hn hk _ (rectangle_bounds (sourceR J*m) s) (rectangle_pair_room hroom) hA |
| linarith only [hh,hloc,hclip,hcollision,hd] |
| | some r => |
| have hh := weighted_pair_class_correlation V A w hw hw1 f hσ hθ (sourceEta J) |
| hn hk r _ (rectangle_bounds (sourceR J*m) s) hH hγ hA hp' |
| unfold Slice.lossBound at hh |
| linarith only [hh,hloc,henergy,hclip',hcollision',hfourth,hatom,hd] |
| have hsum : (∑ a : Option (PairClass m), ∑ ξ, w ξ*averagedCorrelation |
| (classField (n := n) (f ξ) (sourceSigma J) (sourceEta J) (rectangle (sourceR J*m) s) a)) < |
| (Fintype.card (Option (PairClass m)):ℝ)*classTarget (sourceT J) m := by |
| calc |
| _ < ∑ _a : Option (PairClass m), classTarget (sourceT J) m := |
| Finset.sum_lt_sum (fun a _ => (hcls a).le) ⟨none,Finset.mem_univ _,hcls none⟩ |
| _ = _ := by simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul] |
| rw [classes_times_target hT] at hsum |
| have hup := weighted_lowGradient_classes (m := m) (n := n) V A w hw (sourceR J*m) s f |
| (sourceSigma J) (sourceEta J) |
| have hlo := source_lowGradient_correlation V A w hw hw1 f hJ hm hn s hs h1 h2 h3 |
| linarith only [hsum,hup,hlo] |
|
|
| lemma exists_dimension (R s : ℕ) : ∃ m : ℕ, 2 ≤ m ∧ s+1 < m ∧ R*m < (m-s).choose 2 := by |
| let m := 4*(R+s+1) |
| have hm : 2 ≤ m := by dsimp [m]; omega |
| have hs : s+1 < m := by dsimp [m]; omega |
| have ha : m-s = 4*R+3*s+4 := by dsimp [m]; omega |
| have hb : m-s-1 = 4*R+3*s+3 := by omega |
| have hprod : 2*(R*m+1) ≤ (m-s)*(m-s-1) := by |
| rw [hb,ha] |
| dsimp [m] |
| nlinarith |
| refine ⟨m,hm,hs,?_⟩ |
| rw [Nat.choose_two_right] |
| omega |
|
|
| lemma exists_positive_nat_div_lt {E e : ℝ} (he : 0 < e) : |
| ∃ H : ℕ, 0 < H ∧ E/(H:ℝ) < e := by |
| obtain ⟨H,hH⟩ := exists_nat_gt (max 0 (E/e)) |
| have hH0 : (0:ℝ) < H := lt_of_le_of_lt (le_max_left _ _) hH |
| have hEH : E < e*(H:ℝ) := by |
| have := (div_lt_iff₀ he).mp (lt_of_le_of_lt (le_max_right _ _) hH) |
| linarith |
| exact ⟨H,by exact_mod_cast hH0,(div_lt_iff₀ hH0).mpr hEH⟩ |
|
|
| lemma exists_reciprocal_processing {E e : ℝ} (he : 0 < e) : |
| ∃ (H A₀ : ℕ) (γ : ℚ), 0 < H ∧ 0 < A₀ ∧ 0 < (γ:ℝ) ∧ (γ:ℝ) < 1 ∧ |
| E/(H:ℝ) < e ∧ 2*E/(A₀:ℝ) < e ∧ |
| Real.sqrt ((H:ℝ)*((γ:ℝ)+(H:ℝ)^2/(A₀:ℝ))) < e := by |
| obtain ⟨H,hH,hHbound⟩ := exists_positive_nat_div_lt (E := E) he |
| have hHr : (0:ℝ) < H := by exact_mod_cast hH |
| obtain ⟨γ,hγ,hγub⟩ := exists_rat_btwn (show (0:ℝ) < min 1 (e^2/(4*(H:ℝ))) by positivity) |
| have hg1 := (lt_min_iff.mp hγub).1 |
| have hgE : (H:ℝ)*(γ:ℝ) < e^2/4 := by |
| have hh := (lt_div_iff₀ (show (0:ℝ) < 4*(H:ℝ) by positivity)).mp (lt_min_iff.mp hγub).2 |
| nlinarith |
| obtain ⟨A₀,hA⟩ := exists_nat_gt (max 0 (max (2*E/e) (4*(H:ℝ)^3/e^2))) |
| have hAr : (0:ℝ) < A₀ := lt_of_le_of_lt (le_max_left _ _) hA |
| have hAE : 2*E/(A₀:ℝ) < e := by |
| apply (div_lt_iff₀ hAr).mpr |
| have hh := (div_lt_iff₀ he).mp (lt_of_le_of_lt (le_trans (le_max_left _ _) (le_max_right _ _)) hA) |
| linarith |
| have hAH : (H:ℝ)^3/(A₀:ℝ) < e^2/4 := by |
| have hh := (div_lt_iff₀ (show 0 < e^2 by positivity)).mp |
| (lt_of_le_of_lt (le_trans (le_max_right _ _) (le_max_right _ _)) hA) |
| apply (div_lt_iff₀ hAr).mpr |
| nlinarith |
| refine ⟨H,A₀,γ,hH,by exact_mod_cast hAr,hγ,hg1,hHbound,hAE,?_⟩ |
| apply Real.sqrt_lt' he |>.mpr |
| have heq : (H:ℝ)*((γ:ℝ)+(H:ℝ)^2/(A₀:ℝ)) = (H:ℝ)*(γ:ℝ)+(H:ℝ)^3/(A₀:ℝ) := by ring |
| rw [heq] |
| nlinarith |
|
|
| lemma exists_box_scale (m : ℕ) {A₀ e : ℝ} (hA : 0 < A₀) (he : 0 < e) : |
| ∃ k : ℕ, 1 ≤ k ∧ 2*A₀*((m:ℝ)/(k+1))^(((2^m:ℕ):ℝ)⁻¹) < e := by |
| obtain ⟨k,hk⟩ := exists_nat_gt (max 1 ((m:ℝ)/(e/(2*A₀))^(2^m))) |
| have hk1 : (1:ℝ) < k := lt_of_le_of_lt (le_max_left _ _) hk |
| have hk0 : (0:ℝ) < (k:ℝ)+1 := by linarith |
| have hq : (m:ℝ)/(e/(2*A₀))^(2^m) < (k:ℝ)+1 := |
| lt_of_lt_of_le (lt_of_le_of_lt (le_max_right _ _) hk) (by linarith) |
| have hratio : (m:ℝ)/((k:ℝ)+1) < (e/(2*A₀))^(2^m) := by |
| apply (div_lt_iff₀ hk0).mpr |
| have hh := (div_lt_iff₀ (show (0:ℝ) < (e/(2*A₀))^(2^m) by positivity)).mp hq |
| linarith |
| have hroot : ((m:ℝ)/((k:ℝ)+1))^(((2^m:ℕ):ℝ)⁻¹) < e/(2*A₀) := by |
| apply (Real.rpow_inv_lt_iff_of_pos (by positivity) (by positivity) (by positivity)).mpr |
| rwa [Real.rpow_natCast] |
| refine ⟨k,by exact_mod_cast hk1.le,?_⟩ |
| simpa only [mul_comm] using (lt_div_iff₀ (show 0 < 2*A₀ by positivity)).mp hroot |
|
|
| lemma exists_ambient_scale (s D k : ℕ) {σ e : ℝ} (hσ : 0 < σ) (he : 0 < e) : |
| ∃ n : ℕ, k+2 ≤ n ∧ σ⁻¹*Real.sqrt (((s+D:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1))) < e := by |
| obtain ⟨n,hn⟩ := exists_nat_gt (max (k+2:ℝ) (((s+D:ℕ):ℝ)*(k:ℝ)/(e*σ)^2+1)) |
| have hnK : (k:ℝ)+2 < n := lt_of_le_of_lt (le_max_left _ _) hn |
| have hn0 : (0:ℝ) < (n:ℝ)-1 := by have : (0:ℝ) ≤ k := Nat.cast_nonneg _; linarith |
| have hnB : ((s+D:ℕ):ℝ)*(k:ℝ)/(e*σ)^2 < (n:ℝ)-1 := by |
| have := lt_of_le_of_lt (le_max_right _ _) hn |
| linarith |
| have hr : ((s+D:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1)) < (e*σ)^2 := by |
| rw [← mul_div_assoc] |
| apply (div_lt_iff₀ hn0).mpr |
| have := (div_lt_iff₀ (show 0 < (e*σ)^2 by positivity)).mp hnB |
| linarith |
| have hh := (Real.sqrt_lt' (show 0 < e*σ by positivity)).mpr hr |
| refine ⟨n,?_,?_⟩ |
| · exact_mod_cast hnK.le |
| · calc |
| _ = Real.sqrt (((s+D:ℕ):ℝ)*((k:ℝ)/((n:ℝ)-1)))/σ := by ring |
| _ < e := (div_lt_iff₀ hσ).mpr hh |
|
|
| lemma exists_small_rational_atoms {L B : ℝ} (hL : 0 < L) (hB : 0 < B) : |
| ∃ p θ : ℚ, 0 < (p:ℝ) ∧ (p:ℝ) < 1 ∧ 0 < (θ:ℝ) ∧ (θ:ℝ) < 1 ∧ |
| (θ:ℝ)^2+L*(p:ℝ) < B := by |
| obtain ⟨θ,hθ,hθb⟩ := exists_rat_btwn (show (0:ℝ) < min 1 (B/4) by positivity) |
| obtain ⟨p,hp,hpb⟩ := exists_rat_btwn (show (0:ℝ) < min 1 (B/(4*L)) by positivity) |
| obtain ⟨hθ1,hθB⟩ := lt_min_iff.mp hθb |
| obtain ⟨hp1,hpB⟩ := lt_min_iff.mp hpb |
| have hLp : L*(p:ℝ) < B/4 := by |
| have hh := (lt_div_iff₀ (show 0 < 4*L by positivity)).mp hpB |
| nlinarith |
| exact ⟨p,θ,hp,hp1,hθ,hθ1,by nlinarith⟩ |
|
|
| lemma nested_atom_lt {σ e γ C Q : ℝ} (hσ : 0 < σ) (he : 0 < e) (hγ : 0 < γ) (hC : 0 < C) |
| (hQ : Q < (e^2*σ^2*γ/C)^2) : |
| Real.sqrt (σ⁻¹^2)*Real.sqrt (C*Real.sqrt Q/γ) < e := by |
| have h1 := (Real.sqrt_lt' (show 0 < e^2*σ^2*γ/C by positivity)).mpr hQ |
| have h2 : C*Real.sqrt Q/γ < (e*σ)^2 := by |
| have hh := (lt_div_iff₀ hC).mp h1 |
| apply (div_lt_iff₀ hγ).mpr |
| nlinarith |
| have h3 := (Real.sqrt_lt' (show 0 < e*σ by positivity)).mpr h2 |
| rw [Real.sqrt_sq (by positivity : 0 ≤ σ⁻¹)] |
| rw [mul_comm,← div_eq_mul_inv] |
| exact (div_lt_iff₀ hσ).mpr h3 |
| end MinUncut.Inner |
|
|
| end |
|
|
| end OAI |
|
|
