| import Mathlib |
| import OAI.Geometry.BallPacking.Hopf.SixLargeQuadricPacking |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace PackingSufficiencySupport.Hamiltonian |
| open scoped ContDiff BigOperators |
| section |
| variable {ι : Type*} [Fintype ι] |
|
|
| def complexAffineTangent : (ι → ℂ) →L[ℝ] (Option ι → ℂ) := |
| ContinuousLinearMap.pi fun i => match i with |
| | none => 0 |
| | some i => ContinuousLinearMap.proj i |
|
|
| omit [Fintype ι] in |
| @[simp] theorem complexAffineTangent_none (z : ι → ℂ) : complexAffineTangent z none=0 := rfl |
| omit [Fintype ι] in |
| @[simp] theorem complexAffineTangent_some (z : ι → ℂ) (i : ι) : complexAffineTangent z (some i)=z i := rfl |
|
|
| theorem complexAffineLift_hasFDerivAt (z : ι → ℂ) : |
| HasFDerivAt complexAffineLift complexAffineTangent z := by |
| have he : complexAffineLift (ι := ι)=fun z => complexAffineLift 0+complexAffineTangent z := by |
| ext z i |
| cases i <;> simp |
| rw [he] |
| convert! (show HasFDerivAt |
| ((fun _ : ι → ℂ => complexAffineLift (0 : ι → ℂ)) + ⇑(complexAffineTangent (ι := ι))) |
| complexAffineTangent z from by |
| simpa only [zero_add] using |
| (hasFDerivAt_const (complexAffineLift (0 : ι → ℂ)) z).add |
| (complexAffineTangent (ι := ι)).hasFDerivAt) using 1 |
|
|
| @[simp] theorem complexAffineLift_fderiv (z : ι → ℂ) : |
| fderiv ℝ complexAffineLift z=complexAffineTangent := (complexAffineLift_hasFDerivAt z).fderiv |
|
|
| theorem complexPairing_affine_tangent (z v : ι → ℂ) : |
| complexPairing (complexAffineLift z) (complexAffineTangent v)=complexPairing z v := by |
| simp [complexPairing,Fintype.sum_option] |
|
|
| theorem complexPairing_tangent_tangent (z v : ι → ℂ) : |
| complexPairing (complexAffineTangent z) (complexAffineTangent v)=complexPairing z v := by |
| simp [complexPairing,Fintype.sum_option] |
|
|
| theorem hopfForm_affine_restriction (c : ℝ) (z v w : ι → ℂ) : |
| hopfForm c (complexCartesian (complexAffineLift z)) |
| (complexCartesian (complexAffineTangent v)) (complexCartesian (complexAffineTangent w))= |
| affineFSForm c (complexCartesian z) (complexCartesian v) (complexCartesian w) := by |
| have hn : complexCartesian (complexAffineLift z)≠0 := by |
| intro he |
| have hh := congrFun (complexCartesian.injective (he.trans (map_zero _).symm)) none |
| exact one_ne_zero (by simpa only [complexAffineLift_none,Pi.zero_apply] using hh) |
| have hd (u : ι → ℂ) : |
| phaseDot (complexCartesian (complexAffineLift z)) (complexCartesian (complexAffineTangent u))= |
| phaseDot (complexCartesian z) (complexCartesian u) := by |
| rw [←complexPairing_re,complexPairing_affine_tangent,complexPairing_re] |
| have ha (u : ι → ℂ) : |
| phaseArea (complexCartesian (complexAffineLift z)) (complexCartesian (complexAffineTangent u))= |
| phaseArea (complexCartesian z) (complexCartesian u) := by |
| rw [←complexPairing_im,complexPairing_affine_tangent,complexPairing_im] |
| have ht : phaseArea (complexCartesian (complexAffineTangent v)) (complexCartesian (complexAffineTangent w))= |
| phaseArea (complexCartesian v) (complexCartesian w) := by |
| rw [←complexPairing_im,complexPairing_tangent_tangent,complexPairing_im] |
| rw [hopfForm_apply c hn,affineFSForm_apply,complexAffineLift_sq,hd,ha,hd,ha,ht] |
| ring |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| theorem hopfForm_affine_pullback {Z : E → (ι → ℂ)} {x : E} |
| (hZ : DifferentiableAt ℝ Z x) (c : ℝ) (v w : E) : |
| hopfForm c (complexCartesian (complexAffineLift (Z x))) |
| (fderiv ℝ (fun y => complexCartesian (complexAffineLift (Z y))) x v) |
| (fderiv ℝ (fun y => complexCartesian (complexAffineLift (Z y))) x w)= |
| affineFSForm c (complexCartesian (Z x)) |
| (fderiv ℝ (fun y => complexCartesian (Z y)) x v) |
| (fderiv ℝ (fun y => complexCartesian (Z y)) x w) := by |
| have hd := complexCartesian.hasFDerivAt.comp x |
| ((complexAffineLift_hasFDerivAt (Z x)).comp x hZ.hasFDerivAt) |
| have hdz := complexCartesian.hasFDerivAt.comp x hZ.hasFDerivAt |
| rw [show fderiv ℝ (fun y => complexCartesian (complexAffineLift (Z y))) x=_ from hd.fderiv, |
| show fderiv ℝ (fun y => complexCartesian (Z y)) x=_ from hdz.fderiv] |
| simp only [ContinuousLinearMap.comp_apply,ContinuousLinearEquiv.coe_coe] |
| exact hopfForm_affine_restriction c (Z x) _ _ |
|
|
| end |
|
|
| variable {ι : Type} [Fintype ι] |
|
|
| def bubbleCoordinates (ε : ℂ) (x : Option ι → ℂ) : Option ι → ℂ |
| | none => ε*x none |
| | some i => x (some i) |
|
|
| def homogeneousBubble (L m p : ℕ) (ε : ℂ) (x : Option ι → ℂ) : (Fin m → Option ι) → ℂ := |
| fun j => ε^(p-m)*x none^(L-m)*homogeneousVeronese m (bubbleCoordinates ε x) j |
|
|
| theorem bubbleCoordinates_smooth : |
| ContDiff ℂ ∞ (fun a : ℂ×(Option ι → ℂ) => bubbleCoordinates a.1 a.2) := by |
| apply contDiff_pi.mpr |
| rintro (_|i) |
| · exact contDiff_fst.mul ((contDiff_apply ℂ ℂ none).comp contDiff_snd) |
| · exact (contDiff_apply ℂ ℂ (some i)).comp contDiff_snd |
|
|
| theorem homogeneousBubble_joint_smooth (L m p : ℕ) : |
| ContDiff ℂ ∞ (fun a : ℂ×(Option ι → ℂ) => homogeneousBubble L m p a.1 a.2) := by |
| apply contDiff_pi.mpr |
| intro j |
| exact ((contDiff_fst.pow _).mul (((contDiff_apply ℂ ℂ none).comp contDiff_snd).pow _)).mul |
| ((contDiff_apply ℂ ℂ j).comp ((homogeneousVeronese_smooth m).comp bubbleCoordinates_smooth)) |
|
|
| omit [Fintype ι] in |
| theorem bubbleCoordinates_smul (ε ζ : ℂ) (x : Option ι → ℂ) : |
| bubbleCoordinates ε (ζ•x)=ζ•bubbleCoordinates ε x := by |
| ext i |
| cases i <;> simp [bubbleCoordinates,Pi.smul_apply,smul_eq_mul,mul_left_comm] |
|
|
| omit [Fintype ι] in |
| theorem homogeneousBubble_homogeneous {L m : ℕ} (hm : m≤L) (p : ℕ) |
| (ε ζ : ℂ) (x : Option ι → ℂ) : |
| homogeneousBubble L m p ε (ζ•x)=ζ^L•homogeneousBubble L m p ε x := by |
| ext j |
| simp only [homogeneousBubble,Pi.smul_apply,smul_eq_mul,mul_pow,bubbleCoordinates_smul, |
| homogeneousVeronese_homogeneous] |
| rw [show ζ^L=ζ^(L-m)*ζ^m by rw [←pow_add,Nat.sub_add_cancel hm]] |
| ring |
|
|
| omit [Fintype ι] in |
| theorem bubbleCoordinates_affine (ε : ℂ) (z : ι → ℂ) : |
| bubbleCoordinates ε (complexAffineLift (ε•z))=ε•complexAffineLift z := by |
| ext i |
| cases i <;> simp [bubbleCoordinates,complexAffineLift,Pi.smul_apply,smul_eq_mul] |
|
|
| omit [Fintype ι] in |
| theorem homogeneousBubble_scaled {m p : ℕ} (hp : m≤p) (L : ℕ) (ε : ℂ) (z : ι → ℂ) : |
| homogeneousBubble L m p ε (complexAffineLift (ε•z))=ε^p•homogeneousVeronese m (complexAffineLift z) := by |
| ext j |
| simp only [homogeneousBubble,complexAffineLift_none,one_pow,mul_one,bubbleCoordinates_affine, |
| homogeneousVeronese_homogeneous,Pi.smul_apply,smul_eq_mul] |
| rw [←mul_assoc,←pow_add,Nat.sub_add_cancel hp] |
|
|
| omit [Fintype ι] in |
| theorem homogeneousBubble_zero {m p : ℕ} (hp : m<p) (L : ℕ) (x : Option ι → ℂ) : |
| homogeneousBubble L m p 0 x=0 := by |
| ext j |
| simp [homogeneousBubble,zero_pow (show p-m≠0 by omega)] |
|
|
| variable {κ : Type} [Fintype κ] |
| def bubblePolynomial (L m p N : ℕ) (P : (Option ι → ℂ) → (κ → ℂ)) |
| (ε : ℂ) (x : Option ι → ℂ) : (κ ⊕ ((Fin m → Option ι) ⊕ (Fin L → Option ι))) → ℂ := |
| Sum.elim (P x) (Sum.elim (homogeneousBubble L m p ε x) (fun j => ε^N*homogeneousVeronese L x j)) |
|
|
| theorem bubblePolynomial_joint_smooth (L m p N : ℕ) {P : (Option ι → ℂ) → (κ → ℂ)} |
| (hP : ContDiff ℂ ∞ P) : |
| ContDiff ℂ ∞ (fun a : ℂ×(Option ι → ℂ) => bubblePolynomial L m p N P a.1 a.2) := by |
| apply contDiff_pi.mpr |
| rintro (i|(j|k)) |
| · exact (contDiff_apply ℂ ℂ i).comp (hP.comp contDiff_snd) |
| · exact (contDiff_apply ℂ ℂ j).comp (homogeneousBubble_joint_smooth L m p) |
| · exact (contDiff_fst.pow N).mul ((contDiff_apply ℂ ℂ k).comp ((homogeneousVeronese_smooth L).comp contDiff_snd)) |
|
|
| omit [Fintype ι] [Fintype κ] in |
| theorem bubblePolynomial_homogeneous {L m : ℕ} (hm : m≤L) (p N : ℕ) |
| {P : (Option ι → ℂ) → (κ → ℂ)} (hP : ∀ (ζ : ℂ) x,P (ζ•x)=ζ^L•P x) |
| (ε ζ : ℂ) (x : Option ι → ℂ) : |
| bubblePolynomial L m p N P ε (ζ•x)=ζ^L•bubblePolynomial L m p N P ε x := by |
| ext i |
| rcases i with (i|(j|k)) |
| · exact congrFun (hP ζ x) i |
| · exact congrFun (homogeneousBubble_homogeneous hm p ε ζ x) j |
| · simp only [bubblePolynomial,Sum.elim_inr,homogeneousVeronese_homogeneous,Pi.smul_apply,smul_eq_mul] |
| ring |
|
|
| omit [Fintype ι] [Fintype κ] in |
| theorem bubblePolynomial_nonzero (L m p N : ℕ) (P : (Option ι → ℂ) → (κ → ℂ)) |
| {ε : ℂ} (hε : ε≠0) {x : Option ι → ℂ} (hx : x≠0) : |
| bubblePolynomial L m p N P ε x≠0 := by |
| intro h |
| apply homogeneousVeronese_nonzero L hx |
| funext j |
| have hh := congrFun h (Sum.inr (Sum.inr j)) |
| change ε^N*homogeneousVeronese L x j=0 at hh |
| exact (mul_eq_zero.mp hh).resolve_left (pow_ne_zero N hε) |
|
|
| end PackingSufficiencySupport.Hamiltonian |
|
|
| namespace PackingSufficiencySupport.CubicModel |
| open scoped ContDiff BigOperators |
| open DiagonalQuadrics DiagonalQuadrics.Explicit Hamiltonian FiniteMoment FiniteMoment.Radial |
|
|
| def distinguishedChart (ε : ℂ) (z : Fin 3 → ℂ) : Fin 4 → ℂ := |
| ![1,ε*z 0,ε*z 1,ε*z 2] |
|
|
| def distinguishedResidualTerm (p n k J K : ℕ) (ε : ℂ) (z : Fin 3 → ℂ) : ℂ := |
| ε^(k+liftBeta n J K+liftGamma n J K+liftDelta n J K-p)* |
| (z 0-ε*z 1*z 2)^k*z 0^liftBeta n J K*z 1^liftGamma n J K*z 2^liftDelta n J K |
|
|
| theorem distinguishedResidualTerm_smooth (p n k J K : ℕ) : |
| ContDiff ℂ ∞ (fun a : ℂ×(Fin 3 → ℂ) => distinguishedResidualTerm p n k J K a.1 a.2) := by |
| unfold distinguishedResidualTerm |
| fun_prop |
|
|
| theorem distinguishedResidualTerm_factor {p n k J K : ℕ} |
| (hp : p≤k+liftBeta n J K+liftGamma n J K+liftDelta n J K) |
| (ε : ℂ) (z : Fin 3 → ℂ) : |
| firstQuadric (distinguishedChart ε z)^k * quadricLiftMonomial n J K (distinguishedChart ε z)= |
| ε^p*distinguishedResidualTerm p n k J K ε z := by |
| have he : firstQuadric (distinguishedChart ε z)=ε*(z 0-ε*z 1*z 2) := by |
| simp only [firstQuadric,distinguishedChart,Matrix.cons_val_zero,Matrix.cons_val_one,Matrix.cons_val] |
| ring |
| rw [he] |
| simp only [quadricLiftMonomial,distinguishedChart,Matrix.cons_val_zero,Matrix.cons_val_one, |
| Matrix.cons_val,one_pow,one_mul,mul_pow,distinguishedResidualTerm] |
| have hpw : ε^p*ε^(k+liftBeta n J K+liftGamma n J K+liftDelta n J K-p)= |
| ε^k*ε^liftBeta n J K*ε^liftGamma n J K*ε^liftDelta n J K := by |
| rw [←pow_add,Nat.add_sub_of_le hp] |
| simp only [pow_add] |
| calc |
| _=(ε^k*ε^liftBeta n J K*ε^liftGamma n J K*ε^liftDelta n J K)* |
| ((z 0-ε*z 1*z 2)^k*z 0^liftBeta n J K*z 1^liftGamma n J K*z 2^liftDelta n J K) := by ring |
| _=_ := by rw [←hpw]; ring |
|
|
| def distinguishedResidualPolynomial {A B : ℕ} (p L S : ℕ) (t δ : ℝ) |
| (ε : ℂ) (z : Fin 3 → ℂ) : TrapezoidWeight A B × WeightedHomogeneousIndex → ℂ := |
| fun ki => (δ:ℂ)⁻¹^(latticeIndex ki.1).1*(t:ℂ)⁻¹^(latticeIndex ki.1).2 * |
| ∑ d∈(cubicNormalSection (cubicDegree (L+S) ki.1) (cubicMarkedOrder S ki.1) (latticeIndex ki.1).2 ki.2).support, |
| (cubicNormalSection (cubicDegree (L+S) ki.1) (cubicMarkedOrder S ki.1) (latticeIndex ki.1).2 ki.2).coeff d * |
| distinguishedResidualTerm p (L-2*(latticeIndex ki.1).1) (latticeIndex ki.1).1 (d 0) (d 1) ε z |
|
|
| theorem distinguishedResidualPolynomial_smooth {A B : ℕ} (p L S : ℕ) (t δ : ℝ) : |
| ContDiff ℂ ∞ (fun a : ℂ×(Fin 3 → ℂ) => distinguishedResidualPolynomial (A := A) (B := B) p L S t δ a.1 a.2) := by |
| apply contDiff_pi.mpr |
| intro ki |
| exact contDiff_const.mul (ContDiff.sum (fun _ _ => contDiff_const.mul (distinguishedResidualTerm_smooth _ _ _ _ _))) |
|
|
| theorem outerPolynomial_distinguished_factor {L S A B p : ℕ} (hAS : A<S) (hS : 2*S<L) |
| (hB : 3*B<L+S) (hp : p≤L-S) (t δ : ℝ) (ε : ℂ) (z : Fin 3 → ℂ) : |
| outerPolynomial (A := A) (B := B) L S t δ (distinguishedChart ε z)= |
| ε^p•distinguishedResidualPolynomial p L S t δ ε z := by |
| classical |
| ext ki |
| unfold outerPolynomial liftedSection quadricLiftPolynomial distinguishedResidualPolynomial |
| simp only [Pi.smul_apply,smul_eq_mul] |
| rw [Finset.mul_sum,Finset.mul_sum,Finset.mul_sum,Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro d hd |
| have hh := distinguishedResidualTerm_factor |
| (hp.trans (liftedSection_origin_orders hAS hS hB ki.1 ki.2 d hd)) ε z |
| calc |
| _=((δ:ℂ)⁻¹^(latticeIndex ki.1).1*(t:ℂ)⁻¹^(latticeIndex ki.1).2)* |
| (cubicNormalSection (cubicDegree (L+S) ki.1) (cubicMarkedOrder S ki.1) (latticeIndex ki.1).2 ki.2).coeff d * |
| (firstQuadric (distinguishedChart ε z)^(latticeIndex ki.1).1* |
| quadricLiftMonomial (L-2*(latticeIndex ki.1).1) (d 0) (d 1) (distinguishedChart ε z)) := by ring |
| _=_ := by rw [hh]; ring |
|
|
| theorem distinguishedResidualPolynomial_zero {L S A B p : ℕ} (hAS : A<S) (hS : 2*S<L) |
| (hB : 3*B<L+S) (hp : p<L-S) (t δ : ℝ) (z : Fin 3 → ℂ) : |
| distinguishedResidualPolynomial (A := A) (B := B) p L S t δ 0 z=0 := by |
| classical |
| ext ki |
| unfold distinguishedResidualPolynomial |
| rw [Finset.sum_eq_zero] |
| · simp |
| · intro d hd |
| have hh := liftedSection_origin_orders hAS hS hB ki.1 ki.2 d hd |
| have he : (latticeIndex ki.1).1+liftBeta (L-2*(latticeIndex ki.1).1) (d 0) (d 1)+ |
| liftGamma (L-2*(latticeIndex ki.1).1) (d 0) (d 1)+liftDelta (L-2*(latticeIndex ki.1).1) (d 0) (d 1)-p≠0 := by omega |
| simp [distinguishedResidualTerm,zero_pow he] |
|
|
| def distinguishedHomogeneousCoordinates (x : Option (Fin 3) → ℂ) : Fin 4 → ℂ := |
| ![x none,x (some 0),x (some 1),x (some 2)] |
|
|
| theorem distinguishedHomogeneousCoordinates_smooth : |
| ContDiff ℂ ∞ distinguishedHomogeneousCoordinates := by |
| apply contDiff_pi.mpr |
| intro i |
| fin_cases i <;> exact contDiff_apply ℂ ℂ _ |
|
|
| theorem distinguishedHomogeneousCoordinates_smul (ζ : ℂ) (x : Option (Fin 3) → ℂ) : |
| distinguishedHomogeneousCoordinates (ζ•x)=ζ•distinguishedHomogeneousCoordinates x := by |
| ext i |
| fin_cases i <;> rfl |
|
|
| theorem distinguishedHomogeneousCoordinates_chart (ε : ℂ) (z : Fin 3 → ℂ) : |
| distinguishedHomogeneousCoordinates (complexAffineLift (ε•z))=distinguishedChart ε z := by |
| ext i |
| fin_cases i <;> rfl |
|
|
| theorem complexAffineLift_complex_smooth : |
| ContDiff ℂ ∞ (complexAffineLift (ι := Fin 3)) := by |
| apply contDiff_pi.mpr |
| rintro (_|i) |
| · exact contDiff_const |
| · exact contDiff_apply ℂ ℂ i |
|
|
| def cubicBubblePolynomial {A B : ℕ} (L S m p N : ℕ) (t δ : ℝ) (ε : ℂ) := |
| bubblePolynomial L m p N |
| (outerPolynomial (A := A) (B := B) L S t δ ∘ distinguishedHomogeneousCoordinates) ε |
|
|
| def cubicBubbleResidual {A B : ℕ} (L S m p N : ℕ) (t δ : ℝ) |
| (ε : ℂ) (z : Fin 3 → ℂ) : |
| ((TrapezoidWeight A B × WeightedHomogeneousIndex) ⊕ |
| ((Fin m → Option (Fin 3)) ⊕ (Fin L → Option (Fin 3)))) → ℂ := |
| Sum.elim (distinguishedResidualPolynomial p L S t δ ε z) |
| (Sum.elim (homogeneousVeronese m (complexAffineLift z)) |
| (fun j => ε^(N-p)*homogeneousVeronese L (complexAffineLift (ε•z)) j)) |
|
|
| theorem cubicBubblePolynomial_joint_smooth {A B : ℕ} (L S m p N : ℕ) (t δ : ℝ) : |
| ContDiff ℂ ∞ (fun a : ℂ×(Option (Fin 3) → ℂ) => |
| cubicBubblePolynomial (A := A) (B := B) L S m p N t δ a.1 a.2) := by |
| exact bubblePolynomial_joint_smooth L m p N |
| ((outerPolynomial_smooth L S t δ).comp distinguishedHomogeneousCoordinates_smooth) |
|
|
| theorem cubicBubbleResidual_joint_smooth {A B : ℕ} (L S m p N : ℕ) (t δ : ℝ) : |
| ContDiff ℂ ∞ (fun a : ℂ×(Fin 3 → ℂ) => |
| cubicBubbleResidual (A := A) (B := B) L S m p N t δ a.1 a.2) := by |
| apply contDiff_pi.mpr |
| rintro (i|(j|k)) |
| · exact (contDiff_apply ℂ ℂ i).comp (distinguishedResidualPolynomial_smooth p L S t δ) |
| · exact (contDiff_apply ℂ ℂ j).comp ((homogeneousVeronese_smooth m).comp |
| (complexAffineLift_complex_smooth.comp contDiff_snd)) |
| · exact (contDiff_fst.pow _).mul ((contDiff_apply ℂ ℂ k).comp |
| ((homogeneousVeronese_smooth L).comp (complexAffineLift_complex_smooth.comp |
| (contDiff_fst.smul contDiff_snd)))) |
|
|
| theorem cubicBubblePolynomial_homogeneous {L S A B m : ℕ} |
| (hAS : A<S) (hS : 2*S<L) (hB : 3*B<L+S) (hm : m≤L) |
| (p N : ℕ) (t δ : ℝ) (ε ζ : ℂ) (x : Option (Fin 3) → ℂ) : |
| cubicBubblePolynomial (A := A) (B := B) L S m p N t δ ε (ζ•x)= |
| ζ^L•cubicBubblePolynomial L S m p N t δ ε x := by |
| apply bubblePolynomial_homogeneous hm |
| intro ζ x |
| simp only [Function.comp_def,distinguishedHomogeneousCoordinates_smul] |
| ext ki |
| simp only [outerPolynomial,Pi.smul_apply,smul_eq_mul, |
| liftedSection_homogeneous hAS hS hB] |
| ring |
|
|
| theorem cubicBubblePolynomial_nonzero {A B : ℕ} (L S m p N : ℕ) (t δ : ℝ) |
| {ε : ℂ} (hε : ε≠0) {x : Option (Fin 3) → ℂ} (hx : x≠0) : |
| cubicBubblePolynomial (A := A) (B := B) L S m p N t δ ε x≠0 := by |
| exact bubblePolynomial_nonzero L m p N _ hε hx |
|
|
| theorem cubicBubblePolynomial_scaled {L S A B m p N : ℕ} |
| (hAS : A<S) (hS : 2*S<L) (hB : 3*B<L+S) (hp : p≤L-S) |
| (hm : m≤p) (hN : p≤N) (t δ : ℝ) (ε : ℂ) (z : Fin 3 → ℂ) : |
| cubicBubblePolynomial (A := A) (B := B) L S m p N t δ ε (complexAffineLift (ε•z))= |
| ε^p•cubicBubbleResidual L S m p N t δ ε z := by |
| ext i |
| rcases i with (i|(j|k)) |
| · exact congrFun (outerPolynomial_distinguished_factor hAS hS hB hp t δ ε z) i |
| · exact congrFun (homogeneousBubble_scaled hm L ε z) j |
| · change ε^N*_=ε^p*(ε^(N-p)*_) |
| rw [←mul_assoc,←pow_add,Nat.add_sub_of_le hN] |
|
|
| theorem cubicBubbleResidual_nonzero {A B : ℕ} (L S m p N : ℕ) (t δ : ℝ) |
| (ε : ℂ) (z : Fin 3 → ℂ) : |
| cubicBubbleResidual (A := A) (B := B) L S m p N t δ ε z≠0 := by |
| intro h |
| have hh := congrFun h (Sum.inr (Sum.inl (fun _ => none))) |
| change homogeneousVeronese m (complexAffineLift z) (fun _ => none)=0 at hh |
| simp [homogeneousVeronese] at hh |
|
|
| theorem cubicBubbleResidual_zero {L S A B m p N : ℕ} |
| (hAS : A<S) (hS : 2*S<L) (hB : 3*B<L+S) (hp : p<L-S) (hN : p<N) |
| (t δ : ℝ) (z : Fin 3 → ℂ) : |
| cubicBubbleResidual (A := A) (B := B) L S m p N t δ 0 z= |
| Sum.elim (0 : TrapezoidWeight A B × WeightedHomogeneousIndex → ℂ) |
| (Sum.elim (homogeneousVeronese m (complexAffineLift z)) |
| (0 : (Fin L → Option (Fin 3)) → ℂ)) := by |
| ext i |
| rcases i with (i|(j|k)) |
| · exact congrFun (distinguishedResidualPolynomial_zero hAS hS hB hp t δ z) i |
| · rfl |
| · simp [cubicBubbleResidual,zero_pow (show N-p≠0 by omega)] |
|
|
| end PackingSufficiencySupport.CubicModel |
|
|
| namespace PackingSufficiencySupport.Hamiltonian |
| open scoped ContDiff |
| open scoped BigOperators |
| section |
|
|
| variable {ι κ : Type} [Fintype ι] [Fintype κ] |
|
|
| theorem phasePowerMap_dot {F : PlanePhase ι → PlanePhase κ} (hF : ContDiff ℝ ∞ F) |
| {m : ℕ} (hs : ∀ z,phaseSq (F z)=(phaseSq z)^m) (z v : PlanePhase ι) : |
| phaseDot (F z) (fderiv ℝ F z v)=(m:ℝ)*(phaseSq z)^(m-1)*phaseDot z v := by |
| have h₁ := (phaseSq_hasFDerivAt (F z)).comp z (hF.differentiable (by simp) z).hasFDerivAt |
| have h₂ := (phaseSq_hasFDerivAt z).pow m |
| have he : (fun z => phaseSq (F z))=(fun z => (phaseSq z)^m) := funext hs |
| change HasFDerivAt (fun x => phaseSq (F x)) _ z at h₁ |
| rw [he] at h₁ |
| have hh := congrArg (fun L => L v) (h₁.unique h₂) |
| simp only [ContinuousLinearMap.comp_apply,smul_apply,smul_eq_mul,nsmul_eq_mul] at hh |
| nlinarith only [hh] |
|
|
| theorem phasePowerMap_area {F : PlanePhase ι → PlanePhase κ} (hF : ContDiff ℝ ∞ F) |
| {m : ℕ} (hs : ∀ z,phaseSq (F z)=(phaseSq z)^m) |
| (hJ : ∀ z v,fderiv ℝ F z (phaseJ v)=phaseJ (fderiv ℝ F z v)) (z v : PlanePhase ι) : |
| phaseArea (F z) (fderiv ℝ F z v)=(m:ℝ)*(phaseSq z)^(m-1)*phaseArea z v := by |
| have hh := phasePowerMap_dot hF hs z (phaseJ v) |
| rw [hJ,phaseDot_J_right,phaseDot_J_right] at hh |
| linarith |
|
|
| theorem homogeneousVeronese_hopf (m : ℕ) (c : ℝ) {z : ι → ℂ} (hz : z≠0) (v : ι → ℂ) : |
| hopfPrimitive c (complexCartesian (homogeneousVeronese (m+1) z)) |
| (fderiv ℝ (fun y => complexCartesian (homogeneousVeronese (m+1) y)) z v)= |
| hopfPrimitive ((m+1:ℕ)*c) (complexCartesian z) (complexCartesian v) := by |
| let F := cartesianConjugate (homogeneousVeronese (ι := ι) (m+1)) |
| have hV := homogeneousVeronese_smooth (ι := ι) (m+1) |
| have hF : ContDiff ℝ ∞ F := cartesianConjugate_smooth (hV.restrict_scalars ℝ) |
| have hs (x : PlanePhase ι) : phaseSq (F x)=(phaseSq x)^(m+1) := by |
| change phaseSq (complexCartesian (homogeneousVeronese (m+1) (complexCartesian.symm x)))=_ |
| rw [homogeneousVeronese_sq,ContinuousLinearEquiv.apply_symm_apply] |
| have hJ := cartesianConjugate_J hV |
| have ha := phasePowerMap_area hF hs hJ (complexCartesian z) (complexCartesian v) |
| have hD : fderiv ℝ F (complexCartesian z) (complexCartesian v)= |
| fderiv ℝ (fun y => complexCartesian (homogeneousVeronese (m+1) y)) z v := by |
| change fderiv ℝ (fun x : PlanePhase ι => complexCartesian (homogeneousVeronese (m+1) (complexCartesian.symm x))) (complexCartesian z) (complexCartesian v)=_ |
| have hh := ((complexCartesian.contDiff.comp (hV.restrict_scalars ℝ)).differentiable (by simp) z).hasFDerivAt.comp |
| (complexCartesian z) complexCartesian.symm.hasFDerivAt |
| simpa only [F,cartesianConjugate,Function.comp_def,ContinuousLinearEquiv.symm_apply_apply,ContinuousLinearMap.comp_apply, |
| ContinuousLinearEquiv.coe_coe] using congrArg (fun L => L (complexCartesian v)) hh.fderiv |
| change phaseArea (complexCartesian (homogeneousVeronese (m+1) z)) |
| (fderiv ℝ F (complexCartesian z) (complexCartesian v))=_ at ha |
| rw [hD] at ha |
| have hsz : phaseSq (complexCartesian z)≠0 := (phaseSq_pos (by |
| intro h; exact hz (complexCartesian.injective (h.trans (map_zero _).symm)))).ne' |
| simp only [hopfPrimitive,smul_apply,smul_eq_mul,homogeneousVeronese_sq,ha,Nat.add_sub_cancel, |
| Nat.cast_add,Nat.cast_one] |
| rw [pow_succ] |
| field_simp [hsz] |
| |
| end |
| section |
| |
| variable {ι κ ν : Type} [Fintype ι] [Fintype κ] [Fintype ν] |
| |
| def complexMiddleBlock (z : κ → ℂ) : (ι ⊕ (κ ⊕ ν)) → ℂ := |
| Sum.elim 0 (Sum.elim z 0) |
| |
| def complexMiddleBlockCLM : (κ → ℂ) →L[ℝ] ((ι ⊕ (κ ⊕ ν)) → ℂ) := |
| ContinuousLinearMap.pi fun i => match i with |
| | Sum.inl _ => 0 |
| | Sum.inr (Sum.inl k) => ContinuousLinearMap.proj k |
| | Sum.inr (Sum.inr _) => 0 |
| |
| omit [Fintype ι] [Fintype κ] [Fintype ν] in |
| theorem complexMiddleBlockCLM_apply (z : κ → ℂ) : |
| complexMiddleBlockCLM (ι := ι) (ν := ν) z=complexMiddleBlock z := by |
| ext i |
| rcases i with (i|(k|j)) <;> rfl |
| |
| theorem complexMiddleBlock_sq (z : κ → ℂ) : |
| phaseSq (complexCartesian (complexMiddleBlock (ι := ι) (ν := ν) z))= |
| phaseSq (complexCartesian z) := by |
| simp [complexCartesian_sq,complexMiddleBlock,Fintype.sum_sum_type] |
| |
| theorem complexMiddleBlock_pairing (z v : κ → ℂ) : |
| complexPairing (complexMiddleBlock (ι := ι) (ν := ν) z) (complexMiddleBlock v)= |
| complexPairing z v := by |
| simp [complexPairing,complexMiddleBlock,Fintype.sum_sum_type] |
| |
| theorem complexMiddleBlock_hopf (c : ℝ) (z v : κ → ℂ) : |
| hopfPrimitive c (complexCartesian (complexMiddleBlock (ι := ι) (ν := ν) z)) |
| (complexCartesian (complexMiddleBlock v))= |
| hopfPrimitive c (complexCartesian z) (complexCartesian v) := by |
| simp only [hopfPrimitive,smul_apply,smul_eq_mul,complexMiddleBlock_sq, |
| ←complexPairing_im,complexMiddleBlock_pairing] |
| |
| theorem complexMiddleBlock_primitive {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| {F : E → (κ → ℂ)} (hF : ContDiff ℝ ∞ F) (c : ℝ) : |
| primitivePullback (hopfPrimitive c) |
| (fun z => complexCartesian (complexMiddleBlock (ι := ι) (ν := ν) (F z)))= |
| primitivePullback (hopfPrimitive c) (fun z => complexCartesian (F z)) := by |
| ext z v |
| have hD := complexCartesian.hasFDerivAt.comp z |
| ((complexMiddleBlockCLM (ι := ι) (ν := ν)).hasFDerivAt.comp z |
| (hF.differentiable (by simp) z).hasFDerivAt) |
| have hD' := complexCartesian.hasFDerivAt.comp z (hF.differentiable (by simp) z).hasFDerivAt |
| change hopfPrimitive c _ (fderiv ℝ _ z v)=hopfPrimitive c _ (fderiv ℝ _ z v) |
| rw [show fderiv ℝ (fun z => complexCartesian (complexMiddleBlock (ι := ι) (ν := ν) (F z))) z=_ from by simpa only [Function.comp_def,complexMiddleBlockCLM_apply] using hD.fderiv, |
| show fderiv ℝ (fun z => complexCartesian (F z)) z=_ from hD'.fderiv] |
| simpa only [ContinuousLinearMap.comp_apply,ContinuousLinearEquiv.coe_coe, |
| complexMiddleBlockCLM_apply] using complexMiddleBlock_hopf (ι := ι) (ν := ν) c (F z) (fderiv ℝ F z v) |
| |
| theorem homogeneousVeronese_affinePrimitive (m : ℕ) (c : ℝ) : |
| primitivePullback (hopfPrimitive c) |
| (fun z : ι → ℂ => complexCartesian (homogeneousVeronese (m+1) (complexAffineLift z)))= |
| primitivePullback (affineFSPrimitive ((m+1:ℕ)*c)) complexCartesian := by |
| ext z v |
| have hV := ((complexCartesian (ι := Fin (m+1) → Option ι)).contDiff.comp |
| ((homogeneousVeronese_smooth (m+1)).restrict_scalars ℝ)).differentiable (by simp) (complexAffineLift z) |
| have hD := hV.hasFDerivAt.comp z (complexAffineLift_hasFDerivAt z) |
| have hz : complexAffineLift z≠0 := by |
| intro h |
| exact one_ne_zero (congrFun h none) |
| change hopfPrimitive c _ (fderiv ℝ _ z v)=_ |
| rw [show fderiv ℝ (fun z => complexCartesian (homogeneousVeronese (m+1) (complexAffineLift z))) z=_ from hD.fderiv] |
| simp only [ContinuousLinearMap.comp_apply] |
| change hopfPrimitive c _ (fderiv ℝ (fun y => complexCartesian (homogeneousVeronese (m+1) y)) |
| (complexAffineLift z) (complexAffineTangent v))=_ |
| rw [homogeneousVeronese_hopf m c hz] |
| rw [←complexAffineLift_fderiv z,affineFSPrimitive_hopf] |
| simp only [primitivePullback,ContinuousLinearEquiv.fderiv,ContinuousLinearMap.comp_apply, |
| ContinuousLinearEquiv.coe_coe] |
| |
| end |
| |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] |
| |
| theorem fibrePrimitivePullback_smooth {α : F → F →L[ℝ] ℝ} {G : ℝ×E → F} |
| (hG : ContDiff ℝ ∞ G) (hα : ∀ p,ContDiffAt ℝ ∞ α (G p)) : |
| ContDiff ℝ ∞ (fun p : ℝ×E => primitivePullback α (fun x => G (p.1,x)) p.2) := by |
| have hβ : ContDiff ℝ ∞ (primitivePullback α G) := |
| contDiff_iff_contDiffAt.mpr (fun p => primitivePullback_smoothAt (hα p) hG.contDiffAt) |
| have he (p : ℝ×E) : primitivePullback α (fun x => G (p.1,x)) p.2= |
| (primitivePullback α G p).comp (ContinuousLinearMap.inr ℝ ℝ E) := by |
| have hi : HasFDerivAt (fun x : E => (p.1,x)) (ContinuousLinearMap.inr ℝ ℝ E) p.2 := by |
| convert! (hasFDerivAt_const (𝕜 := ℝ) p.1 p.2).prodMk (hasFDerivAt_id p.2) using 1 |
| have hd := (hG.differentiable (by simp) p).hasFDerivAt.comp p.2 hi |
| unfold primitivePullback |
| rw [show fderiv ℝ (fun x => G (p.1,x)) p.2=_ from hd.fderiv] |
| rfl |
| simp_rw [he] |
| exact hβ.clm_comp contDiff_const |
| |
| end PackingSufficiencySupport.Hamiltonian |
| end |
| |
| end OAI |
| |
