math / data /lean /OAI /Geometry /HarmonicGrowth /PolynomialControl.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
44.1 kB
import OAI.Geometry.HarmonicGrowth.Berger
namespace OAI
noncomputable section
section
open Matrix
open scoped BigOperators
open scoped Topology
open Filter
namespace HarmonicCounterexample.Control
lemma derivative_mem_submodule {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
(S : Submodule ℝ E) (hS : IsClosed (S : Set E))
{f : ℝ β†’ E} {v : E} {t : ℝ} (hf : HasDerivAt f v t) (hm : βˆ€ x,f x ∈ S) : v ∈ S := by
apply hS.mem_of_tendsto hf.tendsto_slope
exact Filter.Eventually.of_forall fun x => S.smul_mem _ (S.sub_mem (hm x) (hm t))
variable {A : Type*} [NormedRing A] [NormedAlgebra ℝ A]
lemma conjugation_derivative {g h : ℝ β†’ A} {z : A}
(hg : HasDerivAt g z 0) (hh : HasDerivAt h (-z) 0)
(hg0 : g 0 = 1) (hh0 : h 0 = 1) (X : A) :
HasDerivAt (fun t => g t*X*h t) (z*X-X*z) 0 := by
convert (hg.mul_const X).mul hh using 1
simp only [hg0,hh0,one_mul,mul_one,mul_neg,sub_eq_add_neg]
/-- Differentiating a genuine conjugation orbit in a finite-dimensional Lie
subalgebra proves its infinitesimal normalizer property. No Fourier integral
or unproved representation-theoretic closure is substituted. -/
theorem bracket_mem_of_conjugation [FiniteDimensional ℝ A]
(L : Submodule ℝ A) {g h : ℝ β†’ A} {z : A}
(hg : HasDerivAt g z 0) (hh : HasDerivAt h (-z) 0)
(hg0 : g 0 = 1) (hh0 : h 0 = 1)
(hconj : βˆ€ t X,X ∈ L β†’ g t*X*h t ∈ L) {X : A} (hX : X ∈ L) : (z*X-X*z) ∈ L :=
derivative_mem_submodule L L.closed_of_finiteDimensional
(conjugation_derivative hg hh hg0 hh0 X) (fun t => hconj t X hX)
end HarmonicCounterexample.Control
namespace HarmonicCounterexample.Berger.ComplexStructure
open Matrix NormedSpace
open scoped Matrix.Norms.Operator
variable {ΞΉ : Type*} [Fintype ΞΉ] [DecidableEq ΞΉ]
lemma exp_neg_mul_self (A : Matrix ΞΉ ΞΉ ℝ) : exp (-A)*exp A = 1 := by
rw [← Matrix.exp_add_of_commute (-A) A (Commute.refl A).neg_left,neg_add_cancel,exp_zero]
lemma exp_mul_neg_self (A : Matrix ΞΉ ΞΉ ℝ) : exp A*exp (-A) = 1 := by
rw [← Matrix.exp_add_of_commute A (-A) (Commute.refl A).neg_right,add_neg_cancel,exp_zero]
lemma exp_skew_transpose (A : Matrix ΞΉ ΞΉ ℝ) (hA : Aα΅€ = -A) :
(exp A)α΅€ = exp (-A) := by rw [← Matrix.exp_transpose,hA]
/-- An actual smooth orbit of orthogonal complex structures under any skew
infinitesimal rotation; both orientation classes remain available. -/
def rotate (J : ComplexStructure ΞΉ) (R : Matrix ΞΉ ΞΉ ℝ) (hR : Rα΅€ = -R) (t : ℝ) :
ComplexStructure ΞΉ where
matrix := exp (t β€’ R)*J.matrix*exp (-(t β€’ R))
square := by
have hi := exp_neg_mul_self (t β€’ R)
calc
(exp (t β€’ R)*J.matrix*exp (-(t β€’ R)))*
(exp (t β€’ R)*J.matrix*exp (-(t β€’ R))) =
exp (t β€’ R)*(J.matrix*J.matrix)*exp (-(t β€’ R)) := by
simp only [mul_assoc,← mul_assoc (exp (-(t β€’ R))) (exp (t β€’ R)),hi,one_mul]
_ = -1 := by rw [J.square,mul_neg,mul_one,neg_mul,exp_mul_neg_self]
orthogonal := by
have hs : (t β€’ R)α΅€ = -(t β€’ R) := by simp only [transpose_smul,hR,smul_neg]
have hns : (-(t β€’ R))α΅€ = -(-(t β€’ R)) := by rw [transpose_neg,hs]
rw [transpose_mul,transpose_mul,exp_skew_transpose _ hs,exp_skew_transpose _ hns,neg_neg]
calc
(exp (t β€’ R)*(J.matrixα΅€*exp (-(t β€’ R))))*
(exp (t β€’ R)*J.matrix*exp (-(t β€’ R))) =
exp (t β€’ R)*(J.matrixα΅€*J.matrix)*exp (-(t β€’ R)) := by
simp only [mul_assoc,← mul_assoc (exp (-(t β€’ R))) (exp (t β€’ R)),
exp_neg_mul_self,one_mul]
_ = 1 := by rw [J.orthogonal,mul_one,exp_mul_neg_self]
lemma rotate_zero (J : ComplexStructure ΞΉ) (R : Matrix ΞΉ ΞΉ ℝ) (hR : Rα΅€ = -R) :
(J.rotate R hR 0).matrix = J.matrix := by
simp [rotate]
lemma rotate_hasDerivAt_zero (J : ComplexStructure ΞΉ) (R : Matrix ΞΉ ΞΉ ℝ) (hR : Rα΅€ = -R) :
HasDerivAt (fun t => (J.rotate R hR t).matrix) (R*J.matrix-J.matrix*R) 0 := by
have hg := hasDerivAt_exp_smul_const R (0:ℝ)
simp only [zero_smul,exp_zero,one_mul] at hg
have hh := hasDerivAt_exp_smul_const (-R) (0:ℝ)
simp only [smul_neg,zero_smul,neg_zero,exp_zero,one_mul] at hh
exact HarmonicCounterexample.Control.conjugation_derivative hg hh
(by simp) (by simp) J.matrix
end HarmonicCounterexample.Berger.ComplexStructure
open Matrix
open scoped BigOperators
open scoped Topology
open Filter
open Matrix
namespace HarmonicCounterexample.Control
attribute [local instance 100] LieRing.ofAssociativeRing
variable {π•œ ΞΉ : Type*} [Field π•œ] [Fintype ΞΉ] [DecidableEq ΞΉ]
def traceFree : Matrix ΞΉ ΞΉ π•œ β†’β‚—[π•œ] Matrix ΞΉ ΞΉ π•œ where
toFun M := M - (M.trace / (Fintype.card ΞΉ : π•œ)) β€’ 1
map_add' M N := by simp only [trace_add,add_div,add_smul]; abel
map_smul' c M := by
simp only [trace_smul,smul_eq_mul,mul_div_assoc,smul_sub,smul_smul,RingHom.id_apply]
lemma four_square_polarization {A : Type*} [Ring A] (H X Y : A) :
H*H-(H-2*X)*(H-2*X)-(H-2*Y)*(H-2*Y)+
(H-2*X-2*Y)*(H-2*X-2*Y)=4*(X*Y+Y*X) := by noncomm_ring
/-- Four sign choices already extract each mixed plane product: no exponential
Walsh sum needs to be computed inside the kernel. Trace subtraction is exact. -/
lemma mixed_product_mem [CharZero π•œ] (L : LieSubalgebra π•œ (Matrix ΞΉ ΞΉ π•œ))
(H X Y : Matrix ΞΉ ΞΉ π•œ) (hXY : Commute X Y)
(h0 : traceFree (H*H) ∈ L)
(hi : traceFree ((H-2*X)*(H-2*X)) ∈ L)
(hj : traceFree ((H-2*Y)*(H-2*Y)) ∈ L)
(hij : traceFree ((H-2*X-2*Y)*(H-2*X-2*Y)) ∈ L) :
traceFree (X*Y) ∈ L := by
have h := L.add_mem (L.sub_mem (L.sub_mem h0 hi) hj) hij
rw [← map_sub,← map_sub,← map_add,four_square_polarization] at h
have he : (4 : Matrix ΞΉ ΞΉ π•œ)*(X*Y+Y*X) = (8:π•œ) β€’ (X*Y) := by
rw [← hXY.eq]
ext i j
simp only [Matrix.smul_apply,mul_apply,ofNat_apply]
simp
simp only [Matrix.mul_apply]
ring
rw [he,map_smul] at h
have h' := L.smul_mem (8:π•œ)⁻¹ h
simpa only [smul_smul,inv_mul_cancelβ‚€ (by norm_num : (8:π•œ) β‰  0),one_smul] using h'
end HarmonicCounterexample.Control
end
section
open Matrix
open scoped BigOperators
open scoped Topology
open Filter
open Matrix
namespace HarmonicCounterexample.Control
section
open Matrix HarmonicCounterexample.Berger
open scoped Matrix.Norms.Operator
attribute [local instance 100] LieRing.ofAssociativeRing
variable {ΞΉ ΞΊ : Type*} [Fintype ΞΉ] [DecidableEq ΞΉ] [Fintype ΞΊ] [DecidableEq ΞΊ]
lemma traceFree_commutator (A B : Matrix ΞΊ ΞΊ ℝ) :
traceFree (A*B-B*A) = A*B-B*A := by
simp only [traceFree,LinearMap.coe_mk,AddHom.coe_mk,trace_sub]
rw [trace_mul_comm A B,sub_self,zero_div,zero_smul,sub_zero]
lemma commutator_traceFree (A B : Matrix ΞΊ ΞΊ ℝ) :
A*traceFree B-traceFree B*A = A*B-B*A := by
simp only [traceFree,LinearMap.coe_mk,AddHom.coe_mk,mul_sub,sub_mul,
mul_smul_comm,smul_mul_assoc,mul_one,one_mul]
abel
/-- The actual rotation curve makes every skew angular field an infinitesimal
normalizer of the squared-complex-structure generators. The anti-representation
hypothesis is an ordinary algebraic compatibility, proved for actual polynomial
fields in `linearField_bracket`; no Lie-generation conclusion is assumed. -/
lemma square_generator_normalizer
(ρ : Matrix ΞΉ ΞΉ ℝ β†’β‚—[ℝ] Matrix ΞΊ ΞΊ ℝ)
(hρ : βˆ€ M N,ρ (M*N-N*M) = ρ N*ρ M-ρ M*ρ N)
(L : LieSubalgebra ℝ (Matrix ΞΊ ΞΊ ℝ))
(hgen : βˆ€ J : ComplexStructure ΞΉ,traceFree (ρ J.matrix*ρ J.matrix) ∈ L)
(R : Matrix ΞΉ ΞΉ ℝ) (hR : Rα΅€ = -R) (J : ComplexStructure ΞΉ) :
⁅ρ R,traceFree (ρ J.matrix*ρ J.matrix)⁆ ∈ L := by
let c := ρ.toContinuousLinearMap
have hc : HasDerivAt (fun t => ρ (J.rotate R hR t).matrix)
(ρ (R*J.matrix-J.matrix*R)) 0 :=
c.hasFDerivAt.comp_hasDerivAt 0 (J.rotate_hasDerivAt_zero R hR)
have hs := hc.mul hc
simp only [J.rotate_zero] at hs
let tf := (traceFree (π•œ := ℝ) (ΞΉ := ΞΊ)).toContinuousLinearMap
have ht := tf.hasFDerivAt.comp_hasDerivAt 0 hs
have hval : traceFree (ρ (R*J.matrix-J.matrix*R)*ρ J.matrix+
ρ J.matrix*ρ (R*J.matrix-J.matrix*R)) =
-(ρ R*traceFree (ρ J.matrix*ρ J.matrix)-traceFree (ρ J.matrix*ρ J.matrix)*ρ R) := by
rw [hρ]
have he : (ρ J.matrix*ρ R-ρ R*ρ J.matrix)*ρ J.matrix+
ρ J.matrix*(ρ J.matrix*ρ R-ρ R*ρ J.matrix) =
(ρ J.matrix*ρ J.matrix)*ρ R-ρ R*(ρ J.matrix*ρ J.matrix) := by noncomm_ring
rw [he,traceFree_commutator,commutator_traceFree]
noncomm_ring
have hd : HasDerivAt (fun t => traceFree (ρ (J.rotate R hR t).matrix*
ρ (J.rotate R hR t).matrix))
(-(ρ R*traceFree (ρ J.matrix*ρ J.matrix)-traceFree (ρ J.matrix*ρ J.matrix)*ρ R)) 0 := by
change HasDerivAt (fun t => traceFree (ρ (J.rotate R hR t).matrix*
ρ (J.rotate R hR t).matrix)) _ 0 at ht
change HasDerivAt _ (traceFree (ρ (R*J.matrix-J.matrix*R)*ρ J.matrix+
ρ J.matrix*ρ (R*J.matrix-J.matrix*R))) 0 at ht
rw [hval] at ht
exact ht
have hm := derivative_mem_submodule L.toSubmodule L.toSubmodule.closed_of_finiteDimensional hd
(fun t => hgen (J.rotate R hR t))
change ρ R*traceFree (ρ J.matrix*ρ J.matrix)-traceFree (ρ J.matrix*ρ J.matrix)*ρ R ∈ L
have hn := L.neg_mem hm
change -(-(ρ R*traceFree (ρ J.matrix*ρ J.matrix)-traceFree (ρ J.matrix*ρ J.matrix)*ρ R)) ∈ L at hn
simpa only [neg_neg] using hn
/-- Normalizer membership on generators propagates through the genuine Lie
span by Jacobi. This is the closure step needed for torus weight filtering. -/
lemma normalizer_lieSpan {π•œ A : Type*} [Field π•œ] [LieRing A] [LieAlgebra π•œ A]
(s : Set A) (z : A)
(hz : βˆ€ x ∈ s,⁅z,x⁆ ∈ LieSubalgebra.lieSpan π•œ A s) :
βˆ€ x ∈ LieSubalgebra.lieSpan π•œ A s,⁅z,x⁆ ∈ LieSubalgebra.lieSpan π•œ A s := by
intro x hx
induction hx using LieSubalgebra.lieSpan_induction with
| mem x hx => exact hz x hx
| zero => simp
| add x y hx hy ihx ihy =>
simpa only [lie_add] using (LieSubalgebra.lieSpan π•œ A s).add_mem ihx ihy
| smul a x hx ih =>
simpa only [lie_smul] using (LieSubalgebra.lieSpan π•œ A s).smul_mem a ih
| lie x y hx hy ihx ihy =>
rw [leibniz_lie]
exact (LieSubalgebra.lieSpan π•œ A s).add_mem
((LieSubalgebra.lieSpan π•œ A s).lie_mem ihx hy)
((LieSubalgebra.lieSpan π•œ A s).lie_mem hx ihy)
end
open Matrix HarmonicCounterexample.Berger
open scoped Matrix.Norms.Operator
attribute [local instance 100] LieRing.ofAssociativeRing
variable {ΞΉ ΞΊ : Type*} [Fintype ΞΉ] [DecidableEq ΞΉ] [Fintype ΞΊ] [DecidableEq ΞΊ]
lemma traceFree_commutator_complex (A B : Matrix ΞΊ ΞΊ β„‚) :
traceFree (A*B-B*A) = A*B-B*A := by
simp only [traceFree,LinearMap.coe_mk,AddHom.coe_mk,trace_sub]
rw [trace_mul_comm A B,sub_self,zero_div,zero_smul,sub_zero]
lemma commutator_traceFree_complex (A B : Matrix ΞΊ ΞΊ β„‚) :
A*traceFree B-traceFree B*A = A*B-B*A := by
simp only [traceFree,LinearMap.coe_mk,AddHom.coe_mk,mul_sub,sub_mul,
mul_smul_comm,smul_mul_assoc,mul_one,one_mul]
abel
/-- The actual rotation curve makes every skew angular field an infinitesimal
normalizer of the squared-complex-structure generators. The anti-representation
hypothesis is an ordinary algebraic compatibility, proved for actual polynomial
fields in `linearField_bracket`; no Lie-generation conclusion is assumed. -/
lemma square_generator_normalizer_complex
(ρ : Matrix ΞΉ ΞΉ ℝ β†’β‚—[ℝ] Matrix ΞΊ ΞΊ β„‚)
(hρ : βˆ€ M N,ρ (M*N-N*M) = ρ N*ρ M-ρ M*ρ N)
(L : LieSubalgebra β„‚ (Matrix ΞΊ ΞΊ β„‚))
(hgen : βˆ€ J : ComplexStructure ΞΉ,traceFree (ρ J.matrix*ρ J.matrix) ∈ L)
(R : Matrix ΞΉ ΞΉ ℝ) (hR : Rα΅€ = -R) (J : ComplexStructure ΞΉ) :
⁅ρ R,traceFree (ρ J.matrix*ρ J.matrix)⁆ ∈ L := by
let c := ρ.toContinuousLinearMap
have hc : HasDerivAt (fun t => ρ (J.rotate R hR t).matrix)
(ρ (R*J.matrix-J.matrix*R)) 0 :=
c.hasFDerivAt.comp_hasDerivAt 0 (J.rotate_hasDerivAt_zero R hR)
have hs := hc.mul hc
simp only [J.rotate_zero] at hs
let tf := ((traceFree (π•œ := β„‚) (ΞΉ := ΞΊ)).restrictScalars ℝ).toContinuousLinearMap
have ht := tf.hasFDerivAt.comp_hasDerivAt 0 hs
have hval : traceFree (ρ (R*J.matrix-J.matrix*R)*ρ J.matrix+
ρ J.matrix*ρ (R*J.matrix-J.matrix*R)) =
-(ρ R*traceFree (ρ J.matrix*ρ J.matrix)-traceFree (ρ J.matrix*ρ J.matrix)*ρ R) := by
rw [hρ]
have he : (ρ J.matrix*ρ R-ρ R*ρ J.matrix)*ρ J.matrix+
ρ J.matrix*(ρ J.matrix*ρ R-ρ R*ρ J.matrix) =
(ρ J.matrix*ρ J.matrix)*ρ R-ρ R*(ρ J.matrix*ρ J.matrix) := by noncomm_ring
rw [he,traceFree_commutator_complex,commutator_traceFree_complex]
noncomm_ring
have hd : HasDerivAt (fun t => traceFree (ρ (J.rotate R hR t).matrix*
ρ (J.rotate R hR t).matrix))
(-(ρ R*traceFree (ρ J.matrix*ρ J.matrix)-traceFree (ρ J.matrix*ρ J.matrix)*ρ R)) 0 := by
change HasDerivAt (fun t => traceFree (ρ (J.rotate R hR t).matrix*
ρ (J.rotate R hR t).matrix)) _ 0 at ht
change HasDerivAt _ (traceFree (ρ (R*J.matrix-J.matrix*R)*ρ J.matrix+
ρ J.matrix*ρ (R*J.matrix-J.matrix*R))) 0 at ht
rw [hval] at ht
exact ht
have hm := derivative_mem_submodule (L.toSubmodule.restrictScalars ℝ)
(L.toSubmodule.restrictScalars ℝ).closed_of_finiteDimensional hd
(fun t => hgen (J.rotate R hR t))
change ρ R*traceFree (ρ J.matrix*ρ J.matrix)-traceFree (ρ J.matrix*ρ J.matrix)*ρ R ∈ L
have hn := L.neg_mem hm
change -(-(ρ R*traceFree (ρ J.matrix*ρ J.matrix)-traceFree (ρ J.matrix*ρ J.matrix)*ρ R)) ∈ L at hn
simpa only [neg_neg] using hn
end HarmonicCounterexample.Control
namespace HarmonicCounterexample.Berger.ComplexStructure
open Matrix
variable {s : β„•}
/-- The manuscript's explicit three-plane complex structure: the disjoint
coordinate swaps turn the standard pairs into (X_i,X_j), (Y_i,X_k), (Y_j,Y_k).
It is an ACTUAL orthogonal complex structure, with no matrix equations assumed. -/
def triple (i j k : Fin s) : ComplexStructure (Fin s βŠ• Fin s) :=
(block s).reindex ((Equiv.swap (Sum.inr i) (Sum.inl j)).trans
(Equiv.swap (Sum.inr j) (Sum.inl k)))
def coordinateSign : Fin s βŠ• Fin s β†’ β„‚ := Sum.elim (fun _ => 1) (fun _ => -1)
def coordinatePlane : Fin s βŠ• Fin s β†’ Fin s := Sum.elim id id
def signedIndex (i : Fin s) (Ξ΅ : Bool) : Fin s βŠ• Fin s := if Ξ΅ then .inl i else .inr i
/-- Pullback matrix in the independent complex coordinates x_i Β± i y_i.
This is the exact substitution x=(z+zbar)/2, y=(z-zbar)/(2i), not a spectral
model replacing the real vector field. -/
def splitMatrix (J : ComplexStructure (Fin s βŠ• Fin s)) :
Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) β„‚ := fun a b =>
(1/2:β„‚)*((J.matrix (.inl (coordinatePlane a)) (.inl (coordinatePlane b)):β„‚)
-coordinateSign b*Complex.I*(J.matrix (.inl (coordinatePlane a)) (.inr (coordinatePlane b)):β„‚)
+coordinateSign a*Complex.I*(J.matrix (.inr (coordinatePlane a)) (.inl (coordinatePlane b)):β„‚)
+coordinateSign a*coordinateSign b*(J.matrix (.inr (coordinatePlane a)) (.inr (coordinatePlane b)):β„‚))
lemma triple_split_ij (i j k : Fin s) (hij : i β‰  j) (hik : i β‰  k) (hjk : j β‰  k)
(Ξ΅ Ξ² : Bool) : splitMatrix (triple i j k) (signedIndex i Ξ΅) (signedIndex j Ξ²) = -1/2 := by
cases Ξ΅ <;> cases Ξ² <;>
norm_num [splitMatrix,triple,reindex,block,signedIndex,coordinatePlane,coordinateSign,
Equiv.swap_apply_def,Matrix.submatrix,Matrix.one_apply,
Sum.inl_ne_inr,Sum.inr_ne_inl,Sum.inl.injEq,Sum.inr.injEq,
hij,hik,hjk,hij.symm,hik.symm,hjk.symm]
lemma triple_split_ik (i j k : Fin s) (hij : i β‰  j) (hik : i β‰  k) (hjk : j β‰  k)
(Ξ΅ Ξ³ : Bool) : splitMatrix (triple i j k) (signedIndex i Ξ΅) (signedIndex k Ξ³) =
-Complex.I*coordinateSign (signedIndex i Ξ΅)/2 := by
cases Ξ΅ <;> cases Ξ³ <;>
norm_num [splitMatrix,triple,reindex,block,signedIndex,coordinatePlane,coordinateSign,
Equiv.swap_apply_def,Matrix.submatrix,Matrix.one_apply,
Sum.inl_ne_inr,Sum.inr_ne_inl,Sum.inl.injEq,Sum.inr.injEq,
hij,hik,hjk,hij.symm,hik.symm,hjk.symm] <;> ring
lemma triple_split_ji (i j k : Fin s) (hij : i β‰  j) (hik : i β‰  k) (hjk : j β‰  k)
(Ξ΅ Ξ² : Bool) : splitMatrix (triple i j k) (signedIndex j Ξ²) (signedIndex i Ξ΅) = 1/2 := by
cases Ξ΅ <;> cases Ξ² <;>
norm_num [splitMatrix,triple,reindex,block,signedIndex,coordinatePlane,coordinateSign,
Equiv.swap_apply_def,Matrix.submatrix,Matrix.one_apply,
Sum.inl_ne_inr,Sum.inr_ne_inl,Sum.inl.injEq,Sum.inr.injEq,
hij,hik,hjk,hij.symm,hik.symm,hjk.symm]
lemma triple_split_ki (i j k : Fin s) (hij : i β‰  j) (hik : i β‰  k) (hjk : j β‰  k)
(Ξ΅ Ξ³ : Bool) : splitMatrix (triple i j k) (signedIndex k Ξ³) (signedIndex i Ξ΅) =
-Complex.I*coordinateSign (signedIndex i Ξ΅)/2 := by
cases Ξ΅ <;> cases Ξ³ <;>
norm_num [splitMatrix,triple,reindex,block,signedIndex,coordinatePlane,coordinateSign,
Equiv.swap_apply_def,Matrix.submatrix,Matrix.one_apply,
Sum.inl_ne_inr,Sum.inr_ne_inl,Sum.inl.injEq,Sum.inr.injEq,
hij,hik,hjk,hij.symm,hik.symm,hjk.symm] <;> ring
/-- Complexification of the actual real coordinate matrix. -/
def complexMatrix (J : ComplexStructure (Fin s βŠ• Fin s)) :
Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) β„‚ := J.matrix.map Complex.ofReal
def splitChange (s : β„•) : Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) β„‚ :=
fromBlocks 1 (Complex.I β€’ 1) 1 (-Complex.I β€’ 1)
def unsplitChange (s : β„•) : Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) β„‚ :=
(1/2:β„‚) β€’ fromBlocks 1 1 (-Complex.I β€’ 1) (Complex.I β€’ 1)
lemma split_unsplit (s : β„•) : splitChange s*unsplitChange s = 1 := by
simp only [splitChange,unsplitChange,mul_smul_comm,fromBlocks_multiply,
mul_one,mul_smul_comm,smul_smul]
ext a b
rcases a with a | a <;> rcases b with b | b <;>
by_cases hab : a = b <;> norm_num [Matrix.ofNat_apply,Matrix.one_apply,hab, Sum.inl_ne_inr, Sum.inr_ne_inl]
lemma unsplit_split (s : β„•) : unsplitChange s*splitChange s = 1 := by
simp only [splitChange,unsplitChange,smul_mul_assoc,fromBlocks_multiply,
mul_one,smul_mul_assoc,mul_smul_comm,smul_smul]
ext a b
rcases a with a | a <;> rcases b with b | b <;>
by_cases hab : a = b <;> norm_num [Matrix.ofNat_apply,Matrix.one_apply,hab, Sum.inl_ne_inr, Sum.inr_ne_inl]
lemma splitMatrix_eq (J : ComplexStructure (Fin s βŠ• Fin s)) :
splitMatrix J = splitChange s*complexMatrix J*unsplitChange s := by
ext a b
rcases a with a | a <;> rcases b with b | b
all_goals
simp [splitMatrix,splitChange,unsplitChange,complexMatrix,coordinatePlane,coordinateSign,
Matrix.mul_apply,Fintype.sum_sum_type,Matrix.one_apply]
all_goals ring_nf; simp only [Complex.I_sq]; ring
lemma splitMatrix_square (J : ComplexStructure (Fin s βŠ• Fin s)) :
splitMatrix J*splitMatrix J = -1 := by
have hj : complexMatrix J*complexMatrix J = -1 := by
have h := congrArg (Complex.ofRealHom.mapMatrix : Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) ℝ β†’+* Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) β„‚) J.square
rw [map_mul,map_neg,map_one] at h
change complexMatrix J*complexMatrix J = -1 at h
exact h
rw [splitMatrix_eq]
calc
(splitChange s*complexMatrix J*unsplitChange s)*
(splitChange s*complexMatrix J*unsplitChange s) =
splitChange s*(complexMatrix J*complexMatrix J)*unsplitChange s := by
simp only [mul_assoc,← mul_assoc (unsplitChange s) (splitChange s),unsplit_split,one_mul]
_ = -1 := by rw [hj,mul_neg,mul_one,neg_mul,split_unsplit]
def torusMatrix (r : Fin s β†’ ℝ) : Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) ℝ :=
fromBlocks 0 (-(diagonal r)) (diagonal r) 0
lemma torusMatrix_skew (r : Fin s β†’ ℝ) : (torusMatrix r)α΅€ = -torusMatrix r := by
ext a b
rcases a with a | a <;> rcases b with b | b <;>
by_cases hab : a = b <;> simp [torusMatrix,Matrix.transpose_apply,hab,eq_comm]
lemma torusMatrix_square (r : Fin s β†’ ℝ) (hr : βˆ€ i,r i*r i = 1) :
torusMatrix r*torusMatrix r = -1 := by
have hd : diagonal r*diagonal r = 1 := by
rw [diagonal_mul_diagonal]
simp only [hr,diagonal_one]
simp only [torusMatrix,fromBlocks_multiply,zero_mul,mul_zero,zero_add,add_zero,
neg_mul,mul_neg,hd]
ext a b
rcases a with a | a <;> rcases b with b | b <;> simp [Matrix.one_apply]
def signedStructure (r : Fin s β†’ ℝ) (hr : βˆ€ i,r i*r i = 1) :
ComplexStructure (Fin s βŠ• Fin s) where
matrix := torusMatrix r
square := torusMatrix_square r hr
orthogonal := by rw [torusMatrix_skew,neg_mul,torusMatrix_square r hr,neg_neg]
/-- Real-linear transformation of any actual coordinate field into the source's
independent complex z/bar-z coordinates. -/
def splitFieldMatrix : Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) ℝ β†’β‚—[ℝ]
Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) β„‚ where
toFun M := splitChange s*M.map Complex.ofReal*unsplitChange s
map_add' M N := by
simp only [Matrix.map_add _ Complex.ofReal_add,mul_add,add_mul]
map_smul' r M := by
have he : (r β€’ M).map Complex.ofReal = r β€’ M.map Complex.ofReal := by ext i j; simp
rw [he,mul_smul_comm,smul_mul_assoc]
rfl
lemma splitFieldMatrix_complex (J : ComplexStructure (Fin s βŠ• Fin s)) :
splitFieldMatrix J.matrix = splitMatrix J := (splitMatrix_eq J).symm
lemma splitFieldMatrix_mul (M N : Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) ℝ) :
splitFieldMatrix (M*N) = splitFieldMatrix M*splitFieldMatrix N := by
have hf : (M*N).map Complex.ofReal = M.map Complex.ofReal*N.map Complex.ofReal := by
exact (Complex.ofRealHom.mapMatrix : Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) ℝ β†’+*
Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) β„‚).map_mul M N
change splitChange s*(M*N).map Complex.ofReal*unsplitChange s =
(splitChange s*M.map Complex.ofReal*unsplitChange s)*
(splitChange s*N.map Complex.ofReal*unsplitChange s)
rw [hf]
simp only [mul_assoc,← mul_assoc (unsplitChange s) (splitChange s),unsplit_split,one_mul]
lemma splitFieldMatrix_torus (r : Fin s β†’ ℝ) :
splitFieldMatrix (torusMatrix r) =
diagonal (fun a => Complex.I*coordinateSign a*(r (coordinatePlane a):β„‚)) := by
ext a b
rcases a with a | a <;> rcases b with b | b
all_goals
change (splitChange s*(torusMatrix r).map Complex.ofReal*unsplitChange s) _ _ = _
simp [splitChange,unsplitChange,torusMatrix,Matrix.mul_apply,Fintype.sum_sum_type,
Matrix.one_apply,diagonal_apply,coordinateSign,coordinatePlane]
all_goals by_cases hab : a = b <;> simp [hab]
all_goals ring_nf
end HarmonicCounterexample.Berger.ComplexStructure
open Matrix
open scoped BigOperators
open scoped Topology
open Filter
open Matrix
open scoped BigOperators
open Matrix MvPolynomial
namespace HarmonicCounterexample.Control
variable {π•œ ΞΉ : Type*} [CommRing π•œ] [Fintype ΞΉ] [DecidableEq ΞΉ]
/-- The actual infinitesimal linear coordinate motion, specified on generators. -/
def linearField (M : Matrix ΞΉ ΞΉ π•œ) : Derivation π•œ (MvPolynomial ΞΉ π•œ) (MvPolynomial ΞΉ π•œ) :=
MvPolynomial.mkDerivation π•œ (fun i => βˆ‘ j : ΞΉ,M i j β€’ X j)
omit [DecidableEq ΞΉ] in
lemma linearField_X (M : Matrix ΞΉ ΞΉ π•œ) (i : ΞΉ) :
linearField M (X i) = βˆ‘ j : ΞΉ,M i j β€’ X j := mkDerivation_X _ _ _
omit [DecidableEq ΞΉ] in
lemma linearField_add (M N : Matrix ΞΉ ΞΉ π•œ) : linearField (M+N) = linearField M+linearField N := by
apply MvPolynomial.derivation_ext
intro i
simp [linearField_X,add_smul,Finset.sum_add_distrib]
omit [DecidableEq ΞΉ] in
lemma linearField_smul (c : π•œ) (M : Matrix ΞΉ ΞΉ π•œ) : linearField (c β€’ M) = c β€’ linearField M := by
apply MvPolynomial.derivation_ext
intro i
simp [linearField_X,smul_smul,Finset.smul_sum]
omit [DecidableEq ΞΉ] in
/-- Exact anti-representation identity for coordinate vector fields.
The sign is important: fields act on functions by pullback. -/
lemma linearField_bracket (M N : Matrix ΞΉ ΞΉ π•œ) :
⁅linearField M,linearField N⁆ = linearField (N*M-M*N) := by
apply MvPolynomial.derivation_ext
intro i
simp only [Derivation.commutator_apply,linearField_X,map_sum,Derivation.map_smul,
Matrix.sub_apply,Matrix.mul_apply,Finset.sum_sub_distrib,sub_smul,Finset.smul_sum,
Finset.sum_smul,smul_smul]
congr 1 <;> exact Finset.sum_comm
omit [Fintype ΞΉ] [DecidableEq ΞΉ] in
lemma derivation_sum_apply {ΞΊ : Type*} (s : Finset ΞΊ)
(f : ΞΊ β†’ Derivation π•œ (MvPolynomial ΞΉ π•œ) (MvPolynomial ΞΉ π•œ)) (P : MvPolynomial ΞΉ π•œ) :
(βˆ‘ i ∈ s,f i) P = βˆ‘ i ∈ s,f i P := by
classical
induction s using Finset.induction_on with
| empty => simp
| @insert i s hi ih => simp only [Finset.sum_insert hi,Derivation.add_apply,ih]
lemma linearField_apply (M : Matrix ΞΉ ΞΉ π•œ) (P : MvPolynomial ΞΉ π•œ) :
linearField M P = βˆ‘ i : ΞΉ,βˆ‘ j : ΞΉ,M i j β€’ (X j*pderiv i P) := by
have h : linearField M = βˆ‘ i : ΞΉ,(βˆ‘ j : ΞΉ,M i j β€’ (X j : MvPolynomial ΞΉ π•œ)) β€’ pderiv i := by
apply MvPolynomial.derivation_ext
intro k
simp [linearField_X,Derivation.smul_apply,Pi.single_apply]
rw [h]
simp [Derivation.smul_apply,Finset.sum_mul]
def linearFieldMap : Matrix ΞΉ ΞΉ π•œ β†’β‚—[π•œ] Module.End π•œ (MvPolynomial ΞΉ π•œ) where
toFun M := (linearField M).toLinearMap
map_add' M N := by rw [linearField_add]; rfl
map_smul' c M := by rw [linearField_smul]; rfl
end HarmonicCounterexample.Control
end
section
open Matrix
open scoped BigOperators
open scoped Topology
open Filter
open Matrix
open scoped BigOperators
open Matrix MvPolynomial
namespace HarmonicCounterexample.Control
section
open scoped BigOperators
open Matrix MvPolynomial Finsupp
variable {π•œ ΞΉ : Type*} [Field π•œ] [Fintype ΞΉ] [DecidableEq ΞΉ]
lemma linearField_diagonal_monomial (d : ΞΉ β†’ π•œ) (Ξ½ : ΞΉ β†’β‚€ β„•) (c : π•œ) :
linearField (diagonal d) (monomial Ξ½ c) = (βˆ‘ i : ΞΉ,d i*(Ξ½ i:π•œ)) β€’ monomial Ξ½ c := by
rw [linearField_apply]
simp only [diagonal_apply,ite_smul,zero_smul,Finset.sum_ite_eq,Finset.mem_univ,ite_true,
X_mul_pderiv_monomial,← Nat.cast_smul_eq_nsmul π•œ,smul_smul,Finset.sum_smul]
lemma linearField_square_first (M : Matrix ΞΉ ΞΉ π•œ) (P : MvPolynomial ΞΉ π•œ) :
(βˆ‘ i : ΞΉ,βˆ‘ j : ΞΉ,M i j β€’ (linearField M (X j)*pderiv i P)) = linearField (M*M) P := by
rw [linearField_apply]
simp only [linearField_X,Matrix.mul_apply,Finset.sum_smul,Finset.sum_mul,Finset.smul_sum,
smul_mul_assoc,smul_smul]
apply Finset.sum_congr rfl
intro i _
exact Finset.sum_comm
/-- Exact second-order formula: there is no implicit harmonic projection and
no omitted first-order term. -/
lemma linearField_square (M : Matrix ΞΉ ΞΉ π•œ) (P : MvPolynomial ΞΉ π•œ) :
linearField M (linearField M P) = linearField (M*M) P+
βˆ‘ i : ΞΉ,βˆ‘ j : ΞΉ,M i j β€’ (X j*linearField M (pderiv i P)) := by
have hleib (A B : MvPolynomial ΞΉ π•œ) : linearField M (A*B) =
linearField M A*B+A*linearField M B := by
simpa only [smul_eq_mul,mul_comm,add_comm] using (linearField M).leibniz A B
conv_lhs => rw [linearField_apply M P]
simp only [map_sum,Derivation.map_smul,hleib,smul_add,Finset.sum_add_distrib]
rw [linearField_square_first]
lemma linearField_neg_one (P : MvPolynomial ΞΉ π•œ) {l : β„•} (hP : P.IsHomogeneous l) :
linearField (-1 : Matrix ΞΉ ΞΉ π•œ) P = -(l:π•œ) β€’ P := by
have he : (-1 : Matrix ΞΉ ΞΉ π•œ) = diagonal (fun _ => -1) := by ext i j; by_cases h : i = j <;> simp [h]
rw [he,linearField_apply]
simp only [diagonal_apply,ite_smul,zero_smul,Finset.sum_ite_eq,Finset.mem_univ,ite_true,
neg_one_smul,Finset.sum_neg_distrib]
rw [hP.sum_X_mul_pderiv]
simp only [← Nat.cast_smul_eq_nsmul π•œ,neg_smul]
lemma linearField_square_complex (M : Matrix ΞΉ ΞΉ π•œ) (hM : M*M = -1)
(P : MvPolynomial ΞΉ π•œ) {l : β„•} (hP : P.IsHomogeneous l) :
linearField M (linearField M P) = -(l:π•œ) β€’ P+
βˆ‘ i : ΞΉ,βˆ‘ j : ΞΉ,M i j β€’ (X j*linearField M (pderiv i P)) := by
rw [linearField_square,hM,linearField_neg_one P hP]
abbrev MonomialIndex (ΞΉ : Type*) (l : β„•) := {d : ΞΉ β†’β‚€ β„• // d.degree = l}
instance monomialIndexFintype (l : β„•) : Fintype (MonomialIndex ΞΉ l) := by
let e : MonomialIndex ΞΉ l ≃ β†₯((Finset.univ : Finset ΞΉ).finsuppAntidiag l) :=
{ toFun := fun d => ⟨d.1, by
have h : d.1.degree = βˆ‘ i : ΞΉ,d.1 i := Finsupp.sum_fintype d.1 (fun _ a => a) (fun _ => rfl)
exact Finset.mem_finsuppAntidiag.2 ⟨h.symm.trans d.2,Finset.subset_univ _⟩⟩
invFun := fun d => ⟨d.1,by
have h : d.1.degree = βˆ‘ i : ΞΉ,d.1 i := Finsupp.sum_fintype d.1 (fun _ a => a) (fun _ => rfl)
exact h.trans (Finset.mem_finsuppAntidiag.1 d.2).1⟩
left_inv := fun _ => rfl
right_inv := fun _ => rfl }
exact Fintype.ofEquiv _ e.symm
/-- Actual coefficient coordinates on homogeneous polynomials. -/
def homogeneousCoords (l : β„•) :
homogeneousSubmodule ΞΉ π•œ l ≃ₗ[π•œ] MonomialIndex ΞΉ l β†’β‚€ π•œ :=
(LinearEquiv.ofEq _ _ (homogeneousSubmodule_eq_finsupp_supported ΞΉ π•œ l)).trans
(AddMonoidAlgebra.supportedEquivFinsupp (R := π•œ) (S := π•œ) {d : ΞΉ β†’β‚€ β„• | d.degree = l})
def homogeneousBasis (l : β„•) : Module.Basis (MonomialIndex ΞΉ l) π•œ (homogeneousSubmodule ΞΉ π•œ l) :=
Finsupp.basisSingleOne.map (homogeneousCoords l).symm
omit [Fintype ΞΉ] [DecidableEq ΞΉ] in
lemma homogeneousCoords_apply (l : β„•) (P : homogeneousSubmodule ΞΉ π•œ l) (d : MonomialIndex ΞΉ l) :
homogeneousCoords l P d = P.1.coeff d.1 := rfl
omit [Fintype ΞΉ] [DecidableEq ΞΉ] in
lemma homogeneousBasis_repr (l : β„•) (P : homogeneousSubmodule ΞΉ π•œ l) (d : MonomialIndex ΞΉ l) :
(homogeneousBasis l).repr P d = P.1.coeff d.1 := rfl
omit [Fintype ΞΉ] in
lemma homogeneousBasis_val (l : β„•) (d : MonomialIndex ΞΉ l) :
((homogeneousBasis (π•œ := π•œ) l) d).1 = monomial d.1 1 := by
apply MvPolynomial.ext
intro e
by_cases he : e.degree = l
Β· have h := (homogeneousBasis (π•œ := π•œ) l).repr_self d
have h' := DFunLike.congr_fun h ⟨e,he⟩
change ((homogeneousBasis (π•œ := π•œ) l) d).1.coeff e = (Finsupp.single d (1:π•œ)) ⟨e,he⟩ at h'
simpa only [Finsupp.single_apply,Subtype.ext_iff,coeff_monomial] using h'
Β· have hP := ((homogeneousBasis (π•œ := π•œ) l) d).property
have hzero := hP.coeff_eq_zero he
have hne : d.1 β‰  e := fun hd => he (hd β–Έ d.2)
simp [hzero,coeff_monomial,hne]
lemma linearField_homogeneous {P : MvPolynomial ΞΉ π•œ} {l : β„•}
(hP : P.IsHomogeneous l) (M : Matrix ΞΉ ΞΉ π•œ) : (linearField M P).IsHomogeneous l := by
rw [linearField_apply]
by_cases hl : l = 0
Β· have hc : P = C (P.coeff 0) :=
totalDegree_eq_zero_iff_eq_C.1 ((totalDegree_zero_iff_isHomogeneous ΞΉ).2 (hl β–Έ hP))
rw [hc]
simp only [pderiv_C,mul_zero,smul_zero,Finset.sum_const_zero]
exact isHomogeneous_zero ΞΉ π•œ l
Β· apply IsHomogeneous.sum
intro i _
apply IsHomogeneous.sum
intro j _
apply (homogeneousSubmodule ΞΉ π•œ l).smul_mem
have h := (isHomogeneous_X π•œ j).mul (hP.pderiv (i := i))
have he : 1+(l-1) = l := by omega
change (X j*pderiv i P).IsHomogeneous l
simpa only [he] using h
def homogeneousField (l : β„•) (M : Matrix ΞΉ ΞΉ π•œ) :
Module.End π•œ (homogeneousSubmodule ΞΉ π•œ l) where
toFun P := ⟨linearField M P.1,linearField_homogeneous P.2 M⟩
map_add' _P _Q := Subtype.ext (map_add _ _ _)
map_smul' _a _P := Subtype.ext (Derivation.map_smul _ _ _)
lemma homogeneousField_bracket (l : β„•) (M N : Matrix ΞΉ ΞΉ π•œ) :
homogeneousField l (M*N-N*M) = homogeneousField l N*homogeneousField l M-
homogeneousField l M*homogeneousField l N := by
apply LinearMap.ext
intro P
apply Subtype.ext
have h := DFunLike.congr_fun (linearField_bracket N M) P.1
exact h.symm
/-- An actual finite-dimensional representation, in the actual monomial basis. -/
def homogeneousFieldMap (l : β„•) :
Matrix ΞΉ ΞΉ π•œ β†’β‚—[π•œ] Module.End π•œ (homogeneousSubmodule ΞΉ π•œ l) where
toFun := homogeneousField l
map_add' M N := by
apply LinearMap.ext
intro P
apply Subtype.ext
exact DFunLike.congr_fun (linearField_add M N) P.1
map_smul' a M := by
apply LinearMap.ext
intro P
apply Subtype.ext
exact DFunLike.congr_fun (linearField_smul a M) P.1
def homogeneousMatrix (l : β„•) :
Matrix ΞΉ ΞΉ π•œ β†’β‚—[π•œ] Matrix (MonomialIndex ΞΉ l) (MonomialIndex ΞΉ l) π•œ :=
(LinearMap.toMatrix (homogeneousBasis l) (homogeneousBasis l)).toLinearMap.comp
(homogeneousFieldMap l)
lemma homogeneousMatrix_apply (l : β„•) (M : Matrix ΞΉ ΞΉ π•œ) (ΞΌ Ξ½ : MonomialIndex ΞΉ l) :
homogeneousMatrix l M ΞΌ Ξ½ = (linearField M (monomial Ξ½.1 1)).coeff ΞΌ.1 := by
change (LinearMap.toMatrix (homogeneousBasis l) (homogeneousBasis l) (homogeneousField l M)) ΞΌ Ξ½ = _
rw [LinearMap.toMatrix_apply]
rw [homogeneousBasis_repr]
change (linearField M ((homogeneousBasis l) Ξ½).1).coeff ΞΌ.1 = _
rw [homogeneousBasis_val]
lemma homogeneousMatrix_square_apply (l : β„•) (M : Matrix ΞΉ ΞΉ π•œ) (ΞΌ Ξ½ : MonomialIndex ΞΉ l) :
(homogeneousMatrix l M*homogeneousMatrix l M) ΞΌ Ξ½ =
(linearField M (linearField M (monomial Ξ½.1 1))).coeff ΞΌ.1 := by
change ((LinearMap.toMatrix (homogeneousBasis l) (homogeneousBasis l)) (homogeneousField l M)*
(LinearMap.toMatrix (homogeneousBasis l) (homogeneousBasis l)) (homogeneousField l M)) ΞΌ Ξ½ = _
rw [← LinearMap.toMatrix_mul,LinearMap.toMatrix_apply,homogeneousBasis_repr]
change (linearField M (linearField M ((homogeneousBasis l) Ξ½).1)).coeff ΞΌ.1 = _
rw [homogeneousBasis_val]
lemma homogeneousMatrix_bracket (l : β„•) (M N : Matrix ΞΉ ΞΉ π•œ) :
homogeneousMatrix l (M*N-N*M) = homogeneousMatrix l N*homogeneousMatrix l M-
homogeneousMatrix l M*homogeneousMatrix l N := by
change (LinearMap.toMatrix (homogeneousBasis l) (homogeneousBasis l))
(homogeneousField l (M*N-N*M)) = _
rw [homogeneousField_bracket]
calc
_ = (LinearMap.toMatrix (homogeneousBasis l) (homogeneousBasis l))
(homogeneousField l N*homogeneousField l M)-
(LinearMap.toMatrix (homogeneousBasis l) (homogeneousBasis l))
(homogeneousField l M*homogeneousField l N) :=
map_sub (LinearMap.toMatrix (homogeneousBasis l) (homogeneousBasis l)) _ _
_ = _ := by rw [LinearMap.toMatrix_mul,LinearMap.toMatrix_mul]; rfl
lemma homogeneousMatrix_diagonal (l : β„•) (d : ΞΉ β†’ π•œ) :
homogeneousMatrix l (diagonal d) = diagonal (fun Ξ½ : MonomialIndex ΞΉ l => βˆ‘ i,d i*(Ξ½.1 i:π•œ)) := by
ext ΞΌ Ξ½
rw [homogeneousMatrix_apply,linearField_diagonal_monomial,coeff_smul,coeff_monomial]
by_cases h : ΞΌ = Ξ½
Β· subst ΞΌ; simp
Β· have hn : Ξ½.1 β‰  ΞΌ.1 := fun he => h (Subtype.ext he.symm)
simp [h,hn]
end
open Matrix MvPolynomial HarmonicCounterexample.Berger
open HarmonicCounterexample.Berger.ComplexStructure
open scoped BigOperators
variable {s : β„•}
def angularRepresentation (l : β„•) :
Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) ℝ β†’β‚—[ℝ]
Matrix (MonomialIndex (Fin s βŠ• Fin s) l) (MonomialIndex (Fin s βŠ• Fin s) l) β„‚ :=
((homogeneousMatrix l).restrictScalars ℝ).comp splitFieldMatrix
lemma angularRepresentation_bracket (l : β„•)
(M N : Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) ℝ) :
angularRepresentation l (M*N-N*M) =
angularRepresentation l N*angularRepresentation l M-
angularRepresentation l M*angularRepresentation l N := by
change homogeneousMatrix l (splitFieldMatrix (M*N-N*M)) = _
rw [map_sub,splitFieldMatrix_mul,splitFieldMatrix_mul,homogeneousMatrix_bracket]
rfl
def monomialWeight (Ξ½ : Fin s βŠ• Fin s β†’β‚€ β„•) (i : Fin s) : β„‚ :=
(Ξ½ (.inl i):β„‚)-Ξ½ (.inr i)
lemma angularRepresentation_torus (l : β„•) (r : Fin s β†’ ℝ) :
angularRepresentation l (torusMatrix r) = diagonal
(fun Ξ½ : MonomialIndex (Fin s βŠ• Fin s) l =>
Complex.I*βˆ‘ i : Fin s,(r i:β„‚)*monomialWeight Ξ½.1 i) := by
change homogeneousMatrix l (splitFieldMatrix (torusMatrix r)) = _
rw [splitFieldMatrix_torus,homogeneousMatrix_diagonal]
congr 1
funext Ξ½
simp only [Fintype.sum_sum_type,coordinateSign,coordinatePlane,Sum.elim_inl,Sum.elim_inr,
monomialWeight,mul_sub,Finset.sum_sub_distrib,Finset.mul_sum,id_eq]
rw [← Finset.sum_add_distrib,← Finset.sum_sub_distrib]
apply Finset.sum_congr rfl
intro i _
ring
lemma angularRepresentation_plane (l : β„•) (i : Fin s) :
angularRepresentation l (torusMatrix (Pi.single i 1)) =
diagonal (fun Ξ½ : MonomialIndex (Fin s βŠ• Fin s) l => Complex.I*monomialWeight Ξ½.1 i) := by
rw [angularRepresentation_torus]
congr 1
funext Ξ½
congr 1
rw [Finset.sum_eq_single i]
Β· simp
Β· intro j _ hji
simp [hji]
Β· simp
end HarmonicCounterexample.Control
end
open Matrix
open scoped BigOperators
open scoped Topology
open Filter
open Matrix
open scoped BigOperators
open Matrix MvPolynomial
namespace HarmonicCounterexample.Control
open Matrix MvPolynomial HarmonicCounterexample.Berger
open HarmonicCounterexample.Berger.ComplexStructure
open scoped BigOperators
attribute [local instance 100] LieRing.ofAssociativeRing
variable {s : β„•}
/-- The actual squared-complex-structure Lie algebra on homogeneous
polynomials; the restriction to harmonic polynomials is taken later. -/
def angularLie (l : β„•) : LieSubalgebra β„‚
(Matrix (MonomialIndex (Fin s βŠ• Fin s) l) (MonomialIndex (Fin s βŠ• Fin s) l) β„‚) :=
LieSubalgebra.lieSpan β„‚ _ (Set.range fun J : ComplexStructure (Fin s βŠ• Fin s) =>
traceFree (angularRepresentation l J.matrix*angularRepresentation l J.matrix))
lemma angularLie_generator (l : β„•) (J : ComplexStructure (Fin s βŠ• Fin s)) :
traceFree (angularRepresentation l J.matrix*angularRepresentation l J.matrix) ∈ angularLie l :=
LieSubalgebra.subset_lieSpan (Set.mem_range_self J)
lemma angularLie_normalizer (l : β„•)
(R : Matrix (Fin s βŠ• Fin s) (Fin s βŠ• Fin s) ℝ) (hR : Rα΅€ = -R)
(X : Matrix (MonomialIndex (Fin s βŠ• Fin s) l) (MonomialIndex (Fin s βŠ• Fin s) l) β„‚)
(hX : X ∈ angularLie l) : ⁅angularRepresentation l R,X⁆ ∈ angularLie l := by
apply normalizer_lieSpan _ (angularRepresentation l R) ?_ X hX
rintro _ ⟨J,rfl⟩
exact square_generator_normalizer_complex (angularRepresentation l)
(angularRepresentation_bracket l) (angularLie l) (angularLie_generator l) R hR J
lemma angularLie_weight_normalizer (l : β„•) (i : Fin s)
(X : Matrix (MonomialIndex (Fin s βŠ• Fin s) l) (MonomialIndex (Fin s βŠ• Fin s) l) β„‚)
(hX : X ∈ angularLie l) :
⁅diagonal (fun Ξ½ : MonomialIndex (Fin s βŠ• Fin s) l => monomialWeight Ξ½.1 i),X⁆ ∈ angularLie l := by
have h := angularLie_normalizer l (torusMatrix (Pi.single i 1))
(torusMatrix_skew _) X hX
have ht := (angularLie l).smul_mem (-Complex.I) h
rw [← smul_lie,angularRepresentation_plane] at ht
have hd : (-Complex.I) β€’ diagonal (fun Ξ½ : MonomialIndex (Fin s βŠ• Fin s) l =>
Complex.I*monomialWeight Ξ½.1 i) =
diagonal (fun Ξ½ : MonomialIndex (Fin s βŠ• Fin s) l => monomialWeight Ξ½.1 i) := by
ext ΞΌ Ξ½
by_cases hΞΌ : ΞΌ = Ξ½ <;> simp [hΞΌ,← mul_assoc]
rwa [hd] at ht
/-- The torus field is real-linear in its plane velocities. -/
def torusRepresentation (l : β„•) : (Fin s β†’ ℝ) β†’β‚—[ℝ]
Matrix (MonomialIndex (Fin s βŠ• Fin s) l) (MonomialIndex (Fin s βŠ• Fin s) l) β„‚ where
toFun r := angularRepresentation l (torusMatrix r)
map_add' r q := by
have ht : torusMatrix (r+q) = torusMatrix r+torusMatrix q := by
ext a b
rcases a with a | a <;> rcases b with b | b <;>
by_cases hab : a = b <;> simp [torusMatrix,hab,add_comm]
rw [ht,map_add]
map_smul' c r := by
have ht : torusMatrix (c β€’ r) = c β€’ torusMatrix r := by
ext a b
rcases a with a | a <;> rcases b with b | b <;>
by_cases hab : a = b <;> simp [torusMatrix,hab]
rw [ht,map_smul]
rfl
lemma torusRepresentation_flip (l : β„•) (r q : Fin s β†’ ℝ) :
torusRepresentation l (r-(2:ℝ) β€’ q) = torusRepresentation l r-2*torusRepresentation l q := by
rw [map_sub,map_smul,two_smul ℝ,two_mul]
lemma angularLie_mixed_torus (l : β„•) (i j : Fin s) (hij : i β‰  j) :
traceFree (torusRepresentation l (Pi.single i 1)*torusRepresentation l (Pi.single j 1)) ∈
angularLie l := by
let r : Fin s β†’ ℝ := fun _ => 1
let p : Fin s β†’ ℝ := Pi.single i 1
let q : Fin s β†’ ℝ := Pi.single j 1
have hr : βˆ€ a,r a*r a = 1 := by intro a; simp [r]
have hp : βˆ€ a,(r-(2:ℝ) β€’ p) a*(r-(2:ℝ) β€’ p) a = 1 := by
intro a
by_cases ha : a = i <;> norm_num [r,p,Pi.single_apply,ha,eq_comm]
have hq : βˆ€ a,(r-(2:ℝ) β€’ q) a*(r-(2:ℝ) β€’ q) a = 1 := by
intro a
by_cases ha : a = j <;> norm_num [r,q,Pi.single_apply,ha,eq_comm]
have hpq : βˆ€ a,(r-(2:ℝ) β€’ p-(2:ℝ) β€’ q) a*(r-(2:ℝ) β€’ p-(2:ℝ) β€’ q) a = 1 := by
intro a
by_cases hi : a = i <;> by_cases hj : a = j <;>
norm_num [r,p,q,Pi.single_apply,hi,hj,eq_comm] <;> simp_all
all_goals norm_num
have hc : Commute (torusRepresentation l p) (torusRepresentation l q) := by
change Commute (angularRepresentation l (torusMatrix p)) (angularRepresentation l (torusMatrix q))
rw [angularRepresentation_torus,angularRepresentation_torus]
exact Matrix.commute_diagonal _ _
apply mixed_product_mem (angularLie l) (torusRepresentation l r)
(torusRepresentation l p) (torusRepresentation l q) hc
Β· exact angularLie_generator l (signedStructure r hr)
Β· convert angularLie_generator l (signedStructure (r-(2:ℝ) β€’ p) hp) using 1
change _ = traceFree (torusRepresentation l (r-(2:ℝ) β€’ p)*torusRepresentation l (r-(2:ℝ) β€’ p))
rw [torusRepresentation_flip]
Β· convert angularLie_generator l (signedStructure (r-(2:ℝ) β€’ q) hq) using 1
change _ = traceFree (torusRepresentation l (r-(2:ℝ) β€’ q)*torusRepresentation l (r-(2:ℝ) β€’ q))
rw [torusRepresentation_flip]
Β· convert angularLie_generator l (signedStructure (r-(2:ℝ) β€’ p-(2:ℝ) β€’ q) hpq) using 1
change _ = traceFree (torusRepresentation l (r-(2:ℝ) β€’ p-(2:ℝ) β€’ q)*torusRepresentation l (r-(2:ℝ) β€’ p-(2:ℝ) β€’ q))
rw [torusRepresentation_flip,torusRepresentation_flip]
lemma angularLie_pair_weight (l : β„•) (i j : Fin s) (hij : i β‰  j) :
traceFree (diagonal (fun Ξ½ : MonomialIndex (Fin s βŠ• Fin s) l =>
monomialWeight ν.1 i*monomialWeight ν.1 j)) ∈ angularLie l := by
have h := angularLie_mixed_torus l i j hij
change traceFree (angularRepresentation l (torusMatrix (Pi.single i 1))*
angularRepresentation l (torusMatrix (Pi.single j 1))) ∈ _ at h
rw [angularRepresentation_plane,angularRepresentation_plane,diagonal_mul_diagonal] at h
have he : diagonal (fun Ξ½ : MonomialIndex (Fin s βŠ• Fin s) l =>
(Complex.I*monomialWeight Ξ½.1 i)*(Complex.I*monomialWeight Ξ½.1 j)) =
-diagonal (fun Ξ½ : MonomialIndex (Fin s βŠ• Fin s) l => monomialWeight Ξ½.1 i*monomialWeight Ξ½.1 j) := by
rw [diagonal_neg]
congr 1
funext Ξ½
calc
_ = Complex.I^2*(monomialWeight Ξ½.1 i*monomialWeight Ξ½.1 j) := by ring
_ = _ := by rw [Complex.I_sq]; ring
rw [he,map_neg] at h
have hn := (angularLie l).neg_mem h
change -(-traceFree _) ∈ angularLie l at hn
simpa only [neg_neg] using hn
lemma angularLie_pair_normalizer (l : β„•) (i j : Fin s) (hij : i β‰  j)
(X : Matrix (MonomialIndex (Fin s βŠ• Fin s) l) (MonomialIndex (Fin s βŠ• Fin s) l) β„‚)
(hX : X ∈ angularLie l) :
⁅diagonal (fun Ξ½ : MonomialIndex (Fin s βŠ• Fin s) l =>
monomialWeight Ξ½.1 i*monomialWeight Ξ½.1 j),X⁆ ∈ angularLie l := by
have h := (angularLie l).neg_mem ((angularLie l).lie_mem hX (angularLie_pair_weight l i j hij))
change -(X*traceFree _-traceFree _*X) ∈ angularLie l at h
rw [commutator_traceFree_complex] at h
change _*X-X*_ ∈ angularLie l
simpa only [neg_sub] using h
end HarmonicCounterexample.Control
end
end OAI