| import Mathlib |
| import OAI.Computability.MinUncut.Graphs.HonestComparisons |
| import OAI.Computability.MinUncut.Estimates.ComparisonSoundness |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators |
| namespace MinUncut.Inner |
| open MeasureTheory RowNoise GaussianBudget |
| attribute [local instance] Classical.propDecidable |
| variable {V A : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A] |
| variable {m n : ℕ} |
|
|
| lemma secondError_evaluation_le (a : A) (hn : 0 < n) (hm : 0 < m) |
| {σ η δ : ℝ} (hσ : 0 ≤ σ) (hσ1 : σ ≤ 1) (hη : 0 ≤ η) (hδ : 0 ≤ δ) |
| (hρ : δ^2/(m:ℝ) ≤ 1) : |
| secondError (m := m) (n := n) (evaluationProof a) (δ^2/(m:ℝ)) σ η ≤ 8*δ+4*η := by |
| have hρ0 : 0 ≤ δ^2/(m:ℝ) := by positivity |
| have hB (B : FaceArray A m n) : |
| (𝔼 C : FaceArray A m n, density (δ^2/(m:ℝ)) B C* |
| (∫ c, secondRejection (evaluationProof a) B C σ η c ∂gauss (Point m n))) ≤ 8*δ+4*η := by |
| calc |
| _ ≤ 𝔼 C : FaceArray A m n, density (δ^2/(m:ℝ)) B C* |
| (4*‖vector (codeVector (labelCode B a))-vector (codeVector (labelCode C a))‖+4*η) := by |
| apply Finset.expect_le_expect |
| intro C _ |
| exact mul_le_mul_of_nonneg_left (secondRejection_evaluation_le a B C hn hσ hσ1 hη) |
| (density_nonneg hρ0 hρ B C) |
| _ = 4*(𝔼 C : FaceArray A m n, density (δ^2/(m:ℝ)) B C* |
| ‖vector (codeVector (labelCode B a))-vector (codeVector (labelCode C a))‖)+4*η := by |
| simp_rw [mul_add,mul_left_comm (density _ B _),Finset.expect_add_distrib, |
| ← Finset.mul_expect] |
| rw [← Finset.expect_mul,density_mean,one_mul] |
| _ ≤ _ := by have h := noise_vector_le a B hn hm hδ hρ; linarith |
| exact (Finset.expect_le_expect (fun B _ => hB B)).trans_eq (Fintype.expect_const _) |
|
|
| lemma honest_first_budget (a : A) (hn : 0 < n) {J : ℝ} (hJ : 1 ≤ J) : |
| firstError (m := m) (n := n) (evaluationProof a) (sourceSigma J) (sourceEta J) ≤ |
| 10*sourceSigma J := by |
| have h := firstError_evaluation_le (m := m) a hn (sourceSigma_pos hJ).le (sourceEta_pos hJ).le |
| have := sourceEta_le_sigma hJ |
| have := sourceSigma_pos hJ |
| linarith |
|
|
| lemma honest_second_budget (a : A) (hn : 0 < n) (hm : 0 < m) {J : ℝ} (hJ : 1 ≤ J) : |
| secondError (m := m) (n := n) (evaluationProof a) ((sourceEta J)^2/(m:ℝ)) |
| (sourceSigma J) (sourceEta J) ≤ 10*(sourceEta J+sourceEta J) := by |
| have h := secondError_evaluation_le a hn hm (sourceSigma_pos hJ).le (sourceSigma_le_one hJ) |
| (sourceEta_pos hJ).le (sourceEta_pos hJ).le (source_row_rate hJ hm).2.1 |
| have := sourceEta_pos hJ |
| linarith |
| end MinUncut.Inner |
|
|
| namespace MinUncut.Inner |
| open MeasureTheory |
| attribute [local instance] Classical.propDecidable |
| variable {V A W B : Type*} [AddCommGroup V] [Module F₂ V] [AddTorsor V A] [Fintype A] |
| [AddCommGroup W] [Module F₂ W] [AddTorsor W B] [Fintype B] {m n : ℕ} |
|
|
| omit [Fintype A] [Fintype B] in |
| lemma labelCode_pullback (π : A →ᵃ[F₂] B) (C : FaceArray B m n) (a : A) : |
| labelCode (pullbackFaces π C) a=labelCode C (π a) := by |
| apply Subtype.ext |
| funext x |
| rfl |
|
|
| omit [Fintype A] in |
| lemma fourthError_evaluation (π : A →ᵃ[F₂] B) (a : A) (σ η : ℝ) : |
| fourthError (m := m) (n := n) π (evaluationProof a) (evaluationProof (π a)) σ η=0 := by |
| simp only [fourthError,comparisonRejection,comparisonFailure,evaluationProof,pullQuery, |
| labelCode_pullback,ite_true,integral_zero,Finset.expect_const_zero] |
|
|
| lemma fourthError_le_one (π : A →ᵃ[F₂] B) (f : FoldedProof A) (g : FoldedProof B) (σ η : ℝ) : |
| fourthError (m := m) (n := n) π f g σ η ≤ 1 := by |
| have hC (C : FaceArray B m n) : |
| (∫ c, comparisonRejection f g (pullbackFaces π C) C σ η c ∂gauss (Point m n)) ≤ 1 := by |
| simpa only [integral_const,probReal_univ,one_smul] using |
| integral_mono (comparisonRejection_integrable f g _ _ σ η) (integrable_const 1) |
| (fun c => (comparisonRejection_range f g _ _ σ η c).2) |
| exact (Finset.expect_le_expect (fun C _ => hC C)).trans_eq (Fintype.expect_const _) |
| end MinUncut.Inner |
| namespace MinUncut.Outer |
| open MinUncut.Inner OuterSmoothness |
| attribute [local instance] Classical.propDecidable BinaryFourier.dualFintype |
| variable {Name I S : Type*} [Fintype I] [Fintype S] [Nonempty S] |
|
|
| def honestProof (s : Name → F₂) : ProofFamily Name I where |
| first U := evaluationProof (firstLabel s U) |
| second Q := evaluationProof (secondLabel s Q) |
|
|
| lemma honest_fourth_point (s : Name → F₂) (U : I → Equation Name) (h : I → Bool) |
| (pos : I → Fin 3) (m n : ℕ) (σ η : ℝ) : |
| (honestProof (I := I) s).fourthTotal (m := m) (n := n) σ η U h pos ≤ |
| ∑ i, if Satisfied s (U i) then (0:ℝ) else 1 := by |
| by_cases hall : ∀ i, Satisfied s (U i) |
| · have hp := honest_projection s U hall h pos |
| simp only [ProofFamily.fourthTotal,honestProof] |
| rw [← hp,fourthError_evaluation] |
| simp only [hall,ite_eq_left,Finset.sum_const_zero,le_refl] |
| · obtain ⟨i,hi⟩ := not_forall.mp hall |
| have hs : (1:ℝ) ≤ ∑ j, if Satisfied s (U j) then (0:ℝ) else 1 := by |
| simpa only [hi,ite_false] using |
| (Finset.single_le_sum (a := i) (fun j _ => by split <;> norm_num : ∀ j ∈ Finset.univ, 0 ≤ if Satisfied s (U j) then (0:ℝ) else 1) (Finset.mem_univ i)) |
| exact (fourthError_le_one (projection U h pos) _ _ σ η).trans hs |
|
|
| lemma failure_fraction (equations : S → Equation Name) (s : Name → F₂) : |
| (𝔼 a : S, if Satisfied s (equations a) then (0:ℝ) else 1)=1-equationFraction equations s := by |
| have he (a : S) : (if Satisfied s (equations a) then (0:ℝ) else 1)= |
| 1-(if Satisfied s (equations a) then (1:ℝ) else 0) := by split <;> norm_num |
| simp_rw [he,Finset.expect_sub_distrib,Fintype.expect_const,Fintype.expect_eq_sum_div_card] |
| rfl |
|
|
| lemma honest_fourth_mean (equations : S → Equation Name) (s : Name → F₂) {k : ℕ} |
| (hk : k ≤ Fintype.card I) (m n : ℕ) (σ η : ℝ) : |
| edgeMean equations k ((honestProof (I := I) s).fourthTotal (m := m) (n := n) σ η) ≤ |
| (Fintype.card I:ℝ)*(1-equationFraction equations s) := by |
| apply (edgeMean_mono equations k (fun U h p => honest_fourth_point s U h p m n σ η)).trans_eq |
| let : Nonempty (FixedSets I k) := fixedSets_nonempty hk |
| have hcoord (i : I) : (𝔼 a : I → S, if Satisfied s (equations (a i)) then (0:ℝ) else 1)= |
| 1-equationFraction equations s := |
| (Subbox.expect_coordinate (B := fun _ : I => S) i |
| (fun b => if Satisfied s (equations b) then (0:ℝ) else 1)).trans (failure_fraction equations s) |
| simp only [edgeMean,Fintype.expect_const,Finset.expect_sum_comm,hcoord,Finset.sum_const, |
| Finset.card_univ,nsmul_eq_mul] |
|
|
| attribute [local irreducible] firstError secondError thirdError fourthError edgeMean |
|
|
| lemma honest_errors_le {J : ℝ} (hJ : 1 ≤ J) (P : InnerParameters J) (O : OuterParameters J P) |
| (equations : S → Equation Name) (s : Name → F₂) (hcard : Fintype.card I=O.t) |
| (hs : (O.t:ℝ)*(1-equationFraction equations s) ≤ O.b4) (j : Test) : |
| (honestProof (I := I) s).testErrors P O equations j ≤ budgets P O j := by |
| have hk : O.k ≤ Fintype.card I := by simpa only [hcard] using O.hk |
| have hn : 0 < P.n := by have := P.hn; omega |
| have hm : 0 < P.m := by have := P.hm; omega |
| cases j <;> simp only [ProofFamily.testErrors,budgets,honestProof] |
| · apply (edgeMean_mono equations O.k (fun U h pos => honest_first_budget (V := SecondAlphabet (secondQuestion U h pos)) (secondLabel s (secondQuestion U h pos)) hn hJ)).trans_eq |
| exact edgeMean_const equations hk _ |
| · apply (edgeMean_mono equations O.k (fun U h pos => honest_second_budget (V := SecondAlphabet (secondQuestion U h pos)) (secondLabel s (secondQuestion U h pos)) hn hm hJ)).trans_eq |
| exact edgeMean_const equations hk _ |
| · apply le_of_eq |
| simp only [thirdError_evaluation] |
| exact edgeMean_const equations hk _ |
| · exact (honest_fourth_mean equations s hk P.m P.n (sourceSigma J) (sourceEta J)).trans |
| (by simpa only [hcard] using hs) |
|
|
| lemma honest_cost_le {J : ℝ} (hJ : 1 ≤ J) (P : InnerParameters J) (O : OuterParameters J P) |
| (equations : S → Equation Name) (s : Name → F₂) (hcard : Fintype.card I=O.t) |
| (hs : (O.t:ℝ)*(1-equationFraction equations s) ≤ O.b4) : |
| (honestProof (I := I) s).cost P O equations ≤ 4 := by |
| have hh : (honestProof (I := I) s).cost P O equations ≤ ∑ _ : Test, (1:ℝ) := by |
| apply Finset.sum_le_sum |
| intro j _ |
| exact (div_le_one (budgets_pos hJ P O j)).mpr (honest_errors_le hJ P O equations s hcard hs j) |
| have hc : (∑ _ : Test, (1:ℝ))=4 := by |
| have hc : Fintype.card Test=4 := by decide |
| simp [hc] |
| exact hh.trans_eq hc |
| end MinUncut.Outer |
|
|
| end |
|
|
| end OAI |
|
|
