| import Mathlib |
| import OAI.Geometry.BallPacking.Models.CubicPhysicalLocality |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace PackingSufficiencySupport |
| open scoped BigOperators Pointwise |
| open MeasureTheory Set |
| open MomentPolytope |
|
|
| theorem exists_six_model_comparison_data {ι : Type*} [Fintype ι] [Nonempty ι] |
| (r : ι → ℝ) (hr : ∀ i,0 < r i) {a : ℝ} (ha : 1/2<a) (_ha1 : a<1) |
| (hrs : ∀ i,r i<1-a) (hvol : ∑ i,r i^3<1-a^3) : |
| ∃ h₁ c d₁ h₂ d₂ : ℚ, ∃ τ ε : ℝ, |
| (∀ i,r i<h₁) ∧ h₁<c ∧ (c:ℝ)<1-a ∧ 1-a<(d₁:ℝ) ∧ d₁<h₂ ∧ |
| h₂<d₂ ∧ (d₂:ℝ)<(2-a)/3 ∧ 0<(h₁:ℝ) ∧ 0<(h₂:ℝ) ∧ |
| 0<τ ∧ τ<1 ∧ 0<ε ∧ |
| (∀ i,momentSimplex 2 (r i) ⊆ τ • region sixModelBounds ![h₁,h₂]) ∧ |
| ConcaveOn ℝ (region sixModelBounds ![h₁,h₂]) (sixModelGap (1-a) ((2-a)/3) r) ∧ |
| (0 < ∫ p in region sixModelBounds ![h₁,h₂],sixModelGap (1-a) ((2-a)/3) r p) ∧ |
| ∀ p ∈ region sixModelBounds ![h₁,h₂], p ∉ τ • region sixModelBounds ![h₁,h₂] → |
| ε ≤ sixModelGap (1-a) ((2-a)/3) r p := by |
| classical |
| let S := Finset.univ.image r |
| have hS : S.Nonempty := Finset.image_nonempty.2 Finset.univ_nonempty |
| let R := S.max' hS |
| have hR (i : ι) : r i ≤ R := Finset.le_max' S (r i) (Finset.mem_image_of_mem r (Finset.mem_univ i)) |
| have hRs : R<1-a := (Finset.max'_lt_iff S hS).2 (by |
| intro x hx |
| obtain ⟨i,_,rfl⟩ := Finset.mem_image.1 hx |
| exact hrs i) |
| have hRpos : 0<R := (hr (Classical.arbitrary ι)).trans_le (hR _) |
| have hsb : 1-a<(2-a)/3 := by linarith |
| have hlim : (∑ i,r i^3)/6<sixModelMean (1-a) ((2-a)/3) (1-a) ((2-a)/3) := by |
| rw [sixModelMean_limit_value] |
| exact div_lt_div_of_pos_right hvol (by norm_num) |
| obtain ⟨h₁,h₂,c,d₂,hRh₁,hch₁,hcs,hsh₂,hhd₂,hd₂,hmean⟩ := |
| rational_truncation_pair (fun h => sixModelMean (1-a) ((2-a)/3) h.1 h.2) |
| (continuous_sixModelMean (1-a) ((2-a)/3)) hRs hsb hlim |
| obtain ⟨d₁,hsd₁,hd₁h₂⟩ := exists_rat_btwn hsh₂ |
| have hd₁h₂' : d₁<h₂ := by exact_mod_cast hd₁h₂ |
| have hh₁ : (0:ℝ)<h₁ := hRpos.trans hRh₁ |
| have hRh₂ : R<(h₂:ℝ) := hRs.trans hsh₂ |
| have hh₂ : (0:ℝ)<h₂ := hRpos.trans hRh₂ |
| have hh₁s : (h₁:ℝ)<1-a := (by exact_mod_cast hch₁ : (h₁:ℝ)<c).trans hcs |
| have hh₂b : (h₂:ℝ)<(2-a)/3 := (by exact_mod_cast hhd₂ : (h₂:ℝ)<d₂).trans hd₂ |
| have hratio : max (R/(h₁:ℝ)) (R/(h₂:ℝ))<1 := max_lt |
| ((div_lt_one hh₁).2 hRh₁) ((div_lt_one hh₂).2 hRh₂) |
| obtain ⟨τ,hτlo,hτhi⟩ := exists_between hratio |
| have hτlo₁ : R/(h₁:ℝ)<τ := (le_max_left _ _).trans_lt hτlo |
| have hτlo₂ : R/(h₂:ℝ)<τ := (le_max_right _ _).trans_lt hτlo |
| have hτ : 0<τ := (div_pos hRpos hh₁).trans hτlo₁ |
| have hRτ₁ : R<τ*(h₁:ℝ) := (div_lt_iff₀ hh₁).1 hτlo₁ |
| have hRτ₂ : R<τ*(h₂:ℝ) := (div_lt_iff₀ hh₂).1 hτlo₂ |
| let ε := 9*((2-a)/3-(h₂:ℝ)) |
| have hε : 0<ε := mul_pos (by norm_num) (sub_pos.2 hh₂b) |
| have hcap (i : ι) : momentSimplex 2 (r i) ⊆ τ • region sixModelBounds ![h₁,h₂] := by |
| apply cap_into_scaled_region _ _ sixModelBounds_le_one hτ |
| intro ν |
| fin_cases ν |
| · exact (hR i).trans hRτ₁.le |
| · exact (hR i).trans hRτ₂.le |
| refine ⟨h₁,c,d₁,h₂,d₂,τ,ε,fun i => (hR i).trans_lt hRh₁,hch₁,hcs,hsd₁,hd₁h₂', |
| hhd₂,hd₂,hh₁,hh₂,hτ,hτhi,hε,hcap,?_,?_,?_⟩ |
| · rw [sixModelGap_eq_cappedAffine] |
| apply concaveOn_cappedAffine _ _ _ _ ?_ (convex_region _ _) |
| intro i |
| cases i <;> norm_num |
| · rw [integral_sixModelGap r (fun i => (hr i).le) hh₁.le hh₁s.le hsh₂.le |
| (fun i => (hR i).trans hRh₁.le) (fun i => (hR i).trans hRh₂.le)] |
| linarith |
| · intro p hp hout |
| have hz := sum_caps_zero_outside r (fun _ hp => hp.1) hcap hp hout |
| simp only [sixModelGap,hz,sub_zero] |
| exact sixModelDensity_lower hsh₂.le hp |
|
|
| end PackingSufficiencySupport |
|
|
| namespace PackingSufficiencySupport.CubicModel |
| open scoped ContDiff Manifold Topology BigOperators Pointwise |
| open Set Function Filter Manifold MeasureTheory |
| open DiagonalQuadrics DiagonalQuadrics.Explicit Hamiltonian FiniteMoment MomentPolytope |
|
|
| theorem actual_six_cubic_inner_normal_packing_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:ℝ)) ∧ |
| ∃ h₁ h₂ : ℚ, (∀ i,r i<h₁) ∧ h₁<h₂ ∧ |
| (h₁:ℝ)<(A:ℝ)/L ∧ (h₂:ℝ)<(B:ℝ)/L ∧ |
| ∃ ℓ,∃ φ : Fin N → Ambient 3 → BaseCurve × PlanePhase (Fin 2), |
| (∀ i,FormNeighborhoodEmbedding (closedBall 3 (r' i)) (fun _ => successorStandardForm 2) |
| (globalHorizontalCoupling phaseArea |
| (physicalPrimitive (A := A) (B := B) D S (1/((L:ℝ)*Real.pi)) L ∘ planeMoments)) (φ i)) ∧ |
| (∀ i,MapsTo (φ i) (closedBall 3 (r' i)) |
| (interior (cubicExhaustion ℓ ×ˢ planeRegion sixModelBounds ![h₁,h₂]))) ∧ |
| Pairwise (fun i j => Disjoint (φ i '' closedBall 3 (r' i)) (φ j '' closedBall 3 (r' j))) := by |
| have ha' : (1:ℝ)/2<(a:ℝ) := by |
| have hh : (((1:ℚ)/2:ℚ):ℝ)<(a:ℝ) := Rat.cast_lt.mpr ha |
| norm_num at hh ⊢ |
| exact hh |
| have ha1' : (a:ℝ)<1 := by exact_mod_cast ha1 |
| obtain ⟨h₁,e,d₁,h₂,d₂,τ,ε,hrh,hhe,hes,hsd,hdh,hhd,hd₂,hh₁,hh₂,hτ,hτ1,hε, |
| _hcap,hconc,hmean,houter⟩ := exists_six_model_comparison_data r hr ha' ha1' hrs hvol |
| have hsd' : 1-a<d₁ := by exact_mod_cast hsd |
| have hd₂' : d₂<(2-a)/3 := by exact_mod_cast hd₂ |
| obtain ⟨L,A,B,D,S,hQL,hL,hA,hS0,hAS,hAB,hSB,hB,hS,heA,heB,heD,heS⟩ := |
| exists_six_cubic_inner_weights_large Q ha ha1 |
| (show 0<e by exact_mod_cast (hh₁.trans (show (h₁:ℝ)<e by exact_mod_cast hhe))) |
| (show e<1-a by exact_mod_cast hes) |
| (hsd'.trans (hdh.trans hhd)) hd₂' |
| have hLr : 0<(L:ℝ) := Nat.cast_pos.mpr hL |
| have hh₁d : (h₁:ℝ)<d₁ := (show (h₁:ℝ)<e by exact_mod_cast hhe).trans (hes.trans hsd) |
| have hh₂d : (h₂:ℝ)<d₂ := by exact_mod_cast hhd |
| have hh₁₂ : h₁<h₂ := by |
| have hh : (h₁:ℝ)<h₂ := hh₁d.trans (show (d₁:ℝ)<h₂ by exact_mod_cast hdh) |
| exact_mod_cast hh |
| have hh₁₂' : (h₁:ℝ)<h₂ := by exact_mod_cast hh₁₂ |
| have hPS := physicalParameter_maps_six_region hL (show (h₁:ℝ)<e by exact_mod_cast hhe) hh₂d heA heB |
| have harea := physicalArea_eq_sixModelDensity hL heD heS |
| have hsimp i p (hp : ∀ j,0≤p j) (ht : (∑ j,p j)≤r i) : |
| p∈region sixModelBounds ![(h₁:ℝ),(h₂:ℝ)] := |
| sixModelRegion_contains_cap (hrh i).le ((hrh i).trans hh₁₂').le ⟨hp,ht⟩ |
| have hface (i : Fin N) (p : Moments 2) (hp : ∀ j,0≤p j) (ht : (∑ j,p j)≤r i) ν : |
| (∑ j,sixModelBounds ν j*p j)≠![(h₁:ℝ),(h₂:ℝ)] ν := by |
| have hs : p 0+p 1≤r i := by simpa only [Fin.sum_univ_two] using ht |
| fin_cases ν |
| · simp only [sixModelBounds,Fin.sum_univ_two] |
| change 1*p 0+0*p 1≠(h₁:ℝ) |
| exact ne_of_lt (by linarith [hp 1,hrh i]) |
| · simp only [sixModelBounds,Fin.sum_univ_two] |
| change 1*p 0+1*p 1≠(h₂:ℝ) |
| exact ne_of_lt (by simpa only [one_mul] using hs.trans_lt ((hrh i).trans hh₁₂')) |
| obtain ⟨ℓ,Γ,_hΓ,he,φ,hφ,hm,hd⟩ := actual_cubic_representative_packing hA hS0 hAB hSB hB hS |
| (one_div_pos.mpr (mul_pos hLr Real.pi_pos)) sixModelBounds ![(h₁:ℝ),(h₂:ℝ)] |
| sixModelBounds_nonneg (by intro ν; fin_cases ν; exact hh₁; exact hh₂) |
| (sixModelRegion_isCompact h₁ h₂) hPS r r' hr' hrr hsimp hface |
| (by rw [harea]; exact hconc) |
| (by rw [harea]; exact hmean) hτ hτ1 hε |
| (by rw [harea]; exact houter) |
| refine ⟨L,A,B,D,S,hQL,hL,hA,hS0,hAS,hAB,hSB,hB,hS,heD,heS,h₁,h₂,hrh,hh₁₂,?_,?_,ℓ,φ,?_,hm,hd⟩ |
| · rw [heA,mul_div_cancel_left₀ _ hLr.ne'] |
| exact_mod_cast hhe |
| · rw [heB,mul_div_cancel_left₀ _ hLr.ne'] |
| exact hh₂d |
| · intro i |
| exact (hφ i).congr_target_near (fun x hx => interior_subset (hm i hx)) |
| (physicalCoupling_representative_near hLr.le hPS he) |
|
|
| end PackingSufficiencySupport.CubicModel |
|
|
| namespace PackingSufficiencySupport.Hamiltonian |
| open scoped BigOperators ContDiff ComplexConjugate |
| open DiagonalQuadrics |
|
|
| variable {ι κ : Type*} [Fintype ι] [Fintype κ] |
|
|
| def complexBlocks (s : ι → ℂ) (z : ι → κ → ℂ) : ι × κ → ℂ := fun ij => s ij.1*z ij.1 ij.2 |
|
|
| theorem complexArea_add (z u v : ℂ) : complexArea z (u+v)=complexArea z u+complexArea z v := by |
| simp only [complexArea,mul_add,Complex.add_im] |
|
|
| theorem complexArea_product (s t u v : ℂ) : |
| complexArea (s*t) (u*t+s*v)=Complex.normSq t*complexArea s u+Complex.normSq s*complexArea t v := by |
| rw [complexArea_add,mul_comm u t,mul_comm s t,complexArea_mul,mul_comm t s,complexArea_mul] |
|
|
| theorem complexBlocks_sq (s : ι → ℂ) (z : ι → κ → ℂ) : |
| phaseSq (complexCartesian (complexBlocks s z))= |
| ∑ i,Complex.normSq (s i)*phaseSq (complexCartesian (z i)) := by |
| simp only [complexCartesian_sq,complexBlocks,Fintype.sum_prod_type,Complex.normSq_mul,Finset.mul_sum] |
|
|
| theorem complexBlocks_area (s d : ι → ℂ) (z v : ι → κ → ℂ) : |
| phaseArea (complexCartesian (complexBlocks s z)) |
| (complexCartesian (fun ij => d ij.1*z ij.1 ij.2+s ij.1*v ij.1 ij.2))= |
| ∑ i,(phaseSq (complexCartesian (z i))*complexArea (s i) (d i)+ |
| Complex.normSq (s i)*phaseArea (complexCartesian (z i)) (complexCartesian (v i))) := by |
| have he (a b : κ → ℂ) : phaseArea (complexCartesian a) (complexCartesian b)= |
| ∑ j,complexArea (a j) (b j) := by |
| simp only [←complexPairing_im,complexPairing,Complex.im_sum,Complex.star_def,complexArea] |
| rw [show phaseArea (complexCartesian (complexBlocks s z)) |
| (complexCartesian (fun ij => d ij.1*z ij.1 ij.2+s ij.1*v ij.1 ij.2))= |
| ∑ ij : ι × κ,complexArea (s ij.1*z ij.1 ij.2) (d ij.1*z ij.1 ij.2+s ij.1*v ij.1 ij.2) from by |
| simp only [←complexPairing_im,complexPairing,Complex.im_sum,Complex.star_def,complexArea,complexBlocks]] |
| simp only [Fintype.sum_prod_type,complexArea_product,Finset.sum_add_distrib,←Finset.sum_mul, |
| ←Finset.mul_sum,complexCartesian_sq,he] |
|
|
| theorem hopfPrimitive_complexBlocks (s d : ι → ℂ) (z v : ι → κ → ℂ) |
| (hz : ∀ i,complexCartesian (z i)≠0) (c : ℝ) : |
| hopfPrimitive c (complexCartesian (complexBlocks s z)) |
| (complexCartesian (fun ij => d ij.1*z ij.1 ij.2+s ij.1*v ij.1 ij.2))= |
| (∑ i,(Complex.normSq (s i)*phaseSq (complexCartesian (z i)) / |
| phaseSq (complexCartesian (complexBlocks s z)))* |
| hopfPrimitive c (complexCartesian (z i)) (complexCartesian (v i)))+ |
| c/(2*phaseSq (complexCartesian (complexBlocks s z)))* |
| ∑ i,phaseSq (complexCartesian (z i))*complexArea (s i) (d i) := by |
| simp only [hopfPrimitive,smul_apply,smul_eq_mul,complexBlocks_area,Finset.sum_add_distrib, |
| mul_add,Finset.mul_sum] |
| rw [add_comm] |
| congr 1 |
| apply Finset.sum_congr rfl |
| intro i _ |
| field_simp [(phaseSq_pos (hz i)).ne'] |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| omit [Fintype ι] [Fintype κ] in |
| theorem complexBlocks_hasFDerivAt {s : E → ι → ℂ} {G : E → ι → κ → ℂ} {x : E} |
| (hs : ∀ i,DifferentiableAt ℝ (fun y => s y i) x) |
| (hG : ∀ i,DifferentiableAt ℝ (fun y => G y i) x) : |
| HasFDerivAt (fun y => complexBlocks (s y) (G y)) |
| (ContinuousLinearMap.pi fun ij => |
| (fderiv ℝ (fun y => s y ij.1) x).smulRight (G x ij.1 ij.2)+ |
| s x ij.1 • ((ContinuousLinearMap.proj ij.2).comp (fderiv ℝ (fun y => G y ij.1) x))) x := by |
| apply hasFDerivAt_pi.mpr |
| intro ij |
| have hproj := (hasFDerivAt_pi'.mp (hG ij.1).hasFDerivAt) ij.2 |
| convert (hs ij.1).hasFDerivAt.smul hproj using 1 |
| · rfl |
| · rw [add_comm] |
|
|
| end PackingSufficiencySupport.Hamiltonian |
|
|
| namespace PackingSufficiencySupport.FiniteMoment.Radial |
| open scoped BigOperators Topology ContDiff |
| open Set Filter Function |
|
|
| variable {ι : Type*} [Fintype ι] |
|
|
| abbrev DiskPair := ℂ × ℂ |
|
|
| def squaredRadii (z : DiskPair) : Plane := (Complex.normSq z.1,Complex.normSq z.2) |
|
|
| theorem squaredRadii_nonneg (z : DiskPair) : 0≤(squaredRadii z).1 ∧ 0≤(squaredRadii z).2 := |
| ⟨Complex.normSq_nonneg _,Complex.normSq_nonneg _⟩ |
|
|
| theorem squaredRadii_contDiff : ContDiff ℝ ∞ squaredRadii := by |
| have hn : ContDiff ℝ ∞ Complex.normSq := by |
| change ContDiff ℝ ∞ (fun z : ℂ => z.re*z.re+z.im*z.im) |
| exact (Complex.reCLM.contDiff.mul Complex.reCLM.contDiff).add |
| (Complex.imCLM.contDiff.mul Complex.imCLM.contDiff) |
| exact (hn.comp contDiff_fst).prodMk (hn.comp contDiff_snd) |
|
|
| def diskDomain (A B : ℝ) : Set DiskPair := |
| {z | (squaredRadii z).1<A ∧ (squaredRadii z).1+(squaredRadii z).2<B} |
|
|
| theorem diskDomain_isOpen (A B : ℝ) : IsOpen (diskDomain A B) := |
| (isOpen_lt squaredRadii_contDiff.continuous.fst continuous_const).inter |
| (isOpen_lt (squaredRadii_contDiff.continuous.fst.add squaredRadii_contDiff.continuous.snd) continuous_const) |
|
|
| theorem squaredRadii_mem_lower {A B : ℝ} {z : DiskPair} (hz : z∈diskDomain A B) : |
| squaredRadii z∈lowerTrapezoid A B := |
| ⟨(squaredRadii_nonneg z).1,hz.1,(squaredRadii_nonneg z).2,hz.2⟩ |
|
|
| def diskForward (k : ι → ℕ × ℕ) (a : ι → ℝ) (z : DiskPair) : DiskPair := |
| (Real.sqrt (slope k a (squaredRadii z)).1 • z.1, |
| Real.sqrt (slope k a (squaredRadii z)).2 • z.2) |
|
|
| def diskInverse (k : ι → ℕ × ℕ) (a : ι → ℝ) (z : DiskPair) : DiskPair := |
| ((Real.sqrt (slope k a (nonnegativeInverse k a (squaredRadii z))).1)⁻¹ • z.1, |
| (Real.sqrt (slope k a (nonnegativeInverse k a (squaredRadii z))).2)⁻¹ • z.2) |
|
|
| theorem normSq_real_smul (s : ℝ) (z : ℂ) : Complex.normSq (s • z)=s^2*Complex.normSq z := by |
| change Complex.normSq ((s:ℂ)*z)=_ |
| rw [Complex.normSq_mul,Complex.normSq_ofReal] |
| ring |
|
|
| theorem squaredRadii_forward {k : ι → ℕ × ℕ} {a : ι → ℝ} |
| (ha : ∀ i,0<a i) (h0 : ∃ i,k i=(0,0)) |
| (he0 : ∃ i,k i=(1,0)) (he1 : ∃ i,k i=(0,1)) (z : DiskPair) : |
| squaredRadii (diskForward k a z)=moment k a (squaredRadii z) := by |
| have hs := slope_pos ha h0 he0 he1 (squaredRadii_nonneg z) |
| rw [moment_eq_radius_slope] |
| apply Prod.ext |
| · change Complex.normSq (_ • z.1)=_ |
| rw [normSq_real_smul,Real.sq_sqrt hs.1.le] |
| exact mul_comm _ _ |
| · change Complex.normSq (_ • z.2)=_ |
| rw [normSq_real_smul,Real.sq_sqrt hs.2.le] |
| exact mul_comm _ _ |
|
|
| theorem squaredRadii_inverse {k : ι → ℕ × ℕ} {a : ι → ℝ} |
| (ha : ∀ i,0<a i) (h0 : ∃ i,k i=(0,0)) |
| (he0 : ∃ i,k i=(1,0)) (he1 : ∃ i,k i=(0,1)) {z : DiskPair} |
| (hz : ∃ r : Plane,(0≤r.1 ∧ 0≤r.2) ∧ moment k a r=squaredRadii z) : |
| squaredRadii (diskInverse k a z)=nonnegativeInverse k a (squaredRadii z) := by |
| have hs := slope_pos ha h0 he0 he1 (nonnegativeInverse_nonneg k a (squaredRadii z)) |
| have hm := nonnegativeInverse_spec hz |
| rw [moment_eq_radius_slope] at hm |
| apply Prod.ext |
| · change Complex.normSq (_ • z.1)=_ |
| rw [normSq_real_smul,inv_pow,Real.sq_sqrt hs.1.le] |
| change (slope k a (nonnegativeInverse k a (squaredRadii z))).1⁻¹*(squaredRadii z).1=_ |
| rw [←congrArg Prod.fst hm] |
| field_simp [hs.1.ne'] |
| · change Complex.normSq (_ • z.2)=_ |
| rw [normSq_real_smul,inv_pow,Real.sq_sqrt hs.2.le] |
| change (slope k a (nonnegativeInverse k a (squaredRadii z))).2⁻¹*(squaredRadii z).2=_ |
| rw [←congrArg Prod.snd hm] |
| field_simp [hs.2.ne'] |
|
|
| theorem diskForward_inverse {k : ι → ℕ × ℕ} {a : ι → ℝ} |
| (ha : ∀ i,0<a i) (h0 : ∃ i,k i=(0,0)) |
| (he0 : ∃ i,k i=(1,0)) (he1 : ∃ i,k i=(0,1)) {z : DiskPair} |
| (hz : ∃ r : Plane,(0≤r.1 ∧ 0≤r.2) ∧ moment k a r=squaredRadii z) : |
| diskForward k a (diskInverse k a z)=z := by |
| have hs := slope_pos ha h0 he0 he1 (nonnegativeInverse_nonneg k a (squaredRadii z)) |
| rw [diskForward,squaredRadii_inverse ha h0 he0 he1 hz] |
| dsimp only [diskInverse] |
| apply Prod.ext |
| · exact (smul_smul _ _ _).trans (by rw [mul_inv_cancel₀ (Real.sqrt_pos.mpr hs.1).ne',one_smul]) |
| · exact (smul_smul _ _ _).trans (by rw [mul_inv_cancel₀ (Real.sqrt_pos.mpr hs.2).ne',one_smul]) |
|
|
| theorem diskInverse_forward {k : ι → ℕ × ℕ} {a : ι → ℝ} |
| (ha : ∀ i,0<a i) (h0 : ∃ i,k i=(0,0)) |
| (he0 : ∃ i,k i=(1,0)) (he1 : ∃ i,k i=(0,1)) (z : DiskPair) : |
| diskInverse k a (diskForward k a z)=z := by |
| have hs := slope_pos ha h0 he0 he1 (squaredRadii_nonneg z) |
| rw [diskInverse,squaredRadii_forward ha h0 he0 he1, |
| nonnegativeInverse_of_moment ha h0 he0 he1 (squaredRadii_nonneg z)] |
| dsimp only [diskForward] |
| apply Prod.ext |
| · exact (smul_smul _ _ _).trans (by rw [inv_mul_cancel₀ (Real.sqrt_pos.mpr hs.1).ne',one_smul]) |
| · exact (smul_smul _ _ _).trans (by rw [inv_mul_cancel₀ (Real.sqrt_pos.mpr hs.2).ne',one_smul]) |
|
|
| end PackingSufficiencySupport.FiniteMoment.Radial |
|
|
| namespace PackingSufficiencySupport.Hamiltonian |
| open scoped BigOperators ContDiff ComplexConjugate |
| open DiagonalQuadrics FiniteMoment.Radial |
|
|
| theorem complexArea_real_smul (z v : ℂ) (r : ℝ) : |
| complexArea z (r • v)=r*complexArea z v := by |
| simp only [complexArea_apply,Complex.smul_re,Complex.smul_im,smul_eq_mul] |
| ring |
|
|
| theorem complexArea_power_derivative (z v : ℂ) (n : ℕ) : |
| complexArea (z^n) ((n:ℂ)*z^(n-1)*v)= |
| (n:ℝ)*Complex.normSq z^(n-1)*complexArea z v := by |
| cases n with |
| | zero => simp [complexArea] |
| | succ n => |
| rw [Nat.succ_sub_one,pow_succ] |
| have he : ((n+1:ℕ):ℂ)*z^n*v=((n+1:ℕ):ℝ) • (z^n*v) := by |
| simp only [Complex.real_smul,Complex.ofReal_natCast] |
| ring |
| rw [he,complexArea_real_smul,complexArea_mul,map_pow] |
| ring |
|
|
| def complexMonomial (k : ℕ × ℕ) (z : DiskPair) : ℂ := z.1^k.1*z.2^k.2 |
|
|
| def complexMonomialDerivative (k : ℕ × ℕ) (z : DiskPair) : DiskPair →L[ℝ] ℂ := |
| ((k.1:ℂ)*z.1^(k.1-1)*z.2^k.2) • (ContinuousLinearMap.fst ℝ ℂ ℂ)+ |
| (z.1^k.1*(k.2:ℂ)*z.2^(k.2-1)) • (ContinuousLinearMap.snd ℝ ℂ ℂ) |
|
|
| theorem complexMonomial_contDiff (k : ℕ × ℕ) : ContDiff ℝ ∞ (complexMonomial k) := |
| (contDiff_fst.pow k.1).mul (contDiff_snd.pow k.2) |
|
|
| theorem complexMonomial_hasFDerivAt (k : ℕ × ℕ) (z : DiskPair) : |
| HasFDerivAt (complexMonomial k) (complexMonomialDerivative k z) z := by |
| have h := (((ContinuousLinearMap.fst ℝ ℂ ℂ).hasFDerivAt (x := z)).pow k.1).mul |
| (((ContinuousLinearMap.snd ℝ ℂ ℂ).hasFDerivAt (x := z)).pow k.2) |
| convert! h using 1 |
| apply ContinuousLinearMap.ext |
| intro v |
| simp [complexMonomialDerivative] |
| ring |
|
|
| theorem complexMonomial_normSq (k : ℕ × ℕ) (z : DiskPair) : |
| Complex.normSq (complexMonomial k z)=monomial k (squaredRadii z) := by |
| simp only [complexMonomial,Complex.normSq_mul,map_pow,monomial,squaredRadii] |
|
|
| theorem complexMonomial_area (k : ℕ × ℕ) (z v : DiskPair) : |
| complexArea (complexMonomial k z) (complexMonomialDerivative k z v)= |
| (k.1:ℝ)*(squaredRadii z).1^(k.1-1)*(squaredRadii z).2^k.2*complexArea z.1 v.1+ |
| (k.2:ℝ)*(squaredRadii z).1^k.1*(squaredRadii z).2^(k.2-1)*complexArea z.2 v.2 := by |
| have he : complexMonomialDerivative k z v= |
| ((k.1:ℂ)*z.1^(k.1-1)*v.1)*z.2^k.2+ |
| z.1^k.1*((k.2:ℂ)*z.2^(k.2-1)*v.2) := by |
| simp only [complexMonomialDerivative,add_apply, |
| smul_apply,ContinuousLinearMap.coe_fst',ContinuousLinearMap.coe_snd',smul_eq_mul] |
| ring |
| rw [he,complexMonomial,complexArea_product,complexArea_power_derivative,complexArea_power_derivative] |
| simp only [map_pow,squaredRadii] |
| ring |
|
|
| section |
|
|
| variable {ι κ : Type*} [Fintype ι] [Fintype κ] |
|
|
| def toricLift (k : ι → ℕ × ℕ) (G : ι → κ → ℂ) (z : DiskPair) : ι × κ → ℂ := |
| complexBlocks (fun i => complexMonomial (k i) z) G |
|
|
| def toricLiftDifferential (k : ι → ℕ × ℕ) (G V : ι → κ → ℂ) (z v : DiskPair) : ι × κ → ℂ := |
| fun ij => complexMonomialDerivative (k ij.1) z v * G ij.1 ij.2 + |
| complexMonomial (k ij.1) z * V ij.1 ij.2 |
|
|
| theorem toricLift_sq (k : ι → ℕ × ℕ) (G : ι → κ → ℂ) (z : DiskPair) : |
| phaseSq (complexCartesian (toricLift k G z))= |
| polynomial k (fun i => phaseSq (complexCartesian (G i))) (squaredRadii z) := by |
| rw [toricLift,complexBlocks_sq] |
| simp only [complexMonomial_normSq,polynomial,mul_comm] |
|
|
| theorem toricLift_primitive (k : ι → ℕ × ℕ) (G V : ι → κ → ℂ) |
| (hG : ∀ i,complexCartesian (G i)≠0) (z v : DiskPair) (c : ℝ) : |
| hopfPrimitive c (complexCartesian (toricLift k G z)) |
| (complexCartesian (toricLiftDifferential k G V z v))= |
| (∑ i,probability k (fun j => phaseSq (complexCartesian (G j))) (squaredRadii z) i * |
| hopfPrimitive c (complexCartesian (G i)) (complexCartesian (V i)))+ |
| c/2*((slope k (fun j => phaseSq (complexCartesian (G j))) (squaredRadii z)).1*complexArea z.1 v.1+ |
| (slope k (fun j => phaseSq (complexCartesian (G j))) (squaredRadii z)).2*complexArea z.2 v.2) := by |
| rw [show hopfPrimitive c (complexCartesian (toricLift k G z)) |
| (complexCartesian (toricLiftDifferential k G V z v))= |
| hopfPrimitive c (complexCartesian (complexBlocks (fun i => complexMonomial (k i) z) G)) |
| (complexCartesian (fun ij => complexMonomialDerivative (k ij.1) z v*G ij.1 ij.2+ |
| complexMonomial (k ij.1) z*V ij.1 ij.2)) from rfl, |
| hopfPrimitive_complexBlocks (fun i => complexMonomial (k i) z) |
| (fun i => complexMonomialDerivative (k i) z v) G V hG c] |
| congr 1 |
| · apply Finset.sum_congr rfl |
| intro i _ |
| rw [complexMonomial_normSq,←toricLift,toricLift_sq] |
| simp only [probability] |
| congr 2 |
| exact mul_comm _ _ |
| · rw [←toricLift,toricLift_sq] |
| simp only [complexMonomial_area,FiniteMoment.Radial.slope,slopeNumerator,Prod.smul_fst,Prod.smul_snd,smul_eq_mul, |
| mul_add,Finset.sum_add_distrib,Finset.mul_sum,Finset.sum_mul] |
| congr 1 <;> apply Finset.sum_congr rfl <;> intro i _ <;> ring |
|
|
| end |
|
|
| variable {ι κ X : Type*} [Fintype ι] [Fintype κ] |
| [NormedAddCommGroup X] [NormedSpace ℝ X] |
|
|
| theorem toricLift_contDiff (k : ι → ℕ × ℕ) : |
| ContDiff ℝ ∞ (fun q : (ι → κ → ℂ) × DiskPair => toricLift k q.1 q.2) := by |
| apply contDiff_pi.mpr |
| intro ij |
| dsimp only [toricLift,complexBlocks,complexMonomial] |
| fun_prop |
|
|
| theorem toricLift_fderiv {k : ι → ℕ × ℕ} {G : X → ι → κ → ℂ} {z : X → DiskPair} {x : X} |
| (hG : DifferentiableAt ℝ G x) (hz : DifferentiableAt ℝ z x) (v : X) : |
| fderiv ℝ (fun q => toricLift k (G q) (z q)) x v= |
| toricLiftDifferential k (G x) (fderiv ℝ G x v) (z x) (fderiv ℝ z x v) := by |
| have hs := ((toricLift_contDiff k).differentiable (by simp) (G x,z x)).comp x (hG.prodMk hz) |
| funext ij |
| have hi := (hasFDerivAt_pi'.mp ((hasFDerivAt_pi'.mp hG.hasFDerivAt) ij.1)) ij.2 |
| have hm := (complexMonomial_hasFDerivAt (k ij.1) (z x)).comp x hz.hasFDerivAt |
| have hh := hm.mul hi |
| have he : fderiv ℝ (fun q => toricLift k (G q) (z q) ij) x= |
| (ContinuousLinearMap.proj ij).comp (fderiv ℝ (fun q => toricLift k (G q) (z q)) x) := |
| ((hasFDerivAt_pi'.mp hs.hasFDerivAt) ij).fderiv |
| have hh' : HasFDerivAt (fun q => toricLift k (G q) (z q) ij) |
| (complexMonomial (k ij.1) (z x) • ((ContinuousLinearMap.proj ij.2).comp |
| ((ContinuousLinearMap.proj ij.1).comp (fderiv ℝ G x)))+ |
| G x ij.1 ij.2 • ((complexMonomialDerivative (k ij.1) (z x)).comp (fderiv ℝ z x))) x := by |
| convert! hh using 1 |
| have hv := congrArg (fun L => L v) (he.symm.trans hh'.fderiv) |
| simpa only [ContinuousLinearMap.comp_apply,ContinuousLinearMap.proj_apply,add_apply,smul_apply, |
| smul_eq_mul,toricLiftDifferential,mul_comm,add_comm] using hv |
|
|
| theorem toricLift_pullback_primitive {k : ι → ℕ × ℕ} {G : X → ι → κ → ℂ} {z : X → DiskPair} {x : X} |
| (hG : DifferentiableAt ℝ G x) (hz : DifferentiableAt ℝ z x) |
| (hne : ∀ i,complexCartesian (G x i)≠0) (v : X) (c : ℝ) : |
| hopfPrimitive c (complexCartesian (toricLift k (G x) (z x))) |
| (complexCartesian (fderiv ℝ (fun q => toricLift k (G q) (z q)) x v))= |
| (∑ i,probability k (fun j => phaseSq (complexCartesian (G x j))) (squaredRadii (z x)) i * |
| hopfPrimitive c (complexCartesian (G x i)) (complexCartesian (fderiv ℝ G x v i)))+ |
| c/2*((slope k (fun j => phaseSq (complexCartesian (G x j))) (squaredRadii (z x))).1* |
| complexArea (z x).1 (fderiv ℝ z x v).1+ |
| (slope k (fun j => phaseSq (complexCartesian (G x j))) (squaredRadii (z x))).2* |
| complexArea (z x).2 (fderiv ℝ z x v).2) := by |
| rw [toricLift_fderiv hG hz] |
| exact toricLift_primitive k _ _ hne _ _ c |
|
|
| end PackingSufficiencySupport.Hamiltonian |
| end |
|
|
| end OAI |
|
|
