openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Machines /DirectedBFSRuntime.lean
| import OAI.Combinatorics.ContingencyTables.Transport.DirectedBFSBounds | |
| import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialGrid | |
| namespace OAI | |
| /-! # Polynomial binary execution of the entire materialized BFS -/ | |
| namespace ContingencyTables.DirectedBFSRuntime | |
| open MatchingFPRAS.TreeTyped Polynomial DirectedBFSCode DirectedBFSBounds DirectedBFSProgram | |
| def advance (z : ℕ×Context) : Context := (z.2.1,round z.2.1 z.2.2) | |
| def advanceRealizer : Realizer advance := | |
| pair (composition second first) (composition second roundRealizer) | |
| lemma polynomial_advance : PolynomialTime advanceRealizer := | |
| polynomial_pair (polynomial_composition polynomial_second polynomial_first) | |
| (polynomial_composition polynomial_second polynomial_round) | |
| lemma fold_eq (steps : List ℕ) (g : Graph) (P : Store) : | |
| steps.foldl (fun s i=>advance (i,s)) (g,P)= | |
| (g,steps.foldl (fun P _=>round g P) P) := by | |
| induction steps generalizing P with | |
| | nil => rfl | |
| | cons i steps ih => exact ih (round g P) | |
| theorem polynomial_fold : PolynomialTime (MatchingFPRAS.TreeTyped.fold advanceRealizer) := by | |
| apply MatchingFPRAS.TreeTyped.polynomial_fold polynomial_advance (20*(X+1)^3) | |
| intro steps s pre post he | |
| let S := weight (steps,s) | |
| have hsw : weight s≤ S := weight_snd (steps,s) | |
| have hgw : weight s.1≤ S := (weight_fst s).trans hsw | |
| have hpw : weight s.2≤ S := (weight_snd s).trans hsw | |
| have hn : s.1.length≤ S := (list_length_le_weight s.1).trans hgw | |
| have hpn : s.2.length≤ S := (list_length_le_weight s.2).trans hpw | |
| have hpre : pre.length≤ S := by | |
| have hl : pre.length≤ steps.length := by rw [he,List.length_append]; omega | |
| exact hl.trans ((list_length_le_weight steps).trans (weight_fst (steps,s))) | |
| have hb : Bounded s.2 (S+5) := by | |
| intro o ho | |
| exact (weight_mem ho).trans (hpw.trans (by omega)) | |
| let out := pre.foldl (fun P _=>round s.1 P) s.2 | |
| have ho : Bounded out (S+5+pre.length*(4*s.1.length+2)) := | |
| fold_bounded s.1 s.2 (S+5) (by omega) hb pre | |
| have hol : out.length≤ S := (fold_length_le s.1 s.2 pre).trans | |
| (max_le hpn hn) | |
| have hob : S+5+pre.length*(4*s.1.length+2)≤4*S^2+3*S+5 := by | |
| have hm := Nat.mul_le_mul hpre (show 4*s.1.length+2≤4*S+2 by omega) | |
| nlinarith | |
| have hwo := store_weight out _ ho | |
| have hwm := Nat.mul_le_mul hol (Nat.add_le_add_right hob 1) | |
| have hwout : weight out≤4*S^3+3*S^2+6*S+1 := by nlinarith | |
| change weight (pre.foldl (fun s i=>advance (i,s)) s)≤_ | |
| have hf := fold_eq pre s.1 s.2 | |
| rw [Prod.eta] at hf | |
| rw [hf,weight_prod] | |
| simp only [eval_mul,eval_ofNat,eval_pow,eval_add,eval_X,eval_one] | |
| change 1+weight s.1+weight out≤20*(S+1)^3 | |
| nlinarith | |
| def initialRow (z : ℕ×ℕ) : Option (List ℕ) := | |
| if z.2=z.1 then Option.some [z.1] else none | |
| def initialRowRealizer : Realizer initialRow := | |
| (choose (composition (pair second first) natEqual) | |
| (composition (composition (pair first (constant [])) listCons) some) | |
| (constant none)).congr (by | |
| intro z | |
| simp only [Function.comp_apply,initialRow,decide_eq_true_eq]) | |
| lemma polynomial_initialRow : PolynomialTime initialRowRealizer := | |
| polynomial_congr _ (polynomial_choose | |
| (polynomial_composition (polynomial_pair polynomial_second polynomial_first) polynomial_natEqual) | |
| (polynomial_composition (polynomial_composition | |
| (polynomial_pair polynomial_first (polynomial_constant [])) polynomial_listCons) polynomial_some) | |
| (polynomial_constant none)) | |
| def initialInput (z : Graph×ℕ) : Store := initial z.1 z.2 | |
| def initialRealizer : Realizer initialInput := | |
| composition (pair second (composition first indicesRealizer)) (mapWith initialRowRealizer) | |
| lemma polynomial_initial : PolynomialTime initialRealizer := | |
| polynomial_composition (polynomial_pair polynomial_second | |
| (polynomial_composition polynomial_first polynomial_indices)) | |
| (polynomial_mapWith polynomial_initialRow) | |
| def prepare (z : Graph×ℕ) : List ℕ×Context := | |
| (indices z.1,(z.1,initial z.1 z.2)) | |
| def prepareRealizer : Realizer prepare := | |
| pair (composition (f := fun z : Graph×ℕ=>z.1) (g := indices) first indicesRealizer) | |
| (pair first initialRealizer) | |
| lemma polynomial_prepare : PolynomialTime prepareRealizer := | |
| polynomial_pair (polynomial_composition polynomial_first polynomial_indices) | |
| (polynomial_pair polynomial_first polynomial_initial) | |
| def runInput (z : Graph×ℕ) : Store := run z.1 z.2 | |
| def runRealizer : Realizer runInput := | |
| (composition (composition prepareRealizer (MatchingFPRAS.TreeTyped.fold advanceRealizer)) | |
| second).congr (by | |
| intro z | |
| change ((indices z.1).foldl (fun s i=>advance (i,s)) (z.1,initial z.1 z.2)).2 = _ | |
| rw [fold_eq] | |
| rfl) | |
| theorem polynomial_run : PolynomialTime runRealizer := | |
| polynomial_congr _ (polynomial_composition | |
| (polynomial_composition polynomial_prepare polynomial_fold) polynomial_second) | |
| def searchInput (z : (Graph×ℕ)×ℕ) : Option (List ℕ) := search z.1.1 z.1.2 z.2 | |
| def searchRealizer : Realizer searchInput := | |
| composition (pair (composition first runRealizer) second) lookupRealizer | |
| theorem polynomial_search : PolynomialTime searchRealizer := | |
| polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_first polynomial_run) polynomial_second) polynomial_lookup | |
| end ContingencyTables.DirectedBFSRuntime | |
| end OAI | |