File: Mathlib/Analysis/Seminorm.lean

full_name: Seminorm.smul'
code: /-- A seminorm on a module over a normed ring is a function to the reals that is positive
semidefinite, positive homogeneous, and subadditive. -/
structure Seminorm (𝕜 : Type*) (E : Type*) [SeminormedRing 𝕜] [AddGroup E] [SMul 𝕜 E] extends
  AddGroupSeminorm E where
  /-- The seminorm of a scalar multiplication is the product of the absolute value of the scalar
  and the original seminorm. -/
  smul' : ∀ (a : 𝕜) (x : E), toFun (a • x) = ‖a‖ * toFun x
goal: self.toFun (a • x) = ‖a‖ * self.toFun x

full_name: Seminorm
code: /-- A seminorm on a module over a normed ring is a function to the reals that is positive
semidefinite, positive homogeneous, and subadditive. -/
structure Seminorm (𝕜 : Type*) (E : Type*) [SeminormedRing 𝕜] [AddGroup E] [SMul 𝕜 E] extends
  AddGroupSeminorm E where
  /-- The seminorm of a scalar multiplication is the product of the absolute value of the scalar
  and the original seminorm. -/
  smul' : ∀ (a : 𝕜) (x : E), toFun (a • x) = ‖a‖ * toFun x
goal: Type u_14

full_name: SeminormClass.map_smul_eq_mul
code: /-- `SeminormClass F 𝕜 E` states that `F` is a type of seminorms on the `𝕜`-module `E`.

You should extend this class when you extend `Seminorm`. -/
class SeminormClass (F : Type*) (𝕜 E : outParam Type*) [SeminormedRing 𝕜] [AddGroup E]
  [SMul 𝕜 E] [FunLike F E ℝ] extends AddGroupSeminormClass F E ℝ : Prop where
  /-- The seminorm of a scalar multiplication is the product of the absolute value of the scalar
  and the original seminorm. -/
  map_smul_eq_mul (f : F) (a : 𝕜) (x : E) : f (a • x) = ‖a‖ * f x
goal: f (a • x) = ‖a‖ * f x

full_name: SeminormClass
code: /-- `SeminormClass F 𝕜 E` states that `F` is a type of seminorms on the `𝕜`-module `E`.

You should extend this class when you extend `Seminorm`. -/
class SeminormClass (F : Type*) (𝕜 E : outParam Type*) [SeminormedRing 𝕜] [AddGroup E]
  [SMul 𝕜 E] [FunLike F E ℝ] extends AddGroupSeminormClass F E ℝ : Prop where
  /-- The seminorm of a scalar multiplication is the product of the absolute value of the scalar
  and the original seminorm. -/
  map_smul_eq_mul (f : F) (a : 𝕜) (x : E) : f (a • x) = ‖a‖ * f x
goal: Prop

full_name: Seminorm.of
code: /-- Alternative constructor for a `Seminorm` on an `AddCommGroup E` that is a module over a
`SeminormedRing 𝕜`. -/
def Seminorm.of [SeminormedRing 𝕜] [AddCommGroup E] [Module 𝕜 E] (f : E → ℝ)
    (add_le : ∀ x y : E, f (x + y) ≤ f x + f y) (smul : ∀ (a : 𝕜) (x : E), f (a • x) = ‖a‖ * f x) :
    Seminorm 𝕜 E 
goal: Seminorm 𝕜 E

full_name: Seminorm.ofSMulLE
code: /-- Alternative constructor for a `Seminorm` over a normed field `𝕜` that only assumes `f 0 = 0`
and an inequality for the scalar multiplication. -/
def Seminorm.ofSMulLE [NormedField 𝕜] [AddCommGroup E] [Module 𝕜 E] (f : E → ℝ) (map_zero : f 0 = 0)
    (add_le : ∀ x y, f (x + y) ≤ f x + f y) (smul_le : ∀ (r : 𝕜) (x), f (r • x) ≤ ‖r‖ * f x) :
    Seminorm 𝕜 E 
goal: Seminorm 𝕜 E

full_name: Seminorm.instFunLike
code: instance instFunLike : FunLike (Seminorm 𝕜 E) E ℝ 
goal: FunLike (Seminorm 𝕜 E) E ℝ

full_name: Seminorm.instSeminormClass
code: instance instSeminormClass : SeminormClass (Seminorm 𝕜 E) 𝕜 E 
goal: SeminormClass (Seminorm 𝕜 E) 𝕜 E

full_name: Seminorm.ext
code: @[ext]
theorem ext {p q : Seminorm 𝕜 E} (h : ∀ x, (p : E → ℝ) x = q x) : p = q 
goal: p = q

full_name: Seminorm.instZero
code: instance instZero : Zero (Seminorm 𝕜 E) 
goal: Zero (Seminorm 𝕜 E)

full_name: Seminorm.coe_zero
code: @[simp]
theorem coe_zero : ⇑(0 : Seminorm 𝕜 E) = 0 
goal: ⇑0 = 0

full_name: Seminorm.zero_apply
code: @[simp]
theorem zero_apply (x : E) : (0 : Seminorm 𝕜 E) x = 0 
goal: 0 x = 0

full_name: Seminorm.instInhabited
code: instance : Inhabited (Seminorm 𝕜 E) 
goal: Inhabited (Seminorm 𝕜 E)

full_name: Seminorm.instSMul
code: /-- Any action on `ℝ` which factors through `ℝ≥0` applies to a seminorm. -/
instance instSMul [SMul R ℝ] [SMul R ℝ≥0] [IsScalarTower R ℝ≥0 ℝ] : SMul R (Seminorm 𝕜 E) 
goal: SMul R (Seminorm 𝕜 E)

full_name: Seminorm.instIsScalarTowerOfReal
code: instance [SMul R ℝ] [SMul R ℝ≥0] [IsScalarTower R ℝ≥0 ℝ] [SMul R' ℝ] [SMul R' ℝ≥0]
    [IsScalarTower R' ℝ≥0 ℝ] [SMul R R'] [IsScalarTower R R' ℝ] :
    IsScalarTower R R' (Seminorm 𝕜 E) 
goal: IsScalarTower R R' (Seminorm 𝕜 E)

full_name: Seminorm.coe_smul
code: theorem coe_smul [SMul R ℝ] [SMul R ℝ≥0] [IsScalarTower R ℝ≥0 ℝ] (r : R) (p : Seminorm 𝕜 E) :
    ⇑(r • p) = r • ⇑p 
goal: ⇑(r • p) = r • ⇑p

full_name: Seminorm.smul_apply
code: @[simp]
theorem smul_apply [SMul R ℝ] [SMul R ℝ≥0] [IsScalarTower R ℝ≥0 ℝ] (r : R) (p : Seminorm 𝕜 E)
    (x : E) : (r • p) x = r • p x 
goal: (r • p) x = r • p x

full_name: Seminorm.instAdd
code: instance instAdd : Add (Seminorm 𝕜 E) 
goal: Add (Seminorm 𝕜 E)

full_name: Seminorm.coe_add
code: theorem coe_add (p q : Seminorm 𝕜 E) : ⇑(p + q) = p + q 
goal: ⇑(p + q) = ⇑p + ⇑q

full_name: Seminorm.add_apply
code: @[simp]
theorem add_apply (p q : Seminorm 𝕜 E) (x : E) : (p + q) x = p x + q x 
goal: (p + q) x = p x + q x

full_name: Seminorm.instAddMonoid
code: instance instAddMonoid : AddMonoid (Seminorm 𝕜 E) 
goal: AddMonoid (Seminorm 𝕜 E)

full_name: Seminorm.instOrderedCancelAddCommMonoid
code: instance instOrderedCancelAddCommMonoid : OrderedCancelAddCommMonoid (Seminorm 𝕜 E) 
goal: OrderedCancelAddCommMonoid (Seminorm 𝕜 E)

full_name: Seminorm.instMulAction
code: instance instMulAction [Monoid R] [MulAction R ℝ] [SMul R ℝ≥0] [IsScalarTower R ℝ≥0 ℝ] :
    MulAction R (Seminorm 𝕜 E) 
goal: MulAction R (Seminorm 𝕜 E)

full_name: Seminorm.coeFnAddMonoidHom
code: /-- `coeFn` as an `AddMonoidHom`. Helper definition for showing that `Seminorm 𝕜 E` is a module. -/
@[simps]
def coeFnAddMonoidHom : AddMonoidHom (Seminorm 𝕜 E) (E → ℝ) 
goal: Seminorm 𝕜 E →+ E → ℝ

full_name: Seminorm.coeFnAddMonoidHom_apply
code: /-- `coeFn` as an `AddMonoidHom`. Helper definition for showing that `Seminorm 𝕜 E` is a module. -/
@[simps]
def coeFnAddMonoidHom : AddMonoidHom (Seminorm 𝕜 E) (E → ℝ) 
goal: ∀ (a : Seminorm 𝕜 E) (a_1 : E), (Seminorm.coeFnAddMonoidHom 𝕜 E) a a_1 = a a_1

full_name: Seminorm.coeFnAddMonoidHom_injective
code: theorem coeFnAddMonoidHom_injective : Function.Injective (coeFnAddMonoidHom 𝕜 E) 
goal: Function.Injective ⇑(Seminorm.coeFnAddMonoidHom 𝕜 E)

full_name: Seminorm.instDistribMulAction
code: instance instDistribMulAction [Monoid R] [DistribMulAction R ℝ] [SMul R ℝ≥0]
    [IsScalarTower R ℝ≥0 ℝ] : DistribMulAction R (Seminorm 𝕜 E) 
goal: DistribMulAction R (Seminorm 𝕜 E)

full_name: Seminorm.instModule
code: instance instModule [Semiring R] [Module R ℝ] [SMul R ℝ≥0] [IsScalarTower R ℝ≥0 ℝ] :
    Module R (Seminorm 𝕜 E) 
goal: Module R (Seminorm 𝕜 E)

full_name: Seminorm.instSup
code: instance instSup : Sup (Seminorm 𝕜 E) 
goal: Sup (Seminorm 𝕜 E)

full_name: Seminorm.coe_sup
code: @[simp]
theorem coe_sup (p q : Seminorm 𝕜 E) : ⇑(p ⊔ q) = (p : E → ℝ) ⊔ (q : E → ℝ) 
goal: ⇑(p ⊔ q) = ⇑p ⊔ ⇑q

full_name: Seminorm.sup_apply
code: theorem sup_apply (p q : Seminorm 𝕜 E) (x : E) : (p ⊔ q) x = p x ⊔ q x 
goal: (p ⊔ q) x = p x ⊔ q x

full_name: Seminorm.smul_sup
code: theorem smul_sup [SMul R ℝ] [SMul R ℝ≥0] [IsScalarTower R ℝ≥0 ℝ] (r : R) (p q : Seminorm 𝕜 E) :
    r • (p ⊔ q) = r • p ⊔ r • q 
goal: r • (p ⊔ q) = r • p ⊔ r • q

full_name: Seminorm.instPartialOrder
code: instance instPartialOrder : PartialOrder (Seminorm 𝕜 E) 
goal: PartialOrder (Seminorm 𝕜 E)

full_name: Seminorm.coe_le_coe
code: @[simp, norm_cast]
theorem coe_le_coe {p q : Seminorm 𝕜 E} : (p : E → ℝ) ≤ q ↔ p ≤ q 
goal: ⇑p ≤ ⇑q ↔ p ≤ q

full_name: Seminorm.coe_lt_coe
code: @[simp, norm_cast]
theorem coe_lt_coe {p q : Seminorm 𝕜 E} : (p : E → ℝ) < q ↔ p < q 
goal: ⇑p < ⇑q ↔ p < q

full_name: Seminorm.le_def
code: theorem le_def {p q : Seminorm 𝕜 E} : p ≤ q ↔ ∀ x, p x ≤ q x 
goal: p ≤ q ↔ ∀ (x : E), p x ≤ q x

full_name: Seminorm.lt_def
code: theorem lt_def {p q : Seminorm 𝕜 E} : p < q ↔ p ≤ q ∧ ∃ x, p x < q x 
goal: p < q ↔ p ≤ q ∧ ∃ x, p x < q x

full_name: Seminorm.instSemilatticeSup
code: instance instSemilatticeSup : SemilatticeSup (Seminorm 𝕜 E) 
goal: SemilatticeSup (Seminorm 𝕜 E)

full_name: Seminorm.smul_nnreal_real
code: noncomputable instance smul_nnreal_real : SMul ℝ≥0 ℝ 
goal: SMul ℝ≥0 ℝ

full_name: Seminorm.comp
code: /-- Composition of a seminorm with a linear map is a seminorm. -/
def comp (p : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂] E₂) : Seminorm 𝕜 E 
goal: Seminorm 𝕜 E

full_name: Seminorm.coe_comp
code: theorem coe_comp (p : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂] E₂) : ⇑(p.comp f) = p ∘ f 
goal: ⇑(p.comp f) = ⇑p ∘ ⇑f

full_name: Seminorm.comp_apply
code: @[simp]
theorem comp_apply (p : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂] E₂) (x : E) : (p.comp f) x = p (f x) 
goal: (p.comp f) x = p (f x)

full_name: Seminorm.comp_id
code: @[simp]
theorem comp_id (p : Seminorm 𝕜 E) : p.comp LinearMap.id = p 
goal: p.comp LinearMap.id = p

full_name: Seminorm.comp_zero
code: @[simp]
theorem comp_zero (p : Seminorm 𝕜₂ E₂) : p.comp (0 : E →ₛₗ[σ₁₂] E₂) = 0 
goal: p.comp 0 = 0

full_name: Seminorm.zero_comp
code: @[simp]
theorem zero_comp (f : E →ₛₗ[σ₁₂] E₂) : (0 : Seminorm 𝕜₂ E₂).comp f = 0 
goal: Seminorm.comp 0 f = 0

full_name: Seminorm.comp_comp
code: theorem comp_comp [RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] (p : Seminorm 𝕜₃ E₃) (g : E₂ →ₛₗ[σ₂₃] E₃)
    (f : E →ₛₗ[σ₁₂] E₂) : p.comp (g.comp f) = (p.comp g).comp f 
goal: p.comp (g.comp f) = (p.comp g).comp f

full_name: Seminorm.add_comp
code: theorem add_comp (p q : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂] E₂) :
    (p + q).comp f = p.comp f + q.comp f 
goal: (p + q).comp f = p.comp f + q.comp f

full_name: Seminorm.comp_add_le
code: theorem comp_add_le (p : Seminorm 𝕜₂ E₂) (f g : E →ₛₗ[σ₁₂] E₂) :
    p.comp (f + g) ≤ p.comp f + p.comp g 
goal: p.comp (f + g) ≤ p.comp f + p.comp g

full_name: Seminorm.smul_comp
code: theorem smul_comp (p : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂] E₂) (c : R) :
    (c • p).comp f = c • p.comp f 
goal: (c • p).comp f = c • p.comp f

full_name: Seminorm.comp_mono
code: theorem comp_mono {p q : Seminorm 𝕜₂ E₂} (f : E →ₛₗ[σ₁₂] E₂) (hp : p ≤ q) : p.comp f ≤ q.comp f 
goal: p.comp f ≤ q.comp f

full_name: Seminorm.pullback_apply
code: /-- The composition as an `AddMonoidHom`. -/
@[simps]
def pullback (f : E →ₛₗ[σ₁₂] E₂) : Seminorm 𝕜₂ E₂ →+ Seminorm 𝕜 E 
goal: (Seminorm.pullback f) p = p.comp f

full_name: Seminorm.pullback
code: /-- The composition as an `AddMonoidHom`. -/
@[simps]
def pullback (f : E →ₛₗ[σ₁₂] E₂) : Seminorm 𝕜₂ E₂ →+ Seminorm 𝕜 E 
goal: Seminorm 𝕜₂ E₂ →+ Seminorm 𝕜 E

full_name: Seminorm.instOrderBot
code: instance instOrderBot : OrderBot (Seminorm 𝕜 E) 
goal: OrderBot (Seminorm 𝕜 E)

full_name: Seminorm.coe_bot
code: @[simp]
theorem coe_bot : ⇑(⊥ : Seminorm 𝕜 E) = 0 
goal: ⇑⊥ = 0

full_name: Seminorm.bot_eq_zero
code: theorem bot_eq_zero : (⊥ : Seminorm 𝕜 E) = 0 
goal: ⊥ = 0

full_name: Seminorm.smul_le_smul
code: theorem smul_le_smul {p q : Seminorm 𝕜 E} {a b : ℝ≥0} (hpq : p ≤ q) (hab : a ≤ b) :
    a • p ≤ b • q 
goal: a • p ≤ b • q

full_name: Seminorm.finset_sup_apply
code: theorem finset_sup_apply (p : ι → Seminorm 𝕜 E) (s : Finset ι) (x : E) :
    s.sup p x = ↑(s.sup fun i => ⟨p i x, apply_nonneg (p i) x⟩ : ℝ≥0) 
goal: (s.sup p) x = ↑(s.sup fun i => ⟨(p i) x, ⋯⟩)

full_name: Seminorm.exists_apply_eq_finset_sup
code: theorem exists_apply_eq_finset_sup (p : ι → Seminorm 𝕜 E) {s : Finset ι} (hs : s.Nonempty) (x : E) :
    ∃ i ∈ s, s.sup p x = p i x 
goal: ∃ i ∈ s, (s.sup p) x = (p i) x

full_name: Seminorm.zero_or_exists_apply_eq_finset_sup
code: theorem zero_or_exists_apply_eq_finset_sup (p : ι → Seminorm 𝕜 E) (s : Finset ι) (x : E) :
    s.sup p x = 0 ∨ ∃ i ∈ s, s.sup p x = p i x 
goal: (s.sup p) x = 0 ∨ ∃ i ∈ s, (s.sup p) x = (p i) x

full_name: Seminorm.finset_sup_smul
code: theorem finset_sup_smul (p : ι → Seminorm 𝕜 E) (s : Finset ι) (C : ℝ≥0) :
    s.sup (C • p) = C • s.sup p 
goal: s.sup (C • p) = C • s.sup p

full_name: Seminorm.finset_sup_le_sum
code: theorem finset_sup_le_sum (p : ι → Seminorm 𝕜 E) (s : Finset ι) : s.sup p ≤ ∑ i ∈ s, p i 
goal: s.sup p ≤ ∑ i ∈ s, p i

full_name: Seminorm.finset_sup_apply_le
code: theorem finset_sup_apply_le {p : ι → Seminorm 𝕜 E} {s : Finset ι} {x : E} {a : ℝ} (ha : 0 ≤ a)
    (h : ∀ i, i ∈ s → p i x ≤ a) : s.sup p x ≤ a 
goal: (s.sup p) x ≤ a

full_name: Seminorm.le_finset_sup_apply
code: theorem le_finset_sup_apply {p : ι → Seminorm 𝕜 E} {s : Finset ι} {x : E} {i : ι}
    (hi : i ∈ s) : p i x ≤ s.sup p x 
goal: (p i) x ≤ (s.sup p) x

full_name: Seminorm.finset_sup_apply_lt
code: theorem finset_sup_apply_lt {p : ι → Seminorm 𝕜 E} {s : Finset ι} {x : E} {a : ℝ} (ha : 0 < a)
    (h : ∀ i, i ∈ s → p i x < a) : s.sup p x < a 
goal: (s.sup p) x < a

full_name: Seminorm.norm_sub_map_le_sub
code: theorem norm_sub_map_le_sub (p : Seminorm 𝕜 E) (x y : E) : ‖p x - p y‖ ≤ p (x - y) 
goal: ‖p x - p y‖ ≤ p (x - y)

full_name: Seminorm.comp_smul
code: theorem comp_smul (p : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂] E₂) (c : 𝕜₂) :
    p.comp (c • f) = ‖c‖₊ • p.comp f 
goal: p.comp (c • f) = ‖c‖₊ • p.comp f

full_name: Seminorm.comp_smul_apply
code: theorem comp_smul_apply (p : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂] E₂) (c : 𝕜₂) (x : E) :
    p.comp (c • f) x = ‖c‖ * p (f x) 
goal: (p.comp (c • f)) x = ‖c‖ * p (f x)

full_name: Seminorm.bddBelow_range_add
code: /-- Auxiliary lemma to show that the infimum of seminorms is well-defined. -/
theorem bddBelow_range_add : BddBelow (range fun u => p u + q (x - u)) 
goal: BddBelow (Set.range fun u => p u + q (x - u))

full_name: Seminorm.instInf
code: noncomputable instance instInf : Inf (Seminorm 𝕜 E) 
goal: Inf (Seminorm 𝕜 E)

full_name: Seminorm.inf_apply
code: @[simp]
theorem inf_apply (p q : Seminorm 𝕜 E) (x : E) : (p ⊓ q) x = ⨅ u : E, p u + q (x - u) 
goal: (p ⊓ q) x = ⨅ u, p u + q (x - u)

full_name: Seminorm.instLattice
code: noncomputable instance instLattice : Lattice (Seminorm 𝕜 E) 
goal: Lattice (Seminorm 𝕜 E)

full_name: Seminorm.smul_inf
code: theorem smul_inf [SMul R ℝ] [SMul R ℝ≥0] [IsScalarTower R ℝ≥0 ℝ] (r : R) (p q : Seminorm 𝕜 E) :
    r • (p ⊓ q) = r • p ⊓ r • q 
goal: r • (p ⊓ q) = r • p ⊓ r • q

full_name: Seminorm.instSupSet
code: /-- We define the supremum of an arbitrary subset of `Seminorm 𝕜 E` as follows:
* if `s` is `BddAbove` *as a set of functions `E → ℝ`* (that is, if `s` is pointwise bounded
above), we take the pointwise supremum of all elements of `s`, and we prove that it is indeed a
seminorm.
* otherwise, we take the zero seminorm `⊥`.

There are two things worth mentioning here:
* First, it is not trivial at first that `s` being bounded above *by a function* implies
being bounded above *as a seminorm*. We show this in `Seminorm.bddAbove_iff` by using
that the `Sup s` as defined here is then a bounding seminorm for `s`. So it is important to make
the case disjunction on `BddAbove ((↑) '' s : Set (E → ℝ))` and not `BddAbove s`.
* Since the pointwise `Sup` already gives `0` at points where a family of functions is
not bounded above, one could hope that just using the pointwise `Sup` would work here, without the
need for an additional case disjunction. As discussed on Zulip, this doesn't work because this can
give a function which does *not* satisfy the seminorm axioms (typically sub-additivity).
-/
noncomputable instance instSupSet : SupSet (Seminorm 𝕜 E) 
goal: SupSet (Seminorm 𝕜 E)

full_name: Seminorm.coe_sSup_eq'
code: protected theorem coe_sSup_eq' {s : Set <| Seminorm 𝕜 E}
    (hs : BddAbove ((↑) '' s : Set (E → ℝ))) : ↑(sSup s) = ⨆ p : s, ((p : Seminorm 𝕜 E) : E → ℝ) 
goal: ⇑(sSup s) = ⨆ p, ⇑↑p

full_name: Seminorm.bddAbove_iff
code: protected theorem bddAbove_iff {s : Set <| Seminorm 𝕜 E} :
    BddAbove s ↔ BddAbove ((↑) '' s : Set (E → ℝ)) 
goal: BddAbove s ↔ BddAbove (DFunLike.coe '' s)

full_name: Seminorm.bddAbove_range_iff
code: protected theorem bddAbove_range_iff {ι : Sort*} {p : ι → Seminorm 𝕜 E} :
    BddAbove (range p) ↔ ∀ x, BddAbove (range fun i ↦ p i x) 
goal: BddAbove (Set.range p) ↔ ∀ (x : E), BddAbove (Set.range fun i => (p i) x)

full_name: Seminorm.coe_sSup_eq
code: protected theorem coe_sSup_eq {s : Set <| Seminorm 𝕜 E} (hs : BddAbove s) :
    ↑(sSup s) = ⨆ p : s, ((p : Seminorm 𝕜 E) : E → ℝ) 
goal: ⇑(sSup s) = ⨆ p, ⇑↑p

full_name: Seminorm.coe_iSup_eq
code: protected theorem coe_iSup_eq {ι : Sort*} {p : ι → Seminorm 𝕜 E} (hp : BddAbove (range p)) :
    ↑(⨆ i, p i) = ⨆ i, ((p i : Seminorm 𝕜 E) : E → ℝ) 
goal: ⇑(⨆ i, p i) = ⨆ i, ⇑(p i)

full_name: Seminorm.sSup_apply
code: protected theorem sSup_apply {s : Set (Seminorm 𝕜 E)} (hp : BddAbove s) {x : E} :
    (sSup s) x = ⨆ p : s, (p : E → ℝ) x 
goal: (sSup s) x = ⨆ p, ↑p x

full_name: Seminorm.iSup_apply
code: protected theorem iSup_apply {ι : Sort*} {p : ι → Seminorm 𝕜 E}
    (hp : BddAbove (range p)) {x : E} : (⨆ i, p i) x = ⨆ i, p i x 
goal: (⨆ i, p i) x = ⨆ i, (p i) x

full_name: Seminorm.sSup_empty
code: protected theorem sSup_empty : sSup (∅ : Set (Seminorm 𝕜 E)) = ⊥ 
goal: sSup ∅ = ⊥

full_name: _private.Mathlib.Analysis.Seminorm.0.Seminorm.isLUB_sSup
code: private theorem isLUB_sSup (s : Set (Seminorm 𝕜 E)) (hs₁ : BddAbove s) (hs₂ : s.Nonempty) :
    IsLUB s (sSup s) 
goal: IsLUB s (sSup s)

full_name: Seminorm.instConditionallyCompleteLattice
code: /-- `Seminorm 𝕜 E` is a conditionally complete lattice.

Note that, while `inf`, `sup` and `sSup` have good definitional properties (corresponding to
the instances given here for `Inf`, `Sup` and `SupSet` respectively), `sInf s` is just
defined as the supremum of the lower bounds of `s`, which is not really useful in practice. If you
need to use `sInf` on seminorms, then you should probably provide a more workable definition first,
but this is unlikely to happen so we keep the "bad" definition for now. -/
noncomputable instance instConditionallyCompleteLattice :
    ConditionallyCompleteLattice (Seminorm 𝕜 E) 
goal: ConditionallyCompleteLattice (Seminorm 𝕜 E)

full_name: Seminorm.ball
code: /-- The ball of radius `r` at `x` with respect to seminorm `p` is the set of elements `y` with
`p (y - x) < r`. -/
def ball (x : E) (r : ℝ) 
goal: Set E

full_name: Seminorm.closedBall
code: /-- The closed ball of radius `r` at `x` with respect to seminorm `p` is the set of elements `y`
with `p (y - x) ≤ r`. -/
def closedBall (x : E) (r : ℝ) 
goal: Set E

full_name: Seminorm.mem_ball
code: @[simp]
theorem mem_ball : y ∈ ball p x r ↔ p (y - x) < r 
goal: y ∈ p.ball x r ↔ p (y - x) < r

full_name: Seminorm.mem_closedBall
code: @[simp]
theorem mem_closedBall : y ∈ closedBall p x r ↔ p (y - x) ≤ r 
goal: y ∈ p.closedBall x r ↔ p (y - x) ≤ r

full_name: Seminorm.mem_ball_self
code: theorem mem_ball_self (hr : 0 < r) : x ∈ ball p x r 
goal: x ∈ p.ball x r

full_name: Seminorm.mem_closedBall_self
code: theorem mem_closedBall_self (hr : 0 ≤ r) : x ∈ closedBall p x r 
goal: x ∈ p.closedBall x r

full_name: Seminorm.mem_ball_zero
code: theorem mem_ball_zero : y ∈ ball p 0 r ↔ p y < r 
goal: y ∈ p.ball 0 r ↔ p y < r

full_name: Seminorm.mem_closedBall_zero
code: theorem mem_closedBall_zero : y ∈ closedBall p 0 r ↔ p y ≤ r 
goal: y ∈ p.closedBall 0 r ↔ p y ≤ r

full_name: Seminorm.ball_zero_eq
code: theorem ball_zero_eq : ball p 0 r = { y : E | p y < r } 
goal: p.ball 0 r = {y | p y < r}

full_name: Seminorm.closedBall_zero_eq
code: theorem closedBall_zero_eq : closedBall p 0 r = { y : E | p y ≤ r } 
goal: p.closedBall 0 r = {y | p y ≤ r}

full_name: Seminorm.ball_subset_closedBall
code: theorem ball_subset_closedBall (x r) : ball p x r ⊆ closedBall p x r 
goal: p.ball x r ⊆ p.closedBall x r

full_name: Seminorm.closedBall_eq_biInter_ball
code: theorem closedBall_eq_biInter_ball (x r) : closedBall p x r = ⋂ ρ > r, ball p x ρ 
goal: p.closedBall x r = ⋂ ρ, ⋂ (_ : ρ > r), p.ball x ρ

full_name: Seminorm.ball_zero'
code: @[simp]
theorem ball_zero' (x : E) (hr : 0 < r) : ball (0 : Seminorm 𝕜 E) x r = Set.univ 
goal: Seminorm.ball 0 x r = Set.univ

full_name: Seminorm.closedBall_zero'
code: @[simp]
theorem closedBall_zero' (x : E) (hr : 0 < r) : closedBall (0 : Seminorm 𝕜 E) x r = Set.univ 
goal: Seminorm.closedBall 0 x r = Set.univ

full_name: Seminorm.ball_smul
code: theorem ball_smul (p : Seminorm 𝕜 E) {c : NNReal} (hc : 0 < c) (r : ℝ) (x : E) :
    (c • p).ball x r = p.ball x (r / c) 
goal: (c • p).ball x r = p.ball x (r / ↑c)

full_name: Seminorm.closedBall_smul
code: theorem closedBall_smul (p : Seminorm 𝕜 E) {c : NNReal} (hc : 0 < c) (r : ℝ) (x : E) :
    (c • p).closedBall x r = p.closedBall x (r / c) 
goal: (c • p).closedBall x r = p.closedBall x (r / ↑c)

full_name: Seminorm.ball_sup
code: theorem ball_sup (p : Seminorm 𝕜 E) (q : Seminorm 𝕜 E) (e : E) (r : ℝ) :
    ball (p ⊔ q) e r = ball p e r ∩ ball q e r 
goal: (p ⊔ q).ball e r = p.ball e r ∩ q.ball e r

full_name: Seminorm.closedBall_sup
code: theorem closedBall_sup (p : Seminorm 𝕜 E) (q : Seminorm 𝕜 E) (e : E) (r : ℝ) :
    closedBall (p ⊔ q) e r = closedBall p e r ∩ closedBall q e r 
goal: (p ⊔ q).closedBall e r = p.closedBall e r ∩ q.closedBall e r

full_name: Seminorm.ball_finset_sup'
code: theorem ball_finset_sup' (p : ι → Seminorm 𝕜 E) (s : Finset ι) (H : s.Nonempty) (e : E) (r : ℝ) :
    ball (s.sup' H p) e r = s.inf' H fun i => ball (p i) e r 
goal: (s.sup' H p).ball e r = s.inf' H fun i => (p i).ball e r

full_name: Seminorm.closedBall_finset_sup'
code: theorem closedBall_finset_sup' (p : ι → Seminorm 𝕜 E) (s : Finset ι) (H : s.Nonempty) (e : E)
    (r : ℝ) : closedBall (s.sup' H p) e r = s.inf' H fun i => closedBall (p i) e r 
goal: (s.sup' H p).closedBall e r = s.inf' H fun i => (p i).closedBall e r

full_name: Seminorm.ball_mono
code: theorem ball_mono {p : Seminorm 𝕜 E} {r₁ r₂ : ℝ} (h : r₁ ≤ r₂) : p.ball x r₁ ⊆ p.ball x r₂ 
goal: p.ball x r₁ ⊆ p.ball x r₂

full_name: Seminorm.closedBall_mono
code: theorem closedBall_mono {p : Seminorm 𝕜 E} {r₁ r₂ : ℝ} (h : r₁ ≤ r₂) :
    p.closedBall x r₁ ⊆ p.closedBall x r₂ 
goal: p.closedBall x r₁ ⊆ p.closedBall x r₂

full_name: Seminorm.ball_antitone
code: theorem ball_antitone {p q : Seminorm 𝕜 E} (h : q ≤ p) : p.ball x r ⊆ q.ball x r 
goal: p.ball x r ⊆ q.ball x r

full_name: Seminorm.closedBall_antitone
code: theorem closedBall_antitone {p q : Seminorm 𝕜 E} (h : q ≤ p) :
    p.closedBall x r ⊆ q.closedBall x r 
goal: p.closedBall x r ⊆ q.closedBall x r

full_name: Seminorm.ball_add_ball_subset
code: theorem ball_add_ball_subset (p : Seminorm 𝕜 E) (r₁ r₂ : ℝ) (x₁ x₂ : E) :
    p.ball (x₁ : E) r₁ + p.ball (x₂ : E) r₂ ⊆ p.ball (x₁ + x₂) (r₁ + r₂) 
goal: p.ball x₁ r₁ + p.ball x₂ r₂ ⊆ p.ball (x₁ + x₂) (r₁ + r₂)

full_name: Seminorm.closedBall_add_closedBall_subset
code: theorem closedBall_add_closedBall_subset (p : Seminorm 𝕜 E) (r₁ r₂ : ℝ) (x₁ x₂ : E) :
    p.closedBall (x₁ : E) r₁ + p.closedBall (x₂ : E) r₂ ⊆ p.closedBall (x₁ + x₂) (r₁ + r₂) 
goal: p.closedBall x₁ r₁ + p.closedBall x₂ r₂ ⊆ p.closedBall (x₁ + x₂) (r₁ + r₂)

full_name: Seminorm.sub_mem_ball
code: theorem sub_mem_ball (p : Seminorm 𝕜 E) (x₁ x₂ y : E) (r : ℝ) :
    x₁ - x₂ ∈ p.ball y r ↔ x₁ ∈ p.ball (x₂ + y) r 
goal: x₁ - x₂ ∈ p.ball y r ↔ x₁ ∈ p.ball (x₂ + y) r

full_name: Seminorm.vadd_ball
code: /-- The image of a ball under addition with a singleton is another ball. -/
theorem vadd_ball (p : Seminorm 𝕜 E) : x +ᵥ p.ball y r = p.ball (x +ᵥ y) r 
goal: x +ᵥ p.ball y r = p.ball (x +ᵥ y) r

full_name: Seminorm.vadd_closedBall
code: /-- The image of a closed ball under addition with a singleton is another closed ball. -/
theorem vadd_closedBall (p : Seminorm 𝕜 E) : x +ᵥ p.closedBall y r = p.closedBall (x +ᵥ y) r 
goal: x +ᵥ p.closedBall y r = p.closedBall (x +ᵥ y) r

full_name: Seminorm.ball_comp
code: theorem ball_comp (p : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂] E₂) (x : E) (r : ℝ) :
    (p.comp f).ball x r = f ⁻¹' p.ball (f x) r 
goal: (p.comp f).ball x r = ⇑f ⁻¹' p.ball (f x) r

full_name: Seminorm.closedBall_comp
code: theorem closedBall_comp (p : Seminorm 𝕜₂ E₂) (f : E →ₛₗ[σ₁₂] E₂) (x : E) (r : ℝ) :
    (p.comp f).closedBall x r = f ⁻¹' p.closedBall (f x) r 
goal: (p.comp f).closedBall x r = ⇑f ⁻¹' p.closedBall (f x) r

full_name: Seminorm.preimage_metric_ball
code: theorem preimage_metric_ball {r : ℝ} : p ⁻¹' Metric.ball 0 r = { x | p x < r } 
goal: ⇑p ⁻¹' Metric.ball 0 r = {x | p x < r}

full_name: Seminorm.preimage_metric_closedBall
code: theorem preimage_metric_closedBall {r : ℝ} : p ⁻¹' Metric.closedBall 0 r = { x | p x ≤ r } 
goal: ⇑p ⁻¹' Metric.closedBall 0 r = {x | p x ≤ r}

full_name: Seminorm.ball_zero_eq_preimage_ball
code: theorem ball_zero_eq_preimage_ball {r : ℝ} : p.ball 0 r = p ⁻¹' Metric.ball 0 r 
goal: p.ball 0 r = ⇑p ⁻¹' Metric.ball 0 r

full_name: Seminorm.closedBall_zero_eq_preimage_closedBall
code: theorem closedBall_zero_eq_preimage_closedBall {r : ℝ} :
    p.closedBall 0 r = p ⁻¹' Metric.closedBall 0 r 
goal: p.closedBall 0 r = ⇑p ⁻¹' Metric.closedBall 0 r

full_name: Seminorm.ball_bot
code: @[simp]
theorem ball_bot {r : ℝ} (x : E) (hr : 0 < r) : ball (⊥ : Seminorm 𝕜 E) x r = Set.univ 
goal: ⊥.ball x r = Set.univ

full_name: Seminorm.closedBall_bot
code: @[simp]
theorem closedBall_bot {r : ℝ} (x : E) (hr : 0 < r) :
    closedBall (⊥ : Seminorm 𝕜 E) x r = Set.univ 
goal: ⊥.closedBall x r = Set.univ

full_name: Seminorm.balanced_ball_zero
code: /-- Seminorm-balls at the origin are balanced. -/
theorem balanced_ball_zero (r : ℝ) : Balanced 𝕜 (ball p 0 r) 
goal: Balanced 𝕜 (p.ball 0 r)

full_name: Seminorm.balanced_closedBall_zero
code: /-- Closed seminorm-balls at the origin are balanced. -/
theorem balanced_closedBall_zero (r : ℝ) : Balanced 𝕜 (closedBall p 0 r) 
goal: Balanced 𝕜 (p.closedBall 0 r)

full_name: Seminorm.ball_finset_sup_eq_iInter
code: theorem ball_finset_sup_eq_iInter (p : ι → Seminorm 𝕜 E) (s : Finset ι) (x : E) {r : ℝ}
    (hr : 0 < r) : ball (s.sup p) x r = ⋂ i ∈ s, ball (p i) x r 
goal: (s.sup p).ball x r = ⋂ i ∈ s, (p i).ball x r

full_name: Seminorm.closedBall_finset_sup_eq_iInter
code: theorem closedBall_finset_sup_eq_iInter (p : ι → Seminorm 𝕜 E) (s : Finset ι) (x : E) {r : ℝ}
    (hr : 0 ≤ r) : closedBall (s.sup p) x r = ⋂ i ∈ s, closedBall (p i) x r 
goal: (s.sup p).closedBall x r = ⋂ i ∈ s, (p i).closedBall x r

full_name: Seminorm.ball_finset_sup
code: theorem ball_finset_sup (p : ι → Seminorm 𝕜 E) (s : Finset ι) (x : E) {r : ℝ} (hr : 0 < r) :
    ball (s.sup p) x r = s.inf fun i => ball (p i) x r 
goal: (s.sup p).ball x r = s.inf fun i => (p i).ball x r

full_name: Seminorm.closedBall_finset_sup
code: theorem closedBall_finset_sup (p : ι → Seminorm 𝕜 E) (s : Finset ι) (x : E) {r : ℝ} (hr : 0 ≤ r) :
    closedBall (s.sup p) x r = s.inf fun i => closedBall (p i) x r 
goal: (s.sup p).closedBall x r = s.inf fun i => (p i).closedBall x r

full_name: Seminorm.ball_eq_emptyset
code: @[simp]
theorem ball_eq_emptyset (p : Seminorm 𝕜 E) {x : E} {r : ℝ} (hr : r ≤ 0) : p.ball x r = ∅ 
goal: p.ball x r = ∅

full_name: Seminorm.closedBall_eq_emptyset
code: @[simp]
theorem closedBall_eq_emptyset (p : Seminorm 𝕜 E) {x : E} {r : ℝ} (hr : r < 0) :
    p.closedBall x r = ∅ 
goal: p.closedBall x r = ∅

full_name: Seminorm.closedBall_smul_ball
code: theorem closedBall_smul_ball (p : Seminorm 𝕜 E) {r₁ : ℝ} (hr₁ : r₁ ≠ 0) (r₂ : ℝ) :
    Metric.closedBall (0 : 𝕜) r₁ • p.ball 0 r₂ ⊆ p.ball 0 (r₁ * r₂) 
goal: Metric.closedBall 0 r₁ • p.ball 0 r₂ ⊆ p.ball 0 (r₁ * r₂)

full_name: Seminorm.ball_smul_closedBall
code: theorem ball_smul_closedBall (p : Seminorm 𝕜 E) (r₁ : ℝ) {r₂ : ℝ} (hr₂ : r₂ ≠ 0) :
    Metric.ball (0 : 𝕜) r₁ • p.closedBall 0 r₂ ⊆ p.ball 0 (r₁ * r₂) 
goal: Metric.ball 0 r₁ • p.closedBall 0 r₂ ⊆ p.ball 0 (r₁ * r₂)

full_name: Seminorm.ball_smul_ball
code: theorem ball_smul_ball (p : Seminorm 𝕜 E) (r₁ r₂ : ℝ) :
    Metric.ball (0 : 𝕜) r₁ • p.ball 0 r₂ ⊆ p.ball 0 (r₁ * r₂) 
goal: Metric.ball 0 r₁ • p.ball 0 r₂ ⊆ p.ball 0 (r₁ * r₂)

full_name: Seminorm.closedBall_smul_closedBall
code: theorem closedBall_smul_closedBall (p : Seminorm 𝕜 E) (r₁ r₂ : ℝ) :
    Metric.closedBall (0 : 𝕜) r₁ • p.closedBall 0 r₂ ⊆ p.closedBall 0 (r₁ * r₂) 
goal: Metric.closedBall 0 r₁ • p.closedBall 0 r₂ ⊆ p.closedBall 0 (r₁ * r₂)

full_name: Seminorm.neg_mem_ball_zero
code: theorem neg_mem_ball_zero {r : ℝ} {x : E} : -x ∈ ball p 0 r ↔ x ∈ ball p 0 r 
goal: -x ∈ p.ball 0 r ↔ x ∈ p.ball 0 r

full_name: Seminorm.neg_ball
code: @[simp]
theorem neg_ball (p : Seminorm 𝕜 E) (r : ℝ) (x : E) : -ball p x r = ball p (-x) r 
goal: -p.ball x r = p.ball (-x) r

full_name: Seminorm.closedBall_iSup
code: theorem closedBall_iSup {ι : Sort*} {p : ι → Seminorm 𝕜 E} (hp : BddAbove (range p)) (e : E)
    {r : ℝ} (hr : 0 < r) : closedBall (⨆ i, p i) e r = ⋂ i, closedBall (p i) e r 
goal: (⨆ i, p i).closedBall e r = ⋂ i, (p i).closedBall e r

full_name: Seminorm.ball_norm_mul_subset
code: theorem ball_norm_mul_subset {p : Seminorm 𝕜 E} {k : 𝕜} {r : ℝ} :
    p.ball 0 (‖k‖ * r) ⊆ k • p.ball 0 r 
goal: p.ball 0 (‖k‖ * r) ⊆ k • p.ball 0 r

full_name: Seminorm.smul_ball_zero
code: theorem smul_ball_zero {p : Seminorm 𝕜 E} {k : 𝕜} {r : ℝ} (hk : k ≠ 0) :
    k • p.ball 0 r = p.ball 0 (‖k‖ * r) 
goal: k • p.ball 0 r = p.ball 0 (‖k‖ * r)

full_name: Seminorm.smul_closedBall_subset
code: theorem smul_closedBall_subset {p : Seminorm 𝕜 E} {k : 𝕜} {r : ℝ} :
    k • p.closedBall 0 r ⊆ p.closedBall 0 (‖k‖ * r) 
goal: k • p.closedBall 0 r ⊆ p.closedBall 0 (‖k‖ * r)

full_name: Seminorm.smul_closedBall_zero
code: theorem smul_closedBall_zero {p : Seminorm 𝕜 E} {k : 𝕜} {r : ℝ} (hk : 0 < ‖k‖) :
    k • p.closedBall 0 r = p.closedBall 0 (‖k‖ * r) 
goal: k • p.closedBall 0 r = p.closedBall 0 (‖k‖ * r)

full_name: Seminorm.ball_zero_absorbs_ball_zero
code: theorem ball_zero_absorbs_ball_zero (p : Seminorm 𝕜 E) {r₁ r₂ : ℝ} (hr₁ : 0 < r₁) :
    Absorbs 𝕜 (p.ball 0 r₁) (p.ball 0 r₂) 
goal: Absorbs 𝕜 (p.ball 0 r₁) (p.ball 0 r₂)

full_name: Seminorm.absorbent_ball_zero
code: /-- Seminorm-balls at the origin are absorbent. -/
protected theorem absorbent_ball_zero (hr : 0 < r) : Absorbent 𝕜 (ball p (0 : E) r) 
goal: Absorbent 𝕜 (p.ball 0 r)

full_name: Seminorm.absorbent_closedBall_zero
code: /-- Closed seminorm-balls at the origin are absorbent. -/
protected theorem absorbent_closedBall_zero (hr : 0 < r) : Absorbent 𝕜 (closedBall p (0 : E) r) 
goal: Absorbent 𝕜 (p.closedBall 0 r)

full_name: Seminorm.absorbent_ball
code: /-- Seminorm-balls containing the origin are absorbent. -/
protected theorem absorbent_ball (hpr : p x < r) : Absorbent 𝕜 (ball p x r) 
goal: Absorbent 𝕜 (p.ball x r)

full_name: Seminorm.absorbent_closedBall
code: /-- Seminorm-balls containing the origin are absorbent. -/
protected theorem absorbent_closedBall (hpr : p x < r) : Absorbent 𝕜 (closedBall p x r) 
goal: Absorbent 𝕜 (p.closedBall x r)

full_name: Seminorm.smul_ball_preimage
code: @[simp]
theorem smul_ball_preimage (p : Seminorm 𝕜 E) (y : E) (r : ℝ) (a : 𝕜) (ha : a ≠ 0) :
    (a • ·) ⁻¹' p.ball y r = p.ball (a⁻¹ • y) (r / ‖a‖) 
goal: (fun x => a • x) ⁻¹' p.ball y r = p.ball (a⁻¹ • y) (r / ‖a‖)

full_name: Seminorm.convexOn
code: /-- A seminorm is convex. Also see `convexOn_norm`. -/
protected theorem convexOn : ConvexOn ℝ univ p 
goal: ConvexOn ℝ Set.univ ⇑p

full_name: Seminorm.convex_ball
code: /-- Seminorm-balls are convex. -/
theorem convex_ball : Convex ℝ (ball p x r) 
goal: Convex ℝ (p.ball x r)

full_name: Seminorm.convex_closedBall
code: /-- Closed seminorm-balls are convex. -/
theorem convex_closedBall : Convex ℝ (closedBall p x r) 
goal: Convex ℝ (p.closedBall x r)

full_name: Seminorm.restrictScalars
code: /-- Reinterpret a seminorm over a field `𝕜'` as a seminorm over a smaller field `𝕜`. This will
typically be used with `RCLike 𝕜'` and `𝕜 = ℝ`. -/
protected def restrictScalars (p : Seminorm 𝕜' E) : Seminorm 𝕜 E 
goal: Seminorm 𝕜 E

full_name: Seminorm.coe_restrictScalars
code: @[simp]
theorem coe_restrictScalars (p : Seminorm 𝕜' E) : (p.restrictScalars 𝕜 : E → ℝ) = p 
goal: ⇑(Seminorm.restrictScalars 𝕜 p) = ⇑p

full_name: Seminorm.restrictScalars_ball
code: @[simp]
theorem restrictScalars_ball (p : Seminorm 𝕜' E) : (p.restrictScalars 𝕜).ball = p.ball 
goal: (Seminorm.restrictScalars 𝕜 p).ball = p.ball

full_name: Seminorm.restrictScalars_closedBall
code: @[simp]
theorem restrictScalars_closedBall (p : Seminorm 𝕜' E) :
    (p.restrictScalars 𝕜).closedBall = p.closedBall 
goal: (Seminorm.restrictScalars 𝕜 p).closedBall = p.closedBall

full_name: Seminorm.continuousAt_zero_of_forall'
code: /-- A seminorm is continuous at `0` if `p.closedBall 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.continuousAt_zero'`. -/
theorem continuousAt_zero_of_forall' [TopologicalSpace E] {p : Seminorm 𝕝 E}
    (hp : ∀ r > 0, p.closedBall 0 r ∈ (𝓝 0 : Filter E)) :
    ContinuousAt p 0 
goal: ContinuousAt (⇑p) 0

full_name: Seminorm.continuousAt_zero'
code: theorem continuousAt_zero' [TopologicalSpace E] [ContinuousConstSMul 𝕜 E] {p : Seminorm 𝕜 E}
    {r : ℝ} (hp : p.closedBall 0 r ∈ (𝓝 0 : Filter E)) : ContinuousAt p 0 
goal: ContinuousAt (⇑p) 0

full_name: Seminorm.continuousAt_zero_of_forall
code: /-- A seminorm is continuous at `0` if `p.ball 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.continuousAt_zero'`. -/
theorem continuousAt_zero_of_forall [TopologicalSpace E] {p : Seminorm 𝕝 E}
    (hp : ∀ r > 0, p.ball 0 r ∈ (𝓝 0 : Filter E)) :
    ContinuousAt p 0 
goal: ContinuousAt (⇑p) 0

full_name: Seminorm.continuousAt_zero
code: theorem continuousAt_zero [TopologicalSpace E] [ContinuousConstSMul 𝕜 E] {p : Seminorm 𝕜 E} {r : ℝ}
    (hp : p.ball 0 r ∈ (𝓝 0 : Filter E)) : ContinuousAt p 0 
goal: ContinuousAt (⇑p) 0

full_name: Seminorm.uniformContinuous_of_continuousAt_zero
code: protected theorem uniformContinuous_of_continuousAt_zero [UniformSpace E] [UniformAddGroup E]
    {p : Seminorm 𝕝 E} (hp : ContinuousAt p 0) : UniformContinuous p 
goal: UniformContinuous ⇑p

full_name: Seminorm.continuous_of_continuousAt_zero
code: protected theorem continuous_of_continuousAt_zero [TopologicalSpace E] [TopologicalAddGroup E]
    {p : Seminorm 𝕝 E} (hp : ContinuousAt p 0) : Continuous p 
goal: Continuous ⇑p

full_name: Seminorm.uniformContinuous_of_forall
code: /-- A seminorm is uniformly continuous if `p.ball 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.uniformContinuous`. -/
protected theorem uniformContinuous_of_forall [UniformSpace E] [UniformAddGroup E]
    {p : Seminorm 𝕝 E} (hp : ∀ r > 0, p.ball 0 r ∈ (𝓝 0 : Filter E)) :
    UniformContinuous p 
goal: UniformContinuous ⇑p

full_name: Seminorm.uniformContinuous
code: protected theorem uniformContinuous [UniformSpace E] [UniformAddGroup E] [ContinuousConstSMul 𝕜 E]
    {p : Seminorm 𝕜 E} {r : ℝ} (hp : p.ball 0 r ∈ (𝓝 0 : Filter E)) :
    UniformContinuous p 
goal: UniformContinuous ⇑p

full_name: Seminorm.uniformContinuous_of_forall'
code: /-- A seminorm is uniformly continuous if `p.closedBall 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.uniformContinuous'`. -/
protected theorem uniformContinuous_of_forall' [UniformSpace E] [UniformAddGroup E]
    {p : Seminorm 𝕝 E} (hp : ∀ r > 0, p.closedBall 0 r ∈ (𝓝 0 : Filter E)) :
    UniformContinuous p 
goal: UniformContinuous ⇑p

full_name: Seminorm.uniformContinuous'
code: protected theorem uniformContinuous' [UniformSpace E] [UniformAddGroup E] [ContinuousConstSMul 𝕜 E]
    {p : Seminorm 𝕜 E} {r : ℝ} (hp : p.closedBall 0 r ∈ (𝓝 0 : Filter E)) :
    UniformContinuous p 
goal: UniformContinuous ⇑p

full_name: Seminorm.continuous_of_forall
code: /-- A seminorm is continuous if `p.ball 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.continuous`. -/
protected theorem continuous_of_forall [TopologicalSpace E] [TopologicalAddGroup E]
    {p : Seminorm 𝕝 E} (hp : ∀ r > 0, p.ball 0 r ∈ (𝓝 0 : Filter E)) :
    Continuous p 
goal: Continuous ⇑p

full_name: Seminorm.continuous
code: protected theorem continuous [TopologicalSpace E] [TopologicalAddGroup E] [ContinuousConstSMul 𝕜 E]
    {p : Seminorm 𝕜 E} {r : ℝ} (hp : p.ball 0 r ∈ (𝓝 0 : Filter E)) : Continuous p 
goal: Continuous ⇑p

full_name: Seminorm.continuous_of_forall'
code: /-- A seminorm is continuous if `p.closedBall 0 r ∈ 𝓝 0` for *all* `r > 0`.
Over a `NontriviallyNormedField` it is actually enough to check that this is true
for *some* `r`, see `Seminorm.continuous'`. -/
protected theorem continuous_of_forall' [TopologicalSpace E] [TopologicalAddGroup E]
    {p : Seminorm 𝕝 E} (hp : ∀ r > 0, p.closedBall 0 r ∈ (𝓝 0 : Filter E)) :
    Continuous p 
goal: Continuous ⇑p

full_name: Seminorm.continuous'
code: protected theorem continuous' [TopologicalSpace E] [TopologicalAddGroup E] [ContinuousConstSMul 𝕜 E]
    {p : Seminorm 𝕜 E} {r : ℝ} (hp : p.closedBall 0 r ∈ (𝓝 0 : Filter E)) :
    Continuous p 
goal: Continuous ⇑p

full_name: Seminorm.continuous_of_le
code: theorem continuous_of_le [TopologicalSpace E] [TopologicalAddGroup E]
    {p q : Seminorm 𝕝 E} (hq : Continuous q) (hpq : p ≤ q) : Continuous p 
goal: Continuous ⇑p

full_name: Seminorm.ball_mem_nhds
code: lemma ball_mem_nhds [TopologicalSpace E] {p : Seminorm 𝕝 E} (hp : Continuous p) {r : ℝ}
    (hr : 0 < r) : p.ball 0 r ∈ (𝓝 0 : Filter E) 
goal: p.ball 0 r ∈ 𝓝 0

full_name: Seminorm.uniformSpace_eq_of_hasBasis
code: lemma uniformSpace_eq_of_hasBasis
    {ι} [UniformSpace E] [UniformAddGroup E] [ContinuousConstSMul 𝕜 E]
    {p' : ι → Prop} {s : ι → Set E} (p : Seminorm 𝕜 E) (hb : (𝓝 0 : Filter E).HasBasis p' s)
    (h₁ : ∃ r, p.closedBall 0 r ∈ 𝓝 0) (h₂ : ∀ i, p' i → ∃ r > 0, p.ball 0 r ⊆ s i) :
    ‹UniformSpace E› = p.toAddGroupSeminorm.toSeminormedAddGroup.toUniformSpace 
goal: inst✝ = PseudoMetricSpace.toUniformSpace

full_name: Seminorm.uniformity_eq_of_hasBasis
code: lemma uniformity_eq_of_hasBasis
    {ι} [UniformSpace E] [UniformAddGroup E] [ContinuousConstSMul 𝕜 E]
    {p' : ι → Prop} {s : ι → Set E} (p : Seminorm 𝕜 E) (hb : (𝓝 0 : Filter E).HasBasis p' s)
    (h₁ : ∃ r, p.closedBall 0 r ∈ 𝓝 0) (h₂ : ∀ i, p' i → ∃ r > 0, p.ball 0 r ⊆ s i) :
    𝓤 E = ⨅ r > 0, 𝓟 {x | p (x.1 - x.2) < r} 
goal: 𝓤 E = ⨅ r, ⨅ (_ : r > 0), 𝓟 {x | p (x.1 - x.2) < r}

full_name: Seminorm.rescale_to_shell_zpow
code: /-- Let `p` be a seminorm on a vector space over a `NormedField`.
If there is a scalar `c` with `‖c‖>1`, then any `x` such that `p x ≠ 0` can be
moved by scalar multiplication to any `p`-shell of width `‖c‖`. Also recap information on the
value of `p` on the rescaling element that shows up in applications. -/
lemma rescale_to_shell_zpow (p : Seminorm 𝕜 E) {c : 𝕜} (hc : 1 < ‖c‖) {ε : ℝ}
    (εpos : 0 < ε) {x : E} (hx : p x ≠ 0) : ∃ n : ℤ, c^n ≠ 0 ∧
    p (c^n • x) < ε ∧ (ε / ‖c‖ ≤ p (c^n • x)) ∧ (‖c^n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x) 
goal: ∃ n, c ^ n ≠ 0 ∧ p (c ^ n • x) < ε ∧ ε / ‖c‖ ≤ p (c ^ n • x) ∧ ‖c ^ n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x

full_name: Seminorm.rescale_to_shell
code: /-- Let `p` be a seminorm on a vector space over a `NormedField`.
If there is a scalar `c` with `‖c‖>1`, then any `x` such that `p x ≠ 0` can be
moved by scalar multiplication to any `p`-shell of width `‖c‖`. Also recap information on the
value of `p` on the rescaling element that shows up in applications. -/
lemma rescale_to_shell (p : Seminorm 𝕜 E) {c : 𝕜} (hc : 1 < ‖c‖) {ε : ℝ} (εpos : 0 < ε) {x : E}
    (hx : p x ≠ 0) :
    ∃d : 𝕜, d ≠ 0 ∧ p (d • x) < ε ∧ (ε/‖c‖ ≤ p (d • x)) ∧ (‖d‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x) 
goal: ∃ d, d ≠ 0 ∧ p (d • x) < ε ∧ ε / ‖c‖ ≤ p (d • x) ∧ ‖d‖⁻¹ ≤ ε⁻¹ * ‖c‖ * p x

full_name: Seminorm.bound_of_shell
code: /-- Let `p` and `q` be two seminorms on a vector space over a `NontriviallyNormedField`.
If we have `q x ≤ C * p x` on some shell of the form `{x | ε/‖c‖ ≤ p x < ε}` (where `ε > 0`
and `‖c‖ > 1`), then we also have `q x ≤ C * p x` for all `x` such that `p x ≠ 0`. -/
lemma bound_of_shell
    (p q : Seminorm 𝕜 E) {ε C : ℝ} (ε_pos : 0 < ε) {c : 𝕜} (hc : 1 < ‖c‖)
    (hf : ∀ x, ε / ‖c‖ ≤ p x → p x < ε → q x ≤ C * p x) {x : E} (hx : p x ≠ 0) :
    q x ≤ C * p x 
goal: q x ≤ C * p x

full_name: Seminorm.bound_of_shell_smul
code: /-- A version of `Seminorm.bound_of_shell` expressed using pointwise scalar multiplication of
seminorms. -/
lemma bound_of_shell_smul
    (p q : Seminorm 𝕜 E) {ε : ℝ} {C : ℝ≥0} (ε_pos : 0 < ε) {c : 𝕜} (hc : 1 < ‖c‖)
    (hf : ∀ x, ε / ‖c‖ ≤ p x → p x < ε → q x ≤ (C • p) x) {x : E} (hx : p x ≠ 0) :
    q x ≤ (C • p) x 
goal: q x ≤ (C • p) x

full_name: Seminorm.bound_of_shell_sup
code: lemma bound_of_shell_sup (p : ι → Seminorm 𝕜 E) (s : Finset ι)
    (q : Seminorm 𝕜 E) {ε : ℝ} {C : ℝ≥0} (ε_pos : 0 < ε) {c : 𝕜} (hc : 1 < ‖c‖)
    (hf : ∀ x, (∀ i ∈ s, p i x < ε) → ∀ j ∈ s, ε / ‖c‖ ≤ p j x → q x ≤ (C • p j) x)
    {x : E} (hx : ∃ j, j ∈ s ∧ p j x ≠ 0) :
    q x ≤ (C • s.sup p) x 
goal: q x ≤ (C • s.sup p) x

full_name: Seminorm.bddAbove_of_absorbent
code: /-- Let `p i` be a family of seminorms on `E`. Let `s` be an absorbent set in `𝕜`.
If all seminorms are uniformly bounded at every point of `s`,
then they are bounded in the space of seminorms. -/
lemma bddAbove_of_absorbent {ι : Sort*} {p : ι → Seminorm 𝕜 E} {s : Set E} (hs : Absorbent 𝕜 s)
    (h : ∀ x ∈ s, BddAbove (range (p · x))) : BddAbove (range p) 
goal: BddAbove (Set.range p)

full_name: normSeminorm
code: /-- The norm of a seminormed group as a seminorm. -/
def normSeminorm : Seminorm 𝕜 E 
goal: Seminorm 𝕜 E

full_name: coe_normSeminorm
code: @[simp]
theorem coe_normSeminorm : ⇑(normSeminorm 𝕜 E) = norm 
goal: ⇑(normSeminorm 𝕜 E) = norm

full_name: ball_normSeminorm
code: @[simp]
theorem ball_normSeminorm : (normSeminorm 𝕜 E).ball = Metric.ball 
goal: (normSeminorm 𝕜 E).ball = Metric.ball

full_name: absorbent_ball_zero
code: /-- Balls at the origin are absorbent. -/
theorem absorbent_ball_zero (hr : 0 < r) : Absorbent 𝕜 (Metric.ball (0 : E) r) 
goal: Absorbent 𝕜 (Metric.ball 0 r)

full_name: absorbent_ball
code: /-- Balls containing the origin are absorbent. -/
theorem absorbent_ball (hx : ‖x‖ < r) : Absorbent 𝕜 (Metric.ball x r) 
goal: Absorbent 𝕜 (Metric.ball x r)

full_name: balanced_ball_zero
code: /-- Balls at the origin are balanced. -/
theorem balanced_ball_zero : Balanced 𝕜 (Metric.ball (0 : E) r) 
goal: Balanced 𝕜 (Metric.ball 0 r)

full_name: rescale_to_shell_semi_normed_zpow
code: /-- If there is a scalar `c` with `‖c‖>1`, then any element with nonzero norm can be
moved by scalar multiplication to any shell of width `‖c‖`. Also recap information on the norm of
the rescaling element that shows up in applications. -/
lemma rescale_to_shell_semi_normed_zpow {c : 𝕜} (hc : 1 < ‖c‖) {ε : ℝ} (εpos : 0 < ε) {x : E}
    (hx : ‖x‖ ≠ 0) :
    ∃ n : ℤ, c^n ≠ 0 ∧ ‖c^n • x‖ < ε ∧ (ε / ‖c‖ ≤ ‖c^n • x‖) ∧ (‖c^n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖) 
goal: ∃ n, c ^ n ≠ 0 ∧ ‖c ^ n • x‖ < ε ∧ ε / ‖c‖ ≤ ‖c ^ n • x‖ ∧ ‖c ^ n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖

full_name: rescale_to_shell_semi_normed
code: /-- If there is a scalar `c` with `‖c‖>1`, then any element with nonzero norm can be
moved by scalar multiplication to any shell of width `‖c‖`. Also recap information on the norm of
the rescaling element that shows up in applications. -/
lemma rescale_to_shell_semi_normed {c : 𝕜} (hc : 1 < ‖c‖) {ε : ℝ} (εpos : 0 < ε)
    {x : E} (hx : ‖x‖ ≠ 0) :
    ∃d : 𝕜, d ≠ 0 ∧ ‖d • x‖ < ε ∧ (ε/‖c‖ ≤ ‖d • x‖) ∧ (‖d‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖) 
goal: ∃ d, d ≠ 0 ∧ ‖d • x‖ < ε ∧ ε / ‖c‖ ≤ ‖d • x‖ ∧ ‖d‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖

full_name: rescale_to_shell_zpow
code: lemma rescale_to_shell_zpow [NormedAddCommGroup F] [NormedSpace 𝕜 F] {c : 𝕜} (hc : 1 < ‖c‖)
    {ε : ℝ} (εpos : 0 < ε) {x : F} (hx : x ≠ 0) :
    ∃ n : ℤ, c^n ≠ 0 ∧ ‖c^n • x‖ < ε ∧ (ε / ‖c‖ ≤ ‖c^n • x‖) ∧ (‖c^n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖) 
goal: ∃ n, c ^ n ≠ 0 ∧ ‖c ^ n • x‖ < ε ∧ ε / ‖c‖ ≤ ‖c ^ n • x‖ ∧ ‖c ^ n‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖

full_name: rescale_to_shell
code: /-- If there is a scalar `c` with `‖c‖>1`, then any element can be moved by scalar multiplication to
any shell of width `‖c‖`. Also recap information on the norm of the rescaling element that shows
up in applications. -/
lemma rescale_to_shell [NormedAddCommGroup F] [NormedSpace 𝕜 F] {c : 𝕜} (hc : 1 < ‖c‖)
    {ε : ℝ} (εpos : 0 < ε) {x : F} (hx : x ≠ 0) :
    ∃d : 𝕜, d ≠ 0 ∧ ‖d • x‖ < ε ∧ (ε/‖c‖ ≤ ‖d • x‖) ∧ (‖d‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖) 
goal: ∃ d, d ≠ 0 ∧ ‖d • x‖ < ε ∧ ε / ‖c‖ ≤ ‖d • x‖ ∧ ‖d‖⁻¹ ≤ ε⁻¹ * ‖c‖ * ‖x‖