| import Mathlib |
| import OAI.Computability.DirectedFeedback.RankGraph.PrefixBit |
| |
| namespace OAI |
|
|
| section |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical |
| noncomputable section |
| open scoped Classical |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open scoped BigOperators |
| open DirectedFeedback.SourceProbability |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open scoped BigOperators |
| noncomputable section |
| open scoped BigOperators |
| open scoped Classical |
| noncomputable section |
| open scoped Classical BigOperators |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open RankGraph Prefix PrefixExperiment Games Ranks |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
| variable {M T N : ℕ} [NeZero M] [NeZero T] |
| variable (G : Game U V E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) |
| variable (hYX : Fintype.card Y ≤ Fintype.card X) (fiber : E → X ≃ Y × Bool) |
| variable (deleted : OutputVertex (M := M) G ψLaw → Bool) |
| variable (ord : OutputVertex (M := M) G ψLaw → ℕ) |
| variable (hord : ∀ {a b}, deleted a = false → deleted b = false → |
| OutputArc G ψLaw hYX fiber a b → ord a < ord b) |
| variable (hrank : ∀ r, deleted (.inl r) = false) |
| variable {η ρ : ℝ} (hη : 0 ≤ η) |
| variable (haccuracy : 3*η*(rankLength X T : ℝ)^3*2^((Fintype.card X)^T) ≤ ρ) |
| variable (hs : Spreads ψLaw η) |
| include hord hrank hη haccuracy hs in |
| theorem big_badness : |
| ((common (M := M) G ψLaw).product (bigMarginal G)).probability |
| (fun a => decide (¬bigGood G ψLaw ord a.1 a.2)) ≤ ρ := by |
| let prefLaw := (uniform (Fin T)).sigma (fun t => |
| (atomLaw (bigMarginal G) (subsetLaw (X := X) (M := M))).iid t.val) |
| have hh := sampled_goodness hYX rankLength_ge hη haccuracy ψLaw hs |
| (prefLaw.product (bigMarginal G)) |
| (fun a => Sum.inl ⟨⟨a.1.1.val+1, by have := a.1.1.isLt |
| Fin.snoc (vertices a.1.2) a.2⟩) |
| (rankOrder G ψLaw ord) (rankOrder_arc G ψLaw hYX fiber deleted ord hord hrank) |
| simp only [probability_eq_expect, expectation_product, common, commonLaw, |
| bigGood, prefLaw] at hh ⊢ |
| apply le_trans (le_of_eq ?_) hh |
| apply expectation_congr |
| intro psi |
| apply expectation_congr |
| intro pre |
| apply expectation_congr |
| intro u |
| rfl |
|
|
| include hord hrank hη haccuracy hs in |
| theorem small_badness : |
| ((common (M := M) G ψLaw).product (smallMarginal G)).probability |
| (fun a => decide (¬smallGood G ψLaw ord a.1 a.2)) ≤ ρ := by |
| let prefLaw := (uniform (Fin T)).sigma (fun t => |
| (atomLaw (bigMarginal G) (subsetLaw (X := X) (M := M))).iid t.val) |
| have hh := sampled_goodness hYX rankLength_ge hη haccuracy ψLaw hs |
| (prefLaw.product (smallMarginal G)) |
| (fun a => Sum.inr ⟨a.1.1,vertices a.1.2,a.2⟩) |
| (rankOrder G ψLaw ord) (rankOrder_arc G ψLaw hYX fiber deleted ord hord hrank) |
| simp only [probability_eq_expect, expectation_product, common, commonLaw, |
| smallGood, prefLaw] at hh ⊢ |
| apply le_trans (le_of_eq ?_) hh |
| apply expectation_congr |
| intro psi |
| apply expectation_congr |
| intro pre |
| apply expectation_congr |
| intro v |
| rfl |
|
|
| include hord hrank hη haccuracy hs in |
| theorem edge_badness : |
| ((common (M := M) G ψLaw).product G.edgeLaw).probability |
| (fun a => decide (¬bigGood G ψLaw ord a.1 (G.left a.2))) ≤ ρ ∧ |
| ((common (M := M) G ψLaw).product G.edgeLaw).probability |
| (fun a => decide (¬smallGood G ψLaw ord a.1 (G.right a.2))) ≤ ρ := by |
| constructor |
| · have hh := big_badness G ψLaw hYX fiber deleted ord hord hrank hη haccuracy hs |
| simpa only [probability_eq_expect, expectation_product, bigMarginal, |
| expectation_pushforward] using hh |
| · have hh := small_badness G ψLaw hYX fiber deleted ord hord hrank hη haccuracy hs |
| simpa only [probability_eq_expect, expectation_product, smallMarginal, |
| expectation_pushforward] using hh |
|
|
| end DirectedFeedback.Construction |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Soundness |
| open DirectedFeedback.SourceProbability |
| open FiniteDistribution |
| variable {Ω : Type*} [Fintype Ω] |
|
|
| theorem acceptance_forces_tail (μ : FiniteDistribution Ω) (p : ℝ) (hp : 0 < p) |
| (a b B : Ω → ℝ) (ha0 : ∀ ω, 0 ≤ a ω) (ha1 : ∀ ω, a ω ≤ 1) |
| (hb1 : ∀ ω, b ω ≤ 1) (hbB : ∀ ω, b ω ≤ 2 * p * B ω) |
| (hlower : p / 4 ≤ μ.expectation a) |
| (hcomp : μ.expectation (fun ω => a ω * (1 - b ω)) ≤ p / 16) : |
| p / 8 ≤ μ.probability (fun ω => decide (1 / (4 * p) ≤ B ω)) := by |
| have hp4 : 0 < 4 * p := by positivity |
| have hpoint (ω) : a ω ≤ 2 * (a ω * (1 - b ω)) + |
| if 1 / (4 * p) ≤ B ω then 1 else 0 := by |
| by_cases hh : 1 / (4 * p) ≤ B ω |
| · simp only [hh, ↓reduceIte] |
| have hz : 0 ≤ a ω * (1 - b ω) := mul_nonneg (ha0 ω) (sub_nonneg.mpr (hb1 ω)) |
| linarith [ha1 ω] |
| · simp only [hh, ↓reduceIte, add_zero] |
| have hsmall : 4 * p * B ω < 1 := by |
| have hh' := (lt_div_iff₀ hp4).mp (lt_of_not_ge hh) |
| nlinarith |
| have hbhalf : b ω < 1 / 2 := by nlinarith [hbB ω] |
| nlinarith [mul_nonneg (ha0 ω) (show 0 ≤ 1 / 2 - b ω by linarith)] |
| have he := μ.expectation_mono hpoint |
| have heq : μ.expectation (fun ω => 2 * (a ω * (1 - b ω)) + |
| if 1 / (4 * p) ≤ B ω then 1 else 0) = |
| 2 * μ.expectation (fun ω => a ω * (1 - b ω)) + |
| μ.probability (fun ω => decide (1 / (4 * p) ≤ B ω)) := by |
| unfold expectation probability |
| simp only [mul_add, Finset.sum_add_distrib, decide_eq_true_eq, mul_ite, mul_one, mul_zero] |
| congr 1 |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro ω _ |
| ring |
| rw [heq] at he |
| linarith |
| |
| theorem geometric_half_sum (n : ℕ) : ∑ i ∈ Finset.range (n + 1), (2 : ℝ)^i / 2 = |
| 2^n - 1 / 2 := by |
| induction n with |
| | zero => norm_num |
| | succ n ih => rw [Finset.sum_range_succ, ih, pow_succ]; ring |
| |
| theorem dyadic_layer_cake (M : ℕ) (x : ℝ) (hx : 0 ≤ x) : |
| (∑ i ∈ Finset.range M, (2 : ℝ)^i / 2 * if 2^i ≤ x then 1 else 0) ≤ x := by |
| induction M with |
| | zero => simpa using hx |
| | succ n ih => |
| by_cases hh : (2 : ℝ)^n ≤ x |
| · calc |
| _ ≤ ∑ i ∈ Finset.range (n + 1), (2 : ℝ)^i / 2 := by |
| apply Finset.sum_le_sum |
| intro i _ |
| split_ifs |
| · simp |
| · simp only [mul_zero] |
| positivity |
| _ = 2^n - 1 / 2 := geometric_half_sum n |
| _ ≤ x := by linarith |
| · simpa only [Finset.sum_range_succ, hh, ↓reduceIte, mul_zero, add_zero] using ih |
| |
| theorem dyadic_tails_expectation (μ : FiniteDistribution Ω) (M : ℕ) (B : Ω → ℝ) |
| (hB : ∀ ω, 0 ≤ B ω) |
| (htail : ∀ i < M, (2 : ℝ)⁻¹ ^ (i + 2) / 8 ≤ |
| μ.probability (fun ω => decide (2^i ≤ B ω))) : |
| (M : ℝ) / 64 ≤ μ.expectation B := by |
| have he := μ.expectation_mono (fun ω => dyadic_layer_cake M (B ω) (hB ω)) |
| have heq : μ.expectation (fun ω => |
| ∑ i ∈ Finset.range M, (2 : ℝ)^i / 2 * if 2^i ≤ B ω then 1 else 0) = |
| ∑ i ∈ Finset.range M, (2 : ℝ)^i / 2 * |
| μ.probability (fun ω => decide (2^i ≤ B ω)) := by |
| unfold expectation probability |
| simp only [Finset.mul_sum, decide_eq_true_eq, mul_ite, mul_one, mul_zero] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro ω _ |
| split_ifs <;> ring |
| rw [heq] at he |
| calc |
| _ = ∑ i ∈ Finset.range M, (2 : ℝ)^i / 2 * ((2 : ℝ)⁻¹ ^ (i + 2) / 8) := by |
| have hterm (i : ℕ) : (2 : ℝ)^i / 2 * ((2 : ℝ)⁻¹ ^ (i + 2) / 8) = 1 / 64 := by |
| rw [inv_pow, pow_add] |
| have hz : (2 : ℝ)^i ≠ 0 := by positivity |
| field_simp |
| ring |
| simp_rw [hterm] |
| simp |
| ring |
| _ ≤ _ := (Finset.sum_le_sum (fun i hi => mul_le_mul_of_nonneg_left |
| (htail i (Finset.mem_range.mp hi)) (by positivity))).trans he |
| |
| theorem dyadic_contradiction (μ : FiniteDistribution Ω) (D : ℝ) (hD : 0 ≤ D) |
| (M : ℕ) (hM : (M : ℝ) = 128 * (D + 1)) (B : Ω → ℝ) |
| (hB0 : ∀ ω, 0 ≤ B ω) (hB : μ.expectation B ≤ D + 1) |
| (a b : Fin M → Ω → ℝ) (ha0 : ∀ i ω, 0 ≤ a i ω) (ha1 : ∀ i ω, a i ω ≤ 1) |
| (hb1 : ∀ i ω, b i ω ≤ 1) |
| (hbB : ∀ i ω, b i ω ≤ 2 * ((2 : ℝ)⁻¹ ^ (i.val + 2)) * B ω) |
| (hlower : ∀ i, (2 : ℝ)⁻¹ ^ (i.val + 2) / 4 ≤ μ.expectation (a i)) |
| (hcomp : ∀ i, μ.expectation (fun ω => a i ω * (1 - b i ω)) ≤ |
| (2 : ℝ)⁻¹ ^ (i.val + 2) / 16) : False := by |
| have ht (i : ℕ) (hi : i < M) := acceptance_forces_tail μ ((2 : ℝ)⁻¹ ^ (i + 2)) |
| (by positivity) (a ⟨i, hi⟩) (b ⟨i, hi⟩) B (ha0 ⟨i, hi⟩) (ha1 ⟨i, hi⟩) (hb1 ⟨i, hi⟩) (hbB ⟨i, hi⟩) |
| (hlower ⟨i, hi⟩) (hcomp ⟨i, hi⟩) |
| have hthreshold (i : ℕ) : 1 / (4 * ((2 : ℝ)⁻¹ ^ (i + 2))) = 2^i := by |
| rw [pow_add, inv_pow] |
| have hz : (2 : ℝ)^i ≠ 0 := by positivity |
| field_simp |
| ring |
| simp_rw [hthreshold] at ht |
| have hh := dyadic_tails_expectation μ M B hB0 ht |
| rw [hM] at hh |
| linarith |
| |
| end DirectedFeedback.Soundness |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open PrefixExperiment Pivotal Games |
| variable {M : ℕ} [NeZero M] |
| |
| def lastBias (M : ℕ) : ℝ := (2:ℝ)⁻¹^(M+1) |
| |
| omit [NeZero M] in |
| theorem lastBias_le (i : Fin M) : lastBias M ≤ bias i := by |
| apply pow_le_pow_of_le_one (by norm_num) (by norm_num) |
| have := i.isLt |
| omega |
| |
| end DirectedFeedback.Construction |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open RankGraph Prefix PrefixExperiment Games Pivotal Ranks |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
| variable {M T N : ℕ} [NeZero M] [NeZero T] |
| |
| theorem weighted_soundness |
| (G : Game U V E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) |
| (hYX : Fintype.card Y ≤ Fintype.card X) (fiber : E → X ≃ Y × Bool) |
| (hproj : ∀ e x, (fiber e x).1 = G.project e x) |
| (D H K η ρ γ θ : ℝ) (hD : 0 ≤ D) (hH : 0 < H) (hK : 0 < K) |
| (hη : 0 ≤ η) (hγ : 0 < γ) (hM : (M:ℝ) = 128*(D+1)) |
| (haccuracy : 3*η*(rankLength X T : ℝ)^3*2^((Fintype.card X)^T) ≤ ρ) |
| (hspreads : Spreads ψLaw η) (hρ : Fintype.card X * ρ ≤ 1) |
| (hρ0 : 0 ≤ ρ) (hfull : ρ+D/H ≤ 1/2) |
| (J : ℕ) (hJ : 1 ≤ J) (hJunta : DyadicJuntaBound M ((D+1)/γ) γ J) |
| (hcomp : 2*ρ + M*(2:ℝ)^T*D/K + 6*γ + θ*(J:ℝ)^2 ≤ lastBias M/16) |
| (hsound : G.Sound θ) |
| (F : Finset (OutputVertex (M := M) G ψLaw)) |
| (hF : FeedbackR (OutputArc G ψLaw hYX fiber) F) : |
| D < totalDeletionCost G ψLaw D H K (fun v => decide (v ∈ F)) := by |
| by_contra hn |
| have hcost := not_lt.mp hn |
| let deleted : OutputVertex (M := M) G ψLaw → Bool := fun v => decide (v ∈ F) |
| obtain ⟨ord, hord', _⟩ := exists_topological_order (OutputArc G ψLaw hYX fiber) F hF |
| have hord : ∀ {a b}, deleted a = false → deleted b = false → |
| OutputArc G ψLaw hYX fiber a b → ord a < ord b := by |
| intro a b ha hb hab |
| exact hord' a b (by simpa [deleted] using ha) (by simpa [deleted] using hb) hab |
| have hrank := rank_retained G ψLaw D H K hD hH hK deleted hcost |
| obtain ⟨hf,hb,hv,hc⟩ := family_costs G ψLaw deleted D H K hD hH.le hK.le hcost |
| have hbu := big_badness G ψLaw hYX fiber deleted ord hord hrank hη haccuracy hspreads |
| have hbv := small_badness G ψLaw hYX fiber deleted ord hord hrank hη haccuracy hspreads |
| have hρY : (Fintype.card Y:ℝ)*ρ ≤ 1 := |
| (mul_le_mul_of_nonneg_right (by exact_mod_cast hYX) hρ0).trans hρ |
| let fx : X := Classical.choice inferInstance |
| let fy : Y := Classical.choice inferInstance |
| have hBu' := big_budget G ψLaw hYX fiber deleted ord hord hrank fx D ρ hρ hbu hb |
| have hBv' := small_budget G ψLaw hYX fiber deleted ord hord hrank fy D ρ hρY hbv hv |
| have hBu : ((common (M := M) G ψLaw).product G.edgeLaw).expectation |
| (bigBudget G ψLaw hYX fiber deleted ord hord hrank fx) ≤ D+1 := by |
| simpa only [bigBudget, expectation_product, bigMarginal, expectation_pushforward] using hBu' |
| have hBv : ((common (M := M) G ψLaw).product G.edgeLaw).expectation |
| (smallBudget G ψLaw hYX fiber deleted ord hord hrank fy) ≤ D+1 := by |
| simpa only [smallBudget, expectation_product, smallMarginal, expectation_pushforward] using hBv' |
| have hbad := full_badness G ψLaw hYX fiber deleted ord hord hrank hη haccuracy hspreads |
| have hgoodprob := favorable_probability G ψLaw deleted ord D H ρ hH hf hbad hfull |
| obtain ⟨hebu,hebv⟩ := edge_badness G ψLaw hYX fiber deleted ord hord hrank hη haccuracy hspreads |
| apply Soundness.dyadic_contradiction ((common (M := M) G ψLaw).product G.edgeLaw) |
| D hD M hM (smallBudget G ψLaw hYX fiber deleted ord hord hrank fy) |
| (fun a => budget_nonneg _) hBv |
| (bigAcceptance G ψLaw hYX fiber deleted ord hord hrank fx) |
| (smallAcceptance G ψLaw hYX fiber deleted ord hord hrank fy) |
| · intro i a |
| exact probability_nonnegative _ _ |
| · intro i a |
| exact probability_le_one _ _ |
| · intro i a |
| exact probability_le_one _ _ |
| · intro i a |
| have hp := smallFunction_properties G ψLaw hYX fiber deleted ord hord hrank fy a.1 (G.right a.2) |
| exact acceptance_le_mul_budget _ hp.1 hp.2.1 (2*bias i) |
| (mul_nonneg (by norm_num) (bias_pos i).le) (by linarith [bias_le_quarter i]) |
| · intro i |
| have ha := full_acceptance G ψLaw hYX fiber deleted ord hord hrank fx hgoodprob i |
| simpa only [bigAcceptance, expectation_product, bigMarginal, expectation_pushforward, bias] using ha |
| · intro i |
| have hh := independent_comparison G ψLaw hYX fiber deleted ord hord hrank fx fy i |
| D K ρ γ θ hD hK hγ hsound hproj J hJ hJunta hBu hBv hc hebu hebv |
| exact hh.trans (hcomp.trans (div_le_div_of_nonneg_right (lastBias_le i) (by norm_num))) |
| |
| end DirectedFeedback.Construction |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.SourceProbability.FiniteDistribution |
| variable {I : Type*} [Fintype I] |
| |
| theorem expectation_iid_prod (μ : FiniteDistribution I) (T : ℕ) (f : I → ℝ) : |
| (μ.iid T).expectation (fun a => ∏ t, f (a t)) = (μ.expectation f)^T := by |
| simp only [expectation, iid] |
| simpa only [Finset.prod_mul_distrib] using |
| (Fintype.sum_pow (fun i => μ.weight i * f i) T).symm |
| |
| theorem probability_sublevel_exp (μ : FiniteDistribution I) (count : I → ℝ) (b : ℝ) : |
| μ.probability (fun a => decide (count a < b)) ≤ |
| Real.exp b * μ.expectation (fun a => Real.exp (-count a)) := by |
| rw [probability_eq_expect, ← expectation_mul_left] |
| apply expectation_mono |
| intro a |
| by_cases ha : count a < b |
| · simp only [ha, decide_true, ↓reduceIte] |
| rw [← Real.exp_add] |
| exact Real.one_le_exp_iff.mpr (by linarith) |
| · simp only [ha, decide_false, Bool.false_eq_true, ↓reduceIte] |
| positivity |
| |
| end DirectedFeedback.SourceProbability.FiniteDistribution |
| |
| namespace DirectedFeedback.Pivotal |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| |
| def countTrue {T : ℕ} (a : Fin T → Bool) : ℝ := ∑ t, bitValue (a t) |
| |
| theorem exp_neg_count {T : ℕ} (a : Fin T → Bool) : |
| Real.exp (-countTrue a) = ∏ t, Real.exp (-bitValue (a t)) := by |
| simp only [countTrue, ← Finset.sum_neg_distrib, Real.exp_sum] |
| |
| theorem expMoment_count (a : ℝ) (ha0 : 0 ≤ a) (ha1 : a ≤ 1) (T : ℕ) : |
| ((coin a ha0 ha1).iid T).expectation (fun x => Real.exp (-countTrue x)) = |
| (1-a+a*Real.exp (-1))^T := by |
| simp_rw [exp_neg_count] |
| rw [expectation_iid_prod (coin a ha0 ha1) T (fun b => Real.exp (-bitValue b))] |
| congr 1 |
| simp [expectation, coin, bitValue] |
| ring |
| |
| theorem expMoment_count_le (a : ℝ) (ha0 : 0 ≤ a) (ha1 : a ≤ 1) (T : ℕ) : |
| ((coin a ha0 ha1).iid T).expectation (fun x => Real.exp (-countTrue x)) ≤ |
| Real.exp (-(a*T)*(1-Real.exp (-1))) := by |
| rw [expMoment_count] |
| have hbase : 0 ≤ 1-a+a*Real.exp (-1) := by positivity |
| have hbound : 1-a+a*Real.exp (-1) ≤ Real.exp (a*(Real.exp (-1)-1)) := by |
| nlinarith [Real.add_one_le_exp (a*(Real.exp (-1)-1))] |
| have hp := pow_le_pow_left₀ hbase hbound T |
| calc |
| _ ≤ (Real.exp (a*(Real.exp (-1)-1)))^T := hp |
| _ = Real.exp (-(a*T)*(1-Real.exp (-1))) := by |
| rw [← Real.exp_nat_mul] |
| congr 1 |
| ring |
| |
| theorem exp_neg_one_le : Real.exp (-1) ≤ (3:ℝ)/8 := by |
| have h := Real.sum_le_exp_of_nonneg (show (0:ℝ) ≤ 1 by norm_num) 4 |
| norm_num [Finset.sum_range_succ] at h |
| rw [Real.exp_neg] |
| rw [inv_eq_one_div] |
| exact (div_le_iff₀ (Real.exp_pos 1)).mpr (by linarith) |
| |
| theorem bernoulli_lower_tail (a : ℝ) (ha0 : 0 ≤ a) (ha1 : a ≤ 1) (T : ℕ) : |
| ((coin a ha0 ha1).iid T).probability (fun x => decide (countTrue x < (a*T)/2)) ≤ |
| Real.exp (-(a*T)/8) := by |
| calc |
| _ ≤ Real.exp ((a*T)/2) * |
| ((coin a ha0 ha1).iid T).expectation (fun x => Real.exp (-countTrue x)) := |
| probability_sublevel_exp _ _ _ |
| _ ≤ Real.exp ((a*T)/2) * Real.exp (-(a*T)*(1-Real.exp (-1))) := |
| mul_le_mul_of_nonneg_left (expMoment_count_le a ha0 ha1 T) (Real.exp_nonneg _) |
| _ ≤ Real.exp (-(a*T)/8) := by |
| rw [← Real.exp_add] |
| apply Real.exp_le_exp.mpr |
| have hμ : 0 ≤ a*T := mul_nonneg ha0 (Nat.cast_nonneg _) |
| nlinarith [mul_le_mul_of_nonneg_left exp_neg_one_le hμ] |
| |
| end DirectedFeedback.Pivotal |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.SourceProbability.FiniteDistribution |
| variable {Ω : Type*} [Fintype Ω] |
| |
| theorem pushforward_bool (μ : FiniteDistribution Ω) (event : Ω → Bool) (p : ℝ) |
| (hp0 : 0 ≤ p) (hp1 : p ≤ 1) (he : μ.probability event = p) : |
| μ.pushforward event = DirectedFeedback.Pivotal.coin p hp0 hp1 := by |
| apply eq_of_weight_eq |
| intro b |
| have ht : (μ.pushforward event).weight true = p := by |
| calc |
| _ = μ.probability event := by |
| unfold pushforward probability |
| apply Finset.sum_congr rfl |
| intro x _ |
| cases event x <;> simp |
| _ = p := he |
| have hn := (μ.pushforward event).normalized |
| simp only [Fintype.sum_bool] at hn |
| cases b |
| · change (μ.pushforward event).weight false = 1-p |
| linarith |
| · exact ht |
| |
| end DirectedFeedback.SourceProbability.FiniteDistribution |
| |
| namespace DirectedFeedback.Pivotal |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| variable {Ω : Type*} [Fintype Ω] |
| |
| theorem iid_event_lower_tail (μ : FiniteDistribution Ω) (event : Ω → Bool) |
| (p : ℝ) (hp0 : 0 ≤ p) (hp1 : p ≤ 1) (he : μ.probability event = p) (T : ℕ) : |
| (μ.iid T).probability (fun a => decide (countTrue (fun t => event (a t)) < p*T/2)) ≤ |
| Real.exp (-(p*T)/8) := by |
| rw [← probability_pushforward (μ.iid T) (fun a t => event (a t)) |
| (fun b => decide (countTrue b < p*T/2)), ← iid_pushforward, |
| pushforward_bool μ event p hp0 hp1 he] |
| exact bernoulli_lower_tail p hp0 hp1 T |
| |
| end DirectedFeedback.Pivotal |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Coupling |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| variable {X Y : Type} [Fintype X] [Fintype Y] |
| |
| omit [Fintype X] in |
| theorem support_inclusion (e : X ≃ Y × Bool) (p : ℝ) (hp0 : 0 ≤ p) (hp : p ≤ 1/2) |
| (z : Y → Block) (hz : (law p hp0 hp).weight z ≠ 0) (x : X) : |
| bigBits e z x = true → smallBits z (e x).1 = true := by |
| have hprod : (∏ y, blockWeight p (z y)) ≠ 0 := hz |
| have hblock : blockWeight p (z (e x).1) ≠ 0 := by |
| exact (Finset.prod_ne_zero_iff.mp hprod) _ (Finset.mem_univ _) |
| intro hx |
| apply block_inclusion p _ hblock |
| change (if (e x).2 = true then (z (e x).1).1.2 else (z (e x).1).1.1) = true at hx |
| split at hx |
| · exact Or.inr hx |
| · exact Or.inl hx |
| |
| end DirectedFeedback.Coupling |
| |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open RankGraph Prefix PrefixExperiment Games |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
| variable {M T N : ℕ} [NeZero M] [NeZero T] |
| variable (G : Game U V E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) |
| variable (fiber : E → X ≃ Y × Bool) (hproject : ∀ e x, (fiber e x).1 = G.project e x) |
| |
| omit [Fintype V] [Nonempty X] [Nonempty Y] in |
| theorem comparison_support_coupling (d : ComparisonSupport (M := M) G ψLaw) : |
| (Coupling.law (Y := Y) (bias d.val.2.2.1) (bias_pos _).le |
| (by linarith [bias_le_quarter d.val.2.2.1])).weight d.val.2.2.2.2 ≠ 0 := by |
| intro hz |
| have he : (comparisonLaw G ψLaw).weight d.val = 0 := by |
| simp only [comparisonLaw, sigma, product, hz, mul_zero] |
| linarith [d.property] |
| |
| include hproject in |
| omit [Fintype V] [Nonempty X] [Nonempty Y] in |
| |
| theorem comparison_label_increases (ellU : U → X) (ellV : V → Y) |
| (d : ComparisonSupport (M := M) G ψLaw) |
| (hsat : G.project d.val.2.1 (ellU (G.left d.val.2.1)) = ellV (G.right d.val.2.1)) : |
| eval ellU ellV (comparison G fiber d.val).source < |
| eval ellU ellV (comparison G fiber d.val).target := by |
| let pref : Fin d.val.1.2.1.val → X := fun j => ellU (vertices d.val.1.2.2 j) |
| let xu := ellU (G.left d.val.2.1) |
| let yv := ellV (G.right d.val.2.1) |
| have himp : Coupling.bigBits (fiber d.val.2.1) d.val.2.2.2.2 xu = true → |
| Coupling.smallBits d.val.2.2.2.2 yv = true := by |
| have he : (fiber d.val.2.1 xu).1 = yv := (hproject _ _).trans hsat |
| rw [← he] |
| exact Coupling.support_inclusion _ _ _ _ _ (comparison_support_coupling G ψLaw d) _ |
| have hlabels : labels ellU ellV |
| (.inl ⟨⟨d.val.1.2.1.val+1, by exact Nat.succ_lt_succ d.val.1.2.1.isLt⟩, |
| Fin.snoc (vertices d.val.1.2.2) (G.left d.val.2.1)⟩) = Fin.snoc pref xu := by |
| funext j |
| refine Fin.lastCases ?_ (fun i => ?_) j |
| · simp [labels, pref, xu] |
| · simp [labels, pref, xu] |
| simp only [comparison, twoLevel, eval_vertex, hlabels, Set.mem_preimage, splitLast, |
| Equiv.coe_fn_mk, Fin.init_snoc, Fin.snoc_last] |
| change (if (pref,yv) ∈ conditionedSet (cell d.val.1.2.2) d.val.2.2.2.1 |
| {y | Coupling.smallBits d.val.2.2.2.2 y = true} then d.val.1.1.val ⟨1,_⟩ else d.val.1.1.val ⟨16,_⟩) < |
| (if (pref,xu) ∈ conditionedSet (cell d.val.1.2.2) d.val.2.2.2.1 |
| {x | Coupling.bigBits (fiber d.val.2.1) d.val.2.2.2.2 x = true} then d.val.1.1.val ⟨2,_⟩ else d.val.1.1.val ⟨17,_⟩) |
| by_cases hbefore : (cell d.val.1.2.2 pref).val < d.val.2.2.2.1.val |
| · simp only [conditionedSet, Set.mem_ofPred_eq, hbefore, true_or, ↓reduceIte] |
| apply d.val.1.1.property; change (1 : ℕ) < 2; omega |
| · by_cases heq : cell d.val.1.2.2 pref = d.val.2.2.2.1 |
| · simp only [conditionedSet, Set.mem_ofPred_eq, heq, lt_self_iff_false, false_or, true_and] |
| by_cases hu : Coupling.bigBits (fiber d.val.2.1) d.val.2.2.2.2 xu = true |
| · simp only [hu, himp hu, ↓reduceIte] |
| apply d.val.1.1.property; change (1 : ℕ) < 2; omega |
| · simp only [hu] |
| split |
| · apply d.val.1.1.property; change (1 : ℕ) < 17; omega |
| · apply d.val.1.1.property; change (16 : ℕ) < 17; omega |
| · simp only [conditionedSet, Set.mem_ofPred_eq, hbefore, false_or, heq, false_and, ↓reduceIte] |
| apply d.val.1.1.property; change (16 : ℕ) < 17; omega |
| |
| end DirectedFeedback.Construction |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open PrefixExperiment Pivotal Games |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
| variable {M T N : ℕ} [NeZero M] [NeZero T] |
| |
| omit [NeZero M] [Nonempty X] in |
| theorem subset_eval_probability (i : Fin M) (x : X) : |
| (subsetLaw i).probability (fun b => b x) = bias i := by |
| rw [probability_eq_expect] |
| unfold subsetLaw Pivotal.law |
| rw [expectation_table_eval (fun _ : X => coin (bias i) (bias_pos i).le |
| (by linarith [bias_le_quarter i])) x (fun b : Bool => if b then 1 else 0)] |
| simp [expectation, coin] |
| |
| omit [Fintype V] [Fintype Y] [Nonempty X] [Nonempty Y] in |
| |
| theorem slot_label_probability (G : Game U V E X Y) (ell : U → X) (i : Fin M) : |
| (atomLaw (bigMarginal G) subsetLaw).probability |
| (fun a => decide (a.2.1 = i) && a.2.2 (ell a.1)) = bias i / M := by |
| rw [probability_eq_expect] |
| have hind (a : Slot U X M) : |
| (if decide (a.2.1 = i) && a.2.2 (ell a.1) then (1:ℝ) else 0) = |
| if a.2.1 = i then (if a.2.2 (ell a.1) then 1 else 0) else 0 := by |
| by_cases hi : a.2.1 = i <;> cases a.2.2 (ell a.1) <;> simp [hi] |
| simp_rw [hind] |
| have he := fresh_index_expectation (bigMarginal G) subsetLaw i |
| (fun u b => if b (ell u) then 1 else 0) |
| calc |
| _ = (1 / (Fintype.card (Fin M) : ℝ)) * (bigMarginal G).expectation |
| (fun u => (subsetLaw i).expectation (fun b => if b (ell u) then 1 else 0)) := by |
| convert he using 1 |
| apply expectation_congr |
| intro a |
| by_cases hi : a.2.1 = i <;> simp [hi] |
| _ = bias i / M := by |
| simp_rw [← probability_eq_expect, subset_eval_probability, expectation_const] |
| simp [div_eq_mul_inv, mul_comm] |
| |
| omit [NeZero T] [Fintype V] [Fintype Y] [Nonempty X] [Nonempty Y] in |
| |
| theorem fullCount_lower_tail (G : Game U V E X Y) (ell : U → X) (i : Fin M) : |
| ((atomLaw (bigMarginal G) subsetLaw).iid T).probability (fun a => |
| decide ((fullCount a i (fun t => ell (vertices a t)) : ℝ) < bias i*T/(2*M))) ≤ |
| Real.exp (-(bias i*T/(8*M))) := by |
| have hM : (0:ℝ) < M := by exact_mod_cast Nat.pos_of_ne_zero (NeZero.ne M) |
| have hM' : (1:ℝ) ≤ M := by exact_mod_cast Nat.pos_of_ne_zero (NeZero.ne M) |
| have hp0 : 0 ≤ bias i / M := (div_pos (bias_pos i) hM).le |
| have hp1 : bias i / M ≤ 1 := (div_le_one hM).mpr (by linarith [bias_le_quarter i]) |
| have hh := iid_event_lower_tail (atomLaw (bigMarginal G) subsetLaw) |
| (fun a => decide (a.2.1 = i) && a.2.2 (ell a.1)) (bias i / M) hp0 hp1 |
| (slot_label_probability G ell i) T |
| have hc (a : PrefixData U X M T) : |
| countTrue (fun t => decide ((a t).2.1 = i) && (a t).2.2 (ell (a t).1)) = |
| (fullCount a i (fun t => ell (vertices a t)) : ℝ) := by |
| simp only [countTrue, fullCount, Finset.card_filter, Nat.cast_sum, Nat.cast_ite, |
| Nat.cast_one, Nat.cast_zero] |
| apply Finset.sum_congr rfl |
| intro t _ |
| by_cases hi : (a t).2.1 = i < |
| simp_rw [hc] at hh |
| have he1 : bias i / (M:ℝ) * T / 2 = bias i*T/(2*M) := by ring |
| have he2 : -(bias i / (M:ℝ) * T) / 8 = -(bias i*T/(8*M)) := by ring |
| simpa only [he1, he2] using hh |
|
|
| omit [Fintype V] [Fintype Y] [Nonempty X] [Nonempty Y] [NeZero T] in |
|
|
| theorem fullStars_probability (G : Game U V E X Y) |
| (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) (ell : U → X) : |
| (fullLaw (M := M) G ψLaw).probability (fun d => |
| decide ((fun t => ell (vertices d.2 t)) ∈ fullStars d.2)) ≤ |
| M * Real.exp (-(lastBias M * T/(8*M))) := by |
| rw [fullLaw, probability_eq_expect, expectation_product] |
| dsimp only |
| have he : (ψLaw.expectation fun _ => |
| ((atomLaw (bigMarginal G) (subsetLaw (M := M))).iid T).probability (fun a => |
| decide ((fun t => ell (vertices a t)) ∈ fullStars a))) = |
| ((atomLaw (bigMarginal G) (subsetLaw (M := M))).iid T).probability (fun a => |
| decide ((fun t => ell (vertices a t)) ∈ fullStars a)) := expectation_const _ _ |
| apply le_trans (le_of_eq (Eq.trans ?_ he)) |
| swap |
| · simp only [probability_eq_expect] |
| have hu := probability_exists_le_sum ((atomLaw (bigMarginal G) (subsetLaw (M := M))).iid T) |
| (fun i a => decide ((fullCount a i (fun t => ell (vertices a t)) : ℝ) < bias i*T/(2*M))) |
| simp only [decide_eq_true_eq] at hu |
| apply le_trans (b := ∑ i : Fin M, ((atomLaw (bigMarginal G) (subsetLaw (M := M))).iid T).probability |
| (fun a => decide ((fullCount a i (fun t => ell (vertices a t)) : ℝ) < bias i*T/(2*M)))) |
| · have hev : (fun a : PrefixData U X M T => |
| decide ((fun t => ell (vertices a t)) ∈ fullStars a)) = |
| (fun a => decide (∃ i : Fin M, |
| (fullCount a i (fun t => ell (vertices a t)) : ℝ) < bias i*T/(2*M))) := by |
| funext a |
| apply Bool.eq_iff_iff.mpr |
| rw [decide_eq_true_eq, decide_eq_true_eq] |
| rfl |
| rw [hev] |
| exact hu |
| calc |
| _ ≤ ∑ i : Fin M, Real.exp (-(bias i*T/(8*M))) := |
| Finset.sum_le_sum (fun i _ => fullCount_lower_tail G ell i) |
| _ ≤ ∑ _i : Fin M, Real.exp (-(lastBias M*T/(8*M))) := by |
| apply Finset.sum_le_sum |
| intro i _ |
| apply Real.exp_le_exp.mpr |
| apply neg_le_neg |
| exact div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_right (lastBias_le i) |
| (Nat.cast_nonneg _)) (by positivity) |
| _ = _ := by simp |
|
|
| end DirectedFeedback.Construction |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Pivotal |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| variable {I : Type} [Fintype I] [DecidableEq I] [Nonempty I] |
|
|
| theorem labelOrder_label_probability (x : I) : |
| labelOrderLaw.probability (fun o : LabelOrder I => decide (x = o.1)) = |
| 1 / Fintype.card I := by |
| rw [probability_eq_expect, labelOrderLaw, expectation_sigma] |
| simp only [expectation_const, decide_eq_true_eq] |
| rw [expectation_uniform] |
| simp |
|
|
| end DirectedFeedback.Pivotal |
| |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open RankGraph Prefix PrefixExperiment Games Pivotal |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
| variable {M T N : ℕ} [NeZero M] [NeZero T] |
| variable (G : Game U V E X Y) (ψLaw : FiniteDistribution (Emb (rankLength X T) N)) |
| variable (hYX : Fintype.card Y ≤ Fintype.card X) (fiber : E → X ≃ Y × Bool) |
| variable (ellU : U → X) (ellV : V → Y) |
|
|
| def labelDeleted : OutputVertex (M := M) G ψLaw → Bool := |
| fun v => decide (TestGraph.LabelDeleted (wildSupport G ψLaw hYX) |
| (compSupport G ψLaw fiber) ellU ellV v) |
|
|
| def labelFeedback : Finset (OutputVertex (M := M) G ψLaw) := |
| Finset.univ.filter (TestGraph.LabelDeleted (wildSupport G ψLaw hYX) |
| (compSupport G ψLaw fiber) ellU ellV) |
|
|
| theorem labelFeedback_spec : |
| FeedbackR (OutputArc G ψLaw hYX fiber) (labelFeedback (M := M) G ψLaw hYX fiber ellU ellV) := by |
| exact TestGraph.labelDeleted_feedback _ _ ellU ellV |
|
|
| theorem labelFeedback_indicator : |
| (fun v => decide (v ∈ labelFeedback (M := M) G ψLaw hYX fiber ellU ellV)) = |
| labelDeleted (M := M) G ψLaw hYX fiber ellU ellV := by |
| funext v |
| simp only [labelFeedback, Finset.mem_filter, Finset.mem_univ, true_and, labelDeleted] |
|
|
| theorem full_label_cost : |
| (fullLaw (M := M) G ψLaw).probability |
| (fullDeleted G ψLaw (labelDeleted (M := M) G ψLaw hYX fiber ellU ellV)) ≤ |
| M * Real.exp (-(lastBias M*T/(8*M))) := by |
| rw [fullDeleted, probability_extend] |
| have he : (fullLaw (M := M) G ψLaw).supported.probability (fun d => |
| labelDeleted (M := M) G ψLaw hYX fiber ellU ellV (.inr (.inl (.inl d)))) = |
| (fullLaw (M := M) G ψLaw).probability (fun d => |
| decide ((fun t => ellU (vertices d.2 t)) ∈ fullStars d.2)) := by |
| exact probability_supported (fullLaw (M := M) G ψLaw) |
| (fun d => decide ((fun t => ellU (vertices d.2 t)) ∈ fullStars d.2)) |
| rw [he] |
| exact fullStars_probability G ψLaw ellU |
|
|
| theorem big_label_cost : |
| Fintype.card X * (bigLaw (M := M) G ψLaw).probability |
| (bigDeleted G ψLaw (labelDeleted (M := M) G ψLaw hYX fiber ellU ellV)) = 1 := by |
| rw [bigDeleted, probability_extend] |
| have he : (bigLaw (M := M) G ψLaw).supported.probability (fun d => |
| labelDeleted (M := M) G ψLaw hYX fiber ellU ellV (.inr (.inl (.inr (.inl d))))) = |
| (bigLaw (M := M) G ψLaw).probability (fun d => decide (ellU d.2.1 = d.2.2.1)) := by |
| convert probability_supported (bigLaw (M := M) G ψLaw) |
| (fun d => decide (ellU d.2.1 = d.2.2.1)) using 1 |
| apply congrArg (fun f => (bigLaw (M := M) G ψLaw).supported.probability f) |
| funext d |
| apply Bool.eq_iff_iff.mpr |
| simp only [labelDeleted, decide_eq_true_eq] |
| change (ellU (Fin.snoc (α := fun _ => U) (vertices d.val.1.2.2) d.val.2.1 |
| (Fin.last d.val.1.2.1.val)) = d.val.2.2.1) ↔ _ |
| simp only [Fin.snoc_last] |
| rw [he, bigLaw, probability_eq_expect] |
| simp only [expectation_product] |
| simp_rw [← probability_eq_expect, labelOrder_label_probability, expectation_const] |
| have hc : (Fintype.card X:ℝ) ≠ 0 := by exact_mod_cast Fintype.card_ne_zero |
| field_simp |
|
|
| theorem small_label_cost : |
| Fintype.card Y * (smallLaw (M := M) G ψLaw).probability |
| (smallDeleted G ψLaw (labelDeleted (M := M) G ψLaw hYX fiber ellU ellV)) = 1 := by |
| rw [smallDeleted, probability_extend] |
| have he : (smallLaw (M := M) G ψLaw).supported.probability (fun d => |
| labelDeleted (M := M) G ψLaw hYX fiber ellU ellV (.inr (.inl (.inr (.inr d))))) = |
| (smallLaw (M := M) G ψLaw).probability (fun d => decide (ellV d.2.1 = d.2.2.1)) := by |
| exact probability_supported (smallLaw (M := M) G ψLaw) |
| (fun d => decide (ellV d.2.1 = d.2.2.1)) |
| rw [he, smallLaw, probability_eq_expect] |
| simp only [expectation_product] |
| simp_rw [← probability_eq_expect, labelOrder_label_probability, expectation_const] |
| have hc : (Fintype.card Y:ℝ) ≠ 0 := by exact_mod_cast Fintype.card_ne_zero |
| field_simp |
|
|
| include fiber in |
| theorem comparison_label_cost (hproject : ∀ e x, (fiber e x).1 = G.project e x) : |
| (comparisonLaw (M := M) G ψLaw).probability |
| (comparisonDeleted G ψLaw (labelDeleted (M := M) G ψLaw hYX fiber ellU ellV)) ≤ |
| 1-G.score ellU ellV := by |
| rw [comparisonDeleted, probability_extend] |
| have hm := probability_mono (μ := (comparisonLaw (M := M) G ψLaw).supported) |
| (event := fun d => labelDeleted (M := M) G ψLaw hYX fiber ellU ellV (.inr (.inr d))) |
| (event' := fun d => decide (G.project d.val.2.1 (ellU (G.left d.val.2.1)) ≠ ellV (G.right d.val.2.1))) (by |
| intro d hd |
| apply decide_eq_true |
| intro hs |
| have hi := comparison_label_increases G ψLaw fiber hproject ellU ellV d hs |
| have hd' : TestGraph.LabelDeleted (wildSupport G ψLaw hYX) |
| (compSupport G ψLaw fiber) ellU ellV (.inr (.inr d)) := of_decide_eq_true hd |
| exact not_le.mpr hi hd') |
| apply hm.trans_eq |
| have he := probability_supported (comparisonLaw (M := M) G ψLaw) |
| (fun d => decide (G.project d.2.1 (ellU (G.left d.2.1)) ≠ ellV (G.right d.2.1))) |
| rw [he, comparisonLaw, probability_eq_expect, expectation_sigma] |
| trans (common (M := M) G ψLaw).expectation (fun _ => |
| G.edgeLaw.probability (fun e => decide (G.project e (ellU (G.left e)) ≠ ellV (G.right e)))) |
| · apply expectation_congr |
| intro d |
| rw [expectation_product, probability_eq_expect] |
| apply expectation_congr |
| intro e |
| exact expectation_const ((uniform (Fin M)).sigma (fun i => |
| (uniform (Fin (cellCount d.2.1.val))).product |
| (Coupling.law (Y := Y) (bias i) (bias_pos i).le (by linarith [bias_le_quarter i])))) |
| (if decide (G.project e (ellU (G.left e)) ≠ ellV (G.right e)) then 1 else 0) |
| rw [expectation_const] |
| have hh := probability_not G.edgeLaw |
| (fun e => decide (G.project e (ellU (G.left e)) = ellV (G.right e))) |
| simpa only [decide_not, Game.score] using hh |
| |
| theorem weighted_completeness (hproject : ∀ e x, (fiber e x).1 = G.project e x) |
| (D H K : ℝ) (hH : 0 ≤ H) (hK : 0 ≤ K) : |
| totalDeletionCost G ψLaw D H K (labelDeleted (M := M) G ψLaw hYX fiber ellU ellV) ≤ |
| H * (M * Real.exp (-(lastBias M*T/(8*M)))) + 2 + K*(1-G.score ellU ellV) := by |
| rw [deletionCost_decomposition] |
| have hr : (∑ r : Rank U V X Y T N, |
| if labelDeleted (M := M) G ψLaw hYX fiber ellU ellV (.inl r) then D+1 else 0) = 0 := by |
| apply Finset.sum_eq_zero |
| intro r _ |
| have h : labelDeleted (M := M) G ψLaw hYX fiber ellU ellV (.inl r) = false := by |
| cases e : labelDeleted (M := M) G ψLaw hYX fiber ellU ellV (.inl r) with |
| | false => rfl |
| | true => exact False.elim (of_decide_eq_true e : TestGraph.LabelDeleted |
| (wildSupport G ψLaw hYX) (compSupport G ψLaw fiber) ellU ellV (.inl r)) |
| rw [h] |
| rfl |
| rw [hr, zero_add, big_label_cost, small_label_cost] |
| have hf := mul_le_mul_of_nonneg_left (full_label_cost (M := M) G ψLaw hYX fiber ellU ellV) hH |
| have hc := mul_le_mul_of_nonneg_left |
| (comparison_label_cost (M := M) G ψLaw hYX fiber ellU ellV hproject) hK |
| linarith |
| |
| end DirectedFeedback.Construction |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Construction |
| open Pivotal |
| |
| structure Parameters (D : ℕ) where |
| M : ℕ |
| T : ℕ |
| K : ℕ |
| J : ℕ |
| M_eq : M = 128*(D+1) |
| T_pos : 0 < T |
| K_pos : 0 < K |
| J_pos : 1 ≤ J |
| theta : ℚ |
| theta_pos : 0 < theta |
| theta_half : (theta : ℝ) < 1/2 |
| fullChernoff : (8*((D:ℝ)+1)) * (M * Real.exp (-(lastBias M*T/(8*M)))) ≤ 1 |
| comparison : (M:ℝ)*2^T*D/K ≤ lastBias M/1000 |
| junta : DyadicJuntaBound M (((D:ℝ)+1)/(lastBias M/1000)) (lastBias M/1000) J |
| Ktheta : (K:ℝ)*theta ≤ 1 |
| Jtheta : (theta:ℝ)*(J:ℝ)^2 ≤ lastBias M/1000 |
| |
| theorem exists_parameters (D : ℕ) : Nonempty (Parameters D) := by |
| let M := 128*(D+1) |
| let H : ℝ := 8*((D:ℝ)+1) |
| let p := lastBias M |
| let γ := p/1000 |
| have hM : (0:ℝ) < M := by dsimp [M]; positivity |
| have hH : 0 < H := by dsimp [H]; positivity |
| have hp : 0 < p := by dsimp [p, lastBias]; positivity |
| have hg : 0 < γ := by dsimp [γ]; positivity |
| obtain ⟨T, hT⟩ := exists_nat_gt (8*M*(H*M)/p) |
| have hT0 : 0 < T := by |
| have ht : (0:ℝ) < T := lt_of_le_of_lt (by positivity) hT |
| exact_mod_cast ht |
| have hprefix : H * (M * Real.exp (-(p*T/(8*M)))) ≤ 1 := by |
| have harg : H*M ≤ p*T/(8*M) := by |
| apply (le_div_iff₀ (by positivity)).mpr |
| have hh := (div_lt_iff₀ hp).mp hT |
| nlinarith |
| calc |
| _ = (H*M)/Real.exp (p*T/(8*M)) := by rw [Real.exp_neg]; ring |
| _ ≤ 1 := (div_le_one (Real.exp_pos _)).mpr |
| (harg.trans (by linarith [Real.add_one_le_exp (p*T/(8*M))])) |
| obtain ⟨K, hK⟩ := exists_nat_gt (max 0 ((M:ℝ)*2^T*D/γ)) |
| have hK0 : (0:ℝ) < K := lt_of_le_of_lt (le_max_left _ _) hK |
| have hKnat : 0 < K := by exact_mod_cast hK0 |
| have hcomparison : (M:ℝ)*2^T*D/K ≤ γ := by |
| apply (div_le_iff₀ hK0).mpr |
| have hh := (div_lt_iff₀ hg).mp (lt_of_le_of_lt (le_max_right _ _) hK) |
| linarith |
| obtain ⟨J,hJ,hjunta⟩ := uniform_dyadic_junta M (((D:ℝ)+1)/γ) γ (by positivity) hg |
| have hJ0 : (0:ℝ) < J := by exact_mod_cast (lt_of_lt_of_le Nat.zero_lt_one hJ) |
| let t : ℝ := min (1/4) (min (1/K) (γ/(J:ℝ)^2)) |
| have ht : 0 < t := by dsimp [t]; positivity |
| obtain ⟨θ,hθ0,hθ⟩ := exists_rat_btwn ht |
| have hθnat : (0:ℚ) < θ := by exact_mod_cast hθ0 |
| have ht1 : (θ:ℝ) < 1/4 := hθ.trans_le (min_le_left _ _) |
| have htK : (θ:ℝ) < 1/(K:ℝ) := hθ.trans_le ((min_le_right _ _).trans (min_le_left _ _)) |
| have htJ : (θ:ℝ) < γ/(J:ℝ)^2 := hθ.trans_le ((min_le_right _ _).trans (min_le_right _ _)) |
| refine ⟨⟨M,T,K,J,rfl,hT0,hKnat,hJ,θ,hθnat,by linarith,hprefix,hcomparison,hjunta,?_,?_⟩⟩ |
| · have hh := (lt_div_iff₀ hK0).mp htK |
| nlinarith |
| · exact ((lt_div_iff₀ (sq_pos_of_pos hJ0)).mp htJ).le |
| |
| namespace Parameters |
| variable {D : ℕ} (P : Parameters D) |
| |
| instance : NeZero P.M := ⟨by rw [P.M_eq]; omega⟩ |
| instance : NeZero P.T := ⟨ne_of_gt P.T_pos⟩ |
| |
| theorem gamma_pos : 0 < lastBias P.M/1000 := by unfold lastBias; positivity |
| |
| theorem gamma_le : lastBias P.M/1000 ≤ 1/1000 := by |
| have hp : lastBias P.M ≤ 1 := pow_le_one₀ (by norm_num) (by norm_num) |
| linarith |
| |
| theorem full_error (ρ : ℝ) (hρ : ρ ≤ lastBias P.M/1000) : |
| ρ + (D:ℝ)/(8*((D:ℝ)+1)) ≤ 1/2 := by |
| have hsmall : (D:ℝ)/(8*((D:ℝ)+1)) ≤ 1/8 := by |
| apply (div_le_iff₀ (by positivity)).mpr |
| nlinarith |
| linarith [P.gamma_le] |
| |
| theorem product_error (ρ : ℝ) (hρ : ρ ≤ lastBias P.M/1000) : |
| 2*ρ + P.M*(2:ℝ)^P.T*D/P.K + 6*(lastBias P.M/1000) + |
| (P.theta:ℝ)*(P.J:ℝ)^2 ≤ lastBias P.M/16 := by |
| have hp : 0 < lastBias P.M := by unfold lastBias; positivity |
| linarith [P.comparison,P.Jtheta] |
| |
| end Parameters |
| end DirectedFeedback.Construction |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Construction |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open RankGraph Prefix PrefixExperiment Games Pivotal Ranks |
| |
| structure RankParameters {D : ℕ} (P : Parameters D) (X : Type) [Fintype X] where |
| N : ℕ |
| law : FiniteDistribution (Emb (rankLength X P.T) N) |
| eta : ℝ |
| rho : ℝ |
| eta_pos : 0 < eta |
| rho_nonneg : 0 ≤ rho |
| rho_small : rho ≤ lastBias P.M/1000 |
| rho_alphabet : Fintype.card X * rho ≤ 1 |
| accuracy : 3*eta*(rankLength X P.T : ℝ)^3*2^((Fintype.card X)^P.T) ≤ rho |
| spreads : Spreads law eta |
| rational : ∀ ψ, ∃ q : ℚ, law.weight ψ = q |
| |
| theorem exists_rankParameters {D : ℕ} (P : Parameters D) (X : Type) |
| [Fintype X] [Nonempty X] : Nonempty (RankParameters P X) := by |
| let m : ℝ := Fintype.card X |
| let ρ := min (lastBias P.M/1000) (1/m) |
| let L := rankLength X P.T |
| let η := ρ / (3*(L:ℝ)^3*2^((Fintype.card X)^P.T)) |
| have hm : 0 < m := by dsimp [m]; exact_mod_cast Fintype.card_pos |
| have hρ : 0 < ρ := lt_min P.gamma_pos (div_pos (by norm_num) hm) |
| have hL : 3 ≤ L := by dsimp [L, rankLength]; omega |
| have hLc : (0:ℝ) < L := by exact_mod_cast (by omega : 0 < L) |
| have hη : 0 < η := by dsimp [η]; positivity |
| obtain ⟨N,_,μ,hs,hr⟩ := exists_spreading_law L hL η hη |
| refine ⟨⟨N,μ,η,ρ,hη,hρ.le,min_le_left _ _,?_,?_,hs,hr⟩⟩ |
| · have hh := min_le_right (lastBias P.M/1000) (1/m) |
| have hb := (le_div_iff₀ hm).mp hh |
| dsimp [m] at hb ⊢ |
| nlinarith |
| · dsimp only [η] |
| have hden : (3:ℝ)*(L:ℝ)^3*2^((Fintype.card X)^P.T) ≠ 0 := by positivity |
| field_simp |
| ring_nf |
| rfl |
| |
| variable {U V E X Y : Type} [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
| |
| end DirectedFeedback.Construction |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| end |
| |
| end OAI |
| |
