File: Mathlib/Analysis/NormedSpace/ENorm.lean

full_name: ENorm.toFun
code: /-- Extended norm on a vector space. As in the case of normed spaces, we require only
`‖c • x‖ ≤ ‖c‖ * ‖x‖` in the definition, then prove an equality in `map_smul`. -/
structure ENorm (𝕜 : Type*) (V : Type*) [NormedField 𝕜] [AddCommGroup V] [Module 𝕜 V] where
  toFun : V → ℝ≥0∞
  eq_zero' : ∀ x, toFun x = 0 → x = 0
  map_add_le' : ∀ x y : V, toFun (x + y) ≤ toFun x + toFun y
  map_smul_le' : ∀ (c : 𝕜) (x : V), toFun (c • x) ≤ ‖c‖₊ * toFun x
goal: V → ℝ≥0∞

full_name: ENorm.eq_zero'
code: /-- Extended norm on a vector space. As in the case of normed spaces, we require only
`‖c • x‖ ≤ ‖c‖ * ‖x‖` in the definition, then prove an equality in `map_smul`. -/
structure ENorm (𝕜 : Type*) (V : Type*) [NormedField 𝕜] [AddCommGroup V] [Module 𝕜 V] where
  toFun : V → ℝ≥0∞
  eq_zero' : ∀ x, toFun x = 0 → x = 0
  map_add_le' : ∀ x y : V, toFun (x + y) ≤ toFun x + toFun y
  map_smul_le' : ∀ (c : 𝕜) (x : V), toFun (c • x) ≤ ‖c‖₊ * toFun x
goal: ↑self x = 0 → x = 0

full_name: ENorm
code: /-- Extended norm on a vector space. As in the case of normed spaces, we require only
`‖c • x‖ ≤ ‖c‖ * ‖x‖` in the definition, then prove an equality in `map_smul`. -/
structure ENorm (𝕜 : Type*) (V : Type*) [NormedField 𝕜] [AddCommGroup V] [Module 𝕜 V] where
  toFun : V → ℝ≥0∞
  eq_zero' : ∀ x, toFun x = 0 → x = 0
  map_add_le' : ∀ x y : V, toFun (x + y) ≤ toFun x + toFun y
  map_smul_le' : ∀ (c : 𝕜) (x : V), toFun (c • x) ≤ ‖c‖₊ * toFun x
goal: Type u_2

full_name: ENorm.map_smul_le'
code: /-- Extended norm on a vector space. As in the case of normed spaces, we require only
`‖c • x‖ ≤ ‖c‖ * ‖x‖` in the definition, then prove an equality in `map_smul`. -/
structure ENorm (𝕜 : Type*) (V : Type*) [NormedField 𝕜] [AddCommGroup V] [Module 𝕜 V] where
  toFun : V → ℝ≥0∞
  eq_zero' : ∀ x, toFun x = 0 → x = 0
  map_add_le' : ∀ x y : V, toFun (x + y) ≤ toFun x + toFun y
  map_smul_le' : ∀ (c : 𝕜) (x : V), toFun (c • x) ≤ ‖c‖₊ * toFun x
goal: ↑self (c • x) ≤ ↑‖c‖₊ * ↑self x

full_name: ENorm.map_add_le'
code: /-- Extended norm on a vector space. As in the case of normed spaces, we require only
`‖c • x‖ ≤ ‖c‖ * ‖x‖` in the definition, then prove an equality in `map_smul`. -/
structure ENorm (𝕜 : Type*) (V : Type*) [NormedField 𝕜] [AddCommGroup V] [Module 𝕜 V] where
  toFun : V → ℝ≥0∞
  eq_zero' : ∀ x, toFun x = 0 → x = 0
  map_add_le' : ∀ x y : V, toFun (x + y) ≤ toFun x + toFun y
  map_smul_le' : ∀ (c : 𝕜) (x : V), toFun (c • x) ≤ ‖c‖₊ * toFun x
goal: ↑self (x + y) ≤ ↑self x + ↑self y

full_name: ENorm.instCoeFunForallENNReal
code: instance : CoeFun (ENorm 𝕜 V) fun _ => V → ℝ≥0∞ 
goal: CoeFun (ENorm 𝕜 V) fun x => V → ℝ≥0∞

full_name: ENorm.coeFn_injective
code: theorem coeFn_injective : Function.Injective ((↑) : ENorm 𝕜 V → V → ℝ≥0∞) 
goal: Function.Injective ENorm.toFun

full_name: ENorm.ext
code: @[ext]
theorem ext {e₁ e₂ : ENorm 𝕜 V} (h : ∀ x, e₁ x = e₂ x) : e₁ = e₂ 
goal: e₁ = e₂

full_name: ENorm.ext_iff
code: theorem ext_iff {e₁ e₂ : ENorm 𝕜 V} : e₁ = e₂ ↔ ∀ x, e₁ x = e₂ x 
goal: e₁ = e₂ ↔ ∀ (x : V), ↑e₁ x = ↑e₂ x

full_name: ENorm.coe_inj
code: @[simp, norm_cast]
theorem coe_inj {e₁ e₂ : ENorm 𝕜 V} : (e₁ : V → ℝ≥0∞) = e₂ ↔ e₁ = e₂ 
goal: ↑e₁ = ↑e₂ ↔ e₁ = e₂

full_name: ENorm.map_smul
code: @[simp]
theorem map_smul (c : 𝕜) (x : V) : e (c • x) = ‖c‖₊ * e x 
goal: ↑e (c • x) = ↑‖c‖₊ * ↑e x

full_name: ENorm.map_zero
code: @[simp]
theorem map_zero : e 0 = 0 
goal: ↑e 0 = 0

full_name: ENorm.eq_zero_iff
code: @[simp]
theorem eq_zero_iff {x : V} : e x = 0 ↔ x = 0 
goal: ↑e x = 0 ↔ x = 0

full_name: ENorm.map_neg
code: @[simp]
theorem map_neg (x : V) : e (-x) = e x 
goal: ↑e (-x) = ↑e x

full_name: ENorm.map_sub_rev
code: theorem map_sub_rev (x y : V) : e (x - y) = e (y - x) 
goal: ↑e (x - y) = ↑e (y - x)

full_name: ENorm.map_add_le
code: theorem map_add_le (x y : V) : e (x + y) ≤ e x + e y 
goal: ↑e (x + y) ≤ ↑e x + ↑e y

full_name: ENorm.map_sub_le
code: theorem map_sub_le (x y : V) : e (x - y) ≤ e x + e y 
goal: ↑e (x - y) ≤ ↑e x + ↑e y

full_name: ENorm.partialOrder
code: instance partialOrder : PartialOrder (ENorm 𝕜 V) 
goal: PartialOrder (ENorm 𝕜 V)

full_name: ENorm.instTop
code: /-- The `ENorm` sending each non-zero vector to infinity. -/
noncomputable instance : Top (ENorm 𝕜 V) 
goal: Top (ENorm 𝕜 V)

full_name: ENorm.instInhabited
code: noncomputable instance : Inhabited (ENorm 𝕜 V) 
goal: Inhabited (ENorm 𝕜 V)

full_name: ENorm.top_map
code: theorem top_map {x : V} (hx : x ≠ 0) : (⊤ : ENorm 𝕜 V) x = ⊤ 
goal: ↑⊤ x = ⊤

full_name: ENorm.instOrderTop
code: noncomputable instance : OrderTop (ENorm 𝕜 V) 
goal: OrderTop (ENorm 𝕜 V)

full_name: ENorm.instSemilatticeSup
code: noncomputable instance : SemilatticeSup (ENorm 𝕜 V) 
goal: SemilatticeSup (ENorm 𝕜 V)

full_name: ENorm.coe_max
code: @[simp, norm_cast]
theorem coe_max (e₁ e₂ : ENorm 𝕜 V) : ⇑(e₁ ⊔ e₂) = fun x => max (e₁ x) (e₂ x) 
goal: ↑(e₁ ⊔ e₂) = fun x => max (↑e₁ x) (↑e₂ x)

full_name: ENorm.max_map
code: @[norm_cast]
theorem max_map (e₁ e₂ : ENorm 𝕜 V) (x : V) : (e₁ ⊔ e₂) x = max (e₁ x) (e₂ x) 
goal: ↑(e₁ ⊔ e₂) x = max (↑e₁ x) (↑e₂ x)

full_name: ENorm.emetricSpace
code: /-- Structure of an `EMetricSpace` defined by an extended norm. -/
abbrev emetricSpace : EMetricSpace V 
goal: EMetricSpace V

full_name: ENorm.finiteSubspace
code: /-- The subspace of vectors with finite enorm. -/
def finiteSubspace : Subspace 𝕜 V 
goal: Subspace 𝕜 V

full_name: ENorm.metricSpace
code: /-- Metric space structure on `e.finiteSubspace`. We use `EMetricSpace.toMetricSpace`
to ensure that this definition agrees with `e.emetricSpace`. -/
instance metricSpace : MetricSpace e.finiteSubspace 
goal: MetricSpace ↥e.finiteSubspace

full_name: ENorm.finite_dist_eq
code: theorem finite_dist_eq (x y : e.finiteSubspace) : dist x y = (e (x - y)).toReal 
goal: dist x y = (↑e (↑x - ↑y)).toReal

full_name: ENorm.finite_edist_eq
code: theorem finite_edist_eq (x y : e.finiteSubspace) : edist x y = e (x - y) 
goal: edist x y = ↑e (↑x - ↑y)

full_name: ENorm.normedAddCommGroup
code: /-- Normed group instance on `e.finiteSubspace`. -/
instance normedAddCommGroup : NormedAddCommGroup e.finiteSubspace 
goal: NormedAddCommGroup ↥e.finiteSubspace

full_name: ENorm.finite_norm_eq
code: theorem finite_norm_eq (x : e.finiteSubspace) : ‖x‖ = (e x).toReal 
goal: ‖x‖ = (↑e ↑x).toReal

full_name: ENorm.normedSpace
code: /-- Normed space instance on `e.finiteSubspace`. -/
instance normedSpace : NormedSpace 𝕜 e.finiteSubspace 
goal: NormedSpace 𝕜 ↥e.finiteSubspace