File: Mathlib/Topology/Algebra/GroupWithZero.lean

full_name: Filter.Tendsto.div_const
code: theorem Filter.Tendsto.div_const {x : G₀} (hf : Tendsto f l (𝓝 x)) (y : G₀) :
    Tendsto (fun a => f a / y) l (𝓝 (x / y)) 
goal: Filter.Tendsto (fun a => f a / y) l (𝓝 (x / y))

full_name: ContinuousAt.div_const
code: nonrec theorem ContinuousAt.div_const {a : α} (hf : ContinuousAt f a) (y : G₀) :
    ContinuousAt (fun x => f x / y) a 
goal: ContinuousAt (fun x => f x / y) a

full_name: ContinuousWithinAt.div_const
code: nonrec theorem ContinuousWithinAt.div_const {a} (hf : ContinuousWithinAt f s a) (y : G₀) :
    ContinuousWithinAt (fun x => f x / y) s a 
goal: ContinuousWithinAt (fun x => f x / y) s a

full_name: ContinuousOn.div_const
code: theorem ContinuousOn.div_const (hf : ContinuousOn f s) (y : G₀) :
    ContinuousOn (fun x => f x / y) s 
goal: ContinuousOn (fun x => f x / y) s

full_name: Continuous.div_const
code: @[continuity, fun_prop]
theorem Continuous.div_const (hf : Continuous f) (y : G₀) : Continuous fun x => f x / y 
goal: Continuous fun x => f x / y

full_name: HasContinuousInv₀.continuousAt_inv₀
code: /-- A type with `0` and `Inv` such that `fun x ↦ x⁻¹` is continuous at all nonzero points. Any
normed (semi)field has this property. -/
class HasContinuousInv₀ (G₀ : Type*) [Zero G₀] [Inv G₀] [TopologicalSpace G₀] : Prop where
  /-- The map `fun x ↦ x⁻¹` is continuous at all nonzero points. -/
  continuousAt_inv₀ : ∀ ⦃x : G₀⦄, x ≠ 0 → ContinuousAt Inv.inv x
goal: x ≠ 0 → ContinuousAt Inv.inv x

full_name: HasContinuousInv₀
code: /-- A type with `0` and `Inv` such that `fun x ↦ x⁻¹` is continuous at all nonzero points. Any
normed (semi)field has this property. -/
class HasContinuousInv₀ (G₀ : Type*) [Zero G₀] [Inv G₀] [TopologicalSpace G₀] : Prop where
  /-- The map `fun x ↦ x⁻¹` is continuous at all nonzero points. -/
  continuousAt_inv₀ : ∀ ⦃x : G₀⦄, x ≠ 0 → ContinuousAt Inv.inv x
goal: Prop

full_name: tendsto_inv₀
code: theorem tendsto_inv₀ {x : G₀} (hx : x ≠ 0) : Tendsto Inv.inv (𝓝 x) (𝓝 x⁻¹) 
goal: Filter.Tendsto Inv.inv (𝓝 x) (𝓝 x⁻¹)

full_name: continuousOn_inv₀
code: theorem continuousOn_inv₀ : ContinuousOn (Inv.inv : G₀ → G₀) {0}ᶜ 
goal: ContinuousOn Inv.inv {0}ᶜ

full_name: Filter.Tendsto.inv₀
code: /-- If a function converges to a nonzero value, its inverse converges to the inverse of this value.
We use the name `Filter.Tendsto.inv₀` as `Filter.Tendsto.inv` is already used in multiplicative
topological groups. -/
theorem Filter.Tendsto.inv₀ {a : G₀} (hf : Tendsto f l (𝓝 a)) (ha : a ≠ 0) :
    Tendsto (fun x => (f x)⁻¹) l (𝓝 a⁻¹) 
goal: Filter.Tendsto (fun x => (f x)⁻¹) l (𝓝 a⁻¹)

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

full_name: ContinuousAt.inv₀
code: @[fun_prop]
nonrec theorem ContinuousAt.inv₀ (hf : ContinuousAt f a) (ha : f a ≠ 0) :
    ContinuousAt (fun x => (f x)⁻¹) a 
goal: ContinuousAt (fun x => (f x)⁻¹) a

full_name: Continuous.inv₀
code: @[continuity, fun_prop]
theorem Continuous.inv₀ (hf : Continuous f) (h0 : ∀ x, f x ≠ 0) : Continuous fun x => (f x)⁻¹ 
goal: Continuous fun x => (f x)⁻¹

full_name: ContinuousOn.inv₀
code: @[fun_prop]
theorem ContinuousOn.inv₀ (hf : ContinuousOn f s) (h0 : ∀ x ∈ s, f x ≠ 0) :
    ContinuousOn (fun x => (f x)⁻¹) s 
goal: ContinuousOn (fun x => (f x)⁻¹) s

full_name: Units.embedding_val₀
code: /-- If `G₀` is a group with zero with topology such that `x ↦ x⁻¹` is continuous at all nonzero
points. Then the coercion `G₀ˣ → G₀` is a topological embedding. -/
theorem Units.embedding_val₀ [GroupWithZero G₀] [TopologicalSpace G₀] [HasContinuousInv₀ G₀] :
    Embedding (val : G₀ˣ → G₀) 
goal: Embedding Units.val

full_name: nhds_inv₀
code: lemma nhds_inv₀ (hx : x ≠ 0) : 𝓝 x⁻¹ = (𝓝 x)⁻¹ 
goal: 𝓝 x⁻¹ = (𝓝 x)⁻¹

full_name: tendsto_inv_iff₀
code: lemma tendsto_inv_iff₀ {l : Filter α} {f : α → G₀} (hx : x ≠ 0) :
    Tendsto (fun x ↦ (f x)⁻¹) l (𝓝 x⁻¹) ↔ Tendsto f l (𝓝 x) 
goal: Filter.Tendsto (fun x => (f x)⁻¹) l (𝓝 x⁻¹) ↔ Filter.Tendsto f l (𝓝 x)

full_name: Filter.Tendsto.div
code: theorem Filter.Tendsto.div {l : Filter α} {a b : G₀} (hf : Tendsto f l (𝓝 a))
    (hg : Tendsto g l (𝓝 b)) (hy : b ≠ 0) : Tendsto (f / g) l (𝓝 (a / b)) 
goal: Filter.Tendsto (f / g) l (𝓝 (a / b))

full_name: Filter.tendsto_mul_iff_of_ne_zero
code: theorem Filter.tendsto_mul_iff_of_ne_zero [T1Space G₀] {f g : α → G₀} {l : Filter α} {x y : G₀}
    (hg : Tendsto g l (𝓝 y)) (hy : y ≠ 0) :
    Tendsto (fun n => f n * g n) l (𝓝 <| x * y) ↔ Tendsto f l (𝓝 x) 
goal: Filter.Tendsto (fun n => f n * g n) l (𝓝 (x * y)) ↔ Filter.Tendsto f l (𝓝 x)

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

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

full_name: ContinuousAt.div
code: /-- Continuity at a point of the result of dividing two functions continuous at that point, where
the denominator is nonzero. -/
nonrec theorem ContinuousAt.div (hf : ContinuousAt f a) (hg : ContinuousAt g a) (h₀ : g a ≠ 0) :
    ContinuousAt (f / g) a 
goal: ContinuousAt (f / g) a

full_name: Continuous.div
code: @[continuity]
theorem Continuous.div (hf : Continuous f) (hg : Continuous g) (h₀ : ∀ x, g x ≠ 0) :
    Continuous (f / g) 
goal: Continuous (f / g)

full_name: continuousOn_div
code: theorem continuousOn_div : ContinuousOn (fun p : G₀ × G₀ => p.1 / p.2) { p | p.2 ≠ 0 } 
goal: ContinuousOn (fun p => p.1 / p.2) {p | p.2 ≠ 0}

full_name: Continuous.div₀
code: @[fun_prop]
theorem Continuous.div₀ (hf : Continuous f) (hg : Continuous g) (h₀ : ∀ x, g x ≠ 0) :
    Continuous (fun x => f x / g x) 
goal: Continuous fun x => f x / g x

full_name: ContinuousAt.div₀
code: @[fun_prop]
theorem ContinuousAt.div₀ (hf : ContinuousAt f a) (hg : ContinuousAt g a) (h₀ : g a ≠ 0) :
    ContinuousAt (fun x => f x / g x) a 
goal: ContinuousAt (fun x => f x / g x) a

full_name: ContinuousOn.div₀
code: @[fun_prop]
theorem ContinuousOn.div₀ (hf : ContinuousOn f s) (hg : ContinuousOn g s) (h₀ : ∀ x ∈ s, g x ≠ 0) :
    ContinuousOn (fun x => f x / g x) s 
goal: ContinuousOn (fun x => f x / g x) s

full_name: ContinuousAt.comp_div_cases
code: /-- The function `f x / g x` is discontinuous when `g x = 0`. However, under appropriate
conditions, `h x (f x / g x)` is still continuous.  The condition is that if `g a = 0` then `h x y`
must tend to `h a 0` when `x` tends to `a`, with no information about `y`. This is represented by
the `⊤` filter.  Note: `tendsto_prod_top_iff` characterizes this convergence in uniform spaces.  See
also `Filter.prod_top` and `Filter.mem_prod_top`. -/
theorem ContinuousAt.comp_div_cases {f g : α → G₀} (h : α → G₀ → β) (hf : ContinuousAt f a)
    (hg : ContinuousAt g a) (hh : g a ≠ 0 → ContinuousAt (↿h) (a, f a / g a))
    (h2h : g a = 0 → Tendsto (↿h) (𝓝 a ×ˢ ⊤) (𝓝 (h a 0))) :
    ContinuousAt (fun x => h x (f x / g x)) a 
goal: ContinuousAt (fun x => h x (f x / g x)) a

full_name: Continuous.comp_div_cases
code: /-- `h x (f x / g x)` is continuous under certain conditions, even if the denominator is sometimes
  `0`. See docstring of `ContinuousAt.comp_div_cases`. -/
theorem Continuous.comp_div_cases {f g : α → G₀} (h : α → G₀ → β) (hf : Continuous f)
    (hg : Continuous g) (hh : ∀ a, g a ≠ 0 → ContinuousAt (↿h) (a, f a / g a))
    (h2h : ∀ a, g a = 0 → Tendsto (↿h) (𝓝 a ×ˢ ⊤) (𝓝 (h a 0))) :
    Continuous fun x => h x (f x / g x) 
goal: Continuous fun x => h x (f x / g x)

full_name: Homeomorph.mulLeft₀
code: /-- Left multiplication by a nonzero element in a `GroupWithZero` with continuous multiplication
is a homeomorphism of the underlying type. -/
protected def mulLeft₀ (c : α) (hc : c ≠ 0) : α ≃ₜ α 
goal: α ≃ₜ α

full_name: Homeomorph.mulRight₀
code: /-- Right multiplication by a nonzero element in a `GroupWithZero` with continuous multiplication
is a homeomorphism of the underlying type. -/
protected def mulRight₀ (c : α) (hc : c ≠ 0) : α ≃ₜ α 
goal: α ≃ₜ α

full_name: Homeomorph.coe_mulLeft₀
code: @[simp]
theorem coe_mulLeft₀ (c : α) (hc : c ≠ 0) : ⇑(Homeomorph.mulLeft₀ c hc) = (c * ·) 
goal: ⇑(Homeomorph.mulLeft₀ c hc) = fun x => c * x

full_name: Homeomorph.mulLeft₀_symm_apply
code: @[simp]
theorem mulLeft₀_symm_apply (c : α) (hc : c ≠ 0) :
    ((Homeomorph.mulLeft₀ c hc).symm : α → α) = (c⁻¹ * ·) 
goal: ⇑(Homeomorph.mulLeft₀ c hc).symm = fun x => c⁻¹ * x

full_name: Homeomorph.coe_mulRight₀
code: @[simp]
theorem coe_mulRight₀ (c : α) (hc : c ≠ 0) : ⇑(Homeomorph.mulRight₀ c hc) = (· * c) 
goal: ⇑(Homeomorph.mulRight₀ c hc) = fun x => x * c

full_name: Homeomorph.mulRight₀_symm_apply
code: @[simp]
theorem mulRight₀_symm_apply (c : α) (hc : c ≠ 0) :
    ((Homeomorph.mulRight₀ c hc).symm : α → α) = (· * c⁻¹) 
goal: ⇑(Homeomorph.mulRight₀ c hc).symm = fun x => x * c⁻¹

full_name: map_mul_left_nhds₀
code: theorem map_mul_left_nhds₀ (ha : a ≠ 0) (b : G₀) : map (a * ·) (𝓝 b) = 𝓝 (a * b) 
goal: Filter.map (fun x => a * x) (𝓝 b) = 𝓝 (a * b)

full_name: map_mul_left_nhds_one₀
code: theorem map_mul_left_nhds_one₀ (ha : a ≠ 0) : map (a * ·) (𝓝 1) = 𝓝 (a) 
goal: Filter.map (fun x => a * x) (𝓝 1) = 𝓝 a

full_name: map_mul_right_nhds₀
code: theorem map_mul_right_nhds₀ (ha : a ≠ 0) (b : G₀) : map (· * a) (𝓝 b) = 𝓝 (b * a) 
goal: Filter.map (fun x => x * a) (𝓝 b) = 𝓝 (b * a)

full_name: map_mul_right_nhds_one₀
code: theorem map_mul_right_nhds_one₀ (ha : a ≠ 0) : map (· * a) (𝓝 1) = 𝓝 (a) 
goal: Filter.map (fun x => x * a) (𝓝 1) = 𝓝 a

full_name: nhds_translation_mul_inv₀
code: theorem nhds_translation_mul_inv₀ (ha : a ≠ 0) : comap (· * a⁻¹) (𝓝 1) = 𝓝 a 
goal: Filter.comap (fun x => x * a⁻¹) (𝓝 1) = 𝓝 a

full_name: HasContinuousInv₀.of_nhds_one
code: /-- If a group with zero has continuous multiplication and `fun x ↦ x⁻¹` is continuous at one,
then it is continuous at any unit. -/
theorem HasContinuousInv₀.of_nhds_one (h : Tendsto Inv.inv (𝓝 (1 : G₀)) (𝓝 1)) :
    HasContinuousInv₀ G₀ 
goal: HasContinuousInv₀ G₀

full_name: continuousAt_zpow₀
code: theorem continuousAt_zpow₀ (x : G₀) (m : ℤ) (h : x ≠ 0 ∨ 0 ≤ m) :
    ContinuousAt (fun x => x ^ m) x 
goal: ContinuousAt (fun x => x ^ m) x

full_name: continuousOn_zpow₀
code: theorem continuousOn_zpow₀ (m : ℤ) : ContinuousOn (fun x : G₀ => x ^ m) {0}ᶜ 
goal: ContinuousOn (fun x => x ^ m) {0}ᶜ

full_name: Filter.Tendsto.zpow₀
code: theorem Filter.Tendsto.zpow₀ {f : α → G₀} {l : Filter α} {a : G₀} (hf : Tendsto f l (𝓝 a)) (m : ℤ)
    (h : a ≠ 0 ∨ 0 ≤ m) : Tendsto (fun x => f x ^ m) l (𝓝 (a ^ m)) 
goal: Filter.Tendsto (fun x => f x ^ m) l (𝓝 (a ^ m))

full_name: ContinuousAt.zpow₀
code: @[fun_prop]
nonrec theorem ContinuousAt.zpow₀ (hf : ContinuousAt f a) (m : ℤ) (h : f a ≠ 0 ∨ 0 ≤ m) :
    ContinuousAt (fun x => f x ^ m) a 
goal: ContinuousAt (fun x => f x ^ m) a

full_name: ContinuousWithinAt.zpow₀
code: nonrec theorem ContinuousWithinAt.zpow₀ (hf : ContinuousWithinAt f s a) (m : ℤ)
    (h : f a ≠ 0 ∨ 0 ≤ m) : ContinuousWithinAt (fun x => f x ^ m) s a 
goal: ContinuousWithinAt (fun x => f x ^ m) s a

full_name: ContinuousOn.zpow₀
code: @[fun_prop]
theorem ContinuousOn.zpow₀ (hf : ContinuousOn f s) (m : ℤ) (h : ∀ a ∈ s, f a ≠ 0 ∨ 0 ≤ m) :
    ContinuousOn (fun x => f x ^ m) s 
goal: ContinuousOn (fun x => f x ^ m) s

full_name: Continuous.zpow₀
code: @[continuity, fun_prop]
theorem Continuous.zpow₀ (hf : Continuous f) (m : ℤ) (h0 : ∀ a, f a ≠ 0 ∨ 0 ≤ m) :
    Continuous fun x => f x ^ m 
goal: Continuous fun x => f x ^ m