File: Mathlib/Geometry/Manifold/Algebra/Monoid.lean

full_name: SmoothAdd.smooth_add
code: /-- Basic hypothesis to talk about a smooth (Lie) additive monoid or a smooth additive
semigroup. A smooth additive monoid over `α`, for example, is obtained by requiring both the
instances `AddMonoid α` and `SmoothAdd α`. -/
class SmoothAdd {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [Add G] [TopologicalSpace G] [ChartedSpace H G] extends SmoothManifoldWithCorners I G :
    Prop where
  smooth_add : Smooth (I.prod I) I fun p : G × G => p.1 + p.2
goal: Smooth (I.prod I) I fun p => p.1 + p.2

full_name: SmoothAdd
code: /-- Basic hypothesis to talk about a smooth (Lie) additive monoid or a smooth additive
semigroup. A smooth additive monoid over `α`, for example, is obtained by requiring both the
instances `AddMonoid α` and `SmoothAdd α`. -/
class SmoothAdd {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [Add G] [TopologicalSpace G] [ChartedSpace H G] extends SmoothManifoldWithCorners I G :
    Prop where
  smooth_add : Smooth (I.prod I) I fun p : G × G => p.1 + p.2
goal: Prop

full_name: SmoothMul.smooth_mul
code: /-- Basic hypothesis to talk about a smooth (Lie) monoid or a smooth semigroup.
A smooth monoid over `G`, for example, is obtained by requiring both the instances `Monoid G`
and `SmoothMul I G`. -/
@[to_additive]
class SmoothMul {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [Mul G] [TopologicalSpace G] [ChartedSpace H G] extends SmoothManifoldWithCorners I G :
    Prop where
  smooth_mul : Smooth (I.prod I) I fun p : G × G => p.1 * p.2
goal: Smooth (I.prod I) I fun p => p.1 * p.2

full_name: SmoothMul
code: /-- Basic hypothesis to talk about a smooth (Lie) monoid or a smooth semigroup.
A smooth monoid over `G`, for example, is obtained by requiring both the instances `Monoid G`
and `SmoothMul I G`. -/
@[to_additive]
class SmoothMul {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [Mul G] [TopologicalSpace G] [ChartedSpace H G] extends SmoothManifoldWithCorners I G :
    Prop where
  smooth_mul : Smooth (I.prod I) I fun p : G × G => p.1 * p.2
goal: Prop

full_name: smooth_add
code: @[to_additive]
theorem smooth_mul : Smooth (I.prod I) I fun p : G × G => p.1 * p.2 
goal: Smooth (I.prod I) I fun p => p.1 + p.2

full_name: smooth_mul
code: @[to_additive]
theorem smooth_mul : Smooth (I.prod I) I fun p : G × G => p.1 * p.2 
goal: Smooth (I.prod I) I fun p => p.1 * p.2

full_name: continuousMul_of_smooth
code: /-- If the multiplication is smooth, then it is continuous. This is not an instance for technical
reasons, see note [Design choices about smooth algebraic structures]. -/
@[to_additive "If the addition is smooth, then it is continuous. This is not an instance for
technical reasons, see note [Design choices about smooth algebraic structures]."]
theorem continuousMul_of_smooth : ContinuousMul G 
goal: ContinuousMul G

full_name: continuousAdd_of_smooth
code: /-- If the multiplication is smooth, then it is continuous. This is not an instance for technical
reasons, see note [Design choices about smooth algebraic structures]. -/
@[to_additive "If the addition is smooth, then it is continuous. This is not an instance for
technical reasons, see note [Design choices about smooth algebraic structures]."]
theorem continuousMul_of_smooth : ContinuousMul G 
goal: ContinuousAdd G

full_name: ContMDiffWithinAt.add
code: @[to_additive]
theorem ContMDiffWithinAt.mul (hf : ContMDiffWithinAt I' I n f s x)
    (hg : ContMDiffWithinAt I' I n g s x) : ContMDiffWithinAt I' I n (f * g) s x 
goal: ContMDiffWithinAt I' I n (f + g) s x

full_name: ContMDiffWithinAt.mul
code: @[to_additive]
theorem ContMDiffWithinAt.mul (hf : ContMDiffWithinAt I' I n f s x)
    (hg : ContMDiffWithinAt I' I n g s x) : ContMDiffWithinAt I' I n (f * g) s x 
goal: ContMDiffWithinAt I' I n (f * g) s x

full_name: ContMDiffAt.add
code: @[to_additive]
nonrec theorem ContMDiffAt.mul (hf : ContMDiffAt I' I n f x) (hg : ContMDiffAt I' I n g x) :
    ContMDiffAt I' I n (f * g) x 
goal: ContMDiffAt I' I n (f + g) x

full_name: ContMDiffAt.mul
code: @[to_additive]
nonrec theorem ContMDiffAt.mul (hf : ContMDiffAt I' I n f x) (hg : ContMDiffAt I' I n g x) :
    ContMDiffAt I' I n (f * g) x 
goal: ContMDiffAt I' I n (f * g) x

full_name: ContMDiffOn.add
code: @[to_additive]
theorem ContMDiffOn.mul (hf : ContMDiffOn I' I n f s) (hg : ContMDiffOn I' I n g s) :
    ContMDiffOn I' I n (f * g) s 
goal: ContMDiffOn I' I n (f + g) s

full_name: ContMDiffOn.mul
code: @[to_additive]
theorem ContMDiffOn.mul (hf : ContMDiffOn I' I n f s) (hg : ContMDiffOn I' I n g s) :
    ContMDiffOn I' I n (f * g) s 
goal: ContMDiffOn I' I n (f * g) s

full_name: ContMDiff.mul
code: @[to_additive]
theorem ContMDiff.mul (hf : ContMDiff I' I n f) (hg : ContMDiff I' I n g) :
    ContMDiff I' I n (f * g) 
goal: ContMDiff I' I n (f * g)

full_name: ContMDiff.add
code: @[to_additive]
theorem ContMDiff.mul (hf : ContMDiff I' I n f) (hg : ContMDiff I' I n g) :
    ContMDiff I' I n (f * g) 
goal: ContMDiff I' I n (f + g)

full_name: SmoothWithinAt.add
code: @[to_additive]
nonrec theorem SmoothWithinAt.mul (hf : SmoothWithinAt I' I f s x)
    (hg : SmoothWithinAt I' I g s x) : SmoothWithinAt I' I (f * g) s x 
goal: SmoothWithinAt I' I (f + g) s x

full_name: SmoothWithinAt.mul
code: @[to_additive]
nonrec theorem SmoothWithinAt.mul (hf : SmoothWithinAt I' I f s x)
    (hg : SmoothWithinAt I' I g s x) : SmoothWithinAt I' I (f * g) s x 
goal: SmoothWithinAt I' I (f * g) s x

full_name: SmoothAt.add
code: @[to_additive]
nonrec theorem SmoothAt.mul (hf : SmoothAt I' I f x) (hg : SmoothAt I' I g x) :
    SmoothAt I' I (f * g) x 
goal: SmoothAt I' I (f + g) x

full_name: SmoothAt.mul
code: @[to_additive]
nonrec theorem SmoothAt.mul (hf : SmoothAt I' I f x) (hg : SmoothAt I' I g x) :
    SmoothAt I' I (f * g) x 
goal: SmoothAt I' I (f * g) x

full_name: SmoothOn.add
code: @[to_additive]
nonrec theorem SmoothOn.mul (hf : SmoothOn I' I f s) (hg : SmoothOn I' I g s) :
    SmoothOn I' I (f * g) s 
goal: SmoothOn I' I (f + g) s

full_name: SmoothOn.mul
code: @[to_additive]
nonrec theorem SmoothOn.mul (hf : SmoothOn I' I f s) (hg : SmoothOn I' I g s) :
    SmoothOn I' I (f * g) s 
goal: SmoothOn I' I (f * g) s

full_name: Smooth.mul
code: @[to_additive]
nonrec theorem Smooth.mul (hf : Smooth I' I f) (hg : Smooth I' I g) : Smooth I' I (f * g) 
goal: Smooth I' I (f * g)

full_name: Smooth.add
code: @[to_additive]
nonrec theorem Smooth.mul (hf : Smooth I' I f) (hg : Smooth I' I g) : Smooth I' I (f * g) 
goal: Smooth I' I (f + g)

full_name: smooth_add_left
code: @[to_additive]
theorem smooth_mul_left {a : G} : Smooth I I fun b : G => a * b 
goal: Smooth I I fun b => a + b

full_name: smooth_mul_left
code: @[to_additive]
theorem smooth_mul_left {a : G} : Smooth I I fun b : G => a * b 
goal: Smooth I I fun b => a * b

full_name: smooth_mul_right
code: @[to_additive]
theorem smooth_mul_right {a : G} : Smooth I I fun b : G => b * a 
goal: Smooth I I fun b => b * a

full_name: smooth_add_right
code: @[to_additive]
theorem smooth_mul_right {a : G} : Smooth I I fun b : G => b * a 
goal: Smooth I I fun b => b + a

full_name: smoothLeftMul
code: /-- Left multiplication by `g`. It is meant to mimic the usual notation in Lie groups.
Lemmas involving `smoothLeftMul` with the notation `𝑳` usually use `L` instead of `𝑳` in the
names. -/
def smoothLeftMul : C^∞⟮I, G; I, G⟯ 
goal: C^⊤⟮I, G; I, G⟯

full_name: smoothRightMul
code: /-- Right multiplication by `g`. It is meant to mimic the usual notation in Lie groups.
Lemmas involving `smoothRightMul` with the notation `𝑹` usually use `R` instead of `𝑹` in the
names. -/
def smoothRightMul : C^∞⟮I, G; I, G⟯ 
goal: C^⊤⟮I, G; I, G⟯

full_name: LieGroup._aux_Mathlib_Geometry_Manifold_Algebra_Monoid___unexpand_smoothLeftMul_1
code: scoped[LieGroup] notation "𝑳" => smoothLeftMul
goal: Lean.PrettyPrinter.Unexpander

full_name: LieGroup.«_aux_Mathlib_Geometry_Manifold_Algebra_Monoid___macroRules_LieGroup_term𝑳_1»
code: scoped[LieGroup] notation "𝑳" => smoothLeftMul
goal: Lean.Macro

full_name: LieGroup.«_aux_Mathlib_Geometry_Manifold_Algebra_Monoid___macroRules_LieGroup_term𝑹_1»
code: scoped[LieGroup] notation "𝑹" => smoothRightMul
goal: Lean.Macro

full_name: LieGroup._aux_Mathlib_Geometry_Manifold_Algebra_Monoid___unexpand_smoothRightMul_1
code: scoped[LieGroup] notation "𝑹" => smoothRightMul
goal: Lean.PrettyPrinter.Unexpander

full_name: L_apply
code: @[simp]
theorem L_apply : (𝑳 I g) h = g * h 
goal: (smoothLeftMul I g) h = g * h

full_name: R_apply
code: @[simp]
theorem R_apply : (𝑹 I g) h = h * g 
goal: (smoothRightMul I g) h = h * g

full_name: L_mul
code: @[simp]
theorem L_mul {G : Type*} [Semigroup G] [TopologicalSpace G] [ChartedSpace H G] [SmoothMul I G]
    (g h : G) : 𝑳 I (g * h) = (𝑳 I g).comp (𝑳 I h) 
goal: smoothLeftMul I (g * h) = (smoothLeftMul I g).comp (smoothLeftMul I h)

full_name: R_mul
code: @[simp]
theorem R_mul {G : Type*} [Semigroup G] [TopologicalSpace G] [ChartedSpace H G] [SmoothMul I G]
    (g h : G) : 𝑹 I (g * h) = (𝑹 I h).comp (𝑹 I g) 
goal: smoothRightMul I (g * h) = (smoothRightMul I h).comp (smoothRightMul I g)

full_name: smoothLeftMul_one
code: theorem smoothLeftMul_one : (𝑳 I g') 1 = g' 
goal: (smoothLeftMul I g') 1 = g'

full_name: smoothRightMul_one
code: theorem smoothRightMul_one : (𝑹 I g') 1 = g' 
goal: (smoothRightMul I g') 1 = g'

full_name: SmoothMul.prod
code: @[to_additive]
instance SmoothMul.prod {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) (G : Type*) [TopologicalSpace G] [ChartedSpace H G] [Mul G]
    [SmoothMul I G] {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E'] {H' : Type*}
    [TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H') (G' : Type*) [TopologicalSpace G']
    [ChartedSpace H' G'] [Mul G'] [SmoothMul I' G'] : SmoothMul (I.prod I') (G × G') 
goal: SmoothMul (I.prod I') (G × G')

full_name: SmoothAdd.sum
code: @[to_additive]
instance SmoothMul.prod {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) (G : Type*) [TopologicalSpace G] [ChartedSpace H G] [Mul G]
    [SmoothMul I G] {E' : Type*} [NormedAddCommGroup E'] [NormedSpace 𝕜 E'] {H' : Type*}
    [TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H') (G' : Type*) [TopologicalSpace G']
    [ChartedSpace H' G'] [Mul G'] [SmoothMul I' G'] : SmoothMul (I.prod I') (G × G') 
goal: SmoothAdd (I.prod I') (G × G')

full_name: smooth_nsmul
code: @[to_additive]
theorem smooth_pow : ∀ n : ℕ, Smooth I I fun a : G => a ^ n
  
goal: Smooth I I fun a => n • a

full_name: smooth_pow
code: @[to_additive]
theorem smooth_pow : ∀ n : ℕ, Smooth I I fun a : G => a ^ n
  
goal: Smooth I I fun a => a ^ n

full_name: SmoothAddMonoidMorphism
code: /-- Morphism of additive smooth monoids. -/
structure SmoothAddMonoidMorphism (I : ModelWithCorners 𝕜 E H) (I' : ModelWithCorners 𝕜 E' H')
    (G : Type*) [TopologicalSpace G] [ChartedSpace H G] [AddMonoid G] [SmoothAdd I G]
    (G' : Type*) [TopologicalSpace G'] [ChartedSpace H' G'] [AddMonoid G']
    [SmoothAdd I' G'] extends G →+ G' where
  smooth_toFun : Smooth I I' toFun
goal: Type (max u_8 u_9)

full_name: SmoothAddMonoidMorphism.smooth_toFun
code: /-- Morphism of additive smooth monoids. -/
structure SmoothAddMonoidMorphism (I : ModelWithCorners 𝕜 E H) (I' : ModelWithCorners 𝕜 E' H')
    (G : Type*) [TopologicalSpace G] [ChartedSpace H G] [AddMonoid G] [SmoothAdd I G]
    (G' : Type*) [TopologicalSpace G'] [ChartedSpace H' G'] [AddMonoid G']
    [SmoothAdd I' G'] extends G →+ G' where
  smooth_toFun : Smooth I I' toFun
goal: Smooth I I' (↑self.toAddMonoidHom).toFun

full_name: SmoothMonoidMorphism
code: /-- Morphism of smooth monoids. -/
@[to_additive]
structure SmoothMonoidMorphism (I : ModelWithCorners 𝕜 E H) (I' : ModelWithCorners 𝕜 E' H')
    (G : Type*) [TopologicalSpace G] [ChartedSpace H G] [Monoid G] [SmoothMul I G] (G' : Type*)
    [TopologicalSpace G'] [ChartedSpace H' G'] [Monoid G'] [SmoothMul I' G'] extends
    G →* G' where
  smooth_toFun : Smooth I I' toFun
goal: Type (max u_8 u_9)

full_name: SmoothMonoidMorphism.smooth_toFun
code: /-- Morphism of smooth monoids. -/
@[to_additive]
structure SmoothMonoidMorphism (I : ModelWithCorners 𝕜 E H) (I' : ModelWithCorners 𝕜 E' H')
    (G : Type*) [TopologicalSpace G] [ChartedSpace H G] [Monoid G] [SmoothMul I G] (G' : Type*)
    [TopologicalSpace G'] [ChartedSpace H' G'] [Monoid G'] [SmoothMul I' G'] extends
    G →* G' where
  smooth_toFun : Smooth I I' toFun
goal: Smooth I I' (↑self.toMonoidHom).toFun

full_name: instOneSmoothMonoidMorphism
code: @[to_additive]
instance : One (SmoothMonoidMorphism I I' G G') 
goal: One (SmoothMonoidMorphism I I' G G')

full_name: instZeroSmoothAddMonoidMorphism
code: @[to_additive]
instance : One (SmoothMonoidMorphism I I' G G') 
goal: Zero (SmoothAddMonoidMorphism I I' G G')

full_name: instInhabitedSmoothMonoidMorphism
code: @[to_additive]
instance : Inhabited (SmoothMonoidMorphism I I' G G') 
goal: Inhabited (SmoothMonoidMorphism I I' G G')

full_name: instInhabitedSmoothAddMonoidMorphism
code: @[to_additive]
instance : Inhabited (SmoothMonoidMorphism I I' G G') 
goal: Inhabited (SmoothAddMonoidMorphism I I' G G')

full_name: instFunLikeSmoothMonoidMorphism
code: @[to_additive]
instance : FunLike (SmoothMonoidMorphism I I' G G') G G' 
goal: FunLike (SmoothMonoidMorphism I I' G G') G G'

full_name: instFunLikeSmoothAddMonoidMorphism
code: @[to_additive]
instance : FunLike (SmoothMonoidMorphism I I' G G') G G' 
goal: FunLike (SmoothAddMonoidMorphism I I' G G') G G'

full_name: instMonoidHomClassSmoothMonoidMorphism
code: @[to_additive]
instance : MonoidHomClass (SmoothMonoidMorphism I I' G G') G G' 
goal: MonoidHomClass (SmoothMonoidMorphism I I' G G') G G'

full_name: instAddMonoidHomClassSmoothAddMonoidMorphism
code: @[to_additive]
instance : MonoidHomClass (SmoothMonoidMorphism I I' G G') G G' 
goal: AddMonoidHomClass (SmoothAddMonoidMorphism I I' G G') G G'

full_name: instContinuousMapClassSmoothAddMonoidMorphism
code: @[to_additive]
instance : ContinuousMapClass (SmoothMonoidMorphism I I' G G') G G' 
goal: ContinuousMapClass (SmoothAddMonoidMorphism I I' G G') G G'

full_name: instContinuousMapClassSmoothMonoidMorphism
code: @[to_additive]
instance : ContinuousMapClass (SmoothMonoidMorphism I I' G G') G G' 
goal: ContinuousMapClass (SmoothMonoidMorphism I I' G G') G G'

full_name: ContMDiffWithinAt.prod
code: @[to_additive]
theorem ContMDiffWithinAt.prod (h : ∀ i ∈ t, ContMDiffWithinAt I' I n (f i) s x₀) :
    ContMDiffWithinAt I' I n (fun x ↦ ∏ i ∈ t, f i x) s x₀ 
goal: ContMDiffWithinAt I' I n (fun x => ∏ i ∈ t, f i x) s x₀

full_name: ContMDiffWithinAt.sum
code: @[to_additive]
theorem ContMDiffWithinAt.prod (h : ∀ i ∈ t, ContMDiffWithinAt I' I n (f i) s x₀) :
    ContMDiffWithinAt I' I n (fun x ↦ ∏ i ∈ t, f i x) s x₀ 
goal: ContMDiffWithinAt I' I n (fun x => ∑ i ∈ t, f i x) s x₀

full_name: contMDiffWithinAt_finsum
code: @[to_additive]
theorem contMDiffWithinAt_finprod (lf : LocallyFinite fun i ↦ mulSupport <| f i) {x₀ : M}
    (h : ∀ i, ContMDiffWithinAt I' I n (f i) s x₀) :
    ContMDiffWithinAt I' I n (fun x ↦ ∏ᶠ i, f i x) s x₀ 
goal: ContMDiffWithinAt I' I n (fun x => ∑ᶠ (i : ι), f i x) s x₀

full_name: contMDiffWithinAt_finprod
code: @[to_additive]
theorem contMDiffWithinAt_finprod (lf : LocallyFinite fun i ↦ mulSupport <| f i) {x₀ : M}
    (h : ∀ i, ContMDiffWithinAt I' I n (f i) s x₀) :
    ContMDiffWithinAt I' I n (fun x ↦ ∏ᶠ i, f i x) s x₀ 
goal: ContMDiffWithinAt I' I n (fun x => ∏ᶠ (i : ι), f i x) s x₀

full_name: contMDiffWithinAt_finset_prod'
code: @[to_additive]
theorem contMDiffWithinAt_finset_prod' (h : ∀ i ∈ t, ContMDiffWithinAt I' I n (f i) s x) :
    ContMDiffWithinAt I' I n (∏ i ∈ t, f i) s x 
goal: ContMDiffWithinAt I' I n (∏ i ∈ t, f i) s x

full_name: contMDiffWithinAt_finset_sum'
code: @[to_additive]
theorem contMDiffWithinAt_finset_prod' (h : ∀ i ∈ t, ContMDiffWithinAt I' I n (f i) s x) :
    ContMDiffWithinAt I' I n (∏ i ∈ t, f i) s x 
goal: ContMDiffWithinAt I' I n (∑ i ∈ t, f i) s x

full_name: contMDiffWithinAt_finset_sum
code: @[to_additive]
theorem contMDiffWithinAt_finset_prod (h : ∀ i ∈ t, ContMDiffWithinAt I' I n (f i) s x) :
    ContMDiffWithinAt I' I n (fun x => ∏ i ∈ t, f i x) s x 
goal: ContMDiffWithinAt I' I n (fun x => ∑ i ∈ t, f i x) s x

full_name: contMDiffWithinAt_finset_prod
code: @[to_additive]
theorem contMDiffWithinAt_finset_prod (h : ∀ i ∈ t, ContMDiffWithinAt I' I n (f i) s x) :
    ContMDiffWithinAt I' I n (fun x => ∏ i ∈ t, f i x) s x 
goal: ContMDiffWithinAt I' I n (fun x => ∏ i ∈ t, f i x) s x

full_name: ContMDiffAt.prod
code: @[to_additive]
theorem ContMDiffAt.prod (h : ∀ i ∈ t, ContMDiffAt I' I n (f i) x₀) :
    ContMDiffAt I' I n (fun x ↦ ∏ i ∈ t, f i x) x₀ 
goal: ContMDiffAt I' I n (fun x => ∏ i ∈ t, f i x) x₀

full_name: ContMDiffAt.sum
code: @[to_additive]
theorem ContMDiffAt.prod (h : ∀ i ∈ t, ContMDiffAt I' I n (f i) x₀) :
    ContMDiffAt I' I n (fun x ↦ ∏ i ∈ t, f i x) x₀ 
goal: ContMDiffAt I' I n (fun x => ∑ i ∈ t, f i x) x₀

full_name: contMDiffAt_finsum
code: @[to_additive]
theorem contMDiffAt_finprod
    (lf : LocallyFinite fun i ↦ mulSupport <| f i) (h : ∀ i, ContMDiffAt I' I n (f i) x₀) :
    ContMDiffAt I' I n (fun x ↦ ∏ᶠ i, f i x) x₀ 
goal: ContMDiffAt I' I n (fun x => ∑ᶠ (i : ι), f i x) x₀

full_name: contMDiffAt_finprod
code: @[to_additive]
theorem contMDiffAt_finprod
    (lf : LocallyFinite fun i ↦ mulSupport <| f i) (h : ∀ i, ContMDiffAt I' I n (f i) x₀) :
    ContMDiffAt I' I n (fun x ↦ ∏ᶠ i, f i x) x₀ 
goal: ContMDiffAt I' I n (fun x => ∏ᶠ (i : ι), f i x) x₀

full_name: contMDiffAt_finset_sum'
code: @[to_additive]
theorem contMDiffAt_finset_prod' (h : ∀ i ∈ t, ContMDiffAt I' I n (f i) x) :
    ContMDiffAt I' I n (∏ i ∈ t, f i) x 
goal: ContMDiffAt I' I n (∑ i ∈ t, f i) x

full_name: contMDiffAt_finset_prod'
code: @[to_additive]
theorem contMDiffAt_finset_prod' (h : ∀ i ∈ t, ContMDiffAt I' I n (f i) x) :
    ContMDiffAt I' I n (∏ i ∈ t, f i) x 
goal: ContMDiffAt I' I n (∏ i ∈ t, f i) x

full_name: contMDiffAt_finset_prod
code: @[to_additive]
theorem contMDiffAt_finset_prod (h : ∀ i ∈ t, ContMDiffAt I' I n (f i) x) :
    ContMDiffAt I' I n (fun x => ∏ i ∈ t, f i x) x 
goal: ContMDiffAt I' I n (fun x => ∏ i ∈ t, f i x) x

full_name: contMDiffAt_finset_sum
code: @[to_additive]
theorem contMDiffAt_finset_prod (h : ∀ i ∈ t, ContMDiffAt I' I n (f i) x) :
    ContMDiffAt I' I n (fun x => ∏ i ∈ t, f i x) x 
goal: ContMDiffAt I' I n (fun x => ∑ i ∈ t, f i x) x

full_name: contMDiffOn_finsum
code: @[to_additive]
theorem contMDiffOn_finprod
    (lf : LocallyFinite fun i ↦ Function.mulSupport <| f i) (h : ∀ i, ContMDiffOn I' I n (f i) s) :
    ContMDiffOn I' I n (fun x ↦ ∏ᶠ i, f i x) s 
goal: ContMDiffOn I' I n (fun x => ∑ᶠ (i : ι), f i x) s

full_name: contMDiffOn_finprod
code: @[to_additive]
theorem contMDiffOn_finprod
    (lf : LocallyFinite fun i ↦ Function.mulSupport <| f i) (h : ∀ i, ContMDiffOn I' I n (f i) s) :
    ContMDiffOn I' I n (fun x ↦ ∏ᶠ i, f i x) s 
goal: ContMDiffOn I' I n (fun x => ∏ᶠ (i : ι), f i x) s

full_name: contMDiffOn_finset_sum'
code: @[to_additive]
theorem contMDiffOn_finset_prod' (h : ∀ i ∈ t, ContMDiffOn I' I n (f i) s) :
    ContMDiffOn I' I n (∏ i ∈ t, f i) s 
goal: ContMDiffOn I' I n (∑ i ∈ t, f i) s

full_name: contMDiffOn_finset_prod'
code: @[to_additive]
theorem contMDiffOn_finset_prod' (h : ∀ i ∈ t, ContMDiffOn I' I n (f i) s) :
    ContMDiffOn I' I n (∏ i ∈ t, f i) s 
goal: ContMDiffOn I' I n (∏ i ∈ t, f i) s

full_name: contMDiffOn_finset_sum
code: @[to_additive]
theorem contMDiffOn_finset_prod (h : ∀ i ∈ t, ContMDiffOn I' I n (f i) s) :
    ContMDiffOn I' I n (fun x => ∏ i ∈ t, f i x) s 
goal: ContMDiffOn I' I n (fun x => ∑ i ∈ t, f i x) s

full_name: contMDiffOn_finset_prod
code: @[to_additive]
theorem contMDiffOn_finset_prod (h : ∀ i ∈ t, ContMDiffOn I' I n (f i) s) :
    ContMDiffOn I' I n (fun x => ∏ i ∈ t, f i x) s 
goal: ContMDiffOn I' I n (fun x => ∏ i ∈ t, f i x) s

full_name: ContMDiff.sum
code: @[to_additive]
theorem ContMDiff.prod (h : ∀ i ∈ t, ContMDiff I' I n (f i)) :
    ContMDiff I' I n fun x ↦ ∏ i ∈ t, f i x 
goal: ContMDiff I' I n fun x => ∑ i ∈ t, f i x

full_name: ContMDiff.prod
code: @[to_additive]
theorem ContMDiff.prod (h : ∀ i ∈ t, ContMDiff I' I n (f i)) :
    ContMDiff I' I n fun x ↦ ∏ i ∈ t, f i x 
goal: ContMDiff I' I n fun x => ∏ i ∈ t, f i x

full_name: contMDiff_finset_prod'
code: @[to_additive]
theorem contMDiff_finset_prod' (h : ∀ i ∈ t, ContMDiff I' I n (f i)) :
    ContMDiff I' I n (∏ i ∈ t, f i) 
goal: ContMDiff I' I n (∏ i ∈ t, f i)

full_name: contMDiff_finset_sum'
code: @[to_additive]
theorem contMDiff_finset_prod' (h : ∀ i ∈ t, ContMDiff I' I n (f i)) :
    ContMDiff I' I n (∏ i ∈ t, f i) 
goal: ContMDiff I' I n (∑ i ∈ t, f i)

full_name: contMDiff_finset_sum
code: @[to_additive]
theorem contMDiff_finset_prod (h : ∀ i ∈ t, ContMDiff I' I n (f i)) :
    ContMDiff I' I n fun x => ∏ i ∈ t, f i x 
goal: ContMDiff I' I n fun x => ∑ i ∈ t, f i x

full_name: contMDiff_finset_prod
code: @[to_additive]
theorem contMDiff_finset_prod (h : ∀ i ∈ t, ContMDiff I' I n (f i)) :
    ContMDiff I' I n fun x => ∏ i ∈ t, f i x 
goal: ContMDiff I' I n fun x => ∏ i ∈ t, f i x

full_name: contMDiff_finprod
code: @[to_additive]
theorem contMDiff_finprod (h : ∀ i, ContMDiff I' I n (f i))
    (hfin : LocallyFinite fun i => mulSupport (f i)) : ContMDiff I' I n fun x => ∏ᶠ i, f i x 
goal: ContMDiff I' I n fun x => ∏ᶠ (i : ι), f i x

full_name: contMDiff_finsum
code: @[to_additive]
theorem contMDiff_finprod (h : ∀ i, ContMDiff I' I n (f i))
    (hfin : LocallyFinite fun i => mulSupport (f i)) : ContMDiff I' I n fun x => ∏ᶠ i, f i x 
goal: ContMDiff I' I n fun x => ∑ᶠ (i : ι), f i x

full_name: contMDiff_finsum_cond
code: @[to_additive]
theorem contMDiff_finprod_cond (hc : ∀ i, p i → ContMDiff I' I n (f i))
    (hf : LocallyFinite fun i => mulSupport (f i)) :
    ContMDiff I' I n fun x => ∏ᶠ (i) (_ : p i), f i x 
goal: ContMDiff I' I n fun x => ∑ᶠ (i : ι) (_ : p i), f i x

full_name: contMDiff_finprod_cond
code: @[to_additive]
theorem contMDiff_finprod_cond (hc : ∀ i, p i → ContMDiff I' I n (f i))
    (hf : LocallyFinite fun i => mulSupport (f i)) :
    ContMDiff I' I n fun x => ∏ᶠ (i) (_ : p i), f i x 
goal: ContMDiff I' I n fun x => ∏ᶠ (i : ι) (_ : p i), f i x

full_name: smoothAt_finsum
code: @[to_additive]
theorem smoothAt_finprod
    (lf : LocallyFinite fun i ↦ mulSupport <| f i) (h : ∀ i, SmoothAt I' I (f i) x₀) :
    SmoothAt I' I (fun x ↦ ∏ᶠ i, f i x) x₀ 
goal: SmoothAt I' I (fun x => ∑ᶠ (i : ι), f i x) x₀

full_name: smoothAt_finprod
code: @[to_additive]
theorem smoothAt_finprod
    (lf : LocallyFinite fun i ↦ mulSupport <| f i) (h : ∀ i, SmoothAt I' I (f i) x₀) :
    SmoothAt I' I (fun x ↦ ∏ᶠ i, f i x) x₀ 
goal: SmoothAt I' I (fun x => ∏ᶠ (i : ι), f i x) x₀

full_name: smoothWithinAt_finset_prod'
code: @[to_additive]
theorem smoothWithinAt_finset_prod' (h : ∀ i ∈ t, SmoothWithinAt I' I (f i) s x) :
    SmoothWithinAt I' I (∏ i ∈ t, f i) s x 
goal: SmoothWithinAt I' I (∏ i ∈ t, f i) s x

full_name: smoothWithinAt_finset_sum'
code: @[to_additive]
theorem smoothWithinAt_finset_prod' (h : ∀ i ∈ t, SmoothWithinAt I' I (f i) s x) :
    SmoothWithinAt I' I (∏ i ∈ t, f i) s x 
goal: SmoothWithinAt I' I (∑ i ∈ t, f i) s x

full_name: smoothWithinAt_finset_sum
code: @[to_additive]
theorem smoothWithinAt_finset_prod (h : ∀ i ∈ t, SmoothWithinAt I' I (f i) s x) :
    SmoothWithinAt I' I (fun x => ∏ i ∈ t, f i x) s x 
goal: SmoothWithinAt I' I (fun x => ∑ i ∈ t, f i x) s x

full_name: smoothWithinAt_finset_prod
code: @[to_additive]
theorem smoothWithinAt_finset_prod (h : ∀ i ∈ t, SmoothWithinAt I' I (f i) s x) :
    SmoothWithinAt I' I (fun x => ∏ i ∈ t, f i x) s x 
goal: SmoothWithinAt I' I (fun x => ∏ i ∈ t, f i x) s x

full_name: smoothAt_finset_prod'
code: @[to_additive]
theorem smoothAt_finset_prod' (h : ∀ i ∈ t, SmoothAt I' I (f i) x) :
    SmoothAt I' I (∏ i ∈ t, f i) x 
goal: SmoothAt I' I (∏ i ∈ t, f i) x

full_name: smoothAt_finset_sum'
code: @[to_additive]
theorem smoothAt_finset_prod' (h : ∀ i ∈ t, SmoothAt I' I (f i) x) :
    SmoothAt I' I (∏ i ∈ t, f i) x 
goal: SmoothAt I' I (∑ i ∈ t, f i) x

full_name: smoothAt_finset_prod
code: @[to_additive]
theorem smoothAt_finset_prod (h : ∀ i ∈ t, SmoothAt I' I (f i) x) :
    SmoothAt I' I (fun x => ∏ i ∈ t, f i x) x 
goal: SmoothAt I' I (fun x => ∏ i ∈ t, f i x) x

full_name: smoothAt_finset_sum
code: @[to_additive]
theorem smoothAt_finset_prod (h : ∀ i ∈ t, SmoothAt I' I (f i) x) :
    SmoothAt I' I (fun x => ∏ i ∈ t, f i x) x 
goal: SmoothAt I' I (fun x => ∑ i ∈ t, f i x) x

full_name: smoothOn_finset_prod'
code: @[to_additive]
theorem smoothOn_finset_prod' (h : ∀ i ∈ t, SmoothOn I' I (f i) s) :
    SmoothOn I' I (∏ i ∈ t, f i) s 
goal: SmoothOn I' I (∏ i ∈ t, f i) s

full_name: smoothOn_finset_sum'
code: @[to_additive]
theorem smoothOn_finset_prod' (h : ∀ i ∈ t, SmoothOn I' I (f i) s) :
    SmoothOn I' I (∏ i ∈ t, f i) s 
goal: SmoothOn I' I (∑ i ∈ t, f i) s

full_name: smoothOn_finset_sum
code: @[to_additive]
theorem smoothOn_finset_prod (h : ∀ i ∈ t, SmoothOn I' I (f i) s) :
    SmoothOn I' I (fun x => ∏ i ∈ t, f i x) s 
goal: SmoothOn I' I (fun x => ∑ i ∈ t, f i x) s

full_name: smoothOn_finset_prod
code: @[to_additive]
theorem smoothOn_finset_prod (h : ∀ i ∈ t, SmoothOn I' I (f i) s) :
    SmoothOn I' I (fun x => ∏ i ∈ t, f i x) s 
goal: SmoothOn I' I (fun x => ∏ i ∈ t, f i x) s

full_name: smooth_finset_sum'
code: @[to_additive]
theorem smooth_finset_prod' (h : ∀ i ∈ t, Smooth I' I (f i)) : Smooth I' I (∏ i ∈ t, f i) 
goal: Smooth I' I (∑ i ∈ t, f i)

full_name: smooth_finset_prod'
code: @[to_additive]
theorem smooth_finset_prod' (h : ∀ i ∈ t, Smooth I' I (f i)) : Smooth I' I (∏ i ∈ t, f i) 
goal: Smooth I' I (∏ i ∈ t, f i)

full_name: smooth_finset_prod
code: @[to_additive]
theorem smooth_finset_prod (h : ∀ i ∈ t, Smooth I' I (f i)) :
    Smooth I' I fun x => ∏ i ∈ t, f i x 
goal: Smooth I' I fun x => ∏ i ∈ t, f i x

full_name: smooth_finset_sum
code: @[to_additive]
theorem smooth_finset_prod (h : ∀ i ∈ t, Smooth I' I (f i)) :
    Smooth I' I fun x => ∏ i ∈ t, f i x 
goal: Smooth I' I fun x => ∑ i ∈ t, f i x

full_name: smooth_finprod
code: @[to_additive]
theorem smooth_finprod (h : ∀ i, Smooth I' I (f i))
    (hfin : LocallyFinite fun i => mulSupport (f i)) : Smooth I' I fun x => ∏ᶠ i, f i x 
goal: Smooth I' I fun x => ∏ᶠ (i : ι), f i x

full_name: smooth_finsum
code: @[to_additive]
theorem smooth_finprod (h : ∀ i, Smooth I' I (f i))
    (hfin : LocallyFinite fun i => mulSupport (f i)) : Smooth I' I fun x => ∏ᶠ i, f i x 
goal: Smooth I' I fun x => ∑ᶠ (i : ι), f i x

full_name: smooth_finprod_cond
code: @[to_additive]
theorem smooth_finprod_cond (hc : ∀ i, p i → Smooth I' I (f i))
    (hf : LocallyFinite fun i => mulSupport (f i)) :
    Smooth I' I fun x => ∏ᶠ (i) (_ : p i), f i x 
goal: Smooth I' I fun x => ∏ᶠ (i : ι) (_ : p i), f i x

full_name: smooth_finsum_cond
code: @[to_additive]
theorem smooth_finprod_cond (hc : ∀ i, p i → Smooth I' I (f i))
    (hf : LocallyFinite fun i => mulSupport (f i)) :
    Smooth I' I fun x => ∏ᶠ (i) (_ : p i), f i x 
goal: Smooth I' I fun x => ∑ᶠ (i : ι) (_ : p i), f i x

full_name: hasSmoothAddSelf
code: instance hasSmoothAddSelf : SmoothAdd 𝓘(𝕜, E) E 
goal: SmoothAdd 𝓘(𝕜, E) E

full_name: ContMDiffWithinAt.div_const
code: @[to_additive]
theorem ContMDiffWithinAt.div_const (hf : ContMDiffWithinAt I' I n f s x) :
    ContMDiffWithinAt I' I n (fun x ↦ f x / c) s x 
goal: ContMDiffWithinAt I' I n (fun x => f x / c) s x

full_name: ContMDiffWithinAt.sub_const
code: @[to_additive]
theorem ContMDiffWithinAt.div_const (hf : ContMDiffWithinAt I' I n f s x) :
    ContMDiffWithinAt I' I n (fun x ↦ f x / c) s x 
goal: ContMDiffWithinAt I' I n (fun x => f x - c) s x

full_name: ContMDiffAt.div_const
code: @[to_additive]
nonrec theorem ContMDiffAt.div_const (hf : ContMDiffAt I' I n f x) :
    ContMDiffAt I' I n (fun x ↦ f x / c) x 
goal: ContMDiffAt I' I n (fun x => f x / c) x

full_name: ContMDiffAt.sub_const
code: @[to_additive]
nonrec theorem ContMDiffAt.div_const (hf : ContMDiffAt I' I n f x) :
    ContMDiffAt I' I n (fun x ↦ f x / c) x 
goal: ContMDiffAt I' I n (fun x => f x - c) x

full_name: ContMDiffOn.sub_const
code: @[to_additive]
theorem ContMDiffOn.div_const (hf : ContMDiffOn I' I n f s) :
    ContMDiffOn I' I n (fun x ↦ f x / c) s 
goal: ContMDiffOn I' I n (fun x => f x - c) s

full_name: ContMDiffOn.div_const
code: @[to_additive]
theorem ContMDiffOn.div_const (hf : ContMDiffOn I' I n f s) :
    ContMDiffOn I' I n (fun x ↦ f x / c) s 
goal: ContMDiffOn I' I n (fun x => f x / c) s

full_name: ContMDiff.sub_const
code: @[to_additive]
theorem ContMDiff.div_const (hf : ContMDiff I' I n f) :
    ContMDiff I' I n (fun x ↦ f x / c) 
goal: ContMDiff I' I n fun x => f x - c

full_name: ContMDiff.div_const
code: @[to_additive]
theorem ContMDiff.div_const (hf : ContMDiff I' I n f) :
    ContMDiff I' I n (fun x ↦ f x / c) 
goal: ContMDiff I' I n fun x => f x / c

full_name: SmoothWithinAt.div_const
code: @[to_additive]
nonrec theorem SmoothWithinAt.div_const (hf : SmoothWithinAt I' I f s x) :
  SmoothWithinAt I' I (fun x ↦ f x / c) s x 
goal: SmoothWithinAt I' I (fun x => f x / c) s x

full_name: SmoothWithinAt.sub_const
code: @[to_additive]
nonrec theorem SmoothWithinAt.div_const (hf : SmoothWithinAt I' I f s x) :
  SmoothWithinAt I' I (fun x ↦ f x / c) s x 
goal: SmoothWithinAt I' I (fun x => f x - c) s x

full_name: SmoothAt.div_const
code: @[to_additive]
nonrec theorem SmoothAt.div_const (hf : SmoothAt I' I f x) :
    SmoothAt I' I (fun x ↦ f x / c) x 
goal: SmoothAt I' I (fun x => f x / c) x

full_name: SmoothAt.sub_const
code: @[to_additive]
nonrec theorem SmoothAt.div_const (hf : SmoothAt I' I f x) :
    SmoothAt I' I (fun x ↦ f x / c) x 
goal: SmoothAt I' I (fun x => f x - c) x

full_name: SmoothOn.div_const
code: @[to_additive]
nonrec theorem SmoothOn.div_const (hf : SmoothOn I' I f s) :
    SmoothOn I' I (fun x ↦ f x / c) s 
goal: SmoothOn I' I (fun x => f x / c) s

full_name: SmoothOn.sub_const
code: @[to_additive]
nonrec theorem SmoothOn.div_const (hf : SmoothOn I' I f s) :
    SmoothOn I' I (fun x ↦ f x / c) s 
goal: SmoothOn I' I (fun x => f x - c) s

full_name: Smooth.sub_const
code: @[to_additive]
nonrec theorem Smooth.div_const (hf : Smooth I' I f) : Smooth I' I (fun x ↦ f x / c) 
goal: Smooth I' I fun x => f x - c

full_name: Smooth.div_const
code: @[to_additive]
nonrec theorem Smooth.div_const (hf : Smooth I' I f) : Smooth I' I (fun x ↦ f x / c) 
goal: Smooth I' I fun x => f x / c