openAI-math-dataset / lean /OAI /Combinatorics /BalancedRyser /Probability /ConditionalMultiplicity.lean
| import OAI.Combinatorics.BalancedRyser.Candidates.CandidateExposure | |
| import OAI.Combinatorics.BalancedRyser.Probability.ExactMultiplicity | |
| import OAI.Combinatorics.BalancedRyser.Probability.FreshWitnessProbability | |
| namespace OAI | |
| namespace Balanced.CandidateExposure | |
| noncomputable section | |
| open scoped Classical BigOperators | |
| open ConditionalRestriction TupleAlignment | |
| variable {F : Type*} [Field F] [Fintype F] [DecidableEq F] | |
| theorem exposedLaw_fresh_direction_array (D : Finset (Direction F)) (a : MergedPairs F) : | |
| (exposedLaw D a).map (fun M (d : {d : Direction F // d ∉ D}) => M d.1) = | |
| PMF.uniformOfFintype ({d : Direction F // d ∉ D} → Bool → F) := by | |
| simpa only [exposedLaw, FreshWitnessProbability.exposedLaw, | |
| Function.Embedding.coeFn_mk] using | |
| FreshWitnessProbability.exposedLaw_map_fresh D a | |
| (⟨Subtype.val, Subtype.val_injective⟩ : {d : Direction F // d ∉ D} ↪ Direction F) | |
| (fun d => d.2) | |
| def freshMultiplicity (D : Finset (Direction F)) (M : MergedPairs F) (p : Point F) : ℕ := | |
| (Finset.univ.filter (fun ds : {d : Direction F // d ∉ D} × Bool => | |
| OnLine p (constituent M ds.1.1 ds.2))).card | |
| def exposedMultiplicity (D : Finset (Direction F)) (a : MergedPairs F) (p : Point F) : ℕ := | |
| (Finset.univ.filter (fun ds : {d : Direction F // d ∈ D} × Bool => | |
| OnLine p (constituent a ds.1.1 ds.2))).card | |
| theorem sampledMultiplicity_eq_exposed_add_fresh (D : Finset (Direction F)) | |
| (M : MergedPairs F) (p : Point F) : | |
| sampledMultiplicity M p = exposedMultiplicity D M p + freshMultiplicity D M p := by | |
| simp only [sampledMultiplicity, exposedMultiplicity, freshMultiplicity, | |
| Finset.card_filter, Fintype.sum_prod_type] | |
| convert (Fintype.sum_subtype_add_sum_subtype (fun d => d ∈ D) | |
| (fun d => ∑ b : Bool, if OnLine p (constituent M d b) then 1 else 0)).symm using 1 | |
| congr 1 | |
| apply Finset.sum_congr | |
| · ext d | |
| simp | |
| · intro d hd | |
| rfl | |
| omit [Fintype F] in | |
| theorem exposedMultiplicity_le (D : Finset (Direction F)) (a : MergedPairs F) | |
| (p : Point F) : exposedMultiplicity D a p ≤ 2 * D.card := by | |
| have h := Finset.card_filter_le (s := | |
| (Finset.univ : Finset ({d : Direction F // d ∈ D} × Bool))) | |
| (p := fun ds => OnLine p (constituent a ds.1.1 ds.2)) | |
| simpa [exposedMultiplicity, Fintype.card_prod, Nat.mul_comm] using h | |
| theorem sampledMultiplicity_eq_fixed_add_fresh (D : Finset (Direction F)) | |
| (a M : MergedPairs F) (p : Point F) (hM : M ∈ (exposedLaw D a).support) : | |
| sampledMultiplicity M p = exposedMultiplicity D a p + freshMultiplicity D M p := by | |
| have hfixed : ∀ d, d ∈ D → M d = a d := | |
| (PMF.mem_support_filter_iff (PartialAlignment.canonical_exposure_supported D a)).mp hM |>.1 | |
| rw [sampledMultiplicity_eq_exposed_add_fresh D M p] | |
| congr 1 | |
| unfold exposedMultiplicity | |
| have hpred : | |
| (fun directionSide : {d : Direction F // d ∈ D} × Bool => | |
| OnLine p (constituent M directionSide.1.1 directionSide.2)) = | |
| (fun directionSide : {d : Direction F // d ∈ D} × Bool => | |
| OnLine p (constituent a directionSide.1.1 directionSide.2)) := by | |
| funext directionSide | |
| simp only [constituent, hfixed directionSide.1.1 directionSide.1.2] | |
| simp only [hpred] | |
| theorem freshMultiplicity_atom (D : Finset (Direction F)) (a : MergedPairs F) | |
| (p : Point F) (m : ℕ) : | |
| conditionalProbability D a {M | freshMultiplicity D M p = m} = | |
| ((2 * (Fintype.card F + 1 - D.card)).choose m : ℝ) * | |
| (1 / (Fintype.card F : ℝ)) ^ m * | |
| (1 - 1 / (Fintype.card F : ℝ)) ^ | |
| (2 * (Fintype.card F + 1 - D.card) - m) := by | |
| let fresh := {d : Direction F // d ∉ D} | |
| let E : Set (fresh → Bool → F) := | |
| {o | (Finset.univ.filter (fun ds : fresh × Bool => | |
| lineEval ds.1.1 p = o ds.1 ds.2)).card = m} | |
| have hlaw := congrArg (fun law => (law.toOuterMeasure E).toReal) | |
| (exposedLaw_fresh_direction_array D a) | |
| rw [PMF.toOuterMeasure_map_apply] at hlaw | |
| change conditionalProbability D a {M | freshMultiplicity D M p = m} = | |
| ((PMF.uniformOfFintype (fresh → Bool → F)).toOuterMeasure E).toReal at hlaw | |
| rw [hlaw] | |
| let e := Equiv.curry fresh Bool F | |
| rw [← uniform_toOuterMeasure_equiv e E] | |
| have h := uniform_exact_coordinate_matches_binomial | |
| (fun ds : fresh × Bool => lineEval ds.1.1 p) m | |
| have hcard : Fintype.card fresh = Fintype.card F + 1 - D.card := by | |
| dsimp [fresh] | |
| rw [Fintype.card_subtype_compl] | |
| simp [Direction, Fintype.card_option, Fintype.card_coe] | |
| simpa [e, E, Equiv.curry, Function.curry, eq_comm, Fintype.card_prod, | |
| hcard, Nat.mul_comm] using h | |
| theorem freshMultiplicity_law (D : Finset (Direction F)) (a : MergedPairs F) | |
| (p : Point F) : | |
| ((exposedLaw D a).map (fun M => freshMultiplicity D M p)).toMeasure = | |
| ProbabilityTheory.binomial (2 * (Fintype.card F + 1 - D.card)) | |
| (multiplicityParameter F) := by | |
| apply MeasureTheory.Measure.ext_of_measureReal_singleton | |
| intro m | |
| rw [ProbabilityTheory.binomial_real_singleton] | |
| change (((exposedLaw D a).map (fun M => freshMultiplicity D M p)).toMeasure {m}).toReal = _ | |
| rw [PMF.toMeasure_apply_eq_toOuterMeasure_apply _ (measurableSet_singleton _), | |
| PMF.toOuterMeasure_map_apply] | |
| exact freshMultiplicity_atom D a p m | |
| theorem sampledMultiplicity_conditional_atom (D : Finset (Direction F)) (a : MergedPairs F) | |
| (p : Point F) (m : ℕ) : | |
| conditionalProbability D a | |
| {M | sampledMultiplicity M p = exposedMultiplicity D a p + m} = | |
| ((2 * (Fintype.card F + 1 - D.card)).choose m : ℝ) * | |
| (1 / (Fintype.card F : ℝ)) ^ m * | |
| (1 - 1 / (Fintype.card F : ℝ)) ^ | |
| (2 * (Fintype.card F + 1 - D.card) - m) := by | |
| rw [← freshMultiplicity_atom D a p m] | |
| have hsets : {M | sampledMultiplicity M p = exposedMultiplicity D a p + m} ∩ | |
| (exposedLaw D a).support = | |
| {M | freshMultiplicity D M p = m} ∩ (exposedLaw D a).support := by | |
| ext M | |
| simp only [Set.mem_inter_iff, Set.mem_ofPred_eq] | |
| constructor | |
| · rintro ⟨he, hM⟩ | |
| rw [sampledMultiplicity_eq_fixed_add_fresh D a M p hM] at he | |
| exact ⟨Nat.add_left_cancel he, hM⟩ | |
| · rintro ⟨he, hM⟩ | |
| exact ⟨by rw [sampledMultiplicity_eq_fixed_add_fresh D a M p hM, he], hM⟩ | |
| unfold conditionalProbability | |
| rw [← PMF.toOuterMeasure_apply_inter_support (exposedLaw D a) | |
| {M | sampledMultiplicity M p = exposedMultiplicity D a p + m}, | |
| hsets, PMF.toOuterMeasure_apply_inter_support] | |
| theorem sampledMultiplicity_conditional_law (D : Finset (Direction F)) | |
| (a : MergedPairs F) (p : Point F) : | |
| ((exposedLaw D a).map (fun M => sampledMultiplicity M p)).toMeasure = | |
| (ProbabilityTheory.binomial (2 * (Fintype.card F + 1 - D.card)) | |
| (multiplicityParameter F)).map (fun m => exposedMultiplicity D a p + m) := by | |
| have hmap : (exposedLaw D a).map (fun M => sampledMultiplicity M p) = | |
| (exposedLaw D a).map (fun M => exposedMultiplicity D a p + freshMultiplicity D M p) := by | |
| ext n | |
| simp only [PMF.map_apply] | |
| apply tsum_congr | |
| intro M | |
| by_cases hM : M ∈ (exposedLaw D a).support | |
| · rw [sampledMultiplicity_eq_fixed_add_fresh D a M p hM] | |
| · have hz : exposedLaw D a M = 0 := (PMF.apply_eq_zero_iff _ _).mpr hM | |
| simp [hz] | |
| rw [hmap, ← freshMultiplicity_law D a p] | |
| rw [PMF.toMeasure_map (fun m => exposedMultiplicity D a p + m) | |
| ((exposedLaw D a).map (fun M => freshMultiplicity D M p)) (by fun_prop), PMF.map_comp] | |
| rfl | |
| end | |
| end Balanced.CandidateExposure | |
| end OAI | |