| import Mathlib |
| import OAI.Computability.DirectedFeedback.RankGraph.FailureEvent |
|
|
| 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 |
| namespace DirectedFeedback.Junta |
| open scoped BigOperators |
| open Finset DirectedFeedback.JuntaSupport DFVSMaxCut.BooleanFourthMoment |
| open DFVSMaxCut.Analytic |
|
|
| def roundBoolean {n : ℕ} (p : Cube (Fin n) → ℝ) (x : Cube (Fin n)) : ℝ := |
| if (1 : ℝ) / 2 ≤ p x then 1 else 0 |
|
|
| theorem roundBoolean_isBoolean {n : ℕ} (p : Cube (Fin n) → ℝ) : |
| IsBoolean (roundBoolean p) := by |
| intro x |
| unfold roundBoolean |
| split_ifs <;> simp |
|
|
| theorem roundBoolean_onCoordinates {n : ℕ} (J : Finset (Fin n)) |
| (p : Cube (Fin n) → ℝ) (hp : OnCoordinates J p) : OnCoordinates J (roundBoolean p) := by |
| intro x y h |
| unfold roundBoolean |
| rw [hp x y h] |
|
|
| theorem rounding_error_le {n : ℕ} (f p : Cube (Fin n) → ℝ) (hf : IsBoolean f) : |
| error f (roundBoolean p) ≤ 4 * (𝔼 x, (f x - p x) ^ 2) := by |
| unfold error |
| rw [Finset.mul_expect] |
| apply Finset.expect_le_expect |
| intro x _ |
| by_cases heq : f x = roundBoolean p x |
| · rw [ite_eq_left heq] |
| positivity |
| · rw [ite_eq_right heq] |
| rcases hf x with hf0 | hf1 |
| · have hp : (1 : ℝ) / 2 ≤ p x := by |
| by_contra h |
| exact heq (by rw [hf0]; unfold roundBoolean; rw [ite_eq_right h]) |
| rw [hf0] |
| nlinarith [sq_nonneg (p x - 1 / 2)] |
| · have hp : p x < (1 : ℝ) / 2 := by |
| by_contra h |
| exact heq (by rw [hf1]; unfold roundBoolean; rw [ite_eq_left (le_of_not_gt h)]) |
| rw [hf1] |
| nlinarith [sq_nonneg (p x - 1 / 2)] |
|
|
| theorem friedgut_uniform (b α : ℝ) (hb : 0 ≤ b) (hα : 0 < α) : |
| ∃ Jmax : ℕ, ∀ (n : ℕ) (f : Cube (Fin n) → ℝ), |
| IsBoolean f → totalInfluence f ≤ b → |
| ∃ J : Finset (Fin n), J.card ≤ Jmax ∧ |
| ∃ g : Cube (Fin n) → ℝ, IsBoolean g ∧ OnCoordinates J g ∧ error f g ≤ α := by |
| obtain ⟨K, hK⟩ := exists_nat_gt (2 * b / α) |
| have hKpos : (0 : ℝ) < K + 1 := by positivity |
| have hKb : 2 * b ≤ (K + 1 : ℝ) * α := by |
| have := (div_lt_iff₀ hα).mp hK |
| nlinarith |
| let τ : ℝ := α / (2 * 3 ^ K * (b + 1)) |
| have hb1 : 0 < b + 1 := by linarith |
| have hτ : 0 < τ := by dsimp [τ]; positivity |
| have hτid : (3 : ℝ) ^ K * τ * (b + 1) = α / 2 := by |
| dsimp [τ] |
| field_simp |
| have hτb : (3 : ℝ) ^ K * τ * b ≤ α / 2 := by |
| rw [← hτid] |
| exact mul_le_mul_of_nonneg_left (by linarith : b ≤ b + 1) (by positivity) |
| refine ⟨Nat.ceil (b / τ ^ 2), ?_⟩ |
| intro n f hf hIf |
| let J := highInfluences f τ |
| have hcard : (J.card : ℝ) ≤ b / τ ^ 2 := by |
| apply (le_div_iff₀ (sq_pos_of_pos hτ)).mpr |
| exact (highInfluences_card_bound f τ).trans hIf |
| refine ⟨J, ?_, roundBoolean (project J f), roundBoolean_isBoolean _, |
| roundBoolean_onCoordinates J _ (project_onCoordinates J f), ?_⟩ |
| · exact_mod_cast hcard.trans (Nat.le_ceil _) |
| · have htail := (spectral_tail f K).trans hIf |
| have htail' : 8 * |
| (∑ s ∈ Finset.univ.filter (fun s => K < degree s), coefficient f s ^ 2) ≤ α := by |
| apply (mul_le_mul_iff_of_pos_left hKpos).mp |
| nlinarith |
| have hlow := lowDiff_sum_outside f hf K τ hτ.le |
| have hlow' : 8 * (∑ i ∈ Finset.univ \ J, (𝔼 x, lowDiff f K i x ^ 2)) ≤ α := by |
| have hh := mul_le_mul_of_nonneg_left hIf (by positivity : 0 ≤ (3 : ℝ) ^ K * τ) |
| dsimp [J] |
| nlinarith |
| have hproject := project_squared_error_le J f K |
| have hround := rounding_error_le f (project J f) hf |
| linarith |
|
|
| def cubeEquiv {I J : Type*} (e : I ≃ J) : (I → Bool) ≃ (J → Bool) where |
| toFun x := fun j => x (e.symm j) |
| invFun y := fun i => y (e i) |
| left_inv x := by funext i; simp |
| right_inv y := by funext j; simp |
|
|
| theorem cubeEquiv_update {I J : Type*} [DecidableEq I] [DecidableEq J] |
| (e : I ≃ J) (x : I → Bool) (i : I) (a : Bool) : |
| cubeEquiv e (Function.update x i a) = Function.update (cubeEquiv e x) (e i) a := by |
| funext j |
| by_cases hj : j = e i |
| · subst j; simp [cubeEquiv] |
| · have hji : e.symm j ≠ i := by |
| intro heq |
| apply hj |
| simpa using congrArg e heq |
| simp [cubeEquiv, hj, hji] |
|
|
| def DependsOn {I : Type*} (J : Finset I) (f : (I → Bool) → ℝ) : Prop := |
| ∀ x y, (∀ i ∈ J, x i = y i) → f x = f y |
|
|
| def cubeInfluence {I : Type*} [Fintype I] [DecidableEq I] |
| (f : (I → Bool) → ℝ) (i : I) : ℝ := |
| 𝔼 x, (f x - f (Function.update x i (!x i))) ^ 2 |
|
|
| def cubeError {I : Type*} [Fintype I] [DecidableEq I] (f g : (I → Bool) → ℝ) : ℝ := |
| 𝔼 x, if f x = g x then 0 else 1 |
|
|
| theorem cubeInfluence_reindex {I J : Type*} [Fintype I] [Fintype J] |
| [DecidableEq I] [DecidableEq J] (e : I ≃ J) (f : (J → Bool) → ℝ) (i : I) : |
| cubeInfluence (fun x => f (cubeEquiv e x)) i = cubeInfluence f (e i) := by |
| apply Fintype.expect_equiv (cubeEquiv e) |
| intro x |
| simp only [cubeEquiv_update] |
| simp [cubeEquiv] |
|
|
| theorem friedgut_finite (b α : ℝ) (hb : 0 ≤ b) (hα : 0 < α) : |
| ∃ Jmax : ℕ, ∀ (I : Type) [Fintype I] [DecidableEq I] |
| (f : (I → Bool) → ℝ), |
| (∀ x, f x = 0 ∨ f x = 1) → (∑ i, cubeInfluence f i) ≤ b → |
| ∃ J : Finset I, J.card ≤ Jmax ∧ |
| ∃ g : (I → Bool) → ℝ, (∀ x, g x = 0 ∨ g x = 1) ∧ |
| DependsOn J g ∧ cubeError f g ≤ α := by |
| obtain ⟨Jmax, hJmax⟩ := friedgut_uniform b α hb hα |
| refine ⟨Jmax, ?_⟩ |
| intro I _ _ f hf hIf |
| let e : Fin (Fintype.card I) ≃ I := (Fintype.equivFin I).symm |
| let f' : Cube (Fin (Fintype.card I)) → ℝ := fun x => f (cubeEquiv e x) |
| have htrans : totalInfluence f' = ∑ i, cubeInfluence f i := by |
| unfold totalInfluence |
| change (∑ i, cubeInfluence (fun x => f (cubeEquiv e x)) i) = _ |
| simp_rw [cubeInfluence_reindex] |
| exact e.sum_comp (cubeInfluence f) |
| obtain ⟨J, hcard, g, hg, hdep, herr⟩ := |
| hJmax (Fintype.card I) f' (fun x => hf _) (htrans ▸ hIf) |
| refine ⟨J.map e.toEmbedding, by simpa using hcard, |
| (fun x => g (cubeEquiv e.symm x)), (fun x => hg _), ?_, ?_⟩ |
| · intro x y h |
| apply hdep |
| intro i hi |
| exact h (e i) (Finset.mem_map.mpr ⟨i, hi, rfl⟩) |
| · have heq : cubeError f (fun x => g (cubeEquiv e.symm x)) = error f' g := by |
| unfold cubeError error |
| apply Fintype.expect_equiv (cubeEquiv e.symm) |
| intro x |
| have hx : cubeEquiv e (cubeEquiv e.symm x) = x := by funext i; simp [cubeEquiv] |
| change (if f x = g (cubeEquiv e.symm x) then (0 : ℝ) else 1) = |
| (if f (cubeEquiv e (cubeEquiv e.symm x)) = g (cubeEquiv e.symm x) then 0 else 1) |
| rw [hx] |
| exact heq ▸ herr |
|
|
| end DirectedFeedback.Junta |
|
|
| namespace DirectedFeedback.Junta |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open DirectedFeedback.Probability |
|
|
| variable {I : Type} [Fintype I] [DecidableEq I] |
|
|
| def merge (J : Finset I) (x y : I → Bool) : I → Bool := |
| fun i => if i ∈ J then x i else y i |
|
|
| def swapOutside (J : Finset I) : ((I → Bool) × (I → Bool)) ≃ ((I → Bool) × (I → Bool)) where |
| toFun p := (merge J p.1 p.2, merge J p.2 p.1) |
| invFun p := (merge J p.1 p.2, merge J p.2 p.1) |
| left_inv p := by ext i <;> by_cases hi : i ∈ J <;> simp [merge, hi] |
| right_inv p := by ext i <;> by_cases hi : i ∈ J <;> simp [merge, hi] |
|
|
| theorem expect_merge (J : Finset I) (h : (I → Bool) → ℝ) : |
| (𝔼 x, 𝔼 y, h (merge J x y)) = 𝔼 x, h x := by |
| calc |
| _ = 𝔼 p : (I → Bool) × (I → Bool), h (merge J p.1 p.2) := by |
| rw [← Finset.expect_product']; simp |
| _ = 𝔼 p : (I → Bool) × (I → Bool), h p.1 := by |
| exact (Fintype.expect_equiv (swapOutside J) (fun p => h p.1) |
| (fun p => h (merge J p.1 p.2)) (by |
| intro p |
| congr 1 |
| funext i |
| by_cases hi : i ∈ J <;> simp [swapOutside, merge, hi])).symm |
| _ = _ := by rw [← Finset.univ_product_univ, Finset.expect_product]; simp |
| |
| def disagree (a b : ℝ) : ℝ := if a = b then 0 else 1 |
| |
| theorem disagree_triangle (a b c : ℝ) : disagree a c ≤ disagree a b + disagree b c := by |
| by_cases hab : a = b |
| · subst b; simp [disagree] |
| by_cases hbc : b = c |
| · subst c; simp [disagree] |
| simp only [disagree, ite_eq_right hab, ite_eq_right hbc] |
| split_ifs <;> norm_num |
| |
| theorem restriction_approximation (J : Finset I) (f h : (I → Bool) → ℝ) |
| (hh : DependsOn J h) : |
| ∃ y, cubeError f (fun x => f (merge J x y)) ≤ 2 * cubeError f h := by |
| have hdep (x y : I → Bool) : h x = h (merge J x y) := by |
| apply hh |
| intro i hi |
| simp [merge, hi] |
| have hbound : (𝔼 y, cubeError f (fun x => f (merge J x y))) ≤ 2 * cubeError f h := by |
| unfold cubeError |
| change (𝔼 y, 𝔼 x, disagree (f x) (f (merge J x y))) ≤ _ |
| calc |
| _ ≤ 𝔼 y, 𝔼 x, (disagree (f x) (h x) + disagree (f (merge J x y)) (h (merge J x y))) := by |
| apply Finset.expect_le_expect |
| intro y _ |
| apply Finset.expect_le_expect |
| intro x _ |
| have ht := disagree_triangle (f x) (h x) (f (merge J x y)) |
| simpa [hdep x y, disagree, eq_comm] using ht |
| _ = (𝔼 x, disagree (f x) (h x)) + (𝔼 y, 𝔼 x, |
| disagree (f (merge J x y)) (h (merge J x y))) := by |
| simp_rw [Finset.expect_add_distrib] |
| simp |
| _ = _ := by |
| rw [Finset.expect_comm] |
| rw [expect_merge J (fun z => disagree (f z) (h z))] |
| change cubeError f h + cubeError f h = 2 * cubeError f h |
| ring |
| obtain ⟨y, _, hy⟩ := Finset.exists_le_of_expect_le Finset.univ_nonempty hbound |
| exact ⟨y, hy⟩ |
| |
| end DirectedFeedback.Junta |
| |
| namespace DirectedFeedback.Junta |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open DirectedFeedback.Probability |
| variable {I : Type} [Fintype I] [DecidableEq I] |
| |
| def flatAnd {k : ℕ} (x : I × Fin k → Bool) : I → Bool := |
| fun i => andBit (fun a => x (i, a)) |
| |
| theorem flatAnd_expectation (k : ℕ) (f : (I → Bool) → ℝ) : |
| (𝔼 x : I × Fin k → Bool, f (flatAnd x)) = (dyadicLaw I k).expectation f := by |
| rw [← blockAnd_expectation] |
| apply Fintype.expect_equiv (Equiv.curry I (Fin k) Bool) |
| intro x |
| rfl |
| |
| def biasedInfluence (k : ℕ) (f : (I → Bool) → ℝ) (i : I) : ℝ := |
| (dyadicLaw I k).expectation (fun x => (f x - f (Function.update x i (!x i))) ^ 2) |
| |
| omit [Fintype I] in |
| theorem flatAnd_update_other {k : ℕ} (x : I × Fin k → Bool) (q : I × Fin k) |
| (i : I) (hi : i ≠ q.1) : |
| flatAnd (Function.update x q (!x q)) i = flatAnd x i := by |
| unfold flatAnd |
| congr 1 |
| funext a |
| have hia : (i, a) ≠ q := fun h => hi (congrArg Prod.fst h) |
| simp [hia] |
| |
| omit [Fintype I] in |
| theorem flatAnd_update_cases {k : ℕ} (x : I × Fin k → Bool) (q : I × Fin k) : |
| flatAnd (Function.update x q (!x q)) = flatAnd x ∨ |
| flatAnd (Function.update x q (!x q)) = |
| Function.update (flatAnd x) q.1 (!(flatAnd x q.1)) := by |
| by_cases h : flatAnd (Function.update x q (!x q)) q.1 = flatAnd x q.1 |
| · left |
| funext i |
| by_cases hi : i = q.1 |
| · simpa [hi] using h |
| · exact flatAnd_update_other x q i hi |
| · right |
| funext i |
| by_cases hi : i = q.1 |
| · subst i |
| simp only [Function.update_self] |
| cases ha : flatAnd (Function.update x q (!x q)) q.1 <;> |
| cases hb : flatAnd x q.1 <;> simp_all |
| · rw [Function.update_of_ne hi] |
| exact flatAnd_update_other x q i hi |
| |
| theorem flatAnd_influence_le (k : ℕ) (f : (I → Bool) → ℝ) (q : I × Fin k) : |
| cubeInfluence (fun x => f (flatAnd x)) q ≤ biasedInfluence k f q.1 := by |
| unfold cubeInfluence biasedInfluence |
| rw [← flatAnd_expectation k] |
| apply Finset.expect_le_expect |
| intro x _ |
| dsimp only |
| obtain h | h := flatAnd_update_cases x q |
| · simp only [h, sub_self, zero_pow (by decide : 2 ≠ 0)] |
| exact sq_nonneg _ |
| · rw [h] |
| |
| theorem flatAnd_totalInfluence_le (k : ℕ) (f : (I → Bool) → ℝ) : |
| (∑ q : I × Fin k, cubeInfluence (fun x => f (flatAnd x)) q) ≤ |
| k * ∑ i, biasedInfluence k f i := by |
| calc |
| _ ≤ ∑ q : I × Fin k, biasedInfluence k f q.1 := |
| Finset.sum_le_sum (fun q _ => flatAnd_influence_le k f q) |
| _ = _ := by |
| rw [Fintype.sum_prod_type] |
| simp [← Finset.mul_sum] |
| |
| theorem friedgut_dyadic (k : ℕ) (b α : ℝ) (hb : 0 ≤ b) (hα : 0 < α) : |
| ∃ Jmax : ℕ, ∀ (I : Type) [Fintype I] [DecidableEq I] (f : (I → Bool) → ℝ), |
| (∀ x, f x = 0 ∨ f x = 1) → (∑ i, biasedInfluence k f i) ≤ b → |
| ∃ J : Finset I, J.card ≤ Jmax ∧ ∃ g : (I → Bool) → ℝ, |
| (∀ x, g x = 0 ∨ g x = 1) ∧ DependsOn J g ∧ |
| (dyadicLaw I k).expectation (fun x => disagree (f x) (g x)) ≤ α := by |
| obtain ⟨Jmax, hJmax⟩ := friedgut_finite (k * b) (α / 2) (mul_nonneg (Nat.cast_nonneg _) hb) |
| (by positivity) |
| refine ⟨Jmax, ?_⟩ |
| intro I _ _ f hf hIf |
| let F : (I × Fin k → Bool) → ℝ := fun x => f (flatAnd x) |
| have hIF : (∑ q, cubeInfluence F q) ≤ k * b := |
| (flatAnd_totalInfluence_le k f).trans (mul_le_mul_of_nonneg_left hIf (Nat.cast_nonneg _)) |
| obtain ⟨L, hL, H, _, hH, herror⟩ := hJmax (I × Fin k) F (fun x => hf _) hIF |
| let J : Finset I := L.image Prod.fst |
| let K : Finset (I × Fin k) := Finset.univ.filter (fun q => q.1 ∈ J) |
| have hHK : DependsOn K H := by |
| intro x y hxy |
| apply hH |
| intro q hq |
| apply hxy |
| simp only [K, Finset.mem_filter, Finset.mem_univ, true_and] |
| exact Finset.mem_image.mpr ⟨q, hq, rfl⟩ |
| obtain ⟨y, hy⟩ := restriction_approximation K F H hHK |
| let g : (I → Bool) → ℝ := fun z => f (merge J z (flatAnd y)) |
| have hmerge (x : I × Fin k → Bool) : |
| flatAnd (merge K x y) = merge J (flatAnd x) (flatAnd y) := by |
| funext i |
| by_cases hi : i ∈ J <;> simp [flatAnd, merge, K, hi] |
| refine ⟨J, (Finset.card_image_le).trans hL, g, (fun x => hf _), ?_, ?_⟩ |
| · intro x z hxz |
| apply congrArg f |
| funext i |
| by_cases hi : i ∈ J |
| · simp [merge, hi, hxz i hi] |
| · simp [merge, hi] |
| · have heq : cubeError F (fun x => F (merge K x y)) = |
| (dyadicLaw I k).expectation (fun z => disagree (f z) (g z)) := by |
| unfold cubeError |
| change (𝔼 x, disagree (F x) (F (merge K x y))) = _ |
| simp only [F, hmerge] |
| exact flatAnd_expectation k (fun z => disagree (f z) (g z)) |
| rw [heq] at hy |
| linarith |
| |
| end DirectedFeedback.Junta |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Pivotal |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open DirectedFeedback.Probability |
| variable {I : Type} [Fintype I] [DecidableEq I] |
| |
| theorem bitValue_boolean (b : Bool) : bitValue b = 0 ∨ bitValue b = 1 := by |
| cases b <;> simp [bitValue] |
| |
| theorem dyadic_coin (k : ℕ) : |
| andCoin k = coin ((2 : ℝ)⁻¹ ^ k) (by positivity) |
| (pow_le_one₀ (by norm_num) (by norm_num)) := by |
| apply eq_of_weight_eq |
| intro b |
| cases b |
| · exact andCoin_false k |
| · exact andCoin_true k |
| |
| theorem dyadic_law (k : ℕ) : |
| dyadicLaw I k = law ((2 : ℝ)⁻¹ ^ k) (by positivity) |
| (pow_le_one₀ (by norm_num) (by norm_num)) := by |
| simp only [dyadicLaw, law, dyadic_coin] |
| |
| omit [Fintype I] in |
| theorem update_insertBit (j : I) (b : Bool) (x : {i : I // i ≠ j} → Bool) : |
| Function.update (insertBit j b x) j (!b) = insertBit j (!b) x := by |
| funext i |
| by_cases hi : i = j |
| · subst i; simp |
| · simp [insertBit, hi] |
| |
| theorem prod_insertBit (p : ℝ) (j : I) (b : Bool) (x : {i : I // i ≠ j} → Bool) : |
| (∏ i, atom p (insertBit j b x i)) = atom p b * ∏ i : {i : I // i ≠ j}, atom p (x i) := by |
| rw [← Finset.mul_prod_erase _ _ (Finset.mem_univ j)] |
| rw [insertBit_self, prod_except] |
| simp only [insertBit_other] |
| |
| omit [Fintype I] in |
| theorem flip_square (f : (I → Bool) → Bool) (hf : Monotone f) |
| (j : I) (b : Bool) (x : {i : I // i ≠ j} → Bool) : |
| (bitValue (f (insertBit j b x)) - |
| bitValue (f (Function.update (insertBit j b x) j (!(insertBit j b x j)))))^2 = |
| discreteDerivative f j x := by |
| rw [insertBit_self, update_insertBit, discreteDerivative_eq_indicator f hf] |
| have hm : f (insertBit j false x) ≤ f (insertBit j true x) := by |
| apply hf |
| intro i |
| by_cases hi : i = j |
| · subst i; simp |
| · simp [insertBit, hi] |
| cases b <;> cases h0 : f (insertBit j false x) <;> cases h1 : f (insertBit j true x) <;> |
| simp_all [bitValue, pivotalEvent, Bool.le_iff_imp] |
| |
| theorem biasedInfluence_eq (k : ℕ) (f : (I → Bool) → Bool) (hf : Monotone f) (j : I) : |
| Junta.biasedInfluence k (fun x => bitValue (f x)) j = |
| ∑ x : {i : I // i ≠ j} → Bool, |
| (∏ i, atom ((2 : ℝ)⁻¹^k) (x i)) * discreteDerivative f j x := by |
| unfold Junta.biasedInfluence |
| rw [dyadic_law] |
| change (∑ x, (∏ i, atom ((2 : ℝ)⁻¹^k) (x i)) * |
| (bitValue (f x) - bitValue (f (Function.update x j (!(x j)))))^2) = _ |
| rw [sum_split j] |
| apply Finset.sum_congr rfl |
| intro x _ |
| rw [prod_insertBit, prod_insertBit, flip_square f hf, flip_square f hf] |
| simp only [atom, Bool.false_eq_true, ↓reduceIte] |
| ring |
| |
| theorem dyadic_influences_le_budget (k : ℕ) (f : (I → Bool) → Bool) (hf : Monotone f) : |
| (∑ j, Junta.biasedInfluence k (fun x => bitValue (f x)) j) ≤ budget f := by |
| simp_rw [biasedInfluence_eq k f hf] |
| exact influence_le_budget f hf _ (by positivity) (pow_le_one₀ (by norm_num) (by norm_num)) |
| |
| theorem boolean_dyadic_junta (k : ℕ) (B γ : ℝ) (hB : 0 ≤ B) (hγ : 0 < γ) : |
| ∃ Jmax : ℕ, ∀ (I : Type) [Fintype I] [DecidableEq I] (f : (I → Bool) → Bool), |
| Monotone f → budget f ≤ B → |
| ∃ J : Finset I, J.card ≤ Jmax ∧ ∃ g : (I → Bool) → Bool, |
| (∀ x y, (∀ i ∈ J, x i = y i) → g x = g y) ∧ |
| (law ((2 : ℝ)⁻¹^k) (by positivity) (pow_le_one₀ (by norm_num) (by norm_num))).probability |
| (fun x => decide (f x ≠ g x)) ≤ γ := by |
| obtain ⟨Jmax, hJmax⟩ := Junta.friedgut_dyadic k B γ hB hγ |
| refine ⟨Jmax, ?_⟩ |
| intro I _ _ f hf hbf |
| obtain ⟨J,hJ,g,hg,hdep,herr⟩ := hJmax I (fun x => bitValue (f x)) |
| (fun x => bitValue_boolean (f x)) ((dyadic_influences_le_budget k f hf).trans hbf) |
| let g' : (I → Bool) → Bool := fun x => decide (g x = 1) |
| refine ⟨J,hJ,g',?_,?_⟩ |
| · intro x y hxy |
| simp only [g', hdep x y hxy] |
| · rw [probability_eq_expectation, ← dyadic_law] |
| convert herr using 1 |
| apply expectation_congr |
| intro x |
| obtain hx | hx := hg x <;> cases hfx : f x <;> |
| simp [g', Junta.disagree, bitValue, hx] |
| |
| end DirectedFeedback.Pivotal |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Pivotal |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| |
| def DyadicJuntaBound (M : ℕ) (B γ : ℝ) (Jmax : ℕ) : Prop := |
| ∀ k : Fin (M+2), ∀ (I : Type) [Fintype I] [DecidableEq I] (f : (I → Bool) → Bool), |
| Monotone f → budget f ≤ B → |
| ∃ J : Finset I, J.card ≤ Jmax ∧ ∃ g : (I → Bool) → Bool, |
| (∀ x y, (∀ i ∈ J, x i = y i) → g x = g y) ∧ |
| (law ((2:ℝ)⁻¹^k.val) (by positivity) |
| (pow_le_one₀ (by norm_num) (by norm_num))).probability |
| (fun x => decide (f x ≠ g x)) ≤ γ |
| |
| theorem uniform_dyadic_junta (M : ℕ) (B γ : ℝ) (hB : 0 ≤ B) (hγ : 0 < γ) : |
| ∃ Jmax : ℕ, 1 ≤ Jmax ∧ DyadicJuntaBound M B γ Jmax := by |
| have h := fun k : Fin (M+2) => boolean_dyadic_junta k.val B γ hB hγ |
| choose J hJ using h |
| refine ⟨1 + ∑ k, J k, by omega, ?_⟩ |
| intro k I _ _ f hf hb |
| obtain ⟨S,hS,g,hg,herr⟩ := hJ k I f hf hb |
| refine ⟨S, ?_,g,hg,herr⟩ |
| have hh : J k ≤ ∑ j : Fin (M+2), J j := |
| Finset.single_le_sum (fun _ _ => Nat.zero_le _) (Finset.mem_univ k) |
| omega |
| |
| theorem family_dyadic_junta {M Jmax : ℕ} {B γ : ℝ} |
| (hJ : DyadicJuntaBound M B γ Jmax) (k : Fin (M+2)) |
| {Ω U I : Type} [Fintype I] [DecidableEq I] |
| (f : Ω → U → (I → Bool) → Bool) (hf : ∀ ω u, Monotone (f ω u)) : |
| ∃ (S : Ω → U → Finset I) (g : Ω → U → (I → Bool) → Bool), |
| (∀ ω u, (S ω u).card ≤ Jmax) ∧ |
| (∀ ω u x y, (∀ i ∈ S ω u, x i = y i) → g ω u x = g ω u y) ∧ |
| (∀ ω u, budget (f ω u) ≤ B → |
| (law ((2:ℝ)⁻¹^k.val) (by positivity) |
| (pow_le_one₀ (by norm_num) (by norm_num))).probability |
| (fun x => decide (f ω u x ≠ g ω u x)) ≤ γ) := by |
| have hex (ω : Ω) (u : U) : ∃ S : Finset I, S.card ≤ Jmax ∧ |
| ∃ g : (I → Bool) → Bool, |
| (∀ x y, (∀ i ∈ S, x i = y i) → g x = g y) ∧ |
| (budget (f ω u) ≤ B → |
| (law ((2:ℝ)⁻¹^k.val) (by positivity) |
| (pow_le_one₀ (by norm_num) (by norm_num))).probability |
| (fun x => decide (f ω u x ≠ g x)) ≤ γ) := by |
| by_cases hb : budget (f ω u) ≤ B |
| · obtain ⟨S,hS,g,hg,herr⟩ := hJ k I (f ω u) (hf ω u) hb |
| exact ⟨S,hS,g,hg,fun _ => herr⟩ |
| · exact ⟨∅,by simp,fun _ => false,by simp,fun h => (hb h).elim⟩ |
| choose S hS g hg herr using hex |
| exact ⟨S,g,hS,hg,herr⟩ |
| |
| end DirectedFeedback.Pivotal |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Coupling |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| variable {X Y : Type*} [Fintype X] [Fintype Y] |
| |
| theorem product_pattern_lipschitz {a b c d ε δ : ℝ} |
| (hb : 0 ≤ b) (hc : 0 ≤ c) (hc1 : c ≤ 1) |
| (hb1 : b ≤ 1) (hε : |a-c| ≤ ε) (hδ : |b-d| ≤ δ) : |
| |a*(1-b)-c*(1-d)| ≤ ε + δ := by |
| have hε0 : 0 ≤ ε := (abs_nonneg _).trans hε |
| have hδ0 : 0 ≤ δ := (abs_nonneg _).trans hδ |
| calc |
| _ = |(a-c)*(1-b) + c*(d-b)| := by congr 1; ring |
| _ ≤ |a-c| *|1-b| + |c| *|d-b| := by simpa only [abs_mul] using abs_add_le ((a-c)*(1-b)) (c*(d-b)) |
| _ = |a-c| *(1-b) + c*|b-d| := by rw [abs_of_nonneg (by linarith : 0 ≤ 1-b), abs_of_nonneg hc, abs_sub_comm d b] |
| _ ≤ ε*(1-b) + c*δ := add_le_add (mul_le_mul_of_nonneg_right hε (by linarith)) |
| (mul_le_mul_of_nonneg_left hδ hc) |
| _ ≤ ε + δ := by nlinarith [mul_nonneg hε0 hb, mul_nonneg (sub_nonneg.mpr hc1) hδ0] |
| |
| theorem comparison_juntas (e : X ≃ Y × Bool) (p : ℝ) (hp0 : 0 ≤ p) (hp : p ≤ 1/2) |
| (J : Finset X) (K : Finset Y) (hJK : Disjoint (J.image (fun x => (e x).1)) K) |
| (f f' : (X → Bool) → Bool) (g g' : (Y → Bool) → Bool) |
| (hf' : Uses J f') (hg' : Uses K g') (γ : ℝ) |
| (hf : (Pivotal.law p hp0 (by linarith)).probability (fun x => decide (f x ≠ f' x)) ≤ γ) (hg : (Pivotal.law (2*p) (by positivity) (by linarith)).probability (fun y => decide (g y ≠ g' y)) ≤ γ) : |
| |(Pivotal.law p hp0 (by linarith)).probability f * |
| (1 - (Pivotal.law (2*p) (by positivity) (by linarith)).probability g) - |
| (law p hp0 hp).probability (fun z => f (bigBits e z) && !(g (smallBits z)))| ≤ 4*γ := by |
| let μ := Pivotal.law (I := X) p hp0 (by linarith) |
| let ν := Pivotal.law (I := Y) (2*p) (by positivity) (by linarith) |
| let ρ := law (Y := Y) p hp0 hp |
| have hprod : |μ.probability f * (1-ν.probability g) - |
| μ.probability f' * (1-ν.probability g')| ≤ 2*γ := by |
| have h := product_pattern_lipschitz (probability_nonnegative ν g) |
| (probability_nonnegative μ f') (probability_le_one μ f') (probability_le_one ν g) |
| ((probability_abs_sub_le_disagree μ f f').trans hf) ((probability_abs_sub_le_disagree ν g g').trans hg) |
| linarith |
| have hc := pair_event_disagree ρ (fun z => f (bigBits e z)) (fun z => f' (bigBits e z)) (fun z => !(g (smallBits z))) (fun z => !(g' (smallBits z))) |
| have hnot : (fun z : Y → Block => decide ((!g (smallBits z)) ≠ (!g' (smallBits z)))) = fun z => decide (g (smallBits z) ≠ g' (smallBits z)) := by |
| funext z; simp |
| rw [hnot] at hc |
| change |_ - _| ≤ (law p hp0 hp).probability (fun z => (fun x => decide (f x ≠ f' x)) (bigBits e z)) + (law p hp0 hp).probability (fun z => (fun y => decide (g y ≠ g' y)) (smallBits z)) at hc |
| rw [big_probability e p hp0 hp (fun x => decide (f x ≠ f' x)), small_probability p hp0 hp (fun y => decide (g y ≠ g' y))] at hc |
| have hcc : |ρ.probability (fun z => f (bigBits e z) && !(g (smallBits z))) - |
| ρ.probability (fun z => f' (bigBits e z) && !(g' (smallBits z)))| ≤ 2*γ := by |
| linarith |
| have heq := disjoint_pattern e p hp0 hp J K hJK f' g' hf' hg' |
| change ρ.probability (fun z => f' (bigBits e z) && !(g' (smallBits z))) = |
| μ.probability f' * (1 - ν.probability g') at heq |
| change |μ.probability f * (1-ν.probability g) - |
| ρ.probability (fun z => f (bigBits e z) && !(g (smallBits z)))| ≤ _ |
| calc |
| _ ≤ |μ.probability f * (1-ν.probability g) - μ.probability f' * (1-ν.probability g')| + |
| |μ.probability f' * (1-ν.probability g') - |
| ρ.probability (fun z => f (bigBits e z) && !(g (smallBits z)))| := abs_sub_le _ _ _ |
| _ ≤ 4*γ := by |
| have hc' : |μ.probability f' * (1-ν.probability g') - ρ.probability (fun z => f (bigBits e z) && !(g (smallBits z)))| ≤ 2*γ := by rw [← heq, abs_sub_comm] |
| exact hcc |
| linarith |
|
|
| end DirectedFeedback.Coupling |
|
|
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Soundness |
| open DirectedFeedback.SourceProbability FiniteDistribution |
| open Games |
| variable {Ω U V E X Y : Type} [Fintype Ω] [Fintype U] [Fintype V] [Fintype E] |
| [Fintype X] [Fintype Y] [Nonempty X] [Nonempty Y] |
|
|
| theorem averaged_comparison (μ : FiniteDistribution Ω) (G : Game U V E X Y) |
| (θ : ℝ) (hsound : G.Sound θ) (fiber : E → X ≃ Y × Bool) |
| (hproj : ∀ e x, (fiber e x).1 = G.project e x) |
| (p γ C : ℝ) (hp0 : 0 ≤ p) (hp : p ≤ 1/2) (hγ : 0 < γ) (hC : 0 < C) |
| (f : Ω → U → (X → Bool) → Bool) (g : Ω → V → (Y → Bool) → Bool) |
| (Bu : Ω → U → ℝ) (Bv : Ω → V → ℝ) |
| (hBu0 : ∀ ω u, 0 ≤ Bu ω u) (hBv0 : ∀ ω v, 0 ≤ Bv ω v) |
| (hBu : (μ.product G.edgeLaw).expectation (fun a => Bu a.1 (G.left a.2)) ≤ C) |
| (hBv : (μ.product G.edgeLaw).expectation (fun a => Bv a.1 (G.right a.2)) ≤ C) |
| (J : ℕ) (hJ : 1 ≤ J) (Ju : Ω → U → Finset X) (Jv : Ω → V → Finset Y) |
| (f' : Ω → U → (X → Bool) → Bool) (g' : Ω → V → (Y → Bool) → Bool) |
| (hJu : ∀ ω u, (Ju ω u).card ≤ J) (hJv : ∀ ω v, (Jv ω v).card ≤ J) |
| (hf' : ∀ ω u, Uses (Ju ω u) (f' ω u)) (hg' : ∀ ω v, Uses (Jv ω v) (g' ω v)) |
| (hf : ∀ ω u, Bu ω u ≤ C/γ → |
| (Pivotal.law p hp0 (by linarith)).probability (fun x => decide (f ω u x ≠ f' ω u x)) ≤ γ) |
| (hg : ∀ ω v, Bv ω v ≤ C/γ → |
| (Pivotal.law (2*p) (by positivity) (by linarith)).probability |
| (fun y => decide (g ω v y ≠ g' ω v y)) ≤ γ) : |
| (μ.product G.edgeLaw).expectation (fun a => |
| (Pivotal.law p hp0 (by linarith)).probability (f a.1 (G.left a.2)) * |
| (1 - (Pivotal.law (2*p) (by positivity) (by linarith)).probability (g a.1 (G.right a.2)))) ≤ |
| (μ.product G.edgeLaw).expectation (fun a => |
| (Coupling.law p hp0 hp).probability (fun z => |
| f a.1 (G.left a.2) (Coupling.bigBits (fiber a.2) z) && |
| !(g a.1 (G.right a.2) (Coupling.smallBits z)))) + 2*γ + θ*(J:ℝ)^2 + 4*γ := by |
| let μc := μ.product G.edgeLaw |
| let bU : Ω × E → Bool := fun a => decide (C/γ < Bu a.1 (G.left a.2)) |
| let bV : Ω × E → Bool := fun a => decide (C/γ < Bv a.1 (G.right a.2)) |
| let meet : Ω × E → Bool := fun a => |
| decide (∃ x ∈ Ju a.1 (G.left a.2), G.project a.2 x ∈ Jv a.1 (G.right a.2)) |
| have hU : μc.probability bU ≤ γ := by |
| have hh := markov_bound μc (fun a => Bu a.1 (G.left a.2)) (fun a => hBu0 _ _) |
| (C/γ) (div_pos hC hγ) |
| have he : C / (C/γ) = γ := by field_simp |
| exact hh.trans ((div_le_div_of_nonneg_right hBu (by positivity)).trans_eq he) |
| have hV : μc.probability bV ≤ γ := by |
| have hh := markov_bound μc (fun a => Bv a.1 (G.right a.2)) (fun a => hBv0 _ _) |
| (C/γ) (div_pos hC hγ) |
| have he : C / (C/γ) = γ := by field_simp |
| exact hh.trans ((div_le_div_of_nonneg_right hBv (by positivity)).trans_eq he) |
| have hmeet : μc.probability meet ≤ θ*(J:ℝ)^2 := by |
| rw [probability_eq_expect, expectation_product] |
| simp_rw [← probability_eq_expect] |
| change μ.expectation (fun ω => G.edgeLaw.probability (fun e => |
| decide (∃ x ∈ Ju ω (G.left e), G.project e x ∈ Jv ω (G.right e)))) ≤ _ |
| calc |
| _ ≤ μ.expectation (fun _ => θ*(J:ℝ)^2) := expectation_mono _ |
| (fun ω => list_decoding G θ hsound (Ju ω) (Jv ω) J hJ (hJu ω) (hJv ω)) |
| _ = _ := expectation_const _ _ |
| let A : Ω × E → ℝ := fun a => |
| (Pivotal.law p hp0 (by linarith)).probability (f a.1 (G.left a.2)) * |
| (1 - (Pivotal.law (2*p) (by positivity) (by linarith)).probability (g a.1 (G.right a.2))) |
| let B : Ω × E → ℝ := fun a => |
| (Coupling.law p hp0 hp).probability (fun z => f a.1 (G.left a.2) (Coupling.bigBits (fiber a.2) z) && |
| !(g a.1 (G.right a.2) (Coupling.smallBits z))) |
| have hA1 (a : Ω × E) : A a ≤ 1 := by |
| have h0 := probability_nonnegative (Pivotal.law (I := Y) (2*p) (by positivity) (by linarith)) |
| (g a.1 (G.right a.2)) |
| have h1 := probability_le_one (Pivotal.law (I := Y) (2*p) (by positivity) (by linarith)) |
| (g a.1 (G.right a.2)) |
| have hh := probability_le_one (Pivotal.law (I := X) p hp0 (by linarith)) (f a.1 (G.left a.2)) |
| exact (mul_le_mul_of_nonneg_right hh (by linarith)).trans (by simpa using h0) |
| have hB0 (a : Ω × E) : 0 ≤ B a := probability_nonnegative _ _ |
| have hpoint (a : Ω × E) : A a ≤ B a + 4*γ + |
| (if bU a then 1 else 0) + (if bV a then 1 else 0) + (if meet a then 1 else 0) := by |
| by_cases hu : Bu a.1 (G.left a.2) ≤ C/γ |
| · by_cases hv : Bv a.1 (G.right a.2) ≤ C/γ |
| · by_cases hm : ∃ x ∈ Ju a.1 (G.left a.2), G.project a.2 x ∈ Jv a.1 (G.right a.2) |
| · simp only [bU, bV, meet, not_lt.mpr hu, not_lt.mpr hv, hm, decide_false, decide_true, |
| Bool.false_eq_true, ↓reduceIte, add_zero] |
| linarith [hA1 a, hB0 a] |
| · have hd : Disjoint ((Ju a.1 (G.left a.2)).image (fun x => (fiber a.2 x).1)) |
| (Jv a.1 (G.right a.2)) := by |
| rw [Finset.disjoint_left] |
| intro y hy hy' |
| obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hy |
| exact hm ⟨x,hx, by simpa [hproj] using hy'⟩ |
| have hh := Coupling.comparison_juntas (fiber a.2) p hp0 hp _ _ hd _ _ _ _ |
| (hf' _ _) (hg' _ _) γ (hf _ _ hu) (hg _ _ hv) |
| have hh' : A a - B a ≤ 4*γ := (le_abs_self _).trans hh |
| simpa only [bU, bV, meet, not_lt.mpr hu, not_lt.mpr hv, hm, decide_false, |
| Bool.false_eq_true, ↓reduceIte, add_zero] using (show A a ≤ B a + 4*γ by linarith) |
| · have hv' := lt_of_not_ge hv |
| simp only [bU, bV, not_lt.mpr hu, hv', decide_false, decide_true, |
| Bool.false_eq_true, ↓reduceIte, add_zero] |
| split_ifs <;> linarith [hA1 a, hB0 a] |
| · have hu' := lt_of_not_ge hu |
| simp only [bU, hu', decide_true, ↓reduceIte] |
| split_ifs <;> linarith [hA1 a, hB0 a] |
| have hh := expectation_mono μc hpoint |
| simp only [expectation_add, expectation_const, ← probability_eq_expect] at hh |
| change μc.expectation A ≤ μc.expectation B + 2*γ + θ*(J:ℝ)^2 + 4*γ |
| linarith |
| |
| end DirectedFeedback.Soundness |
| |
| noncomputable section |
| open scoped Classical BigOperators |
| 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] |
| |
| omit [NeZero M] in |
| theorem double_bias (i : Fin M) : 2*bias i = (2:ℝ)⁻¹^(i.val+1) := by |
| unfold bias |
| rw [show i.val+2 = (i.val+1)+1 by omega, pow_succ] |
| ring |
| |
| 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) |
| |
| def bigAcceptance (fallback : X) (i : Fin M) (a : Common U X M T N × E) : ℝ := |
| (subsetLaw i).probability (bigFunction G ψLaw hYX fiber deleted ord hord hrank fallback a.1 (G.left a.2)) |
| |
| def smallAcceptance (fallback : Y) (i : Fin M) (a : Common U X M T N × E) : ℝ := |
| (Pivotal.law (2*bias i) (mul_nonneg (by norm_num) (bias_pos i).le) (by linarith [bias_le_quarter i])).probability |
| (smallFunction G ψLaw hYX fiber deleted ord hord hrank fallback a.1 (G.right a.2)) |
| |
| def bigBudget (fallback : X) (a : Common U X M T N × E) : ℝ := |
| budget (bigFunction G ψLaw hYX fiber deleted ord hord hrank fallback a.1 (G.left a.2)) |
| |
| def smallBudget (fallback : Y) (a : Common U X M T N × E) : ℝ := |
| budget (smallFunction G ψLaw hYX fiber deleted ord hord hrank fallback a.1 (G.right a.2)) |
| |
| theorem independent_comparison (fallbackX : X) (fallbackY : Y) (i : Fin M) |
| (D K ρ γ θ : ℝ) (hD : 0 ≤ D) (hK : 0 < K) (hγ : 0 < γ) |
| (hsound : G.Sound θ) (hproj : ∀ e x, (fiber e x).1 = G.project e x) |
| (J : ℕ) (hJ : 1 ≤ J) (hJunta : DyadicJuntaBound M ((D+1)/γ) γ J) |
| (hBu : ((common (M := M) G ψLaw).product G.edgeLaw).expectation |
| (bigBudget G ψLaw hYX fiber deleted ord hord hrank fallbackX) ≤ D+1) |
| (hBv : ((common (M := M) G ψLaw).product G.edgeLaw).expectation |
| (smallBudget G ψLaw hYX fiber deleted ord hord hrank fallbackY) ≤ D+1) |
| (hcost : K * (comparisonLaw G ψLaw).probability (comparisonDeleted G ψLaw deleted) ≤ D) |
| (hbU : ((common (M := M) G ψLaw).product G.edgeLaw).probability (fun a => |
| decide (¬bigGood G ψLaw ord a.1 (G.left a.2))) ≤ ρ) |
| (hbV : ((common (M := M) G ψLaw).product G.edgeLaw).probability (fun a => |
| decide (¬smallGood G ψLaw ord a.1 (G.right a.2))) ≤ ρ) : |
| ((common (M := M) G ψLaw).product G.edgeLaw).expectation (fun a => |
| bigAcceptance G ψLaw hYX fiber deleted ord hord hrank fallbackX i a * |
| (1-smallAcceptance G ψLaw hYX fiber deleted ord hord hrank fallbackY i a)) ≤ |
| 2*ρ + M*(2:ℝ)^T*D/K + 6*γ + θ*(J:ℝ)^2 := by |
| let f := bigFunction G ψLaw hYX fiber deleted ord hord hrank fallbackX |
| let g := smallFunction G ψLaw hYX fiber deleted ord hord hrank fallbackY |
| have hfm : ∀ d u, Monotone (f d u) := fun d u => |
| (bigFunction_properties G ψLaw hYX fiber deleted ord hord hrank fallbackX d u).1 |
| have hgm : ∀ d v, Monotone (g d v) := fun d v => |
| (smallFunction_properties G ψLaw hYX fiber deleted ord hord hrank fallbackY d v).1 |
| obtain ⟨Ju,fu,hJu,hfu,hEu⟩ := family_dyadic_junta hJunta |
| ⟨i.val+2,by have := i.isLt; omega⟩ f hfm |
| obtain ⟨Jv,gv,hJv,hgv,hEv⟩ := family_dyadic_junta hJunta |
| ⟨i.val+1,by have := i.isLt; omega⟩ g hgm |
| have hh := Soundness.averaged_comparison (common G ψLaw) G θ hsound fiber hproj |
| (bias i) γ (D+1) (bias_pos i).le (by linarith [bias_le_quarter i]) hγ (by linarith) |
| f g (fun d u => budget (f d u)) (fun d v => budget (g d v)) |
| (fun d u => budget_nonneg _) (fun d v => budget_nonneg _) hBu hBv |
| J hJ Ju Jv fu gv hJu hJv hfu hgv hEu (by |
| intro d v hv |
| simpa only [double_bias] using hEv d v hv) |
| have hc := comparison_charge G ψLaw hYX fiber deleted ord hord hrank |
| fallbackX fallbackY i D K ρ hK hcost hbU hbV |
| change _ ≤ _ at hh |
| change _ ≤ _ at hc |
| have he : ((common (M := M) G ψLaw).product G.edgeLaw).expectation (fun a => |
| bigAcceptance G ψLaw hYX fiber deleted ord hord hrank fallbackX i a * |
| (1-smallAcceptance G ψLaw hYX fiber deleted ord hord hrank fallbackY i a)) ≤ |
| ((common (M := M) G ψLaw).product G.edgeLaw).expectation (fun a => |
| (Coupling.law (Y := Y) (bias i) (bias_pos i).le (by linarith [bias_le_quarter i])).probability |
| (failureEvent G ψLaw hYX fiber deleted ord hord hrank fallbackX fallbackY a)) + |
| 2*γ + θ*(J:ℝ)^2 + 4*γ := hh |
| linarith |
| |
| end DirectedFeedback.Construction |
| |
| namespace DirectedFeedback |
| |
| theorem transGen_loop_walk {V : Type*} {R : V → V → Prop} {a : V} |
| (h : Relation.TransGen R a a) : |
| ∃ (n : ℕ) (f : Fin (n + 1) → V), CyclicWalk R f := by |
| obtain ⟨b, hab, hba⟩ := Relation.TransGen.head'_iff.mp h |
| obtain ⟨l, hl, hend⟩ := List.exists_isChain_cons_of_relationReflTransGen hba |
| have hc : List.IsChain R (a :: b :: l) := .cons_cons hab hl |
| let f : Fin (l.length + 1) → V := fun i => (a :: b :: l)[i.val]'(by simp) |
| refine ⟨l.length, f, ?_⟩ |
| intro i |
| have hedge := List.isChain_iff_getElem.mp hc i.val (by simp; have := i.isLt; omega) |
| by_cases hi : i.val + 1 < l.length + 1 |
| · simpa only [f, Fin.val_add_one_of_lt' hi] using hedge |
| · have hilast : i.val = l.length := by have := i.isLt; omega |
| have hwrap : i + 1 = 0 := by apply Fin.ext; simp [Fin.val_add, hilast] |
| have he : (a :: b :: l)[i.val + 1]'(by simp; have := i.isLt; omega) = a := by |
| have hlast : (a :: b :: l).getLast (by simp) = a := by |
| simpa using hend |
| rw [List.getLast_eq_getElem] at hlast |
| simpa [hilast] using hlast |
| simpa only [f, hwrap, Fin.val_zero, List.getElem_cons_zero, he] using hedge |
| |
| theorem exists_topological_order {V : Type*} [Fintype V] [DecidableEq V] |
| (R : V → V → Prop) (F : Finset V) (hF : FeedbackR R F) : |
| ∃ order : V → ℕ, (∀ a b, a ∉ F → b ∉ F → R a b → order a < order b) ∧ |
| (∀ a b, a ∉ F → b ∉ F → order a = order b → a = b) := by |
| classical |
| let S := {v : V // v ∉ F} |
| let r : S → S → Prop := fun a b => R a.val b.val |
| have hr : ∀ a : S, ¬Relation.TransGen r a a := by |
| intro a ha |
| obtain ⟨n, f, hf⟩ := transGen_loop_walk ha |
| have hw : CyclicWalk R (fun i => (f i).val) := hf |
| obtain ⟨i, hi⟩ := feedback_hits_walk R F hF n (fun i => (f i).val) hw |
| exact (f i).property hi |
| let po : PartialOrder S := |
| { le := Relation.ReflTransGen r |
| le_refl a := .refl |
| le_trans _ _ _ := Relation.ReflTransGen.trans |
| le_antisymm a b hab hba := by |
| rcases Relation.reflTransGen_iff_eq_or_transGen.mp hab with heq | hne |
| · exact heq.symm |
| · exact False.elim (hr a (hne.trans_left hba)) } |
| let := po |
| let : Fintype (LinearExtension S) := Fintype.ofEquiv S (Equiv.refl _) |
| let e := (Fintype.orderIsoFinOfCardEq (LinearExtension S) rfl).symm |
| let rank (a : S) : ℕ := (e (toLinearExtension a)).val |
| have hlt {a b : S} (h : r a b) : rank a < rank b := by |
| apply e.strictMono |
| apply (toLinearExtension.monotone (show a ≤ b from Relation.ReflTransGen.single h)).lt_of_ne |
| intro heq |
| have heq' : a = b := heq |
| subst b |
| exact hr a (.single h) |
| have hinj {a b : S} (h : rank a = rank b) : a = b := by |
| have hh := e.injective (Fin.ext h) |
| exact hh |
| refine ⟨fun a => if ha : a ∉ F then rank ⟨a, ha⟩ else 0, ?_, ?_⟩ |
| · intro a b ha hb hab |
| simpa [ha, hb] using hlt (a := ⟨a, ha⟩) (b := ⟨b, hb⟩) hab |
| · intro a b ha hb heq |
| have hh : rank ⟨a, ha⟩ = rank ⟨b, hb⟩ := by simpa [ha, hb] using heq |
| exact congrArg Subtype.val (hinj hh) |
|
|
| end DirectedFeedback |
|
|
| noncomputable section |
| open scoped Classical BigOperators |
| namespace DirectedFeedback.Prefix |
|
|
| theorem prefixCell_congr {X : Type} (t : ℕ) (P Q : ℕ → Set X) |
| (h : ∀ j < t, P j = Q j) : prefixCell t P = prefixCell t Q := by |
| induction t with |
| | zero => rfl |
| | succ t ih => |
| funext a |
| dsimp only [prefixCell] |
| rw [ih (fun j hj => h j (by omega)), h t (by omega)] |
|
|
| end DirectedFeedback.Prefix |
|
|
| namespace DirectedFeedback.RankGraph |
| open DirectedFeedback.SourceProbability.FiniteDistribution Prefix |
| variable {U V X Y : Type} {T N L : ℕ} |
|
|
| theorem good_take_prefix (ord : Rank U V X Y T N → ℕ) (ψ : Fin L → Fin N) |
| (hL : 30 ≤ L) (n : ℕ) (hn : n ≤ T) (s : Fin n → U) |
| (hg : Good ord ψ hL (.inl ⟨⟨n,by omega⟩,s⟩)) (t : ℕ) (ht : t ≤ n) : |
| Good ord ψ hL (.inl ⟨⟨t,by omega⟩,takePrefix ht s⟩) := by |
| induction n with |
| | zero => have he : t = 0 := by omega |
| subst t |
| exact hg |
| | succ n ih => |
| by_cases ht' : t ≤ n |
| · have hp := good_prefix_big (ord := ord) (ψ := ψ) hL n (by omega) s hg |
| exact ih (by omega) (Fin.init s) hp ht' |
| · have he : t = n+1 := by omega |
| subst t |
| exact hg |
|
|
| end DirectedFeedback.RankGraph |
|
|
| 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] |
|
|
| omit [Fintype U] [Fintype X] [NeZero M] [NeZero T] [Nonempty X] in |
| theorem cell_takePrefix {t : ℕ} (ht : t ≤ T) (a : PrefixData U X M T) : |
| cell (takePrefix ht a) = prefixCell t (sets a) := by |
| apply prefixCell_congr |
| intro j hj |
| simp only [sets, hj, dite_eq_left, takePrefix, lt_of_lt_of_le hj ht] |
|
|
| 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 OAI |
|
|
