openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Machines /DirectedBFSProgram.lean
| import OAI.Combinatorics.ContingencyTables.Transport.DirectedBFSCode | |
| import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialCollections | |
| import OAI.Combinatorics.MatchingCount.Machines.TreeSum | |
| import OAI.Combinatorics.MatchingCount.Machines.TreeFastLookup | |
| import OAI.Combinatorics.MatchingCount.Complexity.TreeCostMeasure | |
| namespace OAI | |
| /-! # Polynomial binary programs for one stored BFS round -/ | |
| namespace ContingencyTables.DirectedBFSProgram | |
| open MatchingFPRAS.TreeTyped Polynomial DirectedBFSCode | |
| abbrev Context := Graph×Store | |
| abbrev Query := Context×ℕ | |
| abbrev Candidate := Query×ℕ | |
| def indices (g : Graph) : List ℕ := List.range g.length | |
| def indicesRealizer : Realizer indices := composition listLength range | |
| lemma polynomial_indices : PolynomialTime indicesRealizer := by | |
| apply polynomial_boundedRange polynomial_listLength X | |
| intro g | |
| simpa only [Function.comp_apply,eval_X] using list_length_le_weight g | |
| def pathSomeRealizer : Realizer (fun o : Option (List ℕ)=>o.isSome) := | |
| (composition (pair (constant false) identity) | |
| (optionCases (constant false) (constant true))).congr (by | |
| intro o | |
| cases o <;> rfl) | |
| lemma polynomial_pathSome : PolynomialTime pathSomeRealizer := | |
| polynomial_congr _ (polynomial_composition | |
| (polynomial_pair (polynomial_constant false) polynomial_identity) | |
| (polynomial_optionCases (polynomial_constant false) (polynomial_constant true))) | |
| def lookupPath (z : Store×ℕ) : Option (List ℕ) := lookup z.1 z.2 | |
| def lookupRealizer : Realizer lookupPath := getDFast none | |
| lemma polynomial_lookup : PolynomialTime lookupRealizer := polynomial_getDFast none | |
| def readEdge (z : (Graph×ℕ)×ℕ) : Bool := adjacent z.1.1 z.1.2 z.2 | |
| def readEdgeRealizer : Realizer readEdge := | |
| composition (pair (composition first (getDFast [])) second) (getDFast false) | |
| lemma polynomial_readEdge : PolynomialTime readEdgeRealizer := | |
| polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_first (polynomial_getDFast [])) polynomial_second) | |
| (polynomial_getDFast false) | |
| def candidate (z : Candidate) : Bool := | |
| (lookup z.1.1.2 z.2).isSome && adjacent z.1.1.1 z.2 z.1.2 | |
| def candidateRealizer : Realizer candidate := by | |
| let G : Realizer (fun z : Candidate=>z.1.1.1) := composition (composition first first) first | |
| let P : Realizer (fun z : Candidate=>z.1.1.2) := composition (composition first first) second | |
| let V : Realizer (fun z : Candidate=>z.1.2) := composition first second | |
| let U : Realizer (fun z : Candidate=>z.2) := second | |
| let known : Realizer (fun z : Candidate=>(lookup z.1.1.2 z.2).isSome) := | |
| composition (composition (pair P U) lookupRealizer) pathSomeRealizer | |
| let edge : Realizer (fun z : Candidate=>adjacent z.1.1.1 z.2 z.1.2) := | |
| composition (pair (pair G U) V) readEdgeRealizer | |
| exact composition (pair known edge) boolAnd | |
| lemma polynomial_candidate : PolynomialTime candidateRealizer := by | |
| unfold candidateRealizer | |
| apply polynomial_composition | |
| · apply polynomial_pair | |
| · exact polynomial_composition | |
| (polynomial_composition (polynomial_pair | |
| (polynomial_composition (polynomial_composition polynomial_first polynomial_first) | |
| polynomial_second) polynomial_second) polynomial_lookup) polynomial_pathSome | |
| · exact polynomial_composition (polynomial_pair | |
| (polynomial_pair | |
| (polynomial_composition (polynomial_composition polynomial_first polynomial_first) | |
| polynomial_first) polynomial_second) | |
| (polynomial_composition polynomial_first polynomial_second)) polynomial_readEdge | |
| · exact polynomial_boolAnd | |
| def headOptionRealizer : Realizer (fun xs : List ℕ=>xs.head?) := | |
| (listCase none (composition first some)).congr (by intro xs;cases xs <;> rfl) | |
| lemma polynomial_headOption : PolynomialTime headOptionRealizer := | |
| polynomial_congr _ (polynomial_listCase none | |
| (polynomial_composition polynomial_first polynomial_some)) | |
| def predecessorInput (z : Query) : Option ℕ := DirectedBFSCode.predecessor z.1.1 z.1.2 z.2 | |
| def predecessorRealizer : Realizer predecessorInput := | |
| (composition (composition (pair identity | |
| (composition (composition first first) indicesRealizer)) (filterWith candidateRealizer)) | |
| headOptionRealizer).congr (by | |
| intro z | |
| simp only [Function.comp_apply,id_eq,predecessorInput,DirectedBFSCode.predecessor,indices, | |
| List.head?_filter,candidate]) | |
| lemma polynomial_predecessor : PolynomialTime predecessorRealizer := | |
| polynomial_congr _ (polynomial_composition | |
| (polynomial_composition (polynomial_pair polynomial_identity | |
| (polynomial_composition (polynomial_composition polynomial_first polynomial_first) | |
| polynomial_indices)) (polynomial_filterWith polynomial_candidate)) polynomial_headOption) | |
| def appendPath (z : Query×List ℕ) : Option (List ℕ) := Option.some (z.2++[z.1.2]) | |
| def appendPathRealizer : Realizer appendPath := | |
| composition (composition (pair second | |
| (composition (pair (composition first second) (constant [])) listCons)) append) some | |
| lemma polynomial_appendPath : PolynomialTime appendPathRealizer := | |
| polynomial_composition (polynomial_composition | |
| (polynomial_pair polynomial_second (polynomial_composition | |
| (polynomial_pair (polynomial_composition polynomial_first polynomial_second) | |
| (polynomial_constant [])) polynomial_listCons)) polynomial_append) polynomial_some | |
| def fromPredecessor (z : Query×ℕ) : Option (List ℕ) := | |
| (lookup z.1.1.2 z.2).map (fun xs=>xs++[z.1.2]) | |
| def fromPredecessorRealizer : Realizer fromPredecessor := | |
| (composition (pair first | |
| (composition (pair (composition (composition first first) second) second) lookupRealizer)) | |
| (optionCases (constant none) appendPathRealizer)).congr (by | |
| intro z | |
| dsimp only [Function.comp_apply,lookupPath,fromPredecessor,appendPath] | |
| cases h : lookup z.1.1.2 z.2 <;> rfl) | |
| lemma polynomial_fromPredecessor : PolynomialTime fromPredecessorRealizer := | |
| polynomial_congr _ (polynomial_composition (polynomial_pair polynomial_first | |
| (polynomial_composition (polynomial_pair | |
| (polynomial_composition (polynomial_composition polynomial_first polynomial_first) | |
| polynomial_second) polynomial_second) polynomial_lookup)) | |
| (polynomial_optionCases (polynomial_constant none) polynomial_appendPath)) | |
| def missing (z : Query) : Option (List ℕ) := | |
| (predecessorInput z).bind (fun u=>fromPredecessor (z,u)) | |
| def missingRealizer : Realizer missing := | |
| (composition (pair identity predecessorRealizer) | |
| (optionCases (constant none) fromPredecessorRealizer)).congr (by | |
| intro z | |
| dsimp only [Function.comp_apply,id_eq,missing] | |
| cases h : predecessorInput z <;> rfl) | |
| lemma polynomial_missing : PolynomialTime missingRealizer := | |
| polynomial_congr _ (polynomial_composition | |
| (polynomial_pair polynomial_identity polynomial_predecessor) | |
| (polynomial_optionCases (polynomial_constant none) polynomial_fromPredecessor)) | |
| def rowInput (z : Query) : Option (List ℕ) := roundRow z.1.1 z.1.2 z.2 | |
| def rowRealizer : Realizer rowInput := | |
| (composition (pair identity | |
| (composition (pair (composition first second) second) lookupRealizer)) | |
| (optionCases missingRealizer (composition second some))).congr (by | |
| intro z | |
| dsimp only [Function.comp_apply,id_eq,lookupPath,rowInput,roundRow] | |
| cases h : lookup z.1.2 z.2 <;> rfl) | |
| lemma polynomial_row : PolynomialTime rowRealizer := | |
| polynomial_congr _ (polynomial_composition | |
| (polynomial_pair polynomial_identity (polynomial_composition | |
| (polynomial_pair (polynomial_composition polynomial_first polynomial_second) | |
| polynomial_second) polynomial_lookup)) | |
| (polynomial_optionCases polynomial_missing | |
| (polynomial_composition polynomial_second polynomial_some))) | |
| def roundInput (z : Context) : Store := round z.1 z.2 | |
| def roundRealizer : Realizer roundInput := | |
| composition (pair identity (composition first indicesRealizer)) (mapWith rowRealizer) | |
| theorem polynomial_round : PolynomialTime roundRealizer := | |
| polynomial_composition (polynomial_pair polynomial_identity | |
| (polynomial_composition polynomial_first polynomial_indices)) | |
| (polynomial_mapWith polynomial_row) | |
| end ContingencyTables.DirectedBFSProgram | |
| end OAI | |