openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Counting /CompanionInitialStoredProgram.lean
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionInitialMatrixProgram | |
| import OAI.Combinatorics.ContingencyTables.Rooted.RootedStoredEstimate | |
| import OAI.Combinatorics.ContingencyTables.Rooted.RootedForestCatalog | |
| namespace OAI | |
| /-! # The literal initial count and stored multiplier matrix | |
| The integer count is the product of the free-cell ranges and the small-cell | |
| ranges. Both lists come from the executed forest and cell catalogs. | |
| -/ | |
| namespace ContingencyTables.CompanionInitialStoredProgram | |
| open MatchingFPRAS MatchingFPRAS.TreeTyped DensePrograms ProfilePrograms | |
| abbrev Input := RootedForestCatalog.Data × PairedProfileProgram.Input | |
| def rangeAt (z : RootedForestCatalog.Data×(ℕ×ℕ)) : ℕ := matrixEntry (z.1.2,z.2)+1 | |
| def rangeAtRealizer : Realizer rangeAt := | |
| composition (f := fun z : RootedForestCatalog.Data×(ℕ×ℕ) => matrixEntry (z.1.2,z.2)) | |
| (g := Nat.succ) | |
| (composition (f := fun z : RootedForestCatalog.Data×(ℕ×ℕ) => (z.1.2,z.2)) | |
| (g := matrixEntry) (pair (composition first second) second) matrixEntryRealizer) successor | |
| lemma polynomial_rangeAt : PolynomialTime rangeAtRealizer := | |
| polynomial_composition (polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_first polynomial_second) polynomial_second) | |
| polynomial_matrixEntry) polynomial_successor | |
| def freeRanges (d : RootedForestCatalog.Data) : List ℕ := | |
| (RootedForestCatalog.catalog (d,false)).map (fun ij => rangeAt (d,ij)) | |
| def freeRangesRealizer : Realizer freeRanges := | |
| composition (f := fun d : RootedForestCatalog.Data => (d,RootedForestCatalog.catalog (d,false))) | |
| (g := fun p : RootedForestCatalog.Data×List (ℕ×ℕ) => p.2.map (fun ij => rangeAt (p.1,ij))) | |
| (pair identity (composition (f := fun d : RootedForestCatalog.Data => (d,false)) | |
| (g := RootedForestCatalog.catalog) (pair identity (constant false)) RootedForestCatalog.catalogRealizer)) | |
| (mapWith rangeAtRealizer) | |
| lemma polynomial_freeRanges : PolynomialTime freeRangesRealizer := | |
| polynomial_composition (polynomial_pair polynomial_identity | |
| (polynomial_composition (polynomial_pair polynomial_identity (polynomial_constant false)) | |
| RootedForestCatalog.polynomial_catalog)) (polynomial_mapWith polynomial_rangeAt) | |
| def freeProduct (d : RootedForestCatalog.Data) : ℕ := (freeRanges d).prod | |
| def freeProductRealizer : Realizer freeProduct := | |
| composition (f := freeRanges) (g := List.prod) freeRangesRealizer listProd | |
| lemma polynomial_freeProduct : PolynomialTime freeProductRealizer := | |
| polynomial_composition polynomial_freeRanges polynomial_listProd | |
| def smallProduct (xs : List ℕ) : ℕ := (xs.map Nat.succ).prod | |
| def smallProductRealizer : Realizer smallProduct := composition (map successor) listProd | |
| lemma polynomial_smallProduct : PolynomialTime smallProductRealizer := | |
| polynomial_composition (polynomial_map polynomial_successor) polynomial_listProd | |
| def total (z : Input) : TreeFraction.Fraction := | |
| (freeProduct z.1*smallProduct z.2.1,1) | |
| def totalRealizer : Realizer total := | |
| pair (composition (f := fun z : Input => (freeProduct z.1,smallProduct z.2.1)) | |
| (g := fun p : ℕ×ℕ => p.1*p.2) | |
| (pair (composition (f := fun z : Input => z.1) (g := freeProduct) first freeProductRealizer) | |
| (composition (f := fun z : Input => z.2.1) (g := smallProduct) | |
| (composition second first) smallProductRealizer)) multiply) (constant 1) | |
| lemma polynomial_total : PolynomialTime totalRealizer := | |
| polynomial_pair (polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_first polynomial_freeProduct) | |
| (polynomial_composition (polynomial_composition polynomial_second polynomial_first) | |
| polynomial_smallProduct)) polynomial_multiply) (polynomial_constant 1) | |
| def output (z : Input) : CompanionMultiplierMatrixProgram.FractionMatrix×TreeFraction.Fraction := | |
| (CompanionInitialMatrixProgram.output z.2,total z) | |
| def outputRealizer : Realizer output := | |
| pair (composition (f := fun z : Input => z.2) (g := CompanionInitialMatrixProgram.output) | |
| second CompanionInitialMatrixProgram.outputRealizer) totalRealizer | |
| theorem polynomial_output : PolynomialTime outputRealizer := | |
| polynomial_pair (polynomial_composition polynomial_second | |
| CompanionInitialMatrixProgram.polynomial_output) polynomial_total | |
| noncomputable section | |
| open CompanionFactorialApplication CompanionComputedInitial ForestAssignmentSplit | |
| open CompanionArithmeticProposal | |
| open scoped BigOperators Classical | |
| variable {m n : ℕ} (A : Instance (Fin m) (Fin n)) | |
| def data (S : Set (Labels A×Bool)) : Input := | |
| (RootedForestCatalog.data A,(List.ofFn (capacities A),encodeSet (coordinateOrder A) S)) | |
| lemma rangeAt_data (ij : Fin m×Fin n) : | |
| rangeAt (RootedForestCatalog.data A,(ij.1.val,ij.2.val))=A.b ij.1 ij.2+1 := by | |
| unfold rangeAt RootedForestCatalog.data | |
| rw [matrixEntry_code] | |
| lemma freeRanges_data : freeRanges (RootedForestCatalog.data A)= | |
| List.ofFn (fun i => A.b (RootedForestCatalog.freeEquiv A i).val.1 | |
| (RootedForestCatalog.freeEquiv A i).val.2+1) := by | |
| unfold freeRanges | |
| conv_lhs => rw [←List.ofFn_get (RootedForestCatalog.catalog (RootedForestCatalog.data A,false))] | |
| rw [List.map_ofFn] | |
| apply congrArg List.ofFn | |
| funext i | |
| dsimp only [Function.comp_apply,List.get_eq_getElem] | |
| have h := RootedForestCatalog.catalogCell_coordinates A false i | |
| change ((RootedForestCatalog.freeEquiv A i).val.1.val, | |
| (RootedForestCatalog.freeEquiv A i).val.2.val)=_ at h | |
| rw [←h] | |
| exact rangeAt_data A _ | |
| theorem total_data (S : Set (Labels A×Bool)) : | |
| TreeFraction.val (total (data A S))=RootedStoredEstimate.initialTotal A := by | |
| unfold total data freeProduct smallProduct | |
| rw [freeRanges_data] | |
| simp only [List.prod_ofFn,List.map_ofFn,TreeFraction.val,Nat.cast_one,div_one, | |
| Nat.cast_mul,Nat.cast_prod] | |
| unfold RootedStoredEstimate.initialTotal | |
| congr 1 | |
| · exact Fintype.prod_equiv (RootedForestCatalog.freeEquiv A) _ _ (fun _ => rfl) | |
| · exact Fintype.prod_equiv (cellOrder A).symm _ _ (fun _ => rfl) | |
| theorem output_matrix (S : Set (Labels A×Bool)) : | |
| (output (data A S)).1=CompanionMultiplierMatrixProgram.matrixCode | |
| (CompanionInitialMatrixProgram.initialEntries A) := | |
| CompanionInitialMatrixProgram.output_physical A S | |
| end | |
| end ContingencyTables.CompanionInitialStoredProgram | |
| end OAI | |