openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Polynomial /ComplexPolynomialExecutionSymmetry.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Polynomial.ComplexPolynomialKernelExecution | |
| namespace OAI | |
| /-! Polynomial tensor restrictions and exact coefficient extraction. -/ | |
| noncomputable section | |
| open scoped BigOperators | |
| namespace MatrixMultiplication.Foundation | |
| namespace Tensor | |
| section Swap | |
| variable {K X Y Z X' Y' Z' : Type*} [CommSemiring K] | |
| def swapXY (T : Tensor K X Y Z) : Tensor K Y X Z := fun y x z => T x y z | |
| theorem RankAtMost.swapXY {T : Tensor K X Y Z} {r : ℕ} (h : RankAtMost T r) : | |
| RankAtMost (swapXY T) r := by | |
| rcases h with ⟨a, b, c, rfl⟩ | |
| refine ⟨b, a, c, ?_⟩ | |
| funext y x z | |
| simp only [rankOne] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| ring | |
| theorem swapXY_restrict [Fintype X] [Fintype Y] [Fintype Z] | |
| (A : X' → X → K) (B : Y' → Y → K) (C : Z' → Z → K) | |
| (T : Tensor K X Y Z) : | |
| swapXY (restrict A B C T) = restrict B A C (swapXY T) := by | |
| funext y' x' z' | |
| simp only [swapXY, restrict] | |
| calc | |
| (∑ x, ∑ y, ∑ z, A x' x * B y' y * C z' z * T x y z) = | |
| ∑ y, ∑ x, ∑ z, A x' x * B y' y * C z' z * T x y z := Finset.sum_comm | |
| _ = _ := by | |
| apply Finset.sum_congr rfl | |
| intro y hy | |
| apply Finset.sum_congr rfl | |
| intro x hx | |
| apply Finset.sum_congr rfl | |
| intro z hz | |
| ring | |
| end Swap | |
| end Tensor | |
| namespace PolynomialLocalConstruction | |
| open Tensor LocalMaps | |
| variable {X Y Z OX OY OZ AX AY AZ : Type*} | |
| variable [Fintype AX] [Fintype AY] [Fintype AZ] | |
| theorem kernel_cyclic (auxiliary : Tensor ℂ AX AY AZ) | |
| (MX : X → OX → AX → Polynomial ℂ) (MY : Y → OY → AY → Polynomial ℂ) | |
| (MZ : Z → OZ → AZ → Polynomial ℂ) | |
| (x : X × OX) (y : Y × OY) (z : Z × OZ) : | |
| kernel (Tensor.cyclic auxiliary) MY MZ MX y z x = kernel auxiliary MX MY MZ x y z := by | |
| have h := congrFun (congrFun (congrFun | |
| (Tensor.cyclic_restrict (MX x.1) (MY y.1) (MZ z.1) | |
| (fun a b c => Polynomial.C (auxiliary a b c))) y.2) z.2) x.2 | |
| simpa only [kernel, fiberTransform, Tensor.cyclic, Tensor.restrict] using h.symm | |
| theorem kernel_swapXY (auxiliary : Tensor ℂ AX AY AZ) | |
| (MX : X → OX → AX → Polynomial ℂ) (MY : Y → OY → AY → Polynomial ℂ) | |
| (MZ : Z → OZ → AZ → Polynomial ℂ) | |
| (x : X × OX) (y : Y × OY) (z : Z × OZ) : | |
| kernel (Tensor.swapXY auxiliary) MY MX MZ y x z = kernel auxiliary MX MY MZ x y z := by | |
| have h := congrFun (congrFun (congrFun | |
| (Tensor.swapXY_restrict (MX x.1) (MY y.1) (MZ z.1) | |
| (fun a b c => Polynomial.C (auxiliary a b c))) y.2) x.2) z.2 | |
| simpa only [kernel, fiberTransform, Tensor.swapXY, Tensor.restrict] using h.symm | |
| end PolynomialLocalConstruction | |
| namespace PolynomialKernelExecution.Execution | |
| open Tensor PolynomialLocalConstruction | |
| variable {X Y Z Prefix PX PY PZ AX AY AZ : Type*} | |
| variable [Fintype AX] [Fintype AY] [Fintype AZ] | |
| variable {support : X → Y → Z → Prop} | |
| variable (E : Execution X Y Z Prefix PX PY PZ AX AY AZ support) | |
| def cyclic : Execution Y Z X Prefix PY PZ PX AY AZ AX | |
| (fun y z x => support x y z) where | |
| auxiliary := Tensor.cyclic E.auxiliary | |
| rankBound := E.rankBound | |
| auxiliary_rank := E.auxiliary_rank.cyclic | |
| order := E.order | |
| leftDegree := E.middleDegree | |
| middleDegree := E.rightDegree | |
| rightDegree := E.leftDegree | |
| leftMap := E.middleMap | |
| middleMap := E.rightMap | |
| rightMap := E.leftMap | |
| left_degree := E.middle_degree | |
| middle_degree := E.right_degree | |
| right_degree := E.left_degree | |
| value := Tensor.cyclic E.value | |
| vanishes := by | |
| intro y z x hs j hj | |
| rw [kernel_cyclic] | |
| exact E.vanishes x y z hs j hj | |
| leading := by | |
| intro y z x hs | |
| rw [kernel_cyclic] | |
| exact E.leading x y z hs | |
| synchronized := by | |
| intro y z x hs hn | |
| have h := E.synchronized x y z hs hn | |
| exact ⟨h.1.symm.trans h.2, h.1.symm⟩ | |
| @[simp] theorem cyclic_auxiliary : E.cyclic.auxiliary = Tensor.cyclic E.auxiliary := rfl | |
| @[simp] theorem cyclic_rankBound : E.cyclic.rankBound = E.rankBound := rfl | |
| @[simp] theorem cyclic_order : E.cyclic.order = E.order := rfl | |
| @[simp] theorem cyclic_leftDegree : E.cyclic.leftDegree = E.middleDegree := rfl | |
| @[simp] theorem cyclic_middleDegree : E.cyclic.middleDegree = E.rightDegree := rfl | |
| @[simp] theorem cyclic_rightDegree : E.cyclic.rightDegree = E.leftDegree := rfl | |
| @[simp] theorem cyclic_leftMap : E.cyclic.leftMap = E.middleMap := rfl | |
| @[simp] theorem cyclic_middleMap : E.cyclic.middleMap = E.rightMap := rfl | |
| @[simp] theorem cyclic_rightMap : E.cyclic.rightMap = E.leftMap := rfl | |
| @[simp] theorem cyclic_value | |
| (y : Y × (Prefix × PY)) (z : Z × (Prefix × PZ)) (x : X × (Prefix × PX)) : | |
| E.cyclic.value y z x = E.value x y z := rfl | |
| theorem cyclic_kernel | |
| (y : Y × (Prefix × PY)) (z : Z × (Prefix × PZ)) (x : X × (Prefix × PX)) : | |
| kernel E.cyclic.auxiliary E.cyclic.leftMap E.cyclic.middleMap E.cyclic.rightMap y z x = | |
| kernel E.auxiliary E.leftMap E.middleMap E.rightMap x y z := | |
| kernel_cyclic E.auxiliary E.leftMap E.middleMap E.rightMap x y z | |
| def swapXY : Execution Y X Z Prefix PY PX PZ AY AX AZ | |
| (fun y x z => support x y z) where | |
| auxiliary := Tensor.swapXY E.auxiliary | |
| rankBound := E.rankBound | |
| auxiliary_rank := E.auxiliary_rank.swapXY | |
| order := E.order | |
| leftDegree := E.middleDegree | |
| middleDegree := E.leftDegree | |
| rightDegree := E.rightDegree | |
| leftMap := E.middleMap | |
| middleMap := E.leftMap | |
| rightMap := E.rightMap | |
| left_degree := E.middle_degree | |
| middle_degree := E.left_degree | |
| right_degree := E.right_degree | |
| value := Tensor.swapXY E.value | |
| vanishes := by | |
| intro y x z hs j hj | |
| rw [kernel_swapXY] | |
| exact E.vanishes x y z hs j hj | |
| leading := by | |
| intro y x z hs | |
| rw [kernel_swapXY] | |
| exact E.leading x y z hs | |
| synchronized := by | |
| intro y x z hs hn | |
| have h := E.synchronized x y z hs hn | |
| exact ⟨h.1.symm, h.1.symm.trans h.2⟩ | |
| @[simp] theorem swapXY_auxiliary : E.swapXY.auxiliary = Tensor.swapXY E.auxiliary := rfl | |
| @[simp] theorem swapXY_rankBound : E.swapXY.rankBound = E.rankBound := rfl | |
| @[simp] theorem swapXY_order : E.swapXY.order = E.order := rfl | |
| @[simp] theorem swapXY_leftDegree : E.swapXY.leftDegree = E.middleDegree := rfl | |
| @[simp] theorem swapXY_middleDegree : E.swapXY.middleDegree = E.leftDegree := rfl | |
| @[simp] theorem swapXY_rightDegree : E.swapXY.rightDegree = E.rightDegree := rfl | |
| @[simp] theorem swapXY_leftMap : E.swapXY.leftMap = E.middleMap := rfl | |
| @[simp] theorem swapXY_middleMap : E.swapXY.middleMap = E.leftMap := rfl | |
| @[simp] theorem swapXY_rightMap : E.swapXY.rightMap = E.rightMap := rfl | |
| @[simp] theorem swapXY_value | |
| (y : Y × (Prefix × PY)) (x : X × (Prefix × PX)) (z : Z × (Prefix × PZ)) : | |
| E.swapXY.value y x z = E.value x y z := rfl | |
| theorem swapXY_kernel | |
| (y : Y × (Prefix × PY)) (x : X × (Prefix × PX)) (z : Z × (Prefix × PZ)) : | |
| kernel E.swapXY.auxiliary E.swapXY.leftMap E.swapXY.middleMap E.swapXY.rightMap y x z = | |
| kernel E.auxiliary E.leftMap E.middleMap E.rightMap x y z := | |
| kernel_swapXY E.auxiliary E.leftMap E.middleMap E.rightMap x y z | |
| section OriginalCoordinates | |
| variable {X' Y' Z' : Type*} | |
| variable (eX : X' ≃ X) (eY : Y' ≃ Y) (eZ : Z' ≃ Z) | |
| def reindexOriginal : Execution X' Y' Z' Prefix PX PY PZ AX AY AZ | |
| (fun x y z => support (eX x) (eY y) (eZ z)) where | |
| auxiliary := E.auxiliary | |
| rankBound := E.rankBound | |
| auxiliary_rank := E.auxiliary_rank | |
| order := E.order | |
| leftDegree := E.leftDegree | |
| middleDegree := E.middleDegree | |
| rightDegree := E.rightDegree | |
| leftMap := fun x => E.leftMap (eX x) | |
| middleMap := fun y => E.middleMap (eY y) | |
| rightMap := fun z => E.rightMap (eZ z) | |
| left_degree := fun x => E.left_degree (eX x) | |
| middle_degree := fun y => E.middle_degree (eY y) | |
| right_degree := fun z => E.right_degree (eZ z) | |
| value := fun x y z => E.value (eX x.1, x.2) (eY y.1, y.2) (eZ z.1, z.2) | |
| vanishes := fun x y z hs j hj => | |
| E.vanishes (eX x.1, x.2) (eY y.1, y.2) (eZ z.1, z.2) hs j hj | |
| leading := fun x y z hs => | |
| E.leading (eX x.1, x.2) (eY y.1, y.2) (eZ z.1, z.2) hs | |
| synchronized := fun x y z hs hn => | |
| E.synchronized (eX x.1, x.2) (eY y.1, y.2) (eZ z.1, z.2) hs hn | |
| @[simp] theorem reindexOriginal_auxiliary : | |
| (E.reindexOriginal eX eY eZ).auxiliary = E.auxiliary := rfl | |
| @[simp] theorem reindexOriginal_rankBound : | |
| (E.reindexOriginal eX eY eZ).rankBound = E.rankBound := rfl | |
| @[simp] theorem reindexOriginal_order : | |
| (E.reindexOriginal eX eY eZ).order = E.order := rfl | |
| @[simp] theorem reindexOriginal_leftDegree : | |
| (E.reindexOriginal eX eY eZ).leftDegree = E.leftDegree := rfl | |
| @[simp] theorem reindexOriginal_middleDegree : | |
| (E.reindexOriginal eX eY eZ).middleDegree = E.middleDegree := rfl | |
| @[simp] theorem reindexOriginal_rightDegree : | |
| (E.reindexOriginal eX eY eZ).rightDegree = E.rightDegree := rfl | |
| @[simp] theorem reindexOriginal_leftMap : | |
| (E.reindexOriginal eX eY eZ).leftMap = fun x => E.leftMap (eX x) := rfl | |
| @[simp] theorem reindexOriginal_middleMap : | |
| (E.reindexOriginal eX eY eZ).middleMap = fun y => E.middleMap (eY y) := rfl | |
| @[simp] theorem reindexOriginal_rightMap : | |
| (E.reindexOriginal eX eY eZ).rightMap = fun z => E.rightMap (eZ z) := rfl | |
| @[simp] theorem reindexOriginal_value | |
| (x : X' × (Prefix × PX)) (y : Y' × (Prefix × PY)) (z : Z' × (Prefix × PZ)) : | |
| (E.reindexOriginal eX eY eZ).value x y z = | |
| E.value (eX x.1, x.2) (eY y.1, y.2) (eZ z.1, z.2) := rfl | |
| theorem reindexOriginal_kernel | |
| (x : X' × (Prefix × PX)) (y : Y' × (Prefix × PY)) (z : Z' × (Prefix × PZ)) : | |
| kernel (E.reindexOriginal eX eY eZ).auxiliary | |
| (E.reindexOriginal eX eY eZ).leftMap (E.reindexOriginal eX eY eZ).middleMap | |
| (E.reindexOriginal eX eY eZ).rightMap x y z = | |
| kernel E.auxiliary E.leftMap E.middleMap E.rightMap | |
| (eX x.1, x.2) (eY y.1, y.2) (eZ z.1, z.2) := rfl | |
| end OriginalCoordinates | |
| section Support | |
| variable (support' : X → Y → Z → Prop) | |
| variable (h : ∀ x y z, support' x y z → support x y z) | |
| def onSupport : Execution X Y Z Prefix PX PY PZ AX AY AZ support' where | |
| auxiliary := E.auxiliary | |
| rankBound := E.rankBound | |
| auxiliary_rank := E.auxiliary_rank | |
| order := E.order | |
| leftDegree := E.leftDegree | |
| middleDegree := E.middleDegree | |
| rightDegree := E.rightDegree | |
| leftMap := E.leftMap | |
| middleMap := E.middleMap | |
| rightMap := E.rightMap | |
| left_degree := E.left_degree | |
| middle_degree := E.middle_degree | |
| right_degree := E.right_degree | |
| value := E.value | |
| vanishes := fun x y z hs j hj => E.vanishes x y z (h x.1 y.1 z.1 hs) j hj | |
| leading := fun x y z hs => E.leading x y z (h x.1 y.1 z.1 hs) | |
| synchronized := fun x y z hs hn => E.synchronized x y z (h x.1 y.1 z.1 hs) hn | |
| @[simp] theorem onSupport_auxiliary : (E.onSupport support' h).auxiliary = E.auxiliary := rfl | |
| @[simp] theorem onSupport_rankBound : (E.onSupport support' h).rankBound = E.rankBound := rfl | |
| @[simp] theorem onSupport_order : (E.onSupport support' h).order = E.order := rfl | |
| @[simp] theorem onSupport_leftDegree : (E.onSupport support' h).leftDegree = E.leftDegree := rfl | |
| @[simp] theorem onSupport_middleDegree : (E.onSupport support' h).middleDegree = E.middleDegree := rfl | |
| @[simp] theorem onSupport_rightDegree : (E.onSupport support' h).rightDegree = E.rightDegree := rfl | |
| @[simp] theorem onSupport_leftMap : (E.onSupport support' h).leftMap = E.leftMap := rfl | |
| @[simp] theorem onSupport_middleMap : (E.onSupport support' h).middleMap = E.middleMap := rfl | |
| @[simp] theorem onSupport_rightMap : (E.onSupport support' h).rightMap = E.rightMap := rfl | |
| @[simp] theorem onSupport_value : (E.onSupport support' h).value = E.value := rfl | |
| theorem onSupport_kernel | |
| (x : X × (Prefix × PX)) (y : Y × (Prefix × PY)) (z : Z × (Prefix × PZ)) : | |
| kernel (E.onSupport support' h).auxiliary (E.onSupport support' h).leftMap | |
| (E.onSupport support' h).middleMap (E.onSupport support' h).rightMap x y z = | |
| kernel E.auxiliary E.leftMap E.middleMap E.rightMap x y z := rfl | |
| end Support | |
| end PolynomialKernelExecution.Execution | |
| end MatrixMultiplication.Foundation | |
| end | |
| end OAI | |