openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Sampling /ExactMatrixTableLaw.lean
| import OAI.Combinatorics.ContingencyTables.Sampling.ExactMatrixLimits | |
| import OAI.Combinatorics.ContingencyTables.Sampling.ExactMatrixLookup | |
| import OAI.Combinatorics.ContingencyTables.Transport.IntegerLawEmbedding | |
| import OAI.Combinatorics.ContingencyTables.Machines.MatrixCodeEquality | |
| namespace OAI | |
| /-! # Exact weighted matrix selection realizes a table law -/ | |
| namespace ContingencyTables.ExactMatrixTrial | |
| open MatchingFPRAS MatchingFPRAS.PhysicalStream DensePrograms ProfilePrograms OriginalTableBox | |
| open ExactIntegerChoice ResidualMixture FirstSuccess | |
| open scoped BigOperators Classical | |
| noncomputable section | |
| attribute [local irreducible] lookup originalCandidates | |
| lemma normalized_counts {K Q : ℕ} (p : IntegerLaw (Fin K) Q) | |
| (hQ : 0<Q) (a : Fin K) : (p.count a:ℚ)/totalWeight p.count=(p.toRational hQ).mass a := by | |
| unfold totalWeight | |
| rw [p.total] | |
| rfl | |
| lemma count_weight_pos {K Q : ℕ} (p : IntegerLaw (Fin K) Q) | |
| (hQ : 0<Q) : 0<totalWeight p.count := by | |
| unfold totalWeight | |
| rwa [p.total] | |
| /-- An integer law's full original-box vector pushes back to precisely | |
| that table law under the executed matrix lookup. -/ | |
| lemma table_normalized_event {m n Q : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ) | |
| (p : IntegerLaw (Table r c) Q) (hQ : 0<Q) (fallback X : Table r c) : | |
| (∑ i : Index m n (∑ j,r j), | |
| if lookup ((originalCandidates (List.ofFn r,List.ofFn c),matrixCode fallback.val),i.val)= | |
| matrixCode X.val then normalized (p.push (index r c le_rfl)).count i else 0)= | |
| (p.toRational hQ).mass X := by | |
| let test : Index m n (∑ j,r j) → Bool := fun i => decide | |
| (lookup ((originalCandidates (List.ofFn r,List.ofFn c),matrixCode fallback.val),i.val)=matrixCode X.val) | |
| have hn (i : Index m n (∑ j,r j)) : | |
| normalized (p.push (index r c le_rfl)).count i= | |
| ((p.push (index r c le_rfl)).toRational hQ).mass i := | |
| normalized_counts _ hQ i | |
| simp_rw [hn] | |
| have hm : (mapLaw ((p.push (index r c le_rfl)).toRational hQ) test).mass true= | |
| (mapLaw (p.toRational hQ) (fun T => test (index r c le_rfl T))).mass true := by | |
| rw [IntegerLaw.toRational_push,mapLaw_comp] | |
| have he (T : Table r c) : test (index r c le_rfl T)=true ↔ T=X := by | |
| simp only [test,decide_eq_true_eq,lookup_index] | |
| exact ⟨fun h => Subtype.ext (matrixCode_injective h),fun h => by rw [h]⟩ | |
| simp only [mapLaw] at hm | |
| simp only [test,decide_eq_true_eq] at hm | |
| rw [hm] | |
| have htest (T : Table r c) : | |
| (lookup ((originalCandidates (List.ofFn r,List.ofFn c),matrixCode fallback.val), | |
| (index r c le_rfl T).val)=matrixCode X.val) ↔ T=X := by | |
| simpa only [test,decide_eq_true_eq] using he T | |
| simp only [htest,Finset.sum_ite_eq',Finset.mem_univ,ite_true] | |
| /-- The finite prefixes of the actual exact matrix loop converge to the | |
| input table law. -/ | |
| theorem table_prefix_limit {m n Q : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ) | |
| (p : IntegerLaw (Table r c) Q) (hQ : 0<Q) (fallback X : Table r c) : | |
| Filter.Tendsto (fun N => | |
| ((OnlineIntegerRetry.prefixExperiment (f := trial) | |
| ((originalCandidates (List.ofFn r,List.ofFn c),matrixCode fallback.val), | |
| List.ofFn (p.push (index r c le_rfl)).count) N).mean | |
| (fun o => if o=some (matrixCode X.val) then 1 else 0):ℝ)) | |
| Filter.atTop (nhds ((p.toRational hQ).mass X:ℝ)) := by | |
| have h := prefix_limit (originalCandidates (List.ofFn r,List.ofFn c),matrixCode fallback.val) | |
| (p.push (index r c le_rfl)).count (count_weight_pos _ hQ) (matrixCode X.val) | |
| rw [table_normalized_event r c p hQ fallback X] at h | |
| exact h | |
| end | |
| end ContingencyTables.ExactMatrixTrial | |
| end OAI | |