| import OAI.Geometry.HarmonicGrowth.RealForms |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators InnerProductSpace |
|
|
| namespace HarmonicCounterexample.Angular |
| open MvPolynomial Matrix Berger |
| abbrev PolynomialSpace (n : ℕ) := MvPolynomial (Fin n) ℝ |
| variable {n : ℕ} |
| def polynomialLaplacian : PolynomialSpace n →ₗ[ℝ] PolynomialSpace n := |
| ∑ i : Fin n, (pderiv i).toLinearMap.comp (pderiv i).toLinearMap |
|
|
| def harmonicPolynomials (n l : ℕ) : Submodule ℝ (PolynomialSpace n) := |
| homogeneousSubmodule (Fin n) ℝ l ⊓ LinearMap.ker polynomialLaplacian |
|
|
| lemma pderiv_commute (P : PolynomialSpace n) (i j : Fin n) : |
| pderiv i (pderiv j P) = pderiv j (pderiv i P) := by |
| induction P using MvPolynomial.induction_on with |
| | C c => simp |
| | add P Q hp hq => simp only [map_add,hp,hq] |
| | mul_X P k hp => |
| simp only [pderiv_mul,map_add,pderiv_X,hp] |
| by_cases hi : i = k <;> by_cases hj : j = k |
| · subst i; subst j; rfl |
| · subst i; simp [Ne.symm hj] |
| · subst j; simp [Ne.symm hi] |
| · simp [Ne.symm hi,Ne.symm hj] |
|
|
| / |
| def polynomialRotation (M : Mat n) : PolynomialSpace n →ₗ[ℝ] PolynomialSpace n := |
| ∑ i : Fin n, ∑ j : Fin n, M i j • |
| ((LinearMap.mulLeft ℝ (X j)).comp (pderiv i).toLinearMap) |
|
|
| lemma polynomialRotation_apply (M : Mat n) (P : PolynomialSpace n) : |
| polynomialRotation M P = ∑ i,∑ j,M i j • (X j*pderiv i P) := by |
| simp [polynomialRotation] |
|
|
| lemma polynomialRotation_homogeneous {P : PolynomialSpace n} {l : ℕ} |
| (hP : P.IsHomogeneous l) (M : Mat n) : (polynomialRotation M P).IsHomogeneous l := by |
| rw [polynomialRotation_apply] |
| by_cases hl : l = 0 |
| · have hc : P = C (P.coeff 0) := |
| totalDegree_eq_zero_iff_eq_C.1 ((totalDegree_zero_iff_isHomogeneous (Fin n)).2 (hl ▸ hP)) |
| rw [hc] |
| simp only [pderiv_C,mul_zero,smul_zero,Finset.sum_const_zero] |
| exact isHomogeneous_zero (Fin n) ℝ l |
| · apply IsHomogeneous.sum |
| intro i _ |
| apply IsHomogeneous.sum |
| intro j _ |
| apply (homogeneousSubmodule (Fin n) ℝ 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 |
|
|
| lemma pderiv_rotation_term (P : PolynomialSpace n) (c : ℝ) (i j k : Fin n) : |
| pderiv k (c • (X j*pderiv i P)) = |
| c • (X j*pderiv i (pderiv k P)) + if k = j then c • pderiv i P else 0 := by |
| rw [(pderiv k).map_smul,pderiv_mul,pderiv_commute P k i] |
| by_cases h : k = j |
| · subst j |
| simp only [pderiv_X_self,one_mul,smul_add,ite_true] |
| exact add_comm _ _ |
| · rw [pderiv_X_of_ne (Ne.symm h)] |
| simp [h] |
|
|
| lemma pderiv_rotation (M : Mat n) (P : PolynomialSpace n) (k : Fin n) : |
| pderiv k (polynomialRotation M P) = polynomialRotation M (pderiv k P)+ |
| ∑ i,M i k • pderiv i P := by |
| simp only [polynomialRotation_apply,map_sum,pderiv_rotation_term,Finset.sum_add_distrib] |
| simp |
|
|
| lemma polynomialLaplacian_apply (P : PolynomialSpace n) : |
| polynomialLaplacian P = ∑ i : Fin n,pderiv i (pderiv i P) := by |
| simp [polynomialLaplacian] |
|
|
| lemma laplacian_rotation (M : Mat n) (P : PolynomialSpace n) : |
| polynomialLaplacian (polynomialRotation M P) = |
| polynomialRotation M (polynomialLaplacian P)+ |
| (2 : ℝ) • (∑ k : Fin n,∑ i : Fin n,M i k • pderiv k (pderiv i P)) := by |
| simp only [polynomialLaplacian_apply,pderiv_rotation,map_add,map_sum, |
| Derivation.map_smul,Finset.sum_add_distrib] |
| have hcomm : (∑ k : Fin n,∑ i : Fin n,M i k • pderiv i (pderiv k P)) = |
| ∑ k : Fin n,∑ i : Fin n,M i k • pderiv k (pderiv i P) := by |
| apply Finset.sum_congr rfl |
| intro k _ |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [pderiv_commute P i k] |
| rw [hcomm] |
| module |
|
|
| lemma laplacian_rotation_skew (M : Mat n) (hM : ∀ i j,M i j = -M j i) |
| (P : PolynomialSpace n) : |
| polynomialLaplacian (polynomialRotation M P) = polynomialRotation M (polynomialLaplacian P) := by |
| have hs : (∑ k : Fin n,∑ i : Fin n,M i k • pderiv k (pderiv i P)) = 0 := by |
| let S := ∑ k : Fin n,∑ i : Fin n,M i k • pderiv k (pderiv i P) |
| have he : S = -S := by |
| unfold S |
| conv_lhs => rw [Finset.sum_comm] |
| simp only [← Finset.sum_neg_distrib] |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro k _ |
| rw [hM k i,pderiv_commute P i k,neg_smul,neg_neg] |
| have : (2 : ℝ) • S = 0 := by |
| rw [two_smul] |
| exact eq_neg_iff_add_eq_zero.1 he |
| exact (smul_eq_zero.1 this).resolve_left (by norm_num) |
| rw [laplacian_rotation,hs,smul_zero,add_zero] |
|
|
| instance harmonicPolynomials_finite (n l : ℕ) : FiniteDimensional ℝ (harmonicPolynomials n l) := by |
| let : FiniteDimensional ℝ (homogeneousSubmodule (Fin n) ℝ l) := |
| Module.Finite.of_fg (homogeneousSubmodule_fg (Fin n) ℝ l) |
| exact Submodule.finiteDimensional_of_le (show harmonicPolynomials n l ≤ |
| homogeneousSubmodule (Fin n) ℝ l from inf_le_left) |
|
|
| def rotation (J : ComplexStructure (Fin n)) (l : ℕ) : |
| harmonicPolynomials n l →ₗ[ℝ] harmonicPolynomials n l where |
| toFun P := ⟨polynomialRotation J.matrix P, polynomialRotation_homogeneous P.property.1 _, by |
| change polynomialLaplacian (polynomialRotation J.matrix (P : PolynomialSpace n)) = 0 |
| rw [laplacian_rotation_skew] |
| · rw [show polynomialLaplacian (P : PolynomialSpace n) = 0 from P.property.2,map_zero] |
| · intro i j |
| exact congrFun (congrFun J.skew j) i⟩ |
| map_add' P Q := Subtype.ext (map_add _ _ _) |
| map_smul' c P := Subtype.ext (map_smul _ _ _) |
|
|
|
|
| end HarmonicCounterexample.Angular |
|
|
| end |
|
|
| noncomputable section |
| open scoped BigOperators InnerProductSpace |
|
|
| namespace HarmonicCounterexample.Angular |
| open MvPolynomial Finsupp |
| variable {n : ℕ} |
|
|
| / |
| def factorialWeight (d : Fin n →₀ ℕ) : ℝ := ∏ i : Fin n, (d i).factorial |
|
|
| lemma factorialWeight_pos (d : Fin n →₀ ℕ) : 0 < factorialWeight d := by |
| apply Finset.prod_pos |
| intro i _ |
| exact_mod_cast Nat.factorial_pos (d i) |
|
|
| lemma factorialWeight_add_single (d : Fin n →₀ ℕ) (i : Fin n) : |
| factorialWeight (d+single i 1) = ((d i:ℝ)+1)*factorialWeight d := by |
| classical |
| unfold factorialWeight |
| rw [← Finset.mul_prod_erase _ _ (Finset.mem_univ i), |
| ← Finset.mul_prod_erase _ (fun j : Fin n => ((d j).factorial:ℝ)) (Finset.mem_univ i)] |
| have he : (∏ j ∈ Finset.univ.erase i, (((d+single i 1 : Fin n →₀ ℕ) j).factorial:ℝ)) = |
| ∏ j ∈ Finset.univ.erase i, ((d j).factorial:ℝ) := by |
| apply Finset.prod_congr rfl |
| intro j hj |
| simp [Ne.symm (Finset.mem_erase.1 hj).1] |
| rw [he] |
| simp only [Finsupp.add_apply,single_eq_same,Nat.factorial_succ,Nat.cast_mul,Nat.cast_add,Nat.cast_one] |
| ring |
|
|
| / |
| def fischer : MvPolynomial (Fin n) ℝ →ₗ[ℝ] MvPolynomial (Fin n) ℝ →ₗ[ℝ] ℝ := |
| (Finsupp.linearCombination ℝ (fun d => factorialWeight d • lcoeff ℝ d)).comp |
| (AddMonoidAlgebra.coeffLinearEquiv ℝ).toLinearMap |
|
|
| lemma fischer_monomial (d : Fin n →₀ ℕ) (c : ℝ) (Q : MvPolynomial (Fin n) ℝ) : |
| fischer (monomial d c) Q = c*factorialWeight d*Q.coeff d := by |
| change (Finsupp.linearCombination ℝ (fun e : Fin n →₀ ℕ => |
| factorialWeight e • lcoeff ℝ e) (single d c)) Q = _ |
| rw [Finsupp.linearCombination_single] |
| change c*(factorialWeight d*Q.coeff d) = _ |
| ring |
|
|
| lemma fischer_apply (P Q : MvPolynomial (Fin n) ℝ) : |
| fischer P Q = ∑ d ∈ P.support, P.coeff d*factorialWeight d*Q.coeff d := by |
| conv_lhs => rw [P.as_sum] |
| simp only [map_sum,LinearMap.sum_apply,fischer_monomial] |
|
|
| lemma fischer_symm (P Q : MvPolynomial (Fin n) ℝ) : fischer P Q = fischer Q P := by |
| induction P using MvPolynomial.induction_on' with |
| | monomial d c => |
| induction Q using MvPolynomial.induction_on' with |
| | monomial e b => |
| simp only [fischer_monomial,coeff_monomial] |
| by_cases h : d = e |
| · subst e; simp only [ite_true]; ring |
| · simp [h,Ne.symm h] |
| | add Q R hq hr => simp only [map_add,LinearMap.add_apply,hq,hr] |
| | add P R hp hr => simp only [map_add,LinearMap.add_apply,hp,hr] |
|
|
| lemma fischer_nonneg (P : MvPolynomial (Fin n) ℝ) : 0 ≤ fischer P P := by |
| rw [fischer_apply] |
| apply Finset.sum_nonneg |
| intro d _ |
| nlinarith [factorialWeight_pos d,sq_nonneg (P.coeff d)] |
|
|
| lemma fischer_definite {P : MvPolynomial (Fin n) ℝ} (h : fischer P P = 0) : P = 0 := by |
| rw [fischer_apply] at h |
| have hh := (Finset.sum_eq_zero_iff_of_nonneg (fun d (_ : d ∈ P.support) => |
| show 0 ≤ P.coeff d*factorialWeight d*P.coeff d by |
| nlinarith [factorialWeight_pos d,sq_nonneg (P.coeff d)])).1 h |
| ext d |
| rw [AddMonoidAlgebra.coeff_zero] |
| by_cases hd : d ∈ P.support |
| · rcases mul_eq_zero.1 (hh d hd) with h | h |
| · exact (mul_eq_zero.1 h).resolve_right (factorialWeight_pos d).ne' |
| · exact h |
| · exact MvPolynomial.notMem_support_iff.1 hd |
|
|
| lemma fischer_mul_X (P Q : MvPolynomial (Fin n) ℝ) (i : Fin n) : |
| fischer (P*X i) Q = fischer P (pderiv i Q) := by |
| induction P using MvPolynomial.induction_on' with |
| | monomial d c => |
| rw [← pow_one (X i),← monomial_add_single,fischer_monomial,fischer_monomial, |
| coeff_pderiv,factorialWeight_add_single] |
| ring |
| | add P R hp hr => simp only [add_mul,map_add,LinearMap.add_apply,hp,hr] |
|
|
| lemma fischer_pderiv (P Q : MvPolynomial (Fin n) ℝ) (i : Fin n) : |
| fischer (pderiv i P) Q = fischer P (Q*X i) := by |
| calc |
| _ = fischer Q (pderiv i P) := fischer_symm _ _ |
| _ = fischer (Q*X i) P := (fischer_mul_X Q P i).symm |
| _ = _ := fischer_symm _ _ |
|
|
| / |
| round-space inner product. Its restriction is rotation invariant. -/ |
| @[instance_reducible] |
| def fischerCore (n : ℕ) : InnerProductSpace.Core ℝ (MvPolynomial (Fin n) ℝ) where |
| inner := fun P Q => fischer P Q |
| conj_inner_symm P Q := by simpa only [conj_trivial] using fischer_symm Q P |
| re_inner_nonneg P := fischer_nonneg P |
| add_left P Q R := by simp only [map_add,LinearMap.add_apply] |
| smul_left P Q c := by simp only [map_smul,LinearMap.smul_apply,smul_eq_mul,conj_trivial] |
| definite := fun _ h => fischer_definite h |
|
|
| end HarmonicCounterexample.Angular |
|
|
| end |
|
|
| noncomputable section |
| open scoped BigOperators InnerProductSpace |
|
|
| namespace HarmonicCounterexample.Angular |
| open MvPolynomial Finsupp |
| variable {n : ℕ} |
|
|
| instance homogeneous_finite (n l : ℕ) : FiniteDimensional ℝ (homogeneousSubmodule (Fin n) ℝ l) := |
| Module.Finite.of_fg (homogeneousSubmodule_fg (Fin n) ℝ l) |
|
|
| lemma degree_eq_univ_sum (d : Fin n →₀ ℕ) : d.degree = ∑ i : Fin n,d i := |
| Finsupp.sum_fintype d (fun _ a => a) fun _ => rfl |
|
|
| lemma homogeneous_finrank (n l : ℕ) : |
| Module.finrank ℝ (homogeneousSubmodule (Fin n) ℝ l) = (n+l-1).choose l := by |
| classical |
| rw [homogeneousSubmodule_eq_finsupp_supported] |
| have he : {d : Fin n →₀ ℕ | d.degree = l} = |
| (↑((Finset.univ : Finset (Fin n)).finsuppAntidiag l) : Set (Fin n →₀ ℕ)) := by |
| ext d |
| simp [Finset.mem_finsuppAntidiag,degree_eq_univ_sum] |
| rw [he,(AddMonoidAlgebra.supportedEquivFinsupp |
| (R := ℝ) (S := ℝ) (↑((Finset.univ : Finset (Fin n)).finsuppAntidiag l) : Set (Fin n →₀ ℕ))).finrank_eq] |
| simp only [Finset.coe_sort_coe,Module.finrank_finsupp,Module.finrank_self,mul_one, |
| Fintype.card_coe,Finset.card_finsuppAntidiag_nat_eq_choose,Finset.card_univ,Fintype.card_fin] |
|
|
| / |
| def subFischer (U : Submodule ℝ (MvPolynomial (Fin n) ℝ)) : U →ₗ[ℝ] Module.Dual ℝ U := |
| U.subtype.dualMap.comp (fischer.comp U.subtype) |
|
|
| lemma subFischer_apply (U : Submodule ℝ (MvPolynomial (Fin n) ℝ)) (P Q : U) : |
| subFischer U P Q = fischer (P : MvPolynomial (Fin n) ℝ) (Q : MvPolynomial (Fin n) ℝ) := rfl |
|
|
| lemma subFischer_injective (U : Submodule ℝ (MvPolynomial (Fin n) ℝ)) : |
| Function.Injective (subFischer U) := by |
| apply LinearMap.ker_eq_bot.mp |
| rw [LinearMap.ker_eq_bot'] |
| intro P hP |
| apply Subtype.ext |
| apply fischer_definite |
| exact congrArg (fun f : Module.Dual ℝ U => f P) hP |
|
|
| lemma subFischer_surjective (U : Submodule ℝ (MvPolynomial (Fin n) ℝ)) [FiniteDimensional ℝ U] : |
| Function.Surjective (subFischer U) := |
| (LinearMap.injective_iff_surjective_of_finrank_eq_finrank |
| (Subspace.dual_finrank_eq (K := ℝ) (V := U)).symm).1 (subFischer_injective U) |
|
|
| / |
| def quadraticRadius (n : ℕ) : MvPolynomial (Fin n) ℝ := ∑ i : Fin n,X i^2 |
|
|
| lemma quadraticRadius_homogeneous (n : ℕ) : (quadraticRadius n).IsHomogeneous 2 := by |
| apply IsHomogeneous.sum |
| intro i _ |
| simpa only [one_mul] using (isHomogeneous_X ℝ i).pow 2 |
|
|
| lemma quadraticRadius_ne_zero (hn : 0 < n) : quadraticRadius n ≠ 0 := by |
| intro h |
| have he := congrArg (MvPolynomial.eval (fun _ : Fin n => (1:ℝ))) h |
| have : (n:ℝ) = 0 := by simpa [quadraticRadius] using he |
| exact (Nat.cast_ne_zero.2 hn.ne') this |
|
|
| lemma fischer_radius_laplacian (P Q : MvPolynomial (Fin n) ℝ) : |
| fischer (quadraticRadius n*P) Q = fischer P (∑ i : Fin n,pderiv i (pderiv i Q)) := by |
| simp only [quadraticRadius,Finset.sum_mul,map_sum,LinearMap.sum_apply] |
| apply Finset.sum_congr rfl |
| intro i _ |
| have he : X i^2*P = (P*X i)*X i := by ring |
| rw [he,fischer_mul_X,fischer_mul_X] |
|
|
| / |
| def radiusMultiply (n l : ℕ) : homogeneousSubmodule (Fin n) ℝ l →ₗ[ℝ] |
| homogeneousSubmodule (Fin n) ℝ (l+2) where |
| toFun P := ⟨quadraticRadius n*P, by |
| change (quadraticRadius n * (P : MvPolynomial (Fin n) ℝ)).IsHomogeneous (l+2) |
| have h := (quadraticRadius_homogeneous n).mul P.property |
| simpa only [Nat.add_comm 2 l] using h⟩ |
| map_add' P Q := Subtype.ext (mul_add _ _ _) |
| map_smul' c P := Subtype.ext (mul_smul_comm _ _ _) |
|
|
| lemma radiusMultiply_injective (hn : 0 < n) (l : ℕ) : |
| Function.Injective (radiusMultiply n l) := by |
| intro P Q h |
| apply Subtype.ext |
| exact mul_left_cancel₀ (quadraticRadius_ne_zero hn) (congrArg Subtype.val h) |
|
|
| / |
| def homogeneousLaplacian (n l : ℕ) : homogeneousSubmodule (Fin n) ℝ (l+2) →ₗ[ℝ] |
| homogeneousSubmodule (Fin n) ℝ l where |
| toFun P := ⟨∑ i : Fin n,pderiv i (pderiv i (P : MvPolynomial (Fin n) ℝ)), by |
| apply IsHomogeneous.sum |
| intro i _ |
| have h := (P.property.pderiv (i := i)).pderiv (i := i) |
| simpa only [show l+2-1-1 = l from by omega] using h⟩ |
| map_add' P Q := by apply Subtype.ext; simp only [Submodule.coe_add,map_add,Finset.sum_add_distrib] |
| map_smul' c P := by |
| apply Subtype.ext |
| simp only [Submodule.coe_smul,Derivation.map_smul,Finset.smul_sum,RingHom.id_apply] |
|
|
| / |
| injective radius multiplication and positive Fischer duality. -/ |
| lemma homogeneousLaplacian_surjective (hn : 0 < n) (l : ℕ) : |
| Function.Surjective (homogeneousLaplacian n l) := by |
| intro Q |
| obtain ⟨φ,hφ⟩ := LinearMap.dualMap_surjective_of_injective (radiusMultiply_injective hn l) |
| (subFischer (homogeneousSubmodule (Fin n) ℝ l) Q) |
| obtain ⟨P,hP⟩ := subFischer_surjective (homogeneousSubmodule (Fin n) ℝ (l+2)) φ |
| refine ⟨P,subFischer_injective (homogeneousSubmodule (Fin n) ℝ l) ?_⟩ |
| ext R |
| have h := congrArg (fun f : Module.Dual ℝ (homogeneousSubmodule (Fin n) ℝ l) => f R) hφ |
| rw [← hP] at h |
| change fischer (P : MvPolynomial (Fin n) ℝ) (quadraticRadius n*R) = fischer (Q: MvPolynomial (Fin n) ℝ) R at h |
| change fischer (∑ i : Fin n,pderiv i (pderiv i (P : MvPolynomial (Fin n) ℝ))) R = _ |
| rw [fischer_symm,← fischer_radius_laplacian,fischer_symm] |
| exact h |
|
|
| end HarmonicCounterexample.Angular |
|
|
| end |
|
|
| noncomputable section |
| open scoped BigOperators InnerProductSpace |
|
|
| namespace HarmonicCounterexample.Angular |
| open MvPolynomial |
| variable {n : ℕ} |
|
|
| / |
| def harmonicKernelEquiv (n l : ℕ) : LinearMap.ker (homogeneousLaplacian n l) ≃ₗ[ℝ] |
| harmonicPolynomials n (l+2) where |
| toFun P := ⟨P.val.val, ⟨P.val.property, by |
| change polynomialLaplacian P.val.val = 0 |
| have h := congrArg Subtype.val P.property |
| rw [polynomialLaplacian_apply] |
| exact h⟩⟩ |
| invFun P := ⟨⟨P.val,P.property.1⟩, by |
| apply Subtype.ext |
| change (∑ i : Fin n,pderiv i (pderiv i P.val)) = 0 |
| have h : polynomialLaplacian P.val = 0 := P.property.2 |
| simpa only [polynomialLaplacian_apply] using h⟩ |
| left_inv P := rfl |
| right_inv P := rfl |
| map_add' P Q := rfl |
| map_smul' c P := rfl |
|
|
| lemma harmonic_finrank_add (hn : 0 < n) (l : ℕ) : |
| Module.finrank ℝ (harmonicPolynomials n (l+2)) + (n+l-1).choose l = |
| (n+l+1).choose (l+2) := by |
| have h := LinearMap.finrank_range_add_finrank_ker (homogeneousLaplacian n l) |
| rw [LinearMap.range_eq_top.2 (homogeneousLaplacian_surjective hn l), |
| finrank_top,(harmonicKernelEquiv n l).finrank_eq,homogeneous_finrank] at h |
| rw [homogeneous_finrank] at h |
| simpa only [show n+(l+2)-1 = n+l+1 from by omega, Nat.add_comm] using h |
|
|
| lemma harmonic_finrank_succ_succ (hn : 0 < n) (l : ℕ) : |
| Module.finrank ℝ (harmonicPolynomials n (l+2)) = |
| (n+l+1).choose (l+2) - (n+l-1).choose l := by |
| have h := harmonic_finrank_add hn l |
| omega |
|
|
| / |
| itself a multiple of the squared radius. -/ |
| lemma harmonic_radius_multiple_zero (P Q : PolynomialSpace n) |
| (hP : polynomialLaplacian P = 0) (hQ : P = quadraticRadius n*Q) : P = 0 := by |
| apply fischer_definite |
| calc |
| fischer P P = fischer (quadraticRadius n*Q) P := congrArg (fun R => fischer R P) hQ |
| _ = fischer Q (polynomialLaplacian P) := by |
| rw [polynomialLaplacian_apply,fischer_radius_laplacian] |
| _ = 0 := by rw [hP,map_zero] |
|
|
| end HarmonicCounterexample.Angular |
|
|
| end |
|
|
| noncomputable section |
| open scoped BigOperators InnerProductSpace |
|
|
| namespace HarmonicCounterexample.Angular |
| open MvPolynomial |
| variable {n : ℕ} |
|
|
| lemma pderiv_homogeneous_zero {P : PolynomialSpace n} (hP : P.IsHomogeneous 0) (i : Fin n) : |
| pderiv i P = 0 := by |
| have hc := totalDegree_eq_zero_iff_eq_C.1 ((totalDegree_zero_iff_isHomogeneous (Fin n)).2 hP) |
| rw [hc,pderiv_C] |
|
|
| lemma polynomialLaplacian_low {P : PolynomialSpace n} {l : ℕ} |
| (hP : P.IsHomogeneous l) (hl : l ≤ 1) : polynomialLaplacian P = 0 := by |
| rw [polynomialLaplacian_apply] |
| apply Finset.sum_eq_zero |
| intro i _ |
| exact pderiv_homogeneous_zero (by simpa only [show l-1 = 0 from by omega] using hP.pderiv (i := i)) i |
|
|
| lemma harmonicPolynomials_low (n l : ℕ) (hl : l ≤ 1) : |
| harmonicPolynomials n l = homogeneousSubmodule (Fin n) ℝ l := by |
| apply le_antisymm |
| · exact inf_le_left |
| · intro P hP |
| exact ⟨hP,polynomialLaplacian_low hP hl⟩ |
|
|
| lemma harmonic_finrank_zero (n : ℕ) : Module.finrank ℝ (harmonicPolynomials n 0) = 1 := by |
| rw [harmonicPolynomials_low n 0 (by omega),homogeneous_finrank] |
| exact Nat.choose_zero_right _ |
|
|
| lemma harmonic_finrank_one (n : ℕ) : Module.finrank ℝ (harmonicPolynomials n 1) = n := by |
| rw [harmonicPolynomials_low n 1 (by omega),homogeneous_finrank] |
| simp |
|
|
| / |
| lemma homogeneous_components_independent {ι : Type*} [Fintype ι] (d : ι → ℕ) |
| (hd : Function.Injective d) (P : ι → PolynomialSpace n) |
| (hP : ∀ i,(P i).IsHomogeneous (d i)) (hz : ∑ i,P i = 0) : ∀ i,P i = 0 := by |
| classical |
| intro i |
| have h := congrArg (homogeneousComponent (d i)) hz |
| simp only [map_sum,map_zero] at h |
| have he (j : ι) : homogeneousComponent (d i) (P j) = if i = j then P j else 0 := by |
| simp only [homogeneousComponent_of_mem (hP j),hd.eq_iff] |
| simp only [he,Finset.sum_ite_eq,Finset.mem_univ,ite_true] at h |
| exact h |
|
|
| end HarmonicCounterexample.Angular |
|
|
| end |
|
|
| noncomputable section |
| open scoped BigOperators InnerProductSpace |
|
|
| namespace HarmonicCounterexample.Angular |
| open MvPolynomial |
|
|
|
|
|
|
| lemma sum_harmonic_finrank (n : ℕ) (hn : 0 < n) (k : ℕ) : |
| (∑ l ∈ Finset.range (k+2),Module.finrank ℝ (harmonicPolynomials n l)) = |
| (n+k).choose (k+1) + (n+k-1).choose k := by |
| induction k with |
| | zero => |
| simp only [Finset.sum_range_succ,Finset.sum_range_zero,zero_add] |
| rw [harmonic_finrank_zero,harmonic_finrank_one] |
| simp only [Nat.add_zero,Nat.choose_one_right,Nat.choose_zero_right] |
| omega |
| | succ k ih => |
| rw [show k+1+2 = (k+2)+1 from by omega,Finset.sum_range_succ,ih] |
| have h := harmonic_finrank_add hn k |
| have he : n+(k+1) = n+k+1 := by omega |
| have hf : n+k+1-1 = n+k := by omega |
| rw [he,hf] |
| change (n+k).choose (k+1) + (n+k-1).choose k + |
| Module.finrank ℝ (harmonicPolynomials n (k+2)) = |
| (n+k+1).choose (k+2) + (n+k).choose (k+1) |
| omega |
|
|
| end HarmonicCounterexample.Angular |
|
|
| end |
|
|
| noncomputable section |
| open scoped BigOperators InnerProductSpace |
|
|
| namespace HarmonicCounterexample.Angular |
| open MvPolynomial Matrix |
| variable {n : ℕ} |
|
|
| / |
| lemma fischer_rotation (M : Mat n) (P Q : PolynomialSpace n) : |
| fischer (polynomialRotation M P) Q = fischer P (polynomialRotation M.transpose Q) := by |
| simp only [polynomialRotation_apply,map_sum,LinearMap.sum_apply,map_smul,LinearMap.smul_apply, |
| smul_eq_mul,Matrix.transpose_apply] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro j _ |
| apply Finset.sum_congr rfl |
| intro i _ |
| congr 1 |
| rw [mul_comm (X j),fischer_mul_X,fischer_pderiv,mul_comm _ (X i)] |
|
|
| lemma polynomialRotation_transpose_skew (M : Mat n) (hM : ∀ i j,M i j = -M j i) |
| (P : PolynomialSpace n) : polynomialRotation M.transpose P = -polynomialRotation M P := by |
| simp only [polynomialRotation_apply,Matrix.transpose_apply,← Finset.sum_neg_distrib] |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| rw [hM j i,neg_smul] |
|
|
| lemma fischer_rotation_skew (M : Mat n) (hM : ∀ i j,M i j = -M j i) |
| (P Q : PolynomialSpace n) : |
| fischer (polynomialRotation M P) Q = -fischer P (polynomialRotation M Q) := by |
| rw [fischer_rotation,polynomialRotation_transpose_skew M hM,map_neg] |
|
|
| / |
| any assumed angular norm or a topological completion of the polynomial module. -/ |
| lemma fischer_family_cauchy {ι : Type*} [Fintype ι] |
| (P Q : ι → PolynomialSpace n) : |
| (∑ i,fischer (P i) (Q i))^2 ≤ |
| (∑ i,fischer (P i) (P i))*(∑ i,fischer (Q i) (Q i)) := by |
| have hp (t : ℝ) : 0 ≤ (∑ i,fischer (P i) (P i))*t^2+ |
| (2*(∑ i,fischer (P i) (Q i)))*t+(∑ i,fischer (Q i) (Q i)) := by |
| have h := Finset.sum_nonneg (s := Finset.univ) (fun i _ => fischer_nonneg (t • P i+Q i)) |
| simp only [map_add,LinearMap.add_apply,map_smul,LinearMap.smul_apply,smul_eq_mul] at h |
| have he : (∑ i,fischer (Q i) (P i)) = ∑ i,fischer (P i) (Q i) := by |
| apply Finset.sum_congr rfl |
| intro i _ |
| exact fischer_symm _ _ |
| simp only [Finset.sum_add_distrib,← Finset.mul_sum] at h |
| rw [he] at h |
| nlinarith |
| have h := discrim_le_zero (fun t => by simpa only [sq] using hp t) |
| unfold discrim at h |
| nlinarith |
|
|
| lemma fischer_gradient_energy {l : ℕ} {P : PolynomialSpace n} (hP : P.IsHomogeneous l) : |
| (∑ i : Fin n,fischer (pderiv i P) (pderiv i P)) = (l:ℝ)*fischer P P := by |
| calc |
| _ = fischer P (∑ i : Fin n,X i*pderiv i P) := by |
| simp only [map_sum] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [fischer_pderiv,mul_comm] |
| _ = _ := by |
| rw [hP.sum_X_mul_pderiv] |
| rw [map_nsmul] |
| simp only [nsmul_eq_mul] |
|
|
| / |
| lemma fischer_gradient_orthogonal (M : Mat n) |
| (hM : ∀ i k, (∑ j : Fin n,M i j*M k j) = if i = k then 1 else 0) |
| (P : PolynomialSpace n) : |
| (∑ j : Fin n,fischer (∑ i : Fin n,M i j • pderiv i P) |
| (∑ k : Fin n,M k j • pderiv k P)) = |
| ∑ i : Fin n,fischer (pderiv i P) (pderiv i P) := by |
| simp only [map_sum,LinearMap.sum_apply,map_smul,LinearMap.smul_apply,smul_eq_mul,Finset.mul_sum] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [Finset.sum_comm] |
| have he (k : Fin n) : |
| (∑ j : Fin n,M i j*(M k j*fischer (pderiv k P) (pderiv i P))) = |
| (if i = k then 1 else 0)*fischer (pderiv k P) (pderiv i P) := by |
| rw [← hM i k,Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro j _ |
| ring |
| simp only [he,ite_mul,one_mul,zero_mul] |
| simp only [Finset.sum_ite_eq,Finset.mem_univ,ite_true] |
|
|
| end HarmonicCounterexample.Angular |
|
|
| end |
|
|
| noncomputable section |
| open scoped BigOperators InnerProductSpace |
|
|
| namespace HarmonicCounterexample.Angular |
| open MvPolynomial Matrix |
| variable {n : ℕ} |
|
|
| lemma polynomialRotation_gradient (M : Mat n) (P : PolynomialSpace n) : |
| polynomialRotation M P = ∑ j : Fin n,X j*(∑ i : Fin n,M i j • pderiv i P) := by |
| rw [polynomialRotation_apply,Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro j _ |
| simp only [Finset.mul_sum,mul_smul_comm] |
|
|
| / |
| Fischer duality, Euler's identity, and Cauchy |
| lemma fischer_rotation_bound (M : Mat n) |
| (hM : ∀ i k, (∑ j : Fin n,M i j*M k j) = if i = k then 1 else 0) |
| {P : PolynomialSpace n} {l : ℕ} (hP : P.IsHomogeneous l) : |
| fischer (polynomialRotation M P) (polynomialRotation M P) ≤ |
| (l:ℝ)^2*fischer P P := by |
| let R : Fin n → PolynomialSpace n := fun j => ∑ i : Fin n,M i j • pderiv i P |
| have he : fischer (polynomialRotation M P) (polynomialRotation M P) = |
| ∑ j : Fin n,fischer (R j) (pderiv j (polynomialRotation M P)) := by |
| conv_lhs => arg 1; rw [polynomialRotation_gradient] |
| simp only [map_sum,LinearMap.sum_apply] |
| apply Finset.sum_congr rfl |
| intro j _ |
| rw [mul_comm (X j),fischer_mul_X] |
| have hR : (∑ j : Fin n,fischer (R j) (R j)) = (l:ℝ)*fischer P P := |
| (fischer_gradient_orthogonal M hM P).trans (fischer_gradient_energy hP) |
| have hS := fischer_gradient_energy (polynomialRotation_homogeneous hP M) |
| have hc := fischer_family_cauchy R (fun j => pderiv j (polynomialRotation M P)) |
| rw [← he,hR,hS] at hc |
| have hn := fischer_nonneg (polynomialRotation M P) |
| by_cases hz : fischer (polynomialRotation M P) (polynomialRotation M P) = 0 |
| · rw [hz] |
| exact mul_nonneg (sq_nonneg _) (fischer_nonneg P) |
| · have hp := lt_of_le_of_ne hn (Ne.symm hz) |
| apply le_of_mul_le_mul_right (b := fischer (polynomialRotation M P) (polynomialRotation M P)) _ hp |
| nlinarith |
|
|
| lemma fischer_square_rotation_nonpos (M : Mat n) (hM : ∀ i j,M i j = -M j i) |
| (P : PolynomialSpace n) : |
| fischer P (polynomialRotation M (polynomialRotation M P)) ≤ 0 := by |
| have h := fischer_nonneg (polynomialRotation M P) |
| rw [fischer_rotation_skew M hM] at h |
| linarith |
|
|
| lemma fischer_square_rotation_lower (M : Mat n) (hSkew : ∀ i j,M i j = -M j i) |
| (hOrth : ∀ i k, (∑ j : Fin n,M i j*M k j) = if i = k then 1 else 0) |
| {P : PolynomialSpace n} {l : ℕ} (hP : P.IsHomogeneous l) : |
| -(l:ℝ)^2*fischer P P ≤ fischer P (polynomialRotation M (polynomialRotation M P)) := by |
| have h := fischer_rotation_bound M hOrth hP |
| rw [fischer_rotation_skew M hSkew] at h |
| linarith |
|
|
| end HarmonicCounterexample.Angular |
|
|
| end |
|
|
| noncomputable section |
| open scoped BigOperators InnerProductSpace |
|
|
| namespace HarmonicCounterexample.Angular |
| open MvPolynomial Matrix Berger |
| variable {n : ℕ} |
|
|
| @[reducible] instance polynomialNormedAddCommGroup (n : ℕ) : NormedAddCommGroup (PolynomialSpace n) := |
| InnerProductSpace.Core.toNormedAddCommGroup (cd := fischerCore n) |
|
|
| / |
| of the Fischer norm; the underlying polynomial algebra is unchanged. -/ |
| @[reducible] instance polynomialUniformSpace (n : ℕ) : UniformSpace (PolynomialSpace n) := |
| (polynomialNormedAddCommGroup n).toMetricSpace.toUniformSpace |
|
|
| @[reducible] instance polynomialTopologicalSpace (n : ℕ) : TopologicalSpace (PolynomialSpace n) := |
| (polynomialUniformSpace n).toTopologicalSpace |
|
|
| @[reducible] instance polynomialInnerProductSpace (n : ℕ) : InnerProductSpace ℝ (PolynomialSpace n) := |
| InnerProductSpace.ofCore (fischerCore n).toCore |
|
|
| @[reducible] instance harmonicNormedAddCommGroup (n l : ℕ) : NormedAddCommGroup (harmonicPolynomials n l) := |
| Submodule.normedAddCommGroup _ |
| @[reducible] instance harmonicSeminormedAddCommGroup (n l : ℕ) : SeminormedAddCommGroup (harmonicPolynomials n l) := |
| (harmonicNormedAddCommGroup n l).toSeminormedAddCommGroup |
| @[reducible] instance harmonicTopologicalSpace (n l : ℕ) : TopologicalSpace (harmonicPolynomials n l) := |
| (harmonicNormedAddCommGroup n l).toMetricSpace.toUniformSpace.toTopologicalSpace |
| @[reducible] instance harmonicUniformSpace (n l : ℕ) : UniformSpace (harmonicPolynomials n l) := |
| (harmonicNormedAddCommGroup n l).toMetricSpace.toUniformSpace |
| @[reducible] instance harmonicInnerProductSpace (n l : ℕ) : InnerProductSpace ℝ (harmonicPolynomials n l) := |
| Submodule.innerProductSpace _ |
|
|
| instance harmonicOperatorNormSMulClass (n l : ℕ) : |
| NormSMulClass ℝ (harmonicPolynomials n l →L[ℝ] harmonicPolynomials n l) := |
| @NormedSpace.toNormSMulClass ℝ (harmonicPolynomials n l →L[ℝ] harmonicPolynomials n l) _ _ _ |
|
|
|
|
| lemma polynomial_inner (P Q : PolynomialSpace n) : ⟪P,Q⟫_ℝ = fischer P Q := rfl |
|
|
| lemma harmonic_inner {l : ℕ} (P Q : harmonicPolynomials n l) : |
| ⟪P,Q⟫_ℝ = fischer (P : PolynomialSpace n) (Q : PolynomialSpace n) := rfl |
|
|
| / |
| def rotationCLM (J : ComplexStructure (Fin n)) (l : ℕ) : |
| harmonicPolynomials n l →L[ℝ] harmonicPolynomials n l := |
| LinearMap.toContinuousLinearMap (rotation J l) |
|
|
| lemma rotationCLM_inner_skew (J : ComplexStructure (Fin n)) (l : ℕ) |
| (P Q : harmonicPolynomials n l) : |
| ⟪rotationCLM J l P,Q⟫_ℝ = -⟪P,rotationCLM J l Q⟫_ℝ := by |
| exact fischer_rotation_skew J.matrix (fun i j => congrFun (congrFun J.skew j) i) _ _ |
|
|
| lemma complexStructure_rows (J : ComplexStructure (Fin n)) (i k : Fin n) : |
| (∑ j : Fin n,J.matrix i j*J.matrix k j) = if i = k then 1 else 0 := by |
| have hm : J.matrix * J.matrix.transpose = 1 := by |
| rw [J.skew,mul_neg,J.square,neg_neg] |
| have h := congrFun (congrFun hm i) k |
| simpa only [Matrix.mul_apply,Matrix.transpose_apply,Matrix.one_apply] using h |
|
|
| lemma rotationCLM_norm_le (J : ComplexStructure (Fin n)) (l : ℕ) |
| (P : harmonicPolynomials n l) : ‖rotationCLM J l P‖ ≤ (l:ℝ)*‖P‖ := by |
| have h := fischer_rotation_bound J.matrix (complexStructure_rows J) P.property.1 |
| change ⟪rotationCLM J l P,rotationCLM J l P⟫_ℝ ≤ (l:ℝ)^2*⟪P,P⟫_ℝ at h |
| rw [real_inner_self_eq_norm_sq,real_inner_self_eq_norm_sq] at h |
| apply nonneg_le_nonneg_of_sq_le_sq (mul_nonneg (Nat.cast_nonneg l) (norm_nonneg P)) |
| nlinarith |
|
|
| lemma rotationCLM_opNorm_le (J : ComplexStructure (Fin n)) (l : ℕ) : |
| ‖rotationCLM J l‖ ≤ l := |
| ContinuousLinearMap.opNorm_le_bound _ (Nat.cast_nonneg l) (rotationCLM_norm_le J l) |
|
|
| lemma rotationCLM_square_symmetric (J : ComplexStructure (Fin n)) (l : ℕ) : |
| (rotationCLM J l*rotationCLM J l).IsSymmetric := by |
| intro P Q |
| change ⟪rotationCLM J l (rotationCLM J l P),Q⟫_ℝ = |
| ⟪P,rotationCLM J l (rotationCLM J l Q)⟫_ℝ |
| rw [rotationCLM_inner_skew,rotationCLM_inner_skew,neg_neg] |
|
|
| lemma rotationCLM_square_nonpos (J : ComplexStructure (Fin n)) (l : ℕ) |
| (P : harmonicPolynomials n l) : ⟪P,(rotationCLM J l*rotationCLM J l) P⟫_ℝ ≤ 0 := by |
| exact fischer_square_rotation_nonpos J.matrix |
| (fun i j => congrFun (congrFun J.skew j) i) _ |
|
|
| lemma rotationCLM_square_lower (J : ComplexStructure (Fin n)) (l : ℕ) |
| (P : harmonicPolynomials n l) : |
| -(l:ℝ)^2*‖P‖^2 ≤ ⟪P,(rotationCLM J l*rotationCLM J l) P⟫_ℝ := by |
| have h := fischer_square_rotation_lower J.matrix |
| (fun i j => congrFun (congrFun J.skew j) i) (complexStructure_rows J) P.property.1 |
| change -(l:ℝ)^2*⟪P,P⟫_ℝ ≤ ⟪P,(rotationCLM J l*rotationCLM J l) P⟫_ℝ at h |
| simpa only [real_inner_self_eq_norm_sq] using h |
|
|
| end HarmonicCounterexample.Angular |
|
|
| end |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace HarmonicCounterexample.Control |
| open MvPolynomial Matrix |
| variable {𝕜 ι : Type*} [Field 𝕜] [Fintype ι] [DecidableEq ι] |
|
|
| def directionalPolynomial (M : Matrix ι ι 𝕜) (i : ι) : |
| MvPolynomial ι 𝕜 →ₗ[𝕜] MvPolynomial ι 𝕜 := |
| ∑ j : ι,M j i • (pderiv j).toLinearMap |
|
|
| omit [DecidableEq ι] in |
| lemma directionalPolynomial_apply (M : Matrix ι ι 𝕜) (i : ι) (P : MvPolynomial ι 𝕜) : |
| directionalPolynomial M i P=∑ j : ι,M j i • pderiv j P := by |
| simp [directionalPolynomial] |
|
|
| omit [DecidableEq ι] in |
| lemma directionalPolynomial_mul (M : Matrix ι ι 𝕜) (i : ι) (P Q : MvPolynomial ι 𝕜) : |
| directionalPolynomial M i (P*Q)= |
| directionalPolynomial M i P*Q+P*directionalPolynomial M i Q := by |
| simp only [directionalPolynomial_apply,pderiv_mul,smul_add,Finset.sum_add_distrib, |
| smul_mul_assoc,mul_smul_comm,Finset.sum_mul,Finset.mul_sum] |
|
|
| lemma pderiv_linearChange (M : Matrix ι ι 𝕜) (i : ι) (P : MvPolynomial ι 𝕜) : |
| pderiv i (linearChange M P)=linearChange M (directionalPolynomial M i P) := by |
| induction P using MvPolynomial.induction_on with |
| | C c => simp [linearChange,directionalPolynomial_apply] |
| | add P Q hp hq => simp only [map_add,hp,hq] |
| | mul_X P j hp => |
| rw [map_mul,pderiv_mul,directionalPolynomial_mul,map_add,map_mul,map_mul,← hp] |
| congr 1 |
| congr 1 |
| simp only [linearChange_X,map_sum,Derivation.map_smul,pderiv_X] |
| simp [directionalPolynomial_apply,linearChange,Pi.single_apply] |
|
|
| def ordinaryLaplacian : MvPolynomial ι 𝕜 →ₗ[𝕜] MvPolynomial ι 𝕜 := |
| ∑ i : ι,(pderiv i).toLinearMap.comp (pderiv i).toLinearMap |
|
|
| omit [DecidableEq ι] in |
| lemma ordinaryLaplacian_apply (P : MvPolynomial ι 𝕜) : |
| ordinaryLaplacian P=∑ i : ι,pderiv i (pderiv i P) := by simp [ordinaryLaplacian] |
|
|
| lemma ordinaryLaplacian_linearChange (M : Matrix ι ι 𝕜) (P : MvPolynomial ι 𝕜) : |
| ordinaryLaplacian (linearChange M P)= |
| linearChange M (∑ j : ι,∑ k : ι,(M*M.transpose) j k • pderiv j (pderiv k P)) := by |
| simp only [ordinaryLaplacian_apply,pderiv_linearChange] |
| rw [← map_sum] |
| congr 1 |
| simp only [directionalPolynomial_apply,map_sum,Derivation.map_smul, |
| smul_smul,Matrix.mul_apply,Matrix.transpose_apply,Finset.sum_smul] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro j _ |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro k _ |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [mul_comm,pderiv_commutes] |
|
|
| omit [DecidableEq ι] in |
| lemma ordinaryLaplacian_rename {τ : Type*} [Fintype τ] (e : ι ≃ τ) |
| (P : MvPolynomial ι 𝕜) : |
| ordinaryLaplacian (rename e P)=rename e (ordinaryLaplacian P) := by |
| classical |
| simp only [ordinaryLaplacian_apply,map_sum] |
| rw [← e.sum_comp] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [pderiv_rename e.injective,pderiv_rename e.injective] |
|
|
| omit [DecidableEq ι] in |
| lemma ordinaryLaplacian_map {𝕜' : Type*} [Field 𝕜'] (f : 𝕜 →+* 𝕜') |
| (P : MvPolynomial ι 𝕜) : ordinaryLaplacian (MvPolynomial.map f P)= |
| MvPolynomial.map f (ordinaryLaplacian P) := by |
| simp only [ordinaryLaplacian_apply,map_sum,pderiv_map] |
|
|
| end HarmonicCounterexample.Control |
|
|
| end |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace HarmonicCounterexample.Berger.ComplexStructure |
| open Matrix |
| lemma splitChange_gram (s : ℕ) : |
| splitChange s*(splitChange s).transpose=fromBlocks 0 (2 : Matrix (Fin s) (Fin s) ℂ) 2 0 := by |
| simp only [splitChange,fromBlocks_transpose,transpose_one,transpose_smul,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 <;> simp [Matrix.fromBlocks,Matrix.ofNat_apply,hab] <;> norm_num |
| end HarmonicCounterexample.Berger.ComplexStructure |
|
|
| end |
|
|
| noncomputable section |
| open scoped BigOperators |
|
|
| namespace HarmonicCounterexample.Control |
| open MvPolynomial Matrix HarmonicCounterexample.Berger.ComplexStructure |
| open HarmonicCounterexample.ComplexAngular |
|
|
| lemma ordinaryLaplacian_split (s : ℕ) (P : SplitPolynomial (Fin s)) : |
| ordinaryLaplacian (linearChange (splitChange s) P)= |
| (4:ℂ) • linearChange (splitChange s) (mixedLaplacian P) := by |
| rw [ordinaryLaplacian_linearChange,splitChange_gram] |
| rw [← map_smul] |
| congr 1 |
| simp only [Fintype.sum_sum_type,Matrix.fromBlocks_apply₁₁,Matrix.fromBlocks_apply₁₂, |
| Matrix.fromBlocks_apply₂₁,Matrix.fromBlocks_apply₂₂,Matrix.zero_apply,zero_smul,Finset.sum_const_zero, |
| zero_add,add_zero,Matrix.ofNat_apply] |
| rw [mixedLaplacian_apply,Finset.smul_sum] |
| rw [← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro i _ |
| norm_num |
| rw [pderiv_commutes P (Sum.inl i) (Sum.inr i), ← add_smul] |
| norm_num |
|
|
| lemma linearChange_injective {s : ℕ} : Function.Injective (linearChange (splitChange s)) := by |
| intro P Q h |
| have he := congrArg (linearChange (unsplitChange s)) h |
| change ((linearChange (unsplitChange s)).comp (linearChange (splitChange s))) P= |
| ((linearChange (unsplitChange s)).comp (linearChange (splitChange s))) Q at he |
| simpa only [linearChange_comp,split_unsplit,linearChange_one,AlgHom.id_apply] using he |
|
|
| end HarmonicCounterexample.Control |
|
|
| end |
|
|
| noncomputable section |
|
|
|
|
| namespace HarmonicCounterexample.Control |
| open MvPolynomial |
| open scoped BigOperators |
| variable {ι : Type*} |
|
|
| def realCoefficients : MvPolynomial ι ℂ →ₗ[ℝ] MvPolynomial ι ℝ := |
| (AddMonoidAlgebra.coeffLinearEquiv ℝ).symm.toLinearMap.comp |
| ((Finsupp.mapRange.linearMap Complex.reLm).comp |
| (AddMonoidAlgebra.coeffLinearEquiv ℝ).toLinearMap) |
|
|
| lemma coeff_realCoefficients (P : MvPolynomial ι ℂ) (d : ι →₀ ℕ) : |
| (realCoefficients P).coeff d=(P.coeff d).re := rfl |
|
|
| lemma realCoefficients_ofReal (P : MvPolynomial ι ℝ) : |
| realCoefficients (MvPolynomial.map Complex.ofRealHom P)=P := by |
| ext d |
| simp only [coeff_realCoefficients,coeff_map,Complex.ofRealHom_eq_coe,Complex.ofReal_re] |
|
|
| lemma ofReal_realCoefficients {P : MvPolynomial ι ℂ} |
| (hP : ComplexAngular.conjugate P=P) : |
| MvPolynomial.map Complex.ofRealHom (realCoefficients P)=P := by |
| ext d |
| rw [coeff_map,coeff_realCoefficients] |
| have hh := congrArg (fun polynomial => polynomial.coeff d) hP |
| rw [ComplexAngular.coeff_conjugate] at hh |
| have hz : (P.coeff d).im=0 := by |
| have hi := congrArg Complex.im hh |
| change -(P.coeff d).im=(P.coeff d).im at hi |
| linarith |
| simp only [Complex.ofRealHom_eq_coe] |
| exact Complex.ext (by simp) (by simp [hz]) |
|
|
| lemma realCoefficients_homogeneous {P : MvPolynomial ι ℂ} {l : ℕ} |
| (hP : P.IsHomogeneous l) : (realCoefficients P).IsHomogeneous l := by |
| intro d hd |
| apply hP |
| rw [coeff_realCoefficients] at hd |
| intro hc |
| apply hd |
| simp [hc] |
|
|
| variable [Fintype ι] |
| lemma ordinaryLaplacian_realCoefficients (P : MvPolynomial ι ℂ) : |
| ordinaryLaplacian (realCoefficients P)=realCoefficients (ordinaryLaplacian P) := by |
| ext d |
| simp only [ordinaryLaplacian_apply,map_sum,coeff_sum,coeff_realCoefficients,coeff_pderiv] |
| simp only [Complex.mul_re,Complex.natCast_re,Complex.natCast_im, |
| Complex.add_re,Complex.one_re,Complex.add_im,Complex.one_im,add_zero,mul_zero,sub_zero] |
|
|
| end HarmonicCounterexample.Control |
|
|
| end |
|
|
| noncomputable section |
|
|
|
|
| namespace HarmonicCounterexample.Control |
| open MvPolynomial Matrix |
| open HarmonicCounterexample.Berger.ComplexStructure HarmonicCounterexample.ComplexAngular |
| open scoped BigOperators |
|
|
| lemma linearChange_split_inl (s : ℕ) (i : Fin s) : |
| linearChange (splitChange s) (X (Sum.inl i))= |
| X (Sum.inl i)+Complex.I • X (Sum.inr i) := by |
| simp [linearChange_X,splitChange,Fintype.sum_sum_type,Matrix.one_apply] |
|
|
| lemma linearChange_split_inr (s : ℕ) (i : Fin s) : |
| linearChange (splitChange s) (X (Sum.inr i))= |
| X (Sum.inl i)-Complex.I • X (Sum.inr i) := by |
| simp [linearChange_X,splitChange,Fintype.sum_sum_type,Matrix.one_apply,sub_eq_add_neg] |
|
|
| lemma conjugate_split_X (s : ℕ) (i : Fin s ⊕ Fin s) : |
| conjugate (linearChange (splitChange s) (X i))= |
| linearChange (splitChange s) (X (Sum.swap i)) := by |
| rcases i with i|i |
| · rw [Sum.swap_inl,linearChange_split_inl,linearChange_split_inr] |
| simp [conjugate,smul_eq_C_mul,sub_eq_add_neg] |
| · rw [Sum.swap_inr,linearChange_split_inr,linearChange_split_inl] |
| simp [conjugate,smul_eq_C_mul] |
|
|
| lemma conjugate_split (s : ℕ) (P : SplitPolynomial (Fin s)) : |
| conjugate (linearChange (splitChange s) P)= |
| linearChange (splitChange s) (realConjugatePolynomial P) := by |
| induction P using MvPolynomial.induction_on with |
| | C c => simp [linearChange,conjugate,realConjugatePolynomial,swapPolynomial] |
| | add P Q hP hQ => simp only [map_add,hP,hQ] |
| | mul_X P i hP => |
| rw [map_mul,map_mul,realConjugatePolynomial_mul,map_mul,hP, |
| realConjugatePolynomial_X,conjugate_split_X] |
|
|
| / |
| the index identification with the ambient Euclidean R^16. -/ |
| def cartesianChange : SplitPolynomial (Fin 8) →ₐ[ℂ] MvPolynomial (Fin 16) ℂ := |
| (rename (finSumFinEquiv : Fin 8 ⊕ Fin 8 ≃ Fin 16)).comp (linearChange (splitChange 8)) |
|
|
| def inverseCartesianChange : MvPolynomial (Fin 16) ℂ →ₐ[ℂ] SplitPolynomial (Fin 8) := |
| (linearChange (unsplitChange 8)).comp |
| (rename ((finSumFinEquiv : Fin 8 ⊕ Fin 8 ≃ Fin 16).symm)) |
|
|
| lemma inverse_cartesianChange (P : SplitPolynomial (Fin 8)) : |
| inverseCartesianChange (cartesianChange P)=P := by |
| simp only [inverseCartesianChange,cartesianChange,AlgHom.comp_apply,rename_rename, |
| Equiv.symm_comp_self,rename_id] |
| change ((linearChange (unsplitChange 8)).comp (linearChange (splitChange 8))) P=P |
| rw [linearChange_comp,split_unsplit,linearChange_one,AlgHom.id_apply] |
|
|
| lemma cartesianChange_inverse (P : MvPolynomial (Fin 16) ℂ) : |
| cartesianChange (inverseCartesianChange P)=P := by |
| have hc := congrArg (fun f : SplitPolynomial (Fin 8) →ₐ[ℂ] SplitPolynomial (Fin 8) => |
| f (rename ((finSumFinEquiv : Fin 8 ⊕ Fin 8 ≃ Fin 16).symm) P)) |
| (linearChange_comp (splitChange 8) (unsplitChange 8)) |
| rw [unsplit_split,linearChange_one] at hc |
| change rename (finSumFinEquiv : Fin 8 ⊕ Fin 8 ≃ Fin 16) |
| (linearChange (splitChange 8) (linearChange (unsplitChange 8) |
| (rename ((finSumFinEquiv : Fin 8 ⊕ Fin 8 ≃ Fin 16).symm) P)))=P |
| rw [show linearChange (splitChange 8) (linearChange (unsplitChange 8) |
| (rename ((finSumFinEquiv : Fin 8 ⊕ Fin 8 ≃ Fin 16).symm) P))= |
| rename ((finSumFinEquiv : Fin 8 ⊕ Fin 8 ≃ Fin 16).symm) P from hc] |
| rw [rename_rename] |
| simp |
|
|
| lemma cartesianChange_injective : Function.Injective cartesianChange := |
| Function.LeftInverse.injective inverse_cartesianChange |
|
|
| lemma cartesianChange_homogeneous {P : SplitPolynomial (Fin 8)} {l : ℕ} |
| (hP : P.IsHomogeneous l) : (cartesianChange P).IsHomogeneous l := |
| (linearChange_homogeneous hP _).rename_isHomogeneous |
|
|
| lemma inverseCartesianChange_homogeneous {P : MvPolynomial (Fin 16) ℂ} {l : ℕ} |
| (hP : P.IsHomogeneous l) : (inverseCartesianChange P).IsHomogeneous l := |
| linearChange_homogeneous hP.rename_isHomogeneous _ |
|
|
| lemma conjugate_cartesianChange (P : SplitPolynomial (Fin 8)) : |
| conjugate (cartesianChange P)=cartesianChange (realConjugatePolynomial P) := by |
| change MvPolynomial.map (starRingEnd ℂ) (rename _ _)=_ |
| rw [MvPolynomial.map_rename] |
| change rename _ (conjugate (linearChange (splitChange 8) P))=_ |
| rw [conjugate_split] |
| rfl |
|
|
| lemma ordinaryLaplacian_cartesianChange (P : SplitPolynomial (Fin 8)) : |
| ordinaryLaplacian (cartesianChange P)= (4:ℂ) • cartesianChange (mixedLaplacian P) := by |
| have he := ordinaryLaplacian_rename (finSumFinEquiv : Fin 8 ⊕ Fin 8 ≃ Fin 16) |
| (linearChange (splitChange 8) P) |
| rw [ordinaryLaplacian_split,map_smul] at he |
| exact he |
|
|
| end HarmonicCounterexample.Control |
|
|
| end |
|
|
| noncomputable section |
|
|
|
|
| namespace HarmonicCounterexample.Control |
| open MvPolynomial ComplexAngular |
|
|
| lemma conjugate_ofReal {ι : Type*} (P : MvPolynomial ι ℝ) : |
| conjugate (MvPolynomial.map Complex.ofRealHom P)=MvPolynomial.map Complex.ofRealHom P := by |
| ext d |
| simp [coeff_conjugate,coeff_map] |
|
|
| lemma cartesianChange_fixed {l : ℕ} (P : realHarmonicSpace l) : |
| conjugate (cartesianChange P.val.val)=cartesianChange P.val.val := by |
| rw [conjugate_cartesianChange] |
| have hp : realConjugatePolynomial P.val.val=P.val.val := congrArg Subtype.val P.property |
| rw [hp] |
|
|
| lemma cartesianChange_harmonic {l : ℕ} (P : realHarmonicSpace l) : |
| ordinaryLaplacian (cartesianChange P.val.val)=0 := by |
| rw [ordinaryLaplacian_cartesianChange,P.val.property.2,map_zero,smul_zero] |
|
|
| lemma realCartesian_mem {l : ℕ} (P : realHarmonicSpace l) : |
| realCoefficients (cartesianChange P.val.val) ∈ Angular.harmonicPolynomials 16 l := by |
| refine ⟨realCoefficients_homogeneous (cartesianChange_homogeneous P.val.property.1),?_⟩ |
| change ordinaryLaplacian _=0 |
| rw [ordinaryLaplacian_realCoefficients,cartesianChange_harmonic,map_zero] |
|
|
| lemma inverseCartesian_mem {l : ℕ} (P : Angular.harmonicPolynomials 16 l) : |
| inverseCartesianChange (MvPolynomial.map Complex.ofRealHom P.val) ∈ harmonicSpace (Fin 8) l := by |
| refine ⟨inverseCartesianChange_homogeneous (P.property.1.map _),?_⟩ |
| change mixedLaplacian _=0 |
| have hP : ordinaryLaplacian P.val=0 := P.property.2 |
| have he := ordinaryLaplacian_cartesianChange |
| (inverseCartesianChange (MvPolynomial.map Complex.ofRealHom P.val)) |
| rw [cartesianChange_inverse,ordinaryLaplacian_map,hP,map_zero] at he |
| have hz : cartesianChange (mixedLaplacian |
| (inverseCartesianChange (MvPolynomial.map Complex.ofRealHom P.val)))=0 := |
| (smul_eq_zero.mp he.symm).resolve_left (by norm_num) |
| apply cartesianChange_injective |
| simpa only [map_zero] using hz |
|
|
| lemma inverseCartesian_fixed {l : ℕ} (P : Angular.harmonicPolynomials 16 l) : |
| realConjugatePolynomial (inverseCartesianChange (MvPolynomial.map Complex.ofRealHom P.val))= |
| inverseCartesianChange (MvPolynomial.map Complex.ofRealHom P.val) := by |
| apply cartesianChange_injective |
| rw [← conjugate_cartesianChange,cartesianChange_inverse,conjugate_ofReal] |
|
|
| / |
| exactly the Cartesian harmonic space, not merely an abstract dimension copy. -/ |
| def realCartesianHarmonic (l : ℕ) : realHarmonicSpace l ≃ₗ[ℝ] Angular.harmonicPolynomials 16 l where |
| toFun P := ⟨realCoefficients (cartesianChange P.val.val),realCartesian_mem P⟩ |
| invFun P := ⟨⟨inverseCartesianChange (MvPolynomial.map Complex.ofRealHom P.val),inverseCartesian_mem P⟩, |
| show IsSelfAdjoint _ from Subtype.ext (inverseCartesian_fixed P)⟩ |
| left_inv P := by |
| apply Subtype.ext |
| apply Subtype.ext |
| change inverseCartesianChange (MvPolynomial.map Complex.ofRealHom |
| (realCoefficients (cartesianChange P.val.val)))=P.val.val |
| rw [ofReal_realCoefficients (cartesianChange_fixed P),inverse_cartesianChange] |
| right_inv P := by |
| apply Subtype.ext |
| change realCoefficients (cartesianChange (inverseCartesianChange |
| (MvPolynomial.map Complex.ofRealHom P.val)))=P.val |
| rw [cartesianChange_inverse,realCoefficients_ofReal] |
| map_add' P Q := by |
| apply Subtype.ext |
| change realCoefficients (cartesianChange (P.val.val+Q.val.val))=_ |
| rw [map_add,map_add] |
| rfl |
| map_smul' c P := by |
| apply Subtype.ext |
| change realCoefficients (cartesianChange (c • P.val.val))=c • _ |
| rw [AlgHom.map_smul_of_tower,map_smul] |
|
|
| lemma realCartesianHarmonic_apply (l : ℕ) (P : realHarmonicSpace l) : |
| (realCartesianHarmonic l P).val=realCoefficients (cartesianChange P.val.val) := rfl |
|
|
| lemma ofReal_realCartesianHarmonic (l : ℕ) (P : realHarmonicSpace l) : |
| MvPolynomial.map Complex.ofRealHom (realCartesianHarmonic l P).val=cartesianChange P.val.val := |
| ofReal_realCoefficients (cartesianChange_fixed P) |
| end HarmonicCounterexample.Control |
|
|
| end |
|
|
| noncomputable section |
|
|
|
|
| namespace HarmonicCounterexample.Control |
| open MvPolynomial ComplexAngular Berger Berger.ComplexStructure ComplexStarModule |
| open scoped BigOperators |
|
|
| lemma linearField_map {ι R S : Type*} [Fintype ι] [DecidableEq ι] |
| [CommRing R] [CommRing S] (f : R →+* S) (M : Matrix ι ι R) (P : MvPolynomial ι R) : |
| MvPolynomial.map f (linearField M P)=linearField (M.map f) (MvPolynomial.map f P) := by |
| simp only [linearField_apply,map_sum,smul_eq_C_mul,map_mul,map_C,map_X,pderiv_map] |
| rfl |
|
|
| lemma linearField_rename {ι κ : Type*} [Fintype ι] [DecidableEq ι] |
| [Fintype κ] [DecidableEq κ] (e : ι ≃ κ) (M : Matrix ι ι ℂ) (P : MvPolynomial ι ℂ) : |
| rename e (linearField M P)=linearField (M.submatrix e.symm e.symm) (rename e P) := by |
| simp only [linearField_apply,map_sum,map_smul,map_mul,rename_X] |
| rw [← e.sum_comp] |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [← e.sum_comp] |
| apply Finset.sum_congr rfl |
| intro j _ |
| simp only [Matrix.submatrix_apply,Equiv.symm_apply_apply] |
| rw [pderiv_rename e.injective] |
|
|
| lemma linearChange_splitField (J : ComplexStructure (Fin 8 ⊕ Fin 8)) |
| (P : MvPolynomial (Fin 8 ⊕ Fin 8) ℂ) : |
| linearChange (splitChange 8) (linearField (splitFieldMatrix J.matrix) P)= |
| linearField (J.matrix.map Complex.ofRealHom) (linearChange (splitChange 8) P) := by |
| apply linearChange_linearField |
| change (splitChange 8*J.matrix.map Complex.ofReal*unsplitChange 8)*splitChange 8 = _ |
| rw [Matrix.mul_assoc _ (unsplitChange 8),unsplit_split,Matrix.mul_one] |
| rfl |
|
|
| lemma cartesianChange_field (J : ComplexStructure (Fin 8 ⊕ Fin 8)) |
| (P : MvPolynomial (Fin 8 ⊕ Fin 8) ℂ) : |
| cartesianChange (linearField (splitFieldMatrix J.matrix) P)= |
| linearField ((J.reindex finSumFinEquiv.symm).matrix.map Complex.ofRealHom) |
| (cartesianChange P) := by |
| simp only [cartesianChange,AlgHom.comp_apply,linearChange_splitField,linearField_rename] |
| rfl |
|
|
| lemma rotation_eq_field {n : ℕ} (M : Matrix (Fin n) (Fin n) ℝ) (P : MvPolynomial (Fin n) ℝ) : |
| Angular.polynomialRotation M P=linearField M P := by |
| rw [Angular.polynomialRotation_apply,linearField_apply] |
|
|
| lemma harmonicField_star (l : ℕ) (J : ComplexStructure (Fin 8 ⊕ Fin 8)) : |
| ∀ x,harmonicField l J (star x)= |
| star (harmonicField l J x) := by |
| intro x |
| exact (spaceRealConjugation_harmonicField l J x).symm |
|
|
| lemma restrictReal_harmonicField_val (l : ℕ) (J : ComplexStructure (Fin 8 ⊕ Fin 8)) |
| (P : realHarmonicSpace l) : |
| (RealForm.restrictReal (harmonicField l J) P).val= |
| harmonicField l J P.val := by |
| have hs : IsSelfAdjoint (harmonicField l J P.val) := by |
| change star _ = _ |
| rw [← harmonicField_star,P.property] |
| exact hs.coe_realPart |
|
|
| lemma realCartesian_rotation (l : ℕ) (J : ComplexStructure (Fin 8 ⊕ Fin 8)) |
| (P : realHarmonicSpace l) : |
| realCartesianHarmonic l (RealForm.restrictReal (harmonicField l J) P)= |
| Angular.rotation (J.reindex finSumFinEquiv.symm) l (realCartesianHarmonic l P) := by |
| apply Subtype.ext |
| apply (MvPolynomial.map_injective Complex.ofRealHom Complex.ofReal_injective) |
| rw [ofReal_realCartesianHarmonic] |
| change cartesianChange _=MvPolynomial.map Complex.ofRealHom |
| (Angular.polynomialRotation (J.reindex finSumFinEquiv.symm).matrix (realCartesianHarmonic l P).val) |
| rw [restrictReal_harmonicField_val,rotation_eq_field,linearField_map, |
| ofReal_realCartesianHarmonic] |
| exact cartesianChange_field J P.val.val |
| end HarmonicCounterexample.Control |
|
|
| end |
|
|
| end OAI |
|
|
