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

full_name: HasStrictFDerivAt.clm_comp
code: @[fun_prop]
theorem HasStrictFDerivAt.clm_comp (hc : HasStrictFDerivAt c c' x) (hd : HasStrictFDerivAt d d' x) :
    HasStrictFDerivAt (fun y => (c y).comp (d y))
      ((compL 𝕜 F G H (c x)).comp d' + ((compL 𝕜 F G H).flip (d x)).comp c') x 
goal: HasStrictFDerivAt (fun y => (c y).comp (d y))
  (((ContinuousLinearMap.compL 𝕜 F G H) (c x)).comp d' + ((ContinuousLinearMap.compL 𝕜 F G H).flip (d x)).comp c') x

full_name: HasFDerivWithinAt.clm_comp
code: @[fun_prop]
theorem HasFDerivWithinAt.clm_comp (hc : HasFDerivWithinAt c c' s x)
    (hd : HasFDerivWithinAt d d' s x) :
    HasFDerivWithinAt (fun y => (c y).comp (d y))
      ((compL 𝕜 F G H (c x)).comp d' + ((compL 𝕜 F G H).flip (d x)).comp c') s x 
goal: HasFDerivWithinAt (fun y => (c y).comp (d y))
  (((ContinuousLinearMap.compL 𝕜 F G H) (c x)).comp d' + ((ContinuousLinearMap.compL 𝕜 F G H).flip (d x)).comp c') s x

full_name: HasFDerivAt.clm_comp
code: @[fun_prop]
theorem HasFDerivAt.clm_comp (hc : HasFDerivAt c c' x) (hd : HasFDerivAt d d' x) :
    HasFDerivAt (fun y => (c y).comp (d y))
      ((compL 𝕜 F G H (c x)).comp d' + ((compL 𝕜 F G H).flip (d x)).comp c') x 
goal: HasFDerivAt (fun y => (c y).comp (d y))
  (((ContinuousLinearMap.compL 𝕜 F G H) (c x)).comp d' + ((ContinuousLinearMap.compL 𝕜 F G H).flip (d x)).comp c') x

full_name: DifferentiableWithinAt.clm_comp
code: @[fun_prop]
theorem DifferentiableWithinAt.clm_comp (hc : DifferentiableWithinAt 𝕜 c s x)
    (hd : DifferentiableWithinAt 𝕜 d s x) :
    DifferentiableWithinAt 𝕜 (fun y => (c y).comp (d y)) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => (c y).comp (d y)) s x

full_name: DifferentiableAt.clm_comp
code: @[fun_prop]
theorem DifferentiableAt.clm_comp (hc : DifferentiableAt 𝕜 c x) (hd : DifferentiableAt 𝕜 d x) :
    DifferentiableAt 𝕜 (fun y => (c y).comp (d y)) x 
goal: DifferentiableAt 𝕜 (fun y => (c y).comp (d y)) x

full_name: DifferentiableOn.clm_comp
code: @[fun_prop]
theorem DifferentiableOn.clm_comp (hc : DifferentiableOn 𝕜 c s) (hd : DifferentiableOn 𝕜 d s) :
    DifferentiableOn 𝕜 (fun y => (c y).comp (d y)) s 
goal: DifferentiableOn 𝕜 (fun y => (c y).comp (d y)) s

full_name: Differentiable.clm_comp
code: @[fun_prop]
theorem Differentiable.clm_comp (hc : Differentiable 𝕜 c) (hd : Differentiable 𝕜 d) :
    Differentiable 𝕜 fun y => (c y).comp (d y) 
goal: Differentiable 𝕜 fun y => (c y).comp (d y)

full_name: fderivWithin_clm_comp
code: theorem fderivWithin_clm_comp (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)
    (hd : DifferentiableWithinAt 𝕜 d s x) :
    fderivWithin 𝕜 (fun y => (c y).comp (d y)) s x =
      (compL 𝕜 F G H (c x)).comp (fderivWithin 𝕜 d s x) +
        ((compL 𝕜 F G H).flip (d x)).comp (fderivWithin 𝕜 c s x) 
goal: fderivWithin 𝕜 (fun y => (c y).comp (d y)) s x =
  ((ContinuousLinearMap.compL 𝕜 F G H) (c x)).comp (fderivWithin 𝕜 d s x) +
    ((ContinuousLinearMap.compL 𝕜 F G H).flip (d x)).comp (fderivWithin 𝕜 c s x)

full_name: fderiv_clm_comp
code: theorem fderiv_clm_comp (hc : DifferentiableAt 𝕜 c x) (hd : DifferentiableAt 𝕜 d x) :
    fderiv 𝕜 (fun y => (c y).comp (d y)) x =
      (compL 𝕜 F G H (c x)).comp (fderiv 𝕜 d x) +
        ((compL 𝕜 F G H).flip (d x)).comp (fderiv 𝕜 c x) 
goal: fderiv 𝕜 (fun y => (c y).comp (d y)) x =
  ((ContinuousLinearMap.compL 𝕜 F G H) (c x)).comp (fderiv 𝕜 d x) +
    ((ContinuousLinearMap.compL 𝕜 F G H).flip (d x)).comp (fderiv 𝕜 c x)

full_name: HasStrictFDerivAt.clm_apply
code: @[fun_prop]
theorem HasStrictFDerivAt.clm_apply (hc : HasStrictFDerivAt c c' x)
    (hu : HasStrictFDerivAt u u' x) :
    HasStrictFDerivAt (fun y => (c y) (u y)) ((c x).comp u' + c'.flip (u x)) x 
goal: HasStrictFDerivAt (fun y => (c y) (u y)) ((c x).comp u' + c'.flip (u x)) x

full_name: HasFDerivWithinAt.clm_apply
code: @[fun_prop]
theorem HasFDerivWithinAt.clm_apply (hc : HasFDerivWithinAt c c' s x)
    (hu : HasFDerivWithinAt u u' s x) :
    HasFDerivWithinAt (fun y => (c y) (u y)) ((c x).comp u' + c'.flip (u x)) s x 
goal: HasFDerivWithinAt (fun y => (c y) (u y)) ((c x).comp u' + c'.flip (u x)) s x

full_name: HasFDerivAt.clm_apply
code: @[fun_prop]
theorem HasFDerivAt.clm_apply (hc : HasFDerivAt c c' x) (hu : HasFDerivAt u u' x) :
    HasFDerivAt (fun y => (c y) (u y)) ((c x).comp u' + c'.flip (u x)) x 
goal: HasFDerivAt (fun y => (c y) (u y)) ((c x).comp u' + c'.flip (u x)) x

full_name: DifferentiableWithinAt.clm_apply
code: @[fun_prop]
theorem DifferentiableWithinAt.clm_apply (hc : DifferentiableWithinAt 𝕜 c s x)
    (hu : DifferentiableWithinAt 𝕜 u s x) : DifferentiableWithinAt 𝕜 (fun y => (c y) (u y)) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => (c y) (u y)) s x

full_name: DifferentiableAt.clm_apply
code: @[fun_prop]
theorem DifferentiableAt.clm_apply (hc : DifferentiableAt 𝕜 c x) (hu : DifferentiableAt 𝕜 u x) :
    DifferentiableAt 𝕜 (fun y => (c y) (u y)) x 
goal: DifferentiableAt 𝕜 (fun y => (c y) (u y)) x

full_name: DifferentiableOn.clm_apply
code: @[fun_prop]
theorem DifferentiableOn.clm_apply (hc : DifferentiableOn 𝕜 c s) (hu : DifferentiableOn 𝕜 u s) :
    DifferentiableOn 𝕜 (fun y => (c y) (u y)) s 
goal: DifferentiableOn 𝕜 (fun y => (c y) (u y)) s

full_name: Differentiable.clm_apply
code: @[fun_prop]
theorem Differentiable.clm_apply (hc : Differentiable 𝕜 c) (hu : Differentiable 𝕜 u) :
    Differentiable 𝕜 fun y => (c y) (u y) 
goal: Differentiable 𝕜 fun y => (c y) (u y)

full_name: fderivWithin_clm_apply
code: theorem fderivWithin_clm_apply (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hc : DifferentiableWithinAt 𝕜 c s x) (hu : DifferentiableWithinAt 𝕜 u s x) :
    fderivWithin 𝕜 (fun y => (c y) (u y)) s x =
      (c x).comp (fderivWithin 𝕜 u s x) + (fderivWithin 𝕜 c s x).flip (u x) 
goal: fderivWithin 𝕜 (fun y => (c y) (u y)) s x = (c x).comp (fderivWithin 𝕜 u s x) + (fderivWithin 𝕜 c s x).flip (u x)

full_name: fderiv_clm_apply
code: theorem fderiv_clm_apply (hc : DifferentiableAt 𝕜 c x) (hu : DifferentiableAt 𝕜 u x) :
    fderiv 𝕜 (fun y => (c y) (u y)) x = (c x).comp (fderiv 𝕜 u x) + (fderiv 𝕜 c x).flip (u x) 
goal: fderiv 𝕜 (fun y => (c y) (u y)) x = (c x).comp (fderiv 𝕜 u x) + (fderiv 𝕜 c x).flip (u x)

full_name: HasStrictFDerivAt.continuousMultilinear_apply_const
code: @[fun_prop]
theorem HasStrictFDerivAt.continuousMultilinear_apply_const (hc : HasStrictFDerivAt c c' x)
    (u : ∀ i, M i) : HasStrictFDerivAt (fun y ↦ (c y) u) (c'.flipMultilinear u) x 
goal: HasStrictFDerivAt (fun y => (c y) u) (c'.flipMultilinear u) x

full_name: HasFDerivWithinAt.continuousMultilinear_apply_const
code: @[fun_prop]
theorem HasFDerivWithinAt.continuousMultilinear_apply_const (hc : HasFDerivWithinAt c c' s x)
    (u : ∀ i, M i) :
    HasFDerivWithinAt (fun y ↦ (c y) u) (c'.flipMultilinear u) s x 
goal: HasFDerivWithinAt (fun y => (c y) u) (c'.flipMultilinear u) s x

full_name: HasFDerivAt.continuousMultilinear_apply_const
code: @[fun_prop]
theorem HasFDerivAt.continuousMultilinear_apply_const (hc : HasFDerivAt c c' x) (u : ∀ i, M i) :
    HasFDerivAt (fun y ↦ (c y) u) (c'.flipMultilinear u) x 
goal: HasFDerivAt (fun y => (c y) u) (c'.flipMultilinear u) x

full_name: DifferentiableWithinAt.continuousMultilinear_apply_const
code: @[fun_prop]
theorem DifferentiableWithinAt.continuousMultilinear_apply_const
    (hc : DifferentiableWithinAt 𝕜 c s x) (u : ∀ i, M i) :
    DifferentiableWithinAt 𝕜 (fun y ↦ (c y) u) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => (c y) u) s x

full_name: DifferentiableAt.continuousMultilinear_apply_const
code: @[fun_prop]
theorem DifferentiableAt.continuousMultilinear_apply_const (hc : DifferentiableAt 𝕜 c x)
    (u : ∀ i, M i) :
    DifferentiableAt 𝕜 (fun y ↦ (c y) u) x 
goal: DifferentiableAt 𝕜 (fun y => (c y) u) x

full_name: DifferentiableOn.continuousMultilinear_apply_const
code: @[fun_prop]
theorem DifferentiableOn.continuousMultilinear_apply_const (hc : DifferentiableOn 𝕜 c s)
    (u : ∀ i, M i) : DifferentiableOn 𝕜 (fun y ↦ (c y) u) s 
goal: DifferentiableOn 𝕜 (fun y => (c y) u) s

full_name: Differentiable.continuousMultilinear_apply_const
code: @[fun_prop]
theorem Differentiable.continuousMultilinear_apply_const (hc : Differentiable 𝕜 c) (u : ∀ i, M i) :
    Differentiable 𝕜 fun y ↦ (c y) u 
goal: Differentiable 𝕜 fun y => (c y) u

full_name: fderivWithin_continuousMultilinear_apply_const
code: theorem fderivWithin_continuousMultilinear_apply_const (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hc : DifferentiableWithinAt 𝕜 c s x) (u : ∀ i, M i) :
    fderivWithin 𝕜 (fun y ↦ (c y) u) s x = ((fderivWithin 𝕜 c s x).flipMultilinear u) 
goal: fderivWithin 𝕜 (fun y => (c y) u) s x = (fderivWithin 𝕜 c s x).flipMultilinear u

full_name: fderiv_continuousMultilinear_apply_const
code: theorem fderiv_continuousMultilinear_apply_const (hc : DifferentiableAt 𝕜 c x) (u : ∀ i, M i) :
    (fderiv 𝕜 (fun y ↦ (c y) u) x) = (fderiv 𝕜 c x).flipMultilinear u 
goal: fderiv 𝕜 (fun y => (c y) u) x = (fderiv 𝕜 c x).flipMultilinear u

full_name: fderivWithin_continuousMultilinear_apply_const_apply
code: /-- Application of a `ContinuousMultilinearMap` to a constant commutes with `fderivWithin`. -/
theorem fderivWithin_continuousMultilinear_apply_const_apply (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hc : DifferentiableWithinAt 𝕜 c s x) (u : ∀ i, M i) (m : E) :
    (fderivWithin 𝕜 (fun y ↦ (c y) u) s x) m = (fderivWithin 𝕜 c s x) m u 
goal: (fderivWithin 𝕜 (fun y => (c y) u) s x) m = ((fderivWithin 𝕜 c s x) m) u

full_name: fderiv_continuousMultilinear_apply_const_apply
code: /-- Application of a `ContinuousMultilinearMap` to a constant commutes with `fderiv`. -/
theorem fderiv_continuousMultilinear_apply_const_apply (hc : DifferentiableAt 𝕜 c x)
    (u : ∀ i, M i) (m : E) :
    (fderiv 𝕜 (fun y ↦ (c y) u) x) m = (fderiv 𝕜 c x) m u 
goal: (fderiv 𝕜 (fun y => (c y) u) x) m = ((fderiv 𝕜 c x) m) u

full_name: HasStrictFDerivAt.smul
code: @[fun_prop]
theorem HasStrictFDerivAt.smul (hc : HasStrictFDerivAt c c' x) (hf : HasStrictFDerivAt f f' x) :
    HasStrictFDerivAt (fun y => c y • f y) (c x • f' + c'.smulRight (f x)) x 
goal: HasStrictFDerivAt (fun y => c y • f y) (c x • f' + c'.smulRight (f x)) x

full_name: HasFDerivWithinAt.smul
code: @[fun_prop]
theorem HasFDerivWithinAt.smul (hc : HasFDerivWithinAt c c' s x) (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (fun y => c y • f y) (c x • f' + c'.smulRight (f x)) s x 
goal: HasFDerivWithinAt (fun y => c y • f y) (c x • f' + c'.smulRight (f x)) s x

full_name: HasFDerivAt.smul
code: @[fun_prop]
theorem HasFDerivAt.smul (hc : HasFDerivAt c c' x) (hf : HasFDerivAt f f' x) :
    HasFDerivAt (fun y => c y • f y) (c x • f' + c'.smulRight (f x)) x 
goal: HasFDerivAt (fun y => c y • f y) (c x • f' + c'.smulRight (f x)) x

full_name: DifferentiableWithinAt.smul
code: @[fun_prop]
theorem DifferentiableWithinAt.smul (hc : DifferentiableWithinAt 𝕜 c s x)
    (hf : DifferentiableWithinAt 𝕜 f s x) : DifferentiableWithinAt 𝕜 (fun y => c y • f y) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => c y • f y) s x

full_name: DifferentiableAt.smul
code: @[simp, fun_prop]
theorem DifferentiableAt.smul (hc : DifferentiableAt 𝕜 c x) (hf : DifferentiableAt 𝕜 f x) :
    DifferentiableAt 𝕜 (fun y => c y • f y) x 
goal: DifferentiableAt 𝕜 (fun y => c y • f y) x

full_name: DifferentiableOn.smul
code: @[fun_prop]
theorem DifferentiableOn.smul (hc : DifferentiableOn 𝕜 c s) (hf : DifferentiableOn 𝕜 f s) :
    DifferentiableOn 𝕜 (fun y => c y • f y) s 
goal: DifferentiableOn 𝕜 (fun y => c y • f y) s

full_name: Differentiable.smul
code: @[simp, fun_prop]
theorem Differentiable.smul (hc : Differentiable 𝕜 c) (hf : Differentiable 𝕜 f) :
    Differentiable 𝕜 fun y => c y • f y 
goal: Differentiable 𝕜 fun y => c y • f y

full_name: fderivWithin_smul
code: theorem fderivWithin_smul (hxs : UniqueDiffWithinAt 𝕜 s x) (hc : DifferentiableWithinAt 𝕜 c s x)
    (hf : DifferentiableWithinAt 𝕜 f s x) :
    fderivWithin 𝕜 (fun y => c y • f y) s x =
      c x • fderivWithin 𝕜 f s x + (fderivWithin 𝕜 c s x).smulRight (f x) 
goal: fderivWithin 𝕜 (fun y => c y • f y) s x = c x • fderivWithin 𝕜 f s x + (fderivWithin 𝕜 c s x).smulRight (f x)

full_name: fderiv_smul
code: theorem fderiv_smul (hc : DifferentiableAt 𝕜 c x) (hf : DifferentiableAt 𝕜 f x) :
    fderiv 𝕜 (fun y => c y • f y) x = c x • fderiv 𝕜 f x + (fderiv 𝕜 c x).smulRight (f x) 
goal: fderiv 𝕜 (fun y => c y • f y) x = c x • fderiv 𝕜 f x + (fderiv 𝕜 c x).smulRight (f x)

full_name: HasStrictFDerivAt.smul_const
code: @[fun_prop]
theorem HasStrictFDerivAt.smul_const (hc : HasStrictFDerivAt c c' x) (f : F) :
    HasStrictFDerivAt (fun y => c y • f) (c'.smulRight f) x 
goal: HasStrictFDerivAt (fun y => c y • f) (c'.smulRight f) x

full_name: HasFDerivWithinAt.smul_const
code: @[fun_prop]
theorem HasFDerivWithinAt.smul_const (hc : HasFDerivWithinAt c c' s x) (f : F) :
    HasFDerivWithinAt (fun y => c y • f) (c'.smulRight f) s x 
goal: HasFDerivWithinAt (fun y => c y • f) (c'.smulRight f) s x

full_name: HasFDerivAt.smul_const
code: @[fun_prop]
theorem HasFDerivAt.smul_const (hc : HasFDerivAt c c' x) (f : F) :
    HasFDerivAt (fun y => c y • f) (c'.smulRight f) x 
goal: HasFDerivAt (fun y => c y • f) (c'.smulRight f) x

full_name: DifferentiableWithinAt.smul_const
code: @[fun_prop]
theorem DifferentiableWithinAt.smul_const (hc : DifferentiableWithinAt 𝕜 c s x) (f : F) :
    DifferentiableWithinAt 𝕜 (fun y => c y • f) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => c y • f) s x

full_name: DifferentiableAt.smul_const
code: @[fun_prop]
theorem DifferentiableAt.smul_const (hc : DifferentiableAt 𝕜 c x) (f : F) :
    DifferentiableAt 𝕜 (fun y => c y • f) x 
goal: DifferentiableAt 𝕜 (fun y => c y • f) x

full_name: DifferentiableOn.smul_const
code: @[fun_prop]
theorem DifferentiableOn.smul_const (hc : DifferentiableOn 𝕜 c s) (f : F) :
    DifferentiableOn 𝕜 (fun y => c y • f) s 
goal: DifferentiableOn 𝕜 (fun y => c y • f) s

full_name: Differentiable.smul_const
code: @[fun_prop]
theorem Differentiable.smul_const (hc : Differentiable 𝕜 c) (f : F) :
    Differentiable 𝕜 fun y => c y • f 
goal: Differentiable 𝕜 fun y => c y • f

full_name: fderivWithin_smul_const
code: theorem fderivWithin_smul_const (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hc : DifferentiableWithinAt 𝕜 c s x) (f : F) :
    fderivWithin 𝕜 (fun y => c y • f) s x = (fderivWithin 𝕜 c s x).smulRight f 
goal: fderivWithin 𝕜 (fun y => c y • f) s x = (fderivWithin 𝕜 c s x).smulRight f

full_name: fderiv_smul_const
code: theorem fderiv_smul_const (hc : DifferentiableAt 𝕜 c x) (f : F) :
    fderiv 𝕜 (fun y => c y • f) x = (fderiv 𝕜 c x).smulRight f 
goal: fderiv 𝕜 (fun y => c y • f) x = (fderiv 𝕜 c x).smulRight f

full_name: HasStrictFDerivAt.mul'
code: @[fun_prop]
theorem HasStrictFDerivAt.mul' {x : E} (ha : HasStrictFDerivAt a a' x)
    (hb : HasStrictFDerivAt b b' x) :
    HasStrictFDerivAt (fun y => a y * b y) (a x • b' + a'.smulRight (b x)) x 
goal: HasStrictFDerivAt (fun y => a y * b y) (a x • b' + a'.smulRight (b x)) x

full_name: HasStrictFDerivAt.mul
code: @[fun_prop]
theorem HasStrictFDerivAt.mul (hc : HasStrictFDerivAt c c' x) (hd : HasStrictFDerivAt d d' x) :
    HasStrictFDerivAt (fun y => c y * d y) (c x • d' + d x • c') x 
goal: HasStrictFDerivAt (fun y => c y * d y) (c x • d' + d x • c') x

full_name: HasFDerivWithinAt.mul'
code: @[fun_prop]
theorem HasFDerivWithinAt.mul' (ha : HasFDerivWithinAt a a' s x) (hb : HasFDerivWithinAt b b' s x) :
    HasFDerivWithinAt (fun y => a y * b y) (a x • b' + a'.smulRight (b x)) s x 
goal: HasFDerivWithinAt (fun y => a y * b y) (a x • b' + a'.smulRight (b x)) s x

full_name: HasFDerivWithinAt.mul
code: @[fun_prop]
theorem HasFDerivWithinAt.mul (hc : HasFDerivWithinAt c c' s x) (hd : HasFDerivWithinAt d d' s x) :
    HasFDerivWithinAt (fun y => c y * d y) (c x • d' + d x • c') s x 
goal: HasFDerivWithinAt (fun y => c y * d y) (c x • d' + d x • c') s x

full_name: HasFDerivAt.mul'
code: @[fun_prop]
theorem HasFDerivAt.mul' (ha : HasFDerivAt a a' x) (hb : HasFDerivAt b b' x) :
    HasFDerivAt (fun y => a y * b y) (a x • b' + a'.smulRight (b x)) x 
goal: HasFDerivAt (fun y => a y * b y) (a x • b' + a'.smulRight (b x)) x

full_name: HasFDerivAt.mul
code: @[fun_prop]
theorem HasFDerivAt.mul (hc : HasFDerivAt c c' x) (hd : HasFDerivAt d d' x) :
    HasFDerivAt (fun y => c y * d y) (c x • d' + d x • c') x 
goal: HasFDerivAt (fun y => c y * d y) (c x • d' + d x • c') x

full_name: DifferentiableWithinAt.mul
code: @[fun_prop]
theorem DifferentiableWithinAt.mul (ha : DifferentiableWithinAt 𝕜 a s x)
    (hb : DifferentiableWithinAt 𝕜 b s x) : DifferentiableWithinAt 𝕜 (fun y => a y * b y) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => a y * b y) s x

full_name: DifferentiableAt.mul
code: @[simp, fun_prop]
theorem DifferentiableAt.mul (ha : DifferentiableAt 𝕜 a x) (hb : DifferentiableAt 𝕜 b x) :
    DifferentiableAt 𝕜 (fun y => a y * b y) x 
goal: DifferentiableAt 𝕜 (fun y => a y * b y) x

full_name: DifferentiableOn.mul
code: @[fun_prop]
theorem DifferentiableOn.mul (ha : DifferentiableOn 𝕜 a s) (hb : DifferentiableOn 𝕜 b s) :
    DifferentiableOn 𝕜 (fun y => a y * b y) s 
goal: DifferentiableOn 𝕜 (fun y => a y * b y) s

full_name: Differentiable.mul
code: @[simp, fun_prop]
theorem Differentiable.mul (ha : Differentiable 𝕜 a) (hb : Differentiable 𝕜 b) :
    Differentiable 𝕜 fun y => a y * b y 
goal: Differentiable 𝕜 fun y => a y * b y

full_name: DifferentiableWithinAt.pow
code: @[fun_prop]
theorem DifferentiableWithinAt.pow (ha : DifferentiableWithinAt 𝕜 a s x) :
    ∀ n : ℕ, DifferentiableWithinAt 𝕜 (fun x => a x ^ n) s x
  
goal: DifferentiableWithinAt 𝕜 (fun x => a x ^ n) s x

full_name: DifferentiableAt.pow
code: @[simp, fun_prop]
theorem DifferentiableAt.pow (ha : DifferentiableAt 𝕜 a x) (n : ℕ) :
    DifferentiableAt 𝕜 (fun x => a x ^ n) x 
goal: DifferentiableAt 𝕜 (fun x => a x ^ n) x

full_name: DifferentiableOn.pow
code: @[fun_prop]
theorem DifferentiableOn.pow (ha : DifferentiableOn 𝕜 a s) (n : ℕ) :
    DifferentiableOn 𝕜 (fun x => a x ^ n) s 
goal: DifferentiableOn 𝕜 (fun x => a x ^ n) s

full_name: Differentiable.pow
code: @[simp, fun_prop]
theorem Differentiable.pow (ha : Differentiable 𝕜 a) (n : ℕ) : Differentiable 𝕜 fun x => a x ^ n 
goal: Differentiable 𝕜 fun x => a x ^ n

full_name: fderivWithin_mul'
code: theorem fderivWithin_mul' (hxs : UniqueDiffWithinAt 𝕜 s x) (ha : DifferentiableWithinAt 𝕜 a s x)
    (hb : DifferentiableWithinAt 𝕜 b s x) :
    fderivWithin 𝕜 (fun y => a y * b y) s x =
      a x • fderivWithin 𝕜 b s x + (fderivWithin 𝕜 a s x).smulRight (b x) 
goal: fderivWithin 𝕜 (fun y => a y * b y) s x = a x • fderivWithin 𝕜 b s x + (fderivWithin 𝕜 a s x).smulRight (b x)

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

full_name: fderiv_mul'
code: theorem fderiv_mul' (ha : DifferentiableAt 𝕜 a x) (hb : DifferentiableAt 𝕜 b x) :
    fderiv 𝕜 (fun y => a y * b y) x = a x • fderiv 𝕜 b x + (fderiv 𝕜 a x).smulRight (b x) 
goal: fderiv 𝕜 (fun y => a y * b y) x = a x • fderiv 𝕜 b x + (fderiv 𝕜 a x).smulRight (b x)

full_name: fderiv_mul
code: theorem fderiv_mul (hc : DifferentiableAt 𝕜 c x) (hd : DifferentiableAt 𝕜 d x) :
    fderiv 𝕜 (fun y => c y * d y) x = c x • fderiv 𝕜 d x + d x • fderiv 𝕜 c x 
goal: fderiv 𝕜 (fun y => c y * d y) x = c x • fderiv 𝕜 d x + d x • fderiv 𝕜 c x

full_name: HasStrictFDerivAt.mul_const'
code: @[fun_prop]
theorem HasStrictFDerivAt.mul_const' (ha : HasStrictFDerivAt a a' x) (b : 𝔸) :
    HasStrictFDerivAt (fun y => a y * b) (a'.smulRight b) x 
goal: HasStrictFDerivAt (fun y => a y * b) (a'.smulRight b) x

full_name: HasStrictFDerivAt.mul_const
code: @[fun_prop]
theorem HasStrictFDerivAt.mul_const (hc : HasStrictFDerivAt c c' x) (d : 𝔸') :
    HasStrictFDerivAt (fun y => c y * d) (d • c') x 
goal: HasStrictFDerivAt (fun y => c y * d) (d • c') x

full_name: HasFDerivWithinAt.mul_const'
code: @[fun_prop]
theorem HasFDerivWithinAt.mul_const' (ha : HasFDerivWithinAt a a' s x) (b : 𝔸) :
    HasFDerivWithinAt (fun y => a y * b) (a'.smulRight b) s x 
goal: HasFDerivWithinAt (fun y => a y * b) (a'.smulRight b) s x

full_name: HasFDerivWithinAt.mul_const
code: @[fun_prop]
theorem HasFDerivWithinAt.mul_const (hc : HasFDerivWithinAt c c' s x) (d : 𝔸') :
    HasFDerivWithinAt (fun y => c y * d) (d • c') s x 
goal: HasFDerivWithinAt (fun y => c y * d) (d • c') s x

full_name: HasFDerivAt.mul_const'
code: @[fun_prop]
theorem HasFDerivAt.mul_const' (ha : HasFDerivAt a a' x) (b : 𝔸) :
    HasFDerivAt (fun y => a y * b) (a'.smulRight b) x 
goal: HasFDerivAt (fun y => a y * b) (a'.smulRight b) x

full_name: HasFDerivAt.mul_const
code: @[fun_prop]
theorem HasFDerivAt.mul_const (hc : HasFDerivAt c c' x) (d : 𝔸') :
    HasFDerivAt (fun y => c y * d) (d • c') x 
goal: HasFDerivAt (fun y => c y * d) (d • c') x

full_name: DifferentiableWithinAt.mul_const
code: @[fun_prop]
theorem DifferentiableWithinAt.mul_const (ha : DifferentiableWithinAt 𝕜 a s x) (b : 𝔸) :
    DifferentiableWithinAt 𝕜 (fun y => a y * b) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => a y * b) s x

full_name: DifferentiableAt.mul_const
code: @[fun_prop]
theorem DifferentiableAt.mul_const (ha : DifferentiableAt 𝕜 a x) (b : 𝔸) :
    DifferentiableAt 𝕜 (fun y => a y * b) x 
goal: DifferentiableAt 𝕜 (fun y => a y * b) x

full_name: DifferentiableOn.mul_const
code: @[fun_prop]
theorem DifferentiableOn.mul_const (ha : DifferentiableOn 𝕜 a s) (b : 𝔸) :
    DifferentiableOn 𝕜 (fun y => a y * b) s 
goal: DifferentiableOn 𝕜 (fun y => a y * b) s

full_name: Differentiable.mul_const
code: @[fun_prop]
theorem Differentiable.mul_const (ha : Differentiable 𝕜 a) (b : 𝔸) :
    Differentiable 𝕜 fun y => a y * b 
goal: Differentiable 𝕜 fun y => a y * b

full_name: fderivWithin_mul_const'
code: theorem fderivWithin_mul_const' (hxs : UniqueDiffWithinAt 𝕜 s x)
    (ha : DifferentiableWithinAt 𝕜 a s x) (b : 𝔸) :
    fderivWithin 𝕜 (fun y => a y * b) s x = (fderivWithin 𝕜 a s x).smulRight b 
goal: fderivWithin 𝕜 (fun y => a y * b) s x = (fderivWithin 𝕜 a s x).smulRight b

full_name: fderivWithin_mul_const
code: theorem fderivWithin_mul_const (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hc : DifferentiableWithinAt 𝕜 c s x) (d : 𝔸') :
    fderivWithin 𝕜 (fun y => c y * d) s x = d • fderivWithin 𝕜 c s x 
goal: fderivWithin 𝕜 (fun y => c y * d) s x = d • fderivWithin 𝕜 c s x

full_name: fderiv_mul_const'
code: theorem fderiv_mul_const' (ha : DifferentiableAt 𝕜 a x) (b : 𝔸) :
    fderiv 𝕜 (fun y => a y * b) x = (fderiv 𝕜 a x).smulRight b 
goal: fderiv 𝕜 (fun y => a y * b) x = (fderiv 𝕜 a x).smulRight b

full_name: fderiv_mul_const
code: theorem fderiv_mul_const (hc : DifferentiableAt 𝕜 c x) (d : 𝔸') :
    fderiv 𝕜 (fun y => c y * d) x = d • fderiv 𝕜 c x 
goal: fderiv 𝕜 (fun y => c y * d) x = d • fderiv 𝕜 c x

full_name: HasStrictFDerivAt.const_mul
code: @[fun_prop]
theorem HasStrictFDerivAt.const_mul (ha : HasStrictFDerivAt a a' x) (b : 𝔸) :
    HasStrictFDerivAt (fun y => b * a y) (b • a') x 
goal: HasStrictFDerivAt (fun y => b * a y) (b • a') x

full_name: HasFDerivWithinAt.const_mul
code: @[fun_prop]
theorem HasFDerivWithinAt.const_mul (ha : HasFDerivWithinAt a a' s x) (b : 𝔸) :
    HasFDerivWithinAt (fun y => b * a y) (b • a') s x 
goal: HasFDerivWithinAt (fun y => b * a y) (b • a') s x

full_name: HasFDerivAt.const_mul
code: @[fun_prop]
theorem HasFDerivAt.const_mul (ha : HasFDerivAt a a' x) (b : 𝔸) :
    HasFDerivAt (fun y => b * a y) (b • a') x 
goal: HasFDerivAt (fun y => b * a y) (b • a') x

full_name: DifferentiableWithinAt.const_mul
code: @[fun_prop]
theorem DifferentiableWithinAt.const_mul (ha : DifferentiableWithinAt 𝕜 a s x) (b : 𝔸) :
    DifferentiableWithinAt 𝕜 (fun y => b * a y) s x 
goal: DifferentiableWithinAt 𝕜 (fun y => b * a y) s x

full_name: DifferentiableAt.const_mul
code: @[fun_prop]
theorem DifferentiableAt.const_mul (ha : DifferentiableAt 𝕜 a x) (b : 𝔸) :
    DifferentiableAt 𝕜 (fun y => b * a y) x 
goal: DifferentiableAt 𝕜 (fun y => b * a y) x

full_name: DifferentiableOn.const_mul
code: @[fun_prop]
theorem DifferentiableOn.const_mul (ha : DifferentiableOn 𝕜 a s) (b : 𝔸) :
    DifferentiableOn 𝕜 (fun y => b * a y) s 
goal: DifferentiableOn 𝕜 (fun y => b * a y) s

full_name: Differentiable.const_mul
code: @[fun_prop]
theorem Differentiable.const_mul (ha : Differentiable 𝕜 a) (b : 𝔸) :
    Differentiable 𝕜 fun y => b * a y 
goal: Differentiable 𝕜 fun y => b * a y

full_name: fderivWithin_const_mul
code: theorem fderivWithin_const_mul (hxs : UniqueDiffWithinAt 𝕜 s x)
    (ha : DifferentiableWithinAt 𝕜 a s x) (b : 𝔸) :
    fderivWithin 𝕜 (fun y => b * a y) s x = b • fderivWithin 𝕜 a s x 
goal: fderivWithin 𝕜 (fun y => b * a y) s x = b • fderivWithin 𝕜 a s x

full_name: fderiv_const_mul
code: theorem fderiv_const_mul (ha : DifferentiableAt 𝕜 a x) (b : 𝔸) :
    fderiv 𝕜 (fun y => b * a y) x = b • fderiv 𝕜 a x 
goal: fderiv 𝕜 (fun y => b * a y) x = b • fderiv 𝕜 a x

full_name: hasStrictFDerivAt_list_prod'
code: @[fun_prop]
theorem hasStrictFDerivAt_list_prod' [Fintype ι] {l : List ι} {x : ι → 𝔸} :
    HasStrictFDerivAt (𝕜 := 𝕜) (fun x ↦ (l.map x).prod)
      (∑ i : Fin l.length, ((l.take i).map x).prod •
        smulRight (proj (l.get i)) ((l.drop (.succ i)).map x).prod) x 
goal: HasStrictFDerivAt (fun x => (List.map x l).prod)
  (∑ i : Fin l.length,
    (List.map x (List.take (↑i) l)).prod •
      (ContinuousLinearMap.proj (l.get i)).smulRight (List.map x (List.drop (↑i).succ l)).prod)
  x

full_name: hasStrictFDerivAt_list_prod_finRange'
code: @[fun_prop]
theorem hasStrictFDerivAt_list_prod_finRange' {n : ℕ} {x : Fin n → 𝔸} :
    HasStrictFDerivAt (𝕜 := 𝕜) (fun x ↦ ((List.finRange n).map x).prod)
      (∑ i : Fin n, (((List.finRange n).take i).map x).prod •
        smulRight (proj i) (((List.finRange n).drop (.succ i)).map x).prod) x 
goal: HasStrictFDerivAt (fun x => (List.map x (List.finRange n)).prod)
  (∑ i : Fin n,
    (List.map x (List.take (↑i) (List.finRange n))).prod •
      (ContinuousLinearMap.proj i).smulRight (List.map x (List.drop (↑i).succ (List.finRange n))).prod)
  x

full_name: hasStrictFDerivAt_list_prod_attach'
code: @[fun_prop]
theorem hasStrictFDerivAt_list_prod_attach' [DecidableEq ι] {l : List ι} {x : {i // i ∈ l} → 𝔸} :
    HasStrictFDerivAt (𝕜 := 𝕜) (fun x ↦ (l.attach.map x).prod)
      (∑ i : Fin l.length, ((l.attach.take i).map x).prod •
        smulRight (proj (l.attach.get (i.cast l.length_attach.symm)))
          ((l.attach.drop (.succ i)).map x).prod) x 
goal: HasStrictFDerivAt (fun x => (List.map x l.attach).prod)
  (∑ i : Fin l.length,
    (List.map x (List.take (↑i) l.attach)).prod •
      (ContinuousLinearMap.proj (l.attach.get (Fin.cast ⋯ i))).smulRight
        (List.map x (List.drop (↑i).succ l.attach)).prod)
  x

full_name: hasFDerivAt_list_prod'
code: @[fun_prop]
theorem hasFDerivAt_list_prod' [Fintype ι] {l : List ι} {x : ι → 𝔸'} :
    HasFDerivAt (𝕜 := 𝕜) (fun x ↦ (l.map x).prod)
      (∑ i : Fin l.length, ((l.take i).map x).prod •
        smulRight (proj (l.get i)) ((l.drop (.succ i)).map x).prod) x 
goal: HasFDerivAt (fun x => (List.map x l).prod)
  (∑ i : Fin l.length,
    (List.map x (List.take (↑i) l)).prod •
      (ContinuousLinearMap.proj (l.get i)).smulRight (List.map x (List.drop (↑i).succ l)).prod)
  x

full_name: hasFDerivAt_list_prod_finRange'
code: @[fun_prop]
theorem hasFDerivAt_list_prod_finRange' {n : ℕ} {x : Fin n → 𝔸} :
    HasFDerivAt (𝕜 := 𝕜) (fun x ↦ ((List.finRange n).map x).prod)
      (∑ i : Fin n, (((List.finRange n).take i).map x).prod •
        smulRight (proj i) (((List.finRange n).drop (.succ i)).map x).prod) x 
goal: HasFDerivAt (fun x => (List.map x (List.finRange n)).prod)
  (∑ i : Fin n,
    (List.map x (List.take (↑i) (List.finRange n))).prod •
      (ContinuousLinearMap.proj i).smulRight (List.map x (List.drop (↑i).succ (List.finRange n))).prod)
  x

full_name: hasFDerivAt_list_prod_attach'
code: @[fun_prop]
theorem hasFDerivAt_list_prod_attach' [DecidableEq ι] {l : List ι} {x : {i // i ∈ l} → 𝔸} :
    HasFDerivAt (𝕜 := 𝕜) (fun x ↦ (l.attach.map x).prod)
      (∑ i : Fin l.length, ((l.attach.take i).map x).prod •
        smulRight (proj (l.attach.get (i.cast l.length_attach.symm)))
          ((l.attach.drop (.succ i)).map x).prod) x 
goal: HasFDerivAt (fun x => (List.map x l.attach).prod)
  (∑ i : Fin l.length,
    (List.map x (List.take (↑i) l.attach)).prod •
      (ContinuousLinearMap.proj (l.attach.get (Fin.cast ⋯ i))).smulRight
        (List.map x (List.drop (↑i).succ l.attach)).prod)
  x

full_name: hasStrictFDerivAt_list_prod
code: /--
Auxiliary lemma for `hasStrictFDerivAt_multiset_prod`.

For `NormedCommRing 𝔸'`, can rewrite as `Multiset` using `Multiset.prod_coe`.
-/
@[fun_prop]
theorem hasStrictFDerivAt_list_prod [DecidableEq ι] [Fintype ι] {l : List ι} {x : ι → 𝔸'} :
    HasStrictFDerivAt (𝕜 := 𝕜) (fun x ↦ (l.map x).prod)
      (l.map fun i ↦ ((l.erase i).map x).prod • proj i).sum x 
goal: HasStrictFDerivAt (fun x => (List.map x l).prod)
  (List.map (fun i => (List.map x (l.erase i)).prod • ContinuousLinearMap.proj i) l).sum x

full_name: hasStrictFDerivAt_multiset_prod
code: @[fun_prop]
theorem hasStrictFDerivAt_multiset_prod [DecidableEq ι] [Fintype ι] {u : Multiset ι} {x : ι → 𝔸'} :
    HasStrictFDerivAt (𝕜 := 𝕜) (fun x ↦ (u.map x).prod)
      (u.map (fun i ↦ ((u.erase i).map x).prod • proj i)).sum x 
goal: HasStrictFDerivAt (fun x => (Multiset.map x u).prod)
  (Multiset.map (fun i => (Multiset.map x (u.erase i)).prod • ContinuousLinearMap.proj i) u).sum x

full_name: hasFDerivAt_multiset_prod
code: @[fun_prop]
theorem hasFDerivAt_multiset_prod [DecidableEq ι] [Fintype ι] {u : Multiset ι} {x : ι → 𝔸'} :
    HasFDerivAt (𝕜 := 𝕜) (fun x ↦ (u.map x).prod)
      (Multiset.sum (u.map (fun i ↦ ((u.erase i).map x).prod • proj i))) x 
goal: HasFDerivAt (fun x => (Multiset.map x u).prod)
  (Multiset.map (fun i => (Multiset.map x (u.erase i)).prod • ContinuousLinearMap.proj i) u).sum x

full_name: hasStrictFDerivAt_finset_prod
code: theorem hasStrictFDerivAt_finset_prod [DecidableEq ι] [Fintype ι] {x : ι → 𝔸'} :
    HasStrictFDerivAt (𝕜 := 𝕜) (∏ i ∈ u, · i) (∑ i ∈ u, (∏ j ∈ u.erase i, x j) • proj i) x 
goal: HasStrictFDerivAt (fun x => ∏ i ∈ u, x i) (∑ i ∈ u, (∏ j ∈ u.erase i, x j) • ContinuousLinearMap.proj i) x

full_name: hasFDerivAt_finset_prod
code: theorem hasFDerivAt_finset_prod [DecidableEq ι] [Fintype ι] {x : ι → 𝔸'} :
    HasFDerivAt (𝕜 := 𝕜) (∏ i ∈ u, · i) (∑ i ∈ u, (∏ j ∈ u.erase i, x j) • proj i) x 
goal: HasFDerivAt (fun x => ∏ i ∈ u, x i) (∑ i ∈ u, (∏ j ∈ u.erase i, x j) • ContinuousLinearMap.proj i) x

full_name: HasStrictFDerivAt.list_prod'
code: @[fun_prop]
theorem HasStrictFDerivAt.list_prod' {l : List ι} {x : E}
    (h : ∀ i ∈ l, HasStrictFDerivAt (f i ·) (f' i) x) :
    HasStrictFDerivAt (fun x ↦ (l.map (f · x)).prod)
      (∑ i : Fin l.length, ((l.take i).map (f · x)).prod •
        smulRight (f' (l.get i)) ((l.drop (.succ i)).map (f · x)).prod) x 
goal: HasStrictFDerivAt (fun x => (List.map (fun x_1 => f x_1 x) l).prod)
  (∑ i : Fin l.length,
    (List.map (fun x_1 => f x_1 x) (List.take (↑i) l)).prod •
      (f' (l.get i)).smulRight (List.map (fun x_1 => f x_1 x) (List.drop (↑i).succ l)).prod)
  x

full_name: HasFDerivAt.list_prod'
code: /--
Unlike `HasFDerivAt.finset_prod`, supports non-commutative multiply and duplicate elements.
-/
@[fun_prop]
theorem HasFDerivAt.list_prod' {l : List ι} {x : E}
    (h : ∀ i ∈ l, HasFDerivAt (f i ·) (f' i) x) :
    HasFDerivAt (fun x ↦ (l.map (f · x)).prod)
      (∑ i : Fin l.length, ((l.take i).map (f · x)).prod •
        smulRight (f' (l.get i)) ((l.drop (.succ i)).map (f · x)).prod) x 
goal: HasFDerivAt (fun x => (List.map (fun x_1 => f x_1 x) l).prod)
  (∑ i : Fin l.length,
    (List.map (fun x_1 => f x_1 x) (List.take (↑i) l)).prod •
      (f' (l.get i)).smulRight (List.map (fun x_1 => f x_1 x) (List.drop (↑i).succ l)).prod)
  x

full_name: HasFDerivWithinAt.list_prod'
code: @[fun_prop]
theorem HasFDerivWithinAt.list_prod' {l : List ι} {x : E}
    (h : ∀ i ∈ l, HasFDerivWithinAt (f i ·) (f' i) s x) :
    HasFDerivWithinAt (fun x ↦ (l.map (f · x)).prod)
      (∑ i : Fin l.length, ((l.take i).map (f · x)).prod •
        smulRight (f' (l.get i)) ((l.drop (.succ i)).map (f · x)).prod) s x 
goal: HasFDerivWithinAt (fun x => (List.map (fun x_1 => f x_1 x) l).prod)
  (∑ i : Fin l.length,
    (List.map (fun x_1 => f x_1 x) (List.take (↑i) l)).prod •
      (f' (l.get i)).smulRight (List.map (fun x_1 => f x_1 x) (List.drop (↑i).succ l)).prod)
  s x

full_name: fderiv_list_prod'
code: theorem fderiv_list_prod' {l : List ι} {x : E}
    (h : ∀ i ∈ l, DifferentiableAt 𝕜 (f i ·) x) :
    fderiv 𝕜 (fun x ↦ (l.map (f · x)).prod) x =
      ∑ i : Fin l.length, ((l.take i).map (f · x)).prod •
        smulRight (fderiv 𝕜 (fun x ↦ f (l.get i) x) x)
          ((l.drop (.succ i)).map (f · x)).prod 
goal: fderiv 𝕜 (fun x => (List.map (fun x_1 => f x_1 x) l).prod) x =
  ∑ i : Fin l.length,
    (List.map (fun x_1 => f x_1 x) (List.take (↑i) l)).prod •
      (fderiv 𝕜 (fun x => f (l.get i) x) x).smulRight (List.map (fun x_1 => f x_1 x) (List.drop (↑i).succ l)).prod

full_name: fderivWithin_list_prod'
code: theorem fderivWithin_list_prod' {l : List ι} {x : E}
    (hxs : UniqueDiffWithinAt 𝕜 s x) (h : ∀ i ∈ l, DifferentiableWithinAt 𝕜 (f i ·) s x) :
    fderivWithin 𝕜 (fun x ↦ (l.map (f · x)).prod) s x =
      ∑ i : Fin l.length, ((l.take i).map (f · x)).prod •
        smulRight (fderivWithin 𝕜 (fun x ↦ f (l.get i) x) s x)
          ((l.drop (.succ i)).map (f · x)).prod 
goal: fderivWithin 𝕜 (fun x => (List.map (fun x_1 => f x_1 x) l).prod) s x =
  ∑ i : Fin l.length,
    (List.map (fun x_1 => f x_1 x) (List.take (↑i) l)).prod •
      (fderivWithin 𝕜 (fun x => f (l.get i) x) s x).smulRight
        (List.map (fun x_1 => f x_1 x) (List.drop (↑i).succ l)).prod

full_name: HasStrictFDerivAt.multiset_prod
code: @[fun_prop]
theorem HasStrictFDerivAt.multiset_prod [DecidableEq ι] {u : Multiset ι} {x : E}
    (h : ∀ i ∈ u, HasStrictFDerivAt (g i ·) (g' i) x) :
    HasStrictFDerivAt (fun x ↦ (u.map (g · x)).prod)
      (u.map fun i ↦ ((u.erase i).map (g · x)).prod • g' i).sum x 
goal: HasStrictFDerivAt (fun x => (Multiset.map (fun x_1 => g x_1 x) u).prod)
  (Multiset.map (fun i => (Multiset.map (fun x_1 => g x_1 x) (u.erase i)).prod • g' i) u).sum x

full_name: HasFDerivAt.multiset_prod
code: /--
Unlike `HasFDerivAt.finset_prod`, supports duplicate elements.
-/
@[fun_prop]
theorem HasFDerivAt.multiset_prod [DecidableEq ι] {u : Multiset ι} {x : E}
    (h : ∀ i ∈ u, HasFDerivAt (g i ·) (g' i) x) :
    HasFDerivAt (fun x ↦ (u.map (g · x)).prod)
      (u.map fun i ↦ ((u.erase i).map (g · x)).prod • g' i).sum x 
goal: HasFDerivAt (fun x => (Multiset.map (fun x_1 => g x_1 x) u).prod)
  (Multiset.map (fun i => (Multiset.map (fun x_1 => g x_1 x) (u.erase i)).prod • g' i) u).sum x

full_name: HasFDerivWithinAt.multiset_prod
code: @[fun_prop]
theorem HasFDerivWithinAt.multiset_prod [DecidableEq ι] {u : Multiset ι} {x : E}
    (h : ∀ i ∈ u, HasFDerivWithinAt (g i ·) (g' i) s x) :
    HasFDerivWithinAt (fun x ↦ (u.map (g · x)).prod)
      (u.map fun i ↦ ((u.erase i).map (g · x)).prod • g' i).sum s x 
goal: HasFDerivWithinAt (fun x => (Multiset.map (fun x_1 => g x_1 x) u).prod)
  (Multiset.map (fun i => (Multiset.map (fun x_1 => g x_1 x) (u.erase i)).prod • g' i) u).sum s x

full_name: fderiv_multiset_prod
code: theorem fderiv_multiset_prod [DecidableEq ι] {u : Multiset ι} {x : E}
    (h : ∀ i ∈ u, DifferentiableAt 𝕜 (g i ·) x) :
    fderiv 𝕜 (fun x ↦ (u.map (g · x)).prod) x =
      (u.map fun i ↦ ((u.erase i).map (g · x)).prod • fderiv 𝕜 (g i) x).sum 
goal: fderiv 𝕜 (fun x => (Multiset.map (fun x_1 => g x_1 x) u).prod) x =
  (Multiset.map (fun i => (Multiset.map (fun x_1 => g x_1 x) (u.erase i)).prod • fderiv 𝕜 (g i) x) u).sum

full_name: fderivWithin_multiset_prod
code: theorem fderivWithin_multiset_prod [DecidableEq ι] {u : Multiset ι} {x : E}
    (hxs : UniqueDiffWithinAt 𝕜 s x) (h : ∀ i ∈ u, DifferentiableWithinAt 𝕜 (g i ·) s x) :
    fderivWithin 𝕜 (fun x ↦ (u.map (g · x)).prod) s x =
      (u.map fun i ↦ ((u.erase i).map (g · x)).prod • fderivWithin 𝕜 (g i) s x).sum 
goal: fderivWithin 𝕜 (fun x => (Multiset.map (fun x_1 => g x_1 x) u).prod) s x =
  (Multiset.map (fun i => (Multiset.map (fun x_1 => g x_1 x) (u.erase i)).prod • fderivWithin 𝕜 (g i) s x) u).sum

full_name: HasStrictFDerivAt.finset_prod
code: theorem HasStrictFDerivAt.finset_prod [DecidableEq ι] {x : E}
    (hg : ∀ i ∈ u, HasStrictFDerivAt (g i) (g' i) x) :
    HasStrictFDerivAt (∏ i ∈ u, g i ·) (∑ i ∈ u, (∏ j ∈ u.erase i, g j x) • g' i) x 
goal: HasStrictFDerivAt (fun x => ∏ i ∈ u, g i x) (∑ i ∈ u, (∏ j ∈ u.erase i, g j x) • g' i) x

full_name: HasFDerivAt.finset_prod
code: theorem HasFDerivAt.finset_prod [DecidableEq ι] {x : E}
    (hg : ∀ i ∈ u, HasFDerivAt (g i) (g' i) x) :
    HasFDerivAt (∏ i ∈ u, g i ·) (∑ i ∈ u, (∏ j ∈ u.erase i, g j x) • g' i) x 
goal: HasFDerivAt (fun x => ∏ i ∈ u, g i x) (∑ i ∈ u, (∏ j ∈ u.erase i, g j x) • g' i) x

full_name: HasFDerivWithinAt.finset_prod
code: theorem HasFDerivWithinAt.finset_prod [DecidableEq ι] {x : E}
    (hg : ∀ i ∈ u, HasFDerivWithinAt (g i) (g' i) s x) :
    HasFDerivWithinAt (∏ i ∈ u, g i ·) (∑ i ∈ u, (∏ j ∈ u.erase i, g j x) • g' i) s x 
goal: HasFDerivWithinAt (fun x => ∏ i ∈ u, g i x) (∑ i ∈ u, (∏ j ∈ u.erase i, g j x) • g' i) s x

full_name: fderiv_finset_prod
code: theorem fderiv_finset_prod [DecidableEq ι] {x : E} (hg : ∀ i ∈ u, DifferentiableAt 𝕜 (g i) x) :
    fderiv 𝕜 (∏ i ∈ u, g i ·) x = ∑ i ∈ u, (∏ j ∈ u.erase i, (g j x)) • fderiv 𝕜 (g i) x 
goal: fderiv 𝕜 (fun x => ∏ i ∈ u, g i x) x = ∑ i ∈ u, (∏ j ∈ u.erase i, g j x) • fderiv 𝕜 (g i) x

full_name: fderivWithin_finset_prod
code: theorem fderivWithin_finset_prod [DecidableEq ι] {x : E} (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hg : ∀ i ∈ u, DifferentiableWithinAt 𝕜 (g i) s x) :
    fderivWithin 𝕜 (∏ i ∈ u, g i ·) s x =
      ∑ i ∈ u, (∏ j ∈ u.erase i, (g j x)) • fderivWithin 𝕜 (g i) s x 
goal: fderivWithin 𝕜 (fun x => ∏ i ∈ u, g i x) s x = ∑ i ∈ u, (∏ j ∈ u.erase i, g j x) • fderivWithin 𝕜 (g i) s x

full_name: hasFDerivAt_ring_inverse
code: /-- At an invertible element `x` of a normed algebra `R`, the Fréchet derivative of the inversion
operation is the linear map `fun t ↦ - x⁻¹ * t * x⁻¹`.

TODO: prove that `Ring.inverse` is analytic and use it to prove a `HasStrictFDerivAt` lemma.
TODO (low prio): prove a version without assumption `[CompleteSpace R]` but within the set of
units. -/
@[fun_prop]
theorem hasFDerivAt_ring_inverse (x : Rˣ) :
    HasFDerivAt Ring.inverse (-mulLeftRight 𝕜 R ↑x⁻¹ ↑x⁻¹) x 
goal: HasFDerivAt Ring.inverse (-((ContinuousLinearMap.mulLeftRight 𝕜 R) ↑x⁻¹) ↑x⁻¹) ↑x

full_name: differentiableAt_inverse
code: @[fun_prop]
theorem differentiableAt_inverse {x : R} (hx : IsUnit x) :
    DifferentiableAt 𝕜 (@Ring.inverse R _) x 
goal: DifferentiableAt 𝕜 Ring.inverse x

full_name: differentiableWithinAt_inverse
code: @[fun_prop]
theorem differentiableWithinAt_inverse {x : R} (hx : IsUnit x) (s : Set R) :
    DifferentiableWithinAt 𝕜 (@Ring.inverse R _) s x 
goal: DifferentiableWithinAt 𝕜 Ring.inverse s x

full_name: differentiableOn_inverse
code: @[fun_prop]
theorem differentiableOn_inverse : DifferentiableOn 𝕜 (@Ring.inverse R _) {x | IsUnit x} 
goal: DifferentiableOn 𝕜 Ring.inverse {x | IsUnit x}

full_name: fderiv_inverse
code: theorem fderiv_inverse (x : Rˣ) : fderiv 𝕜 (@Ring.inverse R _) x = -mulLeftRight 𝕜 R ↑x⁻¹ ↑x⁻¹ 
goal: fderiv 𝕜 Ring.inverse ↑x = -((ContinuousLinearMap.mulLeftRight 𝕜 R) ↑x⁻¹) ↑x⁻¹

full_name: DifferentiableWithinAt.inverse
code: @[fun_prop]
theorem DifferentiableWithinAt.inverse (hf : DifferentiableWithinAt 𝕜 h S z) (hz : IsUnit (h z)) :
    DifferentiableWithinAt 𝕜 (fun x => Ring.inverse (h x)) S z 
goal: DifferentiableWithinAt 𝕜 (fun x => Ring.inverse (h x)) S z

full_name: DifferentiableAt.inverse
code: @[simp, fun_prop]
theorem DifferentiableAt.inverse (hf : DifferentiableAt 𝕜 h z) (hz : IsUnit (h z)) :
    DifferentiableAt 𝕜 (fun x => Ring.inverse (h x)) z 
goal: DifferentiableAt 𝕜 (fun x => Ring.inverse (h x)) z

full_name: DifferentiableOn.inverse
code: @[fun_prop]
theorem DifferentiableOn.inverse (hf : DifferentiableOn 𝕜 h S) (hz : ∀ x ∈ S, IsUnit (h x)) :
    DifferentiableOn 𝕜 (fun x => Ring.inverse (h x)) S 
goal: DifferentiableOn 𝕜 (fun x => Ring.inverse (h x)) S

full_name: Differentiable.inverse
code: @[simp, fun_prop]
theorem Differentiable.inverse (hf : Differentiable 𝕜 h) (hz : ∀ x, IsUnit (h x)) :
    Differentiable 𝕜 fun x => Ring.inverse (h x) 
goal: Differentiable 𝕜 fun x => Ring.inverse (h x)

full_name: hasFDerivAt_inv'
code: /-- At an invertible element `x` of a normed division algebra `R`, the Fréchet derivative of the
inversion operation is the linear map `fun t ↦ - x⁻¹ * t * x⁻¹`. -/
@[fun_prop]
theorem hasFDerivAt_inv' {x : R} (hx : x ≠ 0) :
    HasFDerivAt Inv.inv (-mulLeftRight 𝕜 R x⁻¹ x⁻¹) x 
goal: HasFDerivAt Inv.inv (-((ContinuousLinearMap.mulLeftRight 𝕜 R) x⁻¹) x⁻¹) x

full_name: differentiableAt_inv'
code: @[fun_prop]
theorem differentiableAt_inv' {x : R} (hx : x ≠ 0) : DifferentiableAt 𝕜 Inv.inv x 
goal: DifferentiableAt 𝕜 Inv.inv x

full_name: differentiableWithinAt_inv'
code: @[fun_prop]
theorem differentiableWithinAt_inv' {x : R} (hx : x ≠ 0) (s : Set R) :
    DifferentiableWithinAt 𝕜 (fun x => x⁻¹) s x 
goal: DifferentiableWithinAt 𝕜 (fun x => x⁻¹) s x

full_name: differentiableOn_inv'
code: @[fun_prop]
theorem differentiableOn_inv' : DifferentiableOn 𝕜 (fun x : R => x⁻¹) {x | x ≠ 0} 
goal: DifferentiableOn 𝕜 (fun x => x⁻¹) {x | x ≠ 0}

full_name: fderiv_inv'
code: /-- Non-commutative version of `fderiv_inv` -/
theorem fderiv_inv' {x : R} (hx : x ≠ 0) : fderiv 𝕜 Inv.inv x = -mulLeftRight 𝕜 R x⁻¹ x⁻¹ 
goal: fderiv 𝕜 Inv.inv x = -((ContinuousLinearMap.mulLeftRight 𝕜 R) x⁻¹) x⁻¹

full_name: fderivWithin_inv'
code: /-- Non-commutative version of `fderivWithin_inv` -/
theorem fderivWithin_inv' {s : Set R} {x : R} (hx : x ≠ 0) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (fun x => x⁻¹) s x = -mulLeftRight 𝕜 R x⁻¹ x⁻¹ 
goal: fderivWithin 𝕜 (fun x => x⁻¹) s x = -((ContinuousLinearMap.mulLeftRight 𝕜 R) x⁻¹) x⁻¹

full_name: DifferentiableWithinAt.inv'
code: @[fun_prop]
theorem DifferentiableWithinAt.inv' (hf : DifferentiableWithinAt 𝕜 h S z) (hz : h z ≠ 0) :
    DifferentiableWithinAt 𝕜 (fun x => (h x)⁻¹) S z 
goal: DifferentiableWithinAt 𝕜 (fun x => (h x)⁻¹) S z

full_name: DifferentiableAt.inv'
code: @[simp, fun_prop]
theorem DifferentiableAt.inv' (hf : DifferentiableAt 𝕜 h z) (hz : h z ≠ 0) :
    DifferentiableAt 𝕜 (fun x => (h x)⁻¹) z 
goal: DifferentiableAt 𝕜 (fun x => (h x)⁻¹) z

full_name: DifferentiableOn.inv'
code: @[fun_prop]
theorem DifferentiableOn.inv' (hf : DifferentiableOn 𝕜 h S) (hz : ∀ x ∈ S, h x ≠ 0) :
    DifferentiableOn 𝕜 (fun x => (h x)⁻¹) S 
goal: DifferentiableOn 𝕜 (fun x => (h x)⁻¹) S

full_name: Differentiable.inv'
code: @[simp, fun_prop]
theorem Differentiable.inv' (hf : Differentiable 𝕜 h) (hz : ∀ x, h x ≠ 0) :
    Differentiable 𝕜 fun x => (h x)⁻¹ 
goal: Differentiable 𝕜 fun x => (h x)⁻¹