openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Counting /CompanionInitializedRestartProgram.lean
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionRestartProgram | |
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionRestartInitializer | |
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionPhaseFinishProgram | |
| namespace OAI | |
| /-! # Initialization and all stored-multiplier restart stages | |
| Past entries are stored in chronological order. Entry i contains the | |
| multiplier for restart phase i+1. Initialization and restart stages take | |
| disjoint slices of the supplied word. | |
| -/ | |
| namespace ContingencyTables.CompanionInitializedRestartProgram | |
| open MatchingFPRAS MatchingFPRAS.TreeTyped Polynomial | |
| abbrev Prepared := CompanionPhaseContextProgram.Prepared | |
| abbrev Stored := CompanionPhaseFinishProgram.Stored | |
| abbrev Input := (Prepared×List Stored)×List Bool | |
| def reserve (z : Input) : List Bool := z.2.map (fun _ => false) | |
| def reserveRealizer : Realizer reserve := composition second (map (constant false)) | |
| lemma polynomial_reserve : PolynomialTime reserveRealizer := | |
| polynomial_composition polynomial_second (polynomial_map (polynomial_constant false)) | |
| def indices (z : Input) : List ℕ := List.range z.1.2.length | |
| def indicesRealizer : Realizer indices := | |
| composition (composition (composition first second) listLength) range | |
| lemma polynomial_indices : PolynomialTime indicesRealizer := by | |
| apply polynomial_boundedRange | |
| (polynomial_composition (polynomial_composition polynomial_first polynomial_second) polynomial_listLength) X | |
| intro z | |
| simpa only [Function.comp_apply,eval_X] using | |
| (list_length_le_weight z.1.2).trans ((weight_snd z.1).trans (weight_fst z)) | |
| def stageAt (z : Input×ℕ) : CompanionRestartProgram.Stage := | |
| (((z.1.1.1,z.2+1),reserve z.1),(z.1.1.2.getD z.2 default).1) | |
| def stageAtRealizer : Realizer stageAt := by | |
| let prepared : Realizer (fun z : Input×ℕ => z.1.1.1) := composition (composition first first) first | |
| let phase : Realizer (fun z : Input×ℕ => z.2+1) := composition second successor | |
| let marker : Realizer (fun z : Input×ℕ => reserve z.1) := | |
| composition (f := fun z : Input×ℕ => z.1) (g := reserve) first reserveRealizer | |
| let stored : Realizer (fun z : Input×ℕ => z.1.1.2.getD z.2 (default : Stored)) := | |
| composition (f := fun z : Input×ℕ => (z.1.1.2,z.2)) | |
| (g := fun p : List Stored×ℕ => p.1.getD p.2 default) | |
| (pair (composition (composition first first) second) second) (getDFast default) | |
| exact pair (pair (pair prepared phase) marker) (composition (f := fun z : Input×ℕ => | |
| z.1.1.2.getD z.2 (default : Stored)) (g := Prod.fst) stored first) | |
| lemma polynomial_stageAt : PolynomialTime stageAtRealizer := by | |
| unfold stageAtRealizer | |
| apply polynomial_pair | |
| · exact polynomial_pair (polynomial_pair | |
| (polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_first) | |
| (polynomial_composition polynomial_second polynomial_successor)) | |
| (polynomial_composition polynomial_first polynomial_reserve) | |
| · exact polynomial_composition (polynomial_composition (polynomial_pair | |
| (polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_second) | |
| polynomial_second) (polynomial_getDFast default)) polynomial_first | |
| def stages (z : Input) : List CompanionRestartProgram.Stage := | |
| (indices z).map (fun i => stageAt (z,i)) | |
| def stagesRealizer : Realizer stages := composition (pair identity indicesRealizer) (mapWith stageAtRealizer) | |
| lemma polynomial_stages : PolynomialTime stagesRealizer := | |
| polynomial_composition (polynomial_pair polynomial_identity polynomial_indices) | |
| (polynomial_mapWith polynomial_stageAt) | |
| def initialWidth (z : Input) : ℕ := CompanionRestartInitializer.width z.1.1 | |
| def initialWidthRealizer : Realizer initialWidth := | |
| composition (f := fun z : Input => z.1.1) (g := CompanionRestartInitializer.width) | |
| (composition first first) CompanionRestartInitializer.widthRealizer | |
| lemma polynomial_initialWidth : PolynomialTime initialWidthRealizer := | |
| polynomial_composition (polynomial_composition polynomial_first polynomial_first) | |
| CompanionRestartInitializer.polynomial_width | |
| def initialInput (z : Input) : CompanionRestartInitializer.Input := | |
| (z.1.1,z.2.take (initialWidth z)) | |
| def initialInputRealizer : Realizer initialInput := | |
| pair (composition first first) | |
| (composition (f := fun z : Input => (z.2,initialWidth z)) | |
| (g := fun p : List Bool×ℕ => p.1.take p.2) (pair second initialWidthRealizer) takeFast) | |
| lemma polynomial_initialInput : PolynomialTime initialInputRealizer := | |
| polynomial_pair (polynomial_composition polynomial_first polynomial_first) | |
| (polynomial_composition (polynomial_pair polynomial_second polynomial_initialWidth) polynomial_takeFast) | |
| def initialCode (z : Input) : List ℕ := CompanionRestartInitializer.output (initialInput z) | |
| def initialCodeRealizer : Realizer initialCode := | |
| composition (f := initialInput) (g := CompanionRestartInitializer.output) | |
| initialInputRealizer CompanionRestartInitializer.outputRealizer | |
| lemma polynomial_initialCode : PolynomialTime initialCodeRealizer := | |
| polynomial_composition polynomial_initialInput CompanionRestartInitializer.polynomial_output | |
| attribute [local irreducible] stages initialCode initialWidth | |
| def prepare (z : Input) : CompanionRestartProgram.Input := | |
| ((stages z,initialCode z),z.2.drop (initialWidth z)) | |
| def prepareRealizer : Realizer prepare := | |
| pair (pair stagesRealizer initialCodeRealizer) | |
| (composition (f := fun z : Input => (z.2,initialWidth z)) | |
| (g := fun p : List Bool×ℕ => p.1.drop p.2) (pair second initialWidthRealizer) dropFast) | |
| lemma polynomial_prepare : PolynomialTime prepareRealizer := | |
| polynomial_pair (polynomial_pair polynomial_stages polynomial_initialCode) | |
| (polynomial_composition (polynomial_pair polynomial_second polynomial_initialWidth) polynomial_dropFast) | |
| def output (z : Input) : List ℕ := CompanionRestartProgram.output (prepare z) | |
| def outputRealizer : Realizer output := | |
| composition (f := prepare) (g := CompanionRestartProgram.output) | |
| prepareRealizer CompanionRestartProgram.outputRealizer | |
| theorem polynomial_output : PolynomialTime outputRealizer := | |
| polynomial_composition polynomial_prepare CompanionRestartProgram.polynomial_output | |
| end ContingencyTables.CompanionInitializedRestartProgram | |
| end OAI | |