openAI-math-dataset / lean /OAI /Combinatorics /BalancedRyser /Probability /ConditionalRestriction.lean
| import OAI.Combinatorics.BalancedRyser.Probability.FiniteUniformConditioning | |
| import OAI.Combinatorics.BalancedRyser.Probability.UniformRestriction | |
| namespace OAI | |
| namespace Balanced.ConditionalRestriction | |
| open TupleAlignment | |
| noncomputable section | |
| attribute [local instance] Classical.propDecidable | |
| variable {D ι A : Type*} | |
| abbrev FixedArray (P : D → Prop) (a : D → A) := | |
| {o : D → A // ∀ d, P d → o d = a d} | |
| instance (P : D → Prop) (a : D → A) : Nonempty (FixedArray P a) := | |
| ⟨⟨a, by intro d hd; rfl⟩⟩ | |
| def fixedFreshEquiv (P : D → Prop) (a : D → A) : | |
| FixedArray P a ≃ ({d : D // ¬ P d} → A) where | |
| toFun o d := o.1 d.1 | |
| invFun f := ⟨fun d => if hd : P d then a d else f ⟨d,hd⟩, by | |
| intro d hd | |
| simp only [dite_eq_left hd]⟩ | |
| left_inv o := by | |
| apply Subtype.ext | |
| funext d | |
| by_cases hd : P d | |
| · simp only [dite_eq_left hd] | |
| exact (o.2 d hd).symm | |
| · simp only [dite_eq_right hd] | |
| right_inv f := by | |
| funext d | |
| simp only [dite_eq_right d.2] | |
| def fixedRestrict (e : ι ↪ D) (P : D → Prop) (a : D → A) | |
| (o : FixedArray P a) : FixedArray (fun i => P (e i)) (fun i => a (e i)) := | |
| ⟨fun i => o.1 (e i), fun i hi => o.2 (e i) hi⟩ | |
| def freshEmbedding (e : ι ↪ D) (P : D → Prop) : | |
| {i : ι // ¬ P (e i)} ↪ {d : D // ¬ P d} where | |
| toFun i := ⟨e i.1, i.2⟩ | |
| inj' := by | |
| intro i j h | |
| apply Subtype.ext | |
| exact e.injective (congrArg Subtype.val h) | |
| theorem fixedRestriction_commutes (e : ι ↪ D) (P : D → Prop) (a : D → A) : | |
| fixedRestrict e P a ∘ (fixedFreshEquiv P a).symm = | |
| (fixedFreshEquiv (fun i => P (e i)) (fun i => a (e i))).symm ∘ | |
| (fun f i => f (freshEmbedding e P i)) := by | |
| funext f | |
| apply Subtype.ext | |
| funext i | |
| rfl | |
| variable [Fintype D] [Fintype ι] [Fintype A] | |
| [DecidableEq D] [DecidableEq ι] [Nonempty A] | |
| theorem uniform_fixed_restrict (e : ι ↪ D) (P : D → Prop) (a : D → A) : | |
| (PMF.uniformOfFintype (FixedArray P a)).map (fixedRestrict e P a) = | |
| PMF.uniformOfFintype (FixedArray (fun i => P (e i)) (fun i => a (e i))) := by | |
| have hsource := uniform_map_equiv (fixedFreshEquiv P a).symm | |
| have htarget := uniform_map_equiv (fixedFreshEquiv (fun i => P (e i)) (fun i => a (e i))).symm | |
| have hrestrict := uniform_map_restrict (A := A) (freshEmbedding e P) | |
| rw [← hsource, PMF.map_comp, fixedRestriction_commutes, | |
| ← PMF.map_comp, hrestrict, htarget] | |
| theorem fixed_supported (P : D → Prop) (a : D → A) : | |
| ∃ o ∈ {o : D → A | ∀ d, P d → o d = a d}, | |
| o ∈ (PMF.uniformOfFintype (D → A)).support := | |
| ⟨a, by intro d hd; rfl, PMF.mem_support_uniformOfFintype _⟩ | |
| theorem uniform_fixed_filter (P : D → Prop) (a : D → A) : | |
| (PMF.uniformOfFintype (D → A)).filter | |
| {o | ∀ d, P d → o d = a d} (fixed_supported P a) = | |
| (PMF.uniformOfFintype (FixedArray P a)).map Subtype.val := by | |
| let : Nonempty ({o : D → A | ∀ d, P d → o d = a d} : Set (D → A)) := | |
| ⟨⟨a, by intro d hd; rfl⟩⟩ | |
| exact Balanced.uniform_filter_eq_subtype_map _ _ | |
| theorem uniform_conditional_restrict (e : ι ↪ D) (P : D → Prop) (a : D → A) : | |
| ((PMF.uniformOfFintype (D → A)).filter | |
| {o | ∀ d, P d → o d = a d} (fixed_supported P a)).map | |
| (fun o i => o (e i)) = | |
| (PMF.uniformOfFintype (ι → A)).filter | |
| {o | ∀ i, P (e i) → o i = a (e i)} | |
| (fixed_supported (fun i => P (e i)) (fun i => a (e i))) := by | |
| rw [uniform_fixed_filter, uniform_fixed_filter, PMF.map_comp] | |
| change (PMF.uniformOfFintype (FixedArray P a)).map | |
| (Subtype.val ∘ fixedRestrict e P a) = _ | |
| rw [← PMF.map_comp, uniform_fixed_restrict] | |
| end | |
| end Balanced.ConditionalRestriction | |
| end OAI | |