File size: 4,159 Bytes
cdec422 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 | import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Character.Dot
import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Character.Symmetrization
namespace OAI
/-!
# The six permuted tensor characters
Precomposing a character with a leg permutation gives another character. The
six resulting values multiply to the symmetrized product, and each singleton
leg exponent occurs twice among their first-leg exponents.
-/
noncomputable section
open MatrixMultiplication.Foundation
open scoped BigOperators
namespace MatrixMultiplication.AuxiliarySeparation.Character
variable (χ : Character)
/-- The reflected character exchanges the second and third tensor legs. -/
def swap23Character : Character where
value T := χ.value (fun x z y => T x y z)
nonneg T := χ.nonneg (fun x z y => T x y z)
map_zero := χ.map_zero
map_one := χ.map_one
map_directSum T := by
have heq : (fun x z y => Tensor.directSum T x y z) =
Tensor.directSum (fun i x z y => T i x y z) := by
funext x z y
simp only [Tensor.directSum, and_comm]
change χ.value (fun x z y => Tensor.directSum T x y z) = _
rw [heq, χ.map_directSum]
map_product T S := χ.map_product (fun x z y => T x y z) (fun x z y => S x y z)
monotone T A B C := by
have heq : (fun x z y => Tensor.restrict A B C T x y z) =
Tensor.restrict A C B (fun x z y => T x y z) := by
funext x z y
simp only [Tensor.restrict]
apply Finset.sum_congr rfl
intro i hi
rw [Finset.sum_comm]
apply Finset.sum_congr rfl
intro k hk
apply Finset.sum_congr rfl
intro j hj
ring
change χ.value (fun x z y => Tensor.restrict A B C T x y z) ≤ _
rw [heq]
exact χ.monotone (fun x z y => T x y z) A C B
@[simp] theorem swap23Character_value {X Y Z : Type}
[Fintype X] [Fintype Y] [Fintype Z] (T : Tensor ℂ X Y Z) :
χ.swap23Character.value T = χ.value (fun x z y => T x y z) := rfl
/-- The three cyclic orders followed by their reflected orders. -/
def permutedCharacter (i : Fin 6) : Character :=
![χ, χ.cyclicCharacter, χ.cyclicCharacter.cyclicCharacter,
χ.swap23Character, χ.swap23Character.cyclicCharacter,
χ.swap23Character.cyclicCharacter.cyclicCharacter] i
/-- The six permuted characters give exactly the sixfold product on any legs. -/
theorem prod_permutedCharacter_value {X Y Z : Type}
[Fintype X] [Fintype Y] [Fintype Z] (T : Tensor ℂ X Y Z) :
(∏ i : Fin 6, (χ.permutedCharacter i).value T) = χ.sixfoldProduct T := by
simp only [Fin.prod_univ_succ, Fin.prod_univ_zero, mul_one]
change χ.value T * (χ.value (fun y z x => T x y z) *
(χ.value (fun z x y => T x y z) * (χ.value (fun x z y => T x y z) *
(χ.value (fun y x z => T x y z) * χ.value (fun z y x => T x y z))))) = _
unfold sixfoldProduct
ring
@[simp] theorem cyclicCharacter_pX : χ.cyclicCharacter.pX = χ.pZ := by
rfl
@[simp] theorem cyclicCharacter_pY : χ.cyclicCharacter.pY = χ.pX := rfl
@[simp] theorem cyclicCharacter_pZ : χ.cyclicCharacter.pZ = χ.pY := rfl
@[simp] theorem swap23Character_pX : χ.swap23Character.pX = χ.pX := by
unfold pX pZ
simp only [cyclicCharacter_value, swap23Character_value]
congr 2
apply congrArg χ.value
funext x y z
simp [Tensor.cyclic, Tensor.dotPairing, eq_comm]
@[simp] theorem swap23Character_pY : χ.swap23Character.pY = χ.pZ := by
unfold pY pZ
simp only [cyclicCharacter_value, swap23Character_value]
congr 2
apply congrArg χ.value
funext x y z
simp [Tensor.cyclic, Tensor.dotPairing, eq_comm]
@[simp] theorem swap23Character_pZ : χ.swap23Character.pZ = χ.pY := by
unfold pY pZ
simp only [cyclicCharacter_value, swap23Character_value]
congr 2
apply congrArg χ.value
funext x y z
simp [Tensor.cyclic, Tensor.dotPairing, eq_comm]
/-- Each singleton-leg exponent occurs twice among the first-leg exponents. -/
theorem sum_permutedCharacter_pX :
(∑ i : Fin 6, (χ.permutedCharacter i).pX) = 2 * (χ.pX + χ.pY + χ.pZ) := by
simp [permutedCharacter, Fin.sum_univ_succ]
ring
end MatrixMultiplication.AuxiliarySeparation.Character
end
end OAI
|