| import OAI.Probability.FreeIsing.Trees.Cardinality |
| import OAI.Probability.FreeIsing.Trees.ClusterRestriction |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace Problem367.ClusterComponentCount |
|
|
| variable {d : ℕ} |
|
|
| def openAdj (O : TreeVertex d → Bool) (u v : TreeVertex d) : Prop := |
| (u = parentVertex v ∧ v.1 ≠ [] ∧ O v = true) ∨ |
| (v = parentVertex u ∧ u.1 ≠ [] ∧ O u = true) |
|
|
| lemma openAdj_symm {O : TreeVertex d → Bool} {u v : TreeVertex d} |
| (h : openAdj O u v) : openAdj O v u := h.elim Or.inr Or.inl |
|
|
| lemma openAdj_treeAdj {O : TreeVertex d → Bool} {u v : TreeVertex d} |
| (h : openAdj O u v) : treeAdj u v := by |
| rcases h with ⟨rfl, hv, _⟩ | ⟨rfl, hu, _⟩ |
| · exact treeAdj_parentVertex hv |
| · rcases treeAdj_parentVertex hu with h | h |
| · exact Or.inr h |
| · exact Or.inl h |
|
|
| def openRoot (O : TreeVertex d → Bool) (v : TreeVertex d) : TreeVertex d := |
| if _hv : v.1 = [] then v |
| else if O v = true then openRoot O (parentVertex v) else v |
| termination_by v.1.length |
| decreasing_by |
| rw [parentVertex_length] |
| have := List.length_pos_iff.mpr _hv |
| omega |
|
|
| lemma openRoot_of_nil (O : TreeVertex d → Bool) {v : TreeVertex d} |
| (hv : v.1 = []) : openRoot O v = v := by |
| rw [openRoot, dite_eq_left hv] |
|
|
| lemma openRoot_of_closed (O : TreeVertex d → Bool) {v : TreeVertex d} |
| (hv : O v ≠ true) : openRoot O v = v := by |
| rw [openRoot] |
| split_ifs <;> rfl |
|
|
| lemma openRoot_of_open (O : TreeVertex d → Bool) {v : TreeVertex d} |
| (hv : v.1 ≠ []) (ho : O v = true) : |
| openRoot O v = openRoot O (parentVertex v) := by |
| rw [openRoot, dite_eq_right hv, ite_eq_left ho] |
|
|
| lemma openRoot_prefix (O : TreeVertex d → Bool) (v : TreeVertex d) : |
| (openRoot O v).1 <+: v.1 := by |
| induction hvlen : v.1.length using Nat.strong_induction_on generalizing v with |
| | h n ih => |
| by_cases hv : v.1 = [] |
| · rw [openRoot_of_nil O hv] |
| · by_cases ho : O v = true |
| · rw [openRoot_of_open O hv ho] |
| have hp : (parentVertex v).1.length < n := by |
| rw [parentVertex_length] |
| have := List.length_pos_iff.mpr hv |
| omega |
| exact (ih _ hp _ rfl).trans (List.dropLast_prefix v.1) |
| · rw [openRoot_of_closed O ho] |
|
|
| lemma openRoot_length_le (O : TreeVertex d → Bool) (v : TreeVertex d) : |
| (openRoot O v).1.length ≤ v.1.length := (openRoot_prefix O v).length_le |
|
|
| lemma openRoot_stopped (O : TreeVertex d → Bool) (v : TreeVertex d) : |
| (openRoot O v).1 = [] ∨ O (openRoot O v) ≠ true := by |
| induction hvlen : v.1.length using Nat.strong_induction_on generalizing v with |
| | h n ih => |
| by_cases hv : v.1 = [] |
| · rw [openRoot_of_nil O hv] |
| exact Or.inl hv |
| · by_cases ho : O v = true |
| · rw [openRoot_of_open O hv ho] |
| apply ih _ _ _ rfl |
| rw [parentVertex_length] |
| have := List.length_pos_iff.mpr hv |
| omega |
| · rw [openRoot_of_closed O ho] |
| exact Or.inr ho |
|
|
| lemma openRoot_idempotent (O : TreeVertex d → Bool) (v : TreeVertex d) : |
| openRoot O (openRoot O v) = openRoot O v := by |
| rcases openRoot_stopped O v with h | h |
| · exact openRoot_of_nil O h |
| · exact openRoot_of_closed O h |
|
|
| lemma openRoot_eq_of_openAdj {O : TreeVertex d → Bool} {u v : TreeVertex d} |
| (h : openAdj O u v) : openRoot O u = openRoot O v := by |
| rcases h with ⟨rfl, hv, ho⟩ | ⟨rfl, hu, ho⟩ |
| · exact (openRoot_of_open O hv ho).symm |
| · exact openRoot_of_open O hu ho |
|
|
| lemma openRoot_eq_of_connected {O : TreeVertex d → Bool} {u v : TreeVertex d} |
| (h : Relation.ReflTransGen (openAdj O) u v) : openRoot O u = openRoot O v := by |
| induction h with |
| | refl => rfl |
| | tail h huv ih => exact ih.trans (openRoot_eq_of_openAdj huv) |
|
|
| lemma connected_openRoot (O : TreeVertex d → Bool) (v : TreeVertex d) : |
| Relation.ReflTransGen (openAdj O) v (openRoot O v) := by |
| induction hvlen : v.1.length using Nat.strong_induction_on generalizing v with |
| | h n ih => |
| by_cases hv : v.1 = [] |
| · rw [openRoot_of_nil O hv] |
| · by_cases ho : O v = true |
| · rw [openRoot_of_open O hv ho] |
| have hs : openAdj O v (parentVertex v) := Or.inr ⟨rfl, hv, ho⟩ |
| apply (Relation.ReflTransGen.single hs).trans |
| apply ih _ _ _ rfl |
| rw [parentVertex_length] |
| have := List.length_pos_iff.mpr hv |
| omega |
| · rw [openRoot_of_closed O ho] |
|
|
| lemma connected_symm {O : TreeVertex d → Bool} {u v : TreeVertex d} |
| (h : Relation.ReflTransGen (openAdj O) u v) : |
| Relation.ReflTransGen (openAdj O) v u := by |
| induction h with |
| | refl => exact Relation.ReflTransGen.refl |
| | tail h hab ih => exact (Relation.ReflTransGen.single (openAdj_symm hab)).trans ih |
|
|
| lemma connected_of_openRoot_eq {O : TreeVertex d → Bool} {u v : TreeVertex d} |
| (h : openRoot O u = openRoot O v) : Relation.ReflTransGen (openAdj O) u v := by |
| have hu := connected_openRoot O u |
| have hv := connected_openRoot O v |
| rw [h] at hu |
| exact hu.trans (connected_symm hv) |
|
|
| lemma connected_iff_openRoot_eq (O : TreeVertex d → Bool) (u v : TreeVertex d) : |
| Relation.ReflTransGen (openAdj O) u v ↔ openRoot O u = openRoot O v := |
| ⟨openRoot_eq_of_connected, connected_of_openRoot_eq⟩ |
|
|
| lemma openRoot_mem_or_eq {O : TreeVertex d → Bool} |
| {D : Finset (TreeVertex d)} (hD : ConnectedFinset D) |
| {r : TreeVertex d} (hr : r ∈ D) |
| (hmin : ∀ w ∈ D, r.1.length ≤ w.1.length) |
| {v : TreeVertex d} (hv : v ∈ D) : |
| openRoot O v = openRoot O r ∨ |
| (openRoot O v ∈ D ∧ openRoot O v ≠ r ∧ O (openRoot O v) ≠ true) := by |
| induction hvlen : v.1.length using Nat.strong_induction_on generalizing v with |
| | h n ih => |
| by_cases hvr : v = r |
| · subst v |
| exact Or.inl rfl |
| · have hnil := ConnectedFinset.ne_nil_of_ne_min hmin hv hvr |
| by_cases ho : O v = true |
| · rw [openRoot_of_open O hnil ho] |
| have hparent := hD.parent_mem_of_ne_min hr hmin hv hvr |
| apply ih _ _ hparent rfl |
| rw [parentVertex_length] |
| have := List.length_pos_iff.mpr hnil |
| omega |
| · rw [openRoot_of_closed O ho] |
| exact Or.inr ⟨hv, hvr, ho⟩ |
|
|
| lemma image_openRoot {O : TreeVertex d → Bool} |
| {D : Finset (TreeVertex d)} (hD : ConnectedFinset D) |
| {r : TreeVertex d} (hr : r ∈ D) |
| (hmin : ∀ w ∈ D, r.1.length ≤ w.1.length) : |
| D.image (openRoot O) = |
| insert (openRoot O r) ((D.erase r).filter (fun v => O v ≠ true)) := by |
| classical |
| ext x |
| constructor |
| · intro hx |
| obtain ⟨v, hv, rfl⟩ := Finset.mem_image.mp hx |
| rcases openRoot_mem_or_eq hD hr hmin hv with h | ⟨hm, hn, ho⟩ |
| · exact Finset.mem_insert.mpr (Or.inl h) |
| · exact Finset.mem_insert.mpr (Or.inr |
| (Finset.mem_filter.mpr ⟨Finset.mem_erase.mpr ⟨hn, hm⟩, ho⟩)) |
| · intro hx |
| rcases Finset.mem_insert.mp hx with h | h |
| · subst x |
| exact Finset.mem_image.mpr ⟨r, hr, rfl⟩ |
| · obtain ⟨hx, ho⟩ := Finset.mem_filter.mp h |
| exact Finset.mem_image.mpr ⟨x, (Finset.mem_erase.mp hx).2, |
| openRoot_of_closed O ho⟩ |
|
|
| lemma openRoot_not_mem_closed {O : TreeVertex d → Bool} |
| {D : Finset (TreeVertex d)} (hD : ConnectedFinset D) |
| {r : TreeVertex d} (hr : r ∈ D) |
| (hmin : ∀ w ∈ D, r.1.length ≤ w.1.length) : |
| openRoot O r ∉ (D.erase r).filter (fun v => O v ≠ true) := by |
| classical |
| intro h |
| obtain ⟨hm, _⟩ := Finset.mem_filter.mp h |
| obtain ⟨hne, hmem⟩ := Finset.mem_erase.mp hm |
| exact hne (hD.min_unique hr hmin hmem (openRoot_length_le O r)) |
|
|
| def openEdges (O : TreeVertex d → Bool) (D : Finset (TreeVertex d)) : |
| Finset (TreeVertex d × TreeVertex d) := |
| (inducedEdges D).filter (fun e => O e.2 = true) |
|
|
| lemma image_openEdges_snd {O : TreeVertex d → Bool} |
| {D : Finset (TreeVertex d)} (hD : ConnectedFinset D) |
| {r : TreeVertex d} (hr : r ∈ D) |
| (hmin : ∀ w ∈ D, r.1.length ≤ w.1.length) : |
| (openEdges O D).image Prod.snd = (D.erase r).filter (fun v => O v = true) := by |
| classical |
| rw [← hD.inducedEdges_image_snd hr hmin] |
| ext v |
| simp only [openEdges, Finset.mem_image, Finset.mem_filter] |
| constructor |
| · rintro ⟨e, ⟨he, ho⟩, rfl⟩ |
| exact ⟨⟨e, he, rfl⟩, ho⟩ |
| · rintro ⟨⟨e, he, rfl⟩, ho⟩ |
| exact ⟨e, ⟨he, ho⟩, rfl⟩ |
|
|
| theorem card_image_openRoot (O : TreeVertex d → Bool) |
| {D : Finset (TreeVertex d)} (hD : ConnectedFinset D) : |
| (D.image (openRoot O)).card = D.card - (openEdges O D).card := by |
| classical |
| obtain ⟨r, hr, hmin⟩ := D.exists_min_image (fun v => v.1.length) hD.1 |
| rw [image_openRoot hD hr hmin, |
| Finset.card_insert_of_notMem (openRoot_not_mem_closed hD hr hmin)] |
| have hopen : (openEdges O D).card = |
| ((D.erase r).filter (fun v => O v = true)).card := by |
| rw [← image_openEdges_snd hD hr hmin] |
| exact (Finset.card_image_of_injOn (fun x hx y hy hxy => |
| inducedEdges_snd_injOn D (Finset.mem_filter.mp hx).1 |
| (Finset.mem_filter.mp hy).1 hxy)).symm |
| have hsplit := (D.erase r).card_filter_add_card_filter_not (fun v => O v = true) |
| rw [Finset.card_erase_of_mem hr, ← hopen] at hsplit |
| have hpos : 0 < D.card := Finset.card_pos.mpr hD.1 |
| simp only [ne_eq] at * |
| omega |
|
|
| lemma card_image_eq_of_same_fibers {V A B : Type*} [DecidableEq A] [DecidableEq B] |
| (D : Finset V) |
| (f : V → A) (g : V → B) |
| (h : ∀ x ∈ D, ∀ y ∈ D, f x = f y ↔ g x = g y) : |
| (D.image f).card = (D.image g).card := by |
| classical |
| induction D using Finset.induction_on with |
| | empty => simp |
| | @insert a D ha ih => |
| have hsmall : ∀ x ∈ D, ∀ y ∈ D, f x = f y ↔ g x = g y := by |
| intro x hx y hy |
| exact h x (Finset.mem_insert_of_mem hx) y (Finset.mem_insert_of_mem hy) |
| have hc := ih hsmall |
| have hm : f a ∈ D.image f ↔ g a ∈ D.image g := by |
| constructor |
| · rintro hf |
| obtain ⟨x, hx, hfx⟩ := Finset.mem_image.mp hf |
| exact Finset.mem_image.mpr ⟨x, hx, |
| (h x (Finset.mem_insert_of_mem hx) a (Finset.mem_insert_self _ _)).mp hfx⟩ |
| · rintro hg |
| obtain ⟨x, hx, hgx⟩ := Finset.mem_image.mp hg |
| exact Finset.mem_image.mpr ⟨x, hx, |
| (h x (Finset.mem_insert_of_mem hx) a (Finset.mem_insert_self _ _)).mpr hgx⟩ |
| rw [Finset.image_insert, Finset.image_insert] |
| by_cases hf : f a ∈ D.image f |
| · rw [Finset.card_insert_of_mem hf, Finset.card_insert_of_mem (hm.mp hf), hc] |
| · rw [Finset.card_insert_of_notMem hf, |
| Finset.card_insert_of_notMem (fun hg => hf (hm.mpr hg)), hc] |
|
|
| theorem card_image_componentLabel {A : Type*} [DecidableEq A] (O : TreeVertex d → Bool) |
| (label : TreeVertex d → A) |
| (hlabel : ∀ u v, label u = label v ↔ Relation.ReflTransGen (openAdj O) u v) |
| {D : Finset (TreeVertex d)} (hD : ConnectedFinset D) : |
| (D.image label).card = D.card - (openEdges O D).card := by |
| classical |
| calc |
| (D.image label).card = (D.image (openRoot O)).card := |
| card_image_eq_of_same_fibers D label (openRoot O) |
| (fun u _ v _ => (hlabel u v).trans (connected_iff_openRoot_eq O u v)) |
| _ = _ := card_image_openRoot O hD |
|
|
| theorem connected_iff_internal {O : TreeVertex d → Bool} |
| {D : Finset (TreeVertex d)} (hD : ConnectedFinset D) |
| {u v : TreeVertex d} (hu : u ∈ D) (hv : v ∈ D) : |
| Relation.ReflTransGen (openAdj O) u v ↔ |
| Relation.ReflTransGen (fun x y => x ∈ D ∧ y ∈ D ∧ openAdj O x y) u v := |
| hD.reachable_restrict_iff openAdj_treeAdj hu hv |
|
|
| lemma openAdj_iff_mem_openEdges {O : TreeVertex d → Bool} |
| {D : Finset (TreeVertex d)} {u v : TreeVertex d} (hu : u ∈ D) (hv : v ∈ D) : |
| openAdj O u v ↔ (u, v) ∈ openEdges O D ∨ (v, u) ∈ openEdges O D := by |
| classical |
| have hmem (a b : TreeVertex d) : (a,b) ∈ openEdges O D ↔ |
| (a ∈ D ∧ b ∈ D) ∧ (treeAdj a b ∧ a.1.length < b.1.length) ∧ O b = true := by |
| simp [openEdges, inducedEdges, and_assoc] |
| constructor |
| · rintro (⟨rfl, hn, ho⟩ | ⟨rfl, hn, ho⟩) |
| · left |
| apply (hmem _ _).mpr |
| refine ⟨⟨hu, hv⟩, ⟨treeAdj_parentVertex hn, ?_⟩, ho⟩ |
| rw [parentVertex_length] |
| have := List.length_pos_iff.mpr hn |
| omega |
| · right |
| apply (hmem _ _).mpr |
| refine ⟨⟨hv, hu⟩, ⟨treeAdj_parentVertex hn, ?_⟩, ho⟩ |
| rw [parentVertex_length] |
| have := List.length_pos_iff.mpr hn |
| omega |
| · rintro (h | h) |
| · obtain ⟨_, ⟨hadj, hlt⟩, ho⟩ := (hmem _ _).mp h |
| left |
| refine ⟨(treeAdj_parent_of_length_lt hadj hlt).symm, ?_, ho⟩ |
| intro hn |
| simp [hn] at hlt |
| · obtain ⟨_, ⟨hadj, hlt⟩, ho⟩ := (hmem _ _).mp h |
| right |
| refine ⟨(treeAdj_parent_of_length_lt hadj hlt).symm, ?_, ho⟩ |
| intro hn |
| simp [hn] at hlt |
|
|
| theorem compatible_iff_component_constant {A : Type*} |
| (O : TreeVertex d → Bool) (eta : TreeVertex d → A) |
| {D : Finset (TreeVertex d)} (hD : ConnectedFinset D) : |
| (∀ e ∈ openEdges O D, eta e.1 = eta e.2) ↔ |
| ∀ u ∈ D, ∀ v ∈ D, Relation.ReflTransGen (openAdj O) u v → eta u = eta v := by |
| classical |
| constructor |
| · intro he u hu v hv hc |
| have hi := (connected_iff_internal hD hu hv).mp hc |
| clear hu hv hc |
| induction hi with |
| | refl => rfl |
| | tail h hab ih => |
| apply ih.trans |
| rcases (openAdj_iff_mem_openEdges hab.1 hab.2.1).mp hab.2.2 with h | h |
| · exact he _ h |
| · exact (he _ h).symm |
| · intro he e hee |
| have hdata : e.1 ∈ D ∧ e.2 ∈ D := by |
| have hmem := (Finset.mem_filter.mp hee).1 |
| exact Finset.mem_product.mp (Finset.mem_filter.mp hmem).1 |
| exact he e.1 hdata.1 e.2 hdata.2 |
| (Relation.ReflTransGen.single |
| ((openAdj_iff_mem_openEdges hdata.1 hdata.2).mpr (Or.inl hee))) |
|
|
| theorem compatible_iff_label_constant {A B : Type*} |
| (O : TreeVertex d → Bool) (label : TreeVertex d → A) |
| (hlabel : ∀ u v, label u = label v ↔ Relation.ReflTransGen (openAdj O) u v) |
| (eta : TreeVertex d → B) {D : Finset (TreeVertex d)} (hD : ConnectedFinset D) : |
| (∀ e ∈ openEdges O D, eta e.1 = eta e.2) ↔ |
| ∀ u ∈ D, ∀ v ∈ D, label u = label v → eta u = eta v := by |
| rw [compatible_iff_component_constant O eta hD] |
| constructor |
| · intro h u hu v hv heq |
| exact h u hu v hv ((hlabel u v).mp heq) |
| · intro h u hu v hv hconn |
| exact h u hu v hv ((hlabel u v).mpr hconn) |
|
|
| def edgeMask (R : TreeVertex d → TreeVertex d → Prop) [DecidableRel R] |
| (v : TreeVertex d) : Bool := decide (R (parentVertex v) v) |
|
|
| lemma openAdj_edgeMask_iff {R : TreeVertex d → TreeVertex d → Prop} [DecidableRel R] |
| (hR : ∀ {u v}, R u v → treeAdj u v) |
| (hsymm : ∀ {u v}, R u v → R v u) (u v : TreeVertex d) : |
| openAdj (edgeMask R) u v ↔ R u v := by |
| constructor |
| · rintro (⟨rfl, _, ho⟩ | ⟨rfl, _, ho⟩) |
| · exact of_decide_eq_true ho |
| · exact hsymm (of_decide_eq_true ho) |
| · intro huv |
| have hadj := hR huv |
| rcases treeAdj_length hadj with hlen | hlen |
| · have hlt : u.1.length < v.1.length := by omega |
| have hp := treeAdj_parent_of_length_lt hadj hlt |
| left |
| refine ⟨hp.symm, ?_, ?_⟩ |
| · intro hn |
| simp [hn] at hlt |
| · simp only [edgeMask, hp, decide_eq_true_eq] |
| exact huv |
| · have hlt : v.1.length < u.1.length := by omega |
| have hrev : treeAdj v u := hadj.elim Or.inr Or.inl |
| have hp := treeAdj_parent_of_length_lt hrev hlt |
| right |
| refine ⟨hp.symm, ?_, ?_⟩ |
| · intro hn |
| simp [hn] at hlt |
| · simp only [edgeMask, hp, decide_eq_true_eq] |
| exact hsymm huv |
|
|
| lemma connected_edgeMask_iff {R : TreeVertex d → TreeVertex d → Prop} [DecidableRel R] |
| (hR : ∀ {u v}, R u v → treeAdj u v) |
| (hsymm : ∀ {u v}, R u v → R v u) (u v : TreeVertex d) : |
| Relation.ReflTransGen (openAdj (edgeMask R)) u v ↔ Relation.ReflTransGen R u v := by |
| have heq : openAdj (edgeMask R) = R := by |
| funext u v |
| exact propext (openAdj_edgeMask_iff hR hsymm u v) |
| rw [heq] |
|
|
| lemma openEdges_edgeMask (R : TreeVertex d → TreeVertex d → Prop) [DecidableRel R] |
| (D : Finset (TreeVertex d)) : |
| openEdges (edgeMask R) D = (inducedEdges D).filter (fun e => R e.1 e.2) := by |
| classical |
| apply Finset.filter_congr |
| intro e he |
| have he' := (Finset.mem_filter.mp he).2 |
| have hp := treeAdj_parent_of_length_lt he'.1 he'.2 |
| simp only [edgeMask, hp, decide_eq_true_eq] |
|
|
| theorem card_image_of_relation {A : Type*} [DecidableEq A] |
| {R : TreeVertex d → TreeVertex d → Prop} [DecidableRel R] |
| (hR : ∀ {u v}, R u v → treeAdj u v) |
| (hsymm : ∀ {u v}, R u v → R v u) |
| (label : TreeVertex d → A) |
| (hlabel : ∀ u v, label u = label v ↔ Relation.ReflTransGen R u v) |
| {D : Finset (TreeVertex d)} (hD : ConnectedFinset D) : |
| (D.image label).card = |
| D.card - ((inducedEdges D).filter (fun e => R e.1 e.2)).card := by |
| classical |
| rw [← openEdges_edgeMask R D] |
| apply card_image_componentLabel (edgeMask R) label _ hD |
| intro u v |
| exact (hlabel u v).trans (connected_edgeMask_iff hR hsymm u v).symm |
|
|
| end Problem367.ClusterComponentCount |
|
|
| end |
|
|
| end OAI |
|
|
