openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Counting /FiniteSamplerCoupling.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.FiniteKernels | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.BoundedSampling | |
| namespace OAI | |
| /-! # Explicit finite couplings for dependent bounded samplers | |
| The source retains fresh candidate tuples and independent backup choices. | |
| The backup is used only by the ideal completion of an exhausted call; the | |
| bounded output is `none` at that point. No law is conditioned on every call | |
| succeeding. | |
| -/ | |
| noncomputable section | |
| namespace LowSpaceSubsetSum | |
| open scoped BigOperators | |
| attribute [local instance] Classical.propDecidable | |
| namespace FiniteLaw | |
| variable {Ω α : Type*} [Fintype Ω] [Fintype α] | |
| def map (μ : FiniteLaw Ω) (f : Ω → α) : FiniteLaw α where | |
| mass a := μ.probability (fun x => f x = a) | |
| nonneg _ := μ.probability_nonneg _ | |
| total := by | |
| classical | |
| simp only [probability] | |
| rw [Finset.sum_comm] | |
| simpa using μ.total | |
| def expectation (μ : FiniteLaw Ω) (f : Ω → ℝ) : ℝ := ∑ x, μ.mass x * f x | |
| theorem map_expectation (μ : FiniteLaw Ω) (f : Ω → α) (g : α → ℝ) : | |
| (μ.map f).expectation g = μ.expectation (fun x => g (f x)) := by | |
| classical | |
| simp only [expectation, map, probability, Finset.sum_mul, ite_mul, zero_mul] | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro x _ | |
| simp | |
| theorem probability_eq_expectation (μ : FiniteLaw Ω) (P : Ω → Prop) : | |
| μ.probability P = μ.expectation (fun x => if P x then 1 else 0) := by | |
| classical | |
| simp only [probability, expectation, mul_ite, mul_one, mul_zero] | |
| theorem map_probability (μ : FiniteLaw Ω) (f : Ω → α) (P : α → Prop) : | |
| (μ.map f).probability P = μ.probability (fun x => P (f x)) := by | |
| classical | |
| rw [probability_eq_expectation, map_expectation, probability_eq_expectation] | |
| theorem probability_or_le (μ : FiniteLaw Ω) (P Q : Ω → Prop) : | |
| μ.probability (fun x => P x ∨ Q x) ≤ μ.probability P + μ.probability Q := by | |
| classical | |
| simp only [probability, ← Finset.sum_add_distrib] | |
| apply Finset.sum_le_sum | |
| intro x _ | |
| by_cases hp : P x <;> by_cases hq : Q x <;> simp [hp, hq, μ.nonneg x] | |
| end FiniteLaw | |
| /-- An explicit common probability space for an ideal result and a bounded | |
| result. Every nonfailure agrees exactly; failure remains part of the law. -/ | |
| structure SamplerCoupling (α : Type*) [Fintype α] where | |
| Seed : Type | |
| finiteSeed : Fintype Seed | |
| law : Seed finiteSeed | |
| ideal : Seed → α | |
| bounded : Seed → Option α | |
| agrees : ∀ s, bounded s = none ∨ bounded s = some (ideal s) | |
| namespace SamplerCoupling | |
| variable {α : Type*} [Fintype α] | |
| instance (S : SamplerCoupling α) : Fintype S.Seed := S.finiteSeed | |
| def idealLaw (S : SamplerCoupling α) : FiniteLaw α := S.law.map S.ideal | |
| def boundedLaw (S : SamplerCoupling α) : FiniteLaw (Option α) := S.law.map S.bounded | |
| def failure (S : SamplerCoupling α) : ℝ := S.law.probability (fun s => S.bounded s = none) | |
| def pure (a : α) : SamplerCoupling α where | |
| Seed := Unit | |
| finiteSeed := inferInstance | |
| law := FiniteLaw.uniform | |
| ideal _ := a | |
| bounded _ := some a | |
| agrees _ := Or.inr rfl | |
| def bind (S : SamplerCoupling α) (β : α → Type) [∀ a, Fintype (β a)] | |
| (T : ∀ a, SamplerCoupling (β a)) : SamplerCoupling (Σ a, β a) where | |
| Seed := Σ s : S.Seed, (T (S.ideal s)).Seed | |
| finiteSeed := inferInstance | |
| law := S.law.bind (fun s => (T (S.ideal s)).Seed) (fun s => (T (S.ideal s)).law) | |
| ideal s := ⟨S.ideal s.1, (T (S.ideal s.1)).ideal s.2⟩ | |
| bounded s := if S.bounded s.1 = none then none else | |
| ((T (S.ideal s.1)).bounded s.2).map (fun b => ⟨S.ideal s.1, b⟩) | |
| agrees s := by | |
| classical | |
| split | |
| · exact Or.inl rfl | |
| · rcases (T (S.ideal s.1)).agrees s.2 with h | h | |
| · exact Or.inl (by simp [h]) | |
| · exact Or.inr (by simp [h]) | |
| /-- The ideal marginal follows the exact prescribed conditional laws. -/ | |
| theorem bind_ideal_probability (S : SamplerCoupling α) (β : α → Type) | |
| [∀ a, Fintype (β a)] (T : ∀ a, SamplerCoupling (β a)) | |
| (P : (Σ a, β a) → Prop) : | |
| (S.bind β T).idealLaw.probability P = | |
| (S.idealLaw.bind β (fun a => (T a).idealLaw)).probability P := by | |
| classical | |
| rw [idealLaw, FiniteLaw.map_probability] | |
| change (S.law.bind (fun s => (T (S.ideal s)).Seed) | |
| (fun s => (T (S.ideal s)).law)).probability | |
| (fun z => P ⟨S.ideal z.1, (T (S.ideal z.1)).ideal z.2⟩) = _ | |
| rw [FiniteLaw.bind_probability, FiniteLaw.bind_probability] | |
| change S.law.expectation (fun s => | |
| (T (S.ideal s)).law.probability (fun t => P ⟨S.ideal s, (T (S.ideal s)).ideal t⟩)) = _ | |
| have hpoint (a : α) : (T a).law.probability | |
| (fun t => P ⟨a, (T a).ideal t⟩) = | |
| (T a).idealLaw.probability (fun b => P ⟨a, b⟩) := | |
| (FiniteLaw.map_probability (T a).law (T a).ideal (fun b => P ⟨a, b⟩)).symm | |
| simp_rw [hpoint] | |
| exact (FiniteLaw.map_expectation S.law S.ideal | |
| (fun a => (T a).idealLaw.probability (fun b => P ⟨a, b⟩))).symm | |
| /-- The probability of first divergence is at most the previous loss plus | |
| the uniform conditional bound for the next call. -/ | |
| theorem bind_failure_le (S : SamplerCoupling α) (β : α → Type) | |
| [∀ a, Fintype (β a)] (T : ∀ a, SamplerCoupling (β a)) | |
| (δ : ℝ) (hT : ∀ a, (T a).failure ≤ δ) : | |
| (S.bind β T).failure ≤ S.failure + δ := by | |
| classical | |
| let L := S.law.bind (fun s => (T (S.ideal s)).Seed) (fun s => (T (S.ideal s)).law) | |
| have he : (S.bind β T).failure = L.probability (fun s => | |
| S.bounded s.1 = none ∨ (T (S.ideal s.1)).bounded s.2 = none) := by | |
| apply congrArg L.probability | |
| funext s | |
| apply propext | |
| simp only [bind] | |
| split <;> simp_all | |
| rw [he] | |
| apply (L.probability_or_le _ _).trans | |
| have hfirst : L.probability (fun s => S.bounded s.1 = none) = S.failure := | |
| FiniteLaw.bind_first_probability S.law (fun s => (T (S.ideal s)).Seed) | |
| (fun s => (T (S.ideal s)).law) (fun s => S.bounded s = none) | |
| rw [hfirst] | |
| apply add_le_add (le_refl _) | |
| dsimp only [L] | |
| rw [FiniteLaw.bind_probability] | |
| calc | |
| _ ≤ ∑ s, S.law.mass s * δ := by | |
| apply Finset.sum_le_sum | |
| intro s _ | |
| exact mul_le_mul_of_nonneg_left (hT (S.ideal s)) (S.law.nonneg s) | |
| _ = δ := by rw [← Finset.sum_mul, S.law.total, one_mul] | |
| /-- Every ideal event loses at most the unconditional coupling failure. -/ | |
| theorem event_lower (S : SamplerCoupling α) (P : α → Prop) : | |
| S.idealLaw.probability P - S.failure ≤ | |
| S.boundedLaw.probability (fun x => ∃ a, x = some a ∧ P a) := by | |
| classical | |
| rw [idealLaw, boundedLaw, FiniteLaw.map_probability, FiniteLaw.map_probability, failure] | |
| have hi := S.law.probability_inter_ge_sub (fun s => P (S.ideal s)) | |
| (fun s => S.bounded s ≠ none) | |
| simp only [not_not] at hi | |
| apply hi.trans | |
| apply S.law.probability_mono | |
| intro s hs | |
| rcases S.agrees s with hf | he | |
| · exact (hs.2 hf).elim | |
| · exact ⟨S.ideal s, he, hs.1⟩ | |
| end SamplerCoupling | |
| end LowSpaceSubsetSum | |
| end | |
| end OAI | |