openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Machines /FiniteGraphRootProgram.lean
| import OAI.Combinatorics.ContingencyTables.Transport.FiniteGraphRoots | |
| import OAI.Combinatorics.ContingencyTables.Sampling.ProfileExchangeProgram | |
| import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialCollections | |
| import OAI.Combinatorics.MatchingCount.Complexity.TreeChoiceCosts | |
| import OAI.Combinatorics.MatchingCount.Machines.TreeColex | |
| import OAI.Combinatorics.MatchingCount.Sampling.TreeDPCounts | |
| namespace OAI | |
| /-! # A binary list program computing a component root | |
| The graph is supplied by adjacency lists. The program makes one growth | |
| round per stored vertex, then minimizes the reached indices. No loop | |
| depends on the numeric size of an index or of an edge capacity. | |
| -/ | |
| namespace ContingencyTables.FiniteGraphRootProgram | |
| open MatchingFPRAS.TreeTyped Polynomial | |
| abbrev GraphCode := List (List ℕ) | |
| abbrev SearchState := GraphCode×List ℕ | |
| abbrev Input := GraphCode×ℕ | |
| def indices (rows : GraphCode) : List ℕ := List.range rows.length | |
| def indicesRealizer : Realizer indices := composition listLength range | |
| lemma polynomial_indices : PolynomialTime indicesRealizer := by | |
| apply polynomial_boundedRange polynomial_listLength X | |
| intro rows | |
| simpa only [Function.comp_apply,eval_X] using list_length_le_weight rows | |
| def neighborHit (z : List ℕ×List ℕ) : Bool := | |
| z.2.any (fun a => decide (a∈z.1)) | |
| def neighborHitRealizer : Realizer neighborHit := | |
| (composition (mapWith membership) any).congr (by | |
| intro z | |
| simp only [Function.comp_apply,List.any_map,Function.comp_def,id_eq,neighborHit]) | |
| lemma polynomial_neighborHit : PolynomialTime neighborHitRealizer := | |
| polynomial_congr _ (polynomial_composition | |
| (polynomial_mapWith polynomial_membership) polynomial_any) | |
| def growTest (z : SearchState×ℕ) : Bool := | |
| decide (z.2∈z.1.2) || neighborHit (z.1.2,z.1.1.getD z.2 []) | |
| def growTestRealizer : Realizer growTest := | |
| composition (f := fun z : SearchState×ℕ => | |
| (decide (z.2∈z.1.2),neighborHit (z.1.2,z.1.1.getD z.2 []))) | |
| (g := fun z : Bool×Bool => z.1 || z.2) | |
| (pair (composition (pair (composition first second) second) membership) | |
| (composition (pair (composition first second) | |
| (composition (pair (composition first first) second) (getDFast []))) | |
| neighborHitRealizer)) boolOr | |
| lemma polynomial_growTest : PolynomialTime growTestRealizer := | |
| polynomial_composition (polynomial_pair | |
| (polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_first polynomial_second) polynomial_second) | |
| polynomial_membership) | |
| (polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_first polynomial_second) | |
| (polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_first polynomial_first) polynomial_second) | |
| (polynomial_getDFast []))) polynomial_neighborHit)) polynomial_boolOr | |
| def grow (z : SearchState) : List ℕ := | |
| (indices z.1).filter (fun a => growTest (z,a)) | |
| def growRealizer : Realizer grow := | |
| composition (pair identity (composition first indicesRealizer)) | |
| (filterWith growTestRealizer) | |
| lemma polynomial_grow : PolynomialTime growRealizer := | |
| polynomial_composition (polynomial_pair polynomial_identity | |
| (polynomial_composition polynomial_first polynomial_indices)) | |
| (polynomial_filterWith polynomial_growTest) | |
| def advance (z : List ℕ×SearchState) : SearchState := | |
| (z.2.1,grow z.2) | |
| def advanceRealizer : Realizer advance := | |
| pair (composition second first) | |
| (composition (f := fun z : List ℕ×SearchState => z.2) (g := grow) second growRealizer) | |
| lemma polynomial_advance : PolynomialTime advanceRealizer := | |
| polynomial_pair (polynomial_composition polynomial_second polynomial_first) | |
| (polynomial_composition polynomial_second polynomial_grow) | |
| lemma fold_first (steps : List (List ℕ)) (s : SearchState) : | |
| (steps.foldl (fun s row => advance (row,s)) s).1=s.1 := by | |
| induction steps generalizing s with | |
| | nil => rfl | |
| | cons row steps ih => exact ih (advance (row,s)) | |
| lemma grow_weight (s : SearchState) : weight (grow s)≤weight (indices s.1) := | |
| weight_sublist (List.filter_sublist (p := fun a => growTest (s,a)) (l := indices s.1)) | |
| lemma fold_weight (steps : List (List ℕ)) (s : SearchState) : | |
| weight (steps.foldl (fun s row => advance (row,s)) s).2≤ | |
| max (weight s.2) (weight (indices s.1)) := by | |
| induction steps generalizing s with | |
| | nil => exact le_max_left _ _ | |
| | cons row steps ih => | |
| have ht := ih (advance (row,s)) | |
| have hs := grow_weight s | |
| exact ht.trans (max_le (hs.trans (le_max_right _ _)) (le_max_right _ _)) | |
| lemma indices_weight (rows : GraphCode) : | |
| weight (indices rows)≤rows.length*(4*rows.length+2)+1 := by | |
| have h := weight_map_bound (as := List.range rows.length) (f := id) | |
| (N := 4*rows.length+1) (by | |
| intro a ha | |
| exact (weight_nat_numeric a).trans (by | |
| have := List.mem_range.mp ha | |
| omega)) | |
| simpa only [List.map_id,List.length_range,indices] using h | |
| lemma polynomial_searchFold : PolynomialTime (fold advanceRealizer) := by | |
| apply polynomial_fold polynomial_advance (10*(X+1)^2) | |
| intro steps s pre _post _he | |
| let S := weight (steps,s) | |
| let out := pre.foldl (fun s row => advance (row,s)) s | |
| have hs : weight s≤S := weight_snd (steps,s) | |
| have hr : weight s.1≤S := (weight_fst s).trans hs | |
| have hv : weight s.2≤S := (weight_snd s).trans hs | |
| have hn : s.1.length≤S := (list_length_le_weight s.1).trans hr | |
| have hi := indices_weight s.1 | |
| have hib : weight (indices s.1)≤4*S^2+2*S+1 := by | |
| have hm := Nat.mul_le_mul hn (show 4*s.1.length+2≤4*S+2 by omega) | |
| nlinarith | |
| have ho : weight out.2 ≤ max (weight s.2) (weight (indices s.1)) := fold_weight pre s | |
| have hot : weight out.2≤4*S^2+3*S+1 := ho.trans (max_le (by omega) (by omega)) | |
| have hf : out.1=s.1 := fold_first pre s | |
| have hw : weight out=weight out.1+weight out.2+1 := by | |
| change weight (out.1,out.2)=_ | |
| rw [weight_prod] | |
| omega | |
| simp only [eval_mul,eval_ofNat,eval_pow,eval_add,eval_X,eval_one] | |
| change weight out≤10*(S+1)^2 | |
| rw [hw,hf] | |
| nlinarith | |
| def prepare (z : Input) : GraphCode×SearchState := (z.1,(z.1,[z.2])) | |
| def prepareRealizer : Realizer prepare := | |
| pair first (pair first (composition (pair second (constant [])) listCons)) | |
| lemma polynomial_prepare : PolynomialTime prepareRealizer := | |
| polynomial_pair polynomial_first (polynomial_pair polynomial_first | |
| (polynomial_composition (polynomial_pair polynomial_second (polynomial_constant [])) | |
| polynomial_listCons)) | |
| def run (z : Input) : SearchState := | |
| z.1.foldl (fun s row => advance (row,s)) (z.1,[z.2]) | |
| def runRealizer : Realizer run := composition prepareRealizer (fold advanceRealizer) | |
| lemma polynomial_run : PolynomialTime runRealizer := | |
| polynomial_composition polynomial_prepare polynomial_searchFold | |
| def reached (z : Input) : List ℕ := (run z).2 | |
| def reachedRealizer : Realizer reached := | |
| composition (f := run) (g := fun s : SearchState => s.2) runRealizer second | |
| theorem polynomial_reached : PolynomialTime reachedRealizer := | |
| polynomial_composition polynomial_run polynomial_second | |
| lemma minimum_fold_le (xs : List ℕ) (b : ℕ) : | |
| xs.foldl (fun b a => min a b) b≤b := by | |
| induction xs generalizing b with | |
| | nil => exact le_rfl | |
| | cons a xs ih => exact (ih (min a b)).trans (min_le_right _ _) | |
| lemma polynomial_minimumFold : PolynomialTime (fold minimum) := by | |
| apply polynomial_fold polynomial_minimum (4*X+1) | |
| intro xs b pre _post _he | |
| have hb : b.size≤weight (xs,b) := (size_le_weight b).trans (weight_snd (xs,b)) | |
| have hs := Nat.size_le_size (minimum_fold_le pre b) | |
| have hw := weight_nat_le (pre.foldl (fun b a => min a b) b) | |
| simp only [eval_add,eval_mul,eval_ofNat,eval_X,eval_one] | |
| omega | |
| def rootCode (z : Input) : ℕ := | |
| (reached z).foldl (fun b a => min a b) z.1.length | |
| def rootCodeRealizer : Realizer rootCode := | |
| composition (f := fun z : Input => (reached z,z.1.length)) | |
| (g := fun z : List ℕ×ℕ => z.1.foldl (fun b a => min a b) z.2) | |
| (pair reachedRealizer (composition first listLength)) (fold minimum) | |
| theorem polynomial_rootCode : PolynomialTime rootCodeRealizer := | |
| polynomial_composition (polynomial_pair polynomial_reached | |
| (polynomial_composition polynomial_first polynomial_listLength)) polynomial_minimumFold | |
| end ContingencyTables.FiniteGraphRootProgram | |
| end OAI | |