| import Mathlib |
| import OAI.Probability.BinarySweep.Trajectories.Trajectory |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| section |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.GridSplit |
| variable {m n h : ℕ} (bits : Fin (m+n) → ℕ) |
|
|
| abbrev leftBits : Fin m → ℕ := fun i => bits (i.castAdd n) |
| abbrev rightBits : Fin n → ℕ := fun i => bits (i.natAdd m) |
| def leftSlot (x : GridSlot bits) : GridSlot (leftBits bits) := fun i => x (i.castAdd n) |
| def rightSlot (x : GridSlot bits) : GridSlot (rightBits bits) := fun i => x (i.natAdd m) |
| def joinSlot (x : GridSlot (leftBits bits)) (y : GridSlot (rightBits bits)) : GridSlot bits := |
| Fin.addCases x y |
|
|
| def slotEquiv : GridSlot bits ≃ GridSlot (leftBits bits) × GridSlot (rightBits bits) where |
| toFun x := (leftSlot bits x,rightSlot bits x) |
| invFun xy := joinSlot bits xy.1 xy.2 |
| left_inv x := by |
| funext i |
| induction i using Fin.addCases with |
| | left i => simp [joinSlot,leftSlot] |
| | right i => simp [joinSlot,rightSlot] |
| right_inv xy := by |
| apply Prod.ext <;> funext i |
| · simp [leftSlot,joinSlot] |
| · simp [rightSlot,joinSlot] |
|
|
| lemma size_split : gridSize bits=gridSize (leftBits bits)*gridSize (rightBits bits) := by |
| rw [← card_gridSlot, Fintype.card_congr (slotEquiv bits),Fintype.card_prod, |
| card_gridSlot,card_gridSlot] |
|
|
| def leftTime (t : Fin (m+1)) : Fin (m+n+1) := ⟨t.val,by omega⟩ |
| def rightTime (t : Fin (n+1)) : Fin (m+n+1) := ⟨m+t.val,by omega⟩ |
|
|
| variable (H : PathFamily bits h) |
|
|
| lemma rightSlot_leftTime (t : Fin (m+1)) (k : Fin h) : |
| rightSlot bits (H.position (leftTime t) k)=rightSlot bits (H.position 0 k) := by |
| funext i |
| unfold rightSlot |
| have he := trajectory_coordinates (fun t => H.position t k) |
| (fun j i hi => H.changes_only_stage j k i hi) (leftTime t) (i.natAdd m) |
| rw [ite_eq_right (show ¬(i.natAdd m).val < (leftTime t).val from by |
| change ¬m+i.val<t.val; omega)] at he |
| exact he |
|
|
| lemma leftSlot_rightTime (t : Fin (n+1)) (k : Fin h) : |
| leftSlot bits (H.position (rightTime t) k)=leftSlot bits (H.position (rightTime (m:=m) 0) k) := by |
| funext i |
| unfold leftSlot |
| have he (u : Fin (n+1)) : H.position (rightTime u) k (i.castAdd n) = |
| H.position (Fin.last (m+n)) k (i.castAdd n) := by |
| have he := trajectory_coordinates (fun t => H.position t k) |
| (fun j i hi => H.changes_only_stage j k i hi) (rightTime u) (i.castAdd n) |
| rw [ite_eq_left (show (i.castAdd n).val < (rightTime u).val from by |
| change i.val < m + u.val; omega)] at he |
| exact he |
| exact (he t).trans (he 0).symm |
|
|
| abbrev RowLabels (y : GridSlot (rightBits bits)) := |
| {k : Fin h |
| abbrev ColumnLabels (x : GridSlot (leftBits bits)) := |
| {k : Fin h |
|
|
| noncomputable instance rowLabelsFintype (y : GridSlot (rightBits bits)) : |
| Fintype (RowLabels bits H y) := Fintype.ofFinite _ |
| noncomputable instance columnLabelsFintype (x : GridSlot (leftBits bits)) : |
| Fintype (ColumnLabels bits H x) := Fintype.ofFinite _ |
|
|
| def rowFamily (y : GridSlot (rightBits bits)) : |
| PathFamily (leftBits bits) (Fintype.card (RowLabels bits H y)) where |
| position t k := leftSlot bits (H.position (leftTime t) ((Fintype.equivFin (RowLabels bits H y)).symm k).val) |
| disjoint t a b he := by |
| apply (Fintype.equivFin (RowLabels bits H y)).symm.injective |
| apply Subtype.ext |
| apply H.disjoint (leftTime t) |
| apply (slotEquiv bits).injective |
| apply Prod.ext |
| · exact he |
| · change rightSlot bits (H.position (leftTime t) _) = rightSlot bits (H.position (leftTime t) _) |
| simp only [rightSlot_leftTime] |
| exact ((Fintype.equivFin (RowLabels bits H y)).symm a).property.trans |
| ((Fintype.equivFin (RowLabels bits H y)).symm b).property.symm |
| changes_only_stage j k i hi := by |
| change H.position (leftTime j.succ) _ (i.castAdd n) = H.position (leftTime j.castSucc) _ (i.castAdd n) |
| exact H.changes_only_stage (j.castAdd n) _ (i.castAdd n) |
| (fun he => hi (Fin.ext (congrArg (fun q : Fin (m+n) => q.val) he))) |
|
|
| def columnFamily (x : GridSlot (leftBits bits)) : |
| PathFamily (rightBits bits) (Fintype.card (ColumnLabels bits H x)) where |
| position t k := rightSlot bits (H.position (rightTime t) ((Fintype.equivFin (ColumnLabels bits H x)).symm k).val) |
| disjoint t a b he := by |
| apply (Fintype.equivFin (ColumnLabels bits H x)).symm.injective |
| apply Subtype.ext |
| apply H.disjoint (rightTime t) |
| apply (slotEquiv bits).injective |
| apply Prod.ext |
| · change leftSlot bits (H.position (rightTime t) _) = leftSlot bits (H.position (rightTime t) _) |
| simp only [leftSlot_rightTime] |
| exact ((Fintype.equivFin (ColumnLabels bits H x)).symm a).property.trans |
| ((Fintype.equivFin (ColumnLabels bits H x)).symm b).property.symm |
| · exact he |
| changes_only_stage j k i hi := by |
| change H.position (rightTime j.succ) _ (i.natAdd m) = H.position (rightTime j.castSucc) _ (i.natAdd m) |
| exact H.changes_only_stage (j.natAdd m) _ (i.natAdd m) |
| (fun he => hi (Fin.ext (by have hh := congrArg (fun q : Fin (m+n) => q.val) he; simpa using hh))) |
|
|
| end BinaryCoordinateSweeps.GridSplit |
|
|
| end |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.GridSplit |
| variable {m n : ℕ} (bits : Fin (m+n) → ℕ) |
|
|
| def fillSlot {b : ℕ} (a : Fin b → ℕ) (j : Fin b) (u : GridOutside a j) : GridSlot a := |
| (Equiv.piSplitAt j (fun i => Slot (a i))).symm (fun _ => false,u) |
|
|
| lemma fillSlot_other {b : ℕ} (a : Fin b → ℕ) (j : Fin b) (u : GridOutside a j) |
| (i : Fin b) (hi : i≠j) : fillSlot a j u i=u ⟨i,hi⟩ := by |
| simp [fillSlot,Equiv.piSplitAt,hi] |
|
|
| def leftOutsideEquiv (j : Fin m) : |
| GridOutside bits (j.castAdd n) ≃ GridSlot (rightBits bits) × GridOutside (leftBits bits) j where |
| toFun u := (fun i => u ⟨i.natAdd m,by intro h; have hh := congrArg (fun q:Fin (m+n) => q.val) h; simp only [Fin.val_natAdd,Fin.val_castAdd] at hh; omega⟩, |
| fun i => u ⟨i.val.castAdd n,fun h => i.property (Fin.ext (congrArg (fun q:Fin (m+n) => q.val) h))⟩) |
| invFun yu i := joinSlot bits (fillSlot (leftBits bits) j yu.2) yu.1 i.val |
| left_inv u := by |
| funext i |
| rcases i with ⟨i,hi⟩ |
| revert hi |
| induction i using Fin.addCases with |
| | left i => |
| intro hi |
| have hij : i≠j := fun h => hi (congrArg (Fin.castAdd n) h) |
| simp only [joinSlot,Fin.addCases_left,fillSlot_other _ _ _ _ hij] |
| | right i => intro hi; simp only [joinSlot,Fin.addCases_right] |
| right_inv yu := by |
| apply Prod.ext |
| · funext i |
| simp only [joinSlot,Fin.addCases_right] |
| · funext i |
| simp only [joinSlot,Fin.addCases_left,fillSlot_other _ _ _ _ i.property] |
|
|
| def rightOutsideEquiv (j : Fin n) : |
| GridOutside bits (j.natAdd m) ≃ GridSlot (leftBits bits) × GridOutside (rightBits bits) j where |
| toFun u := (fun i => u ⟨i.castAdd n,by intro h; have hh := congrArg (fun q:Fin (m+n) => q.val) h; simp only [Fin.val_natAdd,Fin.val_castAdd] at hh; omega⟩, |
| fun i => u ⟨i.val.natAdd m,fun h => i.property (Fin.ext (by have hh := congrArg (fun q:Fin (m+n) => q.val) h; simpa using hh))⟩) |
| invFun xu i := joinSlot bits xu.1 (fillSlot (rightBits bits) j xu.2) i.val |
| left_inv u := by |
| funext i |
| rcases i with ⟨i,hi⟩ |
| revert hi |
| induction i using Fin.addCases with |
| | left i => intro hi; simp only [joinSlot,Fin.addCases_left] |
| | right i => |
| intro hi |
| have hij : i≠j := fun h => hi (congrArg (Fin.natAdd m) h) |
| simp only [joinSlot,Fin.addCases_right,fillSlot_other _ _ _ _ hij] |
| right_inv xu := by |
| apply Prod.ext |
| · funext i |
| simp only [joinSlot,Fin.addCases_left] |
| · funext i |
| simp only [joinSlot,Fin.addCases_right,fillSlot_other _ _ _ _ i.property] |
|
|
| def rowChoices (g : GridChoices bits) (y : GridSlot (rightBits bits)) : GridChoices (leftBits bits) := |
| fun j u => g (j.castAdd n) ((leftOutsideEquiv bits j).symm (y,u)) |
| def columnChoices (g : GridChoices bits) (x : GridSlot (leftBits bits)) : GridChoices (rightBits bits) := |
| fun j u => g (j.natAdd m) ((rightOutsideEquiv bits j).symm (x,u)) |
|
|
| def joinChoices (L : GridSlot (rightBits bits) → GridChoices (leftBits bits)) |
| (R : GridSlot (leftBits bits) → GridChoices (rightBits bits)) : GridChoices bits := |
| Fin.addCases (fun j u => L ((leftOutsideEquiv bits j) u).1 j ((leftOutsideEquiv bits j) u).2) |
| (fun j u => R ((rightOutsideEquiv bits j) u).1 j ((rightOutsideEquiv bits j) u).2) |
|
|
| def choicesEquiv : GridChoices bits ≃ |
| (GridSlot (rightBits bits) → GridChoices (leftBits bits)) × |
| (GridSlot (leftBits bits) → GridChoices (rightBits bits)) where |
| toFun g := (rowChoices bits g,columnChoices bits g) |
| invFun LR := joinChoices bits LR.1 LR.2 |
| left_inv g := by |
| funext j u |
| induction j using Fin.addCases with |
| | left j => simp [joinChoices,rowChoices] |
| | right j => simp [joinChoices,columnChoices] |
| right_inv LR := by |
| apply Prod.ext |
| · funext y j u |
| simp [rowChoices,joinChoices] |
| · funext x j u |
| simp [columnChoices,joinChoices] |
|
|
| end BinaryCoordinateSweeps.GridSplit |
|
|
| end |
|
|
| end OAI |
|
|
