ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- IsBoundedBilinearMap.continuous_right
theorem IsBoundedBilinearMap.continuous_right (h : IsBoundedBilinearMap 𝕜 f) {e₁ : E} :
    Continuous fun e₂ => f (e₁, e₂) 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace 𝕜 G] {f : E × F → G} (h : IsBoundedBilinearMap 𝕜 f) {e₁ : E}
Goal: Continuous fun e₂ => f (e₁, e₂)
-- ContinuousLinearMap.continuous₂
theorem ContinuousLinearMap.continuous₂ (f : E →L[𝕜] F →L[𝕜] G) :
    Continuous (Function.uncurry fun x y => f x y) 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace 𝕜 G] (f : E →L[𝕜] F →L[𝕜] G)
Goal: Continuous (Function.uncurry fun x y => (f x) y)
-- IsBoundedBilinearMap.isBoundedLinearMap_left
theorem IsBoundedBilinearMap.isBoundedLinearMap_left (h : IsBoundedBilinearMap 𝕜 f) (y : F) :
    IsBoundedLinearMap 𝕜 fun x => f (x, y) 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace 𝕜 G] {f : E × F → G} (h : IsBoundedBilinearMap 𝕜 f) (y : F)
Goal: IsBoundedLinearMap 𝕜 fun x => f (x, y)
-- IsBoundedBilinearMap.isBoundedLinearMap_right
theorem IsBoundedBilinearMap.isBoundedLinearMap_right (h : IsBoundedBilinearMap 𝕜 f) (x : E) :
    IsBoundedLinearMap 𝕜 fun y => f (x, y) 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace 𝕜 G] {f : E × F → G} (h : IsBoundedBilinearMap 𝕜 f) (x : E)
Goal: IsBoundedLinearMap 𝕜 fun y => f (x, y)
-- isBoundedBilinearMap_smul
theorem isBoundedBilinearMap_smul {𝕜' : Type*} [NormedField 𝕜'] [NormedAlgebra 𝕜 𝕜'] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] [NormedSpace 𝕜' E] [IsScalarTower 𝕜 𝕜' E] :
    IsBoundedBilinearMap 𝕜 fun p : 𝕜' × E => p.1 • p.2 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {𝕜' : Type u_5} [NormedField 𝕜'] [NormedAlgebra 𝕜 𝕜'] {E : Type u_6} [NormedAddCommGroup E] [NormedSpace 𝕜 E] [NormedSpace 𝕜' E] [IsScalarTower 𝕜 𝕜' E]
Goal: IsBoundedBilinearMap 𝕜 fun p => p.1 • p.2
-- isBoundedBilinearMap_mul
theorem isBoundedBilinearMap_mul : IsBoundedBilinearMap 𝕜 fun p : 𝕜 × 𝕜 => p.1 * p.2 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜]
Goal: IsBoundedBilinearMap 𝕜 fun p => p.1 * p.2
-- isBoundedBilinearMap_comp
theorem isBoundedBilinearMap_comp :
    IsBoundedBilinearMap 𝕜 fun p : (F →L[𝕜] G) × (E →L[𝕜] F) => p.1.comp p.2 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace 𝕜 G]
Goal: IsBoundedBilinearMap 𝕜 fun p => p.1.comp p.2
-- ContinuousLinearMap.isBoundedLinearMap_comp_left
theorem ContinuousLinearMap.isBoundedLinearMap_comp_left (g : F →L[𝕜] G) :
    IsBoundedLinearMap 𝕜 fun f : E →L[𝕜] F => ContinuousLinearMap.comp g f 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace 𝕜 G] (g : F →L[𝕜] G)
Goal: IsBoundedLinearMap 𝕜 fun f => g.comp f
-- ContinuousLinearMap.isBoundedLinearMap_comp_right
theorem ContinuousLinearMap.isBoundedLinearMap_comp_right (f : E →L[𝕜] F) :
    IsBoundedLinearMap 𝕜 fun g : F →L[𝕜] G => ContinuousLinearMap.comp g f 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace 𝕜 G] (f : E →L[𝕜] F)
Goal: IsBoundedLinearMap 𝕜 fun g => g.comp f
-- isBoundedBilinearMap_apply
theorem isBoundedBilinearMap_apply : IsBoundedBilinearMap 𝕜 fun p : (E →L[𝕜] F) × E => p.1 p.2 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
Goal: IsBoundedBilinearMap 𝕜 fun p => p.1 p.2
-- isBoundedBilinearMap_smulRight
theorem isBoundedBilinearMap_smulRight :
    IsBoundedBilinearMap 𝕜 fun p =>
      (ContinuousLinearMap.smulRight : (E →L[𝕜] 𝕜) → F → E →L[𝕜] F) p.1 p.2 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
Goal: IsBoundedBilinearMap 𝕜 fun p => p.1.smulRight p.2
-- isBoundedBilinearMap_compMultilinear
theorem isBoundedBilinearMap_compMultilinear {ι : Type*} {E : ι → Type*} [Fintype ι]
    [∀ i, NormedAddCommGroup (E i)] [∀ i, NormedSpace 𝕜 (E i)] :
    IsBoundedBilinearMap 𝕜 fun p : (F →L[𝕜] G) × ContinuousMultilinearMap 𝕜 E F =>
      p.1.compContinuousMultilinearMap p.2 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace 𝕜 G] {ι : Type u_5} {E : ι → Type u_6} [Fintype ι] [(i : ι) → NormedAddCommGroup (E i)] [(i : ι) → NormedSpace 𝕜 (E i)]
Goal: IsBoundedBilinearMap 𝕜 fun p => p.1.compContinuousMultilinearMap p.2
-- IsBoundedBilinearMap.deriv_apply
@[simp]
theorem IsBoundedBilinearMap.deriv_apply (h : IsBoundedBilinearMap 𝕜 f) (p q : E × F) :
    h.deriv p q = f (p.1, q.2) + f (q.1, p.2) 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace 𝕜 G] {f : E × F → G} (h : IsBoundedBilinearMap 𝕜 f) (p q : E × F)
Goal: (h.deriv p) q = f (p.1, q.2) + f (q.1, p.2)
-- ContinuousLinearMap.mulLeftRight_isBoundedBilinear
theorem ContinuousLinearMap.mulLeftRight_isBoundedBilinear (𝕜' : Type*) [NormedRing 𝕜']
    [NormedAlgebra 𝕜 𝕜'] :
    IsBoundedBilinearMap 𝕜 fun p : 𝕜' × 𝕜' => ContinuousLinearMap.mulLeftRight 𝕜 𝕜' p.1 p.2 
Arguments: (𝕜 : Type u_1) [NontriviallyNormedField 𝕜] (𝕜' : Type u_5) [NormedRing 𝕜'] [NormedAlgebra 𝕜 𝕜']
Goal: IsBoundedBilinearMap 𝕜 fun p => ((ContinuousLinearMap.mulLeftRight 𝕜 𝕜') p.1) p.2
-- IsBoundedBilinearMap.isBoundedLinearMap_deriv
theorem IsBoundedBilinearMap.isBoundedLinearMap_deriv (h : IsBoundedBilinearMap 𝕜 f) :
    IsBoundedLinearMap 𝕜 fun p : E × F => h.deriv p 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace 𝕜 G] {f : E × F → G} (h : IsBoundedBilinearMap 𝕜 f)
Goal: IsBoundedLinearMap 𝕜 fun p => h.deriv p
-- Continuous.clm_comp
@[continuity, fun_prop]
theorem Continuous.clm_comp {X} [TopologicalSpace X] {g : X → F →L[𝕜] G} {f : X → E →L[𝕜] F}
    (hg : Continuous g) (hf : Continuous f) : Continuous fun x => (g x).comp (f x) 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace 𝕜 G] {X : Type u_5} [TopologicalSpace X] {g : X → F →L[𝕜] G} {f : X → E →L[𝕜] F} (hg : Continuous g) (hf : Continuous f)
Goal: Continuous fun x => (g x).comp (f x)
-- ContinuousOn.clm_comp
theorem ContinuousOn.clm_comp {X} [TopologicalSpace X] {g : X → F →L[𝕜] G} {f : X → E →L[𝕜] F}
    {s : Set X} (hg : ContinuousOn g s) (hf : ContinuousOn f s) :
    ContinuousOn (fun x => (g x).comp (f x)) s 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {G : Type u_4} [NormedAddCommGroup G] [NormedSpace 𝕜 G] {X : Type u_5} [TopologicalSpace X] {g : X → F →L[𝕜] G} {f : X → E →L[𝕜] F} {s : Set X} (hg : ContinuousOn g s) (hf : ContinuousOn f s)
Goal: ContinuousOn (fun x => (g x).comp (f x)) s
-- Continuous.clm_apply
@[continuity, fun_prop]
theorem Continuous.clm_apply {X} [TopologicalSpace X] {f : X → (E →L[𝕜] F)} {g : X → E}
    (hf : Continuous f) (hg : Continuous g) : Continuous (fun x ↦ (f x) (g x)) 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {X : Type u_5} [TopologicalSpace X] {f : X → E →L[𝕜] F} {g : X → E} (hf : Continuous f) (hg : Continuous g)
Goal: Continuous fun x => (f x) (g x)
-- ContinuousOn.clm_apply
theorem ContinuousOn.clm_apply {X} [TopologicalSpace X] {f : X → (E →L[𝕜] F)} {g : X → E}
    {s : Set X} (hf : ContinuousOn f s) (hg : ContinuousOn g s) :
    ContinuousOn (fun x ↦ f x (g x)) s 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] {X : Type u_5} [TopologicalSpace X] {f : X → E →L[𝕜] F} {g : X → E} {s : Set X} (hf : ContinuousOn f s) (hg : ContinuousOn g s)
Goal: ContinuousOn (fun x => (f x) (g x)) s
-- ContinuousLinearEquiv.isOpen
protected theorem isOpen [CompleteSpace E] : IsOpen (range ((↑) : (E ≃L[𝕜] F) → E →L[𝕜] F)) 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] [CompleteSpace E]
Goal: IsOpen (Set.range ContinuousLinearEquiv.toContinuousLinearMap)
-- ContinuousLinearEquiv.nhds
protected theorem nhds [CompleteSpace E] (e : E ≃L[𝕜] F) :
    range ((↑) : (E ≃L[𝕜] F) → E →L[𝕜] F) ∈ 𝓝 (e : E →L[𝕜] F) 
Arguments: {𝕜 : Type u_1} [NontriviallyNormedField 𝕜] {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {F : Type u_3} [NormedAddCommGroup F] [NormedSpace 𝕜 F] [CompleteSpace E] (e : E ≃L[𝕜] F)
Goal: Set.range ContinuousLinearEquiv.toContinuousLinearMap ∈ 𝓝 ↑e
-- NonUnitalSeminormedRing.norm_mul
class NonUnitalSeminormedRing (α : Type*) extends Norm α, NonUnitalRing α,
  PseudoMetricSpace α where
    dist_eq : ∀ x y, dist x y = norm (x - y)
    norm_mul : ∀ a b, norm (a * b) ≤ norm a * norm b
Arguments: {α : Type u_5} [self : NonUnitalSeminormedRing α] (a b : α)
Goal: ‖a * b‖ ≤ ‖a‖ * ‖b‖
-- NonUnitalSeminormedRing.dist_eq
class NonUnitalSeminormedRing (α : Type*) extends Norm α, NonUnitalRing α,
  PseudoMetricSpace α where
    dist_eq : ∀ x y, dist x y = norm (x - y)
    norm_mul : ∀ a b, norm (a * b) ≤ norm a * norm b
Arguments: {α : Type u_5} [self : NonUnitalSeminormedRing α] (x y : α)
Goal: dist x y = ‖x - y‖
-- SeminormedRing.norm_mul
class SeminormedRing (α : Type*) extends Norm α, Ring α, PseudoMetricSpace α where
    dist_eq : ∀ x y, dist x y = norm (x - y)
    norm_mul : ∀ a b, norm (a * b) ≤ norm a * norm b
Arguments: {α : Type u_5} [self : SeminormedRing α] (a b : α)
Goal: ‖a * b‖ ≤ ‖a‖ * ‖b‖
-- SeminormedRing.dist_eq
class SeminormedRing (α : Type*) extends Norm α, Ring α, PseudoMetricSpace α where
    dist_eq : ∀ x y, dist x y = norm (x - y)
    norm_mul : ∀ a b, norm (a * b) ≤ norm a * norm b
Arguments: {α : Type u_5} [self : SeminormedRing α] (x y : α)
Goal: dist x y = ‖x - y‖
-- NonUnitalNormedRing.dist_eq
class NonUnitalNormedRing (α : Type*) extends Norm α, NonUnitalRing α, MetricSpace α where
    dist_eq : ∀ x y, dist x y = norm (x - y)
    norm_mul : ∀ a b, norm (a * b) ≤ norm a * norm b
Arguments: {α : Type u_5} [self : NonUnitalNormedRing α] (x y : α)
Goal: dist x y = ‖x - y‖
-- NonUnitalNormedRing.norm_mul
class NonUnitalNormedRing (α : Type*) extends Norm α, NonUnitalRing α, MetricSpace α where
    dist_eq : ∀ x y, dist x y = norm (x - y)
    norm_mul : ∀ a b, norm (a * b) ≤ norm a * norm b
Arguments: {α : Type u_5} [self : NonUnitalNormedRing α] (a b : α)
Goal: ‖a * b‖ ≤ ‖a‖ * ‖b‖
-- NormedRing.dist_eq
class NormedRing (α : Type*) extends Norm α, Ring α, MetricSpace α where
    dist_eq : ∀ x y, dist x y = norm (x - y)
    norm_mul : ∀ a b, norm (a * b) ≤ norm a * norm b
Arguments: {α : Type u_5} [self : NormedRing α] (x y : α)
Goal: dist x y = ‖x - y‖
-- NormedRing.norm_mul
class NormedRing (α : Type*) extends Norm α, Ring α, MetricSpace α where
    dist_eq : ∀ x y, dist x y = norm (x - y)
    norm_mul : ∀ a b, norm (a * b) ≤ norm a * norm b
Arguments: {α : Type u_5} [self : NormedRing α] (a b : α)
Goal: ‖a * b‖ ≤ ‖a‖ * ‖b‖
-- NormedDivisionRing.dist_eq
class NormedDivisionRing (α : Type*) extends Norm α, DivisionRing α, MetricSpace α where
    dist_eq : ∀ x y, dist x y = norm (x - y)
    norm_mul' : ∀ a b, norm (a * b) = norm a * norm b
Arguments: {α : Type u_5} [self : NormedDivisionRing α] (x y : α)
Goal: dist x y = ‖x - y‖
-- NormedDivisionRing.norm_mul'
class NormedDivisionRing (α : Type*) extends Norm α, DivisionRing α, MetricSpace α where
    dist_eq : ∀ x y, dist x y = norm (x - y)
    norm_mul' : ∀ a b, norm (a * b) = norm a * norm b
Arguments: {α : Type u_5} [self : NormedDivisionRing α] (a b : α)
Goal: ‖a * b‖ = ‖a‖ * ‖b‖
-- NonUnitalSeminormedCommRing.mul_comm
class NonUnitalSeminormedCommRing (α : Type*) extends NonUnitalSeminormedRing α where
    mul_comm : ∀ x y : α, x * y = y * x
Arguments: {α : Type u_5} [self : NonUnitalSeminormedCommRing α] (x y : α)
Goal: x * y = y * x
-- NonUnitalNormedCommRing.mul_comm
class NonUnitalNormedCommRing (α : Type*) extends NonUnitalNormedRing α where
    mul_comm : ∀ x y : α, x * y = y * x
Arguments: {α : Type u_5} [self : NonUnitalNormedCommRing α] (x y : α)
Goal: x * y = y * x
-- SeminormedCommRing.mul_comm
class SeminormedCommRing (α : Type*) extends SeminormedRing α where
    mul_comm : ∀ x y : α, x * y = y * x
Arguments: {α : Type u_5} [self : SeminormedCommRing α] (x y : α)
Goal: x * y = y * x
-- NormedCommRing.mul_comm
class NormedCommRing (α : Type*) extends NormedRing α where
    mul_comm : ∀ x y : α, x * y = y * x
Arguments: {α : Type u_5} [self : NormedCommRing α] (x y : α)
Goal: x * y = y * x
-- NormOneClass.norm_one
class NormOneClass (α : Type*) [Norm α] [One α] : Prop where
    norm_one : ‖(1 : α)‖ = 1
Arguments: {α : Type u_5} [Norm α] [One α] [self : NormOneClass α]
Goal: ‖1‖ = 1
-- nnnorm_one
@[simp]
theorem nnnorm_one [SeminormedAddCommGroup α] [One α] [NormOneClass α] : ‖(1 : α)‖₊ = 1 
Arguments: {α : Type u_1} [SeminormedAddCommGroup α] [One α] [NormOneClass α]
Goal: ‖1‖₊ = 1
-- NormOneClass.nontrivial
theorem NormOneClass.nontrivial (α : Type*) [SeminormedAddCommGroup α] [One α] [NormOneClass α] :
    Nontrivial α 
Arguments: (α : Type u_5) [SeminormedAddCommGroup α] [One α] [NormOneClass α]
Goal: Nontrivial α
-- norm_mul_le
theorem norm_mul_le (a b : α) : ‖a * b‖ ≤ ‖a‖ * ‖b‖ 
Arguments: {α : Type u_1} [NonUnitalSeminormedRing α] (a b : α)
Goal: ‖a * b‖ ≤ ‖a‖ * ‖b‖
-- nnnorm_mul_le
theorem nnnorm_mul_le (a b : α) : ‖a * b‖₊ ≤ ‖a‖₊ * ‖b‖₊ 
Arguments: {α : Type u_1} [NonUnitalSeminormedRing α] (a b : α)
Goal: ‖a * b‖₊ ≤ ‖a‖₊ * ‖b‖₊
-- one_le_norm_one
theorem one_le_norm_one (β) [NormedRing β] [Nontrivial β] : 1 ≤ ‖(1 : β)‖ 
Arguments: (β : Type u_5) [NormedRing β] [Nontrivial β]
Goal: 1 ≤ ‖1‖
-- one_le_nnnorm_one
theorem one_le_nnnorm_one (β) [NormedRing β] [Nontrivial β] : 1 ≤ ‖(1 : β)‖₊ 
Arguments: (β : Type u_5) [NormedRing β] [Nontrivial β]
Goal: 1 ≤ ‖1‖₊
-- Filter.Tendsto.zero_mul_isBoundedUnder_le
theorem Filter.Tendsto.zero_mul_isBoundedUnder_le {f g : ι → α} {l : Filter ι}
    (hf : Tendsto f l (𝓝 0)) (hg : IsBoundedUnder (· ≤ ·) l ((‖·‖) ∘ g)) :
    Tendsto (fun x => f x * g x) l (𝓝 0) 
Arguments: {α : Type u_1} {ι : Type u_4} [NonUnitalSeminormedRing α] {f g : ι → α} {l : Filter ι} (hf : Filter.Tendsto f l (𝓝 0)) (hg : Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l ((fun x => ‖x‖) ∘ g))
Goal: Filter.Tendsto (fun x => f x * g x) l (𝓝 0)
-- Filter.isBoundedUnder_le_mul_tendsto_zero
theorem Filter.isBoundedUnder_le_mul_tendsto_zero {f g : ι → α} {l : Filter ι}
    (hf : IsBoundedUnder (· ≤ ·) l (norm ∘ f)) (hg : Tendsto g l (𝓝 0)) :
    Tendsto (fun x => f x * g x) l (𝓝 0) 
Arguments: {α : Type u_1} {ι : Type u_4} [NonUnitalSeminormedRing α] {f g : ι → α} {l : Filter ι} (hf : Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (norm ∘ f)) (hg : Filter.Tendsto g l (𝓝 0))
Goal: Filter.Tendsto (fun x => f x * g x) l (𝓝 0)
-- mulLeft_bound
theorem mulLeft_bound (x : α) : ∀ y : α, ‖AddMonoidHom.mulLeft x y‖ ≤ ‖x‖ * ‖y‖ 
Arguments: {α : Type u_1} [NonUnitalSeminormedRing α] (x y : α)
Goal: ‖(AddMonoidHom.mulLeft x) y‖ ≤ ‖x‖ * ‖y‖
-- mulRight_bound
theorem mulRight_bound (x : α) : ∀ y : α, ‖AddMonoidHom.mulRight x y‖ ≤ ‖x‖ * ‖y‖ 
Arguments: {α : Type u_1} [NonUnitalSeminormedRing α] (x y : α)
Goal: ‖(AddMonoidHom.mulRight x) y‖ ≤ ‖x‖ * ‖y‖
-- Nat.norm_cast_le
theorem Nat.norm_cast_le : ∀ n : ℕ, ‖(n : α)‖ ≤ n * ‖(1 : α)‖
  
Arguments: {α : Type u_1} [SeminormedRing α] (n : ℕ)
Goal: ‖↑n‖ ≤ ↑n * ‖1‖
-- List.norm_prod_le'
theorem List.norm_prod_le' : ∀ {l : List α}, l ≠ [] → ‖l.prod‖ ≤ (l.map norm).prod
  
Arguments: {α : Type u_1} [SeminormedRing α] {l : List α}
Goal: l ≠ [] → ‖l.prod‖ ≤ (List.map norm l).prod
-- List.nnnorm_prod_le'
theorem List.nnnorm_prod_le' {l : List α} (hl : l ≠ []) : ‖l.prod‖₊ ≤ (l.map nnnorm).prod 
Arguments: {α : Type u_1} [SeminormedRing α] {l : List α} (hl : l ≠ [])
Goal: ‖l.prod‖₊ ≤ (List.map nnnorm l).prod
-- List.norm_prod_le
theorem List.norm_prod_le [NormOneClass α] : ∀ l : List α, ‖l.prod‖ ≤ (l.map norm).prod
  
Arguments: {α : Type u_1} [SeminormedRing α] [NormOneClass α] (l : List α)
Goal: ‖l.prod‖ ≤ (List.map norm l).prod
-- List.nnnorm_prod_le
theorem List.nnnorm_prod_le [NormOneClass α] (l : List α) : ‖l.prod‖₊ ≤ (l.map nnnorm).prod 
Arguments: {α : Type u_1} [SeminormedRing α] [NormOneClass α] (l : List α)
Goal: ‖l.prod‖₊ ≤ (List.map nnnorm l).prod
-- Finset.norm_prod_le'
theorem Finset.norm_prod_le' {α : Type*} [NormedCommRing α] (s : Finset ι) (hs : s.Nonempty)
    (f : ι → α) : ‖∏ i ∈ s, f i‖ ≤ ∏ i ∈ s, ‖f i‖ 
Arguments: {ι : Type u_4} {α : Type u_5} [NormedCommRing α] (s : Finset ι) (hs : s.Nonempty) (f : ι → α)
Goal: ‖∏ i ∈ s, f i‖ ≤ ∏ i ∈ s, ‖f i‖
-- Finset.nnnorm_prod_le'
theorem Finset.nnnorm_prod_le' {α : Type*} [NormedCommRing α] (s : Finset ι) (hs : s.Nonempty)
    (f : ι → α) : ‖∏ i ∈ s, f i‖₊ ≤ ∏ i ∈ s, ‖f i‖₊ 
Arguments: {ι : Type u_4} {α : Type u_5} [NormedCommRing α] (s : Finset ι) (hs : s.Nonempty) (f : ι → α)
Goal: ‖∏ i ∈ s, f i‖₊ ≤ ∏ i ∈ s, ‖f i‖₊
-- Finset.norm_prod_le
theorem Finset.norm_prod_le {α : Type*} [NormedCommRing α] [NormOneClass α] (s : Finset ι)
    (f : ι → α) : ‖∏ i ∈ s, f i‖ ≤ ∏ i ∈ s, ‖f i‖ 
Arguments: {ι : Type u_4} {α : Type u_5} [NormedCommRing α] [NormOneClass α] (s : Finset ι) (f : ι → α)
Goal: ‖∏ i ∈ s, f i‖ ≤ ∏ i ∈ s, ‖f i‖
-- Finset.nnnorm_prod_le
theorem Finset.nnnorm_prod_le {α : Type*} [NormedCommRing α] [NormOneClass α] (s : Finset ι)
    (f : ι → α) : ‖∏ i ∈ s, f i‖₊ ≤ ∏ i ∈ s, ‖f i‖₊ 
Arguments: {ι : Type u_4} {α : Type u_5} [NormedCommRing α] [NormOneClass α] (s : Finset ι) (f : ι → α)
Goal: ‖∏ i ∈ s, f i‖₊ ≤ ∏ i ∈ s, ‖f i‖₊
-- nnnorm_pow_le'
theorem nnnorm_pow_le' (a : α) : ∀ {n : ℕ}, 0 < n → ‖a ^ n‖₊ ≤ ‖a‖₊ ^ n
  
Arguments: {α : Type u_1} [SeminormedRing α] (a : α) {n : ℕ}
Goal: 0 < n → ‖a ^ n‖₊ ≤ ‖a‖₊ ^ n
-- nnnorm_pow_le
theorem nnnorm_pow_le [NormOneClass α] (a : α) (n : ℕ) : ‖a ^ n‖₊ ≤ ‖a‖₊ ^ n 
Arguments: {α : Type u_1} [SeminormedRing α] [NormOneClass α] (a : α) (n : ℕ)
Goal: ‖a ^ n‖₊ ≤ ‖a‖₊ ^ n
-- norm_pow_le'
theorem norm_pow_le' (a : α) {n : ℕ} (h : 0 < n) : ‖a ^ n‖ ≤ ‖a‖ ^ n 
Arguments: {α : Type u_1} [SeminormedRing α] (a : α) {n : ℕ} (h : 0 < n)
Goal: ‖a ^ n‖ ≤ ‖a‖ ^ n
-- norm_pow_le
theorem norm_pow_le [NormOneClass α] (a : α) (n : ℕ) : ‖a ^ n‖ ≤ ‖a‖ ^ n 
Arguments: {α : Type u_1} [SeminormedRing α] [NormOneClass α] (a : α) (n : ℕ)
Goal: ‖a ^ n‖ ≤ ‖a‖ ^ n
-- eventually_norm_pow_le
theorem eventually_norm_pow_le (a : α) : ∀ᶠ n : ℕ in atTop, ‖a ^ n‖ ≤ ‖a‖ ^ n 
Arguments: {α : Type u_1} [SeminormedRing α] (a : α)
Goal: ∀ᶠ (n : ℕ) in Filter.atTop, ‖a ^ n‖ ≤ ‖a‖ ^ n
-- Units.norm_pos
theorem Units.norm_pos [Nontrivial α] (x : αˣ) : 0 < ‖(x : α)‖ 
Arguments: {α : Type u_1} [NormedRing α] [Nontrivial α] (x : αˣ)
Goal: 0 < ‖↑x‖
-- Units.nnnorm_pos
theorem Units.nnnorm_pos [Nontrivial α] (x : αˣ) : 0 < ‖(x : α)‖₊ 
Arguments: {α : Type u_1} [NormedRing α] [Nontrivial α] (x : αˣ)
Goal: 0 < ‖↑x‖₊
-- norm_mul
@[simp]
theorem norm_mul (a b : α) : ‖a * b‖ = ‖a‖ * ‖b‖ 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a b : α)
Goal: ‖a * b‖ = ‖a‖ * ‖b‖
-- nnnorm_mul
@[simp]
theorem nnnorm_mul (a b : α) : ‖a * b‖₊ = ‖a‖₊ * ‖b‖₊ 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a b : α)
Goal: ‖a * b‖₊ = ‖a‖₊ * ‖b‖₊
-- normHom_apply
@[simps]
def normHom : α →*₀ ℝ 
Arguments: {α : Type u_1} [NormedDivisionRing α]
Goal: ∀ (x : α), normHom x = ‖x‖
-- nnnormHom_apply
@[simps]
def nnnormHom : α →*₀ ℝ≥0 
Arguments: {α : Type u_1} [NormedDivisionRing α]
Goal: ∀ (x : α), nnnormHom x = ‖x‖₊
-- norm_pow
@[simp]
theorem norm_pow (a : α) : ∀ n : ℕ, ‖a ^ n‖ = ‖a‖ ^ n 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a : α) (n : ℕ)
Goal: ‖a ^ n‖ = ‖a‖ ^ n
-- nnnorm_pow
@[simp]
theorem nnnorm_pow (a : α) (n : ℕ) : ‖a ^ n‖₊ = ‖a‖₊ ^ n 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a : α) (n : ℕ)
Goal: ‖a ^ n‖₊ = ‖a‖₊ ^ n
-- List.norm_prod
protected theorem List.norm_prod (l : List α) : ‖l.prod‖ = (l.map norm).prod 
Arguments: {α : Type u_1} [NormedDivisionRing α] (l : List α)
Goal: ‖l.prod‖ = (List.map norm l).prod
-- List.nnnorm_prod
protected theorem List.nnnorm_prod (l : List α) : ‖l.prod‖₊ = (l.map nnnorm).prod 
Arguments: {α : Type u_1} [NormedDivisionRing α] (l : List α)
Goal: ‖l.prod‖₊ = (List.map nnnorm l).prod
-- norm_div
@[simp]
theorem norm_div (a b : α) : ‖a / b‖ = ‖a‖ / ‖b‖ 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a b : α)
Goal: ‖a / b‖ = ‖a‖ / ‖b‖
-- nnnorm_div
@[simp]
theorem nnnorm_div (a b : α) : ‖a / b‖₊ = ‖a‖₊ / ‖b‖₊ 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a b : α)
Goal: ‖a / b‖₊ = ‖a‖₊ / ‖b‖₊
-- norm_inv
@[simp]
theorem norm_inv (a : α) : ‖a⁻¹‖ = ‖a‖⁻¹ 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a : α)
Goal: ‖a⁻¹‖ = ‖a‖⁻¹
-- nnnorm_inv
@[simp]
theorem nnnorm_inv (a : α) : ‖a⁻¹‖₊ = ‖a‖₊⁻¹ 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a : α)
Goal: ‖a⁻¹‖₊ = ‖a‖₊⁻¹
-- norm_zpow
@[simp]
theorem norm_zpow : ∀ (a : α) (n : ℤ), ‖a ^ n‖ = ‖a‖ ^ n 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a : α) (n : ℤ)
Goal: ‖a ^ n‖ = ‖a‖ ^ n
-- nnnorm_zpow
@[simp]
theorem nnnorm_zpow : ∀ (a : α) (n : ℤ), ‖a ^ n‖₊ = ‖a‖₊ ^ n 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a : α) (n : ℤ)
Goal: ‖a ^ n‖₊ = ‖a‖₊ ^ n
-- dist_inv_inv₀
theorem dist_inv_inv₀ {z w : α} (hz : z ≠ 0) (hw : w ≠ 0) :
    dist z⁻¹ w⁻¹ = dist z w / (‖z‖ * ‖w‖) 
Arguments: {α : Type u_1} [NormedDivisionRing α] {z w : α} (hz : z ≠ 0) (hw : w ≠ 0)
Goal: dist z⁻¹ w⁻¹ = dist z w / (‖z‖ * ‖w‖)
-- nndist_inv_inv₀
theorem nndist_inv_inv₀ {z w : α} (hz : z ≠ 0) (hw : w ≠ 0) :
    nndist z⁻¹ w⁻¹ = nndist z w / (‖z‖₊ * ‖w‖₊) 
Arguments: {α : Type u_1} [NormedDivisionRing α] {z w : α} (hz : z ≠ 0) (hw : w ≠ 0)
Goal: nndist z⁻¹ w⁻¹ = nndist z w / (‖z‖₊ * ‖w‖₊)
-- antilipschitzWith_mul_left
lemma antilipschitzWith_mul_left {a : α} (ha : a ≠ 0) : AntilipschitzWith (‖a‖₊⁻¹) (a * ·) 
Arguments: {α : Type u_1} [NormedDivisionRing α] {a : α} (ha : a ≠ 0)
Goal: AntilipschitzWith ‖a‖₊⁻¹ fun x => a * x
-- antilipschitzWith_mul_right
lemma antilipschitzWith_mul_right {a : α} (ha : a ≠ 0) : AntilipschitzWith (‖a‖₊⁻¹) (· * a) 
Arguments: {α : Type u_1} [NormedDivisionRing α] {a : α} (ha : a ≠ 0)
Goal: AntilipschitzWith ‖a‖₊⁻¹ fun x => x * a
-- DilationEquiv.mulLeft_apply
@[simps!]
def DilationEquiv.mulLeft (a : α) (ha : a ≠ 0) : α ≃ᵈ α 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a : α) (ha : a ≠ 0) (x : α)
Goal: (DilationEquiv.mulLeft a ha) x = a * x
-- DilationEquiv.mulLeft_symm_apply
@[simps!]
def DilationEquiv.mulLeft (a : α) (ha : a ≠ 0) : α ≃ᵈ α 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a : α) (ha : a ≠ 0) (x : α)
Goal: (DilationEquiv.mulLeft a ha).symm x = a⁻¹ * x
-- DilationEquiv.mulRight_apply
@[simps!]
def DilationEquiv.mulRight (a : α) (ha : a ≠ 0) : α ≃ᵈ α 
Arguments: {α : Type u_1} [NormedDivisionRing α] (a : α) (ha : a ≠ 0) (x : α)
Goal: (DilationEquiv.mulRight a ha) x = x * a