Download data/lean/OAI/Geometry/HarmonicGrowth/PolynomialControl.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 44.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/HarmonicGrowth/PolynomialControl.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Geometry/HarmonicGrowth/PolynomialControl.lean
-
curl -L -o PolynomialControl.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Geometry/HarmonicGrowth/PolynomialControl.lean
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 | |