openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Counting /CompanionComputedInitial.lean
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionCellCatalogProgram | |
| import OAI.Combinatorics.ContingencyTables.Counting.CompanionCanonicalEncoding | |
| namespace OAI | |
| /-! # Initialization from the computed small-cell catalog | |
| The proof-level equivalence follows the actual catalog program. It is | |
| used only to identify the output of the binary list initializer with a | |
| paired transversal and to transfer its distributional error bound. | |
| -/ | |
| namespace ContingencyTables.CompanionComputedInitial | |
| open MatchingFPRAS.TreeTyped CompanionFactorialApplication | |
| open InitialTransversals InitialFactorialBits CompanionInitialDraw | |
| open FirstSuccess ResidualMixture TwoLiftStates CommonBasesFPRAS | |
| open CompanionArithmeticProposal | |
| open scoped BigOperators Classical | |
| abbrev ProgramInput := (CompanionCellCatalog.Input×ℕ)×List Bool | |
| def initialProgram (z : ProgramInput) : List ℕ := | |
| CanonicalInitialEncoding.initialCode ((CompanionCellCatalog.capacities z.1.1,z.1.2),z.2) | |
| def initialProgramRealizer : Realizer initialProgram := | |
| composition (pair (pair | |
| (composition (composition first first) CompanionCellCatalog.capacitiesRealizer) | |
| (composition first second)) second) CanonicalInitialEncoding.initialCodeRealizer | |
| theorem polynomial_initialProgram : PolynomialTime initialProgramRealizer := | |
| polynomial_composition (polynomial_pair (polynomial_pair | |
| (polynomial_composition (polynomial_composition polynomial_first polynomial_first) | |
| CompanionCellCatalog.polynomial_capacities) | |
| (polynomial_composition polynomial_first polynomial_second)) polynomial_second) | |
| CanonicalInitialEncoding.polynomial_initialCode | |
| noncomputable section | |
| variable {m n : ℕ} (A : Instance (Fin m) (Fin n)) | |
| def cellOrder : SmallCell A ≃ Fin (CompanionCellCatalog.catalog (CompanionCellCatalog.input A)).length := | |
| (CompanionCellCatalog.cellEquiv A).symm | |
| def capacities (i : Fin (CompanionCellCatalog.catalog (CompanionCellCatalog.input A)).length) : ℕ := | |
| A.b ((cellOrder A).symm i).val.1 ((cellOrder A).symm i).val.2 | |
| def wordLength (B : ℕ) : ℕ := bitCount (capacities A) B | |
| def initialDraw (B : ℕ) (bits : Fin (wordLength A B) → Bool) : | |
| PlainIndex (pairs : List ((Labels A×Bool)×(Labels A×Bool))) := | |
| indexEquiv A (transversalDraw (fun s : SmallCell A => A.b s.val.1 s.val.2) | |
| (cellOrder A) B bits) | |
| def copyOrder : Labels A ≃ Copy (capacities A) := Equiv.sigmaCongrLeft' (cellOrder A) | |
| def pairOrder : (Labels A×Bool) ≃ (Copy (capacities A)×Bool) := | |
| Equiv.prodCongr (copyOrder A) (Equiv.refl Bool) | |
| def coordinateOrder : (Labels A×Bool) ≃ Fin (CanonicalInitialEncoding.pairOrder (capacities A)).length := | |
| (pairOrder A).trans (CanonicalInitialEncoding.coordinateEquiv (capacities A)) | |
| lemma encodeSet_reindex (S : Set (Labels A×Bool)) : | |
| encodeSet (coordinateOrder A) S= | |
| encodeSet (CanonicalInitialEncoding.coordinateEquiv (capacities A)) | |
| ((pairOrder A).symm ⁻¹' S) := rfl | |
| lemma draw_preimage (B : ℕ) (bits : Fin (wordLength A B) → Bool) : | |
| (pairOrder A).symm ⁻¹' (initialDraw A B bits).val.val= | |
| encode (capacities A) (drawChoices (capacities A) B bits) := by | |
| ext p | |
| rcases p with ⟨⟨i,k⟩,side⟩ | |
| have hc := Equiv.piCongrLeft'_symm_apply_apply | |
| (fun s : SmallCell A => Finset (Fin (A.b s.val.1 s.val.2))) | |
| (cellOrder A) (drawChoices (capacities A) B bits) i | |
| cases side | |
| · change k∈(choiceEquiv (fun s : SmallCell A => A.b s.val.1 s.val.2) | |
| (cellOrder A) (drawChoices (capacities A) B bits)) ((cellOrder A).symm i) ↔ | |
| k∈drawChoices (capacities A) B bits i | |
| exact Iff.of_eq (congrArg (fun S => k∈S) hc) | |
| · change k∉(choiceEquiv (fun s : SmallCell A => A.b s.val.1 s.val.2) | |
| (cellOrder A) (drawChoices (capacities A) B bits)) ((cellOrder A).symm i) ↔ | |
| k∉drawChoices (capacities A) B bits i | |
| exact Iff.of_eq (congrArg (fun S => k∉S) hc) | |
| /-- The complete program computes the semantic initializer with the | |
| coordinate order recovered from the program's own catalog. -/ | |
| theorem initialProgram_eq (B : ℕ) (hB : 0<B) (bits : Fin (wordLength A B) → Bool) : | |
| initialProgram ((CompanionCellCatalog.input A,B),List.ofFn bits)= | |
| encodeSet (coordinateOrder A) (initialDraw A B bits).val.val := by | |
| unfold initialProgram | |
| rw [CompanionCellCatalog.capacities_eq] | |
| rw [encodeSet_reindex,draw_preimage] | |
| exact CanonicalInitialEncoding.initialCode_ofFn (capacities A) B hB bits | |
| lemma catalog_count_le : (CompanionCellCatalog.catalog (CompanionCellCatalog.input A)).length≤A.d := by | |
| have hc := Fintype.card_congr (CompanionCellCatalog.cellEquiv A) | |
| simpa only [Fintype.card_fin] using hc.trans_le (cellCount_bound A) | |
| theorem wordLength_bound (B : ℕ) : wordLength A B≤A.d*(A.W+1)*B := by | |
| have hh := bitCount_bound (capacities A) B A.W (fun i => | |
| (A.hsmall _ _ ((cellOrder A).symm i).property).le) | |
| exact hh.trans (Nat.mul_le_mul_right B | |
| (Nat.mul_le_mul_right (A.W+1) (catalog_count_le A))) | |
| /-- The computed-order initializer has the same μ₀ reference law and | |
| error guarantee as the abstract-order initializer. -/ | |
| theorem initialDraw_error (B : ℕ) : | |
| variation (mapLaw (uniformLaw (α := Fin (wordLength A B) → Bool)) (initialDraw A B)) | |
| (idealLaw A)≤(A.d:ℚ)*(3*A.W+1)/(2*(2:ℚ)^B) := by | |
| unfold initialDraw wordLength capacities | |
| have he := mapLaw_equiv_output (indexEquiv A) | |
| (uniformLaw (α := Fin (bitCount | |
| (fun i => A.b ((cellOrder A).symm i).val.1 ((cellOrder A).symm i).val.2) B) → Bool)) | |
| (transversalDraw (fun s : SmallCell A => A.b s.val.1 s.val.2) (cellOrder A) B) | |
| rw [he,idealLaw,variation_equiv] | |
| have ht := transversalDraw_error (fun s : SmallCell A => A.b s.val.1 s.val.2) | |
| (cellOrder A) B A.W (fun s => (A.hsmall _ _ s.property).le) | |
| apply ht.trans | |
| apply div_le_div_of_nonneg_right _ (by positivity) | |
| apply mul_le_mul_of_nonneg_right _ (by positivity) | |
| exact_mod_cast catalog_count_le A | |
| theorem initialDraw_precision (h : ℕ) : | |
| variation (mapLaw (uniformLaw (α := Fin (wordLength A (precision A h)) → Bool)) | |
| (initialDraw A (precision A h))) (idealLaw A)≤1/(2:ℚ)^h := | |
| (initialDraw_error A (precision A h)).trans (precision_error A h) | |
| end | |
| end ContingencyTables.CompanionComputedInitial | |
| end OAI | |