| import Mathlib |
| import OAI.Probability.BinarySweep.GridBounds.GridSplitWeights |
| |
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.GridSplit |
| |
| variable {X Y : Type*} |
| def rowPerm (f : Y → Equiv.Perm X) : Equiv.Perm (X×Y) where |
| toFun xy := (f xy.2 xy.1,xy.2) |
| invFun xy := ((f xy.2).symm xy.1,xy.2) |
| left_inv xy := by simp |
| right_inv xy := by simp |
|
|
| def rowPermHom : (Y → Equiv.Perm X) →* Equiv.Perm (X×Y) where |
| toFun := rowPerm |
| map_one' := by ext xy <;> rfl |
| map_mul' f g := by ext xy < |
|
|
| def columnPerm (f : X → Equiv.Perm Y) : Equiv.Perm (X×Y) where |
| toFun xy := (xy.1,f xy.1 xy.2) |
| invFun xy := (xy.1,(f xy.1).symm xy.2) |
| left_inv xy := by simp |
| right_inv xy := by simp |
|
|
| def columnPermHom : (X → Equiv.Perm Y) →* Equiv.Perm (X×Y) where |
| toFun := columnPerm |
| map_one' := by ext xy <;> rfl |
| map_mul' f g := by ext xy < |
|
|
| variable {m n : ℕ} (bits : Fin (m+n) → ℕ) |
|
|
| lemma gridLayer_left (g : GridChoices bits) (j : Fin m) (x : GridSlot bits) : |
| (slotEquiv bits) (gridLayer bits g (j.castAdd n) x) = |
| (gridLayer (leftBits bits) (rowChoices bits g (rightSlot bits x)) j (leftSlot bits x), |
| rightSlot bits x) := by |
| apply Prod.ext |
| · simp only |
| funext i |
| change gridLayer bits g (j.castAdd n) x (i.castAdd n)=_ |
| by_cases hi : i=j |
| · subst i |
| rw [gridLayer_at,gridLayer_at,rowChoices_at] |
| rfl |
| · rw [gridLayer_other bits g _ _ (fun he => hi (Fin.castAdd_injective m n he)), |
| gridLayer_other _ _ _ _ hi] |
| rfl |
| · funext i |
| exact gridLayer_other bits g _ _ (by |
| intro he |
| have hh := congrArg (fun i : Fin (m+n) => i.val) he |
| simp only [Fin.val_natAdd,Fin.val_castAdd] at hh |
|
|
| lemma gridLayer_right (g : GridChoices bits) (j : Fin n) (x : GridSlot bits) : |
| (slotEquiv bits) (gridLayer bits g (j.natAdd m) x) = |
| (leftSlot bits x, |
| gridLayer (rightBits bits) (columnChoices bits g (leftSlot bits x)) j (rightSlot bits x)) := by |
| apply Prod.ext |
| · funext i |
| exact gridLayer_other bits g _ _ (by |
| intro he |
| have hh := congrArg (fun i : Fin (m+n) => i.val) he |
| simp only [Fin.val_natAdd,Fin.val_castAdd] at hh |
| · simp only |
| funext i |
| change gridLayer bits g (j.natAdd m) x (i.natAdd m)=_ |
| by_cases hi : i=j |
| · subst i |
| rw [gridLayer_at,gridLayer_at,columnChoices_at] |
| rfl |
| · rw [gridLayer_other bits g _ _ (fun he => hi (Fin.natAdd_injective n m he)), |
| gridLayer_other _ _ _ _ hi] |
| rfl |
|
|
| lemma layer_left_congr (g : GridChoices bits) (j : Fin m) : |
| (slotEquiv bits).permCongr (gridLayer bits g (j.castAdd n)) = |
| rowPerm (fun y => gridLayer (leftBits bits) (rowChoices bits g y) j) := by |
| apply Equiv.ext |
| intro xy |
| have he := gridLayer_left bits g j ((slotEquiv bits).symm xy) |
| change (slotEquiv bits) (gridLayer bits g (j.castAdd n) ((slotEquiv bits).symm xy))= _ |
| rw [he] |
| have ht := (slotEquiv bits).apply_symm_apply xy |
| rw [show leftSlot bits ((slotEquiv bits).symm xy)=xy.1 from congrArg Prod.fst ht, |
| show rightSlot bits ((slotEquiv bits).symm xy)=xy.2 from congrArg Prod.snd ht] |
| rfl |
|
|
| lemma layer_right_congr (g : GridChoices bits) (j : Fin n) : |
| (slotEquiv bits).permCongr (gridLayer bits g (j.natAdd m)) = |
| columnPerm (fun x => gridLayer (rightBits bits) (columnChoices bits g x) j) := by |
| apply Equiv.ext |
| intro xy |
| have he := gridLayer_right bits g j ((slotEquiv bits).symm xy) |
| change (slotEquiv bits) (gridLayer bits g (j.natAdd m) ((slotEquiv bits).symm xy))= _ |
| rw [he] |
| have ht := (slotEquiv bits).apply_symm_apply xy |
| rw [show leftSlot bits ((slotEquiv bits).symm xy)=xy.1 from congrArg Prod.fst ht, |
| show rightSlot bits ((slotEquiv bits).symm xy)=xy.2 from congrArg Prod.snd ht] |
| rfl |
|
|
| lemma prod_rows (L : List (Y → Equiv.Perm X)) : |
| (L.map rowPerm).prod=rowPerm (fun y => (L.map (fun f => f y)).prod) := by |
| induction L with |
| | nil => rfl |
| | cons f L ih => |
| simp only [List.map_cons,List.prod_cons,ih] |
| apply Equiv.ext |
| intro xy |
| rfl |
| lemma prod_columns (L : List (X → Equiv.Perm Y)) : |
| (L.map columnPerm).prod=columnPerm (fun x => (L.map (fun f => f x)).prod) := by |
| induction L with |
| | nil => rfl |
| | cons f L ih => |
| simp only [List.map_cons,List.prod_cons,ih] |
| apply Equiv.ext |
| intro xy |
| rfl |
|
|
| theorem gridSweep_split (g : GridChoices bits) : |
| (slotEquiv bits).permCongr (gridSweep bits g) = |
| columnPerm (fun x => gridSweep (rightBits bits) (columnChoices bits g x)) * |
| rowPerm (fun y => gridSweep (leftBits bits) (rowChoices bits g y)) := by |
| change (slotEquiv bits).permCongrHom (gridSweep bits g)=_ |
| unfold gridSweep |
| rw [List.ofFn_add,List.reverse_append,List.prod_append] |
| rw [map_mul] |
| congr 1 |
| · rw [map_list_prod (slotEquiv bits).permCongrHom,List.map_reverse,List.map_ofFn] |
| change (List.ofFn (fun j : Fin n => (slotEquiv bits).permCongr (gridLayer bits g (j.natAdd m)))).reverse.prod=_ |
| simp_rw [layer_right_congr] |
| simpa only [List.map_reverse,List.map_ofFn,Function.comp_def] using |
| (prod_columns (List.ofFn (fun j : Fin n => fun x => |
| gridLayer (rightBits bits) (columnChoices bits g x) j)).reverse) |
| · rw [map_list_prod (slotEquiv bits).permCongrHom,List.map_reverse,List.map_ofFn] |
| change (List.ofFn (fun j : Fin m => (slotEquiv bits).permCongr (gridLayer bits g (j.castAdd n)))).reverse.prod=_ |
| simp_rw [layer_left_congr] |
| simpa only [List.map_reverse,List.map_ofFn,Function.comp_def] using |
| (prod_rows (List.ofFn (fun j : Fin m => fun y => |
| gridLayer (leftBits bits) (rowChoices bits g y) j)).reverse) |
| |
| end BinaryCoordinateSweeps.GridSplit |
| |
| end |
|
|
| end OAI |
|
|
