math / data /lean /OAI /NumberTheory /GaussianMoat /BooleanCube.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
14.9 kB
import OAI.NumberTheory.GaussianMoat.SignConcentration
namespace OAI
universe uIota
namespace GaussianMoat
open MeasureTheory ProbabilityTheory
open scoped NNReal
@[reducible] def Cube : ℕ → Type
| 0 => Unit
| n + 1 => Bool × Cube n
instance cubeFintype : (n : ℕ) → Fintype (Cube n)
| 0 => inferInstanceAs (Fintype Unit)
| n + 1 => @instFintypeProd Bool (Cube n) inferInstance (cubeFintype n)
instance cubeDecidableEq : (n : ℕ) → DecidableEq (Cube n)
| 0 => inferInstanceAs (DecidableEq Unit)
| n + 1 => @instDecidableEqProd Bool (Cube n) inferInstance (cubeDecidableEq n)
def cubeDist : (n : ℕ) → Cube n → Cube n → ℕ
| 0, _, _ => 0
| n + 1, (b,x), (c,y) => (if b = c then 0 else 1) + cubeDist n x y
@[simp] theorem cubeDist_self (n : ℕ) (x : Cube n) : cubeDist n x x = 0 := by
induction n with
| zero => rfl
| succ n ih => obtain ⟨b,x⟩ := x; simp [cubeDist, ih]
@[simp] theorem cubeDist_zero_iff (n : ℕ) (x y : Cube n) : cubeDist n x y = 0 ↔ x = y := by
induction n with
| zero => simp only [cubeDist]
| succ n ih =>
obtain ⟨b,x⟩ := x
obtain ⟨c,y⟩ := y
by_cases h : b = c <;> simp [cubeDist, h, ih, Prod.mk.injEq]
theorem cubeDist_symm (n : ℕ) (x y : Cube n) : cubeDist n x y = cubeDist n y x := by
induction n with
| zero => rfl
| succ n ih =>
obtain ⟨b,x⟩ := x
obtain ⟨c,y⟩ := y
simp [cubeDist, eq_comm (a := b) (b := c), ih x y]
theorem cubeDist_triangle (n : ℕ) (x y z : Cube n) :
cubeDist n x z ≤ cubeDist n x y + cubeDist n y z := by
induction n with
| zero => simp [cubeDist]
| succ n ih =>
obtain ⟨b,x⟩ := x
obtain ⟨c,y⟩ := y
obtain ⟨d,z⟩ := z
have h := ih x y z
cases b <;> cases c <;> cases d <;> simp [cubeDist] <;> omega
noncomputable def cubeSize {n : ℕ} (S : Cube n → Prop) : ℕ := by
classical
exact ∑ x, if S x then 1 else 0
noncomputable def cubeBoundary {n : ℕ} (S : Cube n → Prop) : ℕ := by
classical
exact ∑ x, ∑ y, if S x ∧ ¬ S y ∧ cubeDist n x y = 1 then 1 else 0
noncomputable def cubeCross {n : ℕ} (A B : Cube n → Prop) : ℕ := by
classical
exact ∑ x, if A x ∧ ¬ B x then 1 else 0
theorem cubeSize_succ {n : ℕ} (S : Cube (n+1) → Prop) :
cubeSize S = cubeSize (fun x => S (false,x)) + cubeSize (fun x => S (true,x)) := by
classical
simp only [cubeSize, Fintype.sum_prod_type, Fintype.sum_bool]
ac_rfl
theorem cubeBoundary_succ {n : ℕ} (S : Cube (n+1) → Prop) :
cubeBoundary S = cubeBoundary (fun x => S (false,x)) + cubeBoundary (fun x => S (true,x)) +
cubeCross (fun x => S (false,x)) (fun x => S (true,x)) +
cubeCross (fun x => S (true,x)) (fun x => S (false,x)) := by
classical
simp only [cubeBoundary, cubeCross, Fintype.sum_prod_type, Fintype.sum_bool, cubeDist,
Bool.false_eq_true, Bool.true_eq_false, ↓reduceIte, zero_add, Nat.add_eq_left,
cubeDist_zero_iff, Finset.sum_add_distrib]
simp only [and_assoc, and_left_comm, and_comm, ite_and, Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte]
omega
theorem cubeCross_card_le {n : ℕ} (A B : Cube n → Prop) : cubeSize A ≤ cubeSize B + cubeCross A B := by
classical
rw [cubeSize, cubeSize, cubeCross, ← Finset.sum_add_distrib]
apply Finset.sum_le_sum
intro x _
by_cases ha : A x <;> by_cases hb : B x <;> simp [ha, hb]
theorem cube_degree (n : ℕ) (x : Cube n) : (∑ y, if cubeDist n x y = 1 then 1 else 0) = n := by
classical
induction n with
| zero => simp [cubeDist]
| succ n ih =>
obtain ⟨b,x⟩ := x
cases b <;> simp only [Fintype.sum_prod_type, Fintype.sum_bool, cubeDist,
Bool.false_eq_true, Bool.true_eq_false, ↓reduceIte, zero_add, Nat.add_eq_left,
cubeDist_zero_iff, Finset.sum_ite_eq, Finset.mem_univ, ↓reduceIte, ih]
omega
theorem binEntropy_ge_two_mul {p : ℝ} (hp0 : 0 ≤ p) (hp2 : p ≤ 1/2) :
2 * p * Real.log 2 ≤ Real.binEntropy p := by
have hc : ConcaveOn ℝ (Set.Icc 0 1) Real.binEntropy := Real.strictConcave_binEntropy.concaveOn
have h := hc.2 (show (0 : ℝ) ∈ Set.Icc 0 1 by norm_num)
(show (2 : ℝ)⁻¹ ∈ Set.Icc 0 1 by norm_num)
(show 0 ≤ 1 - 2*p by linarith) (show 0 ≤ 2*p by positivity) (by ring)
simpa only [smul_eq_mul, Real.binEntropy_zero, Real.binEntropy_two_inv,
mul_zero, zero_add, show 2*p*(2:ℝ)⁻¹ = p by ring] using h
theorem entropy_merge_of_le {a b : ℝ} (ha : 0 ≤ a) (hab : a ≤ b) :
2 * a * Real.log 2 ≤ (a+b)*Real.log (a+b) - a*Real.log a - b*Real.log b := by
by_cases ha0 : a = 0
· simp [ha0]
have hap : 0 < a := lt_of_le_of_ne ha (Ne.symm ha0)
have hbp : 0 < b := hap.trans_le hab
have ht : 0 < a+b := by positivity
have hp0 : 0 ≤ a/(a+b) := by positivity
have hp2 : a/(a+b) ≤ 1/2 := (div_le_iff₀ ht).mpr (by linarith)
have h := mul_le_mul_of_nonneg_left (binEntropy_ge_two_mul hp0 hp2) ht.le
have heq : (a+b) * Real.binEntropy (a/(a+b)) =
(a+b)*Real.log (a+b) - a*Real.log a - b*Real.log b := by
have hsub : 1-a/(a+b) = b/(a+b) := by field_simp; ring
rw [Real.binEntropy, hsub, Real.log_inv, Real.log_inv,
Real.log_div hap.ne' ht.ne', Real.log_div hbp.ne' ht.ne']
field_simp
ring
rw [heq] at h
have heq' : (a+b) * (2 * (a/(a+b)) * Real.log 2) = 2*a*Real.log 2 := by
field_simp
rwa [heq'] at h
theorem entropy_merge {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) :
2 * min a b * Real.log 2 ≤ (a+b)*Real.log (a+b) - a*Real.log a - b*Real.log b := by
rcases le_total a b with hab | hba
· simpa [min_eq_left hab] using entropy_merge_of_le ha hab
· have h := entropy_merge_of_le hb hba
rw [min_eq_right hba]
convert h using 1
rw [add_comm b a]
ring
theorem cube_edge_isoperimetric (n : ℕ) (S : Cube n → Prop) :
(cubeSize S : ℝ) * ((n : ℝ) * Real.log 2 - Real.log (cubeSize S)) ≤
(cubeBoundary S : ℝ) * Real.log 2 := by
classical
induction n with
| zero =>
by_cases hs : S () <;> simp [cubeSize, cubeBoundary, cubeDist, hs]
| succ n ih =>
have h0 := ih (fun x => S (false,x))
have h1 := ih (fun x => S (true,x))
have hac := cubeCross_card_le (fun x => S (false,x)) (fun x => S (true,x))
have hbc := cubeCross_card_le (fun x => S (true,x)) (fun x => S (false,x))
have hac' : (cubeSize (fun x => S (false,x)) : ℝ) ≤
cubeSize (fun x => S (true,x)) + cubeCross (fun x => S (false,x)) (fun x => S (true,x)) := by
exact_mod_cast hac
have hbc' : (cubeSize (fun x => S (true,x)) : ℝ) ≤
cubeSize (fun x => S (false,x)) + cubeCross (fun x => S (true,x)) (fun x => S (false,x)) := by
exact_mod_cast hbc
have he := entropy_merge (a := (cubeSize (fun x => S (false,x)) : ℝ))
(b := (cubeSize (fun x => S (true,x)) : ℝ)) (by positivity) (by positivity)
have hl : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num)
rw [cubeSize_succ, cubeBoundary_succ]
push_cast
rcases le_total (cubeSize (fun x => S (false,x)) : ℝ) (cubeSize (fun x => S (true,x)) : ℝ) with hab | hba
· rw [min_eq_left hab] at he
have hn : (0 : ℝ) ≤ cubeCross (fun x => S (false,x)) (fun x => S (true,x)) := by positivity
nlinarith
· rw [min_eq_right hba] at he
have hn : (0 : ℝ) ≤ cubeCross (fun x => S (true,x)) (fun x => S (false,x)) := by positivity
nlinarith
def cubeExpand {n : ℕ} (S : Cube n → Prop) (y : Cube n) : Prop :=
S y ∨ ∃ x, S x ∧ cubeDist n x y = 1
def cubeExpandIter {n : ℕ} (S : Cube n → Prop) : ℕ → Cube n → Prop
| 0 => S
| h+1 => cubeExpand (cubeExpandIter S h)
theorem cubeSize_mono {n : ℕ} {S T : Cube n → Prop} (h : ∀ x, S x → T x) :
cubeSize S ≤ cubeSize T := by
classical
apply Finset.sum_le_sum
intro x _
by_cases hs : S x
· simp [hs, h x hs]
· simp [hs]
theorem cube_card (n : ℕ) : Fintype.card (Cube n) = 2^n := by
induction n with
| zero => rfl
| succ n ih =>
change Fintype.card (Bool × Cube n) = _
rw [Fintype.card_prod, Fintype.card_bool, ih, pow_succ]
omega
theorem cubeSize_le (n : ℕ) (S : Cube n → Prop) : cubeSize S ≤ 2^n := by
classical
calc
cubeSize S ≤ ∑ _ : Cube n, 1 := by
apply Finset.sum_le_sum
intro x _
split_ifs <;> omega
_ = 2^n := by simp [cube_card]
theorem cubeBoundary_expand_bound {n : ℕ} (S : Cube n → Prop) :
cubeBoundary S + n * cubeSize S ≤ n * cubeSize (cubeExpand S) := by
classical
have hdegree (y : Cube n) :
(∑ x, if S x ∧ ¬ S y ∧ cubeDist n x y = 1 then 1 else 0) ≤
n * (if ¬S y ∧ (∃ x, S x ∧ cubeDist n x y = 1) then 1 else 0) := by
by_cases hy : ¬S y ∧ (∃ x, S x ∧ cubeDist n x y = 1)
· rw [ite_eq_left hy, mul_one]
calc
_ ≤ ∑ x, if cubeDist n y x = 1 then 1 else 0 := by
apply Finset.sum_le_sum
intro x _
by_cases h : S x ∧ ¬ S y ∧ cubeDist n x y = 1
· simp [h, cubeDist_symm n y x]
· simp [h]
_ = n := cube_degree n y
· simp only [hy, ↓reduceIte, mul_zero, Nat.le_zero]
apply Finset.sum_eq_zero
intro x _
have hnot : ¬(S x ∧ ¬S y ∧ cubeDist n x y = 1) := by
rintro ⟨hs, hns, hd⟩
exact hy ⟨hns,x,hs,hd⟩
simp [hnot]
have hb := Finset.sum_le_sum (s := Finset.univ) (fun y _ => hdegree y)
rw [← Finset.mul_sum] at hb
have heq : cubeSize (cubeExpand S) = cubeSize S +
∑ y, if ¬S y ∧ (∃ x, S x ∧ cubeDist n x y = 1) then 1 else 0 := by
rw [cubeSize, cubeSize, ← Finset.sum_add_distrib]
apply Finset.sum_congr rfl
intro y _
by_cases hs : S y <;> simp [cubeExpand, hs]
unfold cubeBoundary
rw [Finset.sum_comm, heq, Nat.mul_add]
omega
theorem cubeExpandIter_witness {n h : ℕ} {S : Cube n → Prop} {x : Cube n}
(hx : cubeExpandIter S h x) : ∃ y, S y ∧ cubeDist n y x ≤ h := by
induction h generalizing x with
| zero => exact ⟨x,hx,by simp⟩
| succ h ih =>
rcases hx with hx | ⟨z,hz,hzx⟩
· obtain ⟨y,hy,hyx⟩ := ih hx
exact ⟨y,hy,by omega⟩
· obtain ⟨y,hy,hyz⟩ := ih hz
exact ⟨y,hy,by have ht := cubeDist_triangle n y z x; omega⟩
theorem cubeExpandIter_disjoint {n h : ℕ} {S T : Cube n → Prop}
(hsep : ∀ x, S x → ∀ y, T y → 2*h < cubeDist n x y) :
∀ x, ¬(cubeExpandIter S h x ∧ cubeExpandIter T h x) := by
rintro x ⟨hs,ht⟩
obtain ⟨y,hy,hyx⟩ := cubeExpandIter_witness hs
obtain ⟨z,hz,hzx⟩ := cubeExpandIter_witness ht
have h := hsep y hy z hz
have htri := cubeDist_triangle n y x z
rw [cubeDist_symm n x z] at htri
omega
theorem cubeSize_sum_le {n : ℕ} {ι : Type uIota} [Fintype ι] (S : ι → Cube n → Prop)
(hd : ∀ i j, i ≠ j → ∀ x, ¬(S i x ∧ S j x)) :
∑ i, cubeSize (S i) ≤ 2^n := by
classical
unfold cubeSize
rw [Finset.sum_comm]
calc
_ ≤ ∑ _ : Cube n, 1 := by
apply Finset.sum_le_sum
intro x _
by_cases he : ∃ i, S i x
· obtain ⟨i,hi⟩ := he
rw [Finset.sum_eq_single i]
· simp [hi]
· intro j _ hji
have hnot : ¬S j x := fun hj => hd j i hji x ⟨hj,hi⟩
simp [hnot]
· simp
· have hh : ∀ i, ¬S i x := by simpa only [not_exists] using he
simp [hh]
_ = 2^n := by simp [cube_card]
theorem cube_growth {n : ℕ} (hn : 0 < n) (S : Cube n → Prop) {a E : ℝ}
(hE : 0 < E) (hlogE : Real.log E ≤ (n : ℝ) * Real.log 2 - a)
(hsize : (cubeSize S : ℝ) ≤ E) :
(1 + a / ((n : ℝ) * Real.log 2)) * cubeSize S ≤ cubeSize (cubeExpand S) := by
by_cases hz : cubeSize S = 0
· simp [hz]
have hpos : (0 : ℝ) < cubeSize S := by exact_mod_cast Nat.pos_of_ne_zero hz
have hnpos : (0 : ℝ) < n := by exact_mod_cast hn
have hlogtwo : 0 < Real.log 2 := Real.log_pos (by norm_num)
have hden : 0 < (n : ℝ) * Real.log 2 := mul_pos hnpos hlogtwo
have hl := ((Real.log_le_log_iff hpos hE).mpr hsize).trans hlogE
have hi := cube_edge_isoperimetric n S
have hb : (cubeBoundary S : ℝ) + n * cubeSize S ≤ n * cubeSize (cubeExpand S) := by
exact_mod_cast cubeBoundary_expand_bound S
apply (mul_le_mul_iff_left₀ hden).mp
field_simp at ⊢
nlinarith [mul_le_mul_of_nonneg_left hl hpos.le,
mul_le_mul_of_nonneg_right hb hlogtwo.le]
theorem cube_iter_growth {n : ℕ} (S : Cube n → Prop) {δ E : ℝ} (hδ : 0 ≤ δ)
(hgrow : ∀ T : Cube n → Prop, (cubeSize T : ℝ) ≤ E →
(1+δ)*cubeSize T ≤ cubeSize (cubeExpand T)) (h : ℕ) :
min E ((1+δ)^h * cubeSize S) ≤ cubeSize (cubeExpandIter S h) := by
induction h with
| zero => simpa only [pow_zero, one_mul, cubeExpandIter] using
(min_le_right E (cubeSize S : ℝ))
| succ h ih =>
have hmono : (cubeSize (cubeExpandIter S h) : ℝ) ≤ cubeSize (cubeExpandIter S (h+1)) := by
exact_mod_cast cubeSize_mono (S := cubeExpandIter S h) (T := cubeExpand (cubeExpandIter S h))
(fun _ hx => Or.inl hx)
by_cases hlarge : E ≤ (cubeSize (cubeExpandIter S h) : ℝ)
· exact (min_le_left _ _).trans (hlarge.trans hmono)
· have hsmall : (cubeSize (cubeExpandIter S h) : ℝ) ≤ E := le_of_not_ge hlarge
have hpow : (1+δ)^h * cubeSize S ≤ E := by
by_contra hnot
rw [min_eq_left (le_of_not_ge hnot)] at ih
exact hlarge ih
rw [min_eq_right hpow] at ih
have hmul := mul_le_mul_of_nonneg_left ih (by linarith : 0 ≤ 1+δ)
have hg := hgrow (cubeExpandIter S h) hsmall
apply (min_le_right _ _).trans
simpa only [pow_succ, mul_assoc, mul_left_comm, cubeExpandIter] using hmul.trans hg
theorem cube_separated_bound {n h : ℕ} (hn : 0 < n) {ι : Type uIota} [Fintype ι]
(S : ι → Cube n → Prop) {a E A : ℝ} (ha : 0 ≤ a) (hE : 0 < E)
(hlogE : Real.log E ≤ (n : ℝ) * Real.log 2 - a)
(hseed : ∀ i, A * cubeSize (S i) ≤ E)
(hfactor : A ≤ (1 + a / ((n : ℝ)*Real.log 2))^h)
(hsep : ∀ i j, i ≠ j → ∀ x, S i x → ∀ y, S j y → 2*h < cubeDist n x y) :
A * (∑ i, (cubeSize (S i) : ℝ)) ≤ (2 : ℝ)^n := by
have hδ : 0 ≤ a / ((n : ℝ)*Real.log 2) := by
apply div_nonneg ha
exact mul_nonneg (Nat.cast_nonneg _) (Real.log_nonneg (by norm_num))
have hlarge (i : ι) : A * cubeSize (S i) ≤ cubeSize (cubeExpandIter (S i) h) := by
apply le_trans (le_min (hseed i) (mul_le_mul_of_nonneg_right hfactor (Nat.cast_nonneg _)))
exact cube_iter_growth (S i) hδ (fun T ht => cube_growth hn T hE hlogE ht) h
rw [Finset.mul_sum]
apply (Finset.sum_le_sum (fun i _ => hlarge i)).trans
have hd : ∀ i j, i ≠ j → ∀ x, ¬(cubeExpandIter (S i) h x ∧ cubeExpandIter (S j) h x) := by
intro i j hij
exact cubeExpandIter_disjoint (hsep i j hij)
exact_mod_cast cubeSize_sum_le (fun i => cubeExpandIter (S i) h) hd
end GaussianMoat
end OAI