File: Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean

full_name: ContinuousLinearMap.hasMFDerivWithinAt
code: protected theorem hasMFDerivWithinAt : HasMFDerivWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') f s x f 
goal: HasMFDerivWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) s x f

full_name: ContinuousLinearMap.hasMFDerivAt
code: protected theorem hasMFDerivAt : HasMFDerivAt 𝓘(𝕜, E) 𝓘(𝕜, E') f x f 
goal: HasMFDerivAt 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) x f

full_name: ContinuousLinearMap.mdifferentiableWithinAt
code: protected theorem mdifferentiableWithinAt : MDifferentiableWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') f s x 
goal: MDifferentiableWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) s x

full_name: ContinuousLinearMap.mdifferentiableOn
code: protected theorem mdifferentiableOn : MDifferentiableOn 𝓘(𝕜, E) 𝓘(𝕜, E') f s 
goal: MDifferentiableOn 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) s

full_name: ContinuousLinearMap.mdifferentiableAt
code: protected theorem mdifferentiableAt : MDifferentiableAt 𝓘(𝕜, E) 𝓘(𝕜, E') f x 
goal: MDifferentiableAt 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) x

full_name: ContinuousLinearMap.mdifferentiable
code: protected theorem mdifferentiable : MDifferentiable 𝓘(𝕜, E) 𝓘(𝕜, E') f 
goal: MDifferentiable 𝓘(𝕜, E) 𝓘(𝕜, E') ⇑f

full_name: ContinuousLinearMap.mfderiv_eq
code: theorem mfderiv_eq : mfderiv 𝓘(𝕜, E) 𝓘(𝕜, E') f x = f 
goal: mfderiv 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) x = f

full_name: ContinuousLinearMap.mfderivWithin_eq
code: theorem mfderivWithin_eq (hs : UniqueMDiffWithinAt 𝓘(𝕜, E) s x) :
    mfderivWithin 𝓘(𝕜, E) 𝓘(𝕜, E') f s x = f 
goal: mfderivWithin 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) s x = f

full_name: ContinuousLinearEquiv.hasMFDerivWithinAt
code: protected theorem hasMFDerivWithinAt : HasMFDerivWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') f s x (f : E →L[𝕜] E') 
goal: HasMFDerivWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) s x ↑f

full_name: ContinuousLinearEquiv.hasMFDerivAt
code: protected theorem hasMFDerivAt : HasMFDerivAt 𝓘(𝕜, E) 𝓘(𝕜, E') f x (f : E →L[𝕜] E') 
goal: HasMFDerivAt 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) x ↑f

full_name: ContinuousLinearEquiv.mdifferentiableWithinAt
code: protected theorem mdifferentiableWithinAt : MDifferentiableWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') f s x 
goal: MDifferentiableWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) s x

full_name: ContinuousLinearEquiv.mdifferentiableOn
code: protected theorem mdifferentiableOn : MDifferentiableOn 𝓘(𝕜, E) 𝓘(𝕜, E') f s 
goal: MDifferentiableOn 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) s

full_name: ContinuousLinearEquiv.mdifferentiableAt
code: protected theorem mdifferentiableAt : MDifferentiableAt 𝓘(𝕜, E) 𝓘(𝕜, E') f x 
goal: MDifferentiableAt 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) x

full_name: ContinuousLinearEquiv.mdifferentiable
code: protected theorem mdifferentiable : MDifferentiable 𝓘(𝕜, E) 𝓘(𝕜, E') f 
goal: MDifferentiable 𝓘(𝕜, E) 𝓘(𝕜, E') ⇑f

full_name: ContinuousLinearEquiv.mfderiv_eq
code: theorem mfderiv_eq : mfderiv 𝓘(𝕜, E) 𝓘(𝕜, E') f x = (f : E →L[𝕜] E') 
goal: mfderiv 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) x = ↑f

full_name: ContinuousLinearEquiv.mfderivWithin_eq
code: theorem mfderivWithin_eq (hs : UniqueMDiffWithinAt 𝓘(𝕜, E) s x) :
    mfderivWithin 𝓘(𝕜, E) 𝓘(𝕜, E') f s x = (f : E →L[𝕜] E') 
goal: mfderivWithin 𝓘(𝕜, E) 𝓘(𝕜, E') (⇑f) s x = ↑f

full_name: hasMFDerivAt_id
code: theorem hasMFDerivAt_id (x : M) :
    HasMFDerivAt I I (@id M) x (ContinuousLinearMap.id 𝕜 (TangentSpace I x)) 
goal: HasMFDerivAt I I id x (ContinuousLinearMap.id 𝕜 (TangentSpace I x))

full_name: hasMFDerivWithinAt_id
code: theorem hasMFDerivWithinAt_id (s : Set M) (x : M) :
    HasMFDerivWithinAt I I (@id M) s x (ContinuousLinearMap.id 𝕜 (TangentSpace I x)) 
goal: HasMFDerivWithinAt I I id s x (ContinuousLinearMap.id 𝕜 (TangentSpace I x))

full_name: mdifferentiableAt_id
code: theorem mdifferentiableAt_id : MDifferentiableAt I I (@id M) x 
goal: MDifferentiableAt I I id x

full_name: mdifferentiableWithinAt_id
code: theorem mdifferentiableWithinAt_id : MDifferentiableWithinAt I I (@id M) s x 
goal: MDifferentiableWithinAt I I id s x

full_name: mdifferentiable_id
code: theorem mdifferentiable_id : MDifferentiable I I (@id M) 
goal: MDifferentiable I I id

full_name: mdifferentiableOn_id
code: theorem mdifferentiableOn_id : MDifferentiableOn I I (@id M) s 
goal: MDifferentiableOn I I id s

full_name: mfderiv_id
code: @[simp, mfld_simps]
theorem mfderiv_id : mfderiv I I (@id M) x = ContinuousLinearMap.id 𝕜 (TangentSpace I x) 
goal: mfderiv I I id x = ContinuousLinearMap.id 𝕜 (TangentSpace I x)

full_name: mfderivWithin_id
code: theorem mfderivWithin_id (hxs : UniqueMDiffWithinAt I s x) :
    mfderivWithin I I (@id M) s x = ContinuousLinearMap.id 𝕜 (TangentSpace I x) 
goal: mfderivWithin I I id s x = ContinuousLinearMap.id 𝕜 (TangentSpace I x)

full_name: tangentMap_id
code: @[simp, mfld_simps]
theorem tangentMap_id : tangentMap I I (id : M → M) = id 
goal: tangentMap I I id = id

full_name: tangentMapWithin_id
code: theorem tangentMapWithin_id {p : TangentBundle I M} (hs : UniqueMDiffWithinAt I s p.proj) :
    tangentMapWithin I I (id : M → M) s p = p 
goal: tangentMapWithin I I id s p = p

full_name: hasMFDerivAt_const
code: theorem hasMFDerivAt_const (c : M') (x : M) :
    HasMFDerivAt I I' (fun _ : M => c) x (0 : TangentSpace I x →L[𝕜] TangentSpace I' c) 
goal: HasMFDerivAt I I' (fun x => c) x 0

full_name: hasMFDerivWithinAt_const
code: theorem hasMFDerivWithinAt_const (c : M') (s : Set M) (x : M) :
    HasMFDerivWithinAt I I' (fun _ : M => c) s x (0 : TangentSpace I x →L[𝕜] TangentSpace I' c) 
goal: HasMFDerivWithinAt I I' (fun x => c) s x 0

full_name: mdifferentiableAt_const
code: theorem mdifferentiableAt_const : MDifferentiableAt I I' (fun _ : M => c) x 
goal: MDifferentiableAt I I' (fun x => c) x

full_name: mdifferentiableWithinAt_const
code: theorem mdifferentiableWithinAt_const : MDifferentiableWithinAt I I' (fun _ : M => c) s x 
goal: MDifferentiableWithinAt I I' (fun x => c) s x

full_name: mdifferentiable_const
code: theorem mdifferentiable_const : MDifferentiable I I' fun _ : M => c 
goal: MDifferentiable I I' fun x => c

full_name: mdifferentiableOn_const
code: theorem mdifferentiableOn_const : MDifferentiableOn I I' (fun _ : M => c) s 
goal: MDifferentiableOn I I' (fun x => c) s

full_name: mfderiv_const
code: @[simp, mfld_simps]
theorem mfderiv_const :
    mfderiv I I' (fun _ : M => c) x = (0 : TangentSpace I x →L[𝕜] TangentSpace I' c) 
goal: mfderiv I I' (fun x => c) x = 0

full_name: mfderivWithin_const
code: theorem mfderivWithin_const (hxs : UniqueMDiffWithinAt I s x) :
    mfderivWithin I I' (fun _ : M => c) s x = (0 : TangentSpace I x →L[𝕜] TangentSpace I' c) 
goal: mfderivWithin I I' (fun x => c) s x = 0

full_name: hasMFDerivAt_fst
code: theorem hasMFDerivAt_fst (x : M × M') :
    HasMFDerivAt (I.prod I') I Prod.fst x
      (ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)) 
goal: HasMFDerivAt (I.prod I') I Prod.fst x (ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2))

full_name: hasMFDerivWithinAt_fst
code: theorem hasMFDerivWithinAt_fst (s : Set (M × M')) (x : M × M') :
    HasMFDerivWithinAt (I.prod I') I Prod.fst s x
      (ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)) 
goal: HasMFDerivWithinAt (I.prod I') I Prod.fst s x (ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2))

full_name: mdifferentiableAt_fst
code: theorem mdifferentiableAt_fst {x : M × M'} : MDifferentiableAt (I.prod I') I Prod.fst x 
goal: MDifferentiableAt (I.prod I') I Prod.fst x

full_name: mdifferentiableWithinAt_fst
code: theorem mdifferentiableWithinAt_fst {s : Set (M × M')} {x : M × M'} :
    MDifferentiableWithinAt (I.prod I') I Prod.fst s x 
goal: MDifferentiableWithinAt (I.prod I') I Prod.fst s x

full_name: mdifferentiable_fst
code: theorem mdifferentiable_fst : MDifferentiable (I.prod I') I (Prod.fst : M × M' → M) 
goal: MDifferentiable (I.prod I') I Prod.fst

full_name: mdifferentiableOn_fst
code: theorem mdifferentiableOn_fst {s : Set (M × M')} : MDifferentiableOn (I.prod I') I Prod.fst s 
goal: MDifferentiableOn (I.prod I') I Prod.fst s

full_name: mfderiv_fst
code: @[simp, mfld_simps]
theorem mfderiv_fst {x : M × M'} :
    mfderiv (I.prod I') I Prod.fst x =
      ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2) 
goal: mfderiv (I.prod I') I Prod.fst x = ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)

full_name: mfderivWithin_fst
code: theorem mfderivWithin_fst {s : Set (M × M')} {x : M × M'}
    (hxs : UniqueMDiffWithinAt (I.prod I') s x) :
    mfderivWithin (I.prod I') I Prod.fst s x =
      ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2) 
goal: mfderivWithin (I.prod I') I Prod.fst s x = ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)

full_name: tangentMap_prod_fst
code: @[simp, mfld_simps]
theorem tangentMap_prod_fst {p : TangentBundle (I.prod I') (M × M')} :
    tangentMap (I.prod I') I Prod.fst p = ⟨p.proj.1, p.2.1⟩ 
goal: tangentMap (I.prod I') I Prod.fst p = { proj := p.proj.1, snd := p.snd.1 }

full_name: tangentMapWithin_prod_fst
code: theorem tangentMapWithin_prod_fst {s : Set (M × M')} {p : TangentBundle (I.prod I') (M × M')}
    (hs : UniqueMDiffWithinAt (I.prod I') s p.proj) :
    tangentMapWithin (I.prod I') I Prod.fst s p = ⟨p.proj.1, p.2.1⟩ 
goal: tangentMapWithin (I.prod I') I Prod.fst s p = { proj := p.proj.1, snd := p.snd.1 }

full_name: hasMFDerivAt_snd
code: theorem hasMFDerivAt_snd (x : M × M') :
    HasMFDerivAt (I.prod I') I' Prod.snd x
      (ContinuousLinearMap.snd 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)) 
goal: HasMFDerivAt (I.prod I') I' Prod.snd x (ContinuousLinearMap.snd 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2))

full_name: hasMFDerivWithinAt_snd
code: theorem hasMFDerivWithinAt_snd (s : Set (M × M')) (x : M × M') :
    HasMFDerivWithinAt (I.prod I') I' Prod.snd s x
      (ContinuousLinearMap.snd 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)) 
goal: HasMFDerivWithinAt (I.prod I') I' Prod.snd s x (ContinuousLinearMap.snd 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2))

full_name: mdifferentiableAt_snd
code: theorem mdifferentiableAt_snd {x : M × M'} : MDifferentiableAt (I.prod I') I' Prod.snd x 
goal: MDifferentiableAt (I.prod I') I' Prod.snd x

full_name: mdifferentiableWithinAt_snd
code: theorem mdifferentiableWithinAt_snd {s : Set (M × M')} {x : M × M'} :
    MDifferentiableWithinAt (I.prod I') I' Prod.snd s x 
goal: MDifferentiableWithinAt (I.prod I') I' Prod.snd s x

full_name: mdifferentiable_snd
code: theorem mdifferentiable_snd : MDifferentiable (I.prod I') I' (Prod.snd : M × M' → M') 
goal: MDifferentiable (I.prod I') I' Prod.snd

full_name: mdifferentiableOn_snd
code: theorem mdifferentiableOn_snd {s : Set (M × M')} : MDifferentiableOn (I.prod I') I' Prod.snd s 
goal: MDifferentiableOn (I.prod I') I' Prod.snd s

full_name: mfderiv_snd
code: @[simp, mfld_simps]
theorem mfderiv_snd {x : M × M'} :
    mfderiv (I.prod I') I' Prod.snd x =
      ContinuousLinearMap.snd 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2) 
goal: mfderiv (I.prod I') I' Prod.snd x = ContinuousLinearMap.snd 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)

full_name: mfderivWithin_snd
code: theorem mfderivWithin_snd {s : Set (M × M')} {x : M × M'}
    (hxs : UniqueMDiffWithinAt (I.prod I') s x) :
    mfderivWithin (I.prod I') I' Prod.snd s x =
      ContinuousLinearMap.snd 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2) 
goal: mfderivWithin (I.prod I') I' Prod.snd s x = ContinuousLinearMap.snd 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)

full_name: tangentMap_prod_snd
code: @[simp, mfld_simps]
theorem tangentMap_prod_snd {p : TangentBundle (I.prod I') (M × M')} :
    tangentMap (I.prod I') I' Prod.snd p = ⟨p.proj.2, p.2.2⟩ 
goal: tangentMap (I.prod I') I' Prod.snd p = { proj := p.proj.2, snd := p.snd.2 }

full_name: tangentMapWithin_prod_snd
code: theorem tangentMapWithin_prod_snd {s : Set (M × M')} {p : TangentBundle (I.prod I') (M × M')}
    (hs : UniqueMDiffWithinAt (I.prod I') s p.proj) :
    tangentMapWithin (I.prod I') I' Prod.snd s p = ⟨p.proj.2, p.2.2⟩ 
goal: tangentMapWithin (I.prod I') I' Prod.snd s p = { proj := p.proj.2, snd := p.snd.2 }

full_name: MDifferentiableAt.mfderiv_prod
code: theorem MDifferentiableAt.mfderiv_prod {f : M → M'} {g : M → M''} {x : M}
    (hf : MDifferentiableAt I I' f x) (hg : MDifferentiableAt I I'' g x) :
    mfderiv I (I'.prod I'') (fun x => (f x, g x)) x =
      (mfderiv I I' f x).prod (mfderiv I I'' g x) 
goal: mfderiv I (I'.prod I'') (fun x => (f x, g x)) x = (mfderiv I I' f x).prod (mfderiv I I'' g x)

full_name: mfderiv_prod_left
code: theorem mfderiv_prod_left {x₀ : M} {y₀ : M'} :
    mfderiv I (I.prod I') (fun x => (x, y₀)) x₀ =
      ContinuousLinearMap.inl 𝕜 (TangentSpace I x₀) (TangentSpace I' y₀) 
goal: mfderiv I (I.prod I') (fun x => (x, y₀)) x₀ = ContinuousLinearMap.inl 𝕜 (TangentSpace I x₀) (TangentSpace I' y₀)

full_name: mfderiv_prod_right
code: theorem mfderiv_prod_right {x₀ : M} {y₀ : M'} :
    mfderiv I' (I.prod I') (fun y => (x₀, y)) y₀ =
      ContinuousLinearMap.inr 𝕜 (TangentSpace I x₀) (TangentSpace I' y₀) 
goal: mfderiv I' (I.prod I') (fun y => (x₀, y)) y₀ = ContinuousLinearMap.inr 𝕜 (TangentSpace I x₀) (TangentSpace I' y₀)

full_name: mfderiv_prod_eq_add
code: /-- The total derivative of a function in two variables is the sum of the partial derivatives.
  Note that to state this (without casts) we need to be able to see through the definition of
  `TangentSpace`. -/
theorem mfderiv_prod_eq_add {f : M × M' → M''} {p : M × M'}
    (hf : MDifferentiableAt (I.prod I') I'' f p) :
    mfderiv (I.prod I') I'' f p =
      show E × E' →L[𝕜] E'' from
        mfderiv (I.prod I') I'' (fun z : M × M' => f (z.1, p.2)) p +
          mfderiv (I.prod I') I'' (fun z : M × M' => f (p.1, z.2)) p 
goal: mfderiv (I.prod I') I'' f p =
  let_fun this := mfderiv (I.prod I') I'' (fun z => f (z.1, p.2)) p + mfderiv (I.prod I') I'' (fun z => f (p.1, z.2)) p;
  this

full_name: HasMFDerivAt.add
code: theorem HasMFDerivAt.add (hf : HasMFDerivAt I 𝓘(𝕜, E') f z f')
    (hg : HasMFDerivAt I 𝓘(𝕜, E') g z g') : HasMFDerivAt I 𝓘(𝕜, E') (f + g) z (f' + g') 
goal: HasMFDerivAt I 𝓘(𝕜, E') (f + g) z (f' + g')

full_name: MDifferentiableAt.add
code: theorem MDifferentiableAt.add (hf : MDifferentiableAt I 𝓘(𝕜, E') f z)
    (hg : MDifferentiableAt I 𝓘(𝕜, E') g z) : MDifferentiableAt I 𝓘(𝕜, E') (f + g) z 
goal: MDifferentiableAt I 𝓘(𝕜, E') (f + g) z

full_name: MDifferentiable.add
code: theorem MDifferentiable.add (hf : MDifferentiable I 𝓘(𝕜, E') f)
    (hg : MDifferentiable I 𝓘(𝕜, E') g) : MDifferentiable I 𝓘(𝕜, E') (f + g) 
goal: MDifferentiable I 𝓘(𝕜, E') (f + g)

full_name: mfderiv_add
code: theorem mfderiv_add (hf : MDifferentiableAt I 𝓘(𝕜, E') f z)
    (hg : MDifferentiableAt I 𝓘(𝕜, E') g z) :
    (by exact mfderiv I 𝓘(𝕜, E') (f + g) z : TangentSpace I z →L[𝕜] E') =
      (by exact mfderiv I 𝓘(𝕜, E') f z) + (by exact mfderiv I 𝓘(𝕜, E') g z) 
goal: mfderiv I 𝓘(𝕜, E') (f + g) z = mfderiv I 𝓘(𝕜, E') f z + mfderiv I 𝓘(𝕜, E') g z

full_name: HasMFDerivAt.const_smul
code: theorem HasMFDerivAt.const_smul (hf : HasMFDerivAt I 𝓘(𝕜, E') f z f') (s : 𝕜) :
    HasMFDerivAt I 𝓘(𝕜, E') (s • f) z (s • f') 
goal: HasMFDerivAt I 𝓘(𝕜, E') (s • f) z (s • f')

full_name: MDifferentiableAt.const_smul
code: theorem MDifferentiableAt.const_smul (hf : MDifferentiableAt I 𝓘(𝕜, E') f z) (s : 𝕜) :
    MDifferentiableAt I 𝓘(𝕜, E') (s • f) z 
goal: MDifferentiableAt I 𝓘(𝕜, E') (s • f) z

full_name: MDifferentiable.const_smul
code: theorem MDifferentiable.const_smul (s : 𝕜) (hf : MDifferentiable I 𝓘(𝕜, E') f) :
    MDifferentiable I 𝓘(𝕜, E') (s • f) 
goal: MDifferentiable I 𝓘(𝕜, E') (s • f)

full_name: const_smul_mfderiv
code: theorem const_smul_mfderiv (hf : MDifferentiableAt I 𝓘(𝕜, E') f z) (s : 𝕜) :
    (mfderiv I 𝓘(𝕜, E') (s • f) z : TangentSpace I z →L[𝕜] E') =
      (s • mfderiv I 𝓘(𝕜, E') f z : TangentSpace I z →L[𝕜] E') 
goal: mfderiv I 𝓘(𝕜, E') (s • f) z = s • mfderiv I 𝓘(𝕜, E') f z

full_name: HasMFDerivAt.neg
code: theorem HasMFDerivAt.neg (hf : HasMFDerivAt I 𝓘(𝕜, E') f z f') :
    HasMFDerivAt I 𝓘(𝕜, E') (-f) z (-f') 
goal: HasMFDerivAt I 𝓘(𝕜, E') (-f) z (-f')

full_name: hasMFDerivAt_neg
code: theorem hasMFDerivAt_neg : HasMFDerivAt I 𝓘(𝕜, E') (-f) z (-f') ↔ HasMFDerivAt I 𝓘(𝕜, E') f z f' 
goal: HasMFDerivAt I 𝓘(𝕜, E') (-f) z (-f') ↔ HasMFDerivAt I 𝓘(𝕜, E') f z f'

full_name: MDifferentiableAt.neg
code: theorem MDifferentiableAt.neg (hf : MDifferentiableAt I 𝓘(𝕜, E') f z) :
    MDifferentiableAt I 𝓘(𝕜, E') (-f) z 
goal: MDifferentiableAt I 𝓘(𝕜, E') (-f) z

full_name: mdifferentiableAt_neg
code: theorem mdifferentiableAt_neg :
    MDifferentiableAt I 𝓘(𝕜, E') (-f) z ↔ MDifferentiableAt I 𝓘(𝕜, E') f z 
goal: MDifferentiableAt I 𝓘(𝕜, E') (-f) z ↔ MDifferentiableAt I 𝓘(𝕜, E') f z

full_name: MDifferentiable.neg
code: theorem MDifferentiable.neg (hf : MDifferentiable I 𝓘(𝕜, E') f) : MDifferentiable I 𝓘(𝕜, E') (-f) 
goal: MDifferentiable I 𝓘(𝕜, E') (-f)

full_name: mfderiv_neg
code: theorem mfderiv_neg (f : M → E') (x : M) :
    (mfderiv I 𝓘(𝕜, E') (-f) x : TangentSpace I x →L[𝕜] E') =
      (-mfderiv I 𝓘(𝕜, E') f x : TangentSpace I x →L[𝕜] E') 
goal: mfderiv I 𝓘(𝕜, E') (-f) x = -mfderiv I 𝓘(𝕜, E') f x

full_name: HasMFDerivAt.sub
code: theorem HasMFDerivAt.sub (hf : HasMFDerivAt I 𝓘(𝕜, E') f z f')
    (hg : HasMFDerivAt I 𝓘(𝕜, E') g z g') : HasMFDerivAt I 𝓘(𝕜, E') (f - g) z (f' - g') 
goal: HasMFDerivAt I 𝓘(𝕜, E') (f - g) z (f' - g')

full_name: MDifferentiableAt.sub
code: theorem MDifferentiableAt.sub (hf : MDifferentiableAt I 𝓘(𝕜, E') f z)
    (hg : MDifferentiableAt I 𝓘(𝕜, E') g z) : MDifferentiableAt I 𝓘(𝕜, E') (f - g) z 
goal: MDifferentiableAt I 𝓘(𝕜, E') (f - g) z

full_name: MDifferentiable.sub
code: theorem MDifferentiable.sub (hf : MDifferentiable I 𝓘(𝕜, E') f)
    (hg : MDifferentiable I 𝓘(𝕜, E') g) : MDifferentiable I 𝓘(𝕜, E') (f - g) 
goal: MDifferentiable I 𝓘(𝕜, E') (f - g)

full_name: mfderiv_sub
code: theorem mfderiv_sub (hf : MDifferentiableAt I 𝓘(𝕜, E') f z)
    (hg : MDifferentiableAt I 𝓘(𝕜, E') g z) :
    (by exact mfderiv I 𝓘(𝕜, E') (f - g) z : TangentSpace I z →L[𝕜] E') =
      (by exact mfderiv I 𝓘(𝕜, E') f z) - (by exact mfderiv I 𝓘(𝕜, E') g z) 
goal: mfderiv I 𝓘(𝕜, E') (f - g) z = mfderiv I 𝓘(𝕜, E') f z - mfderiv I 𝓘(𝕜, E') g z

full_name: HasMFDerivWithinAt.mul'
code: theorem HasMFDerivWithinAt.mul' (hp : HasMFDerivWithinAt I 𝓘(𝕜, F') p s z p')
    (hq : HasMFDerivWithinAt I 𝓘(𝕜, F') q s z q') :
    HasMFDerivWithinAt I 𝓘(𝕜, F') (p * q) s z (p z • q' + p'.smulRight (q z) : E →L[𝕜] F') 
goal: HasMFDerivWithinAt I 𝓘(𝕜, F') (p * q) s z (p z • q' + p'.smulRight (q z))

full_name: HasMFDerivAt.mul'
code: theorem HasMFDerivAt.mul' (hp : HasMFDerivAt I 𝓘(𝕜, F') p z p')
    (hq : HasMFDerivAt I 𝓘(𝕜, F') q z q') :
    HasMFDerivAt I 𝓘(𝕜, F') (p * q) z (p z • q' + p'.smulRight (q z) : E →L[𝕜] F') 
goal: HasMFDerivAt I 𝓘(𝕜, F') (p * q) z (p z • q' + p'.smulRight (q z))

full_name: MDifferentiableWithinAt.mul
code: theorem MDifferentiableWithinAt.mul (hp : MDifferentiableWithinAt I 𝓘(𝕜, F') p s z)
    (hq : MDifferentiableWithinAt I 𝓘(𝕜, F') q s z) :
    MDifferentiableWithinAt I 𝓘(𝕜, F') (p * q) s z 
goal: MDifferentiableWithinAt I 𝓘(𝕜, F') (p * q) s z

full_name: MDifferentiableAt.mul
code: theorem MDifferentiableAt.mul (hp : MDifferentiableAt I 𝓘(𝕜, F') p z)
    (hq : MDifferentiableAt I 𝓘(𝕜, F') q z) : MDifferentiableAt I 𝓘(𝕜, F') (p * q) z 
goal: MDifferentiableAt I 𝓘(𝕜, F') (p * q) z

full_name: MDifferentiableOn.mul
code: theorem MDifferentiableOn.mul (hp : MDifferentiableOn I 𝓘(𝕜, F') p s)
    (hq : MDifferentiableOn I 𝓘(𝕜, F') q s) : MDifferentiableOn I 𝓘(𝕜, F') (p * q) s 
goal: MDifferentiableOn I 𝓘(𝕜, F') (p * q) s

full_name: MDifferentiable.mul
code: theorem MDifferentiable.mul (hp : MDifferentiable I 𝓘(𝕜, F') p)
    (hq : MDifferentiable I 𝓘(𝕜, F') q) : MDifferentiable I 𝓘(𝕜, F') (p * q) 
goal: MDifferentiable I 𝓘(𝕜, F') (p * q)

full_name: HasMFDerivWithinAt.mul
code: theorem HasMFDerivWithinAt.mul (hp : HasMFDerivWithinAt I 𝓘(𝕜, F') p s z p')
    (hq : HasMFDerivWithinAt I 𝓘(𝕜, F') q s z q') :
    HasMFDerivWithinAt I 𝓘(𝕜, F') (p * q) s z (p z • q' + q z • p' : E →L[𝕜] F') 
goal: HasMFDerivWithinAt I 𝓘(𝕜, F') (p * q) s z (p z • q' + q z • p')

full_name: HasMFDerivAt.mul
code: theorem HasMFDerivAt.mul (hp : HasMFDerivAt I 𝓘(𝕜, F') p z p')
    (hq : HasMFDerivAt I 𝓘(𝕜, F') q z q') :
    HasMFDerivAt I 𝓘(𝕜, F') (p * q) z (p z • q' + q z • p' : E →L[𝕜] F') 
goal: HasMFDerivAt I 𝓘(𝕜, F') (p * q) z (p z • q' + q z • p')