File size: 3,357 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import OAI.Analysis.Calculus.Quaternion.Algebra

/-! Actual differential product rules for quaternionic currents. -/

noncomputable section
namespace OAI.Analysis.Calculus.Quaternion

open scoped Matrix Matrix.Norms.Elementwise

section Algebra
variable {m s : Type*} [Fintype m] [Fintype s]

theorem strongDivergence_add (e : s β†’ Q) (dA dB : m Γ— s β†’ Matrix m m Q) (b : m) :
    strongDivergence e (fun p => dA p + dB p) b =
      strongDivergence e dA b + strongDivergence e dB b := by
  simp [strongDivergence, mul_add, Finset.sum_add_distrib]

theorem strongDivergence_smul (e : s β†’ Q) (dA : m Γ— s β†’ Matrix m m Q)
    (c : ℝ) (b : m) :
    strongDivergence e (fun p => c β€’ dA p) b = c β€’ strongDivergence e dA b := by
  simp [strongDivergence, Finset.smul_sum]

theorem strongDivergence_weighted (e : s β†’ Q) (A : Matrix m m Q)
    (dA : m Γ— s β†’ Matrix m m Q) (g : ℝ) (dg : m Γ— s β†’ ℝ) (b : m) :
    strongDivergence e (fun p => dg p β€’ A + g β€’ dA p) b =
      (star (gradientMap e dg) α΅₯* A) b + g β€’ strongDivergence e dA b := by
  rw [strongDivergence_add, strongDivergence_smul]
  congr 1
  simp [strongDivergence, Matrix.vecMul, dotProduct, gradientMap, Finset.sum_mul]

end Algebra

section Differential
variable {E m s : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [Fintype m] [Fintype s]

private theorem fderiv_real_smul {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
    {g : E β†’ ℝ} {A : E β†’ F} {x : E}
    (hg : DifferentiableAt ℝ g x) (hA : DifferentiableAt ℝ A x) (v : E) :
    fderiv ℝ (fun y => g y β€’ A y) x v =
      fderiv ℝ g x v β€’ A x + g x β€’ fderiv ℝ A x v := by
  have hF := (hg.hasFDerivAt.smul hA.hasFDerivAt).fderiv
  simpa only [add_apply, ContinuousLinearMap.smulRight_apply,
    smul_apply, add_comm] using! congrArg (fun L => L v) hF

theorem fderiv_current_smul {g : E β†’ ℝ} {A : E β†’ Matrix m m Q} {x : E}
    (hg : DifferentiableAt ℝ g x) (hA : DifferentiableAt ℝ A x) (v : E) :
    fderiv ℝ (fun y => g y β€’ A y) x v =
      fderiv ℝ g x v β€’ A x + g x β€’ fderiv ℝ A x v := by
  exact fderiv_real_smul hg hA v

theorem strongDivergence_current_smul (e : s β†’ Q) (d : m Γ— s β†’ E)
    {g : E β†’ ℝ} {A : E β†’ Matrix m m Q} {x : E}
    (hg : DifferentiableAt ℝ g x) (hA : DifferentiableAt ℝ A x) (b : m) :
    strongDivergence e (fun p => fderiv ℝ (fun y => g y β€’ A y) x (d p)) b =
      (star (gradientMap e (fun p => fderiv ℝ g x (d p))) α΅₯* A x) b +
        g x β€’ strongDivergence e (fun p => fderiv ℝ A x (d p)) b := by
  simp only [fderiv_current_smul hg hA]
  exact strongDivergence_weighted e (A x) _ (g x) _ b

/-- Multiplication by a real function preserves current conservation whenever
the current annihilates its quaternionic gradient. -/
theorem strongDivergence_current_smul_zero (e : s β†’ Q) (d : m Γ— s β†’ E)
    {g : E β†’ ℝ} {A : E β†’ Matrix m m Q} {x : E}
    (hg : DifferentiableAt ℝ g x) (hA : DifferentiableAt ℝ A x)
    (hG : star (gradientMap e (fun p => fderiv ℝ g x (d p))) α΅₯* A x = 0)
    (hdiv : βˆ€ b, strongDivergence e (fun p => fderiv ℝ A x (d p)) b = 0) (b : m) :
    strongDivergence e (fun p => fderiv ℝ (fun y => g y β€’ A y) x (d p)) b = 0 := by
  rw [strongDivergence_current_smul e d hg hA, hG, hdiv]
  simp

end Differential
end OAI.Analysis.Calculus.Quaternion