| import Mathlib |
| import OAI.Probability.BinarySweep.TensorBounds.SignedBlock |
| import OAI.Probability.BinarySweep.GridBounds.GridSplitSweep |
| import OAI.Probability.BinarySweep.FiniteLaws.OneCard |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| section |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.BinarySplit |
| variable {m n : ℕ} |
|
|
| def fillSlot {d : ℕ} (j : Fin d) (u : {i : Fin d |
| (Equiv.piSplitAt j (fun _ => Bool)).symm (false,u) |
|
|
| lemma fillSlot_other {d : ℕ} (j : Fin d) (u : {i : Fin d |
| (i : Fin d) (hi : i≠j) : fillSlot j u i=u ⟨i,hi⟩ := by |
| simp [fillSlot,Equiv.piSplitAt,hi] |
|
|
| def leftOutsideEquiv (j : Fin m) : |
| ({i : Fin (m+n) |
| 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 := Fin.addCases (fillSlot 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 [Fin.addCases_left,fillSlot_other _ _ _ hij] |
| | right i => intro hi; simp only [Fin.addCases_right] |
| right_inv yu := by |
| apply Prod.ext |
| · funext i |
| simp only [Fin.addCases_right] |
| · funext i |
| simp only [Fin.addCases_left,fillSlot_other _ _ _ i.property] |
|
|
| def rightOutsideEquiv (j : Fin n) : |
| ({i : Fin (m+n) |
| 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 := Fin.addCases xu.1 (fillSlot 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 [Fin.addCases_left] |
| | right i => |
| intro hi |
| have hij : i≠j := fun h => hi (congrArg (Fin.natAdd m) h) |
| simp only [Fin.addCases_right,fillSlot_other _ _ _ hij] |
| right_inv xu := by |
| apply Prod.ext |
| · funext i |
| simp only [Fin.addCases_left] |
| · funext i |
| simp only [Fin.addCases_right,fillSlot_other _ _ _ i.property] |
|
|
| def rowChoices (g : SweepCoins (m+n)) (y : Slot n) : SweepCoins m := |
| fun j u => g (j.castAdd n) ((leftOutsideEquiv j).symm (y,u)) |
| def columnChoices (g : SweepCoins (m+n)) (x : Slot m) : SweepCoins n := |
| fun j u => g (j.natAdd m) ((rightOutsideEquiv j).symm (x,u)) |
|
|
| def joinChoices (L : Slot n → SweepCoins m) |
| (R : Slot m → SweepCoins n) : SweepCoins (m+n) := |
| Fin.addCases (fun j u => L ((leftOutsideEquiv j) u).1 j ((leftOutsideEquiv j) u).2) |
| (fun j u => R ((rightOutsideEquiv j) u).1 j ((rightOutsideEquiv j) u).2) |
|
|
| def choicesEquiv : SweepCoins (m+n) ≃ |
| (Slot n → SweepCoins m) × |
| (Slot m → SweepCoins n) where |
| toFun g := (rowChoices g,columnChoices g) |
| invFun LR := joinChoices 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.BinarySplit |
|
|
| end |
|
|
| open scoped BigOperators Classical |
|
|
| namespace BinaryCoordinateSweeps.BinarySplit |
| open GridSplit |
|
|
| variable {m n : ℕ} |
|
|
| lemma rowChoices_at (c : SweepCoins (m+n)) (x : Slot (m+n)) (j : Fin m) : |
| rowChoices c (Signed.splitWord x).2 j (fun i => (Signed.splitWord x).1 i)= |
| c (j.castAdd n) (fun i => x i) := by |
| unfold rowChoices |
| congr 1 |
| apply (leftOutsideEquiv j).injective |
| rw [Equiv.apply_symm_apply] |
| rfl |
|
|
| lemma columnChoices_at (c : SweepCoins (m+n)) (x : Slot (m+n)) (j : Fin n) : |
| columnChoices c (Signed.splitWord x).1 j (fun i => (Signed.splitWord x).2 i)= |
| c (j.natAdd m) (fun i => x i) := by |
| unfold columnChoices |
| congr 1 |
| apply (rightOutsideEquiv j).injective |
| rw [Equiv.apply_symm_apply] |
| rfl |
|
|
| lemma layer_left (c : SweepCoins (m+n)) (j : Fin m) (x : Slot (m+n)) : |
| Signed.splitWord (coordinateLayer (m+n) (j.castAdd n) (c (j.castAdd n)) x)= |
| (coordinateLayer m j (rowChoices c (Signed.splitWord x).2 j) (Signed.splitWord x).1, |
| (Signed.splitWord x).2) := by |
| apply Prod.ext |
| · dsimp only |
| funext i |
| change coordinateLayer _ _ _ x (i.castAdd n)=_ |
| by_cases hi : i=j |
| · subst i |
| rw [coordinateLayer_apply_at,coordinateLayer_apply_at,rowChoices_at] |
| rfl |
| · rw [coordinateLayer_apply_other _ _ _ (fun he => hi (Fin.ext |
| (congrArg (fun i : Fin (m+n) => i.val) he))),coordinateLayer_apply_other _ _ _ hi] |
| rfl |
| · dsimp only |
| funext i |
| exact coordinateLayer_apply_other (m+n) (j.castAdd n) (i.natAdd m) (by |
| intro he |
| have hh := congrArg (fun i : Fin (m+n) => i.val) he |
| simp only [Fin.val_natAdd,Fin.val_castAdd] at hh; omega) _ x |
|
|
| lemma layer_right (c : SweepCoins (m+n)) (j : Fin n) (x : Slot (m+n)) : |
| Signed.splitWord (coordinateLayer (m+n) (j.natAdd m) (c (j.natAdd m)) x)= |
| ((Signed.splitWord x).1, |
| coordinateLayer n j (columnChoices c (Signed.splitWord x).1 j) (Signed.splitWord x).2) := by |
| apply Prod.ext |
| · dsimp only |
| funext i |
| exact coordinateLayer_apply_other (m+n) (j.natAdd m) (i.castAdd n) (by |
| intro he |
| have hh := congrArg (fun i : Fin (m+n) => i.val) he |
| simp only [Fin.val_natAdd,Fin.val_castAdd] at hh; omega) _ x |
| · dsimp only |
| funext i |
| change coordinateLayer _ _ _ x (i.natAdd m)=_ |
| by_cases hi : i=j |
| · subst i |
| rw [coordinateLayer_apply_at,coordinateLayer_apply_at,columnChoices_at] |
| rfl |
| · rw [coordinateLayer_apply_other _ _ _ (fun he => hi (Fin.ext (by |
| have hh := congrArg (fun i : Fin (m+n) => i.val) he; simpa using hh))), |
| coordinateLayer_apply_other _ _ _ hi] |
| rfl |
|
|
| lemma layer_left_congr (c : SweepCoins (m+n)) (j : Fin m) : |
| Signed.splitWord.permCongr (coordinateLayer (m+n) (j.castAdd n) (c (j.castAdd n)))= |
| rowPerm (fun y => coordinateLayer m j (rowChoices c y j)) := by |
| apply Equiv.ext |
| intro xy |
| have he := layer_left c j (Signed.splitWord.symm xy) |
| change Signed.splitWord (coordinateLayer _ _ _ (Signed.splitWord.symm xy))=_ |
| rw [he,Equiv.apply_symm_apply] |
| rfl |
|
|
| lemma layer_right_congr (c : SweepCoins (m+n)) (j : Fin n) : |
| Signed.splitWord.permCongr (coordinateLayer (m+n) (j.natAdd m) (c (j.natAdd m)))= |
| columnPerm (fun x => coordinateLayer n j (columnChoices c x j)) := by |
| apply Equiv.ext |
| intro xy |
| have he := layer_right c j (Signed.splitWord.symm xy) |
| change Signed.splitWord (coordinateLayer _ _ _ (Signed.splitWord.symm xy))=_ |
| rw [he,Equiv.apply_symm_apply] |
| rfl |
|
|
| theorem binarySweep_split (c : SweepCoins (m+n)) : |
| Signed.splitWord.permCongr (binarySweep (m+n) c)= |
| columnPerm (fun x => binarySweep n (columnChoices c x)) * |
| rowPerm (fun y => binarySweep m (rowChoices c y)) := by |
| change Signed.splitWord.permCongrHom (binarySweep (m+n) c)=_ |
| unfold binarySweep |
| rw [List.ofFn_add,List.reverse_append,List.prod_append,map_mul] |
| congr 1 |
| · rw [map_list_prod Signed.splitWord.permCongrHom,List.map_reverse,List.map_ofFn] |
| change (List.ofFn (fun j : Fin n => Signed.splitWord.permCongr |
| (coordinateLayer _ (j.natAdd m) (c (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 => |
| coordinateLayer n j (columnChoices c x j))).reverse) |
| · rw [map_list_prod Signed.splitWord.permCongrHom,List.map_reverse,List.map_ofFn] |
| change (List.ofFn (fun j : Fin m => Signed.splitWord.permCongr |
| (coordinateLayer _ (j.castAdd n) (c (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 => |
| coordinateLayer m j (rowChoices c y j))).reverse) |
|
|
| end BinaryCoordinateSweeps.BinarySplit |
|
|
| end |
|
|
| end OAI |
|
|
