openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Separation /ComplexInitialTargetExecution.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Tensor.ComplexInitialTargetKernel | |
| import OAI.LinearAlgebra.MatrixMultiplication.Polynomial.ComplexPolynomialKernelExecution | |
| namespace OAI | |
| /-! Finite type counts, hierarchy separation and tensor execution bounds. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.Foundation.InitialTargetExecution | |
| open Tensor LocalMaps PolynomialLocalConstruction PolynomialKernelExecution | |
| variable {X Y Z RawLabel Label : Type*} | |
| def scalarOutput : Label × Unit → Label × (Fin 1 × Fin 1) := | |
| fun output => (output.1, (0, 0)) | |
| def initial (PX : X → Prop) (PY : Y → Prop) (PZ : Z → Prop) | |
| (lx : X → RawLabel) (ly : Y → RawLabel) (lz : Z → RawLabel) | |
| (embed : Label → RawLabel) (injective : Function.Injective embed) | |
| (support : X → Y → Z → Prop) | |
| (compatible : ∀ x y z, support x y z → PX x → PY y → PZ z → | |
| lx x = ly y ∧ lx x = lz z) : | |
| Execution X Y Z Label Unit Unit Unit Unit Unit Unit support where | |
| auxiliary := InitialTargetKernel.auxiliary | |
| rankBound := 1 | |
| auxiliary_rank := InitialTargetKernel.auxiliary_rank | |
| order := 0 | |
| leftDegree := 0 | |
| middleDegree := 0 | |
| rightDegree := 0 | |
| leftMap := fun x output input => | |
| InitialTargetKernel.sideMap PX lx embed x (scalarOutput output) input | |
| middleMap := fun y output input => | |
| InitialTargetKernel.sideMap PY ly embed y (scalarOutput output) input | |
| rightMap := fun z output input => | |
| InitialTargetKernel.sideMap PZ lz embed z (scalarOutput output) input | |
| left_degree := fun x output input => | |
| InitialTargetKernel.sideMap_degree PX lx embed x (scalarOutput output) input | |
| middle_degree := fun y output input => | |
| InitialTargetKernel.sideMap_degree PY ly embed y (scalarOutput output) input | |
| right_degree := fun z output input => | |
| InitialTargetKernel.sideMap_degree PZ lz embed z (scalarOutput output) input | |
| value := fun x y z => InitialTargetKernel.previousLeading PX PY PZ lx ly lz embed | |
| (x.1, scalarOutput x.2) (y.1, scalarOutput y.2) (z.1, scalarOutput z.2) | |
| vanishes := fun x y z _ j hj => | |
| InitialTargetKernel.kernel_low PX PY PZ lx ly lz embed | |
| (x.1, scalarOutput x.2) (y.1, scalarOutput y.2) (z.1, scalarOutput z.2) j hj | |
| leading := fun x y z hs => | |
| InitialTargetKernel.kernel_leading PX PY PZ lx ly lz embed injective support compatible | |
| (x.1, scalarOutput x.2) (y.1, scalarOutput y.2) (z.1, scalarOutput z.2) hs | |
| synchronized := by | |
| intro x y z _ hn | |
| have h := (InitialTargetKernel.previousLeading_ne_zero_iff PX PY PZ lx ly lz embed | |
| (x.1, scalarOutput x.2) (y.1, scalarOutput y.2) (z.1, scalarOutput z.2)).mp hn | |
| exact ⟨h.1, h.2.1⟩ | |
| variable (PX : X → Prop) (PY : Y → Prop) (PZ : Z → Prop) | |
| variable (lx : X → RawLabel) (ly : Y → RawLabel) (lz : Z → RawLabel) | |
| variable (embed : Label → RawLabel) (injective : Function.Injective embed) | |
| variable (support : X → Y → Z → Prop) | |
| variable (compatible : ∀ x y z, support x y z → PX x → PY y → PZ z → | |
| lx x = ly y ∧ lx x = lz z) | |
| @[simp] theorem initial_rankBound : | |
| (initial PX PY PZ lx ly lz embed injective support compatible).rankBound = 1 := rfl | |
| @[simp] theorem initial_order : | |
| (initial PX PY PZ lx ly lz embed injective support compatible).order = 0 := rfl | |
| theorem initial_value_ne_zero_iff (x : X × (Label × Unit)) | |
| (y : Y × (Label × Unit)) (z : Z × (Label × Unit)) : | |
| (initial PX PY PZ lx ly lz embed injective support compatible).value x y z ≠ 0 ↔ | |
| x.2.1 = y.2.1 ∧ x.2.1 = z.2.1 ∧ | |
| InitialTargetKernel.Eligible PX PY PZ lx ly lz embed x.2.1 x.1 y.1 z.1 := | |
| InitialTargetKernel.previousLeading_ne_zero_iff PX PY PZ lx ly lz embed | |
| (x.1, scalarOutput x.2) (y.1, scalarOutput y.2) (z.1, scalarOutput z.2) | |
| theorem initial_eligible (x : X × (Label × Unit)) | |
| (y : Y × (Label × Unit)) (z : Z × (Label × Unit)) | |
| (hn : (initial PX PY PZ lx ly lz embed injective support compatible).value x y z ≠ 0) : | |
| InitialTargetKernel.Eligible PX PY PZ lx ly lz embed x.2.1 x.1 y.1 z.1 := | |
| ((initial_value_ne_zero_iff PX PY PZ lx ly lz embed injective support compatible | |
| x y z).mp hn).2.2 | |
| theorem initial_substitution (original : Tensor ℂ X Y Z) : | |
| let E := initial PX PY PZ lx ly lz embed injective support compatible | |
| fiberTransform E.leftMap E.middleMap E.rightMap | |
| (fun x y z => Polynomial.C (Tensor.product original E.auxiliary x y z)) = | |
| originalScale (fun x y z => Polynomial.C (original x y z)) | |
| (kernel E.auxiliary E.leftMap E.middleMap E.rightMap) := by | |
| let E := initial PX PY PZ lx ly lz embed injective support compatible | |
| have h := fiberTransform_originalScale E.leftMap E.middleMap E.rightMap | |
| (fun x y z => Polynomial.C (original x y z)) | |
| (fun x y z => Polynomial.C (E.auxiliary x.2 y.2 z.2)) | |
| have hinput : | |
| (fun x y z => Polynomial.C (Tensor.product original E.auxiliary x y z)) = | |
| originalScale (fun x y z => Polynomial.C (original x y z)) | |
| (fun x y z => Polynomial.C (E.auxiliary x.2 y.2 z.2)) := by | |
| funext x y z | |
| simp only [Tensor.product, originalScale, map_mul] | |
| rw [← hinput] at h | |
| simpa only [E, kernel] using h | |
| end MatrixMultiplication.Foundation.InitialTargetExecution | |
| end | |
| end OAI | |