openAI-math-dataset / lean /OAI /Combinatorics /ContingencyTables /Sampling /ExactIntegerProgram.lean
| import OAI.Combinatorics.ContingencyTables.Sampling.ExactIntegerChoice | |
| import OAI.Combinatorics.ContingencyTables.Machines.ListWordProgram | |
| import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialSums | |
| namespace OAI | |
| /-! # Binary execution of an exact integer-weighted rejection trial -/ | |
| namespace ContingencyTables.ExactIntegerPrograms | |
| open MatchingFPRAS MatchingFPRAS.TreeTyped ProfilePrograms | |
| /-- Fractions share the total integer weight before canonical reduction. -/ | |
| def weightsCode (xs : List ℕ) : List TreeFraction.Fraction := | |
| xs.map (fun w => TreeFraction.normalize (w,xs.sum)) | |
| def weightsCodeRealizer : Realizer weightsCode := | |
| composition (f := fun xs : List ℕ => (xs.sum,xs)) | |
| (g := fun z : ℕ×List ℕ => z.2.map (fun w => TreeFraction.normalize (w,z.1))) | |
| (pair listSum identity) | |
| (mapWith (composition (pair second first) TreeFraction.normalizeRealizer)) | |
| lemma polynomial_weightsCode : PolynomialTime weightsCodeRealizer := | |
| polynomial_composition (polynomial_pair polynomial_listSum polynomial_identity) | |
| (polynomial_mapWith (polynomial_composition (polynomial_pair polynomial_second polynomial_first) | |
| TreeFraction.polynomial_normalize)) | |
| abbrev Input := List ℕ×List Bool | |
| def choiceInput (z : Input) : List TreeFraction.Fraction×TreeFraction.Fraction := | |
| (weightsCode z.1,(StackAddition.value z.2,z.1.sum)) | |
| def choiceInputRealizer : Realizer choiceInput := | |
| pair (composition first weightsCodeRealizer) | |
| (pair (composition second bitValue) (composition first listSum)) | |
| lemma polynomial_choiceInput : PolynomialTime choiceInputRealizer := | |
| polynomial_pair (polynomial_composition polynomial_first polynomial_weightsCode) | |
| (polynomial_pair (polynomial_composition polynomial_second polynomial_bitValue) | |
| (polynomial_composition polynomial_first polynomial_listSum)) | |
| /-- One trial returns an index or requests another independent word. | |
| All integers are processed in binary; no weight is expanded into copies. -/ | |
| def weightedIndex (z : Input) : Option ℕ := | |
| if StackAddition.value z.2<z.1.sum then some (ExecutableChoice.choose (choiceInput z)) else none | |
| def weightedIndexRealizer : Realizer weightedIndex := | |
| (choose (composition (pair (composition second bitValue) (composition first listSum)) less) | |
| (composition (composition choiceInputRealizer ExecutableChoice.chooseFast) TreeTyped.some) | |
| (constant none)).congr (by | |
| intro z | |
| simp only [Function.comp_apply,decide_eq_true_eq,weightedIndex]) | |
| lemma polynomial_weightedIndex : PolynomialTime weightedIndexRealizer := by | |
| unfold weightedIndexRealizer | |
| apply polynomial_congr | |
| exact polynomial_choose | |
| (polynomial_composition (polynomial_pair | |
| (polynomial_composition polynomial_second polynomial_bitValue) | |
| (polynomial_composition polynomial_first polynomial_listSum)) polynomial_less) | |
| (polynomial_composition | |
| (polynomial_composition polynomial_choiceInput ExecutableChoice.polynomial_chooseFast) | |
| polynomial_some) (polynomial_constant none) | |
| noncomputable section | |
| open ExactIntegerChoice | |
| open scoped BigOperators Classical | |
| lemma weightsCode_ofFn {r : ℕ} (w : Fin r → ℕ) : | |
| weightsCode (List.ofFn w)=List.ofFn (fun i => TreeFraction.repr (normalized w i)) := by | |
| simp only [weightsCode,List.sum_ofFn,List.map_ofFn,TreeFraction.normalize_repr] | |
| rfl | |
| /-- The compiled binary trial is exactly the integer-grid experiment. -/ | |
| lemma weightedIndex_ofFn {r k : ℕ} (w : Fin r → ℕ) (h : 0<totalWeight w) | |
| (hQ : totalWeight w≤2^k) (bits : Fin k → Bool) : | |
| weightedIndex (List.ofFn w,List.ofFn bits)= | |
| (weightedTrial w h hQ (FairBits.binaryWordEquiv k bits)).map Fin.val := by | |
| unfold weightedIndex choiceInput weightedTrial intervalTrial | |
| rw [weightsCode_ofFn,bitValue_eq_word,List.sum_ofFn] | |
| change (if (FairBits.binaryWordEquiv k bits).val<totalWeight w then _ else _)=_ | |
| split_ifs with hb | |
| · exact congrArg Option.some (ExecutableChoice.choose_eq (normalized w) (normalized_nonnegative w) | |
| (normalized_total w h) h ⟨(FairBits.binaryWordEquiv k bits).val,hb⟩) | |
| · rfl | |
| end | |
| end ContingencyTables.ExactIntegerPrograms | |
| end OAI | |