openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Sampling /CompletionProbability.lean
| import Mathlib.Algebra.Group.Fin.Basic | |
| import Mathlib.Basic.Real.Basic | |
| import Mathlib.SetTheory.Cardinal.Finite | |
| import OAI.Computability.PerfectCompleteness.Reduction.CompletionLemmas | |
| namespace OAI | |
| section | |
| noncomputable section | |
| open scoped Classical | |
| namespace PerfectCompleteness.CompletionProbability | |
| variable {L A B : Type*} | |
| abbrev Illegal (legal : L ↪ A) := {a : A // a ∉ Set.range legal} | |
| def uniformProbability {Ω : Type*} [Fintype Ω] (event : Ω → Prop) : ℝ := | |
| (Fintype.card {ω : Ω // event ω} : ℝ) / Fintype.card Ω | |
| theorem card_illegal [Fintype L] [Fintype A] (legal : L ↪ A) : | |
| Fintype.card (Illegal legal) = Fintype.card A - Fintype.card L := by | |
| rw [Fintype.card_subtype_compl, Fintype.card_range legal] | |
| def rotate {n : ℕ} [NeZero n] (legal : L ↪ A) | |
| (enum : Illegal legal ≃ Fin n) (seed : Fin n) : Equiv.Perm (Illegal legal) where | |
| toFun a := enum.symm (seed + enum a) | |
| invFun a := enum.symm (-seed + enum a) | |
| left_inv a := by simp [← add_assoc] | |
| right_inv a := by simp [← add_assoc] | |
| def rotateAll {n : ℕ} [NeZero n] (legal : L ↪ A) | |
| (enum : Illegal legal ≃ Fin n) (seed : Fin n) : Equiv.Perm A := | |
| (Equiv.refl {a : A // a ∈ Set.range legal}).subtypeCongr (rotate legal enum seed) | |
| def sample {n : ℕ} [NeZero n] (legal : L ↪ A) (pHat : A → B) | |
| (enum : Illegal legal ≃ Fin n) (seed : Fin n) (a : A) : B := | |
| pHat (rotateAll legal enum seed a) | |
| @[simp] theorem sample_legal {n : ℕ} [NeZero n] (legal : L ↪ A) | |
| (pHat : A → B) (enum : Illegal legal ≃ Fin n) (seed : Fin n) (l : L) : | |
| sample legal pHat enum seed (legal l) = pHat (legal l) := by | |
| have hl : legal l ∈ Set.range legal := ⟨l, rfl⟩ | |
| exact congrArg pHat (Equiv.Perm.subtypeCongr.left_apply | |
| (Equiv.refl {a : A // a ∈ Set.range legal}) (rotate legal enum seed) hl) | |
| theorem sample_exact_two [Fintype A] {n : ℕ} [NeZero n] | |
| (legal : L ↪ A) (pHat : A → B) (enum : Illegal legal ≃ Fin n) | |
| (hexact : ∀ b, Fintype.card {a : A // pHat a = b} = 2) (seed : Fin n) (b : B) : | |
| Fintype.card {a : A // sample legal pHat enum seed a = b} = 2 := by | |
| exact (Fintype.card_congr ((rotateAll legal enum seed).subtypeEquivOfSubtype | |
| (p := fun a : A => pHat a = b))).trans (hexact b) | |
| def seedEquiv {n : ℕ} [NeZero n] (legal : L ↪ A) | |
| (enum : Illegal legal ≃ Fin n) (a : Illegal legal) : Fin n ≃ Illegal legal where | |
| toFun seed := enum.symm (seed + enum a) | |
| invFun j := enum j - enum a | |
| left_inv seed := by simp | |
| right_inv j := by simp | |
| @[simp] theorem sample_illegal {n : ℕ} [NeZero n] (legal : L ↪ A) | |
| (pHat : A → B) (enum : Illegal legal ≃ Fin n) (seed : Fin n) (a : Illegal legal) : | |
| sample legal pHat enum seed a.val = pHat ((seedEquiv legal enum a) seed).val := by | |
| exact congrArg pHat (Equiv.Perm.subtypeCongr.right_apply | |
| (Equiv.refl {a : A // a ∈ Set.range legal}) (rotate legal enum seed) a.property) | |
| theorem sample_event_card [Fintype A] {n : ℕ} [NeZero n] | |
| (legal : L ↪ A) (pHat : A → B) (enum : Illegal legal ≃ Fin n) | |
| (a : Illegal legal) (b : B) : | |
| Fintype.card {seed : Fin n // sample legal pHat enum seed a.val = b} = | |
| Fintype.card {j : Illegal legal // pHat j.val = b} := by | |
| exact Fintype.card_congr ((seedEquiv legal enum a).subtypeEquiv | |
| (fun seed => by simp)) | |
| theorem sample_probability [Fintype A] {n : ℕ} [NeZero n] | |
| (legal : L ↪ A) (pHat : A → B) (enum : Illegal legal ≃ Fin n) | |
| (a : Illegal legal) (b : B) : | |
| uniformProbability (fun seed : Fin n => sample legal pHat enum seed a.val = b) = | |
| (Fintype.card {j : Illegal legal // pHat j.val = b} : ℝ) / n := by | |
| rw [uniformProbability, sample_event_card, Fintype.card_fin] | |
| theorem residual_fiber_le_two [Fintype A] (legal : L ↪ A) (pHat : A → B) | |
| (hexact : ∀ b, Fintype.card {a : A // pHat a = b} = 2) (b : B) : | |
| Fintype.card {j : Illegal legal // pHat j.val = b} ≤ 2 := by | |
| let incl : {j : Illegal legal // pHat j.val = b} ↪ {a : A // pHat a = b} := | |
| ⟨fun j => ⟨j.val.val, j.property⟩, by | |
| intro j k h | |
| apply Subtype.ext | |
| apply Subtype.ext | |
| exact congrArg (fun z : {a : A // pHat a = b} => z.val) h⟩ | |
| exact (Fintype.card_le_of_embedding incl).trans (le_of_eq (hexact b)) | |
| theorem residual_fiber_card [Fintype L] [Fintype A] | |
| (legal : L ↪ A) (p : L → B) (pHat : A → B) | |
| (hext : ∀ l, pHat (legal l) = p l) | |
| (hexact : ∀ b, Fintype.card {a : A // pHat a = b} = 2) (b : B) : | |
| Fintype.card {a : Illegal legal // pHat a.val = b} = | |
| 2 - Fintype.card {l : L // p l = b} := by | |
| let F := {a : A // pHat a = b} | |
| let P : F → Prop := fun a => a.val ∈ Set.range legal | |
| let eLegal : {l : L // p l = b} ≃ {a : F // P a} := by | |
| refine Equiv.ofBijective | |
| (fun l : {l : L // p l = b} => | |
| (⟨⟨legal l.val, (hext l.val).trans l.property⟩, | |
| ⟨l.val, rfl⟩⟩ : {a : F // P a})) ⟨?_, ?_⟩ | |
| · intro x y h | |
| apply Subtype.ext | |
| apply legal.injective | |
| exact congrArg (fun a : {a : F // P a} => a.val.val) h | |
| · intro a | |
| obtain ⟨l, hl⟩ := (a.property : a.val.val ∈ Set.range legal) | |
| have hpl : p l = b := | |
| (hext l).symm.trans ((congrArg pHat hl).trans a.val.property) | |
| refine ⟨⟨l, hpl⟩, ?_⟩ | |
| apply Subtype.ext | |
| apply Subtype.ext | |
| exact hl | |
| let eResidual : {a : Illegal legal // pHat a.val = b} ≃ {a : F // ¬P a} := { | |
| toFun := fun a => ⟨⟨a.val.val, a.property⟩, a.val.property⟩ | |
| invFun := fun a => ⟨⟨a.val.val, a.property⟩, a.val.property⟩ | |
| left_inv := fun a => by | |
| apply Subtype.ext | |
| apply Subtype.ext | |
| rfl | |
| right_inv := fun a => by | |
| apply Subtype.ext | |
| apply Subtype.ext | |
| rfl | |
| } | |
| have hF : Fintype.card F = 2 := hexact b | |
| calc | |
| _ = Fintype.card {a : F // ¬P a} := Fintype.card_congr eResidual | |
| _ = Fintype.card F - Fintype.card {a : F // P a} := | |
| Fintype.card_subtype_compl P | |
| _ = 2 - Fintype.card {l : L // p l = b} := by | |
| rw [hF, ← Fintype.card_congr eLegal] | |
| theorem sample_probability_residual [Fintype L] [Fintype A] {n : ℕ} [NeZero n] | |
| (legal : L ↪ A) (p : L → B) (pHat : A → B) (enum : Illegal legal ≃ Fin n) | |
| (hext : ∀ l, pHat (legal l) = p l) | |
| (hexact : ∀ b, Fintype.card {a : A // pHat a = b} = 2) | |
| (a : Illegal legal) (b : B) : | |
| uniformProbability (fun seed : Fin n => sample legal pHat enum seed a.val = b) = | |
| ((2 - Fintype.card {l : L // p l = b} : ℕ) : ℝ) / | |
| (Fintype.card A - Fintype.card L : ℕ) := by | |
| rw [sample_probability] | |
| have hn : n = Fintype.card A - Fintype.card L := by | |
| rw [← card_illegal legal] | |
| simpa only [Fintype.card_fin] using (Fintype.card_congr enum).symm | |
| rw [← hn] | |
| simpa only [← Nat.card_eq_fintype_card] using | |
| congrArg (fun k : ℕ => (k : ℝ) / (n : ℝ)) | |
| (residual_fiber_card legal p pHat hext hexact b) | |
| theorem sample_probability_le [Fintype L] [Fintype A] {n : ℕ} [NeZero n] | |
| (legal : L ↪ A) (pHat : A → B) (enum : Illegal legal ≃ Fin n) | |
| (hexact : ∀ b, Fintype.card {a : A // pHat a = b} = 2) | |
| (a : Illegal legal) (b : B) : | |
| uniformProbability (fun seed : Fin n => sample legal pHat enum seed a.val = b) ≤ | |
| 2 / (Fintype.card A - Fintype.card L : ℕ) := by | |
| have hn : n = Fintype.card A - Fintype.card L := by | |
| rw [← card_illegal legal] | |
| simpa only [Fintype.card_fin] using (Fintype.card_congr enum).symm | |
| rw [sample_probability, hn] | |
| apply div_le_div_of_nonneg_right | |
| · exact Nat.cast_le.mpr (residual_fiber_le_two legal pHat hexact b) | |
| · exact Nat.cast_nonneg _ | |
| theorem exists_completion_sampler [Fintype L] [Fintype A] [Fintype B] | |
| (legal : L ↪ A) (p : L → B) | |
| (hsmall : ∀ b, Fintype.card {l : L // p l = b} ≤ 2) | |
| (hcard : Fintype.card A = 2 * Fintype.card B) : | |
| ∃ n : ℕ, 0 < n ∧ ∃ sampler : Fin n → A → B, | |
| (∀ seed l, sampler seed (legal l) = p l) ∧ | |
| (∀ seed b, Fintype.card {a : A // sampler seed a = b} = 2) ∧ | |
| ∀ (a : Illegal legal) (b : B), | |
| uniformProbability (fun seed => sampler seed a.val = b) = | |
| ((2 - Fintype.card {l : L // p l = b} : ℕ) : ℝ) / | |
| (Fintype.card A - Fintype.card L : ℕ) ∧ | |
| uniformProbability (fun seed => sampler seed a.val = b) ≤ | |
| 2 / (Fintype.card A - Fintype.card L : ℕ) := by | |
| obtain ⟨pHat, hext, hexact⟩ := | |
| Completion.exists_exact_two_completion legal p hsmall hcard | |
| by_cases hz : Fintype.card (Illegal legal) = 0 | |
| · refine ⟨1, Nat.zero_lt_one, (fun _ => pHat), ?_, ?_, ?_⟩ | |
| · intro seed l | |
| exact hext l | |
| · intro seed b | |
| exact hexact b | |
| · intro a b | |
| have hp : 0 < Fintype.card (Illegal legal) := Fintype.card_pos_iff.mpr ⟨a⟩ | |
| exact False.elim (Nat.ne_of_gt hp hz) | |
| · let : NeZero (Fintype.card (Illegal legal)) := ⟨hz⟩ | |
| let enum := Fintype.equivFin (Illegal legal) | |
| refine ⟨Fintype.card (Illegal legal), Nat.pos_of_ne_zero hz, | |
| sample legal pHat enum, ?_, ?_, ?_⟩ | |
| · intro seed l | |
| simpa only [sample_legal] using hext l | |
| · intro seed b | |
| exact sample_exact_two legal pHat enum hexact seed b | |
| · intro a b | |
| exact ⟨sample_probability_residual legal p pHat enum hext hexact a b, | |
| sample_probability_le legal pHat enum hexact a b⟩ | |
| end PerfectCompleteness.CompletionProbability | |
| end | |
| end | |
| end OAI | |