| import Mathlib |
| import OAI.Geometry.BallPacking.Normal.CompactDegenerationTransfer |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace PackingSufficiencySupport.CubicModel |
| open scoped ContDiff Manifold Topology BigOperators |
| open Set Function Manifold |
| open DiagonalQuadrics DiagonalQuadrics.Explicit Hamiltonian FiniteMoment MomentPolytope |
| open MvPolynomial |
| open FiniteMoment.Radial |
|
|
| theorem actual_six_cubic_inner_polynomial_packing_avoid_axes_large (Q : ℕ) {N : ℕ} [Nonempty (Fin N)] |
| (r r' : Fin N → ℝ) (hr : ∀ i,0<r i) (hr' : ∀ i,0≤r' i) |
| (hrr : ∀ i,r' i<r i) {a : ℚ} (ha : (1:ℚ)/2<a) (ha1 : a<1) |
| (hrs : ∀ i,r i<1-(a:ℝ)) (hvol : ∑ i,r i^3<1-(a:ℝ)^3) : |
| ∃ L A B D S : ℕ,Q<L ∧ 0<L ∧ 0<A ∧ 0<S ∧ A<S ∧ A≤B ∧ S≤B ∧ 3*B<D ∧ 3*S<D ∧ |
| (D:ℝ)=(L:ℝ)*(2-(a:ℝ)) ∧ (S:ℝ)=(L:ℝ)*(1-(a:ℝ)) ∧ |
| ∃ t : ℝ,0<t ∧ ∃ f : Fin N → Ambient 3 → CubicAmbient, |
| (∀ i,FormNeighborhoodEmbedding (closedBall 3 (r' i)) (fun _ => successorStandardForm 2) |
| (cubicAmbientForm (A := A) (B := B) D S (1/((L:ℝ)*Real.pi)) t) (f i)) ∧ |
| (∀ i,MapsTo (f i) (closedBall 3 (r' i)) cubicAffineDomain) ∧ |
| Pairwise (fun i j => Disjoint (f i '' closedBall 3 (r' i)) (f j '' closedBall 3 (r' j))) := by |
| classical |
| obtain ⟨L,A,B,D,S,hQL,hL,hA,hS0,hAS,hAB,hSB,hB,hS,heD,heS,h₁,h₂,_hrh,_hh₁₂,hh₁,hh₂,ℓ,φ,hφ,hm,hd⟩ := |
| actual_six_cubic_inner_normal_packing_large Q r r' hr hr' hrr ha ha1 hrs hvol |
| have hLr : 0<(L:ℝ) := Nat.cast_pos.mpr hL |
| let K : Set CubicPhysicalSpace := ⋃ i,φ i '' closedBall 3 (r' i) |
| have hK : IsCompact K := by |
| apply isCompact_iUnion |
| intro i |
| obtain ⟨U,_hU,hKU,hs,_he,_hf⟩ := hφ i |
| exact (closedBall_isCompact 3 (r' i)).image_of_continuousOn (hs.continuousOn.mono hKU) |
| have hPS := physicalParameter_maps_six_region hL hh₁ hh₂ |
| (show (A:ℝ)=(L:ℝ)*((A:ℝ)/L) by field_simp) |
| (show (B:ℝ)=(L:ℝ)*((B:ℝ)/L) by field_simp) |
| have hKd (p : CubicPhysicalSpace) (hp : p∈K) : |
| physicalParameter L (planeMoments p.2)∈Radial.lowerTrapezoid A B := by |
| obtain ⟨i,x,hx,rfl⟩ := mem_iUnion.mp hp |
| exact hPS (interior_subset (hm i hx)).2 |
| have hinv (p : CubicPhysicalSpace) (hp : p∈K) : |
| (cubicPhysicalForm (A := A) (B := B) D S L p).IsInvertible := by |
| obtain ⟨i,x,hx,rfl⟩ := mem_iUnion.mp hp |
| exact (hφ i).target_invertible (complexSplitPhase 2).toLinearEquiv.finrank_eq hx |
| (successorStandardForm_isInvertible 2) |
| obtain ⟨t,ht,g,W,hW,hKW,hg,hgemb,hgT,hgform⟩ := |
| exists_actual_cubic_normal_transfer_into hA hAB D S hLr hK hKd hinv |
| cubicAffineDomain_isOpen inclusion_mem_cubicAffineDomain |
| obtain ⟨hf,hdj⟩ := postcompose_form_packing (fun i => closedBall 3 (r' i)) |
| (fun _ => successorStandardForm 2) (cubicPhysicalForm (A := A) (B := B) D S L) |
| (cubicAmbientForm (A := A) (B := B) D S (1/((L:ℝ)*Real.pi)) t) |
| hW g hg.contMDiffOn hgemb hgform φ hφ |
| (fun i x hx => hKW (mem_iUnion.mpr ⟨i,x,hx,rfl⟩)) hd |
| exact ⟨L,A,B,D,S,hQL,hL,hA,hS0,hAS,hAB,hSB,hB,hS,heD,heS,t,ht,fun i => g ∘ φ i,hf,fun i x hx => hgT (hKW (mem_iUnion.mpr ⟨i,x,hx,rfl⟩)),hdj⟩ |
| |
| def quadricParam (u v w : ℂ) : Fin 4 → ℂ := ![v*w,u^2,u*v,u*w] |
| def liftAlpha (n J K : ℕ) := J+K-n |
| def liftBeta (n J K : ℕ) := n+liftAlpha n J K-(J+K) |
| def liftGamma (n J K : ℕ) := J-liftAlpha n J K |
| def liftDelta (n J K : ℕ) := K-liftAlpha n J K |
| |
| theorem lift_exponents {n J K : ℕ} (hJ : J≤n) (hK : K≤n) : |
| liftAlpha n J K+liftGamma n J K=J ∧ |
| liftAlpha n J K+liftDelta n J K=K ∧ |
| 2*liftBeta n J K+liftGamma n J K+liftDelta n J K=2*n-(J+K) ∧ |
| liftAlpha n J K+liftBeta n J K+liftGamma n J K+liftDelta n J K=n := by |
| dsimp [liftAlpha,liftBeta,liftGamma,liftDelta] |
| omega |
| |
| theorem lift_order_bounds {n J K r : ℕ} (hJ : J≤n) (hK : K≤n) |
| (hr : r≤n) (hJK : J+K+r≤2*n) : |
| r≤liftBeta n J K+liftGamma n J K+liftDelta n J K ∧ |
| liftBeta n J K+liftGamma n J K+liftDelta n J K≤n := by |
| dsimp [liftAlpha,liftBeta,liftGamma,liftDelta] |
| omega |
| |
| def quadricLiftMonomial (n J K : ℕ) (x : Fin 4 → ℂ) := |
| x 0^liftAlpha n J K*x 1^liftBeta n J K*x 2^liftGamma n J K*x 3^liftDelta n J K |
| |
| theorem quadricLiftMonomial_smooth (n J K : ℕ) : |
| ContDiff ℂ ∞ (quadricLiftMonomial n J K) := |
| ((((contDiff_apply ℂ ℂ 0).pow _).mul ((contDiff_apply ℂ ℂ 1).pow _)).mul |
| ((contDiff_apply ℂ ℂ 2).pow _)).mul ((contDiff_apply ℂ ℂ 3).pow _) |
| |
| theorem quadricLiftMonomial_param {n J K : ℕ} (hJ : J≤n) (hK : K≤n) |
| (u v w : ℂ) : |
| quadricLiftMonomial n J K (quadricParam u v w)=u^(2*n-(J+K))*v^J*w^K := by |
| obtain ⟨heJ,heK,heI,_⟩ := lift_exponents hJ hK |
| change (v*w)^liftAlpha n J K*(u^2)^liftBeta n J K* |
| (u*v)^liftGamma n J K*(u*w)^liftDelta n J K=_ |
| calc |
| _=u^(2*liftBeta n J K+liftGamma n J K+liftDelta n J K)* |
| v^(liftAlpha n J K+liftGamma n J K)*w^(liftAlpha n J K+liftDelta n J K) := by |
| simp only [mul_pow,pow_add,pow_mul] |
| ring |
| _=_ := by rw [heJ,heK,heI] |
| |
| theorem quadricLiftMonomial_homogeneous {n J K : ℕ} (hJ : J≤n) (hK : K≤n) |
| (ζ : ℂ) (x : Fin 4 → ℂ) : |
| quadricLiftMonomial n J K (ζ • x)=ζ^n*quadricLiftMonomial n J K x := by |
| have he := (lift_exponents hJ hK).2.2.2 |
| unfold quadricLiftMonomial |
| simp only [Pi.smul_apply,smul_eq_mul,mul_pow] |
| calc |
| _=ζ^(liftAlpha n J K+liftBeta n J K+liftGamma n J K+liftDelta n J K)* |
| (x 0^liftAlpha n J K*x 1^liftBeta n J K*x 2^liftGamma n J K*x 3^liftDelta n J K) := by |
| simp only [pow_add]; ring |
| _=_ := by rw [he] |
| |
| def quadricLiftPolynomial (n : ℕ) (q : MvPolynomial (Fin 2) ℂ) (x : Fin 4 → ℂ) : ℂ := |
| ∑ d∈q.support,q.coeff d*quadricLiftMonomial n (d 0) (d 1) x |
| |
| theorem quadricLiftPolynomial_smooth (n : ℕ) (q : MvPolynomial (Fin 2) ℂ) : |
| ContDiff ℂ ∞ (quadricLiftPolynomial n q) := by |
| unfold quadricLiftPolynomial |
| exact ContDiff.sum (fun _ _ => contDiff_const.mul (quadricLiftMonomial_smooth _ _ _)) |
| |
| theorem quadricLiftPolynomial_param {n : ℕ} (q : MvPolynomial (Fin 2) ℂ) |
| (h0 : q.degreeOf 0≤n) (h1 : q.degreeOf 1≤n) (v w : ℂ) : |
| quadricLiftPolynomial n q (quadricParam 1 v w)=MvPolynomial.eval ![v,w] q := by |
| rw [MvPolynomial.eval_eq'] |
| apply Finset.sum_congr rfl |
| intro d hd |
| rw [quadricLiftMonomial_param ((MvPolynomial.monomial_le_degreeOf 0 hd).trans h0) |
| ((MvPolynomial.monomial_le_degreeOf 1 hd).trans h1)] |
| simp [Fin.prod_univ_two] |
|
|
| theorem quadricLiftPolynomial_homogeneous {n : ℕ} (q : MvPolynomial (Fin 2) ℂ) |
| (h0 : q.degreeOf 0≤n) (h1 : q.degreeOf 1≤n) (ζ : ℂ) (x : Fin 4 → ℂ) : |
| quadricLiftPolynomial n q (ζ • x)=ζ^n*quadricLiftPolynomial n q x := by |
| unfold quadricLiftPolynomial |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro d hd |
| rw [quadricLiftMonomial_homogeneous ((MvPolynomial.monomial_le_degreeOf 0 hd).trans h0) |
| ((MvPolynomial.monomial_le_degreeOf 1 hd).trans h1)] |
| ring |
|
|
| theorem quadricLiftPolynomial_orders {n r : ℕ} (q : MvPolynomial (Fin 2) ℂ) |
| (h0 : q.degreeOf 0≤n) (h1 : q.degreeOf 1≤n) |
| (hr : r≤n) (hdeg : q.totalDegree+r≤2*n) (d : Fin 2 →₀ ℕ) (hd : d∈q.support) : |
| r≤liftBeta n (d 0) (d 1)+liftGamma n (d 0) (d 1)+liftDelta n (d 0) (d 1) ∧ |
| liftBeta n (d 0) (d 1)+liftGamma n (d 0) (d 1)+liftDelta n (d 0) (d 1)≤n := by |
| apply lift_order_bounds ((MvPolynomial.monomial_le_degreeOf 0 hd).trans h0) |
| ((MvPolynomial.monomial_le_degreeOf 1 hd).trans h1) hr |
| have h := MvPolynomial.le_totalDegree hd |
| have he : d.sum (fun _ e => e)=d 0+d 1 := by |
| rw [d.sum_fintype (fun _ e => e) (by simp)] |
| simp [Fin.sum_univ_two] |
| rw [he] at h |
| omega |
|
|
| def planeCubicPolynomial : MvPolynomial (Fin 2) ℂ := |
| X 0^2*X 1+C (-1)*(X 0*X 1^2)+X 1+C (-2)*X 0 |
|
|
| theorem planeCubicPolynomial_eval (v w : ℂ) : |
| eval ![v,w] planeCubicPolynomial=polynomial (v,w) := by |
| simp only [planeCubicPolynomial,map_add,map_mul,map_pow,MvPolynomial.eval_X,MvPolynomial.eval_C] |
| change v^2*w+(-1)*(v*w^2)+w+(-2)*v=v*w*(v-w)+w-2*v |
| ring |
|
|
| theorem planeCubicPolynomial_degreeOf (i : Fin 2) : planeCubicPolynomial.degreeOf i≤2 := by |
| have h0 : (X 0^2*X 1 : MvPolynomial (Fin 2) ℂ).degreeOf i≤2 := by |
| have h := degreeOf_mul_le i (X 0^2 : MvPolynomial (Fin 2) ℂ) (X 1) |
| fin_cases i <;> simp [degreeOf_X_pow_of_ne,degreeOf_X] at h ⊢ <;> omega |
| have h1 : (C (-1)*(X 0*X 1^2) : MvPolynomial (Fin 2) ℂ).degreeOf i≤2 := by |
| apply (degreeOf_C_mul_le _ _ _).trans |
| have h := degreeOf_mul_le i (X 0 : MvPolynomial (Fin 2) ℂ) (X 1^2) |
| fin_cases i <;> simp [degreeOf_X_pow_of_ne,degreeOf_X] at h ⊢ <;> omega |
| have h2 : (X 1 : MvPolynomial (Fin 2) ℂ).degreeOf i≤2 := by |
| fin_cases i <;> simp [degreeOf_X] |
| have h3 : (C (-2)*X 0 : MvPolynomial (Fin 2) ℂ).degreeOf i≤2 := by |
| apply (degreeOf_C_mul_le _ _ _).trans |
| fin_cases i <;> simp [degreeOf_X] |
| exact (degreeOf_add_le _ _ _).trans (max_le ((degreeOf_add_le _ _ _).trans |
| (max_le ((degreeOf_add_le _ _ _).trans (max_le h0 h1)) h2)) h3) |
|
|
| theorem planeCubicPolynomial_totalDegree : planeCubicPolynomial.totalDegree≤3 := by |
| have h0 : (X 0^2*X 1 : MvPolynomial (Fin 2) ℂ).totalDegree≤3 := by |
| have h := totalDegree_mul (X 0^2 : MvPolynomial (Fin 2) ℂ) (X 1) |
| rw [totalDegree_X_pow,totalDegree_X] at h |
| exact h |
| have h1 : (C (-1)*(X 0*X 1^2) : MvPolynomial (Fin 2) ℂ).totalDegree≤3 := by |
| apply (totalDegree_mul _ _).trans |
| simp only [totalDegree_C,zero_add] |
| have h := totalDegree_mul (X 0 : MvPolynomial (Fin 2) ℂ) (X 1^2) |
| rw [totalDegree_X,totalDegree_X_pow] at h |
| exact h |
| have h2 : (X 1 : MvPolynomial (Fin 2) ℂ).totalDegree≤3 := by simp |
| have h3 : (C (-2)*X 0 : MvPolynomial (Fin 2) ℂ).totalDegree≤3 := by |
| exact (totalDegree_mul _ _).trans (by simp) |
| exact (totalDegree_add _ _).trans (max_le ((totalDegree_add _ _).trans |
| (max_le ((totalDegree_add _ _).trans (max_le h0 h1)) h2)) h3) |
|
|
| def coefficientPowers (D m : ℕ) : WeightedHomogeneousIndex → ℕ × ℕ |
| | none => (0,0) |
| | some none => (D-m,0) |
| | some (some j) => ![(0,D-m),(D-m,m),(m,D-m)] j |
|
|
| theorem coefficientPowers_bounds {D m : ℕ} (hm : 2*m≤D) (i : WeightedHomogeneousIndex) : |
| (coefficientPowers D m i).1≤D-m ∧ (coefficientPowers D m i).2≤D-m ∧ |
| (coefficientPowers D m i).1+(coefficientPowers D m i).2≤D := by |
| cases i with |
| | none => simp [coefficientPowers] |
| | some i => |
| cases i with |
| | none => simp [coefficientPowers] |
| | some i => fin_cases i <;> dsimp [coefficientPowers] <;> omega |
|
|
| def coefficientPolynomial (D m : ℕ) (i : WeightedHomogeneousIndex) : MvPolynomial (Fin 2) ℂ := |
| X 0^(coefficientPowers D m i).1*X 1^(coefficientPowers D m i).2 |
|
|
| theorem coefficientPolynomial_eval (D m : ℕ) (i : WeightedHomogeneousIndex) (v w : ℂ) : |
| eval ![v,w] (coefficientPolynomial D m i)=ambientWeightedCoefficient D m (v,w) i := by |
| unfold ambientWeightedCoefficient |
| rw [←complexCartesian_affineComplex,ContinuousLinearEquiv.symm_apply_apply] |
| simp only [coefficientPolynomial,map_mul,map_pow,MvPolynomial.eval_X] |
| cases i with |
| | none => simp [coefficientPowers,complexAffineLift] |
| | some i => |
| cases i with |
| | none => simp [coefficientPowers,complexAffineLift,weightedProjection,affineComplex] |
| | some i => fin_cases i <;> |
| simp [coefficientPowers,complexAffineLift,weightedProjection,affineComplex] |
|
|
| theorem coefficientPolynomial_degreeOf {D m : ℕ} (hm : 2*m≤D) |
| (i : WeightedHomogeneousIndex) (j : Fin 2) : (coefficientPolynomial D m i).degreeOf j≤D-m := by |
| have h := degreeOf_mul_le j (X 0^(coefficientPowers D m i).1 : MvPolynomial (Fin 2) ℂ) |
| (X 1^(coefficientPowers D m i).2) |
| have hb := coefficientPowers_bounds hm i |
| fin_cases j <;> simp [degreeOf_X_pow_of_ne] at h |
| · exact h.trans hb.1 |
| · exact h.trans hb.2.1 |
|
|
| theorem coefficientPolynomial_totalDegree {D m : ℕ} (hm : 2*m≤D) (i : WeightedHomogeneousIndex) : |
| (coefficientPolynomial D m i).totalDegree≤D := by |
| have h := totalDegree_mul (X 0^(coefficientPowers D m i).1 : MvPolynomial (Fin 2) ℂ) |
| (X 1^(coefficientPowers D m i).2) |
| simp only [totalDegree_X_pow] at h |
| exact h.trans (coefficientPowers_bounds hm i).2.2 |
|
|
| def cubicNormalSection (D m k : ℕ) (i : WeightedHomogeneousIndex) : MvPolynomial (Fin 2) ℂ := |
| planeCubicPolynomial^k*coefficientPolynomial D m i |
|
|
| theorem cubicNormalSection_eval (D m k : ℕ) (i : WeightedHomogeneousIndex) (v w : ℂ) : |
| eval ![v,w] (cubicNormalSection D m k i)=polynomial (v,w)^k*ambientWeightedCoefficient D m (v,w) i := by |
| rw [cubicNormalSection,map_mul,map_pow,planeCubicPolynomial_eval,coefficientPolynomial_eval] |
|
|
| theorem cubicNormalSection_degreeOf {D m : ℕ} (hm : 2*m≤D) (k : ℕ) |
| (i : WeightedHomogeneousIndex) (j : Fin 2) : (cubicNormalSection D m k i).degreeOf j≤2*k+(D-m) := by |
| exact (degreeOf_mul_le _ _ _).trans (add_le_add |
| ((degreeOf_pow_le _ _ _).trans ((Nat.mul_le_mul_left k (planeCubicPolynomial_degreeOf j)).trans_eq (Nat.mul_comm k 2))) |
| (coefficientPolynomial_degreeOf hm i j)) |
|
|
| theorem cubicNormalSection_totalDegree {D m : ℕ} (hm : 2*m≤D) (k : ℕ) |
| (i : WeightedHomogeneousIndex) : (cubicNormalSection D m k i).totalDegree≤3*k+D := by |
| exact (totalDegree_mul _ _).trans (add_le_add |
| ((totalDegree_pow _ _).trans ((Nat.mul_le_mul_left k planeCubicPolynomial_totalDegree).trans_eq (Nat.mul_comm k 3))) |
| (coefficientPolynomial_totalDegree hm i)) |
|
|
| theorem cubic_lift_integer_bounds {L S k₁ k₂ : ℕ} (hS : 2*S<L) (hk₁ : k₁<S) |
| (hk : 3*(k₁+k₂)<L+S) : |
| 2*(S-(k₁+k₂))≤L+S-3*(k₁+k₂) ∧ |
| 2*k₂+(L+S-3*(k₁+k₂)-(S-(k₁+k₂)))≤L-2*k₁ ∧ |
| L-S-k₁≤L-2*k₁ ∧ |
| 3*k₂+(L+S-3*(k₁+k₂))+(L-S-k₁)≤2*(L-2*k₁) := by omega |
|
|
| def firstQuadric (x : Fin 4 → ℂ) : ℂ := x 0*x 1-x 2*x 3 |
|
|
| theorem firstQuadric_smooth : ContDiff ℂ ∞ firstQuadric := |
| ((contDiff_apply ℂ ℂ 0).mul (contDiff_apply ℂ ℂ 1)).sub |
| ((contDiff_apply ℂ ℂ 2).mul (contDiff_apply ℂ ℂ 3)) |
|
|
| theorem firstQuadric_homogeneous (ζ : ℂ) (x : Fin 4 → ℂ) : |
| firstQuadric (ζ • x)=ζ^2*firstQuadric x := by |
| simp only [firstQuadric,Pi.smul_apply,smul_eq_mul] |
| ring |
|
|
| theorem inner_lattice_bounds {L S A B : ℕ} (hAS : A<S) (hS : 2*S<L) |
| (hB : 3*B<L+S) (k : TrapezoidWeight A B) : |
| 2*cubicMarkedOrder S k≤cubicDegree (L+S) k ∧ |
| 2*(latticeIndex k).2+(cubicDegree (L+S) k-cubicMarkedOrder S k)≤L-2*(latticeIndex k).1 ∧ |
| L-S-(latticeIndex k).1≤L-2*(latticeIndex k).1 ∧ |
| 3*(latticeIndex k).2+cubicDegree (L+S) k+(L-S-(latticeIndex k).1)≤2*(L-2*(latticeIndex k).1) := by |
| have hk1 : (latticeIndex k).1<S := by |
| have h := k.property.1 |
| change k.val.1.val<S |
| omega |
| have hk : 3*((latticeIndex k).1+(latticeIndex k).2)<L+S := by |
| have h := totalWeight_le k |
| change 3*totalWeight k<L+S |
| omega |
| exact cubic_lift_integer_bounds hS hk1 hk |
|
|
| def liftedSection {A B : ℕ} (L S : ℕ) (k : TrapezoidWeight A B) |
| (i : WeightedHomogeneousIndex) (x : Fin 4 → ℂ) : ℂ := |
| firstQuadric x^(latticeIndex k).1 * |
| quadricLiftPolynomial (L-2*(latticeIndex k).1) |
| (cubicNormalSection (cubicDegree (L+S) k) (cubicMarkedOrder S k) (latticeIndex k).2 i) x |
|
|
| theorem liftedSection_smooth {A B : ℕ} (L S : ℕ) (k : TrapezoidWeight A B) |
| (i : WeightedHomogeneousIndex) : ContDiff ℂ ∞ (liftedSection L S k i) := |
| (firstQuadric_smooth.pow _).mul (quadricLiftPolynomial_smooth _ _) |
|
|
| theorem liftedSection_homogeneous {L S A B : ℕ} (hAS : A<S) (hS : 2*S<L) |
| (hB : 3*B<L+S) (k : TrapezoidWeight A B) (i : WeightedHomogeneousIndex) |
| (ζ : ℂ) (x : Fin 4 → ℂ) : liftedSection L S k i (ζ • x)=ζ^L*liftedSection L S k i x := by |
| obtain ⟨hm,hdeg,_,_⟩ := inner_lattice_bounds hAS hS hB k |
| have hd (j : Fin 2) := (cubicNormalSection_degreeOf hm (latticeIndex k).2 i j).trans hdeg |
| have he : 2*(latticeIndex k).1+(L-2*(latticeIndex k).1)=L := by |
| have h := k.property.1 |
| dsimp [Radial.latticeIndex] |
| omega |
| rw [liftedSection,firstQuadric_homogeneous,quadricLiftPolynomial_homogeneous _ (hd 0) (hd 1)] |
| simp only [mul_pow,←pow_mul] |
| rw [show ζ^L=ζ^(2*(latticeIndex k).1)*ζ^(L-2*(latticeIndex k).1) by rw [←pow_add,he]] |
| unfold liftedSection |
| ring |
|
|
| theorem liftedSection_origin_orders {L S A B : ℕ} (hAS : A<S) (hS : 2*S<L) |
| (hB : 3*B<L+S) (k : TrapezoidWeight A B) (i : WeightedHomogeneousIndex) |
| (d : Fin 2 →₀ ℕ) |
| (hd : d∈(cubicNormalSection (cubicDegree (L+S) k) (cubicMarkedOrder S k) (latticeIndex k).2 i).support) : |
| L-S≤(latticeIndex k).1+liftBeta (L-2*(latticeIndex k).1) (d 0) (d 1)+ |
| liftGamma (L-2*(latticeIndex k).1) (d 0) (d 1)+liftDelta (L-2*(latticeIndex k).1) (d 0) (d 1) := by |
| obtain ⟨hm,hdeg,hr,horder⟩ := inner_lattice_bounds hAS hS hB k |
| have hdj (j : Fin 2) := (cubicNormalSection_degreeOf hm (latticeIndex k).2 i j).trans hdeg |
| have htotal := cubicNormalSection_totalDegree hm (latticeIndex k).2 i |
| have hh := (quadricLiftPolynomial_orders _ (hdj 0) (hdj 1) hr |
| (show (cubicNormalSection (cubicDegree (L+S) k) (cubicMarkedOrder S k) (latticeIndex k).2 i).totalDegree+ |
| (L-S-(latticeIndex k).1)≤2*(L-2*(latticeIndex k).1) by omega) d hd).1 |
| have hk := k.property.1 |
| dsimp [Radial.latticeIndex] at * |
| omega |
|
|
| def firstQuadricChart (p : CubicAmbient) : Fin 4 → ℂ := ![p.2,1,p.1.1,p.1.2] |
|
|
| theorem firstQuadricChart_smooth : ContDiff ℂ ∞ firstQuadricChart := by |
| apply contDiff_pi.mpr |
| intro j |
| fin_cases j |
| · exact contDiff_snd |
| · exact contDiff_const |
| · exact contDiff_fst.fst |
| · exact contDiff_fst.snd |
|
|
| def outerTube (δ : ℝ) (p : CubicAmbient) : CubicAmbient := |
| (p.1,p.1.1*p.1.2+(δ:ℂ)*p.2) |
|
|
| theorem outerTube_smooth : ContDiff ℝ ∞ (fun p : ℝ × CubicAmbient => outerTube p.1 p.2) := |
| contDiff_snd.fst.prodMk ((contDiff_snd.fst.fst.mul contDiff_snd.fst.snd).add |
| ((Complex.ofRealCLM.contDiff.comp contDiff_fst).mul contDiff_snd.snd)) |
|
|
| theorem outerTube_firstQuadric (δ : ℝ) (p : CubicAmbient) : |
| firstQuadric (firstQuadricChart (outerTube δ p))=(δ:ℂ)*p.2 := by |
| simp only [firstQuadric,firstQuadricChart,outerTube,Matrix.cons_val_zero, |
| Matrix.cons_val_one,Matrix.cons_val,mul_one] |
| ring |
|
|
| def outerPolynomial {A B : ℕ} (L S : ℕ) (t δ : ℝ) (x : Fin 4 → ℂ) : |
| TrapezoidWeight A B × WeightedHomogeneousIndex → ℂ := |
| fun ki => (δ:ℂ)⁻¹^(latticeIndex ki.1).1*(t:ℂ)⁻¹^(latticeIndex ki.1).2 * |
| liftedSection L S ki.1 ki.2 x |
|
|
| def outerConePolynomial {A B : ℕ} (L S : ℕ) (t : ℝ) (p : ℝ × CubicAmbient) : |
| TrapezoidWeight A B × WeightedHomogeneousIndex → ℂ := |
| fun ki => p.2.2^(latticeIndex ki.1).1*(t:ℂ)⁻¹^(latticeIndex ki.1).2 * |
| quadricLiftPolynomial (L-2*(latticeIndex ki.1).1) |
| (cubicNormalSection (cubicDegree (L+S) ki.1) (cubicMarkedOrder S ki.1) (latticeIndex ki.1).2 ki.2) |
| (firstQuadricChart (outerTube p.1 p.2)) |
|
|
| theorem outerPolynomial_smooth {A B : ℕ} (L S : ℕ) (t δ : ℝ) : |
| ContDiff ℂ ∞ (outerPolynomial (A := A) (B := B) L S t δ) := by |
| exact contDiff_pi.mpr (fun ki => contDiff_const.mul (liftedSection_smooth _ _ _ _)) |
|
|
| theorem outerConePolynomial_smooth {A B : ℕ} (L S : ℕ) (t : ℝ) : |
| ContDiff ℝ ∞ (outerConePolynomial (A := A) (B := B) L S t) := by |
| apply contDiff_pi.mpr |
| intro ki |
| exact ((contDiff_snd.snd.pow _).mul contDiff_const).mul |
| (((quadricLiftPolynomial_smooth _ _).restrict_scalars ℝ).comp |
| ((firstQuadricChart_smooth.restrict_scalars ℝ).comp outerTube_smooth)) |
|
|
| theorem outerConePolynomial_eq {A B : ℕ} (L S : ℕ) (t : ℝ) {δ : ℝ} (hδ : δ≠0) |
| (p : CubicAmbient) : outerConePolynomial (A := A) (B := B) L S t (δ,p)= |
| outerPolynomial L S t δ (firstQuadricChart (outerTube δ p)) := by |
| ext ki |
| simp only [outerConePolynomial,outerPolynomial,liftedSection,outerTube_firstQuadric,mul_pow] |
| have hδc : (δ:ℂ)≠0 := Complex.ofReal_ne_zero.mpr hδ |
| rw [show (δ:ℂ)⁻¹^(latticeIndex ki.1).1*(t:ℂ)⁻¹^(latticeIndex ki.1).2 * |
| ((δ:ℂ)^(latticeIndex ki.1).1*p.2^(latticeIndex ki.1).1 * |
| quadricLiftPolynomial (L-2*(latticeIndex ki.1).1) |
| (cubicNormalSection (cubicDegree (L+S) ki.1) (cubicMarkedOrder S ki.1) (latticeIndex ki.1).2 ki.2) |
| (firstQuadricChart (outerTube δ p)))= |
| ((δ:ℂ)⁻¹*(δ:ℂ))^(latticeIndex ki.1).1 * outerConePolynomial (A := A) (B := B) L S t (δ,p) ki by |
| simp only [mul_pow,outerConePolynomial]; ring] |
| rw [inv_mul_cancel₀ hδc,one_pow,one_mul] |
| rfl |
|
|
| theorem outerConePolynomial_zero {L S A B : ℕ} (hAS : A<S) (hS : 2*S<L) |
| (hB : 3*B<L+S) (t : ℝ) (p : CubicAmbient) : |
| outerConePolynomial (A := A) (B := B) L S t (0,p)= |
| conePolynomial (L+S) S (cubicNormalCoordinates t p) := by |
| ext ki |
| obtain ⟨hm,hdeg,_,_⟩ := inner_lattice_bounds hAS hS hB ki.1 |
| have hd (j : Fin 2) := (cubicNormalSection_degreeOf hm (latticeIndex ki.1).2 ki.2 j).trans hdeg |
| have hc : firstQuadricChart (outerTube 0 p)=quadricParam 1 p.1.1 p.1.2 := by |
| ext j |
| fin_cases j <;> simp [firstQuadricChart,outerTube,quadricParam] |
| simp only [outerConePolynomial,hc,quadricLiftPolynomial_param _ (hd 0) (hd 1),cubicNormalSection_eval] |
| change _=p.2^(latticeIndex ki.1).1*(t⁻¹ • polynomial p.1)^(latticeIndex ki.1).2* |
| ambientWeightedCoefficient (cubicDegree (L+S) ki.1) (cubicMarkedOrder S ki.1) p.1 ki.2 |
| rw [Complex.real_smul,mul_pow,Complex.ofReal_inv] |
| ring |
|
|
| end PackingSufficiencySupport.CubicModel |
|
|
| namespace PackingSufficiencySupport.Hamiltonian |
| open scoped ContDiff |
|
|
| variable {E F G : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] [NormedAddCommGroup G] [NormedSpace ℝ G] |
| theorem primitivePullback_comp (α : G → G →L[ℝ] ℝ) {f : F → G} {g : E → F} |
| (hf : ContDiff ℝ ∞ f) (hg : ContDiff ℝ ∞ g) : |
| primitivePullback (primitivePullback α f) g=primitivePullback α (f ∘ g) := by |
| funext x |
| unfold primitivePullback |
| rw [fderiv_comp x (hf.differentiable (by simp) (g x)) (hg.differentiable (by simp) x)] |
| rfl |
|
|
| end PackingSufficiencySupport.Hamiltonian |
|
|
| namespace PackingSufficiencySupport.CubicModel |
| open scoped ContDiff Manifold Topology BigOperators |
| open Set Function Manifold |
| open DiagonalQuadrics DiagonalQuadrics.Explicit Hamiltonian FiniteMoment FiniteMoment.Radial |
|
|
| theorem quadricLiftPolynomial_one (n : ℕ) (x : Fin 4 → ℂ) : |
| quadricLiftPolynomial n 1 x=x 1^n := by |
| classical |
| simp [quadricLiftPolynomial,quadricLiftMonomial,liftAlpha,liftBeta,liftGamma,liftDelta] |
|
|
| theorem outerConePolynomial_vertex {A B : ℕ} (L S : ℕ) (t : ℝ) |
| (p : ℝ × CubicAmbient) (k : TrapezoidWeight A B) (hk : Radial.latticeIndex k=(0,0)) : |
| outerConePolynomial L S t p (k,none)=1 := by |
| simp [outerConePolynomial,hk,cubicNormalSection,coefficientPolynomial,coefficientPowers, |
| quadricLiftPolynomial_one,firstQuadricChart] |
|
|
| theorem outerPolynomial_vertex {A B : ℕ} (L S : ℕ) (t δ : ℝ) |
| (p : CubicAmbient) (k : TrapezoidWeight A B) (hk : Radial.latticeIndex k=(0,0)) : |
| outerPolynomial L S t δ (firstQuadricChart p) (k,none)=1 := by |
| simp [outerPolynomial,liftedSection,hk,cubicNormalSection,coefficientPolynomial, |
| coefficientPowers,quadricLiftPolynomial_one,firstQuadricChart] |
|
|
| theorem outerConePolynomial_nonzero {A B : ℕ} (L S : ℕ) (t : ℝ) (p : ℝ × CubicAmbient) : |
| complexCartesian (outerConePolynomial (A := A) (B := B) L S t p)≠0 := by |
| obtain ⟨k,hk⟩ := lattice_zero A B |
| intro h |
| have he := congrFun (complexCartesian.injective (h.trans (map_zero _).symm)) (k,none) |
| rw [outerConePolynomial_vertex L S t p k hk] at he |
| exact one_ne_zero he |
|
|
| theorem outerPolynomial_nonzero {A B : ℕ} (L S : ℕ) (t δ : ℝ) (p : CubicAmbient) : |
| complexCartesian (outerPolynomial (A := A) (B := B) L S t δ (firstQuadricChart p))≠0 := by |
| obtain ⟨k,hk⟩ := lattice_zero A B |
| intro h |
| have he := congrFun (complexCartesian.injective (h.trans (map_zero _).symm)) (k,none) |
| rw [outerPolynomial_vertex L S t δ p k hk] at he |
| exact one_ne_zero he |
|
|
| def outerAmbientPrimitive {A B : ℕ} (L S : ℕ) (c t δ : ℝ) : CubicAmbient → CubicAmbient →L[ℝ] ℝ := |
| primitivePullback (hopfPrimitive c) |
| (complexCartesian ∘ outerPolynomial (A := A) (B := B) L S t δ ∘ firstQuadricChart) |
|
|
| theorem outerAmbientPrimitive_smooth {A B : ℕ} (L S : ℕ) (c t δ : ℝ) : |
| ContDiff ℝ ∞ (outerAmbientPrimitive (A := A) (B := B) L S c t δ) := by |
| apply contDiff_iff_contDiffAt.mpr |
| intro p |
| exact primitivePullback_smoothAt (hopfPrimitive_smoothAt c (outerPolynomial_nonzero L S t δ p)) |
| ((complexCartesian (ι := TrapezoidWeight A B × WeightedHomogeneousIndex)).contDiff.comp |
| (((outerPolynomial_smooth L S t δ).restrict_scalars ℝ).comp |
| (firstQuadricChart_smooth.restrict_scalars ℝ))).contDiffAt |
|
|
| def outerAmbientForm {A B : ℕ} (L S : ℕ) (c t δ : ℝ) := |
| euclideanExteriorOneForm (outerAmbientPrimitive (A := A) (B := B) L S c t δ) |
|
|
| def outerConePrimitive {A B : ℕ} (L S : ℕ) (c t δ : ℝ) : CubicAmbient → CubicAmbient →L[ℝ] ℝ := |
| primitivePullback (hopfPrimitive c) |
| (fun p => complexCartesian (outerConePolynomial (A := A) (B := B) L S t (δ,p))) |
|
|
| theorem outerConePrimitive_smooth {A B : ℕ} (L S : ℕ) (c t : ℝ) : |
| SmoothOneFormFamily (outerConePrimitive (A := A) (B := B) L S c t) := by |
| let F : ℝ × CubicAmbient → PlanePhase (TrapezoidWeight A B × WeightedHomogeneousIndex) := |
| complexCartesian ∘ outerConePolynomial L S t |
| have hF : ContDiff ℝ ∞ F := complexCartesian.contDiff.comp (outerConePolynomial_smooth L S t) |
| have hβ : ContDiff ℝ ∞ (primitivePullback (hopfPrimitive c) F) := by |
| apply contDiff_iff_contDiffAt.mpr |
| intro p |
| exact primitivePullback_smoothAt (hopfPrimitive_smoothAt c (outerConePolynomial_nonzero L S t p)) hF.contDiffAt |
| have he (p : ℝ × CubicAmbient) : outerConePrimitive (A := A) (B := B) L S c t p.1 p.2= |
| (primitivePullback (hopfPrimitive c) F p).comp (ContinuousLinearMap.inr ℝ ℝ CubicAmbient) := by |
| have hi : HasFDerivAt (fun x : CubicAmbient => (p.1,x)) (ContinuousLinearMap.inr ℝ ℝ CubicAmbient) p.2 := by |
| convert! (hasFDerivAt_const (𝕜 := ℝ) p.1 p.2).prodMk (hasFDerivAt_id p.2) using 1 |
| have hd := (hF.differentiable (by simp) p).hasFDerivAt.comp p.2 hi |
| unfold outerConePrimitive primitivePullback |
| rw [show fderiv ℝ (fun x => complexCartesian (outerConePolynomial L S t (p.1,x))) p.2=_ from hd.fderiv] |
| rfl |
| have hΓ : ContDiff ℝ ∞ (fun p : ℝ × CubicAmbient => outerConePrimitive (A := A) (B := B) L S c t p.1 p.2) := by |
| simp_rw [he] |
| exact hβ.clm_comp contDiff_const |
| intro z |
| simpa only [vector_chartOneForm] using hΓ.contDiffOn |
|
|
| theorem outerConePrimitive_zero {L S A B : ℕ} (hAS : A<S) (hS : 2*S<L) |
| (hB : 3*B<L+S) (c t : ℝ) : |
| outerConePrimitive (A := A) (B := B) L S c t 0=cubicAmbientPrimitive (A := A) (B := B) (L+S) S c t := by |
| have he : (fun p => complexCartesian (outerConePolynomial (A := A) (B := B) L S t (0,p)))= |
| (complexCartesian ∘ conePolynomial (L+S) S) ∘ cubicNormalCoordinates t := by |
| funext p |
| rw [outerConePolynomial_zero hAS hS hB] |
| rfl |
| unfold outerConePrimitive cubicAmbientPrimitive cubicConePrimitive |
| rw [he] |
| symm |
| exact primitivePullback_comp (hopfPrimitive (ι := TrapezoidWeight A B × WeightedHomogeneousIndex) c) |
| (f := complexCartesian ∘ conePolynomial (A := A) (B := B) (L+S) S) |
| (g := cubicNormalCoordinates t) |
| (complexCartesian.contDiff.comp (conePolynomial_smooth _ _)) |
| (cubicNormalCoordinates_smooth t) |
|
|
| theorem outerConePrimitive_positive {A B : ℕ} (L S : ℕ) (c t : ℝ) {δ : ℝ} (hδ : δ≠0) : |
| outerConePrimitive (A := A) (B := B) L S c t δ= |
| primitivePullback (outerAmbientPrimitive (A := A) (B := B) L S c t δ) (outerTube δ) := by |
| have he : (fun p => complexCartesian (outerConePolynomial (A := A) (B := B) L S t (δ,p)))= |
| (complexCartesian ∘ outerPolynomial L S t δ ∘ firstQuadricChart) ∘ outerTube δ := by |
| funext p |
| rw [outerConePolynomial_eq L S t hδ] |
| rfl |
| unfold outerConePrimitive outerAmbientPrimitive |
| rw [he] |
| symm |
| exact primitivePullback_comp (hopfPrimitive (ι := TrapezoidWeight A B × WeightedHomogeneousIndex) c) |
| (f := complexCartesian ∘ outerPolynomial (A := A) (B := B) L S t δ ∘ firstQuadricChart) |
| (g := outerTube δ) |
| (complexCartesian.contDiff.comp (((outerPolynomial_smooth L S t δ).restrict_scalars ℝ).comp |
| (firstQuadricChart_smooth.restrict_scalars ℝ))) |
| (outerTube_smooth.comp (contDiff_const.prodMk contDiff_id)) |
|
|
| theorem outerTube_isEmbedding {δ : ℝ} (hδ : δ≠0) : Topology.IsEmbedding (outerTube δ) := by |
| let R : CubicAmbient → CubicAmbient := fun p => (p.1,(δ:ℂ)⁻¹*(p.2-p.1.1*p.1.2)) |
| have hR : Continuous R := continuous_fst.prodMk |
| (continuous_const.mul (continuous_snd.sub (continuous_fst.fst.mul continuous_fst.snd))) |
| have he : R ∘ outerTube δ=id := by |
| funext p |
| change (p.1,(δ:ℂ)⁻¹*((p.1.1*p.1.2+(δ:ℂ)*p.2)-p.1.1*p.1.2))=p |
| refine Prod.ext ?_ ?_ |
| · rfl |
| change (δ:ℂ)⁻¹*((p.1.1*p.1.2+(δ:ℂ)*p.2)-p.1.1*p.1.2)=p.2 |
| rw [add_sub_cancel_left,←mul_assoc,inv_mul_cancel₀ (Complex.ofReal_ne_zero.mpr hδ),one_mul] |
| apply Topology.IsEmbedding.of_comp |
| ((outerTube_smooth.comp (contDiff_const.prodMk contDiff_id)).continuous) hR |
| change Topology.IsEmbedding (R ∘ outerTube δ) |
| rw [he] |
| exact Topology.IsEmbedding.id |
|
|
| theorem exists_actual_outer_normal_transfer {L S A B : ℕ} (hAS : A<S) (hS : 2*S<L) |
| (hB : 3*B<L+S) (c t : ℝ) {K : Set CubicAmbient} (hK : IsCompact K) |
| (hKd : K⊆cubicAffineDomain) |
| (hinv : ∀ p∈K,(cubicAmbientForm (A := A) (B := B) (L+S) S c t p).IsInvertible) : |
| ∃ δ : ℝ,0<δ ∧ ∃ g : CubicAmbient → CubicAmbient,∃ W : Set CubicAmbient, |
| IsOpen W ∧ K⊆W ∧ ContDiff ℝ ∞ g ∧ Topology.IsEmbedding (fun x : W => g x.val) ∧ |
| (∀ x∈W,(g x).2≠0) ∧ ∀ x∈W,∀ v w, |
| outerAmbientForm (A := A) (B := B) L S c t δ (g x) (fderiv ℝ g x v) (fderiv ℝ g x w)= |
| cubicAmbientForm (A := A) (B := B) (L+S) S c t x v w := by |
| have hΓ := outerConePrimitive_smooth (A := A) (B := B) L S c t |
| have hΓ0 : ∀ x,manifoldExteriorOneForm (outerConePrimitive (A := A) (B := B) L S c t 0) x= |
| cubicAmbientForm (A := A) (B := B) (L+S) S c t x := by |
| intro x |
| rw [outerConePrimitive_zero hAS hS hB,vector_exteriorOneForm] |
| rfl |
| have hnondeg (x : CubicAmbient) (hx : x∈K) : |
| (manifoldExteriorOneForm (outerConePrimitive (A := A) (B := B) L S c t 0) x).IsInvertible := by |
| rw [hΓ0] |
| exact hinv x hx |
| have hform (δ : ℝ) (hδ : δ∈Ioc (0:ℝ) 1) (x : CubicAmbient) (_hx : x∈(univ : Set CubicAmbient)) : |
| manifoldExteriorOneForm (outerConePrimitive (A := A) (B := B) L S c t δ) x= |
| (outerAmbientForm (A := A) (B := B) L S c t δ (outerTube δ x)).bilinearComp |
| (manifoldMapDifferential (E := CubicAmbient) (F := CubicAmbient) (outerTube δ) x) |
| (manifoldMapDifferential (E := CubicAmbient) (F := CubicAmbient) (outerTube δ) x) := by |
| have hTube : ContDiff ℝ ∞ (outerTube δ) := |
| outerTube_smooth.comp (contDiff_const.prodMk contDiff_id) |
| rw [outerConePrimitive_positive L S c t (ne_of_gt hδ.1),vector_exteriorOneForm, |
| primitivePullback_exterior (outerAmbientPrimitive_smooth L S c t δ) hTube] |
| simp only [outerAmbientForm,manifoldMapDifferential,mfderiv_eq_fderiv] |
| have hinto : MapsTo (outerTube 0) K {p : CubicAmbient | p.2≠0} := by |
| intro x hx |
| have h := hKd hx |
| change x.1.1*x.1.2+(0:ℂ)*x.2≠0 |
| rw [zero_mul,add_zero] |
| exact mul_ne_zero h.1 h.2 |
| have hTubeM : ContMDiff ((𝓘(ℝ,ℝ)).prod 𝓘(ℝ,CubicAmbient)) 𝓘(ℝ,CubicAmbient) ∞ |
| (fun p : ℝ×CubicAmbient => outerTube p.1 p.2) := by |
| rw [modelWithCornersSelf_prod,chartedSpaceSelf_prod] |
| exact outerTube_smooth.contMDiff |
| obtain ⟨δ,hδ,g,W,hW,hKW,hg,hgemb,hgT,hgform⟩ := |
| exists_compact_exact_fibre_embedding_central_into hΓ hK hnondeg isOpen_univ (subset_univ K) |
| (by norm_num : 0<(1:ℝ)) hTubeM |
| (fun δ hδ => (outerTube_isEmbedding (ne_of_gt hδ.1)).comp Topology.IsEmbedding.subtypeVal) |
| (isOpen_ne_fun continuous_snd continuous_const) hinto |
| (fun δ => outerAmbientForm (A := A) (B := B) L S c t δ) hform |
| refine ⟨δ,hδ.1,g,W,hW,hKW,hg.contDiff,hgemb,hgT,?_⟩ |
| intro x hx v w |
| have hh := hgform x hx v w |
| rw [hΓ0] at hh |
| simp only [mfderiv_eq_fderiv] at hh |
| convert! hh using 1 |
|
|
| end PackingSufficiencySupport.CubicModel |
| end |
|
|
| end OAI |
|
|
