openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Sampling /BoundedListSamplingLemmas.lean
| import Mathlib.Data.Rat.Cast.Order | |
| import OAI.Computability.PerfectCompleteness.Reduction.CompletionSoundness | |
| import OAI.Computability.PerfectCompleteness.Reduction.TargetGameLemmas | |
| import OAI.Computability.PerfectCompleteness.Repetition.CleanConditioning | |
| import OAI.Computability.PerfectCompleteness.Sampling.FiniteListSampling | |
| import OAI.Computability.UniqueGames.Foundations.SamplingLemmas | |
| namespace OAI | |
| namespace PerfectCompleteness.BoundedListSampling | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| open UniqueGamesTheorem.Foundations.Games | |
| variable {Index A : Type*} [Fintype A] | |
| def listLaw (L : Finset A) (default : A) : FiniteDistribution A := | |
| if h : L.Nonempty then FiniteListSampling.uniformList L h | |
| else FiniteListSampling.uniformList {default} (Finset.singleton_nonempty default) | |
| theorem listLaw_of_nonempty (L : Finset A) (default : A) (h : L.Nonempty) : | |
| listLaw L default = FiniteListSampling.uniformList L h := by | |
| simp [listLaw, h] | |
| @[simp] theorem listLaw_empty_weight (default a : A) : | |
| (listLaw ∅ default).weight a = if a = default then 1 else 0 := by | |
| simp [listLaw, FiniteListSampling.uniformList] | |
| theorem listLaw_weight_mem (L : Finset A) (default a : A) (ha : a ∈ L) : | |
| (listLaw L default).weight a = 1 / (L.card : ℝ) := by | |
| rw [listLaw_of_nonempty L default ⟨a, ha⟩] | |
| exact FiniteListSampling.uniformList_weight_mem L ⟨a, ha⟩ a ha | |
| theorem listLaw_weight_lower (L : Finset A) (default : A) (M : ℝ) | |
| (hM : 0 < M) (hcard : (L.card : ℝ) ≤ M) (a : A) (ha : a ∈ L) : | |
| 1 / M ≤ (listLaw L default).weight a := by | |
| rw [listLaw_weight_mem L default a ha] | |
| have hcardPos : 0 < (L.card : ℝ) := Nat.cast_pos.mpr (Finset.Nonempty.card_pos ⟨a, ha⟩) | |
| apply (div_le_div_iff₀ hM hcardPos).mpr | |
| simpa only [one_mul] using hcard | |
| theorem list_success_lower (L : Finset A) (default : A) (M : ℝ) | |
| (hM : 0 < M) (hcard : (L.card : ℝ) ≤ M) (event : A → Bool) | |
| (witness : ∃ a ∈ L, event a = true) : | |
| 1 / M ≤ (listLaw L default).probability event := by | |
| obtain ⟨a, ha, hevent⟩ := witness | |
| exact (listLaw_weight_lower L default M hM hcard a ha).trans | |
| (FiniteListSampling.probability_ge_weight (listLaw L default) event a hevent) | |
| variable [Fintype Index] [Nonempty Index] | |
| def jointLaw (L : Index → Finset A) (default : A) : FiniteDistribution (Index × A) := | |
| CleanConditioning.kernelJoint (FiniteDistribution.uniform Index) (fun σ => listLaw (L σ) default) | |
| @[simp] theorem jointLaw_weight (L : Index → Finset A) (default : A) (σ : Index) (a : A) : | |
| (jointLaw L default).weight (σ, a) = | |
| (1 / (Fintype.card Index : ℝ)) * (listLaw (L σ) default).weight a := rfl | |
| theorem jointLaw_probability (L : Index → Finset A) (default : A) (event : Index × A → Bool) : | |
| (jointLaw L default).probability event = | |
| ∑ σ, (1 / (Fintype.card Index : ℝ)) * | |
| (listLaw (L σ) default).probability (fun a => event (σ, a)) := | |
| CleanConditioning.probability_kernelJoint _ _ _ | |
| theorem jointLaw_index_law (L : Index → Finset A) (default : A) : | |
| (jointLaw L default).pushforward Prod.fst = FiniteDistribution.uniform Index := by | |
| apply FiniteDistribution.eq_of_weight_eq | |
| intro σ | |
| change (∑ p : Index × A, if p.1 = σ then | |
| (FiniteDistribution.uniform Index).weight p.1 * (listLaw (L p.1) default).weight p.2 else 0) = | |
| (FiniteDistribution.uniform Index).weight σ | |
| rw [Fintype.sum_prod_type] | |
| calc | |
| _ = ∑ τ, if τ = σ then (FiniteDistribution.uniform Index).weight τ else 0 := by | |
| apply Finset.sum_congr rfl | |
| intro τ _ | |
| by_cases hτ : τ = σ | |
| · simp only [ite_eq_left hτ, ← Finset.mul_sum, FiniteDistribution.normalized, mul_one] | |
| · simp only [ite_eq_right hτ, Finset.sum_const_zero] | |
| _ = _ := by simp | |
| theorem jointLaw_weight_ge_of_mem (L : Index → Finset A) (default : A) (M : ℝ) | |
| (hM : 0 < M) (hcard : ∀ σ, ((L σ).card : ℝ) ≤ M) | |
| (σ : Index) (a : A) (ha : a ∈ L σ) : | |
| 1 / ((Fintype.card Index : ℝ) * M) ≤ (jointLaw L default).weight (σ, a) := by | |
| rw [jointLaw_weight, ← one_div_mul_one_div] | |
| exact mul_le_mul_of_nonneg_left (listLaw_weight_lower (L σ) default M hM (hcard σ) a ha) | |
| (one_div_nonneg.mpr (Nat.cast_nonneg _)) | |
| theorem joint_success_lower (L : Index → Finset A) (default : A) (M : ℝ) | |
| (hM : 0 < M) (hcard : ∀ σ, ((L σ).card : ℝ) ≤ M) | |
| (event : Index × A → Bool) (witness : ∃ σ a, a ∈ L σ ∧ event (σ, a) = true) : | |
| 1 / ((Fintype.card Index : ℝ) * M) ≤ (jointLaw L default).probability event := by | |
| obtain ⟨σ, a, ha, hevent⟩ := witness | |
| exact (jointLaw_weight_ge_of_mem L default M hM hcard σ a ha).trans | |
| (FiniteListSampling.probability_ge_weight (jointLaw L default) event (σ, a) hevent) | |
| theorem joint_success_lower_of_indices (L : Index → Finset A) (default : A) (M : ℝ) | |
| (hM : 0 < M) (hcard : ∀ σ, ((L σ).card : ℝ) ≤ M) | |
| (event : Index × A → Bool) (good : Index → Bool) | |
| (witness : ∀ σ, good σ = true → ∃ a ∈ L σ, event (σ, a) = true) : | |
| (FiniteDistribution.uniform Index).probability good / M ≤ | |
| (jointLaw L default).probability event := by | |
| have hstep : ∀ σ, (if good σ then 1 / M else 0) ≤ | |
| (listLaw (L σ) default).probability (fun a => event (σ, a)) := by | |
| intro σ | |
| by_cases hgood : good σ = true | |
| · simpa only [hgood, ite_true] using | |
| list_success_lower (L σ) default M hM (hcard σ) _ (witness σ hgood) | |
| · simpa [hgood] using | |
| (listLaw (L σ) default).probability_nonnegative (fun a => event (σ, a)) | |
| calc | |
| _ = ∑ σ, (FiniteDistribution.uniform Index).weight σ * (if good σ then 1 / M else 0) := by | |
| simp only [FiniteDistribution.probability, Finset.sum_div, ite_div, zero_div, | |
| mul_ite, mul_one_div, mul_zero] | |
| _ ≤ ∑ σ, (FiniteDistribution.uniform Index).weight σ * | |
| (listLaw (L σ) default).probability (fun a => event (σ, a)) := | |
| Finset.sum_le_sum (fun σ _ => mul_le_mul_of_nonneg_left (hstep σ) | |
| ((FiniteDistribution.uniform Index).nonnegative σ)) | |
| _ = _ := (jointLaw_probability L default event).symm | |
| def outputLaw {B : Type*} [Fintype B] (L : Index → Finset A) (default : A) | |
| (decode : Index → A → B) : FiniteDistribution B := | |
| (jointLaw L default).pushforward (fun p => decode p.1 p.2) | |
| theorem outputLaw_probability {B : Type*} [Fintype B] | |
| (L : Index → Finset A) (default : A) (decode : Index → A → B) (event : B → Bool) : | |
| (outputLaw L default decode).probability event = | |
| (jointLaw L default).probability (fun p => event (decode p.1 p.2)) := | |
| FiniteDistribution.probability_pushforward _ _ _ | |
| theorem output_success_lower {B : Type*} [Fintype B] | |
| (L : Index → Finset A) (default : A) (decode : Index → A → B) | |
| (M : ℝ) (hM : 0 < M) (hcard : ∀ σ, ((L σ).card : ℝ) ≤ M) | |
| (event : B → Bool) | |
| (witness : ∃ σ a, a ∈ L σ ∧ event (decode σ a) = true) : | |
| 1 / ((Fintype.card Index : ℝ) * M) ≤ (outputLaw L default decode).probability event := by | |
| rw [outputLaw_probability] | |
| exact joint_success_lower L default M hM hcard _ witness | |
| theorem output_weight_ge_of_mem {B : Type*} [Fintype B] | |
| (L : Index → Finset A) (default : A) (decode : Index → A → B) | |
| (M : ℝ) (hM : 0 < M) (hcard : ∀ σ, ((L σ).card : ℝ) ≤ M) | |
| (σ : Index) (a : A) (ha : a ∈ L σ) : | |
| 1 / ((Fintype.card Index : ℝ) * M) ≤ (outputLaw L default decode).weight (decode σ a) := by | |
| have h := output_success_lower L default decode M hM hcard | |
| (fun b => decide (b = decode σ a)) ⟨σ, a, ha, by simp⟩ | |
| simpa [FiniteDistribution.probability] using h | |
| theorem independent_match_lower {B C : Type*} [Fintype B] [Fintype C] [Nonempty C] | |
| (L : Index → Finset A) (default : A) (decode : Index → A → B) | |
| (M : ℝ) (hM : 0 < M) (hcard : ∀ σ, ((L σ).card : ℝ) ≤ M) | |
| (accepts : C → B → Bool) | |
| (witness : ∃ σ a, a ∈ L σ ∧ ∃ c, accepts c (decode σ a) = true) : | |
| 1 / ((Fintype.card C : ℝ) * (Fintype.card Index : ℝ) * M) ≤ | |
| ((FiniteDistribution.uniform C).product (outputLaw L default decode)).probability | |
| (fun p => accepts p.1 p.2) := by | |
| obtain ⟨σ, a, ha, c, haccept⟩ := witness | |
| have hright := output_weight_ge_of_mem L default decode M hM hcard σ a ha | |
| calc | |
| _ = (1 / (Fintype.card C : ℝ)) * (1 / ((Fintype.card Index : ℝ) * M)) := by | |
| simp only [one_div_mul_one_div, mul_assoc] | |
| _ ≤ ((FiniteDistribution.uniform C).product (outputLaw L default decode)).weight | |
| (c, decode σ a) := | |
| mul_le_mul_of_nonneg_left hright ((FiniteDistribution.uniform C).nonnegative c) | |
| _ ≤ _ := FiniteListSampling.probability_ge_weight _ _ (c, decode σ a) haccept | |
| end | |
| end PerfectCompleteness.BoundedListSampling | |
| namespace PerfectCompleteness.LegalUniform | |
| open scoped BigOperators Classical | |
| open UniqueGamesTheorem.Foundations.Games | |
| open WeightRounding | |
| noncomputable section | |
| def enumeratedWeights {E : Type*} [Fintype E] | |
| (f : E → ℚ) (hpositive : ∀ e, 0 < f e) (htotal : ∑ e, f e = 1) | |
| (enum : E ≃ Fin (Fintype.card E)) : PositiveWeights (Fintype.card E) where | |
| weight i := f (enum.symm i) | |
| positive i := hpositive (enum.symm i) | |
| total := (enum.symm.sum_comp f).trans htotal | |
| theorem transport_weight_eq_enumerated {E : Type*} [Fintype E] | |
| (μ : FiniteDistribution E) (f : E → ℚ) | |
| (hpositive : ∀ e, 0 < f e) (htotal : ∑ e, f e = 1) | |
| (hweights : ∀ e, μ.weight e = (f e : ℝ)) | |
| (enum : E ≃ Fin (Fintype.card E)) (i : Fin (Fintype.card E)) : | |
| (μ.transport enum).weight i = | |
| ((enumeratedWeights f hpositive htotal enum).weight i : ℝ) := | |
| hweights (enum.symm i) | |
| def uniformWeights (E : Type*) [Fintype E] [Nonempty E] : | |
| PositiveWeights (Fintype.card E) where | |
| weight _ := 1 / (Fintype.card E : ℚ) | |
| positive _ := by | |
| have hcard : (0 : ℚ) < Fintype.card E := by | |
| exact_mod_cast (Fintype.card_pos : 0 < Fintype.card E) | |
| exact div_pos zero_lt_one hcard | |
| total := by | |
| have hcard : (Fintype.card E : ℚ) ≠ 0 := | |
| Nat.cast_ne_zero.mpr Fintype.card_ne_zero | |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, | |
| nsmul_eq_mul, one_div] | |
| exact mul_inv_cancel₀ hcard | |
| @[simp] theorem uniformWeights_weight (E : Type*) [Fintype E] [Nonempty E] | |
| (i : Fin (Fintype.card E)) : | |
| (uniformWeights E).weight i = 1 / (Fintype.card E : ℚ) := rfl | |
| theorem transport_uniform_weight {E : Type*} [Fintype E] [Nonempty E] | |
| (μ : FiniteDistribution E) (huniform : μ = FiniteDistribution.uniform E) | |
| (enum : E ≃ Fin (Fintype.card E)) (i : Fin (Fintype.card E)) : | |
| (μ.transport enum).weight i = ((uniformWeights E).weight i : ℝ) := by | |
| rw [huniform] | |
| change (1 / (Fintype.card E : ℝ)) = ((1 / (Fintype.card E : ℚ) : ℚ) : ℝ) | |
| simp only [Rat.cast_div, Rat.cast_one, Rat.cast_natCast] | |
| theorem equivFin_uniform_weight {E : Type*} [Fintype E] [Nonempty E] | |
| (μ : FiniteDistribution E) (huniform : μ = FiniteDistribution.uniform E) | |
| (i : Fin (Fintype.card E)) : | |
| (μ.transport (Fintype.equivFin E)).weight i = | |
| ((uniformWeights E).weight i : ℝ) := | |
| transport_uniform_weight μ huniform (Fintype.equivFin E) i | |
| theorem exists_uniform_weights {E : Type*} [Fintype E] [Nonempty E] | |
| (μ : FiniteDistribution E) (huniform : μ = FiniteDistribution.uniform E) : | |
| ∃ w : PositiveWeights (Fintype.card E), | |
| (∀ i, w.weight i = 1 / (Fintype.card E : ℚ)) ∧ | |
| ∀ i, (μ.transport (Fintype.equivFin E)).weight i = (w.weight i : ℝ) := by | |
| exact ⟨uniformWeights E, uniformWeights_weight E, equivFin_uniform_weight μ huniform⟩ | |
| end | |
| end PerfectCompleteness.LegalUniform | |
| end OAI | |