File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

full_name: ContinuousLinearMap.hasDerivWithinAt_of_bilinear
code: theorem hasDerivWithinAt_of_bilinear
    (hu : HasDerivWithinAt u u' s x) (hv : HasDerivWithinAt v v' s x) :
    HasDerivWithinAt (fun x ↦ B (u x) (v x)) (B (u x) v' + B u' (v x)) s x 
goal: HasDerivWithinAt (fun x => (B (u x)) (v x)) ((B (u x)) v' + (B u') (v x)) s x

full_name: ContinuousLinearMap.hasDerivAt_of_bilinear
code: theorem hasDerivAt_of_bilinear (hu : HasDerivAt u u' x) (hv : HasDerivAt v v' x) :
    HasDerivAt (fun x ↦ B (u x) (v x)) (B (u x) v' + B u' (v x)) x 
goal: HasDerivAt (fun x => (B (u x)) (v x)) ((B (u x)) v' + (B u') (v x)) x

full_name: ContinuousLinearMap.hasStrictDerivAt_of_bilinear
code: theorem hasStrictDerivAt_of_bilinear (hu : HasStrictDerivAt u u' x) (hv : HasStrictDerivAt v v' x) :
    HasStrictDerivAt (fun x ↦ B (u x) (v x)) (B (u x) v' + B u' (v x)) x 
goal: HasStrictDerivAt (fun x => (B (u x)) (v x)) ((B (u x)) v' + (B u') (v x)) x

full_name: ContinuousLinearMap.derivWithin_of_bilinear
code: theorem derivWithin_of_bilinear (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hu : DifferentiableWithinAt 𝕜 u s x) (hv : DifferentiableWithinAt 𝕜 v s x) :
    derivWithin (fun y => B (u y) (v y)) s x =
      B (u x) (derivWithin v s x) + B (derivWithin u s x) (v x) 
goal: derivWithin (fun y => (B (u y)) (v y)) s x = (B (u x)) (derivWithin v s x) + (B (derivWithin u s x)) (v x)

full_name: ContinuousLinearMap.deriv_of_bilinear
code: theorem deriv_of_bilinear (hu : DifferentiableAt 𝕜 u x) (hv : DifferentiableAt 𝕜 v x) :
    deriv (fun y => B (u y) (v y)) x = B (u x) (deriv v x) + B (deriv u x) (v x) 
goal: deriv (fun y => (B (u y)) (v y)) x = (B (u x)) (deriv v x) + (B (deriv u x)) (v x)

full_name: HasDerivWithinAt.smul
code: theorem HasDerivWithinAt.smul (hc : HasDerivWithinAt c c' s x) (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun y => c y • f y) (c x • f' + c' • f x) s x 
goal: HasDerivWithinAt (fun y => c y • f y) (c x • f' + c' • f x) s x

full_name: HasDerivAt.smul
code: theorem HasDerivAt.smul (hc : HasDerivAt c c' x) (hf : HasDerivAt f f' x) :
    HasDerivAt (fun y => c y • f y) (c x • f' + c' • f x) x 
goal: HasDerivAt (fun y => c y • f y) (c x • f' + c' • f x) x

full_name: HasStrictDerivAt.smul
code: nonrec theorem HasStrictDerivAt.smul (hc : HasStrictDerivAt c c' x) (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun y => c y • f y) (c x • f' + c' • f x) x 
goal: HasStrictDerivAt (fun y => c y • f y) (c x • f' + c' • f x) x

full_name: derivWithin_smul
code: theorem derivWithin_smul (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)
    (hf : DifferentiableWithinAt 𝕜 f s x) :
    derivWithin (fun y => c y • f y) s x = c x • derivWithin f s x + derivWithin c s x • f x 
goal: derivWithin (fun y => c y • f y) s x = c x • derivWithin f s x + derivWithin c s x • f x

full_name: deriv_smul
code: theorem deriv_smul (hc : DifferentiableAt 𝕜 c x) (hf : DifferentiableAt 𝕜 f x) :
    deriv (fun y => c y • f y) x = c x • deriv f x + deriv c x • f x 
goal: deriv (fun y => c y • f y) x = c x • deriv f x + deriv c x • f x

full_name: HasStrictDerivAt.smul_const
code: theorem HasStrictDerivAt.smul_const (hc : HasStrictDerivAt c c' x) (f : F) :
    HasStrictDerivAt (fun y => c y • f) (c' • f) x 
goal: HasStrictDerivAt (fun y => c y • f) (c' • f) x

full_name: HasDerivWithinAt.smul_const
code: theorem HasDerivWithinAt.smul_const (hc : HasDerivWithinAt c c' s x) (f : F) :
    HasDerivWithinAt (fun y => c y • f) (c' • f) s x 
goal: HasDerivWithinAt (fun y => c y • f) (c' • f) s x

full_name: HasDerivAt.smul_const
code: theorem HasDerivAt.smul_const (hc : HasDerivAt c c' x) (f : F) :
    HasDerivAt (fun y => c y • f) (c' • f) x 
goal: HasDerivAt (fun y => c y • f) (c' • f) x

full_name: derivWithin_smul_const
code: theorem derivWithin_smul_const (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hc : DifferentiableWithinAt 𝕜 c s x) (f : F) :
    derivWithin (fun y => c y • f) s x = derivWithin c s x • f 
goal: derivWithin (fun y => c y • f) s x = derivWithin c s x • f

full_name: deriv_smul_const
code: theorem deriv_smul_const (hc : DifferentiableAt 𝕜 c x) (f : F) :
    deriv (fun y => c y • f) x = deriv c x • f 
goal: deriv (fun y => c y • f) x = deriv c x • f

full_name: HasStrictDerivAt.const_smul
code: nonrec theorem HasStrictDerivAt.const_smul (c : R) (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun y => c • f y) (c • f') x 
goal: HasStrictDerivAt (fun y => c • f y) (c • f') x

full_name: HasDerivAtFilter.const_smul
code: nonrec theorem HasDerivAtFilter.const_smul (c : R) (hf : HasDerivAtFilter f f' x L) :
    HasDerivAtFilter (fun y => c • f y) (c • f') x L 
goal: HasDerivAtFilter (fun y => c • f y) (c • f') x L

full_name: HasDerivWithinAt.const_smul
code: nonrec theorem HasDerivWithinAt.const_smul (c : R) (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun y => c • f y) (c • f') s x 
goal: HasDerivWithinAt (fun y => c • f y) (c • f') s x

full_name: HasDerivAt.const_smul
code: nonrec theorem HasDerivAt.const_smul (c : R) (hf : HasDerivAt f f' x) :
    HasDerivAt (fun y => c • f y) (c • f') x 
goal: HasDerivAt (fun y => c • f y) (c • f') x

full_name: derivWithin_const_smul
code: theorem derivWithin_const_smul (hxs : UniqueDiffWithinAt 𝕜 s x) (c : R)
    (hf : DifferentiableWithinAt 𝕜 f s x) :
    derivWithin (fun y => c • f y) s x = c • derivWithin f s x 
goal: derivWithin (fun y => c • f y) s x = c • derivWithin f s x

full_name: deriv_const_smul
code: theorem deriv_const_smul (c : R) (hf : DifferentiableAt 𝕜 f x) :
    deriv (fun y => c • f y) x = c • deriv f x 
goal: deriv (fun y => c • f y) x = c • deriv f x

full_name: deriv_const_smul'
code: /-- A variant of `deriv_const_smul` without differentiability assumption when the scalar
multiplication is by field elements. -/
lemma deriv_const_smul' {f : 𝕜 → F} {x : 𝕜} {R : Type*} [Field R] [Module R F] [SMulCommClass 𝕜 R F]
    [ContinuousConstSMul R F] (c : R) :
    deriv (fun y ↦ c • f y) x = c • deriv f x 
goal: deriv (fun y => c • f y) x = c • deriv f x

full_name: HasDerivWithinAt.mul
code: theorem HasDerivWithinAt.mul (hc : HasDerivWithinAt c c' s x) (hd : HasDerivWithinAt d d' s x) :
    HasDerivWithinAt (fun y => c y * d y) (c' * d x + c x * d') s x 
goal: HasDerivWithinAt (fun y => c y * d y) (c' * d x + c x * d') s x

full_name: HasDerivAt.mul
code: theorem HasDerivAt.mul (hc : HasDerivAt c c' x) (hd : HasDerivAt d d' x) :
    HasDerivAt (fun y => c y * d y) (c' * d x + c x * d') x 
goal: HasDerivAt (fun y => c y * d y) (c' * d x + c x * d') x

full_name: HasStrictDerivAt.mul
code: theorem HasStrictDerivAt.mul (hc : HasStrictDerivAt c c' x) (hd : HasStrictDerivAt d d' x) :
    HasStrictDerivAt (fun y => c y * d y) (c' * d x + c x * d') x 
goal: HasStrictDerivAt (fun y => c y * d y) (c' * d x + c x * d') x

full_name: derivWithin_mul
code: theorem derivWithin_mul (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)
    (hd : DifferentiableWithinAt 𝕜 d s x) :
    derivWithin (fun y => c y * d y) s x = derivWithin c s x * d x + c x * derivWithin d s x 
goal: derivWithin (fun y => c y * d y) s x = derivWithin c s x * d x + c x * derivWithin d s x

full_name: deriv_mul
code: @[simp]
theorem deriv_mul (hc : DifferentiableAt 𝕜 c x) (hd : DifferentiableAt 𝕜 d x) :
    deriv (fun y => c y * d y) x = deriv c x * d x + c x * deriv d x 
goal: deriv (fun y => c y * d y) x = deriv c x * d x + c x * deriv d x

full_name: HasDerivWithinAt.mul_const
code: theorem HasDerivWithinAt.mul_const (hc : HasDerivWithinAt c c' s x) (d : 𝔸) :
    HasDerivWithinAt (fun y => c y * d) (c' * d) s x 
goal: HasDerivWithinAt (fun y => c y * d) (c' * d) s x

full_name: HasDerivAt.mul_const
code: theorem HasDerivAt.mul_const (hc : HasDerivAt c c' x) (d : 𝔸) :
    HasDerivAt (fun y => c y * d) (c' * d) x 
goal: HasDerivAt (fun y => c y * d) (c' * d) x

full_name: hasDerivAt_mul_const
code: theorem hasDerivAt_mul_const (c : 𝕜) : HasDerivAt (fun x => x * c) c x 
goal: HasDerivAt (fun x => x * c) c x

full_name: HasStrictDerivAt.mul_const
code: theorem HasStrictDerivAt.mul_const (hc : HasStrictDerivAt c c' x) (d : 𝔸) :
    HasStrictDerivAt (fun y => c y * d) (c' * d) x 
goal: HasStrictDerivAt (fun y => c y * d) (c' * d) x

full_name: derivWithin_mul_const
code: theorem derivWithin_mul_const (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)
    (d : 𝔸) : derivWithin (fun y => c y * d) s x = derivWithin c s x * d 
goal: derivWithin (fun y => c y * d) s x = derivWithin c s x * d

full_name: deriv_mul_const
code: theorem deriv_mul_const (hc : DifferentiableAt 𝕜 c x) (d : 𝔸) :
    deriv (fun y => c y * d) x = deriv c x * d 
goal: deriv (fun y => c y * d) x = deriv c x * d

full_name: deriv_mul_const_field
code: theorem deriv_mul_const_field (v : 𝕜') : deriv (fun y => u y * v) x = deriv u x * v 
goal: deriv (fun y => u y * v) x = deriv u x * v

full_name: deriv_mul_const_field'
code: @[simp]
theorem deriv_mul_const_field' (v : 𝕜') : (deriv fun x => u x * v) = fun x => deriv u x * v 
goal: (deriv fun x => u x * v) = fun x => deriv u x * v

full_name: HasDerivWithinAt.const_mul
code: theorem HasDerivWithinAt.const_mul (c : 𝔸) (hd : HasDerivWithinAt d d' s x) :
    HasDerivWithinAt (fun y => c * d y) (c * d') s x 
goal: HasDerivWithinAt (fun y => c * d y) (c * d') s x

full_name: HasDerivAt.const_mul
code: theorem HasDerivAt.const_mul (c : 𝔸) (hd : HasDerivAt d d' x) :
    HasDerivAt (fun y => c * d y) (c * d') x 
goal: HasDerivAt (fun y => c * d y) (c * d') x

full_name: HasStrictDerivAt.const_mul
code: theorem HasStrictDerivAt.const_mul (c : 𝔸) (hd : HasStrictDerivAt d d' x) :
    HasStrictDerivAt (fun y => c * d y) (c * d') x 
goal: HasStrictDerivAt (fun y => c * d y) (c * d') x

full_name: derivWithin_const_mul
code: theorem derivWithin_const_mul (hxs : UniqueDiffWithinAt 𝕜 s x) (c : 𝔸)
    (hd : DifferentiableWithinAt 𝕜 d s x) :
    derivWithin (fun y => c * d y) s x = c * derivWithin d s x 
goal: derivWithin (fun y => c * d y) s x = c * derivWithin d s x

full_name: deriv_const_mul
code: theorem deriv_const_mul (c : 𝔸) (hd : DifferentiableAt 𝕜 d x) :
    deriv (fun y => c * d y) x = c * deriv d x 
goal: deriv (fun y => c * d y) x = c * deriv d x

full_name: deriv_const_mul_field
code: theorem deriv_const_mul_field (u : 𝕜') : deriv (fun y => u * v y) x = u * deriv v x 
goal: deriv (fun y => u * v y) x = u * deriv v x

full_name: deriv_const_mul_field'
code: @[simp]
theorem deriv_const_mul_field' (u : 𝕜') : (deriv fun x => u * v x) = fun x => u * deriv v x 
goal: (deriv fun x => u * v x) = fun x => u * deriv v x

full_name: HasDerivAt.finset_prod
code: theorem HasDerivAt.finset_prod (hf : ∀ i ∈ u, HasDerivAt (f i) (f' i) x) :
    HasDerivAt (∏ i ∈ u, f i ·) (∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • f' i) x 
goal: HasDerivAt (fun x => ∏ i ∈ u, f i x) (∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • f' i) x

full_name: HasDerivWithinAt.finset_prod
code: theorem HasDerivWithinAt.finset_prod (hf : ∀ i ∈ u, HasDerivWithinAt (f i) (f' i) s x) :
    HasDerivWithinAt (∏ i ∈ u, f i ·) (∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • f' i) s x 
goal: HasDerivWithinAt (fun x => ∏ i ∈ u, f i x) (∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • f' i) s x

full_name: HasStrictDerivAt.finset_prod
code: theorem HasStrictDerivAt.finset_prod (hf : ∀ i ∈ u, HasStrictDerivAt (f i) (f' i) x) :
    HasStrictDerivAt (∏ i ∈ u, f i ·) (∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • f' i) x 
goal: HasStrictDerivAt (fun x => ∏ i ∈ u, f i x) (∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • f' i) x

full_name: deriv_finset_prod
code: theorem deriv_finset_prod (hf : ∀ i ∈ u, DifferentiableAt 𝕜 (f i) x) :
    deriv (∏ i ∈ u, f i ·) x = ∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • deriv (f i) x 
goal: deriv (fun x => ∏ i ∈ u, f i x) x = ∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • deriv (f i) x

full_name: derivWithin_finset_prod
code: theorem derivWithin_finset_prod (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hf : ∀ i ∈ u, DifferentiableWithinAt 𝕜 (f i) s x) :
    derivWithin (∏ i ∈ u, f i ·) s x =
      ∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • derivWithin (f i) s x 
goal: derivWithin (fun x => ∏ i ∈ u, f i x) s x = ∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • derivWithin (f i) s x

full_name: DifferentiableAt.finset_prod
code: theorem DifferentiableAt.finset_prod (hd : ∀ i ∈ u, DifferentiableAt 𝕜 (f i) x) :
    DifferentiableAt 𝕜 (∏ i ∈ u, f i ·) x 
goal: DifferentiableAt 𝕜 (fun x => ∏ i ∈ u, f i x) x

full_name: DifferentiableWithinAt.finset_prod
code: theorem DifferentiableWithinAt.finset_prod (hd : ∀ i ∈ u, DifferentiableWithinAt 𝕜 (f i) s x) :
    DifferentiableWithinAt 𝕜 (∏ i ∈ u, f i ·) s x 
goal: DifferentiableWithinAt 𝕜 (fun x => ∏ i ∈ u, f i x) s x

full_name: DifferentiableOn.finset_prod
code: theorem DifferentiableOn.finset_prod (hd : ∀ i ∈ u, DifferentiableOn 𝕜 (f i) s) :
    DifferentiableOn 𝕜 (∏ i ∈ u, f i ·) s 
goal: DifferentiableOn 𝕜 (fun x => ∏ i ∈ u, f i x) s

full_name: Differentiable.finset_prod
code: theorem Differentiable.finset_prod (hd : ∀ i ∈ u, Differentiable 𝕜 (f i)) :
    Differentiable 𝕜 (∏ i ∈ u, f i ·) 
goal: Differentiable 𝕜 fun x => ∏ i ∈ u, f i x

full_name: HasDerivAt.div_const
code: theorem HasDerivAt.div_const (hc : HasDerivAt c c' x) (d : 𝕜') :
    HasDerivAt (fun x => c x / d) (c' / d) x 
goal: HasDerivAt (fun x => c x / d) (c' / d) x

full_name: HasDerivWithinAt.div_const
code: theorem HasDerivWithinAt.div_const (hc : HasDerivWithinAt c c' s x) (d : 𝕜') :
    HasDerivWithinAt (fun x => c x / d) (c' / d) s x 
goal: HasDerivWithinAt (fun x => c x / d) (c' / d) s x

full_name: HasStrictDerivAt.div_const
code: theorem HasStrictDerivAt.div_const (hc : HasStrictDerivAt c c' x) (d : 𝕜') :
    HasStrictDerivAt (fun x => c x / d) (c' / d) x 
goal: HasStrictDerivAt (fun x => c x / d) (c' / d) x

full_name: DifferentiableWithinAt.div_const
code: theorem DifferentiableWithinAt.div_const (hc : DifferentiableWithinAt 𝕜 c s x) (d : 𝕜') :
    DifferentiableWithinAt 𝕜 (fun x => c x / d) s x 
goal: DifferentiableWithinAt 𝕜 (fun x => c x / d) s x

full_name: DifferentiableAt.div_const
code: @[simp]
theorem DifferentiableAt.div_const (hc : DifferentiableAt 𝕜 c x) (d : 𝕜') :
    DifferentiableAt 𝕜 (fun x => c x / d) x 
goal: DifferentiableAt 𝕜 (fun x => c x / d) x

full_name: DifferentiableOn.div_const
code: theorem DifferentiableOn.div_const (hc : DifferentiableOn 𝕜 c s) (d : 𝕜') :
    DifferentiableOn 𝕜 (fun x => c x / d) s 
goal: DifferentiableOn 𝕜 (fun x => c x / d) s

full_name: Differentiable.div_const
code: @[simp]
theorem Differentiable.div_const (hc : Differentiable 𝕜 c) (d : 𝕜') :
    Differentiable 𝕜 fun x => c x / d 
goal: Differentiable 𝕜 fun x => c x / d

full_name: derivWithin_div_const
code: theorem derivWithin_div_const (hc : DifferentiableWithinAt 𝕜 c s x)
    (d : 𝕜') (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (fun x => c x / d) s x = derivWithin c s x / d 
goal: derivWithin (fun x => c x / d) s x = derivWithin c s x / d

full_name: deriv_div_const
code: @[simp]
theorem deriv_div_const (d : 𝕜') : deriv (fun x => c x / d) x = deriv c x / d 
goal: deriv (fun x => c x / d) x = deriv c x / d

full_name: HasStrictDerivAt.clm_comp
code: theorem HasStrictDerivAt.clm_comp (hc : HasStrictDerivAt c c' x) (hd : HasStrictDerivAt d d' x) :
    HasStrictDerivAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') x 
goal: HasStrictDerivAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') x

full_name: HasDerivWithinAt.clm_comp
code: theorem HasDerivWithinAt.clm_comp (hc : HasDerivWithinAt c c' s x)
    (hd : HasDerivWithinAt d d' s x) :
    HasDerivWithinAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') s x 
goal: HasDerivWithinAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') s x

full_name: HasDerivAt.clm_comp
code: theorem HasDerivAt.clm_comp (hc : HasDerivAt c c' x) (hd : HasDerivAt d d' x) :
    HasDerivAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') x 
goal: HasDerivAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') x

full_name: derivWithin_clm_comp
code: theorem derivWithin_clm_comp (hc : DifferentiableWithinAt 𝕜 c s x)
    (hd : DifferentiableWithinAt 𝕜 d s x) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (fun y => (c y).comp (d y)) s x =
      (derivWithin c s x).comp (d x) + (c x).comp (derivWithin d s x) 
goal: derivWithin (fun y => (c y).comp (d y)) s x = (derivWithin c s x).comp (d x) + (c x).comp (derivWithin d s x)

full_name: deriv_clm_comp
code: theorem deriv_clm_comp (hc : DifferentiableAt 𝕜 c x) (hd : DifferentiableAt 𝕜 d x) :
    deriv (fun y => (c y).comp (d y)) x = (deriv c x).comp (d x) + (c x).comp (deriv d x) 
goal: deriv (fun y => (c y).comp (d y)) x = (deriv c x).comp (d x) + (c x).comp (deriv d x)

full_name: HasStrictDerivAt.clm_apply
code: theorem HasStrictDerivAt.clm_apply (hc : HasStrictDerivAt c c' x) (hu : HasStrictDerivAt u u' x) :
    HasStrictDerivAt (fun y => (c y) (u y)) (c' (u x) + c x u') x 
goal: HasStrictDerivAt (fun y => (c y) (u y)) (c' (u x) + (c x) u') x

full_name: HasDerivWithinAt.clm_apply
code: theorem HasDerivWithinAt.clm_apply (hc : HasDerivWithinAt c c' s x)
    (hu : HasDerivWithinAt u u' s x) :
    HasDerivWithinAt (fun y => (c y) (u y)) (c' (u x) + c x u') s x 
goal: HasDerivWithinAt (fun y => (c y) (u y)) (c' (u x) + (c x) u') s x

full_name: HasDerivAt.clm_apply
code: theorem HasDerivAt.clm_apply (hc : HasDerivAt c c' x) (hu : HasDerivAt u u' x) :
    HasDerivAt (fun y => (c y) (u y)) (c' (u x) + c x u') x 
goal: HasDerivAt (fun y => (c y) (u y)) (c' (u x) + (c x) u') x

full_name: derivWithin_clm_apply
code: theorem derivWithin_clm_apply (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)
    (hu : DifferentiableWithinAt 𝕜 u s x) :
    derivWithin (fun y => (c y) (u y)) s x = derivWithin c s x (u x) + c x (derivWithin u s x) 
goal: derivWithin (fun y => (c y) (u y)) s x = (derivWithin c s x) (u x) + (c x) (derivWithin u s x)

full_name: deriv_clm_apply
code: theorem deriv_clm_apply (hc : DifferentiableAt 𝕜 c x) (hu : DifferentiableAt 𝕜 u x) :
    deriv (fun y => (c y) (u y)) x = deriv c x (u x) + c x (deriv u x) 
goal: deriv (fun y => (c y) (u y)) x = (deriv c x) (u x) + (c x) (deriv u x)