openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Rooted /ForestGreedySemantics.lean
| import OAI.Combinatorics.ContingencyTables.Rooted.ForestGreedyProgram | |
| import OAI.Combinatorics.ContingencyTables.Rooted.MaximumForestExchange | |
| namespace OAI | |
| /-! # Correctness of the actual binary forest loop | |
| The invariant refers to the adjacency list produced by the program. | |
| The final graph is decoded directly from that list. Optimal forests | |
| occur only as proof witnesses for the safe-edge invariant. | |
| -/ | |
| namespace ContingencyTables.ForestGreedySemantics | |
| open SimpleGraph MaximumForest MaximumForestExchange | |
| open ForestGreedyProgram ForestEdgeChoiceProgram FiniteGraphRootProgram WeightedArgmaxProgram | |
| open scoped Classical | |
| variable {n : ℕ} | |
| /-- Every stored edge is valid, and every graph edge is stored in at least | |
| one orientation with its exact capacity. -/ | |
| def Catalog (G : SimpleGraph (Fin n)) (b : Sym2 (Fin n)→ℕ) (es : List Edge) : Prop := | |
| (∀ e∈es,∃ u v : Fin n,G.Adj u v ∧ e=((u.val,v.val),b s(u,v))) ∧ | |
| (∀ u v,G.Adj u v → | |
| ((u.val,v.val),b s(u,v))∈es ∨ ((v.val,u.val),b s(u,v))∈es) | |
| lemma chosen_spec {G T : SimpleGraph (Fin n)} {b : Sym2 (Fin n)→ℕ} {es : List Edge} | |
| (hC : Catalog G b es) {e : Edge} (he : choice (graphCode T,es)=some e) : | |
| ∃ u v : Fin n,e=((u.val,v.val),b s(u,v)) ∧ G.Adj u v ∧ ¬T.Reachable u v ∧ | |
| ∀ a d,G.Adj a d → ¬T.Reachable a d → b s(a,d)≤b s(u,v) := by | |
| have hm := choice_mem he | |
| obtain ⟨u,v,hG,heq⟩ := hC.1 e hm.1 | |
| subst e | |
| have hnu : ¬T.Reachable u v := (eligible_code T es u v _).mp hm.2 | |
| refine ⟨u,v,rfl,hG,hnu,?_⟩ | |
| intro a d had hn | |
| rcases hC.2 a d had with hmem|hmem | |
| · exact choice_max he hmem ((eligible_code T es a d _).mpr hn) | |
| · exact choice_max he hmem ((eligible_code T es d a _).mpr (fun hd=>hn hd.symm)) | |
| lemma none_spec {G T : SimpleGraph (Fin n)} {b : Sym2 (Fin n)→ℕ} {es : List Edge} | |
| (hC : Catalog G b es) (he : choice (graphCode T,es)=none) : | |
| ∀ u v,G.Adj u v → T.Reachable u v := by | |
| intro u v hG | |
| by_contra hn | |
| rcases hC.2 u v hG with hmem|hmem | |
| · have hfalse := choice_none he _ hmem | |
| have htrue := (eligible_code T es u v (b s(u,v))).mpr hn | |
| exact Bool.noConfusion (hfalse.symm.trans htrue) | |
| · have hfalse := choice_none he _ hmem | |
| have htrue := (eligible_code T es v u (b s(u,v))).mpr (fun hr=>hn hr.symm) | |
| exact Bool.noConfusion (hfalse.symm.trans htrue) | |
| def iterate : ℕ→State→State | |
| | 0,s=>s | |
| | k+1,s=>iterate k (ForestGreedyProgram.advance (0,s)) | |
| lemma fold_eq_iterate (xs : List ℕ) (s : State) : | |
| xs.foldl (fun s a=>ForestGreedyProgram.advance (a,s)) s=iterate xs.length s := by | |
| induction xs generalizing s with | |
| | nil=>rfl | |
| | cons a xs ih=>simpa only [List.foldl_cons,List.length_cons,iterate,ForestGreedyProgram.advance] using ih (ForestGreedyProgram.advance (a,s)) | |
| lemma execute_iterate (s : State) : execute s=iterate (s.1.length*s.1.length) s := by | |
| simpa only [execute,slots,List.length_range] using fold_eq_iterate (slots s) s | |
| lemma advance_none {s : State} (he : choice s=none) : ForestGreedyProgram.advance (0,s)=s := by | |
| simp only [ForestGreedyProgram.advance,update,he,Option.elim_none] | |
| lemma iterate_none {s : State} (he : choice s=none) (k : ℕ) : iterate k s=s := by | |
| induction k with | |
| | zero=>rfl | |
| | succ k ih=>simpa only [iterate,advance_none he] using ih | |
| lemma advance_code (T : SimpleGraph (Fin n)) (es : List Edge) (u v : Fin n) | |
| (w : ℕ) (hne : u≠v) | |
| (he : choice (graphCode T,es)=some ((u.val,v.val),w)) : | |
| ForestGreedyProgram.advance (0,(graphCode T,es))=(graphCode (T⊔edge u v),es) := by | |
| simp only [ForestGreedyProgram.advance,update,he,Option.elim_some] | |
| change (ForestJoinProgram.join (graphCode T,(u.val,v.val)),es)=_ | |
| rw [ForestJoinProgram.join_code T u v hne] | |
| private noncomputable def edgeCount (G : SimpleGraph (Fin n)) : ℕ := G.edgeFinset.card | |
| private lemma edgeCount_le (G : SimpleGraph (Fin n)) : | |
| edgeCount G≤Fintype.card (Sym2 (Fin n)) := Finset.card_le_univ _ | |
| private lemma card_add (T : SimpleGraph (Fin n)) {u v : Fin n} | |
| (hn : ¬T.Reachable u v) (huv : u≠v) : | |
| edgeCount (T⊔edge u v)=edgeCount T+1 := by | |
| have h := T.card_edgeFinset_sup_edge (fun ht=>hn ht.reachable) huv | |
| unfold edgeCount | |
| convert h using 1 | |
| congr 1 | |
| ext a | |
| simp only [mem_edgeFinset] | |
| /-- A fuel count at least the number of missing unordered edges suffices | |
| for the executed loop, without any tie-breaking assumption. -/ | |
| theorem iterate_optimal (G T : SimpleGraph (Fin n)) (b : Sym2 (Fin n)→ℕ) | |
| (es : List Edge) (hC : Catalog G b es) (hb : ∀ e∈G.edgeSet,0<b e) | |
| (hT : Extendible G T b) (k : ℕ) | |
| (hbudget : Fintype.card (Sym2 (Fin n))≤edgeCount T+k) : | |
| ∃ F : SimpleGraph (Fin n),iterate k (graphCode T,es)=(graphCode F,es) ∧ | |
| F≤G ∧ F.IsAcyclic ∧ | |
| ∀ H : SimpleGraph (Fin n),H≤G → H.IsAcyclic → weight H b≤weight F b := by | |
| induction k generalizing T with | |
| | zero=> | |
| have hnone : choice (graphCode T,es)=none := by | |
| cases he : choice (graphCode T,es) with | |
| | none=>rfl | |
| | some e=> | |
| obtain ⟨u,v,_,hg,hn,_⟩ := chosen_spec hC he | |
| have hc := card_add T hn hg.ne | |
| have hle := edgeCount_le (T⊔edge u v) | |
| omega | |
| exact ⟨T,rfl,finished G T b hT (none_spec hC hnone)⟩ | |
| | succ k ih=> | |
| cases he : choice (graphCode T,es) with | |
| | none=>exact ⟨T,iterate_none he _,finished G T b hT (none_spec hC he)⟩ | |
| | some e=> | |
| obtain ⟨u,v,rfl,hg,hn,hbest⟩ := chosen_spec hC he | |
| have hnext := safe_edge G T b hb hT hg hn hbest | |
| have hc := card_add T hn hg.ne | |
| obtain ⟨F,hF,hopt⟩ := ih (T⊔edge u v) hnext (by omega) | |
| refine ⟨F,?_,hopt⟩ | |
| rw [iterate,advance_code T es u v _ hg.ne he] | |
| convert hF using 1 | |
| congr 3 | |
| def decoded (g : GraphCode) : SimpleGraph (Fin n) where | |
| Adj u v := u≠v ∧ u.val∈g.getD v.val [] ∧ v.val∈g.getD u.val [] | |
| symm := ⟨by intro u v h; exact ⟨Ne.symm h.1,h.2.2,h.2.1⟩⟩ | |
| loopless := ⟨by intro u h; exact h.1 rfl⟩ | |
| lemma decoded_graphCode (G : SimpleGraph (Fin n)) : decoded (graphCode G)=G := by | |
| ext u v | |
| simp only [decoded,graphCode_getD,adjacencyRow_mem] | |
| constructor | |
| · rintro ⟨_,⟨a,ha,haG⟩,_⟩ | |
| exact (Fin.ext ha) ▸ haG | |
| · intro h | |
| exact ⟨h.ne,⟨u,rfl,h⟩,⟨v,rfl,h.symm⟩⟩ | |
| lemma unordered_pair_budget : Fintype.card (Sym2 (Fin n))≤n*n := by | |
| have hs : Function.Surjective (fun p : Fin n×Fin n=>s(p.1,p.2)) := by | |
| intro e | |
| induction e using Sym2.inductionOn with | |
| | _ u v=>exact ⟨(u,v),rfl⟩ | |
| simpa only [Fintype.card_prod,Fintype.card_fin] using Fintype.card_le_of_surjective _ hs | |
| /-- The graph is decoded from the literal result list, not selected from | |
| an existence proof. -/ | |
| theorem execute_optimal (G T : SimpleGraph (Fin n)) (b : Sym2 (Fin n)→ℕ) | |
| (es : List Edge) (hC : Catalog G b es) (hb : ∀ e∈G.edgeSet,0<b e) | |
| (hT : Extendible G T b) : | |
| let F := decoded (execute (graphCode T,es)).1 | |
| F≤G ∧ F.IsAcyclic ∧ | |
| ∀ H : SimpleGraph (Fin n),H≤G → H.IsAcyclic → weight H b≤weight F b := by | |
| obtain ⟨F,hF,hopt⟩ := iterate_optimal G T b es hC hb hT (n*n) | |
| (by have h := unordered_pair_budget (n:=n); omega) | |
| rw [execute_iterate,graphCode_length,hF] | |
| simpa only [decoded_graphCode] using hopt | |
| end ContingencyTables.ForestGreedySemantics | |
| end OAI | |