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

full_name: LieAddGroup.smooth_neg
code: /-- An additive Lie group is a group and a smooth manifold at the same time in which
the addition and negation operations are smooth. -/
class LieAddGroup {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [AddGroup G] [TopologicalSpace G] [ChartedSpace H G] extends SmoothAdd I G : Prop where
  /-- Negation is smooth in an additive Lie group. -/
  smooth_neg : Smooth I I fun a : G => -a
goal: Smooth I I fun a => -a

full_name: LieAddGroup
code: /-- An additive Lie group is a group and a smooth manifold at the same time in which
the addition and negation operations are smooth. -/
class LieAddGroup {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [AddGroup G] [TopologicalSpace G] [ChartedSpace H G] extends SmoothAdd I G : Prop where
  /-- Negation is smooth in an additive Lie group. -/
  smooth_neg : Smooth I I fun a : G => -a
goal: Prop

full_name: LieGroup
code: /-- A (multiplicative) Lie group is a group and a smooth manifold at the same time in which
the multiplication and inverse operations are smooth. -/
@[to_additive]
class LieGroup {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [Group G] [TopologicalSpace G] [ChartedSpace H G] extends SmoothMul I G : Prop where
  /-- Inversion is smooth in a Lie group. -/
  smooth_inv : Smooth I I fun a : G => a⁻¹
goal: Prop

full_name: LieGroup.smooth_inv
code: /-- A (multiplicative) Lie group is a group and a smooth manifold at the same time in which
the multiplication and inverse operations are smooth. -/
@[to_additive]
class LieGroup {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [Group G] [TopologicalSpace G] [ChartedSpace H G] extends SmoothMul I G : Prop where
  /-- Inversion is smooth in a Lie group. -/
  smooth_inv : Smooth I I fun a : G => a⁻¹
goal: Smooth I I fun a => a⁻¹

full_name: smooth_inv
code: /-- In a Lie group, inversion is a smooth map. -/
@[to_additive "In an additive Lie group, inversion is a smooth map."]
theorem smooth_inv : Smooth I I fun x : G => x⁻¹ 
goal: Smooth I I fun x => x⁻¹

full_name: smooth_neg
code: /-- In a Lie group, inversion is a smooth map. -/
@[to_additive "In an additive Lie group, inversion is a smooth map."]
theorem smooth_inv : Smooth I I fun x : G => x⁻¹ 
goal: Smooth I I fun x => -x

full_name: topologicalAddGroup_of_lieAddGroup
code: /-- A Lie group is a topological group. This is not an instance for technical reasons,
see note [Design choices about smooth algebraic structures]. -/
@[to_additive "An additive Lie group is an additive topological group. This is not an instance for
technical reasons, see note [Design choices about smooth algebraic structures]."]
theorem topologicalGroup_of_lieGroup : TopologicalGroup G 
goal: TopologicalAddGroup G

full_name: topologicalGroup_of_lieGroup
code: /-- A Lie group is a topological group. This is not an instance for technical reasons,
see note [Design choices about smooth algebraic structures]. -/
@[to_additive "An additive Lie group is an additive topological group. This is not an instance for
technical reasons, see note [Design choices about smooth algebraic structures]."]
theorem topologicalGroup_of_lieGroup : TopologicalGroup G 
goal: TopologicalGroup G

full_name: ContMDiffWithinAt.inv
code: @[to_additive]
theorem ContMDiffWithinAt.inv {f : M → G} {s : Set M} {x₀ : M}
    (hf : ContMDiffWithinAt I' I n f s x₀) : ContMDiffWithinAt I' I n (fun x => (f x)⁻¹) s x₀ 
goal: ContMDiffWithinAt I' I n (fun x => (f x)⁻¹) s x₀

full_name: ContMDiffWithinAt.neg
code: @[to_additive]
theorem ContMDiffWithinAt.inv {f : M → G} {s : Set M} {x₀ : M}
    (hf : ContMDiffWithinAt I' I n f s x₀) : ContMDiffWithinAt I' I n (fun x => (f x)⁻¹) s x₀ 
goal: ContMDiffWithinAt I' I n (fun x => -f x) s x₀

full_name: ContMDiffAt.neg
code: @[to_additive]
theorem ContMDiffAt.inv {f : M → G} {x₀ : M} (hf : ContMDiffAt I' I n f x₀) :
    ContMDiffAt I' I n (fun x => (f x)⁻¹) x₀ 
goal: ContMDiffAt I' I n (fun x => -f x) x₀

full_name: ContMDiffAt.inv
code: @[to_additive]
theorem ContMDiffAt.inv {f : M → G} {x₀ : M} (hf : ContMDiffAt I' I n f x₀) :
    ContMDiffAt I' I n (fun x => (f x)⁻¹) x₀ 
goal: ContMDiffAt I' I n (fun x => (f x)⁻¹) x₀

full_name: ContMDiffOn.inv
code: @[to_additive]
theorem ContMDiffOn.inv {f : M → G} {s : Set M} (hf : ContMDiffOn I' I n f s) :
    ContMDiffOn I' I n (fun x => (f x)⁻¹) s 
goal: ContMDiffOn I' I n (fun x => (f x)⁻¹) s

full_name: ContMDiffOn.neg
code: @[to_additive]
theorem ContMDiffOn.inv {f : M → G} {s : Set M} (hf : ContMDiffOn I' I n f s) :
    ContMDiffOn I' I n (fun x => (f x)⁻¹) s 
goal: ContMDiffOn I' I n (fun x => -f x) s

full_name: ContMDiff.neg
code: @[to_additive]
theorem ContMDiff.inv {f : M → G} (hf : ContMDiff I' I n f) : ContMDiff I' I n fun x => (f x)⁻¹ 
goal: ContMDiff I' I n fun x => -f x

full_name: ContMDiff.inv
code: @[to_additive]
theorem ContMDiff.inv {f : M → G} (hf : ContMDiff I' I n f) : ContMDiff I' I n fun x => (f x)⁻¹ 
goal: ContMDiff I' I n fun x => (f x)⁻¹

full_name: SmoothWithinAt.neg
code: @[to_additive]
nonrec theorem SmoothWithinAt.inv {f : M → G} {s : Set M} {x₀ : M}
    (hf : SmoothWithinAt I' I f s x₀) : SmoothWithinAt I' I (fun x => (f x)⁻¹) s x₀ 
goal: SmoothWithinAt I' I (fun x => -f x) s x₀

full_name: SmoothWithinAt.inv
code: @[to_additive]
nonrec theorem SmoothWithinAt.inv {f : M → G} {s : Set M} {x₀ : M}
    (hf : SmoothWithinAt I' I f s x₀) : SmoothWithinAt I' I (fun x => (f x)⁻¹) s x₀ 
goal: SmoothWithinAt I' I (fun x => (f x)⁻¹) s x₀

full_name: SmoothAt.inv
code: @[to_additive]
nonrec theorem SmoothAt.inv {f : M → G} {x₀ : M} (hf : SmoothAt I' I f x₀) :
    SmoothAt I' I (fun x => (f x)⁻¹) x₀ 
goal: SmoothAt I' I (fun x => (f x)⁻¹) x₀

full_name: SmoothAt.neg
code: @[to_additive]
nonrec theorem SmoothAt.inv {f : M → G} {x₀ : M} (hf : SmoothAt I' I f x₀) :
    SmoothAt I' I (fun x => (f x)⁻¹) x₀ 
goal: SmoothAt I' I (fun x => -f x) x₀

full_name: SmoothOn.neg
code: @[to_additive]
nonrec theorem SmoothOn.inv {f : M → G} {s : Set M} (hf : SmoothOn I' I f s) :
    SmoothOn I' I (fun x => (f x)⁻¹) s 
goal: SmoothOn I' I (fun x => -f x) s

full_name: SmoothOn.inv
code: @[to_additive]
nonrec theorem SmoothOn.inv {f : M → G} {s : Set M} (hf : SmoothOn I' I f s) :
    SmoothOn I' I (fun x => (f x)⁻¹) s 
goal: SmoothOn I' I (fun x => (f x)⁻¹) s

full_name: Smooth.neg
code: @[to_additive]
nonrec theorem Smooth.inv {f : M → G} (hf : Smooth I' I f) : Smooth I' I fun x => (f x)⁻¹ 
goal: Smooth I' I fun x => -f x

full_name: Smooth.inv
code: @[to_additive]
nonrec theorem Smooth.inv {f : M → G} (hf : Smooth I' I f) : Smooth I' I fun x => (f x)⁻¹ 
goal: Smooth I' I fun x => (f x)⁻¹

full_name: ContMDiffWithinAt.div
code: @[to_additive]
theorem ContMDiffWithinAt.div {f g : M → G} {s : Set M} {x₀ : M}
    (hf : ContMDiffWithinAt I' I n f s x₀) (hg : ContMDiffWithinAt I' I n g s x₀) :
    ContMDiffWithinAt I' I n (fun x => f x / g x) s x₀ 
goal: ContMDiffWithinAt I' I n (fun x => f x / g x) s x₀

full_name: ContMDiffWithinAt.sub
code: @[to_additive]
theorem ContMDiffWithinAt.div {f g : M → G} {s : Set M} {x₀ : M}
    (hf : ContMDiffWithinAt I' I n f s x₀) (hg : ContMDiffWithinAt I' I n g s x₀) :
    ContMDiffWithinAt I' I n (fun x => f x / g x) s x₀ 
goal: ContMDiffWithinAt I' I n (fun x => f x - g x) s x₀

full_name: ContMDiffAt.div
code: @[to_additive]
theorem ContMDiffAt.div {f g : M → G} {x₀ : M} (hf : ContMDiffAt I' I n f x₀)
    (hg : ContMDiffAt I' I n g x₀) : ContMDiffAt I' I n (fun x => f x / g x) x₀ 
goal: ContMDiffAt I' I n (fun x => f x / g x) x₀

full_name: ContMDiffAt.sub
code: @[to_additive]
theorem ContMDiffAt.div {f g : M → G} {x₀ : M} (hf : ContMDiffAt I' I n f x₀)
    (hg : ContMDiffAt I' I n g x₀) : ContMDiffAt I' I n (fun x => f x / g x) x₀ 
goal: ContMDiffAt I' I n (fun x => f x - g x) x₀

full_name: ContMDiffOn.div
code: @[to_additive]
theorem ContMDiffOn.div {f g : M → G} {s : Set M} (hf : ContMDiffOn I' I n f s)
    (hg : ContMDiffOn I' I n g s) : ContMDiffOn I' I n (fun x => f x / g x) s 
goal: ContMDiffOn I' I n (fun x => f x / g x) s

full_name: ContMDiffOn.sub
code: @[to_additive]
theorem ContMDiffOn.div {f g : M → G} {s : Set M} (hf : ContMDiffOn I' I n f s)
    (hg : ContMDiffOn I' I n g s) : ContMDiffOn I' I n (fun x => f x / g x) s 
goal: ContMDiffOn I' I n (fun x => f x - g x) s

full_name: ContMDiff.div
code: @[to_additive]
theorem ContMDiff.div {f g : M → G} (hf : ContMDiff I' I n f) (hg : ContMDiff I' I n g) :
    ContMDiff I' I n fun x => f x / g x 
goal: ContMDiff I' I n fun x => f x / g x

full_name: ContMDiff.sub
code: @[to_additive]
theorem ContMDiff.div {f g : M → G} (hf : ContMDiff I' I n f) (hg : ContMDiff I' I n g) :
    ContMDiff I' I n fun x => f x / g x 
goal: ContMDiff I' I n fun x => f x - g x

full_name: SmoothWithinAt.sub
code: @[to_additive]
nonrec theorem SmoothWithinAt.div {f g : M → G} {s : Set M} {x₀ : M}
    (hf : SmoothWithinAt I' I f s x₀) (hg : SmoothWithinAt I' I g s x₀) :
    SmoothWithinAt I' I (fun x => f x / g x) s x₀ 
goal: SmoothWithinAt I' I (fun x => f x - g x) s x₀

full_name: SmoothWithinAt.div
code: @[to_additive]
nonrec theorem SmoothWithinAt.div {f g : M → G} {s : Set M} {x₀ : M}
    (hf : SmoothWithinAt I' I f s x₀) (hg : SmoothWithinAt I' I g s x₀) :
    SmoothWithinAt I' I (fun x => f x / g x) s x₀ 
goal: SmoothWithinAt I' I (fun x => f x / g x) s x₀

full_name: SmoothAt.div
code: @[to_additive]
nonrec theorem SmoothAt.div {f g : M → G} {x₀ : M} (hf : SmoothAt I' I f x₀)
    (hg : SmoothAt I' I g x₀) : SmoothAt I' I (fun x => f x / g x) x₀ 
goal: SmoothAt I' I (fun x => f x / g x) x₀

full_name: SmoothAt.sub
code: @[to_additive]
nonrec theorem SmoothAt.div {f g : M → G} {x₀ : M} (hf : SmoothAt I' I f x₀)
    (hg : SmoothAt I' I g x₀) : SmoothAt I' I (fun x => f x / g x) x₀ 
goal: SmoothAt I' I (fun x => f x - g x) x₀

full_name: SmoothOn.sub
code: @[to_additive]
nonrec theorem SmoothOn.div {f g : M → G} {s : Set M} (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.div
code: @[to_additive]
nonrec theorem SmoothOn.div {f g : M → G} {s : Set M} (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.div
code: @[to_additive]
nonrec theorem Smooth.div {f g : M → G} (hf : Smooth I' I f) (hg : Smooth I' I g) :
    Smooth I' I (f / g) 
goal: Smooth I' I (f / g)

full_name: Smooth.sub
code: @[to_additive]
nonrec theorem Smooth.div {f g : M → G} (hf : Smooth I' I f) (hg : Smooth I' I g) :
    Smooth I' I (f / g) 
goal: Smooth I' I (f - g)

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

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

full_name: normedSpaceLieAddGroup
code: instance normedSpaceLieAddGroup {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] : LieAddGroup 𝓘(𝕜, E) E 
goal: LieAddGroup 𝓘(𝕜, E) E

full_name: SmoothInv₀
code: /-- A smooth manifold with `0` and `Inv` such that `fun x ↦ x⁻¹` is smooth at all nonzero points.
Any complete normed (semi)field has this property. -/
class SmoothInv₀ {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [Inv G] [Zero G] [TopologicalSpace G] [ChartedSpace H G] : Prop where
  /-- Inversion is smooth away from `0`. -/
  smoothAt_inv₀ : ∀ ⦃x : G⦄, x ≠ 0 → SmoothAt I I (fun y ↦ y⁻¹) x
goal: Prop

full_name: SmoothInv₀.smoothAt_inv₀
code: /-- A smooth manifold with `0` and `Inv` such that `fun x ↦ x⁻¹` is smooth at all nonzero points.
Any complete normed (semi)field has this property. -/
class SmoothInv₀ {𝕜 : Type*} [NontriviallyNormedField 𝕜] {H : Type*} [TopologicalSpace H]
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (G : Type*)
    [Inv G] [Zero G] [TopologicalSpace G] [ChartedSpace H G] : Prop where
  /-- Inversion is smooth away from `0`. -/
  smoothAt_inv₀ : ∀ ⦃x : G⦄, x ≠ 0 → SmoothAt I I (fun y ↦ y⁻¹) x
goal: x ≠ 0 → SmoothAt I I (fun y => y⁻¹) x

full_name: instSmoothInv₀ModelWithCornersSelfOfCompleteSpace
code: instance {𝕜 : Type*} [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] : SmoothInv₀ 𝓘(𝕜) 𝕜 
goal: SmoothInv₀ 𝓘(𝕜, 𝕜) 𝕜

full_name: smoothAt_inv₀
code: theorem smoothAt_inv₀ {x : G} (hx : x ≠ 0) : SmoothAt I I (fun y ↦ y⁻¹) x 
goal: SmoothAt I I (fun y => y⁻¹) x

full_name: hasContinuousInv₀_of_hasSmoothInv₀
code: /-- In a manifold with smooth inverse away from `0`, the inverse is continuous away from `0`.
This is not an instance for technical reasons, see
note [Design choices about smooth algebraic structures]. -/
theorem hasContinuousInv₀_of_hasSmoothInv₀ : HasContinuousInv₀ G 
goal: HasContinuousInv₀ G

full_name: SmoothOn_inv₀
code: theorem SmoothOn_inv₀ : SmoothOn I I (Inv.inv : G → G) {0}ᶜ 
goal: SmoothOn I I Inv.inv {0}ᶜ

full_name: ContMDiffWithinAt.inv₀
code: theorem ContMDiffWithinAt.inv₀ (hf : ContMDiffWithinAt I' I n f s a) (ha : f a ≠ 0) :
    ContMDiffWithinAt I' I n (fun x => (f x)⁻¹) s a 
goal: ContMDiffWithinAt I' I n (fun x => (f x)⁻¹) s a

full_name: ContMDiffAt.inv₀
code: theorem ContMDiffAt.inv₀ (hf : ContMDiffAt I' I n f a) (ha : f a ≠ 0) :
    ContMDiffAt I' I n (fun x ↦ (f x)⁻¹) a 
goal: ContMDiffAt I' I n (fun x => (f x)⁻¹) a

full_name: ContMDiff.inv₀
code: theorem ContMDiff.inv₀ (hf : ContMDiff I' I n f) (h0 : ∀ x, f x ≠ 0) :
    ContMDiff I' I n (fun x ↦ (f x)⁻¹) 
goal: ContMDiff I' I n fun x => (f x)⁻¹

full_name: ContMDiffOn.inv₀
code: theorem ContMDiffOn.inv₀ (hf : ContMDiffOn I' I n f s) (h0 : ∀ x ∈ s, f x ≠ 0) :
    ContMDiffOn I' I n (fun x => (f x)⁻¹) s 
goal: ContMDiffOn I' I n (fun x => (f x)⁻¹) s

full_name: SmoothWithinAt.inv₀
code: theorem SmoothWithinAt.inv₀ (hf : SmoothWithinAt I' I f s a) (ha : f a ≠ 0) :
    SmoothWithinAt I' I (fun x => (f x)⁻¹) s a 
goal: SmoothWithinAt I' I (fun x => (f x)⁻¹) s a

full_name: SmoothAt.inv₀
code: theorem SmoothAt.inv₀ (hf : SmoothAt I' I f a) (ha : f a ≠ 0) :
    SmoothAt I' I (fun x => (f x)⁻¹) a 
goal: SmoothAt I' I (fun x => (f x)⁻¹) a

full_name: Smooth.inv₀
code: theorem Smooth.inv₀ (hf : Smooth I' I f) (h0 : ∀ x, f x ≠ 0) : Smooth I' I fun x => (f x)⁻¹ 
goal: Smooth I' I fun x => (f x)⁻¹

full_name: SmoothOn.inv₀
code: theorem SmoothOn.inv₀ (hf : SmoothOn I' I f s) (h0 : ∀ x ∈ s, f x ≠ 0) :
    SmoothOn I' I (fun x => (f x)⁻¹) s 
goal: SmoothOn I' I (fun x => (f x)⁻¹) s

full_name: ContMDiffWithinAt.div₀
code: theorem ContMDiffWithinAt.div₀
    (hf : ContMDiffWithinAt I' I n f s a) (hg : ContMDiffWithinAt I' I n g s a) (h₀ : g a ≠ 0) :
    ContMDiffWithinAt I' I n (f / g) s a 
goal: ContMDiffWithinAt I' I n (f / g) s a

full_name: ContMDiffOn.div₀
code: theorem ContMDiffOn.div₀ (hf : ContMDiffOn I' I n f s) (hg : ContMDiffOn I' I n g s)
    (h₀ : ∀ x ∈ s, g x ≠ 0) : ContMDiffOn I' I n (f / g) s 
goal: ContMDiffOn I' I n (f / g) s

full_name: ContMDiffAt.div₀
code: theorem ContMDiffAt.div₀ (hf : ContMDiffAt I' I n f a) (hg : ContMDiffAt I' I n g a)
    (h₀ : g a ≠ 0) : ContMDiffAt I' I n (f / g) a 
goal: ContMDiffAt I' I n (f / g) a

full_name: ContMDiff.div₀
code: theorem ContMDiff.div₀ (hf : ContMDiff I' I n f) (hg : ContMDiff I' I n g) (h₀ : ∀ x, g x ≠ 0) :
    ContMDiff I' I n (f / g) 
goal: ContMDiff I' I n (f / g)

full_name: SmoothWithinAt.div₀
code: theorem SmoothWithinAt.div₀ (hf : SmoothWithinAt I' I f s a)
    (hg : SmoothWithinAt I' I g s a) (h₀ : g a ≠ 0) : SmoothWithinAt I' I (f / g) s a 
goal: SmoothWithinAt I' I (f / g) s a

full_name: SmoothOn.div₀
code: theorem SmoothOn.div₀ (hf : SmoothOn I' I f s) (hg : SmoothOn I' I g s) (h₀ : ∀ x ∈ s, g x ≠ 0) :
    SmoothOn I' I (f / g) s 
goal: SmoothOn I' I (f / g) s

full_name: SmoothAt.div₀
code: theorem SmoothAt.div₀ (hf : SmoothAt I' I f a) (hg : SmoothAt I' I g a) (h₀ : g a ≠ 0) :
    SmoothAt I' I (f / g) a 
goal: SmoothAt I' I (f / g) a

full_name: Smooth.div₀
code: theorem Smooth.div₀ (hf : Smooth I' I f) (hg : Smooth I' I g) (h₀ : ∀ x, g x ≠ 0) :
    Smooth I' I (f / g) 
goal: Smooth I' I (f / g)