| import OAI.Combinatorics.BalancedRyser.Local.GlobalPartialAlignment |
| import OAI.Combinatorics.BalancedRyser.Local.Local |
| import OAI.Combinatorics.BalancedRyser.Local.LowReuseOrder |
| import OAI.Combinatorics.BalancedRyser.Probability.FiniteUniformFibers |
|
|
| namespace OAI |
|
|
| namespace Balanced.AlignedListProbability |
|
|
| open TupleAlignment PartialAlignment ConditionalRestriction |
| open scoped BigOperators |
|
|
| noncomputable section |
| attribute [local instance] Classical.propDecidable |
|
|
| variable {F : Type*} [Field F] [Fintype F] [DecidableEq F] |
|
|
| theorem partial_alignment_probability_eq (d : Fin 4 → Direction F) |
| (hd : ∀ i, d i ≠ d (i + 1)) (σ : Fin 4 → Bool) |
| (g : Direction F) (hg : ∀ i, d i ≠ g) (c : F) |
| (J : Finset (Fin 4)) (hJ : J.card ≤ 1) (a : Fin 4 → Bool → F) : |
| ((PMF.uniformOfFintype (PartialOffsets J a)).toOuterMeasure |
| {o | ∀ i, OnLine (tuplePositionEquiv d hd σ o.1 i) (g,c)}).toReal = |
| (Fintype.card F : ℝ)⁻¹ ^ 4 := by |
| rcases J.eq_empty_or_nonempty with rfl | ⟨j, hj⟩ |
| · let e : PartialOffsets ∅ a ≃ (Fin 4 → Bool → F) := |
| Equiv.subtypeUnivEquiv (by simp) |
| have h := congrArg (fun law => (law.toOuterMeasure |
| {o | ∀ i, OnLine (tuplePositionEquiv d hd σ o i) (g,c)}).toReal) |
| (uniform_map_equiv e) |
| rw [PMF.toOuterMeasure_map_apply] at h |
| exact h.trans (alignedOffsets_outer_probability d hd σ g c) |
| · have heq : J = {j} := by |
| apply Finset.eq_singleton_iff_unique_mem.mpr |
| exact ⟨hj, fun k hk => Finset.card_le_one.mp hJ k hk j hj⟩ |
| subst J |
| let e : PartialOffsets {j} a ≃ ChildOffsetsAt j (a j) := |
| Equiv.subtypeEquivRight (by intro o; simp) |
| have h := congrArg (fun law => (law.toOuterMeasure |
| {o : ChildOffsetsAt j (a j) | |
| ∀ i, OnLine (tuplePositionEquiv d hd σ o.1 i) (g,c)}).toReal) |
| (uniform_map_equiv e) |
| rw [PMF.toOuterMeasure_map_apply] at h |
| exact h.trans (alignedChildOffsetsAt_pmf_probability d hd σ g j (hg j) c (a j)) |
|
|
| theorem global_conditional_alignment_probability_eq (T : FourTuple F) |
| (hT : Function.Injective T.generator) (g : Direction F) |
| (hg : ∀ i, T.generator i ≠ g) (c : F) |
| (D : Finset (Direction F)) (hD : (exposedTupleIndices T D).card ≤ 1) |
| (a : MergedPairs F) : |
| (((PMF.uniformOfFintype (MergedPairs F)).filter {M | ∀ d, d ∈ D → M d = a d} |
| (fixed_supported (fun d => d ∈ D) a)).toOuterMeasure |
| {M | ∀ i, OnLine (tuplePoint M T i) (g,c)}).toReal = |
| (Fintype.card F : ℝ)⁻¹ ^ 4 := by |
| let hd := adjacent_ne_of_injective T hT |
| let E : Set (Fin 4 → Bool → F) := |
| {o | ∀ i, OnLine (tuplePositionEquiv T.generator hd T.side o i) (g,c)} |
| have h := congrArg (fun law => (law.toOuterMeasure E).toReal) |
| (global_exposed_tuple_law T hT D a) |
| rw [PMF.toOuterMeasure_map_apply] at h |
| calc |
| _ = (((PMF.uniformOfFintype (Fin 4 → Bool → F)).filter |
| {o | ∀ i ∈ exposedTupleIndices T D, o i = a (T.generator i)} |
| (partialOffsets_supported (exposedTupleIndices T D) |
| (fun i => a (T.generator i)))).toOuterMeasure E).toReal := h |
| _ = _ := by |
| rw [partialOffsets_conditional_law, PMF.toOuterMeasure_map_apply] |
| exact partial_alignment_probability_eq T.generator hd T.side g hg c |
| (exposedTupleIndices T D) hD (fun i => a (T.generator i)) |
|
|
| theorem canonical_conditional_alignment_probability_eq (T : FourTuple F) |
| (hT : Function.Injective T.generator) (g : Direction F) |
| (hg : ∀ i, T.generator i ≠ g) (c : F) |
| (D : Finset (Direction F)) (hD : (exposedTupleIndices T D).card ≤ 1) |
| (a : MergedPairs F) : |
| (((offsetLaw F).filter {M | ∀ d, d ∈ D → M d = a d} |
| (canonical_exposure_supported D a)).toOuterMeasure |
| {M | ∀ i, OnLine (tuplePoint M T i) (g,c)}).toReal = |
| (Fintype.card F : ℝ)⁻¹ ^ 4 := by |
| simpa only [offsetLaw_eq_uniform] using |
| global_conditional_alignment_probability_eq T hT g hg c D hD a |
|
|
| omit [Field F] [Fintype F] in |
|
|
| theorem card_exposedTupleIndices (T : FourTuple F) |
| (hT : Function.Injective T.generator) (D : Finset (Direction F)) : |
| (exposedTupleIndices T D).card = (generatorSet T ∩ D).card := by |
| have heq : (exposedTupleIndices T D).image T.generator = generatorSet T ∩ D := by |
| ext d |
| simp only [exposedTupleIndices, generatorSet, Finset.mem_image, |
| Finset.mem_filter, Finset.mem_univ, true_and, Finset.mem_inter] |
| constructor |
| · rintro ⟨i, hi, rfl⟩ |
| exact ⟨⟨i, rfl⟩, hi⟩ |
| · rintro ⟨⟨i, rfl⟩, hi⟩ |
| exact ⟨i, hi, rfl⟩ |
| rw [← heq, Finset.card_image_of_injective _ hT] |
|
|
| omit [Fintype F] in |
|
|
| theorem tuplePoint_eq_of_agree (T : FourTuple F) (M N : MergedPairs F) |
| (h : ∀ d ∈ generatorSet T, M d = N d) (j : Fin 4) : |
| tuplePoint M T j = tuplePoint N T j := by |
| have hj : T.generator j ∈ generatorSet T := by simp [generatorSet] |
| have hn : T.generator (j+1) ∈ generatorSet T := by simp [generatorSet] |
| simp only [tuplePoint, constituent, h _ hj, h _ hn] |
|
|
| def ListAligned {ι : Type*} (T : ι → FourTuple F) (L : ι → Line F) |
| (l : List ι) (M : MergedPairs F) : Prop := |
| ∀ i ∈ l, ∀ j, OnLine (tuplePoint M (T i) j) (L i) |
|
|
| omit [Fintype F] in |
| theorem listAligned_agree {ι : Type*} [DecidableEq ι] |
| (T : ι → FourTuple F) (L : ι → Line F) (l : List ι) |
| (M N : MergedPairs F) |
| (h : ∀ d ∈ l.toFinset.biUnion (fun i => generatorSet (T i)), M d = N d) : |
| ListAligned T L l M ↔ ListAligned T L l N := by |
| have hp (i : ι) (hi : i ∈ l) (j : Fin 4) : |
| tuplePoint M (T i) j = tuplePoint N (T i) j := by |
| apply tuplePoint_eq_of_agree |
| intro d hd |
| exact h d (Finset.mem_biUnion.mpr ⟨i, List.mem_toFinset.mpr hi, hd⟩) |
| constructor <;> intro ha i hi j |
| · rw [← hp i hi j] |
| exact ha i hi j |
| · rw [hp i hi j] |
| exact ha i hi j |
|
|
| theorem fixed_alignment_probability_eq (T : FourTuple F) |
| (hT : Function.Injective T.generator) (g : Direction F) |
| (hg : ∀ i, T.generator i ≠ g) (c : F) |
| (D : Finset (Direction F)) (hD : (exposedTupleIndices T D).card ≤ 1) |
| (a : MergedPairs F) : |
| ((PMF.uniformOfFintype (FixedArray (fun d => d ∈ D) a)).toOuterMeasure |
| {M | ∀ j, OnLine (tuplePoint M.1 T j) (g,c)}).toReal = |
| (Fintype.card F : ℝ)⁻¹ ^ 4 := by |
| have h := global_conditional_alignment_probability_eq T hT g hg c D hD a |
| rw [uniform_fixed_filter, PMF.toOuterMeasure_map_apply] at h |
| convert h using 1 |
| exact FiniteUniformFibers.probability_fintype_congr _ _ rfl |
|
|
| theorem alignment_inter_probability_eq (T : FourTuple F) |
| (hT : Function.Injective T.generator) (g : Direction F) |
| (hg : ∀ i, T.generator i ≠ g) (c : F) |
| (D : Finset (Direction F)) (hD : (exposedTupleIndices T D).card ≤ 1) |
| (E : MergedPairs F → Prop) |
| (hE : ∀ M N, (∀ d ∈ D, M d = N d) → (E M ↔ E N)) : |
| ((PMF.uniformOfFintype (MergedPairs F)).toOuterMeasure |
| {M | E M ∧ ∀ j, OnLine (tuplePoint M T j) (g,c)}).toReal = |
| (Fintype.card F : ℝ)⁻¹ ^ 4 * |
| ((PMF.uniformOfFintype (MergedPairs F)).toOuterMeasure {M | E M}).toReal := by |
| apply FiniteUniformFibers.fixed_probability_inter D E _ _ hE |
| intro a |
| convert fixed_alignment_probability_eq T hT g hg c D hD a using 1 |
| exact FiniteUniformFibers.probability_fintype_congr _ _ rfl |
|
|
| theorem list_alignment_probability {ι : Type*} [DecidableEq ι] |
| (T : ι → FourTuple F) (L : ι → Line F) (l : List ι) |
| (hT : ∀ i ∈ l, Function.Injective (T i).generator) |
| (hg : ∀ i ∈ l, ∀ j, (T i).generator j ≠ (L i).1) |
| (horder : SmallReuseOrder (fun i => generatorSet (T i)) l) : |
| ((PMF.uniformOfFintype (MergedPairs F)).toOuterMeasure |
| {M | ListAligned T L l M}).toReal = |
| ((Fintype.card F : ℝ)⁻¹ ^ 4) ^ l.length := by |
| induction l with |
| | nil => |
| simp [ListAligned] |
| | cons i l ih => |
| have hTi := hT i (by simp) |
| have hgi := hg i (by simp) |
| have htailT : ∀ j ∈ l, Function.Injective (T j).generator := |
| fun j hj => hT j (by simp [hj]) |
| have htailg : ∀ j ∈ l, ∀ k, (T j).generator k ≠ (L j).1 := |
| fun j hj => hg j (by simp [hj]) |
| have hD : (exposedTupleIndices (T i) |
| (l.toFinset.biUnion (fun j => generatorSet (T j)))).card ≤ 1 := by |
| rw [card_exposedTupleIndices (T i) hTi] |
| exact horder.2 |
| have hevent : {M | ListAligned T L (i :: l) M} = |
| {M | ListAligned T L l M ∧ ∀ j, OnLine (tuplePoint M (T i) j) (L i)} := by |
| ext M |
| simp only [ListAligned, List.mem_cons, forall_eq_or_imp, Set.mem_ofPred_eq] |
| exact and_comm |
| rw [hevent] |
| have hstep := alignment_inter_probability_eq (T i) hTi (L i).1 hgi (L i).2 |
| (l.toFinset.biUnion (fun j => generatorSet (T j))) hD (ListAligned T L l) |
| (listAligned_agree T L l) |
| simpa only [Prod.eta, ih htailT htailg horder.1, List.length_cons, |
| pow_succ, mul_comm] using hstep |
|
|
| end |
| end Balanced.AlignedListProbability |
|
|
| end OAI |
|
|
