openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Machines /CachedTerminalCount.lean
| import OAI.Combinatorics.ContingencyTables.Machines.PreparedTransitionCache | |
| import OAI.Combinatorics.ContingencyTables.Machines.MatrixCodeEquality | |
| import OAI.Combinatorics.ContingencyTables.Sampling.OuterTrialProgram | |
| namespace OAI | |
| /-! # Exact terminal counts from the retained dense-completion cache -/ | |
| namespace ContingencyTables.ProfilePrograms | |
| open MatchingFPRAS MatchingFPRAS.TreeTyped DensePrograms | |
| abbrev TerminalOutputInput := (ProfileCheckData×ℕ)×(Option MatrixCode×ℕ) | |
| def terminalOutputEntry (z : TerminalOutputInput) : Option MatrixCode×ℕ := | |
| (z.2.1.bind (fun X => outerTrial (z.1,X)),z.2.2) | |
| def terminalOutputEntryRealizer : Realizer terminalOutputEntry := | |
| (pair (composition (pair first (composition second first)) | |
| (optionCases (constant none) outerTrialRealizer)) (composition second second)).congr (by | |
| rintro ⟨p,⟨o,n⟩⟩ | |
| cases o <;> rfl) | |
| lemma polynomial_terminalOutputEntry : PolynomialTime terminalOutputEntryRealizer := by | |
| unfold terminalOutputEntryRealizer | |
| apply polynomial_congr | |
| exact polynomial_pair (polynomial_composition (polynomial_pair polynomial_first | |
| (polynomial_composition polynomial_second polynomial_first)) | |
| (polynomial_optionCases (polynomial_constant none) polynomial_outerTrial)) | |
| (polynomial_composition polynomial_second polynomial_second) | |
| def terminalOutputs (z : TransitionCache) : List (Option MatrixCode×ℕ) := | |
| z.2.2.map (fun entry => terminalOutputEntry (z.1.1,entry)) | |
| def terminalOutputsRealizer : Realizer terminalOutputs := | |
| composition (pair (composition first first) (composition second second)) | |
| (mapWith terminalOutputEntryRealizer) | |
| lemma polynomial_terminalOutputs : PolynomialTime terminalOutputsRealizer := | |
| polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_first polynomial_first) | |
| (polynomial_composition polynomial_second polynomial_second)) | |
| (polynomial_mapWith polynomial_terminalOutputEntry) | |
| def successfulWeight (z : MatrixCode×(Option MatrixCode×ℕ)) : ℕ := | |
| z.2.1.elim 0 (fun X => if X=z.1 then z.2.2 else 0) | |
| def successfulWeightRealizer : Realizer successfulWeight := by | |
| let input : Realizer (fun z : MatrixCode×(Option MatrixCode×ℕ) => | |
| ((z.1,z.2.2),z.2.1)) := pair (pair first (composition second second)) | |
| (composition second first) | |
| let test : Realizer (fun z : (MatrixCode×ℕ)×MatrixCode => decide (z.2=z.1.1)) := | |
| composition (pair second (composition first first)) matrixEqual | |
| let result := choose test (composition first second) (constant 0) | |
| exact (composition input (optionCases (constant 0) result)).congr (by | |
| intro z | |
| simp only [Function.comp_apply,decide_eq_true_eq] | |
| rfl) | |
| lemma polynomial_successfulWeight : PolynomialTime successfulWeightRealizer := by | |
| unfold successfulWeightRealizer | |
| apply polynomial_congr | |
| exact polynomial_composition (polynomial_pair (polynomial_pair polynomial_first | |
| (polynomial_composition polynomial_second polynomial_second)) | |
| (polynomial_composition polynomial_second polynomial_first)) | |
| (polynomial_optionCases (polynomial_constant 0) (polynomial_choose | |
| (polynomial_composition (polynomial_pair polynomial_second | |
| (polynomial_composition polynomial_first polynomial_first)) polynomial_matrixEqual) | |
| (polynomial_composition polynomial_first polynomial_second) (polynomial_constant 0))) | |
| def successfulWeightSum (z : MatrixCode×List (Option MatrixCode×ℕ)) : ℕ := | |
| (z.2.map (fun entry => successfulWeight (z.1,entry))).sum | |
| def successfulWeightSumRealizer : Realizer successfulWeightSum := | |
| composition (mapWith successfulWeightRealizer) listSum | |
| lemma polynomial_successfulWeightSum : PolynomialTime successfulWeightSumRealizer := | |
| polynomial_composition (polynomial_mapWith polynomial_successfulWeight) polynomial_listSum | |
| def terminalCount (z : TransitionCache×MatrixCode) : ℕ := | |
| z.1.2.1*successfulWeightSum (z.2,terminalOutputs z.1) | |
| def terminalCountRealizer : Realizer terminalCount := | |
| composition (pair (composition (composition first second) first) | |
| (composition (pair second (composition first terminalOutputsRealizer)) | |
| successfulWeightSumRealizer)) multiply | |
| lemma polynomial_terminalCount : PolynomialTime terminalCountRealizer := | |
| polynomial_composition (polynomial_pair | |
| (polynomial_composition (polynomial_composition polynomial_first polynomial_second) polynomial_first) | |
| (polynomial_composition (polynomial_pair polynomial_second | |
| (polynomial_composition polynomial_first polynomial_terminalOutputs)) polynomial_successfulWeightSum)) | |
| polynomial_multiply | |
| end ContingencyTables.ProfilePrograms | |
| namespace ContingencyTables.ProfilePrograms | |
| open DensePrograms | |
| lemma terminalCount_eq (p : ResidualParameters) (M : ℕ) | |
| (entries : List (Option MatrixCode×ℕ)) (target : MatrixCode) : | |
| terminalCount ((p,(M,entries)),target)= | |
| M*(entries.map (fun entry => entry.1.elim 0 | |
| (fun X => if outerTrial (p.1,X)=some target then entry.2 else 0))).sum := by | |
| unfold terminalCount terminalOutputs successfulWeightSum | |
| rw [List.map_map] | |
| congr 2 | |
| apply List.map_congr_left | |
| rintro ⟨o,n⟩ _ | |
| cases o with | |
| | none => rfl | |
| | some X => | |
| simp only [Function.comp_apply,terminalOutputEntry,Option.bind_some,successfulWeight, | |
| Option.elim_some] | |
| cases outerTrial (p.1,X) with | |
| | none => rfl | |
| | some Y => simp only [Option.elim_some,Option.some.injEq] | |
| end ContingencyTables.ProfilePrograms | |
| end OAI | |