| import Mathlib |
| import OAI.Probability.CriticalPercolation.Entropy.BinaryConfiguration |
| import OAI.Probability.CriticalPercolation.Entropy.BinaryCosts |
|
|
| namespace OAI |
|
|
| section |
| section |
| namespace CriticalPercolation.BinaryLaw |
| open scoped Classical |
| open FiniteProduct BondGraph BinaryInterpolation InterpolationForest ExactExposure FiniteEntropy |
|
|
| variable {V E : Type*} |
|
|
| abbrev stepLeft (d : ℕ) (x : ℕ → V) (n : ℕ) (D : FixedDescriptor n) (i : Fin n) : V := |
| (descriptorNode (E := E) d x n D (i.val+2)).1 |
| abbrev stepRight (d : ℕ) (x : ℕ → V) (n : ℕ) (D : FixedDescriptor n) (i : Fin n) : V := |
| (descriptorNode (E := E) d x n D (descriptorParent (E := E) d x n D (i.val+2))).1 |
| abbrev stepTargets (d : ℕ) (x : ℕ → V) (n : ℕ) (D : FixedDescriptor n) (i : Fin n) : Set V := |
| scheduledTargets (E := E) d x n (fun j => (D j).1) i.val |
|
|
| def activeSteps (n : ℕ) (D : FixedDescriptor n) : Finset (Fin n) := |
| Finset.univ.filter fun i => (D i).2.2 = true |
|
|
| variable [Fintype V] [Fintype E] |
| variable (G : BondGraph V E) (order : List (LazyDFS.Dart V E)) (d : ℕ) (x : ℕ → V) |
| variable (p : ℝ) (w : E → Prop → ℝ) (n : ℕ) (D : FixedDescriptor n) |
|
|
| noncomputable def pairQuery (i : Fin n) : QueryTree E := |
| (pair G (stepLeft (E := E) d x n D i) (stepRight (E := E) d x n D i)).bare |
|
|
| noncomputable def selectedTranscript (i : Fin n) (ω : E → Bool) : E → Bool := |
| if (D i).2.2 = true then |
| representative (pairQuery G d x n D i).run (fun _ => false) ((pairQuery G d x n D i).run ω) |
| else ω |
|
|
| noncomputable def selectedWeight (i : Fin n) (ω : E → Bool) (m : Option E) : ℝ := |
| if (D i).2.2 = true then match m with |
| | none => 0 |
| | some e => markWeight G order (stepTargets (E := E) d x n D i) |
| (stepLeft (E := E) d x n D i) (stepRight (E := E) d x n D i) p w ω e |
| else scheduleWeight G order d x p w n (fun j => (D j).1) i (configuration ω) m |
|
|
| noncomputable def selectedCost (i : Fin n) (ω : E → Bool) (m : Option E) : ℝ := |
| if (D i).2.2 = true then match m with |
| | none => 0 |
| | some e => markCost G order (stepTargets (E := E) d x n D i) |
| (stepLeft (E := E) d x n D i) (stepRight (E := E) d x n D i) p w ω e |
| else 0 |
|
|
| lemma selected_nonneg (hp : p ∈ Set.Ioo 0 1) (h0 : ∀ e, w e False = 1-p) |
| (h1 : ∀ e, w e True = p) (i : Fin n) (ω : E → Bool) (m : Option E) : |
| 0 ≤ selectedWeight G order d x p w n D i ω m ∧ |
| 0 ≤ selectedCost G order d x p w n D i ω m := by |
| unfold selectedWeight selectedCost |
| split_ifs |
| · cases m with |
| | none => exact ⟨le_rfl,le_rfl⟩ |
| | some e => exact mark_nonneg G order _ _ _ hp w h0 h1 ω e |
| · exact ⟨scheduleWeight_nonneg G order d x p w hp h0 h1 n _ i _ m,le_rfl⟩ |
|
|
| lemma selected_run (i : Fin n) (ω : E → Bool) (m : Option E) : |
| selectedWeight G order d x p w n D i (selectedTranscript G d x n D i ω) m = |
| selectedWeight G order d x p w n D i ω m ∧ |
| selectedCost G order d x p w n D i (selectedTranscript G d x n D i ω) m = |
| selectedCost G order d x p w n D i ω m := by |
| unfold selectedWeight selectedCost selectedTranscript |
| split_ifs with hi |
| · cases m with |
| | none => exact ⟨rfl,rfl⟩ |
| | some e => |
| exact pair_mark_congr G order _ _ _ (scheduled_parent_mem d x n D i) p w _ ω |
| (representative_run (pairQuery G d x n D i).run (fun _ => false) ω) e |
| · exact ⟨rfl,rfl⟩ |
|
|
| lemma selectedWeight_le_raw (hp : p ∈ Set.Ioo 0 1) (h0 : ∀ e, w e False = 1-p) |
| (h1 : ∀ e, w e True = p) (i : Fin n) (ω : E → Bool) (m : Option E) : |
| selectedWeight G order d x p w n D i ω m ≤ |
| scheduleWeight G order d x p w n (fun j => (D j).1) i (configuration ω) m := by |
| unfold selectedWeight |
| split_ifs |
| · cases m with |
| | none => exact scheduleWeight_nonneg G order d x p w hp h0 h1 n _ i _ none |
| | some e => |
| unfold scheduleWeight |
| rw [scheduledAnchor_node] |
| exact G.markWeight_le_raw order _ _ _ (scheduled_parent_mem d x n D i) hp w h0 h1 ω e |
| · exact le_rfl |
|
|
| lemma supported_selected_eq (s : ℕ) (ω : E → Bool) (m : Fin n → Option E) |
| (hz : conditionedMass G order d x p w s n D (ω,m) ≠ 0) (i : Fin n) : |
| selectedWeight G order d x p w n D i ω (m i) = |
| scheduleWeight G order d x p w n (fun j => (D j).1) i (configuration ω) (m i) := by |
| unfold selectedWeight |
| split_ifs with hi |
| · obtain ⟨e,he,ha⟩ := supported_active_admissible G order d x p w s n D ω m hz ⟨i,hi⟩ |
| dsimp only at he ha |
| rw [he] |
| unfold scheduleWeight |
| rw [scheduledAnchor_node] |
| exact G.markWeight_eq_raw_of_admissible order _ _ _ (scheduled_parent_mem d x n D i) p w ω e ha |
| · rfl |
|
|
| lemma supported_selected_positive (s : ℕ) (hp : p ∈ Set.Ioo 0 1) |
| (h0 : ∀ e, w e False = 1-p) (h1 : ∀ e, w e True = p) |
| (z : (E → Bool) × (Fin n → Option E)) |
| (hz : 0 < conditionedMass G order d x p w s n D z) (i : Fin n) : |
| 0 < selectedWeight G order d x p w n D i (selectedTranscript G d x n D i z.1) (z.2 i) := by |
| rw [(selected_run G order d x p w n D i z.1 (z.2 i)).1, |
| supported_selected_eq G order d x p w n D s z.1 z.2 hz.ne' i] |
| exact lt_of_le_of_ne (scheduleWeight_nonneg G order d x p w hp h0 h1 n _ i _ _) |
| (Ne.symm (supported_schedule_ne_zero G order d x p w s n D z.1 z.2 hz.ne' i)) |
|
|
| lemma selected_moment (horder : LazyDFS.GoodDarts G order) (ho : LazyDFS.Exhaustive G order) |
| (hp : p ∈ Set.Ioo 0 1) (h0 : ∀ e, w e False = 1-p) (h1 : ∀ e, w e True = p) |
| (i : Fin n) (hi : i ∈ activeSteps n D) : |
| (∑ ym : (E → Bool) × Option E, |
| pushMass (selectedTranscript G d x n D i) (FiniteProduct.density (QueryTree.bitWeight p)) ym.1 * |
| selectedWeight G order d x p w n D i ym.1 ym.2 * |
| (1+selectedCost G order d x p w n D i ym.1 ym.2)) ≤ 4 := by |
| have hi' : (D i).2.2 = true := (Finset.mem_filter.mp hi).2 |
| rw [Fintype.sum_prod_type] |
| simp_rw [mul_assoc] |
| simp_rw [← Finset.mul_sum] |
| rw [sum_pushMass_mul] |
| simp_rw [(selected_run G order d x p w n D i _ _).1, |
| (selected_run G order d x p w n D i _ _).2] |
| simp only [selectedWeight,selectedCost,ite_eq_left hi',Fintype.sum_option,zero_mul,zero_add] |
| exact marked_pair_bound G order horder ho _ _ _ (scheduled_parent_mem d x n D i) hp w h0 h1 |
|
|
| end CriticalPercolation.BinaryLaw |
| end |
| end |
|
|
| end OAI |
|
|
