openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Recovery /EquivOrbitTransport.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Recovery.OrbitCounting | |
| import OAI.LinearAlgebra.MatrixMultiplication.Tensor.ComplexTensorRestrictionComposition | |
| namespace OAI | |
| /-! Finite orbit symmetries, masks and exact recovery operations. -/ | |
| open MatrixMultiplication.Foundation | |
| namespace MatrixMultiplication.EquivOrbitTransport | |
| variable {G X Y : Type*} [Group G] [MulAction G Y] | |
| @[instance_reducible] def action (e : X ≃ Y) : MulAction G X where | |
| smul g x := e.symm (g • e x) | |
| one_smul x := by | |
| change e.symm ((1 : G) • e x) = x | |
| simp | |
| mul_smul g h x := by | |
| change e.symm ((g * h) • e x) = e.symm (g • e (e.symm (h • e x))) | |
| simp [mul_smul] | |
| @[simp] theorem equiv_smul (e : X ≃ Y) (g : G) (x : X) : | |
| letI : MulAction G X := action e | |
| e (g • x) = g • e x := by | |
| exact e.apply_symm_apply _ | |
| section Finite | |
| variable [Fintype G] [DecidableEq X] [DecidableEq Y] | |
| theorem orbitSet_map (e : X ≃ Y) (x : X) : | |
| letI : MulAction G X := action e | |
| (OrbitCounting.orbitSet (G := G) x).map e.toEmbedding = | |
| OrbitCounting.orbitSet (G := G) (e x) := by | |
| let : MulAction G X := action e | |
| change (Finset.univ.image fun g : G => e.symm (g • e x)).map e.toEmbedding = _ | |
| simp only [Finset.map_eq_image, Finset.image_image, Function.comp_def, | |
| Equiv.toEmbedding_apply, Equiv.apply_symm_apply, OrbitCounting.orbitSet] | |
| theorem orbitSet_card (e : X ≃ Y) (x : X) : | |
| letI : MulAction G X := action e | |
| (OrbitCounting.orbitSet (G := G) x).card = | |
| (OrbitCounting.orbitSet (G := G) (e x)).card := by | |
| let : MulAction G X := action e | |
| simpa only [Finset.card_map] using congrArg Finset.card (orbitSet_map e x) | |
| theorem rejected_card (e : X ≃ Y) (bad : X → Prop) [DecidablePred bad] (x : X) : | |
| letI : MulAction G X := action e | |
| ((OrbitCounting.orbitSet (G := G) x).filter bad).card = | |
| ((OrbitCounting.orbitSet (G := G) (e x)).filter (bad ∘ e.symm)).card := by | |
| let : MulAction G X := action e | |
| calc | |
| ((OrbitCounting.orbitSet (G := G) x).filter bad).card = | |
| (((OrbitCounting.orbitSet (G := G) x).filter bad).map e.toEmbedding).card := | |
| (Finset.card_map _).symm | |
| _ = _ := by rw [Finset.map_filter, orbitSet_map] | |
| theorem rejected_fraction (e : X ≃ Y) (bad : X → Prop) [DecidablePred bad] (x : X) : | |
| letI : MulAction G X := action e | |
| (((OrbitCounting.orbitSet (G := G) x).filter bad).card : ℝ) / | |
| (OrbitCounting.orbitSet (G := G) x).card = | |
| (((OrbitCounting.orbitSet (G := G) (e x)).filter (bad ∘ e.symm)).card : ℝ) / | |
| (OrbitCounting.orbitSet (G := G) (e x)).card := by | |
| let : MulAction G X := action e | |
| rw [rejected_card e bad x, orbitSet_card e x] | |
| end Finite | |
| theorem coefficients_preserved | |
| {K RX RY RZ CX CY CZ : Type*} [CommSemiring K] | |
| [MulAction G CX] [MulAction G CY] [MulAction G CZ] | |
| (ex : RX ≃ CX) (ey : RY ≃ CY) (ez : RZ ≃ CZ) | |
| (raw : Tensor K RX RY RZ) (canonical : Tensor K CX CY CZ) | |
| (hcoords : ∀ x y z, raw x y z = canonical (ex x) (ey y) (ez z)) | |
| (hcanonical : ∀ (g : G) x y z, | |
| canonical (g • x) (g • y) (g • z) = canonical x y z) : | |
| letI : MulAction G RX := action ex | |
| letI : MulAction G RY := action ey | |
| letI : MulAction G RZ := action ez | |
| ∀ (g : G) x y z, raw (g • x) (g • y) (g • z) = raw x y z := by | |
| let : MulAction G RX := action ex | |
| let : MulAction G RY := action ey | |
| let : MulAction G RZ := action ez | |
| intro g x y z | |
| rw [hcoords, hcoords] | |
| change canonical (ex (ex.symm (g • ex x))) (ey (ey.symm (g • ey y))) | |
| (ez (ez.symm (g • ez z))) = _ | |
| simpa only [Equiv.apply_symm_apply] using hcanonical g (ex x) (ey y) (ez z) | |
| end MatrixMultiplication.EquivOrbitTransport | |
| end OAI | |