| import Mathlib |
| import OAI.Analysis.Conductivity.Variational.CompactPhysicalCorrections |
| import OAI.Analysis.Conductivity.Walls.ParametricWallTensors |
|
|
| namespace OAI |
|
|
|
|
| noncomputable section |
| namespace ScalarConductivity |
| open Set Filter Topology |
|
|
| def angularShift (T : ℝ) (n : Fin 2 → ℤ) : Coord3 := ![0,T*(n 0:ℝ),T*(n 1:ℝ)] |
|
|
| lemma angularShift_zero (T : ℝ) : angularShift T 0=0 := by ext i; fin_cases i <;> simp [angularShift] |
| lemma angularShift_add (T : ℝ) (n m : Fin 2 → ℤ) : |
| angularShift T (n+m)=angularShift T n+angularShift T m := by |
| ext i |
| fin_cases i <;> simp [angularShift,mul_add] |
| lemma angularShift_succ (T : ℝ) (n : Fin 2 → ℤ) (i : Fin 2) : |
| angularShift T n i.succ=T*(n i:ℝ) := by fin_cases i <;> rfl |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| def angularPeriodize (T : ℝ) (f : Coord3 → E) (x : Coord3) : E := |
| ∑ᶠ n : Fin 2 → ℤ,f (x+angularShift T n) |
|
|
| def AngularPeriodic (T : ℝ) (f : Coord3 → E) : Prop := |
| ∀ n x,f (x+angularShift T n)=f x |
|
|
| omit [NormedSpace ℝ E] in |
| lemma angularPeriodize_periodic (T : ℝ) (f : Coord3 → E) : |
| AngularPeriodic T (angularPeriodize T f) := by |
| intro n x |
| unfold angularPeriodize |
| calc |
| _ = ∑ᶠ m : Fin 2 → ℤ,f (x+angularShift T (m+n)) := by |
| congr 1 |
| funext m |
| rw [angularShift_add] |
| congr 1 |
| abel |
| _ = _ := finsum_comp_equiv (Equiv.addRight n) (f := fun m => f (x+angularShift T m)) |
|
|
| omit [NormedSpace ℝ E] in |
| lemma angular_translates_locallyFinite {T : ℝ} (hT : 0<T) |
| {f : Coord3 → E} (hc : HasCompactSupport f) : |
| LocallyFinite (fun n : Fin 2 → ℤ => Function.support (fun x => f (x+angularShift T n))) := by |
| obtain ⟨R,hR⟩ := hc.isBounded.exists_norm_le |
| intro x |
| obtain ⟨N,hN⟩ := exists_nat_gt ((R+‖x‖+1)/T) |
| refine ⟨Metric.ball x 1,Metric.ball_mem_nhds x zero_lt_one,?_⟩ |
| apply (Set.finite_Icc (fun _ : Fin 2 => -(N:ℤ)) (fun _ => (N:ℤ))).subset |
| rintro n ⟨z,hz,hzx⟩ |
| have hzs : z+angularShift T n∈tsupport f := subset_tsupport f hz |
| have hzn : ‖z‖<‖x‖+1 := by |
| have hh : ‖z‖ ≤ ‖x‖+dist z x := by |
| simpa only [dist_eq_norm,add_comm,norm_sub_rev] using norm_le_norm_add_norm_sub x z |
| linarith [Metric.mem_ball.mp hzx] |
| have hsn : ‖angularShift T n‖<R+‖x‖+1 := by |
| have he : angularShift T n=(z+angularShift T n)-z := by abel |
| rw [he] |
| exact lt_of_le_of_lt (norm_sub_le _ _) (by linarith [hR _ hzs]) |
| have hi (i : Fin 2) : |(n i:ℝ)|<(N:ℝ) := by |
| have hh := (norm_le_pi_norm (angularShift T n) i.succ).trans_lt hsn |
| rw [angularShift_succ,Real.norm_eq_abs,abs_mul,abs_of_pos hT] at hh |
| exact (lt_div_iff₀ hT).mpr (by simpa only [mul_comm] using hh) |>.trans hN |
| constructor |
| · intro i |
| have hh := (abs_lt.mp (hi i)).1.le |
| exact_mod_cast hh |
| · intro i |
| have hh := (abs_lt.mp (hi i)).2.le |
| exact_mod_cast hh |
|
|
| lemma angularPeriodize_smooth {T : ℝ} (hT : 0<T) |
| {f : Coord3 → E} (hf : ContDiff ℝ (↑(⊤:ℕ∞)) f) (hc : HasCompactSupport f) : |
| ContDiff ℝ (↑(⊤:ℕ∞)) (angularPeriodize T f) := by |
| rw [←contMDiff_iff_contDiff] |
| exact contMDiff_finsum (fun n => (contMDiff_iff_contDiff).mpr |
| (hf.comp (contDiff_id.add contDiff_const))) (angular_translates_locallyFinite hT hc) |
|
|
| omit [NormedSpace ℝ E] in |
| lemma angularPeriodize_local_sum {T : ℝ} (hT : 0<T) |
| {f : Coord3 → E} (hc : HasCompactSupport f) (x : Coord3) : |
| ∃ s : Finset (Fin 2 → ℤ),∀ᶠ y in 𝓝 x, |
| angularPeriodize T f y=∑ n∈s,f (y+angularShift T n) ∧ |
| ∀ n,n∉s → f (y+angularShift T n)=0 := by |
| classical |
| obtain ⟨N,hN,hfin⟩ := angular_translates_locallyFinite hT hc x |
| refine ⟨hfin.toFinset,?_⟩ |
| filter_upwards [hN] with y hy |
| have hz (n) (hn : n∉hfin.toFinset) : f (y+angularShift T n)=0 := by |
| by_contra h |
| exact hn (hfin.mem_toFinset.mpr ⟨y,h,hy⟩) |
| exact ⟨finsum_eq_sum_of_support_subset _ (by |
| intro n hn |
| by_contra h |
| exact hn (hz n h)),hz⟩ |
|
|
| end ScalarConductivity |
|
|
|
|
|
|
| namespace ScalarConductivity |
| open Set Filter Topology Matrix |
| open scoped Matrix.Norms.Elementwise |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| omit [NormedSpace ℝ E] in |
| lemma angularPeriodize_finite {T : ℝ} (hT : 0<T) |
| {f : Coord3 → E} (hc : HasCompactSupport f) (x : Coord3) : |
| Function.HasFiniteSupport (fun n => f (x+angularShift T n)) := |
| (angular_translates_locallyFinite hT hc).point_finite x |
|
|
| lemma angularPeriodize_fderiv {T : ℝ} (hT : 0<T) |
| {f : Coord3 → E} (hf : ContDiff ℝ (↑(⊤:ℕ∞)) f) (hc : HasCompactSupport f) (x : Coord3) : |
| fderiv ℝ (angularPeriodize T f) x=angularPeriodize T (fderiv ℝ f) x := by |
| classical |
| obtain ⟨s,hs⟩ := angularPeriodize_local_sum hT hc x |
| have he : angularPeriodize T f=ᶠ[𝓝 x] (fun y => ∑ n∈s,f (y+angularShift T n)) := |
| hs.mono (fun _ h => h.1) |
| rw [he.fderiv_eq] |
| have hn : (fun y => ∑ n∈s,f (y+angularShift T n))=∑ n∈s,(fun y => f (y+angularShift T n)) := by |
| funext y; simp only [Finset.sum_apply] |
| rw [hn,fderiv_sum (A:=fun n y => f (y+angularShift T n)) (fun n _ => |
| (hf.comp (contDiff_id.add (contDiff_const (c:=angularShift T n)))).differentiable (by simp) x)] |
| simp only [fderiv_comp_add_right] |
| symm |
| apply finsum_eq_sum_of_support_subset |
| intro n hn |
| by_contra hns |
| have hz : (fun y => f (y+angularShift T n))=ᶠ[𝓝 x] (fun _ => 0) := |
| hs.mono (fun _ h => h.2 n hns) |
| have hh := hz.fderiv_eq (𝕜:=ℝ) |
| rw [fderiv_comp_add_right] at hh |
| exact hn (hh.trans (fderiv_const_apply (𝕜:=ℝ) (0:E))) |
|
|
| lemma AngularPeriodic.fderiv {T : ℝ} {f : Coord3 → E} (hf : AngularPeriodic T f) : |
| AngularPeriodic T (fderiv ℝ f) := by |
| intro n x |
| have he : (fun y => f (y+angularShift T n))=f := funext (hf n) |
| rw [←fderiv_comp_add_right,he] |
|
|
| lemma coordinateDivergence_comp_add (F : Coord3 → Coord3) (a x : Coord3) : |
| coordinateDivergence (fun y => F (y+a)) x=coordinateDivergence F (x+a) := by |
| unfold coordinateDivergence |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [fderiv_comp_add_right (f:=fun y => F y i)] |
|
|
| lemma symmetricSource_congr_nhds {H K : Coord3 → Mat3} {u : Coord3 → Fin 2 → ℝ} |
| {x : Coord3} (h : H=ᶠ[𝓝 x] K) (j : Fin 2) : |
| symmetricSource H u j x=symmetricSource K u j x := by |
| unfold symmetricSource coordinateDivergence |
| apply Finset.sum_congr rfl |
| intro i _ |
| have he : (fun y => (H y*gradientColumns (fderiv ℝ u y)).col j i)=ᶠ[𝓝 x] |
| (fun y => (K y*gradientColumns (fderiv ℝ u y)).col j i) := by |
| filter_upwards [h] with y hy |
| rw [hy] |
| rw [he.fderiv_eq] |
|
|
| lemma symmetricSource_finset_sum {ι : Type*} (s : Finset ι) (H : ι → Coord3 → Mat3) |
| (hH : ∀ i∈s,ContDiff ℝ (↑(⊤:ℕ∞)) (H i)) |
| {u : Coord3 → Fin 2 → ℝ} (hu : ContDiff ℝ (↑(⊤:ℕ∞)) u) (j : Fin 2) : |
| symmetricSource (∑ i∈s,H i) u j=∑ i∈s,symmetricSource (H i) u j := by |
| classical |
| induction s using Finset.induction with |
| | empty => simp [symmetricSource_zero] |
| | @insert a s ha ih => |
| simp only [Finset.sum_insert ha] |
| have hsum : ContDiff ℝ (↑(⊤:ℕ∞)) (∑ i∈s,H i) := by |
| convert (ContDiff.sum (fun i hi => hH i (Finset.mem_insert_of_mem hi))) using 1 |
| funext y; simp only [Finset.sum_apply] |
| rw [symmetricSource_add (hH a (Finset.mem_insert_self _ _)) hsum hu j, |
| ih (fun i hi => hH i (Finset.mem_insert_of_mem hi))] |
|
|
| lemma symmetricSource_angular_translate {T : ℝ} {u : Coord3 → Fin 2 → ℝ} |
| (hu : AngularPeriodic T u) (H : Coord3 → Mat3) (j : Fin 2) (n : Fin 2 → ℤ) (x : Coord3) : |
| symmetricSource (fun y => H (y+angularShift T n)) u j x= |
| symmetricSource H u j (x+angularShift T n) := by |
| have he : (fun y => (H (y+angularShift T n)*gradientColumns (fderiv ℝ u y)).col j)= |
| (fun y => (H (y+angularShift T n)*gradientColumns (fderiv ℝ u (y+angularShift T n))).col j) := by |
| funext y |
| rw [hu.fderiv n y] |
| unfold symmetricSource |
| rw [he] |
| exact coordinateDivergence_comp_add (fun y => (H y*gradientColumns (fderiv ℝ u y)).col j) _ _ |
|
|
| theorem symmetricSource_angularPeriodize {T : ℝ} (hT : 0<T) |
| {H : Coord3 → Mat3} (hH : ContDiff ℝ (↑(⊤:ℕ∞)) H) (hc : HasCompactSupport H) |
| {u : Coord3 → Fin 2 → ℝ} (hu : ContDiff ℝ (↑(⊤:ℕ∞)) u) (hp : AngularPeriodic T u) |
| (j : Fin 2) (x : Coord3) : |
| symmetricSource (angularPeriodize T H) u j x=angularPeriodize T (symmetricSource H u j) x := by |
| classical |
| obtain ⟨s,hs⟩ := angularPeriodize_local_sum hT hc x |
| have he : angularPeriodize T H=ᶠ[𝓝 x] ∑ n∈s,(fun y => H (y+angularShift T n)) := by |
| filter_upwards [hs] with y hy |
| simpa only [Finset.sum_apply] using hy.1 |
| rw [symmetricSource_congr_nhds he j, |
| symmetricSource_finset_sum s (fun n y => H (y+angularShift T n)) |
| (fun n _ => hH.comp (contDiff_id.add (contDiff_const (c:=angularShift T n)))) hu j] |
| simp only [Finset.sum_apply,symmetricSource_angular_translate hp] |
| symm |
| apply finsum_eq_sum_of_support_subset |
| intro n hn |
| by_contra hns |
| have hz : (fun y => H (y+angularShift T n))=ᶠ[𝓝 x] (0 : Coord3 → Mat3) := |
| hs.mono (fun _ h => h.2 n hns) |
| have hh := symmetricSource_congr_nhds (u:=u) hz j |
| rw [symmetricSource_angular_translate hp,symmetricSource_zero] at hh |
| exact hn hh |
|
|
| lemma angularPeriodize_symmetric {T : ℝ} (hT : 0<T) {H : Coord3 → Mat3} |
| (hc : HasCompactSupport H) (hs : ∀ x,(H x).IsSymm) (x : Coord3) : |
| (angularPeriodize T H x).IsSymm := by |
| obtain ⟨s,h⟩ := angularPeriodize_local_sum hT hc x |
| rw [(h.self_of_nhds).1] |
| classical |
| change (∑ n∈s,H (x+angularShift T n))ᵀ=∑ n∈s,H (x+angularShift T n) |
| rw [Matrix.transpose_sum] |
| exact Finset.sum_congr rfl (fun n _ => hs _) |
|
|
| end ScalarConductivity |
|
|
| end |
|
|
| end OAI |
|
|
