| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! Exact differential-algebra identities of the physical and normalized |
| augmented elasticity systems. Smooth derivatives are constructed below; |
| commutation and Leibniz are proved, not postulated for the physical operator. -/ |
| noncomputable section |
| open scoped BigOperators |
| namespace ElasticityAugmented |
|
|
| abbrev X := EuclideanSpace ℝ (Fin 3) |
| def e (i : Fin 3) : X := EuclideanSpace.single i 1 |
|
|
| def smoothAlgebra : Subalgebra ℂ (X → ℂ) where |
| carrier := {f | ContDiff ℝ (⊤ : ℕ∞) f} |
| add_mem' := by |
| intro f g hf hg |
| change ContDiff ℝ (⊤ : ℕ∞) f at hf |
| change ContDiff ℝ (⊤ : ℕ∞) g at hg |
| exact hf.add hg |
| mul_mem' := by |
| intro f g hf hg |
| change ContDiff ℝ (⊤ : ℕ∞) f at hf |
| change ContDiff ℝ (⊤ : ℕ∞) g at hg |
| exact hf.mul hg |
| zero_mem' := by |
| change ContDiff ℝ (⊤ : ℕ∞) (fun _ : X => (0 : ℂ)) |
| exact contDiff_const |
| one_mem' := by |
| change ContDiff ℝ (⊤ : ℕ∞) (fun _ : X => (1 : ℂ)) |
| exact contDiff_const |
| algebraMap_mem' a := by |
| change ContDiff ℝ (⊤ : ℕ∞) (fun _ : X => a) |
| exact contDiff_const |
|
|
| abbrev Smooth := smoothAlgebra |
|
|
| lemma smooth_coe (f : Smooth) : ContDiff ℝ (⊤ : ℕ∞) (f : X → ℂ) := f.property |
|
|
| /-- Actual coordinate derivative, as a derivation of the smooth function algebra. -/ |
| def coord (i : Fin 3) : Derivation ℂ Smooth Smooth := Derivation.mk' |
| { toFun := fun f => ⟨fun x => fderiv ℝ (f : X → ℂ) x (e i), |
| by |
| change ContDiff ℝ (⊤ : ℕ∞) (fun x => fderiv ℝ (f : X → ℂ) x (e i)) |
| exact ((smooth_coe f).fderiv_right (m := (⊤ : ℕ∞)) (by simp)).clm_apply contDiff_const⟩ |
| map_add' := by |
| intro f g |
| apply Subtype.ext |
| funext x |
| exact congrArg (fun L : X →L[ℝ] ℂ => L (e i)) |
| (fderiv_add ((smooth_coe f).differentiable (by simp) x) |
| ((smooth_coe g).differentiable (by simp) x)) |
| map_smul' := by |
| intro a f |
| apply Subtype.ext |
| funext x |
| exact congrArg (fun L : X →L[ℝ] ℂ => L (e i)) |
| (fderiv_const_smul ((smooth_coe f).differentiable (by simp) x) a) } |
| (by |
| intro f g |
| apply Subtype.ext |
| funext x |
| exact congrArg (fun L : X →L[ℝ] ℂ => L (e i)) |
| (fderiv_mul ((smooth_coe f).differentiable (by simp) x) |
| ((smooth_coe g).differentiable (by simp) x))) |
|
|
| lemma coord_apply (i : Fin 3) (f : Smooth) (x : X) : |
| (coord i f : X → ℂ) x = fderiv ℝ (f : X → ℂ) x (e i) := rfl |
|
|
| lemma coord_coord (f : Smooth) (i j : Fin 3) (x : X) : |
| (coord i (coord j f) : X → ℂ) x = fderiv ℝ (fderiv ℝ (f : X → ℂ)) x (e i) (e j) := by |
| have hd : Differentiable ℝ (fderiv ℝ (f : X → ℂ)) := |
| ((smooth_coe f).fderiv_right (m := (⊤ : ℕ∞)) (by simp)).differentiable (by simp) |
| change fderiv ℝ (fun y => fderiv ℝ (f : X → ℂ) y (e j)) x (e i) = _ |
| rw [fderiv_clm_apply (hd x) (differentiableAt_const (e j))] |
| simp |
|
|
| lemma coord_commute (i j : Fin 3) (f : Smooth) : coord i (coord j f) = coord j (coord i f) := by |
| apply Subtype.ext |
| funext x |
| rw [coord_coord, coord_coord] |
| exact (smooth_coe f).contDiffAt.isSymmSndFDerivAt (by |
| simp only [minSmoothness_of_isRCLikeNormedField] |
| exact WithTop.coe_le_coe.mpr (le_top : (2 : ℕ∞) ≤ ⊤)) _ _ |
|
|
| section DifferentialAlgebra |
| variable {A : Type*} [CommRing A] [Algebra ℂ A] |
| variable {ι : Type*} [Fintype ι] |
| variable (D : ι → Derivation ℂ A A) |
|
|
| omit [Fintype ι] in |
| lemma partial_mul (i : ι) (a b : A) : D i (a*b) = D i a*b + a*D i b := by |
| simpa only [smul_eq_mul, add_comm, mul_comm] using (D i).leibniz a b |
|
|
| def lap (f : A) : A := ∑ i, D i (D i f) |
| def div (u : ι → A) : A := ∑ i, D i (u i) |
| def cm (m : A) (u : ι → A) (i : ι) : A := |
| ∑ j, D j m * (D j (u i) + D i (u j)) |
| def R (lam m : A) (u : ι → A) (d : A) (i : ι) : A := |
| m * lap D (u i) + (lam+m)*D i d + cm D m u i + D i lam*d |
| def S (lam m : A) (u : ι → A) (d : A) : A := |
| (lam+m+m)*lap D d + 2*(∑ i, D i (lam+m)*D i d) + |
| 2*(∑ i, D i m*lap D (u i)) + |
| 2*(∑ i, ∑ j, D i (D j m)*D i (u j)) + lap D lam*d |
| def P (m : A) (f : A) : A := m*lap D f + ∑ i, D i m*D i f |
|
|
| variable (hD : ∀ i j f, D i (D j f) = D j (D i f)) |
| include hD |
|
|
| lemma partial_lap (i : ι) (f : A) : D i (lap D f) = lap D (D i f) := by |
| simp only [lap, map_sum] |
| apply Finset.sum_congr rfl |
| intro j _ |
| rw [hD i j, hD i j] |
|
|
| lemma div_lap (u : ι → A) : div D (fun i => lap D (u i)) = lap D (div D u) := by |
| simp only [div, lap, map_sum] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro j _ |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [hD i j, hD i j] |
|
|
| lemma div_cm (m : A) (u : ι → A) : |
| div D (cm D m u) = |
| 2*(∑ i, ∑ j, D i (D j m)*D i (u j)) + |
| (∑ i, D i m*D i (div D u)) + (∑ i, D i m*lap D (u i)) := by |
| have hH : (∑ i, ∑ j, D i (D j m)*D j (u i)) = |
| ∑ i, ∑ j, D i (D j m)*D i (u j) := by |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| rw [hD j i] |
| have hv : (∑ i, ∑ j, D j m * D i (D j (u i))) = |
| ∑ j, D j m*D j (div D u) := by |
| rw [Finset.sum_comm] |
| simp only [div, map_sum, Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro j _ |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [hD i j] |
| have hl : (∑ i, ∑ j, D j m * D i (D i (u j))) = |
| ∑ j, D j m*lap D (u j) := by |
| rw [Finset.sum_comm] |
| simp only [lap, Finset.mul_sum] |
| simp only [div, cm, map_sum, partial_mul, map_add, mul_add, Finset.sum_add_distrib] |
| rw [hH, hv, hl] |
| simp only [div, map_sum] |
| ring |
|
|
| /-- The independent scalar compatibility identity, before imposing d=div u. -/ |
| theorem augmented_identity (lam m : A) (u : ι → A) (d : A) : |
| div D (R D lam m u d) - S D lam m u d = P D m (div D u-d) := by |
| have hL := div_lap D hD u |
| have hC := div_cm D hD m u |
| simp only [div] at hL hC |
| simp only [div, R, map_add, partial_mul, Finset.sum_add_distrib] |
| rw [← Finset.mul_sum, hL, hC] |
| simp only [S, P, lap, map_sub, map_add, map_sum, mul_sub, add_mul, mul_add, |
| Finset.sum_add_distrib, Finset.sum_sub_distrib, Finset.mul_sum, Finset.sum_mul] |
| ring_nf |
| simp only [← Finset.sum_mul, ← Finset.mul_sum] |
| ring |
|
|
| end DifferentialAlgebra |
|
|
| /-- No commuting-derivation hypothesis remains for actual smooth functions. -/ |
| theorem smooth_augmented_identity (lam m : Smooth) (u : Fin 3 → Smooth) (d : Smooth) : |
| div coord (R coord lam m u d) - S coord lam m u d = P coord m (div coord u-d) := |
| augmented_identity coord coord_commute lam m u d |
|
|
| section CovariantAlgebra |
| variable {A : Type*} [CommRing A] [Algebra ℂ A] |
| variable {ι : Type*} [Fintype ι] |
| variable (D : ι → Derivation ℂ A A) (T : ι → A →ₗ[ℂ] A) |
|
|
| def lapT (f : A) : A := ∑ i, T i (T i f) |
| def divT (u : ι → A) : A := ∑ i, T i (u i) |
| def cmT (m : A) (u : ι → A) (i : ι) : A := |
| ∑ j, D j m * (T j (u i) + T i (u j)) |
| def RT (lam m : A) (u : ι → A) (d : A) (i : ι) : A := |
| m * lapT T (u i) + (lam+m)*T i d + cmT D T m u i + D i lam*d |
| def ST (lam m : A) (u : ι → A) (d : A) : A := |
| (lam+m+m)*lapT T d + 2*(∑ i, D i (lam+m)*T i d) + |
| 2*(∑ i, D i m*lapT T (u i)) + |
| 2*(∑ i, ∑ j, D i (D j m)*T i (u j)) + lap D lam*d |
| def PT (m : A) (f : A) : A := m*lapT T f + ∑ i, D i m*T i f |
|
|
| variable (hD : ∀ i j f, D i (D j f) = D j (D i f)) |
| variable (hT : ∀ i j f, T i (T j f) = T j (T i f)) |
| variable (hTD : ∀ i a b, T i (a*b) = D i a*b+a*T i b) |
|
|
| include hT in |
| lemma covariant_div_lap (u : ι → A) : divT T (fun i => lapT T (u i)) = lapT T (divT T u) := by |
| simp only [divT, lapT, map_sum] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro j _ |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [hT i j, hT i j] |
|
|
| include hD hT hTD in |
| lemma covariant_div_cm (m : A) (u : ι → A) : |
| divT T (cmT D T m u) = |
| 2*(∑ i, ∑ j, D i (D j m)*T i (u j)) + |
| (∑ i, D i m*T i (divT T u)) + (∑ i, D i m*lapT T (u i)) := by |
| have hH : (∑ i, ∑ j, D i (D j m)*T j (u i)) = |
| ∑ i, ∑ j, D i (D j m)*T i (u j) := by |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| rw [hD j i] |
| have hv : (∑ i, ∑ j, D j m * T i (T j (u i))) = |
| ∑ j, D j m*T j (divT T u) := by |
| rw [Finset.sum_comm] |
| simp only [divT, map_sum, Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro j _ |
| apply Finset.sum_congr rfl |
| intro i _ |
| rw [hT i j] |
| have hl : (∑ i, ∑ j, D j m * T i (T i (u j))) = |
| ∑ j, D j m*lapT T (u j) := by |
| rw [Finset.sum_comm] |
| simp only [lapT, Finset.mul_sum] |
| simp only [divT, cmT, map_sum, hTD, map_add, mul_add, Finset.sum_add_distrib] |
| rw [hH, hv, hl] |
| simp only [divT, map_sum] |
| ring |
|
|
| include hD hT hTD in |
| /-- Compatibility after conjugation, proved for the genuine connection |
| Leibniz rule rather than falsely treating a shifted derivative as a derivation. -/ |
| theorem covariant_augmented_identity (lam m : A) (u : ι → A) (d : A) : |
| divT T (RT D T lam m u d) - ST D T lam m u d = PT D T m (divT T u-d) := by |
| have hL := covariant_div_lap T hT u |
| have hC := covariant_div_cm D T hD hT hTD m u |
| simp only [divT] at hL hC |
| simp only [divT, RT, map_add, hTD, Finset.sum_add_distrib] |
| rw [← Finset.mul_sum, hL, hC] |
| simp only [ST, PT, lap, lapT, map_sub, map_add, map_sum, mul_sub, add_mul, mul_add, |
| Finset.sum_add_distrib, Finset.sum_sub_distrib, Finset.mul_sum, Finset.sum_mul] |
| ring_nf |
| simp only [← Finset.sum_mul, ← Finset.mul_sum] |
| ring |
|
|
| /-- The physical stress-divergence, using the conjugated coordinate derivative. -/ |
| def LT (lam m : A) (u : ι → A) (i : ι) : A := |
| T i (lam * divT T u) + ∑ j, T j (m*(T j (u i)+T i (u j))) |
|
|
| include hT hTD in |
| lemma physical_conjugated_expansion (lam m : A) (u : ι → A) (i : ι) : |
| LT T lam m u i = RT D T lam m u (divT T u) i := by |
| have ht : (∑ j, T j (T i (u j))) = T i (divT T u) := by |
| simp only [divT, map_sum] |
| apply Finset.sum_congr rfl |
| intro j _ |
| rw [hT j i] |
| simp only [LT, RT, hTD, map_add, mul_add, Finset.sum_add_distrib, ← Finset.mul_sum] |
| rw [ht] |
| simp only [cmT, lapT, mul_add, Finset.sum_add_distrib] |
| ring |
|
|
| /-- A complex constant phase shifts an actual coordinate derivative. -/ |
| def shifted (z : ι → ℂ) (i : ι) : A →ₗ[ℂ] A := |
| (D i).toLinearMap + z i • LinearMap.id |
|
|
| omit [Fintype ι] in |
| lemma shifted_apply (z : ι → ℂ) (i : ι) (f : A) : |
| shifted D z i f = D i f + z i • f := rfl |
|
|
| omit [Fintype ι] in |
| lemma shifted_mul (z : ι → ℂ) (i : ι) (a b : A) : |
| shifted D z i (a*b) = D i a*b+a*shifted D z i b := by |
| simp only [shifted_apply, partial_mul, Algebra.smul_def] |
| ring |
|
|
| include hD in |
| omit [Fintype ι] in |
| lemma shifted_commute (z : ι → ℂ) (i j : ι) (f : A) : |
| shifted D z i (shifted D z j f) = shifted D z j (shifted D z i f) := by |
| simp only [shifted_apply, map_add, map_smul, smul_add, smul_smul, hD i j] |
| simp only [Algebra.smul_def] |
| ring_nf |
|
|
| theorem shifted_physical_expansion (z : ι → ℂ) (lam m : A) (u : ι → A) |
| (hc : ∀ i j f, D i (D j f) = D j (D i f)) (i : ι) : |
| LT (shifted D z) lam m u i = RT D (shifted D z) lam m u (divT (shifted D z) u) i := |
| physical_conjugated_expansion D (shifted D z) (shifted_commute D hc z) (shifted_mul D z) lam m u i |
|
|
| theorem shifted_physical_divergence (z : ι → ℂ) (lam m : A) (u : ι → A) |
| (hc : ∀ i j f, D i (D j f) = D j (D i f)) : |
| divT (shifted D z) (LT (shifted D z) lam m u) = |
| ST D (shifted D z) lam m u (divT (shifted D z) u) := by |
| have he := covariant_augmented_identity D (shifted D z) hc (shifted_commute D hc z) |
| (shifted_mul D z) lam m u (divT (shifted D z) u) |
| rw [sub_self] at he |
| simp only [PT, lapT, map_zero, mul_zero, Finset.sum_const_zero, add_zero] at he |
| rw [← sub_eq_zero] |
| convert he using 1 |
| congr 2 |
| funext i |
| exact shifted_physical_expansion D z lam m u hc i |
|
|
| end CovariantAlgebra |
|
|
| variable {A : Type*} [CommRing A] [Algebra ℂ A] |
| variable {ι : Type*} [Fintype ι] |
| variable (D : ι → Derivation ℂ A A) (T : ι → A →ₗ[ℂ] A) |
|
|
| lemma grad_cm (m : A) (u : ι → A) : |
| (∑ i, D i m*cmT D T m u i) = |
| 2*(∑ i, ∑ j, D i m*D j m*T i (u j)) := by |
| have hs : (∑ i, ∑ j, D i m*D j m*T j (u i)) = |
| ∑ i, ∑ j, D i m*D j m*T i (u j) := by |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro i _ |
| apply Finset.sum_congr rfl |
| intro j _ |
| ring |
| simp only [cmT, Finset.mul_sum, mul_add, ← mul_assoc, Finset.sum_add_distrib] |
| rw [hs] |
| ring_nf |
| simp only [← Finset.sum_mul] |
|
|
| lemma grad_RT (lam m : A) (u : ι → A) (d : A) : |
| (∑ i, D i m*RT D T lam m u d i) = |
| m*(∑ i, D i m*lapT T (u i)) + |
| (lam+m)*(∑ i, D i m*T i d) + |
| 2*(∑ i, ∑ j, D i m*D j m*T i (u j)) + |
| (∑ i, D i m*D i lam)*d := by |
| have hc := grad_cm D T m u |
| simp only [RT, mul_add, Finset.sum_add_distrib] |
| rw [hc] |
| simp only [Finset.mul_sum, mul_assoc, mul_left_comm, mul_comm] |
|
|
| lemma normalized_vector (lam m n : A) (hn : n*m=1) (u : ι → A) (d : A) (i : ι) : |
| n*RT D T lam m u d i = lapT T (u i) + ((lam+m)*n)*T i d + |
| (∑ j, ((n*D j m)*T j (u i) + (n*D j m)*T i (u j))) + |
| (n*D i lam)*d := by |
| simp only [RT, cmT, mul_add, add_mul, Finset.mul_sum, Finset.sum_add_distrib] |
| simp only [← mul_assoc] |
| linear_combination lapT T (u i)*hn |
|
|
| lemma normalized_scalar_numerator (lam m n : A) (hn : n*m=1) |
| (u : ι → A) (d : A) : |
| ST D T lam m u d - 2*n*(∑ i, D i m*RT D T lam m u d i) = |
| (lam+m+m)*lapT T d + |
| 2*(∑ i, (D i (lam+m)-(lam+m)*n*D i m)*T i d) + |
| 2*(∑ i, ∑ j, (D i (D j m)-2*n*D i m*D j m)*T i (u j)) + |
| (lap D lam-2*n*(∑ i, D i m*D i lam))*d := by |
| rw [grad_RT] |
| simp only [ST, sub_mul, Finset.sum_sub_distrib] |
| simp only [mul_assoc, ← Finset.mul_sum] |
| linear_combination -2*(∑ i, D i m*lapT T (u i))*hn |
|
|
| lemma normalized_scalar (lam m n o : A) (hn : n*m=1) (ho : o*(lam+m+m)=1) |
| (u : ι → A) (d : A) : |
| o*(ST D T lam m u d - 2*n*(∑ i, D i m*RT D T lam m u d i)) = |
| lapT T d + |
| (∑ i, (2*o*(D i (lam+m)-(lam+m)*n*D i m))*T i d) + |
| (∑ i, ∑ j, (2*o*(D i (D j m)-2*n*D i m*D j m))*T i (u j)) + |
| (o*(lap D lam-2*n*(∑ i, D i m*D i lam)))*d := by |
| rw [normalized_scalar_numerator D T lam m n hn] |
| simp only [mul_add, Finset.mul_sum, ← mul_assoc, ho, one_mul] |
| ring_nf |
|
|
| end ElasticityAugmented |
|
|
| end |
|
|
| end OAI |
|
|
