File: Mathlib/Analysis/Normed/Ring/Seminorm.lean

full_name: RingSeminorm.mul_le'
code: /-- A seminorm on a ring `R` is a function `f : R → ℝ` that preserves zero, takes nonnegative
  values, is subadditive and submultiplicative and such that `f (-x) = f x` for all `x ∈ R`. -/
structure RingSeminorm (R : Type*) [NonUnitalNonAssocRing R] extends AddGroupSeminorm R where
  /-- The property of a `RingSeminorm` that for all `x` and `y` in the ring, the norm of `x * y` is
    less than the norm of `x` times the norm of `y`. -/
  mul_le' : ∀ x y : R, toFun (x * y) ≤ toFun x * toFun y
goal: self.toFun (x * y) ≤ self.toFun x * self.toFun y

full_name: RingSeminorm
code: /-- A seminorm on a ring `R` is a function `f : R → ℝ` that preserves zero, takes nonnegative
  values, is subadditive and submultiplicative and such that `f (-x) = f x` for all `x ∈ R`. -/
structure RingSeminorm (R : Type*) [NonUnitalNonAssocRing R] extends AddGroupSeminorm R where
  /-- The property of a `RingSeminorm` that for all `x` and `y` in the ring, the norm of `x * y` is
    less than the norm of `x` times the norm of `y`. -/
  mul_le' : ∀ x y : R, toFun (x * y) ≤ toFun x * toFun y
goal: Type u_4

full_name: RingNorm
code: /-- A function `f : R → ℝ` is a norm on a (nonunital) ring if it is a seminorm and `f x = 0`
  implies `x = 0`. -/
structure RingNorm (R : Type*) [NonUnitalNonAssocRing R] extends RingSeminorm R, AddGroupNorm R
goal: Type u_4

full_name: MulRingSeminorm
code: /-- A multiplicative seminorm on a ring `R` is a function `f : R → ℝ` that preserves zero and
multiplication, takes nonnegative values, is subadditive and such that `f (-x) = f x` for all `x`.
-/
structure MulRingSeminorm (R : Type*) [NonAssocRing R] extends AddGroupSeminorm R,
  MonoidWithZeroHom R ℝ
goal: Type u_4

full_name: MulRingNorm
code: /-- A multiplicative norm on a ring `R` is a multiplicative ring seminorm such that `f x = 0`
implies `x = 0`. -/
structure MulRingNorm (R : Type*) [NonAssocRing R] extends MulRingSeminorm R, AddGroupNorm R
goal: Type u_4

full_name: RingSeminorm.funLike
code: instance funLike : FunLike (RingSeminorm R) R ℝ 
goal: FunLike (RingSeminorm R) R ℝ

full_name: RingSeminorm.ringSeminormClass
code: instance ringSeminormClass : RingSeminormClass (RingSeminorm R) R ℝ 
goal: RingSeminormClass (RingSeminorm R) R ℝ

full_name: RingSeminorm.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe (p : RingSeminorm R) : (p.toAddGroupSeminorm : R → ℝ) = p 
goal: ⇑p.toAddGroupSeminorm = ⇑p

full_name: RingSeminorm.ext
code: @[ext]
theorem ext {p q : RingSeminorm R} : (∀ x, p x = q x) → p = q 
goal: (∀ (x : R), p x = q x) → p = q

full_name: RingSeminorm.instZero
code: instance : Zero (RingSeminorm R) 
goal: Zero (RingSeminorm R)

full_name: RingSeminorm.eq_zero_iff
code: theorem eq_zero_iff {p : RingSeminorm R} : p = 0 ↔ ∀ x, p x = 0 
goal: p = 0 ↔ ∀ (x : R), p x = 0

full_name: RingSeminorm.ne_zero_iff
code: theorem ne_zero_iff {p : RingSeminorm R} : p ≠ 0 ↔ ∃ x, p x ≠ 0 
goal: p ≠ 0 ↔ ∃ x, p x ≠ 0

full_name: RingSeminorm.instInhabited
code: instance : Inhabited (RingSeminorm R) 
goal: Inhabited (RingSeminorm R)

full_name: RingSeminorm.instOneOfDecidableEq
code: /-- The trivial seminorm on a ring `R` is the `RingSeminorm` taking value `0` at `0` and `1` at
every other element. -/
instance [DecidableEq R] : One (RingSeminorm R) 
goal: One (RingSeminorm R)

full_name: RingSeminorm.apply_one
code: @[simp]
theorem apply_one [DecidableEq R] (x : R) : (1 : RingSeminorm R) x = if x = 0 then 0 else 1 
goal: 1 x = if x = 0 then 0 else 1

full_name: RingSeminorm.seminorm_one_eq_one_iff_ne_zero
code: theorem seminorm_one_eq_one_iff_ne_zero (hp : p 1 ≤ 1) : p 1 = 1 ↔ p ≠ 0 
goal: p 1 = 1 ↔ p ≠ 0

full_name: normRingSeminorm
code: /-- The norm of a `NonUnitalSeminormedRing` as a `RingSeminorm`. -/
def normRingSeminorm (R : Type*) [NonUnitalSeminormedRing R] : RingSeminorm R 
goal: RingSeminorm R

full_name: RingNorm.funLike
code: instance funLike : FunLike (RingNorm R) R ℝ 
goal: FunLike (RingNorm R) R ℝ

full_name: RingNorm.ringNormClass
code: instance ringNormClass : RingNormClass (RingNorm R) R ℝ 
goal: RingNormClass (RingNorm R) R ℝ

full_name: RingNorm.toFun_eq_coe
code: theorem toFun_eq_coe (p : RingNorm R) : p.toFun = p 
goal: p.toFun = ⇑p

full_name: RingNorm.ext
code: @[ext]
theorem ext {p q : RingNorm R} : (∀ x, p x = q x) → p = q 
goal: (∀ (x : R), p x = q x) → p = q

full_name: RingNorm.instOneOfDecidableEq
code: /-- The trivial norm on a ring `R` is the `RingNorm` taking value `0` at `0` and `1` at every
  other element. -/
instance [DecidableEq R] : One (RingNorm R) 
goal: One (RingNorm R)

full_name: RingNorm.apply_one
code: @[simp]
theorem apply_one [DecidableEq R] (x : R) : (1 : RingNorm R) x = if x = 0 then 0 else 1 
goal: 1 x = if x = 0 then 0 else 1

full_name: RingNorm.instInhabitedOfDecidableEq
code: instance [DecidableEq R] : Inhabited (RingNorm R) 
goal: Inhabited (RingNorm R)

full_name: MulRingSeminorm.funLike
code: instance funLike : FunLike (MulRingSeminorm R) R ℝ 
goal: FunLike (MulRingSeminorm R) R ℝ

full_name: MulRingSeminorm.mulRingSeminormClass
code: instance mulRingSeminormClass : MulRingSeminormClass (MulRingSeminorm R) R ℝ 
goal: MulRingSeminormClass (MulRingSeminorm R) R ℝ

full_name: MulRingSeminorm.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe (p : MulRingSeminorm R) : (p.toAddGroupSeminorm : R → ℝ) = p 
goal: ⇑p.toAddGroupSeminorm = ⇑p

full_name: MulRingSeminorm.ext
code: @[ext]
theorem ext {p q : MulRingSeminorm R} : (∀ x, p x = q x) → p = q 
goal: (∀ (x : R), p x = q x) → p = q

full_name: MulRingSeminorm.instOne
code: /-- The trivial seminorm on a ring `R` is the `MulRingSeminorm` taking value `0` at `0` and `1` at
every other element. -/
instance : One (MulRingSeminorm R) 
goal: One (MulRingSeminorm R)

full_name: MulRingSeminorm.apply_one
code: @[simp]
theorem apply_one (x : R) : (1 : MulRingSeminorm R) x = if x = 0 then 0 else 1 
goal: 1 x = if x = 0 then 0 else 1

full_name: MulRingSeminorm.instInhabited
code: instance : Inhabited (MulRingSeminorm R) 
goal: Inhabited (MulRingSeminorm R)

full_name: MulRingNorm.funLike
code: instance funLike : FunLike (MulRingNorm R) R ℝ 
goal: FunLike (MulRingNorm R) R ℝ

full_name: MulRingNorm.mulRingNormClass
code: instance mulRingNormClass : MulRingNormClass (MulRingNorm R) R ℝ 
goal: MulRingNormClass (MulRingNorm R) R ℝ

full_name: MulRingNorm.toFun_eq_coe
code: theorem toFun_eq_coe (p : MulRingNorm R) : p.toFun = p 
goal: p.toFun = ⇑p

full_name: MulRingNorm.ext
code: @[ext]
theorem ext {p q : MulRingNorm R} : (∀ x, p x = q x) → p = q 
goal: (∀ (x : R), p x = q x) → p = q

full_name: MulRingNorm.instOne
code: /-- The trivial norm on a ring `R` is the `MulRingNorm` taking value `0` at `0` and `1` at every
other element. -/
instance : One (MulRingNorm R) 
goal: One (MulRingNorm R)

full_name: MulRingNorm.apply_one
code: @[simp]
theorem apply_one (x : R) : (1 : MulRingNorm R) x = if x = 0 then 0 else 1 
goal: 1 x = if x = 0 then 0 else 1

full_name: MulRingNorm.instInhabited
code: instance : Inhabited (MulRingNorm R) 
goal: Inhabited (MulRingNorm R)

full_name: MulRingNorm.equiv
code: /-- Two multiplicative ring norms `f, g` on `R` are equivalent if there exists a positive constant
  `c` such that for all `x ∈ R`, `(f x)^c = g x`.  -/

def equiv (f : MulRingNorm R) (g : MulRingNorm R) 
goal: Prop

full_name: MulRingNorm.equiv_refl
code: /-- Equivalence of multiplicative ring norms is reflexive. -/
lemma equiv_refl (f : MulRingNorm R) : equiv f f 
goal: f.equiv f

full_name: MulRingNorm.equiv_symm
code: /-- Equivalence of multiplicative ring norms is symmetric. -/
lemma equiv_symm {f g : MulRingNorm R} (hfg : equiv f g) : equiv g f 
goal: g.equiv f

full_name: MulRingNorm.equiv_trans
code: /-- Equivalence of multiplicative ring norms is transitive. -/
lemma equiv_trans {f g k : MulRingNorm R} (hfg : equiv f g) (hgk : equiv g k) :
    equiv f k 
goal: f.equiv k

full_name: RingSeminorm.toRingNorm
code: /-- A nonzero ring seminorm on a field `K` is a ring norm. -/
def RingSeminorm.toRingNorm {K : Type*} [Field K] (f : RingSeminorm K) (hnt : f ≠ 0) :
    RingNorm K 
goal: RingNorm K

full_name: normRingNorm
code: /-- The norm of a `NonUnitalNormedRing` as a `RingNorm`. -/
@[simps!]
def normRingNorm (R : Type*) [NonUnitalNormedRing R] : RingNorm R 
goal: RingNorm R

full_name: normRingNorm_toFun
code: /-- The norm of a `NonUnitalNormedRing` as a `RingNorm`. -/
@[simps!]
def normRingNorm (R : Type*) [NonUnitalNormedRing R] : RingNorm R 
goal: ∀ (a : R), (normRingNorm R).toFun a = ‖a‖

full_name: MulRingNorm_nat_le_nat
code: /-- A multiplicative ring norm satisfies `f n ≤ n` for every `n : ℕ`. -/
lemma MulRingNorm_nat_le_nat {R : Type*} [Ring R] (n : ℕ) (f : MulRingNorm R) : f n ≤ n 
goal: f ↑n ≤ ↑n

full_name: MulRingNorm.apply_natAbs_eq
code: /-- A multiplicative norm composed with the absolute value on integers equals the norm itself. -/
lemma MulRingNorm.apply_natAbs_eq {R : Type*} [Ring R] (x : ℤ) (f : MulRingNorm R) : f (natAbs x) =
    f x 
goal: f ↑x.natAbs = f ↑x