| import Mathlib |
|
|
| namespace OAI |
|
|
| section |
| section |
| namespace CriticalPercolation.InterpolationForest |
|
|
| structure Forest where |
| parent : ℕ → ℕ |
| parent_lt : ∀ n, 2 ≤ n → parent n < n |
|
|
| namespace Forest |
| variable (F : Forest) |
|
|
| def lineage (F : Forest) (n : ℕ) : List ℕ := |
| if _h : n < 2 then [n] else n :: F.lineage (F.parent n) |
| termination_by n |
| decreasing_by exact F.parent_lt n (by omega) |
|
|
| lemma lineage_base {n : ℕ} (h : n < 2) : F.lineage n = [n] := by |
| rw [lineage, dite_eq_left h] |
|
|
| lemma lineage_step {n : ℕ} (h : 2 ≤ n) : F.lineage n = n :: F.lineage (F.parent n) := by |
| rw [lineage, dite_eq_right (by omega : ¬n<2)] |
|
|
| lemma self_mem_lineage (n : ℕ) : n ∈ F.lineage n := by |
| rw [lineage] |
| split_ifs <;> simp |
|
|
| lemma mem_lineage_le {a n : ℕ} (h : a ∈ F.lineage n) : a ≤ n := by |
| induction n using Nat.strong_induction_on generalizing a with |
| | h n ih => |
| by_cases hn : n < 2 |
| · have he : a = n := by simpa only [F.lineage_base hn,List.mem_singleton] using h |
| exact he.le |
| · rw [F.lineage_step (by omega : 2 ≤ n),List.mem_cons] at h |
| rcases h with rfl|h |
| · exact le_rfl |
| · exact (ih (F.parent n) (F.parent_lt n (by omega)) h).trans |
| (F.parent_lt n (by omega)).le |
|
|
| lemma lineage_nodup (n : ℕ) : (F.lineage n).Nodup := by |
| induction n using Nat.strong_induction_on with |
| | h n ih => |
| by_cases hn : n < 2 |
| · simp [F.lineage_base hn] |
| · rw [F.lineage_step (by omega : 2 ≤ n),List.nodup_cons] |
| have hlt := F.parent_lt n (by omega) |
| exact ⟨fun h => (Nat.not_le_of_gt hlt) (F.mem_lineage_le h),ih _ hlt⟩ |
|
|
| def root (F : Forest) (n : ℕ) : ℕ := |
| if _h : n < 2 then n else F.root (F.parent n) |
| termination_by n |
| decreasing_by exact F.parent_lt n (by omega) |
|
|
| lemma root_base {n : ℕ} (h : n < 2) : F.root n = n := by |
| rw [root, dite_eq_left h] |
|
|
| lemma root_step {n : ℕ} (h : 2 ≤ n) : F.root n = F.root (F.parent n) := by |
| rw [root, dite_eq_right (by omega : ¬n<2)] |
|
|
| lemma root_lt_two (n : ℕ) : F.root n < 2 := by |
| induction n using Nat.strong_induction_on with |
| | h n ih => |
| by_cases hn : n < 2 |
| · simpa only [F.root_base hn] using hn |
| · rw [F.root_step (by omega : 2 ≤ n)] |
| exact ih _ (F.parent_lt n (by omega)) |
|
|
| lemma root_mem_lineage (n : ℕ) : F.root n ∈ F.lineage n := by |
| induction n using Nat.strong_induction_on with |
| | h n ih => |
| by_cases hn : n < 2 |
| · simp [F.root_base hn,F.lineage_base hn] |
| · rw [F.root_step (by omega : 2 ≤ n),F.lineage_step (by omega : 2 ≤ n)] |
| exact List.mem_cons_of_mem _ (ih _ (F.parent_lt n (by omega))) |
|
|
| lemma root_eq_of_mem {a n : ℕ} (h : a ∈ F.lineage n) : F.root a = F.root n := by |
| induction n using Nat.strong_induction_on generalizing a with |
| | h n ih => |
| by_cases hn : n < 2 |
| · have he : a=n := by simpa only [F.lineage_base hn,List.mem_singleton] using h |
| rw [he] |
| · rw [F.lineage_step (by omega : 2 ≤ n),List.mem_cons] at h |
| rcases h with rfl|h |
| · rfl |
| · rw [F.root_step (by omega : 2 ≤ n)] |
| exact ih _ (F.parent_lt n (by omega)) h |
|
|
| lemma lineage_disjoint {a b : ℕ} (h : F.root a ≠ F.root b) : |
| List.Disjoint (F.lineage a) (F.lineage b) := by |
| intro n ha hb |
| exact h ((F.root_eq_of_mem ha).symm.trans (F.root_eq_of_mem hb)) |
|
|
| lemma lineage_subset_of_mem {a n : ℕ} (h : a ∈ F.lineage n) : |
| F.lineage a ⊆ F.lineage n := by |
| induction n using Nat.strong_induction_on generalizing a with |
| | h n ih => |
| by_cases hn : n < 2 |
| · have he : a=n := by simpa only [F.lineage_base hn,List.mem_singleton] using h |
| rw [he] |
| · rw [F.lineage_step (by omega : 2 ≤ n),List.mem_cons] at h |
| rcases h with rfl|h |
| · exact List.Subset.refl _ |
| · intro b hb |
| rw [F.lineage_step (by omega : 2 ≤ n)] |
| exact List.mem_cons_of_mem _ (ih _ (F.parent_lt n (by omega)) h hb) |
|
|
| lemma parent_mem_lineage {a n : ℕ} (ha : 2 ≤ a) (h : a ∈ F.lineage n) : |
| F.parent a ∈ F.lineage n := by |
| apply F.lineage_subset_of_mem h |
| rw [F.lineage_step ha] |
| exact List.mem_cons_of_mem _ (F.self_mem_lineage _) |
|
|
| lemma parent_injective_lineage {n a b : ℕ} (ha : a ∈ F.lineage n) |
| (hb : b ∈ F.lineage n) (ha2 : 2 ≤ a) (hb2 : 2 ≤ b) |
| (he : F.parent a = F.parent b) : a=b := by |
| induction n using Nat.strong_induction_on generalizing a b with |
| | h n ih => |
| by_cases hn : n < 2 |
| · have := F.mem_lineage_le ha |
| omega |
| · rw [F.lineage_step (by omega : 2 ≤ n),List.mem_cons] at ha hb |
| rcases ha with rfl|ha <;> rcases hb with rfl|hb |
| · rfl |
| · have hle := F.mem_lineage_le hb |
| have hlt := F.parent_lt b hb2 |
| omega |
| · have hle := F.mem_lineage_le ha |
| have hlt := F.parent_lt a ha2 |
| omega |
| · exact ih _ (F.parent_lt n (by omega)) ha hb ha2 hb2 he |
|
|
| lemma parent_injective_two_lineages {u v a b : ℕ} |
| (huv : F.root u ≠ F.root v) |
| (ha : a ∈ F.lineage u ∨ a ∈ F.lineage v) |
| (hb : b ∈ F.lineage u ∨ b ∈ F.lineage v) |
| (ha2 : 2 ≤ a) (hb2 : 2 ≤ b) (he : F.parent a = F.parent b) : a=b := by |
| rcases ha with ha|ha <;> rcases hb with hb|hb |
| · exact F.parent_injective_lineage ha hb ha2 hb2 he |
| · have h1 := F.root_eq_of_mem (F.parent_mem_lineage ha2 ha) |
| have h2 := F.root_eq_of_mem (F.parent_mem_lineage hb2 hb) |
| exact (huv (h1.symm.trans ((congrArg F.root he).trans h2))).elim |
| · have h1 := F.root_eq_of_mem (F.parent_mem_lineage ha2 ha) |
| have h2 := F.root_eq_of_mem (F.parent_mem_lineage hb2 hb) |
| exact (huv (h2.symm.trans ((congrArg F.root he).symm.trans h1))).elim |
| · exact F.parent_injective_lineage ha hb ha2 hb2 he |
|
|
| end Forest |
| end CriticalPercolation.InterpolationForest |
|
|
| namespace CriticalPercolation.InterpolationForest.Forest |
| open scoped Classical |
|
|
| variable (F : Forest) |
|
|
| def active (u v : ℕ) : Finset ℕ := |
| ((F.lineage u ++ F.lineage v).toFinset).filter (fun i => 2 ≤ i) |
|
|
| lemma mem_active {u v a : ℕ} : a ∈ F.active u v ↔ |
| (a ∈ F.lineage u ∨ a ∈ F.lineage v) ∧ 2 ≤ a := by |
| simp [active] |
|
|
| lemma active_parent {u v a : ℕ} (ha : a ∈ F.active u v) : |
| F.parent a < 2 ∨ F.parent a ∈ F.active u v := by |
| by_cases hp : F.parent a < 2 |
| · exact Or.inl hp |
| · apply Or.inr |
| rw [mem_active] at ha ⊢ |
| exact ⟨ha.1.imp (F.parent_mem_lineage ha.2) (F.parent_mem_lineage ha.2),by omega⟩ |
|
|
| lemma parent_injOn_active {u v : ℕ} (huv : F.root u ≠ F.root v) : |
| Set.InjOn F.parent (↑(F.active u v) : Set ℕ) := by |
| intro a ha b hb he |
| rw [Finset.mem_coe,mem_active] at ha hb |
| exact F.parent_injective_two_lineages huv ha.1 hb.1 ha.2 hb.2 he |
|
|
| theorem active_pair_multiplicity {u v : ℕ} (huv : F.root u ≠ F.root v) (a : ℕ) : |
| ((F.active u v).filter fun b => b=a ∨ F.parent b=a).card ≤ 2 := by |
| have h1 : ((F.active u v).filter fun b => b=a).card ≤ 1 := by |
| rw [Finset.card_le_one] |
| intro b hb c hc |
| exact (Finset.mem_filter.mp hb).2.trans (Finset.mem_filter.mp hc).2.symm |
| have h2 : ((F.active u v).filter fun b => F.parent b=a).card ≤ 1 := by |
| rw [Finset.card_le_one] |
| intro b hb c hc |
| exact F.parent_injOn_active huv (Finset.mem_filter.mp hb).1 (Finset.mem_filter.mp hc).1 |
| ((Finset.mem_filter.mp hb).2.trans (Finset.mem_filter.mp hc).2.symm) |
| rw [Finset.filter_or] |
| exact (Finset.card_union_le _ _).trans (by omega) |
|
|
| lemma previous_lineage_le_parent {n a b : ℕ} (ha : a ∈ F.lineage n) |
| (hb : b ∈ F.lineage n) (ha2 : 2 ≤ a) (hba : b < a) : b ≤ F.parent a := by |
| induction n using Nat.strong_induction_on generalizing a b with |
| | h n ih => |
| by_cases hn : n < 2 |
| · have := F.mem_lineage_le ha |
| omega |
| · rw [F.lineage_step (by omega : 2 ≤ n),List.mem_cons] at ha hb |
| rcases ha with rfl|ha <;> rcases hb with rfl|hb |
| · omega |
| · exact F.mem_lineage_le hb |
| · have := F.mem_lineage_le ha |
| have := F.parent_lt b (by omega : 2 ≤ b) |
| omega |
| · exact ih _ (F.parent_lt n (by omega)) ha hb ha2 hba |
|
|
| theorem previous_active_le_parent {u v a b : ℕ} (huv : F.root u ≠ F.root v) |
| (ha : a ∈ F.active u v) (hb : b ∈ F.active u v) |
| (hside : F.root a = F.root b) (hba : b < a) : b ≤ F.parent a := by |
| rw [mem_active] at ha hb |
| rcases ha.1 with hau|hav <;> rcases hb.1 with hbu|hbv |
| · exact F.previous_lineage_le_parent hau hbu ha.2 hba |
| · exact (huv ((F.root_eq_of_mem hau).symm.trans (hside.trans (F.root_eq_of_mem hbv)))).elim |
| · exact (huv ((F.root_eq_of_mem hbu).symm.trans (hside.symm.trans (F.root_eq_of_mem hav)))).elim |
| · exact F.previous_lineage_le_parent hav hbv ha.2 hba |
|
|
| end CriticalPercolation.InterpolationForest.Forest |
| end |
| end |
|
|
| end OAI |
|
|
