| import OAI.Combinatorics.BalancedRyser.Local.AlignmentStepLaw |
| |
| namespace OAI |
|
|
| namespace Balanced.AlignedListProbability |
| |
| open Local PartialAlignment |
| noncomputable section |
| open scoped Classical |
|
|
| variable {F : Type*} [Field F] [Fintype F] [DecidableEq F] |
|
|
| def installCurrentTupleOffsets (T : FourTuple F) |
| (o : Fin 4 → Bool → F) (a : MergedPairs F) : MergedPairs F := |
| Function.extend T.generator o a |
|
|
| omit [Field F] [Fintype F] [DecidableEq F] in |
| @[simp] theorem installCurrentTupleOffsets_generator |
| (T : FourTuple F) (hT : Function.Injective T.generator) |
| (o : Fin 4 → Bool → F) (a : MergedPairs F) (j : Fin 4) : |
| installCurrentTupleOffsets T o a (T.generator j) = o j := |
| hT.extend_apply o a j |
| |
| omit [Field F] [Fintype F] in |
|
|
| theorem installCurrentTupleOffsets_outside (T : FourTuple F) |
| (o : Fin 4 → Bool → F) (a : MergedPairs F) (d : Direction F) |
| (hd : d ∉ generatorSet T) : |
| installCurrentTupleOffsets T o a d = a d := by |
| apply Function.extend_apply' |
| intro h |
| obtain ⟨j, rfl⟩ := h |
| exact hd (Finset.mem_image.mpr ⟨j, Finset.mem_univ _, rfl⟩) |
|
|
| omit [Field F] [Fintype F] in |
|
|
| theorem installCurrentTupleOffsets_agree_old |
| (T : FourTuple F) (hT : Function.Injective T.generator) |
| (D : Finset (Direction F)) (o : Fin 4 → Bool → F) (a : MergedPairs F) |
| (ho : ∀ j ∈ exposedTupleIndices T D, o j = a (T.generator j)) : |
| ∀ d ∈ D, installCurrentTupleOffsets T o a d = a d := by |
| intro d hd |
| by_cases hg : d ∈ generatorSet T |
| · obtain ⟨j, _, rfl⟩ := Finset.mem_image.mp hg |
| rw [installCurrentTupleOffsets_generator T hT] |
| exact ho j (by simpa only [exposedTupleIndices, Finset.mem_filter, |
| Finset.mem_univ, true_and] using hd) |
| · exact installCurrentTupleOffsets_outside T o a d hg |
|
|
| def generateCurrentState |
| (T : FourTuple F) (hT : Function.Injective T.generator) |
| (g : Direction F) (hg : ∀ j, T.generator j ≠ g) (c : F) |
| (D : Finset (Direction F)) (hD : (exposedTupleIndices T D).card ≤ 1) |
| (a : MergedPairs F) (x : CurrentFreeCoordinates T D) : MergedPairs F := |
| installCurrentTupleOffsets T (generateCurrentTupleOffsets T hT g hg c D hD a x) a |
|
|
| theorem generateCurrentState_agree_old |
| (T : FourTuple F) (hT : Function.Injective T.generator) |
| (g : Direction F) (hg : ∀ j, T.generator j ≠ g) (c : F) |
| (D : Finset (Direction F)) (hD : (exposedTupleIndices T D).card ≤ 1) |
| (a : MergedPairs F) (x : CurrentFreeCoordinates T D) : |
| ∀ d ∈ D, generateCurrentState T hT g hg c D hD a x d = a d := by |
| apply installCurrentTupleOffsets_agree_old T hT D |
| exact ((alignedFreeCoordinatesEquiv T.generator |
| (TupleAlignment.adjacent_ne_of_injective T hT) T.side g hg c |
| (exposedTupleIndices T D) hD (fun j => a (T.generator j))).symm x).1.2 |
|
|
| theorem generateCurrentState_aligned |
| (T : FourTuple F) (hT : Function.Injective T.generator) |
| (g : Direction F) (hg : ∀ j, T.generator j ≠ g) (c : F) |
| (D : Finset (Direction F)) (hD : (exposedTupleIndices T D).card ≤ 1) |
| (a : MergedPairs F) (x : CurrentFreeCoordinates T D) : |
| ∀ j, OnLine (tuplePoint (generateCurrentState T hT g hg c D hD a x) T j) (g,c) := by |
| intro j |
| have h := ((alignedFreeCoordinatesEquiv T.generator |
| (TupleAlignment.adjacent_ne_of_injective T hT) T.side g hg c |
| (exposedTupleIndices T D) hD (fun k => a (T.generator k))).symm x).2 j |
| simpa only [generateCurrentState, tuplePoint, constituent, |
| installCurrentTupleOffsets_generator T hT, |
| TupleAlignment.tuplePositionEquiv_apply, generateCurrentTupleOffsets] using h |
|
|
| omit [Field F] [Fintype F] in |
|
|
| theorem installCurrentTupleOffsets_reconstruct |
| (T : FourTuple F) (hT : Function.Injective T.generator) |
| (D : Finset (Direction F)) (a M : MergedPairs F) |
| (hfix : ∀ d ∈ D, M d = a d) : |
| ∀ d ∈ D ∪ generatorSet T, |
| M d = installCurrentTupleOffsets T (fun j => M (T.generator j)) a d := by |
| intro d hd |
| by_cases hg : d ∈ generatorSet T |
| · obtain ⟨j, _, rfl⟩ := Finset.mem_image.mp hg |
| rw [installCurrentTupleOffsets_generator T hT] |
| · rw [installCurrentTupleOffsets_outside T _ a d hg] |
| exact hfix d ((Finset.mem_union.mp hd).resolve_right hg) |
|
|
| omit [Field F] in |
|
|
| theorem conditionedOffsetProbability_congr_on (A E G : MergedPairs F → Prop) |
| (h : ∀ M, A M → (E M ↔ G M)) : |
| conditionedOffsetProbability A E = conditionedOffsetProbability A G := by |
| have he : (fun M => A M ∧ E M) = (fun M => A M ∧ G M) := by |
| funext M |
| apply propext |
| by_cases ha : A M |
| · simp only [ha, true_and, h M ha] |
| · simp only [ha, false_and] |
| unfold conditionedOffsetProbability |
| rw [he] |
|
|
| theorem current_state_generated_probability |
| (T : FourTuple F) (hT : Function.Injective T.generator) |
| (g : Direction F) (hg : ∀ j, T.generator j ≠ g) (c : F) |
| (D : Finset (Direction F)) (hD : (exposedTupleIndices T D).card ≤ 1) |
| (a : MergedPairs F) (E : MergedPairs F → Prop) |
| (hE : ∀ M N, (∀ d ∈ D ∪ generatorSet T, M d = N d) → (E M ↔ E N)) : |
| conditionedOffsetProbability |
| (fun M => (∀ d ∈ D, M d = a d) ∧ ∀ j, OnLine (tuplePoint M T j) (g,c)) E = |
| ((PMF.uniformOfFintype (CurrentFreeCoordinates T D)).toOuterMeasure |
| {x | E (generateCurrentState T hT g hg c D hD a x)}).toReal := by |
| let G : (Fin 4 → Bool → F) → Prop := fun o => E (installCurrentTupleOffsets T o a) |
| have hc := conditionedOffsetProbability_congr_on |
| (fun M => (∀ d ∈ D, M d = a d) ∧ ∀ j, OnLine (tuplePoint M T j) (g,c)) |
| E (fun M => G (fun j => M (T.generator j))) |
| (fun M hm => hE M _ (installCurrentTupleOffsets_reconstruct T hT D a M hm.1)) |
| exact hc.trans (current_tuple_generated_probability T hT g hg c D hD a G) |
| |
| theorem generateCurrentState_freePoint |
| (T : FourTuple F) (hT : Function.Injective T.generator) |
| (g : Direction F) (hg : ∀ j, T.generator j ≠ g) (c : F) |
| (D : Finset (Direction F)) (hD : (exposedTupleIndices T D).card ≤ 1) |
| (a : MergedPairs F) (x : CurrentFreeCoordinates T D) |
| (j : {j : Fin 4 // j ∈ freePositions (exposedTupleIndices T D)}) : |
| tuplePoint (generateCurrentState T hT g hg c D hD a x) T j.1 = |
| ((TupleAlignment.linePointEquiv g c).symm (x j)).1 := by |
| have h := alignedPartial_generated_free T.generator |
| (TupleAlignment.adjacent_ne_of_injective T hT) T.side g hg c |
| (exposedTupleIndices T D) hD (fun k => a (T.generator k)) x j |
| simpa only [generateCurrentState, tuplePoint, constituent, |
| installCurrentTupleOffsets_generator T hT, |
| TupleAlignment.tuplePositionEquiv_apply, generateCurrentTupleOffsets] using h |
| |
| theorem generateCurrentState_old_left |
| (T : FourTuple F) (hT : Function.Injective T.generator) |
| (g : Direction F) (hg : ∀ j, T.generator j ≠ g) (c : F) |
| (D : Finset (Direction F)) (hD : (exposedTupleIndices T D).card ≤ 1) |
| (a : MergedPairs F) (x : CurrentFreeCoordinates T D) |
| (j : Fin 4) (hj : T.generator j ∈ D) : |
| tuplePoint (generateCurrentState T hT g hg c D hD a x) T j = |
| (TupleAlignment.lineEvalEquiv (T.generator j) g (hg j)).symm |
| (a (T.generator j) (T.side j), c) := by |
| have h := alignedPartial_position_old_left T.generator |
| (TupleAlignment.adjacent_ne_of_injective T hT) T.side g hg c |
| (exposedTupleIndices T D) (fun k => a (T.generator k)) |
| ((alignedFreeCoordinatesEquiv T.generator |
| (TupleAlignment.adjacent_ne_of_injective T hT) T.side g hg c |
| (exposedTupleIndices T D) hD (fun k => a (T.generator k))).symm x) |
| j (by simpa only [exposedTupleIndices, Finset.mem_filter, |
| Finset.mem_univ, true_and] using hj) |
| simpa only [generateCurrentState, tuplePoint, constituent, |
| installCurrentTupleOffsets_generator T hT, |
| TupleAlignment.tuplePositionEquiv_apply, generateCurrentTupleOffsets] using h |
| |
| theorem generateCurrentState_old_right |
| (T : FourTuple F) (hT : Function.Injective T.generator) |
| (g : Direction F) (hg : ∀ j, T.generator j ≠ g) (c : F) |
| (D : Finset (Direction F)) (hD : (exposedTupleIndices T D).card ≤ 1) |
| (a : MergedPairs F) (x : CurrentFreeCoordinates T D) |
| (j : Fin 4) (hj : T.generator (j+1) ∈ D) : |
| tuplePoint (generateCurrentState T hT g hg c D hD a x) T j = |
| (TupleAlignment.lineEvalEquiv (T.generator (j+1)) g (hg (j+1))).symm |
| (a (T.generator (j+1)) (!(T.side (j+1))), c) := by |
| have h := alignedPartial_position_old_right T.generator |
| (TupleAlignment.adjacent_ne_of_injective T hT) T.side g hg c |
| (exposedTupleIndices T D) (fun k => a (T.generator k)) |
| ((alignedFreeCoordinatesEquiv T.generator |
| (TupleAlignment.adjacent_ne_of_injective T hT) T.side g hg c |
| (exposedTupleIndices T D) hD (fun k => a (T.generator k))).symm x) |
| j (by simpa only [exposedTupleIndices, Finset.mem_filter, |
| Finset.mem_univ, true_and] using hj) |
| simpa only [generateCurrentState, tuplePoint, constituent, |
| installCurrentTupleOffsets_generator T hT, |
| TupleAlignment.tuplePositionEquiv_apply, generateCurrentTupleOffsets] using h |
| |
| theorem generateCurrentState_listAligned {ι : Type*} [DecidableEq ι] |
| (T : ι → FourTuple F) (L : ι → Line F) (pre : List ι) (i : ι) |
| (hi : Function.Injective (T i).generator) |
| (hg : ∀ j, (T i).generator j ≠ (L i).1) |
| (hD : (exposedTupleIndices (T i) |
| (pre.toFinset.biUnion (fun k => generatorSet (T k)))).card ≤ 1) |
| (a : MergedPairs F) (ha : ListAligned T L pre a) |
| (x : CurrentFreeCoordinates (T i) |
| (pre.toFinset.biUnion (fun k => generatorSet (T k)))) : |
| ListAligned T L (i :: pre) |
| (generateCurrentState (T i) hi (L i).1 hg (L i).2 |
| (pre.toFinset.biUnion (fun k => generatorSet (T k))) hD a x) := by |
| intro k hk |
| rcases List.mem_cons.mp hk with hki | hk |
| · subst k |
| exact generateCurrentState_aligned (T i) hi (L i).1 hg (L i).2 _ hD a x |
| · have hp := (listAligned_agree T L pre _ a |
| (generateCurrentState_agree_old (T i) hi (L i).1 hg (L i).2 _ hD a x)).mpr ha |
| exact hp k hk |
|
|
| theorem full_aligned_state_generated_probability {ι : Type*} [DecidableEq ι] |
| (T : ι → FourTuple F) (L : ι → Line F) (post pre : List ι) (i : ι) |
| (hT : ∀ k ∈ post ++ i :: pre, Function.Injective (T k).generator) |
| (hg : ∀ k ∈ post ++ i :: pre, ∀ j, (T k).generator j ≠ (L k).1) |
| (horder : SmallReuseOrder (fun k => generatorSet (T k)) (post ++ i :: pre)) |
| (a : MergedPairs F) (ha : ListAligned T L pre a) |
| (E : MergedPairs F → Prop) |
| (hE : ∀ M N, (∀ d ∈ (i :: pre).toFinset.biUnion (fun k => generatorSet (T k)), |
| M d = N d) → (E M ↔ E N)) : |
| let D := pre.toFinset.biUnion (fun k => generatorSet (T k)) |
| conditionedOffsetProbability |
| (fun M => ListAligned T L (post ++ i :: pre) M ∧ ∀ d ∈ D, M d = a d) E = |
| ((PMF.uniformOfFintype (CurrentFreeCoordinates (T i) D)).toOuterMeasure |
| {x | E (generateCurrentState (T i) (hT i (by simp)) (L i).1 |
| (hg i (by simp)) (L i).2 D |
| (step_exposed_count T post pre i (hT i (by simp)) horder) a x)}).toReal := by |
| let D := pre.toFinset.biUnion (fun k => generatorSet (T k)) |
| have hdep (M N : MergedPairs F) |
| (h : ∀ d ∈ D ∪ generatorSet (T i), M d = N d) : E M ↔ E N := by |
| apply hE M N |
| intro d hd |
| apply h d |
| simpa only [D, List.toFinset_cons, Finset.biUnion_insert, Finset.union_comm] using hd |
| have hs := conditioned_alignment_step T L post pre i hT hg horder a ha E hE |
| have hc := current_state_generated_probability (T i) (hT i (by simp)) (L i).1 |
| (hg i (by simp)) (L i).2 D |
| (step_exposed_count T post pre i (hT i (by simp)) horder) a E hdep |
| exact hs.trans (by simpa only [and_comm, Prod.eta] using hc) |
| |
| end |
| end Balanced.AlignedListProbability |
| |
| end OAI |
| |
