File: Mathlib/Analysis/Normed/Group/Hom.lean

full_name: NormedAddGroupHom.bound'
code: /-- A morphism of seminormed abelian groups is a bounded group homomorphism. -/
structure NormedAddGroupHom (V W : Type*) [SeminormedAddCommGroup V]
  [SeminormedAddCommGroup W] where
  /-- The function underlying a `NormedAddGroupHom` -/
  toFun : V → W
  /-- A `NormedAddGroupHom` is additive. -/
  map_add' : ∀ v₁ v₂, toFun (v₁ + v₂) = toFun v₁ + toFun v₂
  /-- A `NormedAddGroupHom` is bounded. -/
  bound' : ∃ C, ∀ v, ‖toFun v‖ ≤ C * ‖v‖
goal: ∃ C, ∀ (v : V), ‖self.toFun v‖ ≤ C * ‖v‖

full_name: NormedAddGroupHom.toFun
code: /-- A morphism of seminormed abelian groups is a bounded group homomorphism. -/
structure NormedAddGroupHom (V W : Type*) [SeminormedAddCommGroup V]
  [SeminormedAddCommGroup W] where
  /-- The function underlying a `NormedAddGroupHom` -/
  toFun : V → W
  /-- A `NormedAddGroupHom` is additive. -/
  map_add' : ∀ v₁ v₂, toFun (v₁ + v₂) = toFun v₁ + toFun v₂
  /-- A `NormedAddGroupHom` is bounded. -/
  bound' : ∃ C, ∀ v, ‖toFun v‖ ≤ C * ‖v‖
goal: V → W

full_name: NormedAddGroupHom.map_add'
code: /-- A morphism of seminormed abelian groups is a bounded group homomorphism. -/
structure NormedAddGroupHom (V W : Type*) [SeminormedAddCommGroup V]
  [SeminormedAddCommGroup W] where
  /-- The function underlying a `NormedAddGroupHom` -/
  toFun : V → W
  /-- A `NormedAddGroupHom` is additive. -/
  map_add' : ∀ v₁ v₂, toFun (v₁ + v₂) = toFun v₁ + toFun v₂
  /-- A `NormedAddGroupHom` is bounded. -/
  bound' : ∃ C, ∀ v, ‖toFun v‖ ≤ C * ‖v‖
goal: self.toFun (v₁ + v₂) = self.toFun v₁ + self.toFun v₂

full_name: NormedAddGroupHom
code: /-- A morphism of seminormed abelian groups is a bounded group homomorphism. -/
structure NormedAddGroupHom (V W : Type*) [SeminormedAddCommGroup V]
  [SeminormedAddCommGroup W] where
  /-- The function underlying a `NormedAddGroupHom` -/
  toFun : V → W
  /-- A `NormedAddGroupHom` is additive. -/
  map_add' : ∀ v₁ v₂, toFun (v₁ + v₂) = toFun v₁ + toFun v₂
  /-- A `NormedAddGroupHom` is bounded. -/
  bound' : ∃ C, ∀ v, ‖toFun v‖ ≤ C * ‖v‖
goal: Type (max u_1 u_2)

full_name: AddMonoidHom.mkNormedAddGroupHom
code: /-- Associate to a group homomorphism a bounded group homomorphism under a norm control condition.

See `AddMonoidHom.mkNormedAddGroupHom'` for a version that uses `ℝ≥0` for the bound. -/
def mkNormedAddGroupHom (f : V →+ W) (C : ℝ) (h : ∀ v, ‖f v‖ ≤ C * ‖v‖) : NormedAddGroupHom V W 
goal: NormedAddGroupHom V W

full_name: AddMonoidHom.mkNormedAddGroupHom'
code: /-- Associate to a group homomorphism a bounded group homomorphism under a norm control condition.

See `AddMonoidHom.mkNormedAddGroupHom` for a version that uses `ℝ` for the bound. -/
def mkNormedAddGroupHom' (f : V →+ W) (C : ℝ≥0) (hC : ∀ x, ‖f x‖₊ ≤ C * ‖x‖₊) :
    NormedAddGroupHom V W 
goal: NormedAddGroupHom V W

full_name: exists_pos_bound_of_bound
code: theorem exists_pos_bound_of_bound {V W : Type*} [SeminormedAddCommGroup V]
    [SeminormedAddCommGroup W] {f : V → W} (M : ℝ) (h : ∀ x, ‖f x‖ ≤ M * ‖x‖) :
    ∃ N, 0 < N ∧ ∀ x, ‖f x‖ ≤ N * ‖x‖ 
goal: ∃ N, 0 < N ∧ ∀ (x : V), ‖f x‖ ≤ N * ‖x‖

full_name: NormedAddGroupHom.ofLipschitz
code: /-- A Lipschitz continuous additive homomorphism is a normed additive group homomorphism. -/
def ofLipschitz (f : V₁ →+ V₂) {K : ℝ≥0} (h : LipschitzWith K f) : NormedAddGroupHom V₁ V₂ 
goal: NormedAddGroupHom V₁ V₂

full_name: NormedAddGroupHom.funLike
code: instance funLike : FunLike (NormedAddGroupHom V₁ V₂) V₁ V₂ 
goal: FunLike (NormedAddGroupHom V₁ V₂) V₁ V₂

full_name: NormedAddGroupHom.toAddMonoidHomClass
code: instance toAddMonoidHomClass : AddMonoidHomClass (NormedAddGroupHom V₁ V₂) V₁ V₂ 
goal: AddMonoidHomClass (NormedAddGroupHom V₁ V₂) V₁ V₂

full_name: NormedAddGroupHom.coe_inj
code: theorem coe_inj (H : (f : V₁ → V₂) = g) : f = g 
goal: f = g

full_name: NormedAddGroupHom.coe_injective
code: theorem coe_injective : @Function.Injective (NormedAddGroupHom V₁ V₂) (V₁ → V₂) toFun 
goal: Function.Injective NormedAddGroupHom.toFun

full_name: NormedAddGroupHom.coe_inj_iff
code: theorem coe_inj_iff : f = g ↔ (f : V₁ → V₂) = g 
goal: f = g ↔ ⇑f = ⇑g

full_name: NormedAddGroupHom.ext
code: @[ext]
theorem ext (H : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: NormedAddGroupHom.ext_iff
code: protected theorem ext_iff : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : V₁), f x = g x

full_name: NormedAddGroupHom.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe : f.toFun = f 
goal: f.toFun = ⇑f

full_name: NormedAddGroupHom.coe_mk
code: theorem coe_mk (f) (h₁) (h₂) (h₃) : ⇑(⟨f, h₁, h₂, h₃⟩ : NormedAddGroupHom V₁ V₂) = f 
goal: ⇑{ toFun := f, map_add' := h₁, bound' := ⋯ } = f

full_name: NormedAddGroupHom.coe_mkNormedAddGroupHom
code: @[simp]
theorem coe_mkNormedAddGroupHom (f : V₁ →+ V₂) (C) (hC) : ⇑(f.mkNormedAddGroupHom C hC) = f 
goal: ⇑(f.mkNormedAddGroupHom C hC) = ⇑f

full_name: NormedAddGroupHom.coe_mkNormedAddGroupHom'
code: @[simp]
theorem coe_mkNormedAddGroupHom' (f : V₁ →+ V₂) (C) (hC) : ⇑(f.mkNormedAddGroupHom' C hC) = f 
goal: ⇑(f.mkNormedAddGroupHom' C hC) = ⇑f

full_name: NormedAddGroupHom.toAddMonoidHom
code: /-- The group homomorphism underlying a bounded group homomorphism. -/
def toAddMonoidHom (f : NormedAddGroupHom V₁ V₂) : V₁ →+ V₂ 
goal: V₁ →+ V₂

full_name: NormedAddGroupHom.coe_toAddMonoidHom
code: @[simp]
theorem coe_toAddMonoidHom : ⇑f.toAddMonoidHom = f 
goal: ⇑f.toAddMonoidHom = ⇑f

full_name: NormedAddGroupHom.toAddMonoidHom_injective
code: theorem toAddMonoidHom_injective :
    Function.Injective (@NormedAddGroupHom.toAddMonoidHom V₁ V₂ _ _) 
goal: Function.Injective NormedAddGroupHom.toAddMonoidHom

full_name: NormedAddGroupHom.mk_toAddMonoidHom
code: @[simp]
theorem mk_toAddMonoidHom (f) (h₁) (h₂) :
    (⟨f, h₁, h₂⟩ : NormedAddGroupHom V₁ V₂).toAddMonoidHom = AddMonoidHom.mk' f h₁ 
goal: { toFun := f, map_add' := h₁, bound' := h₂ }.toAddMonoidHom = AddMonoidHom.mk' f h₁

full_name: NormedAddGroupHom.bound
code: theorem bound : ∃ C, 0 < C ∧ ∀ x, ‖f x‖ ≤ C * ‖x‖ 
goal: ∃ C, 0 < C ∧ ∀ (x : V₁), ‖f x‖ ≤ C * ‖x‖

full_name: NormedAddGroupHom.antilipschitz_of_norm_ge
code: theorem antilipschitz_of_norm_ge {K : ℝ≥0} (h : ∀ x, ‖x‖ ≤ K * ‖f x‖) : AntilipschitzWith K f 
goal: AntilipschitzWith K ⇑f

full_name: NormedAddGroupHom.SurjectiveOnWith
code: /-- A normed group hom is surjective on the subgroup `K` with constant `C` if every element
`x` of `K` has a preimage whose norm is bounded above by `C*‖x‖`. This is a more
abstract version of `f` having a right inverse defined on `K` with operator norm
at most `C`. -/
def SurjectiveOnWith (f : NormedAddGroupHom V₁ V₂) (K : AddSubgroup V₂) (C : ℝ) : Prop 
goal: Prop

full_name: NormedAddGroupHom.SurjectiveOnWith.mono
code: theorem SurjectiveOnWith.mono {f : NormedAddGroupHom V₁ V₂} {K : AddSubgroup V₂} {C C' : ℝ}
    (h : f.SurjectiveOnWith K C) (H : C ≤ C') : f.SurjectiveOnWith K C' 
goal: f.SurjectiveOnWith K C'

full_name: NormedAddGroupHom.SurjectiveOnWith.exists_pos
code: theorem SurjectiveOnWith.exists_pos {f : NormedAddGroupHom V₁ V₂} {K : AddSubgroup V₂} {C : ℝ}
    (h : f.SurjectiveOnWith K C) : ∃ C' > 0, f.SurjectiveOnWith K C' 
goal: ∃ C' > 0, f.SurjectiveOnWith K C'

full_name: NormedAddGroupHom.SurjectiveOnWith.surjOn
code: theorem SurjectiveOnWith.surjOn {f : NormedAddGroupHom V₁ V₂} {K : AddSubgroup V₂} {C : ℝ}
    (h : f.SurjectiveOnWith K C) : Set.SurjOn f Set.univ K 
goal: Set.SurjOn (⇑f) Set.univ ↑K

full_name: NormedAddGroupHom.opNorm
code: /-- The operator norm of a seminormed group homomorphism is the inf of all its bounds. -/
def opNorm (f : NormedAddGroupHom V₁ V₂) 
goal: ℝ

full_name: NormedAddGroupHom.hasOpNorm
code: instance hasOpNorm : Norm (NormedAddGroupHom V₁ V₂) 
goal: Norm (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.norm_def
code: theorem norm_def : ‖f‖ = sInf { c | 0 ≤ c ∧ ∀ x, ‖f x‖ ≤ c * ‖x‖ } 
goal: ‖f‖ = sInf {c | 0 ≤ c ∧ ∀ (x : V₁), ‖f x‖ ≤ c * ‖x‖}

full_name: NormedAddGroupHom.bounds_nonempty
code: theorem bounds_nonempty {f : NormedAddGroupHom V₁ V₂} :
    ∃ c, c ∈ { c | 0 ≤ c ∧ ∀ x, ‖f x‖ ≤ c * ‖x‖ } 
goal: ∃ c, c ∈ {c | 0 ≤ c ∧ ∀ (x : V₁), ‖f x‖ ≤ c * ‖x‖}

full_name: NormedAddGroupHom.bounds_bddBelow
code: theorem bounds_bddBelow {f : NormedAddGroupHom V₁ V₂} :
    BddBelow { c | 0 ≤ c ∧ ∀ x, ‖f x‖ ≤ c * ‖x‖ } 
goal: BddBelow {c | 0 ≤ c ∧ ∀ (x : V₁), ‖f x‖ ≤ c * ‖x‖}

full_name: NormedAddGroupHom.opNorm_nonneg
code: theorem opNorm_nonneg : 0 ≤ ‖f‖ 
goal: 0 ≤ ‖f‖

full_name: NormedAddGroupHom.le_opNorm
code: /-- The fundamental property of the operator norm: `‖f x‖ ≤ ‖f‖ * ‖x‖`. -/
theorem le_opNorm (x : V₁) : ‖f x‖ ≤ ‖f‖ * ‖x‖ 
goal: ‖f x‖ ≤ ‖f‖ * ‖x‖

full_name: NormedAddGroupHom.le_opNorm_of_le
code: theorem le_opNorm_of_le {c : ℝ} {x} (h : ‖x‖ ≤ c) : ‖f x‖ ≤ ‖f‖ * c 
goal: ‖f x‖ ≤ ‖f‖ * c

full_name: NormedAddGroupHom.le_of_opNorm_le
code: theorem le_of_opNorm_le {c : ℝ} (h : ‖f‖ ≤ c) (x : V₁) : ‖f x‖ ≤ c * ‖x‖ 
goal: ‖f x‖ ≤ c * ‖x‖

full_name: NormedAddGroupHom.lipschitz
code: /-- continuous linear maps are Lipschitz continuous. -/
theorem lipschitz : LipschitzWith ⟨‖f‖, opNorm_nonneg f⟩ f 
goal: LipschitzWith ⟨‖f‖, ⋯⟩ ⇑f

full_name: NormedAddGroupHom.uniformContinuous
code: protected theorem uniformContinuous (f : NormedAddGroupHom V₁ V₂) : UniformContinuous f 
goal: UniformContinuous ⇑f

full_name: NormedAddGroupHom.continuous
code: @[continuity]
protected theorem continuous (f : NormedAddGroupHom V₁ V₂) : Continuous f 
goal: Continuous ⇑f

full_name: NormedAddGroupHom.ratio_le_opNorm
code: theorem ratio_le_opNorm (x : V₁) : ‖f x‖ / ‖x‖ ≤ ‖f‖ 
goal: ‖f x‖ / ‖x‖ ≤ ‖f‖

full_name: NormedAddGroupHom.opNorm_le_bound
code: /-- If one controls the norm of every `f x`, then one controls the norm of `f`. -/
theorem opNorm_le_bound {M : ℝ} (hMp : 0 ≤ M) (hM : ∀ x, ‖f x‖ ≤ M * ‖x‖) : ‖f‖ ≤ M 
goal: ‖f‖ ≤ M

full_name: NormedAddGroupHom.opNorm_eq_of_bounds
code: theorem opNorm_eq_of_bounds {M : ℝ} (M_nonneg : 0 ≤ M) (h_above : ∀ x, ‖f x‖ ≤ M * ‖x‖)
    (h_below : ∀ N ≥ 0, (∀ x, ‖f x‖ ≤ N * ‖x‖) → M ≤ N) : ‖f‖ = M 
goal: ‖f‖ = M

full_name: NormedAddGroupHom.opNorm_le_of_lipschitz
code: theorem opNorm_le_of_lipschitz {f : NormedAddGroupHom V₁ V₂} {K : ℝ≥0} (hf : LipschitzWith K f) :
    ‖f‖ ≤ K 
goal: ‖f‖ ≤ ↑K

full_name: NormedAddGroupHom.mkNormedAddGroupHom_norm_le
code: /-- If a bounded group homomorphism map is constructed from a group homomorphism via the constructor
`AddMonoidHom.mkNormedAddGroupHom`, then its norm is bounded by the bound given to the constructor
if it is nonnegative. -/
theorem mkNormedAddGroupHom_norm_le (f : V₁ →+ V₂) {C : ℝ} (hC : 0 ≤ C) (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) :
    ‖f.mkNormedAddGroupHom C h‖ ≤ C 
goal: ‖f.mkNormedAddGroupHom C h‖ ≤ C

full_name: NormedAddGroupHom.ofLipschitz_norm_le
code: /-- If a bounded group homomorphism map is constructed from a group homomorphism via the constructor
`NormedAddGroupHom.ofLipschitz`, then its norm is bounded by the bound given to the constructor. -/
theorem ofLipschitz_norm_le (f : V₁ →+ V₂) {K : ℝ≥0} (h : LipschitzWith K f) :
    ‖ofLipschitz f h‖ ≤ K 
goal: ‖NormedAddGroupHom.ofLipschitz f h‖ ≤ ↑K

full_name: NormedAddGroupHom.mkNormedAddGroupHom_norm_le'
code: /-- If a bounded group homomorphism map is constructed from a group homomorphism
via the constructor `AddMonoidHom.mkNormedAddGroupHom`, then its norm is bounded by the bound
given to the constructor or zero if this bound is negative. -/
theorem mkNormedAddGroupHom_norm_le' (f : V₁ →+ V₂) {C : ℝ} (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) :
    ‖f.mkNormedAddGroupHom C h‖ ≤ max C 0 
goal: ‖f.mkNormedAddGroupHom C h‖ ≤ max C 0

full_name: NormedAddGroupHom.add
code: /-- Addition of normed group homs. -/
instance add : Add (NormedAddGroupHom V₁ V₂) 
goal: Add (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.opNorm_add_le
code: /-- The operator norm satisfies the triangle inequality. -/
theorem opNorm_add_le : ‖f + g‖ ≤ ‖f‖ + ‖g‖ 
goal: ‖f + g‖ ≤ ‖f‖ + ‖g‖

full_name: NormedAddGroupHom.coe_add
code: @[simp]
theorem coe_add (f g : NormedAddGroupHom V₁ V₂) : ⇑(f + g) = f + g 
goal: ⇑(f + g) = ⇑f + ⇑g

full_name: NormedAddGroupHom.add_apply
code: @[simp]
theorem add_apply (f g : NormedAddGroupHom V₁ V₂) (v : V₁) :
    (f + g) v = f v + g v 
goal: (f + g) v = f v + g v

full_name: NormedAddGroupHom.zero
code: instance zero : Zero (NormedAddGroupHom V₁ V₂) 
goal: Zero (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.inhabited
code: instance inhabited : Inhabited (NormedAddGroupHom V₁ V₂) 
goal: Inhabited (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.opNorm_zero
code: /-- The norm of the `0` operator is `0`. -/
theorem opNorm_zero : ‖(0 : NormedAddGroupHom V₁ V₂)‖ = 0 
goal: ‖0‖ = 0

full_name: NormedAddGroupHom.opNorm_zero_iff
code: /-- For normed groups, an operator is zero iff its norm vanishes. -/
theorem opNorm_zero_iff {V₁ V₂ : Type*} [NormedAddCommGroup V₁] [NormedAddCommGroup V₂]
    {f : NormedAddGroupHom V₁ V₂} : ‖f‖ = 0 ↔ f = 0 
goal: ‖f‖ = 0 ↔ f = 0

full_name: NormedAddGroupHom.coe_zero
code: @[simp]
theorem coe_zero : ⇑(0 : NormedAddGroupHom V₁ V₂) = 0 
goal: ⇑0 = 0

full_name: NormedAddGroupHom.zero_apply
code: @[simp]
theorem zero_apply (v : V₁) : (0 : NormedAddGroupHom V₁ V₂) v = 0 
goal: 0 v = 0

full_name: NormedAddGroupHom.id
code: /-- The identity as a continuous normed group hom. -/
@[simps!]
def id : NormedAddGroupHom V V 
goal: NormedAddGroupHom V V

full_name: NormedAddGroupHom.id_apply
code: /-- The identity as a continuous normed group hom. -/
@[simps!]
def id : NormedAddGroupHom V V 
goal: ∀ (a : V), (NormedAddGroupHom.id V) a = a

full_name: NormedAddGroupHom.norm_id_le
code: /-- The norm of the identity is at most `1`. It is in fact `1`, except when the norm of every
element vanishes, where it is `0`. (Since we are working with seminorms this can happen even if the
space is non-trivial.) It means that one can not do better than an inequality in general. -/
theorem norm_id_le : ‖(id V : NormedAddGroupHom V V)‖ ≤ 1 
goal: ‖NormedAddGroupHom.id V‖ ≤ 1

full_name: NormedAddGroupHom.norm_id_of_nontrivial_seminorm
code: /-- If there is an element with norm different from `0`, then the norm of the identity equals `1`.
(Since we are working with seminorms supposing that the space is non-trivial is not enough.) -/
theorem norm_id_of_nontrivial_seminorm (h : ∃ x : V, ‖x‖ ≠ 0) : ‖id V‖ = 1 
goal: ‖NormedAddGroupHom.id V‖ = 1

full_name: NormedAddGroupHom.norm_id
code: /-- If a normed space is non-trivial, then the norm of the identity equals `1`. -/
theorem norm_id {V : Type*} [NormedAddCommGroup V] [Nontrivial V] : ‖id V‖ = 1 
goal: ‖NormedAddGroupHom.id V‖ = 1

full_name: NormedAddGroupHom.coe_id
code: theorem coe_id : (NormedAddGroupHom.id V : V → V) = _root_.id 
goal: ⇑(NormedAddGroupHom.id V) = id

full_name: NormedAddGroupHom.neg
code: /-- Opposite of a normed group hom. -/
instance neg : Neg (NormedAddGroupHom V₁ V₂) 
goal: Neg (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.coe_neg
code: @[simp]
theorem coe_neg (f : NormedAddGroupHom V₁ V₂) : ⇑(-f) = -f 
goal: ⇑(-f) = -⇑f

full_name: NormedAddGroupHom.neg_apply
code: @[simp]
theorem neg_apply (f : NormedAddGroupHom V₁ V₂) (v : V₁) :
    (-f : NormedAddGroupHom V₁ V₂) v = -f v 
goal: (-f) v = -f v

full_name: NormedAddGroupHom.opNorm_neg
code: theorem opNorm_neg (f : NormedAddGroupHom V₁ V₂) : ‖-f‖ = ‖f‖ 
goal: ‖-f‖ = ‖f‖

full_name: NormedAddGroupHom.sub
code: /-- Subtraction of normed group homs. -/
instance sub : Sub (NormedAddGroupHom V₁ V₂) 
goal: Sub (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.coe_sub
code: @[simp]
theorem coe_sub (f g : NormedAddGroupHom V₁ V₂) : ⇑(f - g) = f - g 
goal: ⇑(f - g) = ⇑f - ⇑g

full_name: NormedAddGroupHom.sub_apply
code: @[simp]
theorem sub_apply (f g : NormedAddGroupHom V₁ V₂) (v : V₁) :
    (f - g : NormedAddGroupHom V₁ V₂) v = f v - g v 
goal: (f - g) v = f v - g v

full_name: NormedAddGroupHom.smul
code: instance smul : SMul R (NormedAddGroupHom V₁ V₂) 
goal: SMul R (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.coe_smul
code: @[simp]
theorem coe_smul (r : R) (f : NormedAddGroupHom V₁ V₂) : ⇑(r • f) = r • ⇑f 
goal: ⇑(r • f) = r • ⇑f

full_name: NormedAddGroupHom.smul_apply
code: @[simp]
theorem smul_apply (r : R) (f : NormedAddGroupHom V₁ V₂) (v : V₁) : (r • f) v = r • f v 
goal: (r • f) v = r • f v

full_name: NormedAddGroupHom.smulCommClass
code: instance smulCommClass [SMulCommClass R R' V₂] :
    SMulCommClass R R' (NormedAddGroupHom V₁ V₂) 
goal: SMulCommClass R R' (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.isScalarTower
code: instance isScalarTower [SMul R R'] [IsScalarTower R R' V₂] :
    IsScalarTower R R' (NormedAddGroupHom V₁ V₂) 
goal: IsScalarTower R R' (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.isCentralScalar
code: instance isCentralScalar [DistribMulAction Rᵐᵒᵖ V₂] [IsCentralScalar R V₂] :
    IsCentralScalar R (NormedAddGroupHom V₁ V₂) 
goal: IsCentralScalar R (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.nsmul
code: instance nsmul : SMul ℕ (NormedAddGroupHom V₁ V₂) 
goal: SMul ℕ (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.coe_nsmul
code: @[simp]
theorem coe_nsmul (r : ℕ) (f : NormedAddGroupHom V₁ V₂) : ⇑(r • f) = r • ⇑f 
goal: ⇑(r • f) = r • ⇑f

full_name: NormedAddGroupHom.nsmul_apply
code: @[simp]
theorem nsmul_apply (r : ℕ) (f : NormedAddGroupHom V₁ V₂) (v : V₁) : (r • f) v = r • f v 
goal: (r • f) v = r • f v

full_name: NormedAddGroupHom.zsmul
code: instance zsmul : SMul ℤ (NormedAddGroupHom V₁ V₂) 
goal: SMul ℤ (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.coe_zsmul
code: @[simp]
theorem coe_zsmul (r : ℤ) (f : NormedAddGroupHom V₁ V₂) : ⇑(r • f) = r • ⇑f 
goal: ⇑(r • f) = r • ⇑f

full_name: NormedAddGroupHom.zsmul_apply
code: @[simp]
theorem zsmul_apply (r : ℤ) (f : NormedAddGroupHom V₁ V₂) (v : V₁) : (r • f) v = r • f v 
goal: (r • f) v = r • f v

full_name: NormedAddGroupHom.toAddCommGroup
code: /-- Homs between two given normed groups form a commutative additive group. -/
instance toAddCommGroup : AddCommGroup (NormedAddGroupHom V₁ V₂) 
goal: AddCommGroup (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.toSeminormedAddCommGroup
code: /-- Normed group homomorphisms themselves form a seminormed group with respect to
    the operator norm. -/
instance toSeminormedAddCommGroup : SeminormedAddCommGroup (NormedAddGroupHom V₁ V₂) 
goal: SeminormedAddCommGroup (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.toNormedAddCommGroup
code: /-- Normed group homomorphisms themselves form a normed group with respect to
    the operator norm. -/
instance toNormedAddCommGroup {V₁ V₂ : Type*} [NormedAddCommGroup V₁] [NormedAddCommGroup V₂] :
    NormedAddCommGroup (NormedAddGroupHom V₁ V₂) 
goal: NormedAddCommGroup (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.coeAddHom
code: /-- Coercion of a `NormedAddGroupHom` is an `AddMonoidHom`. Similar to `AddMonoidHom.coeFn`.  -/
@[simps]
def coeAddHom : NormedAddGroupHom V₁ V₂ →+ V₁ → V₂ 
goal: NormedAddGroupHom V₁ V₂ →+ V₁ → V₂

full_name: NormedAddGroupHom.coeAddHom_apply
code: /-- Coercion of a `NormedAddGroupHom` is an `AddMonoidHom`. Similar to `AddMonoidHom.coeFn`.  -/
@[simps]
def coeAddHom : NormedAddGroupHom V₁ V₂ →+ V₁ → V₂ 
goal: ∀ (a : NormedAddGroupHom V₁ V₂) (a_1 : V₁), NormedAddGroupHom.coeAddHom a a_1 = a a_1

full_name: NormedAddGroupHom.coe_sum
code: @[simp]
theorem coe_sum {ι : Type*} (s : Finset ι) (f : ι → NormedAddGroupHom V₁ V₂) :
    ⇑(∑ i ∈ s, f i) = ∑ i ∈ s, (f i : V₁ → V₂) 
goal: ⇑(∑ i ∈ s, f i) = ∑ i ∈ s, ⇑(f i)

full_name: NormedAddGroupHom.sum_apply
code: theorem sum_apply {ι : Type*} (s : Finset ι) (f : ι → NormedAddGroupHom V₁ V₂) (v : V₁) :
    (∑ i ∈ s, f i) v = ∑ i ∈ s, f i v 
goal: (∑ i ∈ s, f i) v = ∑ i ∈ s, (f i) v

full_name: NormedAddGroupHom.distribMulAction
code: instance distribMulAction {R : Type*} [MonoidWithZero R] [DistribMulAction R V₂]
    [PseudoMetricSpace R] [BoundedSMul R V₂] : DistribMulAction R (NormedAddGroupHom V₁ V₂) 
goal: DistribMulAction R (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.module
code: instance module {R : Type*} [Semiring R] [Module R V₂] [PseudoMetricSpace R] [BoundedSMul R V₂] :
    Module R (NormedAddGroupHom V₁ V₂) 
goal: Module R (NormedAddGroupHom V₁ V₂)

full_name: NormedAddGroupHom.comp
code: /-- The composition of continuous normed group homs. -/
@[simps!]
protected def comp (g : NormedAddGroupHom V₂ V₃) (f : NormedAddGroupHom V₁ V₂) :
    NormedAddGroupHom V₁ V₃ 
goal: NormedAddGroupHom V₁ V₃

full_name: NormedAddGroupHom.comp_apply
code: /-- The composition of continuous normed group homs. -/
@[simps!]
protected def comp (g : NormedAddGroupHom V₂ V₃) (f : NormedAddGroupHom V₁ V₂) :
    NormedAddGroupHom V₁ V₃ 
goal: ∀ (a : V₁), (g.comp f) a = g (f a)

full_name: NormedAddGroupHom.norm_comp_le
code: theorem norm_comp_le (g : NormedAddGroupHom V₂ V₃) (f : NormedAddGroupHom V₁ V₂) :
    ‖g.comp f‖ ≤ ‖g‖ * ‖f‖ 
goal: ‖g.comp f‖ ≤ ‖g‖ * ‖f‖

full_name: NormedAddGroupHom.norm_comp_le_of_le
code: theorem norm_comp_le_of_le {g : NormedAddGroupHom V₂ V₃} {C₁ C₂ : ℝ} (hg : ‖g‖ ≤ C₂)
    (hf : ‖f‖ ≤ C₁) : ‖g.comp f‖ ≤ C₂ * C₁ 
goal: ‖g.comp f‖ ≤ C₂ * C₁

full_name: NormedAddGroupHom.norm_comp_le_of_le'
code: theorem norm_comp_le_of_le' {g : NormedAddGroupHom V₂ V₃} (C₁ C₂ C₃ : ℝ) (h : C₃ = C₂ * C₁)
    (hg : ‖g‖ ≤ C₂) (hf : ‖f‖ ≤ C₁) : ‖g.comp f‖ ≤ C₃ 
goal: ‖g.comp f‖ ≤ C₃

full_name: NormedAddGroupHom.compHom
code: /-- Composition of normed groups hom as an additive group morphism. -/
def compHom : NormedAddGroupHom V₂ V₃ →+ NormedAddGroupHom V₁ V₂ →+ NormedAddGroupHom V₁ V₃ 
goal: NormedAddGroupHom V₂ V₃ →+ NormedAddGroupHom V₁ V₂ →+ NormedAddGroupHom V₁ V₃

full_name: NormedAddGroupHom.comp_zero
code: @[simp]
theorem comp_zero (f : NormedAddGroupHom V₂ V₃) : f.comp (0 : NormedAddGroupHom V₁ V₂) = 0 
goal: f.comp 0 = 0

full_name: NormedAddGroupHom.zero_comp
code: @[simp]
theorem zero_comp (f : NormedAddGroupHom V₁ V₂) : (0 : NormedAddGroupHom V₂ V₃).comp f = 0 
goal: NormedAddGroupHom.comp 0 f = 0

full_name: NormedAddGroupHom.comp_assoc
code: theorem comp_assoc {V₄ : Type*} [SeminormedAddCommGroup V₄] (h : NormedAddGroupHom V₃ V₄)
    (g : NormedAddGroupHom V₂ V₃) (f : NormedAddGroupHom V₁ V₂) :
    (h.comp g).comp f = h.comp (g.comp f) 
goal: (h.comp g).comp f = h.comp (g.comp f)

full_name: NormedAddGroupHom.coe_comp
code: theorem coe_comp (f : NormedAddGroupHom V₁ V₂) (g : NormedAddGroupHom V₂ V₃) :
    (g.comp f : V₁ → V₃) = (g : V₂ → V₃) ∘ (f : V₁ → V₂) 
goal: ⇑(g.comp f) = ⇑g ∘ ⇑f

full_name: NormedAddGroupHom.incl
code: /-- The inclusion of an `AddSubgroup`, as bounded group homomorphism. -/
@[simps!]
def incl (s : AddSubgroup V) : NormedAddGroupHom s V 
goal: NormedAddGroupHom (↥s) V

full_name: NormedAddGroupHom.incl_apply
code: /-- The inclusion of an `AddSubgroup`, as bounded group homomorphism. -/
@[simps!]
def incl (s : AddSubgroup V) : NormedAddGroupHom s V 
goal: (NormedAddGroupHom.incl s) self = ↑self

full_name: NormedAddGroupHom.norm_incl
code: theorem norm_incl {V' : AddSubgroup V} (x : V') : ‖incl _ x‖ = ‖x‖ 
goal: ‖(NormedAddGroupHom.incl V') x‖ = ‖x‖

full_name: NormedAddGroupHom.ker
code: /-- The kernel of a bounded group homomorphism. Naturally endowed with a
`SeminormedAddCommGroup` instance. -/
def ker : AddSubgroup V₁ 
goal: AddSubgroup V₁

full_name: NormedAddGroupHom.mem_ker
code: theorem mem_ker (v : V₁) : v ∈ f.ker ↔ f v = 0 
goal: v ∈ f.ker ↔ f v = 0

full_name: NormedAddGroupHom.ker.lift
code: /-- Given a normed group hom `f : V₁ → V₂` satisfying `g.comp f = 0` for some `g : V₂ → V₃`,
    the corestriction of `f` to the kernel of `g`. -/
@[simps]
def ker.lift (h : g.comp f = 0) : NormedAddGroupHom V₁ g.ker 
goal: NormedAddGroupHom V₁ ↥g.ker

full_name: NormedAddGroupHom.ker.lift_apply_coe
code: /-- Given a normed group hom `f : V₁ → V₂` satisfying `g.comp f = 0` for some `g : V₂ → V₃`,
    the corestriction of `f` to the kernel of `g`. -/
@[simps]
def ker.lift (h : g.comp f = 0) : NormedAddGroupHom V₁ g.ker 
goal: ↑((NormedAddGroupHom.ker.lift f g h) v) = f v

full_name: NormedAddGroupHom.ker.incl_comp_lift
code: @[simp]
theorem ker.incl_comp_lift (h : g.comp f = 0) : (incl g.ker).comp (ker.lift f g h) = f 
goal: (NormedAddGroupHom.incl g.ker).comp (NormedAddGroupHom.ker.lift f g h) = f

full_name: NormedAddGroupHom.ker_zero
code: @[simp]
theorem ker_zero : (0 : NormedAddGroupHom V₁ V₂).ker = ⊤ 
goal: NormedAddGroupHom.ker 0 = ⊤

full_name: NormedAddGroupHom.coe_ker
code: theorem coe_ker : (f.ker : Set V₁) = (f : V₁ → V₂) ⁻¹' {0} 
goal: ↑f.ker = ⇑f ⁻¹' {0}

full_name: NormedAddGroupHom.isClosed_ker
code: theorem isClosed_ker {V₂ : Type*} [NormedAddCommGroup V₂] (f : NormedAddGroupHom V₁ V₂) :
    IsClosed (f.ker : Set V₁) 
goal: IsClosed ↑f.ker

full_name: NormedAddGroupHom.range
code: /-- The image of a bounded group homomorphism. Naturally endowed with a
`SeminormedAddCommGroup` instance. -/
def range : AddSubgroup V₂ 
goal: AddSubgroup V₂

full_name: NormedAddGroupHom.mem_range
code: theorem mem_range (v : V₂) : v ∈ f.range ↔ ∃ w, f w = v 
goal: v ∈ f.range ↔ ∃ w, f w = v

full_name: NormedAddGroupHom.mem_range_self
code: @[simp]
theorem mem_range_self (v : V₁) : f v ∈ f.range 
goal: f v ∈ f.range

full_name: NormedAddGroupHom.comp_range
code: theorem comp_range : (g.comp f).range = AddSubgroup.map g.toAddMonoidHom f.range 
goal: (g.comp f).range = AddSubgroup.map g.toAddMonoidHom f.range

full_name: NormedAddGroupHom.incl_range
code: theorem incl_range (s : AddSubgroup V₁) : (incl s).range = s 
goal: (NormedAddGroupHom.incl s).range = s

full_name: NormedAddGroupHom.range_comp_incl_top
code: @[simp]
theorem range_comp_incl_top : (f.comp (incl (⊤ : AddSubgroup V₁))).range = f.range 
goal: (f.comp (NormedAddGroupHom.incl ⊤)).range = f.range

full_name: NormedAddGroupHom.NormNoninc
code: /-- A `NormedAddGroupHom` is *norm-nonincreasing* if `‖f v‖ ≤ ‖v‖` for all `v`. -/
def NormNoninc (f : NormedAddGroupHom V W) : Prop 
goal: Prop

full_name: NormedAddGroupHom.NormNoninc.normNoninc_iff_norm_le_one
code: theorem normNoninc_iff_norm_le_one : f.NormNoninc ↔ ‖f‖ ≤ 1 
goal: f.NormNoninc ↔ ‖f‖ ≤ 1

full_name: NormedAddGroupHom.NormNoninc.zero
code: theorem zero : (0 : NormedAddGroupHom V₁ V₂).NormNoninc 
goal: NormedAddGroupHom.NormNoninc 0

full_name: NormedAddGroupHom.NormNoninc.id
code: theorem id : (id V).NormNoninc 
goal: (NormedAddGroupHom.id V).NormNoninc

full_name: NormedAddGroupHom.NormNoninc.comp
code: theorem comp {g : NormedAddGroupHom V₂ V₃} {f : NormedAddGroupHom V₁ V₂} (hg : g.NormNoninc)
    (hf : f.NormNoninc) : (g.comp f).NormNoninc 
goal: (g.comp f).NormNoninc

full_name: NormedAddGroupHom.NormNoninc.neg_iff
code: @[simp]
theorem neg_iff {f : NormedAddGroupHom V₁ V₂} : (-f).NormNoninc ↔ f.NormNoninc 
goal: (-f).NormNoninc ↔ f.NormNoninc

full_name: NormedAddGroupHom.norm_eq_of_isometry
code: theorem norm_eq_of_isometry {f : NormedAddGroupHom V W} (hf : Isometry f) (v : V) : ‖f v‖ = ‖v‖ 
goal: ‖f v‖ = ‖v‖

full_name: NormedAddGroupHom.isometry_id
code: theorem isometry_id : @Isometry V V _ _ (id V) 
goal: Isometry ⇑(NormedAddGroupHom.id V)

full_name: NormedAddGroupHom.isometry_comp
code: theorem isometry_comp {g : NormedAddGroupHom V₂ V₃} {f : NormedAddGroupHom V₁ V₂} (hg : Isometry g)
    (hf : Isometry f) : Isometry (g.comp f) 
goal: Isometry ⇑(g.comp f)

full_name: NormedAddGroupHom.normNoninc_of_isometry
code: theorem normNoninc_of_isometry (hf : Isometry f) : f.NormNoninc 
goal: f.NormNoninc

full_name: NormedAddGroupHom.equalizer
code: /-- The equalizer of two morphisms `f g : NormedAddGroupHom V W`. -/
def equalizer 
goal: AddSubgroup V

full_name: NormedAddGroupHom.Equalizer.ι
code: /-- The inclusion of `f.equalizer g` as a `NormedAddGroupHom`. -/
def ι : NormedAddGroupHom (f.equalizer g) V 
goal: NormedAddGroupHom (↥(f.equalizer g)) V

full_name: NormedAddGroupHom.Equalizer.comp_ι_eq
code: theorem comp_ι_eq : f.comp (ι f g) = g.comp (ι f g) 
goal: f.comp (NormedAddGroupHom.Equalizer.ι f g) = g.comp (NormedAddGroupHom.Equalizer.ι f g)

full_name: NormedAddGroupHom.Equalizer.lift_apply_coe
code: /-- If `φ : NormedAddGroupHom V₁ V` is such that `f.comp φ = g.comp φ`, the induced morphism
`NormedAddGroupHom V₁ (f.equalizer g)`. -/
@[simps]
def lift (φ : NormedAddGroupHom V₁ V) (h : f.comp φ = g.comp φ) :
    NormedAddGroupHom V₁ (f.equalizer g) 
goal: ↑((NormedAddGroupHom.Equalizer.lift φ h) v) = φ v

full_name: NormedAddGroupHom.Equalizer.lift
code: /-- If `φ : NormedAddGroupHom V₁ V` is such that `f.comp φ = g.comp φ`, the induced morphism
`NormedAddGroupHom V₁ (f.equalizer g)`. -/
@[simps]
def lift (φ : NormedAddGroupHom V₁ V) (h : f.comp φ = g.comp φ) :
    NormedAddGroupHom V₁ (f.equalizer g) 
goal: NormedAddGroupHom V₁ ↥(f.equalizer g)

full_name: NormedAddGroupHom.Equalizer.ι_comp_lift
code: @[simp]
theorem ι_comp_lift (φ : NormedAddGroupHom V₁ V) (h : f.comp φ = g.comp φ) :
    (ι _ _).comp (lift φ h) = φ 
goal: (NormedAddGroupHom.Equalizer.ι f g).comp (NormedAddGroupHom.Equalizer.lift φ h) = φ

full_name: NormedAddGroupHom.Equalizer.liftEquiv_apply
code: /-- The lifting property of the equalizer as an equivalence. -/
@[simps]
def liftEquiv :
    { φ : NormedAddGroupHom V₁ V // f.comp φ = g.comp φ } ≃
      NormedAddGroupHom V₁ (f.equalizer g) 
goal: NormedAddGroupHom.Equalizer.liftEquiv φ = NormedAddGroupHom.Equalizer.lift ↑φ ⋯

full_name: NormedAddGroupHom.Equalizer.liftEquiv
code: /-- The lifting property of the equalizer as an equivalence. -/
@[simps]
def liftEquiv :
    { φ : NormedAddGroupHom V₁ V // f.comp φ = g.comp φ } ≃
      NormedAddGroupHom V₁ (f.equalizer g) 
goal: { φ // f.comp φ = g.comp φ } ≃ NormedAddGroupHom V₁ ↥(f.equalizer g)

full_name: NormedAddGroupHom.Equalizer.liftEquiv_symm_apply_coe
code: /-- The lifting property of the equalizer as an equivalence. -/
@[simps]
def liftEquiv :
    { φ : NormedAddGroupHom V₁ V // f.comp φ = g.comp φ } ≃
      NormedAddGroupHom V₁ (f.equalizer g) 
goal: ↑(NormedAddGroupHom.Equalizer.liftEquiv.symm ψ) = (NormedAddGroupHom.Equalizer.ι f g).comp ψ

full_name: NormedAddGroupHom.Equalizer.map
code: /-- Given `φ : NormedAddGroupHom V₁ V₂` and `ψ : NormedAddGroupHom W₁ W₂` such that
`ψ.comp f₁ = f₂.comp φ` and `ψ.comp g₁ = g₂.comp φ`, the induced morphism
`NormedAddGroupHom (f₁.equalizer g₁) (f₂.equalizer g₂)`. -/
def map (φ : NormedAddGroupHom V₁ V₂) (ψ : NormedAddGroupHom W₁ W₂) (hf : ψ.comp f₁ = f₂.comp φ)
    (hg : ψ.comp g₁ = g₂.comp φ) : NormedAddGroupHom (f₁.equalizer g₁) (f₂.equalizer g₂) 
goal: NormedAddGroupHom ↥(f₁.equalizer g₁) ↥(f₂.equalizer g₂)

full_name: NormedAddGroupHom.Equalizer.ι_comp_map
code: @[simp]
theorem ι_comp_map (hf : ψ.comp f₁ = f₂.comp φ) (hg : ψ.comp g₁ = g₂.comp φ) :
    (ι f₂ g₂).comp (map φ ψ hf hg) = φ.comp (ι f₁ g₁) 
goal: (NormedAddGroupHom.Equalizer.ι f₂ g₂).comp (NormedAddGroupHom.Equalizer.map φ ψ hf hg) =
  φ.comp (NormedAddGroupHom.Equalizer.ι f₁ g₁)

full_name: NormedAddGroupHom.Equalizer.map_id
code: @[simp]
theorem map_id : map (f₂ := f₁) (g₂ := g₁) (id V₁) (id W₁) rfl rfl = id (f₁.equalizer g₁) 
goal: NormedAddGroupHom.Equalizer.map (NormedAddGroupHom.id V₁) (NormedAddGroupHom.id W₁) ⋯ ⋯ =
  NormedAddGroupHom.id ↥(f₁.equalizer g₁)

full_name: NormedAddGroupHom.Equalizer.comm_sq₂
code: theorem comm_sq₂ (hf : ψ.comp f₁ = f₂.comp φ) (hf' : ψ'.comp f₂ = f₃.comp φ') :
    (ψ'.comp ψ).comp f₁ = f₃.comp (φ'.comp φ) 
goal: (ψ'.comp ψ).comp f₁ = f₃.comp (φ'.comp φ)

full_name: NormedAddGroupHom.Equalizer.map_comp_map
code: theorem map_comp_map (hf : ψ.comp f₁ = f₂.comp φ) (hg : ψ.comp g₁ = g₂.comp φ)
    (hf' : ψ'.comp f₂ = f₃.comp φ') (hg' : ψ'.comp g₂ = g₃.comp φ') :
    (map φ' ψ' hf' hg').comp (map φ ψ hf hg) =
      map (φ'.comp φ) (ψ'.comp ψ) (comm_sq₂ hf hf') (comm_sq₂ hg hg') 
goal: (NormedAddGroupHom.Equalizer.map φ' ψ' hf' hg').comp (NormedAddGroupHom.Equalizer.map φ ψ hf hg) =
  NormedAddGroupHom.Equalizer.map (φ'.comp φ) (ψ'.comp ψ) ⋯ ⋯

full_name: NormedAddGroupHom.Equalizer.ι_normNoninc
code: theorem ι_normNoninc : (ι f g).NormNoninc 
goal: (NormedAddGroupHom.Equalizer.ι f g).NormNoninc

full_name: NormedAddGroupHom.Equalizer.lift_normNoninc
code: /-- The lifting of a norm nonincreasing morphism is norm nonincreasing. -/
theorem lift_normNoninc (φ : NormedAddGroupHom V₁ V) (h : f.comp φ = g.comp φ) (hφ : φ.NormNoninc) :
    (lift φ h).NormNoninc 
goal: (NormedAddGroupHom.Equalizer.lift φ h).NormNoninc

full_name: NormedAddGroupHom.Equalizer.norm_lift_le
code: /-- If `φ` satisfies `‖φ‖ ≤ C`, then the same is true for the lifted morphism. -/
theorem norm_lift_le (φ : NormedAddGroupHom V₁ V) (h : f.comp φ = g.comp φ) (C : ℝ) (hφ : ‖φ‖ ≤ C) :
    ‖lift φ h‖ ≤ C 
goal: ‖NormedAddGroupHom.Equalizer.lift φ h‖ ≤ C

full_name: NormedAddGroupHom.Equalizer.map_normNoninc
code: theorem map_normNoninc (hf : ψ.comp f₁ = f₂.comp φ) (hg : ψ.comp g₁ = g₂.comp φ)
    (hφ : φ.NormNoninc) : (map φ ψ hf hg).NormNoninc 
goal: (NormedAddGroupHom.Equalizer.map φ ψ hf hg).NormNoninc

full_name: NormedAddGroupHom.Equalizer.norm_map_le
code: theorem norm_map_le (hf : ψ.comp f₁ = f₂.comp φ) (hg : ψ.comp g₁ = g₂.comp φ) (C : ℝ)
    (hφ : ‖φ.comp (ι f₁ g₁)‖ ≤ C) : ‖map φ ψ hf hg‖ ≤ C 
goal: ‖NormedAddGroupHom.Equalizer.map φ ψ hf hg‖ ≤ C