| import Mathlib |
| import OAI.Analysis.Conductivity.Model |
|
|
| namespace OAI |
|
|
| noncomputable section |
| namespace ScalarConductivity |
| open Real Set Filter Topology MeasureTheory |
|
|
| lemma smooth_deriv_infty {f : ℝ → ℝ} |
| (hf : ContDiff ℝ (↑(⊤ : ℕ∞)) f) : |
| ContDiff ℝ (↑(⊤ : ℕ∞)) (deriv f) := |
| (contDiff_infty_iff_deriv.mp hf).2 |
|
|
| lemma smoothTransition_flat_left {x : ℝ} (hx : x < 0) : |
| deriv smoothTransition x = 0 ∧ deriv (deriv smoothTransition) x = 0 := by |
| have he : smoothTransition =ᶠ[𝓝 x] fun _ => (0 : ℝ) := by |
| filter_upwards [isOpen_Iio.mem_nhds hx] with y hy |
| exact smoothTransition.zero_of_nonpos hy.le |
| exact ⟨by simpa using he.deriv_eq, by simpa using he.deriv.deriv_eq⟩ |
|
|
| lemma smoothTransition_flat_right {x : ℝ} (hx : 1 < x) : |
| deriv smoothTransition x = 0 ∧ deriv (deriv smoothTransition) x = 0 := by |
| have he : smoothTransition =ᶠ[𝓝 x] fun _ => (1 : ℝ) := by |
| filter_upwards [isOpen_Ioi.mem_nhds hx] with y hy |
| exact smoothTransition.one_of_one_le hy.le |
| exact ⟨by simpa using he.deriv_eq, by simpa using he.deriv.deriv_eq⟩ |
|
|
| lemma exists_transition_derivative_bound : ∃ M : ℝ, 1 ≤ M ∧ ∀ x : ℝ, |
| |deriv smoothTransition x| ≤ M ∧ |deriv (deriv smoothTransition) x| ≤ M := by |
| have hc : HasCompactSupport (deriv smoothTransition) := by |
| apply HasCompactSupport.intro (K := Icc (0 : ℝ) 1) isCompact_Icc |
| intro x hx |
| by_cases h : x < 0 |
| · exact (smoothTransition_flat_left h).1 |
| · exact (smoothTransition_flat_right (by simp only [mem_Icc, not_and_or, not_le] at hx |
| rcases hx with hx | hx |
| · exact False.elim (h hx) |
| · exact hx)).1 |
| obtain ⟨M,hM⟩ := hc.exists_bound_of_continuous |
| (smooth_deriv_infty smoothTransition.contDiff).continuous |
| obtain ⟨N,hN⟩ := hc.deriv.exists_bound_of_continuous |
| (smooth_deriv_infty (smooth_deriv_infty smoothTransition.contDiff)).continuous |
| refine ⟨max 1 (max M N), le_max_left _ _, fun x => ⟨?_,?_⟩⟩ |
| · exact (show |deriv smoothTransition x| ≤ M by simpa only [Real.norm_eq_abs] using hM x).trans |
| ((le_max_left M N).trans (le_max_right _ _)) |
| · exact (show |deriv (deriv smoothTransition) x| ≤ N by simpa only [Real.norm_eq_abs] using hN x).trans |
| ((le_max_right M N).trans (le_max_right _ _)) |
|
|
| def crossingOn (L z : ℝ) : ℝ := smoothTransition (4*z/L+3) |
| def crossingOff (L z : ℝ) : ℝ := 1 - smoothTransition (4*z/L-2) |
|
|
| def crossingFirst (L z : ℝ) : ℝ := crossingOff L z * exp (-3*z) |
| def crossingSecond (L z : ℝ) : ℝ := crossingOn L z * exp (-z) |
|
|
| lemma crossingOn_smooth (L : ℝ) : ContDiff ℝ (↑(⊤ : ℕ∞)) (crossingOn L) := by |
| exact smoothTransition.contDiff.comp ((contDiff_const.mul contDiff_id).div_const L |>.add contDiff_const) |
| lemma crossingOff_smooth (L : ℝ) : ContDiff ℝ (↑(⊤ : ℕ∞)) (crossingOff L) := by |
| exact contDiff_const.sub (smoothTransition.contDiff.comp |
| (((contDiff_const.mul contDiff_id).div_const L).sub contDiff_const)) |
| lemma crossingFirst_smooth (L : ℝ) : ContDiff ℝ (↑(⊤ : ℕ∞)) (crossingFirst L) := by |
| exact (crossingOff_smooth L).mul ((contDiff_const.mul contDiff_id).exp) |
| lemma crossingSecond_smooth (L : ℝ) : ContDiff ℝ (↑(⊤ : ℕ∞)) (crossingSecond L) := by |
| exact (crossingOn_smooth L).mul (contDiff_id.neg.exp) |
|
|
| lemma crossingOn_bounds (L z : ℝ) : 0 ≤ crossingOn L z ∧ crossingOn L z ≤ 1 := |
| ⟨smoothTransition.nonneg _,smoothTransition.le_one _⟩ |
| lemma crossingOff_bounds (L z : ℝ) : 0 ≤ crossingOff L z ∧ crossingOff L z ≤ 1 := by |
| constructor <;> dsimp [crossingOff] |
| · linarith [smoothTransition.le_one (4*z/L-2)] |
| · linarith [smoothTransition.nonneg (4*z/L-2)] |
|
|
| lemma crossingOn_eq_zero {L z : ℝ} (hL : 0 < L) (hz : z ≤ -3*L/4) : |
| crossingOn L z = 0 := by |
| apply smoothTransition.zero_of_nonpos |
| have : 4*z/L ≤ -3 := (div_le_iff₀ hL).mpr (by linarith) |
| linarith |
| lemma crossingOn_eq_one {L z : ℝ} (hL : 0 < L) (hz : -L/2 ≤ z) : |
| crossingOn L z = 1 := by |
| apply smoothTransition.one_of_one_le |
| have : -2 ≤ 4*z/L := (le_div_iff₀ hL).mpr (by linarith) |
| linarith |
| lemma crossingOff_eq_one {L z : ℝ} (hL : 0 < L) (hz : z ≤ L/2) : |
| crossingOff L z = 1 := by |
| have : 4*z/L ≤ 2 := (div_le_iff₀ hL).mpr (by linarith) |
| rw [crossingOff,smoothTransition.zero_of_nonpos (by linarith),sub_zero] |
| lemma crossingOff_eq_zero {L z : ℝ} (hL : 0 < L) (hz : 3*L/4 ≤ z) : |
| crossingOff L z = 0 := by |
| have : 3 ≤ 4*z/L := (le_div_iff₀ hL).mpr (by linarith) |
| rw [crossingOff,smoothTransition.one_of_one_le (by linarith),sub_self] |
|
|
| lemma crossingOn_hasDerivAt (L z : ℝ) : HasDerivAt (crossingOn L) |
| ((4/L)*deriv smoothTransition (4*z/L+3)) z := by |
| have h := ((smoothTransition.contDiff (n := ⊤)).differentiable (by simp) (4*z/L+3)).hasDerivAt |
| change HasDerivAt (fun w => smoothTransition (4*w/L+3)) ((4/L)*deriv smoothTransition (4*z/L+3)) z |
| exact (h.comp z (((hasDerivAt_id z).const_mul 4).div_const L |>.add_const 3)).congr_deriv |
| (g' := (4/L)*deriv smoothTransition (4*z/L+3)) |
| (by simp only [mul_one]; ring) |
| lemma crossingOff_hasDerivAt (L z : ℝ) : HasDerivAt (crossingOff L) |
| (-(4/L)*deriv smoothTransition (4*z/L-2)) z := by |
| have h := ((smoothTransition.contDiff (n := ⊤)).differentiable (by simp) (4*z/L-2)).hasDerivAt |
| change HasDerivAt (fun w => 1-smoothTransition (4*w/L-2)) (-(4/L)*deriv smoothTransition (4*z/L-2)) z |
| exact ((h.comp z ((((hasDerivAt_id z).const_mul 4).div_const L).sub_const 2)).const_sub 1).congr_deriv |
| (g' := -(4/L)*deriv smoothTransition (4*z/L-2)) |
| (by simp only [mul_one]; ring) |
|
|
| lemma deriv_crossingOn (L : ℝ) : deriv (crossingOn L) = |
| fun z => (4/L)*deriv smoothTransition (4*z/L+3) := |
| funext fun z => (crossingOn_hasDerivAt L z).deriv |
| lemma deriv_crossingOff (L : ℝ) : deriv (crossingOff L) = |
| fun z => -(4/L)*deriv smoothTransition (4*z/L-2) := |
| funext fun z => (crossingOff_hasDerivAt L z).deriv |
|
|
| lemma crossingOn_second (L z : ℝ) : deriv (deriv (crossingOn L)) z = |
| (4/L)^2*deriv (deriv smoothTransition) (4*z/L+3) := by |
| rw [deriv_crossingOn] |
| have h := ((smooth_deriv_infty smoothTransition.contDiff).differentiable (by simp) (4*z/L+3)).hasDerivAt |
| have hh := (h.comp z ((((hasDerivAt_id z).const_mul 4).div_const L).add_const 3)).const_mul (4/L) |
| convert hh.deriv using 1 <;> simp only [Function.comp_def, id_eq, mul_one] |
| ring |
| lemma crossingOff_second (L z : ℝ) : deriv (deriv (crossingOff L)) z = |
| -(4/L)^2*deriv (deriv smoothTransition) (4*z/L-2) := by |
| rw [deriv_crossingOff] |
| have h := ((smooth_deriv_infty smoothTransition.contDiff).differentiable (by simp) (4*z/L-2)).hasDerivAt |
| have hh := (h.comp z ((((hasDerivAt_id z).const_mul 4).div_const L).sub_const 2)).const_mul (-(4/L)) |
| convert hh.deriv using 1 <;> simp only [Function.comp_def, id_eq, mul_one] |
| ring |
|
|
| end ScalarConductivity |
|
|
| end |
|
|
| end OAI |
|
|
