| import Mathlib |
| import OAI.Probability.CriticalPercolation.Entropy.MulLogDivScaled |
|
|
| namespace OAI |
|
|
| section |
| section |
| open Set MeasureTheory ProbabilityTheory |
| open Set |
| open scoped BigOperators |
| open scoped Classical |
| open Real |
| open Set Real |
| open scoped Topology |
|
|
| namespace CriticalPercolation |
| open FiniteEntropy |
|
|
| universe u |
|
|
| inductive QueryTree (E : Type u) : Type u where |
| | stop : QueryTree E |
| | ask (e : E) (left right : QueryTree E) : QueryTree E |
|
|
| namespace QueryTree |
| variable {E : Type u} |
|
|
| @[reducible] def Leaf : QueryTree E → Type u |
| | .stop => PUnit |
| | .ask _ left right => Sum left.Leaf right.Leaf |
|
|
| instance leafFintype : (t : QueryTree E) → Fintype t.Leaf |
| | .stop => inferInstanceAs (Fintype PUnit) |
| | .ask _ left right => @instFintypeSum _ _ left.leafFintype right.leafFintype |
|
|
| def run : (t : QueryTree E) → (E → Bool) → t.Leaf |
| | .stop, _ => PUnit.unit |
| | .ask e left right, ω => if ω e then Sum.inr (right.run ω) else Sum.inl (left.run ω) |
|
|
| def reads : (t : QueryTree E) → (E → Bool) → List E |
| | .stop, _ => [] |
| | .ask e left right, ω => e :: if ω e then right.reads ω else left.reads ω |
|
|
| def Valid [DecidableEq E] : QueryTree E → Finset E → Prop |
| | .stop, _ => True |
| | .ask e left right, used => e ∉ used ∧ left.Valid (insert e used) ∧ right.Valid (insert e used) |
|
|
| noncomputable def reference (p : ℝ) : (t : QueryTree E) → t.Leaf → ℝ |
| | .stop, _ => 1 |
| | .ask _ left _, Sum.inl x => (1-p)*left.reference p x |
| | .ask _ _ right, Sum.inr x => p*right.reference p x |
|
|
| lemma reference_pos {p : ℝ} (hp : p ∈ Set.Ioo 0 1) : |
| ∀ (t : QueryTree E) (x : t.Leaf), 0 < t.reference p x := by |
| intro t |
| induction t with |
| | stop => intro x; exact zero_lt_one |
| | ask e left right hl hr => |
| intro x |
| cases x with |
| | inl x => exact mul_pos (sub_pos.mpr hp.2) (hl x) |
| | inr x => exact mul_pos hp.1 (hr x) |
|
|
| lemma reference_sum (p : ℝ) (t : QueryTree E) : ∑ x, t.reference p x = 1 := by |
| induction t with |
| | stop => simp [reference, Leaf] |
| | ask e left right hl hr => |
| change (∑ x : Sum left.Leaf right.Leaf, (ask e left right).reference p x) = 1 |
| rw [Fintype.sum_sum_type] |
| simp only [reference, ← Finset.mul_sum, hl, hr, mul_one] |
| ring |
|
|
| noncomputable def charge (F : ℝ → ℝ) : (t : QueryTree E) → (t.Leaf → ℝ) → ℝ |
| | .stop, _ => 0 |
| | .ask _ left right, P => |
| let l := ∑ x, P (Sum.inl x) |
| let r := ∑ x, P (Sum.inr x) |
| (l+r)*F (r/(l+r)) + left.charge F (fun x => P (Sum.inl x)) + |
| right.charge F (fun x => P (Sum.inr x)) |
|
|
| lemma charge_mono {F H : ℝ → ℝ} (hFH : ∀ r ∈ Set.Icc (0:ℝ) 1, F r ≤ H r) |
| (t : QueryTree E) (P : t.Leaf → ℝ) (hP : ∀ x, 0 ≤ P x) : |
| t.charge F P ≤ t.charge H P := by |
| induction t with |
| | stop => rfl |
| | ask e left right hl hr => |
| let l := ∑ x, P (Sum.inl x) |
| let r := ∑ x, P (Sum.inr x) |
| have hn : 0 ≤ l+r := add_nonneg (Finset.sum_nonneg fun x _ => hP (.inl x)) |
| (Finset.sum_nonneg fun x _ => hP (.inr x)) |
| have hb : r/(l+r) ∈ Set.Icc (0:ℝ) 1 := by |
| constructor |
| · exact div_nonneg (Finset.sum_nonneg fun x _ => hP (.inr x)) hn |
| · by_cases hz : l+r = 0 |
| · simp [hz] |
| · apply (div_le_one (lt_of_le_of_ne hn (Ne.symm hz))).mpr |
| have : 0 ≤ l := Finset.sum_nonneg fun x _ => hP (.inl x) |
| linarith |
| exact add_le_add (add_le_add (mul_le_mul_of_nonneg_left (hFH _ hb) hn) |
| (hl _ fun x => hP (.inl x))) (hr _ fun x => hP (.inr x)) |
|
|
| lemma charge_const_mul (F : ℝ → ℝ) (c : ℝ) (t : QueryTree E) (P : t.Leaf → ℝ) : |
| t.charge (fun r => c*F r) P = c*t.charge F P := by |
| induction t with |
| | stop => simp [charge] |
| | ask e left right hl hr => simp only [charge, hl, hr]; ring |
|
|
| theorem divergence_reference_eq_charge {p : ℝ} (hp : p ∈ Set.Ioo 0 1) |
| (t : QueryTree E) (P : t.Leaf → ℝ) (hP : ∀ x, 0 ≤ P x) : |
| divergence P (t.reference p) = |
| t.charge (fun r => binaryDivergence r p) P + (∑ x, P x)*Real.log (∑ x, P x) := by |
| induction t with |
| | stop => simp [divergence, reference, charge, Leaf] |
| | ask e left right hl hr => |
| let P₀ : left.Leaf → ℝ := fun x => P (Sum.inl x) |
| let P₁ : right.Leaf → ℝ := fun x => P (Sum.inr x) |
| have hb := binaryDivergence_mass_split |
| (Finset.sum_nonneg (s := Finset.univ) (fun x _ => hP (.inl x))) |
| (Finset.sum_nonneg (s := Finset.univ) (fun x _ => hP (.inr x))) hp |
| change (∑ x : Sum left.Leaf right.Leaf, P x*Real.log (P x/(ask e left right).reference p x)) = _ |
| rw [Fintype.sum_sum_type] |
| change divergence P₀ (fun x => (1-p)*left.reference p x) + |
| divergence P₁ (fun x => p*right.reference p x) = _ |
| rw [divergence_scale_reference P₀ (left.reference p) (fun x => hP (.inl x)) |
| (fun x _ => reference_pos hp left x) (sub_pos.mpr hp.2), |
| divergence_scale_reference P₁ (right.reference p) (fun x => hP (.inr x)) |
| (fun x _ => reference_pos hp right x) hp.1, |
| hl P₀ (fun x => hP (.inl x)), hr P₁ (fun x => hP (.inr x))] |
| change _ = _ + (∑ x : Sum left.Leaf right.Leaf, P x)*Real.log (∑ x : Sum left.Leaf right.Leaf, P x) |
| rw [Fintype.sum_sum_type] |
| dsimp only [charge, P₀, P₁] |
| linarith |
|
|
| theorem divergence_reference_bounds {p : ℝ} (hp : p ∈ Set.Ioo 0 1) |
| (t : QueryTree E) (P : t.Leaf → ℝ) (hP : ∀ x, 0 ≤ P x) (hMass : ∑ x, P x = 1) : |
| 2*t.charge (fun r => (r-p)^2) P ≤ divergence P (t.reference p) ∧ |
| divergence P (t.reference p) ≤ (p*(1-p))⁻¹*t.charge (fun r => (r-p)^2) P := by |
| rw [divergence_reference_eq_charge hp t P hP, hMass, Real.log_one, mul_zero, add_zero] |
| constructor |
| · have h := charge_mono (fun r hr => binaryDivergence_lower hp hr) t P hP |
| rwa [charge_const_mul] at h |
| · have h := charge_mono (fun r hr => binaryDivergence_upper hp hr) t P hP |
| have heq : (fun r => (r-p)^2/(p*(1-p))) = |
| (fun r => (p*(1-p))⁻¹*(r-p)^2) := by |
| funext r; simp only [div_eq_mul_inv, mul_comm] |
| rwa [heq, charge_const_mul] at h |
|
|
| lemma valid_mono [DecidableEq E] (t : QueryTree E) {s u : Finset E} (hsu : s ⊆ u) |
| (hv : t.Valid u) : t.Valid s := by |
| induction t generalizing s u with |
| | stop => trivial |
| | ask e left right hl hr => |
| exact ⟨fun he => hv.1 (hsu he), hl (Finset.insert_subset_insert e hsu) hv.2.1, |
| hr (Finset.insert_subset_insert e hsu) hv.2.2⟩ |
|
|
| lemma run_dependsOn [DecidableEq E] (t : QueryTree E) (used : Finset E) (hv : t.Valid used) : |
| DependsOn t.run (↑used : Set E)ᶜ := by |
| intro ω ω' hω |
| induction t generalizing used with |
| | stop => rfl |
| | ask e left right hl hr => |
| have he : ω e = ω' e := hω e hv.1 |
| have hc : ∀ i ∈ (↑(insert e used) : Set E)ᶜ, ω i = ω' i := by |
| intro i hi |
| exact hω i (fun hu => hi (Finset.mem_insert_of_mem hu)) |
| simp only [run, he] |
| split_ifs |
| · exact congrArg Sum.inr (hr _ hv.2.2 hc) |
| · exact congrArg Sum.inl (hl _ hv.2.1 hc) |
|
|
| lemma reads_disjoint [DecidableEq E] (t : QueryTree E) (used : Finset E) |
| (hv : t.Valid used) (ω : E → Bool) : ∀ e ∈ t.reads ω, e ∉ used := by |
| induction t generalizing used with |
| | stop => simp [reads] |
| | ask e left right hl hr => |
| intro f hf |
| simp only [reads, List.mem_cons] at hf |
| rcases hf with rfl | hf |
| · exact hv.1 |
| · split_ifs at hf with he |
| · exact fun hu => hr _ hv.2.2 _ hf (Finset.mem_insert_of_mem hu) |
| · exact fun hu => hl _ hv.2.1 _ hf (Finset.mem_insert_of_mem hu) |
|
|
| lemma reads_nodup [DecidableEq E] (t : QueryTree E) (used : Finset E) |
| (hv : t.Valid used) (ω : E → Bool) : (t.reads ω).Nodup := by |
| induction t generalizing used with |
| | stop => simp [reads] |
| | ask e left right hl hr => |
| simp only [reads, List.nodup_cons] |
| split_ifs |
| · exact ⟨fun he => reads_disjoint right _ hv.2.2 ω e he (Finset.mem_insert_self _ _), |
| hr _ hv.2.2⟩ |
| · exact ⟨fun he => reads_disjoint left _ hv.2.1 ω e he (Finset.mem_insert_self _ _), |
| hl _ hv.2.1⟩ |
|
|
| end QueryTree |
| end CriticalPercolation |
|
|
| open scoped BigOperators |
| open Set |
|
|
| end |
| end |
|
|
| end OAI |
|
|
