openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Rooted /MaximumForestExchange.lean
| import OAI.Combinatorics.ContingencyTables.Rooted.MaximumForest | |
| namespace OAI | |
| /-! # The safe-edge invariant for the executed maximum-forest algorithm | |
| At every step, choose a largest-capacity edge whose endpoints lie in | |
| different current components. It extends the current forest inside a | |
| maximum-weight forest. This is the exchange proof behind the binary | |
| component-search implementation; no forest is enumerated by that program. | |
| -/ | |
| namespace ContingencyTables.MaximumForestExchange | |
| open SimpleGraph MaximumForest | |
| open scoped BigOperators Classical | |
| variable {V : Type*} [Fintype V] | |
| omit [Fintype V] in | |
| /-- In an acyclic supergraph, an edge between vertices already joined by | |
| the subgraph must itself belong to that subgraph. -/ | |
| lemma adj_of_reachable_of_acyclic {T F : SimpleGraph V} (hTF : T≤F) | |
| (hF : F.IsAcyclic) {u v : V} (hr : T.Reachable u v) (hf : F.Adj u v) : T.Adj u v := by | |
| have hc : (T⊔edge u v).IsAcyclic := | |
| hF.anti (sup_le hTF ((F.edge_le_iff).mpr (Or.inr hf))) | |
| have h := (isAcyclic_sup_fromEdgeSet_iff.mp hc).2 hr | |
| exact h.resolve_left hf.ne | |
| omit [Fintype V] in | |
| /-- Every path between different current components contains an edge | |
| between different current components. -/ | |
| lemma path_crosses {T F : SimpleGraph V} {u v : V} (p : F.Walk u v) | |
| (hn : ¬T.Reachable u v) : | |
| ∃ a b,F.Adj a b ∧ s(a,b)∈p.edges ∧ ¬T.Reachable a b := by | |
| induction p with | |
| | nil => exact (hn (Reachable.refl _)).elim | |
| | @cons u w v h p ih => | |
| by_cases hu : T.Reachable u w | |
| · obtain ⟨a,b,hab,he,hnab⟩ := ih (fun hw=>hn (hu.trans hw)) | |
| exact ⟨a,b,hab,by simp only [Walk.edges_cons,List.mem_cons]; exact Or.inr he,hnab⟩ | |
| · exact ⟨u,w,h,by simp only [Walk.edges_cons,List.mem_cons,true_or],hu⟩ | |
| lemma weight_delete {F : SimpleGraph V} (b : Sym2 V→ℕ) | |
| {e : Sym2 V} (he : e∈F.edgeSet) : | |
| weight (F.deleteEdges {e}) b+b e=weight F b := by | |
| have hs : (F.deleteEdges {e}).edgeFinset=F.edgeFinset.erase e := by | |
| ext a | |
| simp [edgeSet_deleteEdges,and_comm] | |
| rw [weight_eq (F.deleteEdges {e}),weight_eq F,hs] | |
| exact Finset.sum_erase_add (s:=F.edgeFinset) (a:=e) b (by simpa using he) | |
| /-- The current forest is contained in some globally optimal forest. -/ | |
| def Extendible (G T : SimpleGraph V) (b : Sym2 V→ℕ) : Prop := | |
| ∃ F : SimpleGraph V,T≤F ∧ F≤G ∧ F.IsAcyclic ∧ | |
| ∀ H : SimpleGraph V,H≤G → H.IsAcyclic → weight H b≤weight F b | |
| lemma bottom_extendible (G : SimpleGraph V) (b : Sym2 V→ℕ) : Extendible G ⊥ b := by | |
| obtain ⟨F,hFG,hF,hmax⟩ := exists_maximum G b | |
| exact ⟨F,bot_le,hFG,hF,hmax⟩ | |
| /-- A greatest edge joining two current components is safe. The argument | |
| uses a maximum forest only as a witness for the invariant. -/ | |
| theorem safe_edge (G T : SimpleGraph V) (b : Sym2 V→ℕ) | |
| (hb : ∀ e∈G.edgeSet,0<b e) (hT : Extendible G T b) | |
| {u v : V} (he : G.Adj u v) (hn : ¬T.Reachable u v) | |
| (hbest : ∀ a d,G.Adj a d → ¬T.Reachable a d → b s(a,d)≤b s(u,v)) : | |
| Extendible G (T⊔edge u v) b := by | |
| obtain ⟨F,hTF,hFG,hF,hmax⟩ := hT | |
| by_cases hef : F.Adj u v | |
| · exact ⟨F,sup_le hTF ((F.edge_le_iff).mpr (Or.inr hef)),hFG,hF,hmax⟩ | |
| have hspan := maximum_spans G F b hFG hF hmax hb | |
| have hreach : F.Reachable u v := by rw [hspan]; exact he.reachable | |
| obtain ⟨p,hp⟩ := hreach.exists_isPath | |
| obtain ⟨a,d,had,ht,hnad⟩ := path_crosses p hn | |
| let t := s(a,d) | |
| let D := F.deleteEdges {t} | |
| have htF : t∈F.edgeSet := by simpa only [t,mem_edgeSet] using had | |
| have htT : ¬T.Adj a d := fun h=>hnad h.reachable | |
| have hTD : T≤D := by | |
| intro x y hxy | |
| have hne : s(x,y)≠t := by | |
| intro hxyad | |
| have ha : T.Adj a d := by | |
| have hmem : t∈T.edgeSet := by rw [←hxyad]; simpa using hxy | |
| simpa only [t,mem_edgeSet] using hmem | |
| exact htT ha | |
| exact (deleteEdges_adj).mpr ⟨hTF hxy,by simpa only [Set.mem_singleton_iff] using hne⟩ | |
| have hDF : D≤F := F.deleteEdges_le {t} | |
| have hDuv : ¬D.Reachable u v := | |
| not_reachable_delete_path_edge F hF p hp t ht | |
| have hDacyc : (D⊔edge u v).IsAcyclic := | |
| (hF.anti hDF).sup_edge_of_not_reachable hDuv | |
| have hDfree : ¬D.Adj u v := fun h=>hef (hDF h) | |
| have hDG : D⊔edge u v≤G := | |
| sup_le (hDF.trans hFG) ((G.edge_le_iff).mpr (Or.inr he)) | |
| have hweight := weight_sup_edge D b u v hDfree he.ne | |
| have hdelete := weight_delete b htF | |
| have hbetter := hbest a d (hFG had) hnad | |
| have hmono : weight F b≤weight (D⊔edge u v) b := by | |
| dsimp only [D,t] at hweight hdelete hbetter ⊢ | |
| omega | |
| refine ⟨D⊔edge u v,sup_le_sup_right hTD _,hDG,hDacyc,?_⟩ | |
| intro H hHG hH | |
| exact (hmax H hHG hH).trans hmono | |
| /-- Once no edge joins different current components, the invariant | |
| certifies global optimality of the current forest. -/ | |
| theorem finished (G T : SimpleGraph V) (b : Sym2 V→ℕ) | |
| (hT : Extendible G T b) | |
| (hn : ∀ u v,G.Adj u v → T.Reachable u v) : | |
| T≤G ∧ T.IsAcyclic ∧ | |
| ∀ H : SimpleGraph V,H≤G → H.IsAcyclic → weight H b≤weight T b := by | |
| obtain ⟨F,hTF,hFG,hF,hmax⟩ := hT | |
| have hFT : F≤T := by | |
| intro u v hf | |
| exact adj_of_reachable_of_acyclic hTF hF (hn u v (hFG hf)) hf | |
| have heq : F=T := le_antisymm hFT hTF | |
| exact heq ▸ ⟨hFG,hF,hmax⟩ | |
| end ContingencyTables.MaximumForestExchange | |
| end OAI | |