File: Mathlib/Topology/ContinuousFunction/Bounded.lean

full_name: BoundedContinuousFunction
code: /-- `α →ᵇ β` is the type of bounded continuous functions `α → β` from a topological space to a
metric space.

When possible, instead of parametrizing results over `(f : α →ᵇ β)`,
you should parametrize over `(F : Type*) [BoundedContinuousMapClass F α β] (f : F)`.

When you extend this structure, make sure to extend `BoundedContinuousMapClass`. -/
structure BoundedContinuousFunction (α : Type u) (β : Type v) [TopologicalSpace α]
    [PseudoMetricSpace β] extends ContinuousMap α β : Type max u v where
  map_bounded' : ∃ C, ∀ x y, dist (toFun x) (toFun y) ≤ C
goal: Type (max u v)

full_name: BoundedContinuousFunction.map_bounded'
code: /-- `α →ᵇ β` is the type of bounded continuous functions `α → β` from a topological space to a
metric space.

When possible, instead of parametrizing results over `(f : α →ᵇ β)`,
you should parametrize over `(F : Type*) [BoundedContinuousMapClass F α β] (f : F)`.

When you extend this structure, make sure to extend `BoundedContinuousMapClass`. -/
structure BoundedContinuousFunction (α : Type u) (β : Type v) [TopologicalSpace α]
    [PseudoMetricSpace β] extends ContinuousMap α β : Type max u v where
  map_bounded' : ∃ C, ∀ x y, dist (toFun x) (toFun y) ≤ C
goal: ∃ C, ∀ (x y : α), dist (self.toFun x) (self.toFun y) ≤ C

full_name: BoundedContinuousFunction.«_aux_Mathlib_Topology_ContinuousFunction_Bounded___macroRules_BoundedContinuousFunction_term_→ᵇ__1»
code: scoped[BoundedContinuousFunction] infixr:25 " →ᵇ " => BoundedContinuousFunction
goal: Lean.Macro

full_name: BoundedContinuousFunction._aux_Mathlib_Topology_ContinuousFunction_Bounded___unexpand_BoundedContinuousFunction_1
code: scoped[BoundedContinuousFunction] infixr:25 " →ᵇ " => BoundedContinuousFunction
goal: Lean.PrettyPrinter.Unexpander

full_name: BoundedContinuousMapClass.map_bounded
code: /-- `BoundedContinuousMapClass F α β` states that `F` is a type of bounded continuous maps.

You should also extend this typeclass when you extend `BoundedContinuousFunction`. -/
class BoundedContinuousMapClass (F : Type*) (α β : outParam Type*) [TopologicalSpace α]
    [PseudoMetricSpace β] [FunLike F α β] extends ContinuousMapClass F α β : Prop where
  map_bounded (f : F) : ∃ C, ∀ x y, dist (f x) (f y) ≤ C
goal: ∃ C, ∀ (x y : α), dist (f x) (f y) ≤ C

full_name: BoundedContinuousMapClass
code: /-- `BoundedContinuousMapClass F α β` states that `F` is a type of bounded continuous maps.

You should also extend this typeclass when you extend `BoundedContinuousFunction`. -/
class BoundedContinuousMapClass (F : Type*) (α β : outParam Type*) [TopologicalSpace α]
    [PseudoMetricSpace β] [FunLike F α β] extends ContinuousMapClass F α β : Prop where
  map_bounded (f : F) : ∃ C, ∀ x y, dist (f x) (f y) ≤ C
goal: Prop

full_name: BoundedContinuousFunction.instFunLike
code: instance instFunLike : FunLike (α →ᵇ β) α β 
goal: FunLike (BoundedContinuousFunction α β) α β

full_name: BoundedContinuousFunction.instBoundedContinuousMapClass
code: instance instBoundedContinuousMapClass : BoundedContinuousMapClass (α →ᵇ β) α β 
goal: BoundedContinuousMapClass (BoundedContinuousFunction α β) α β

full_name: BoundedContinuousFunction.instCoeTC
code: instance instCoeTC [FunLike F α β] [BoundedContinuousMapClass F α β] : CoeTC F (α →ᵇ β) 
goal: CoeTC F (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.coe_to_continuous_fun
code: @[simp]
theorem coe_to_continuous_fun (f : α →ᵇ β) : (f.toContinuousMap : α → β) = f 
goal: ⇑f.toContinuousMap = ⇑f

full_name: BoundedContinuousFunction.Simps.apply
code: /-- See Note [custom simps projection]. We need to specify this projection explicitly in this case,
  because it is a composition of multiple projections. -/
def Simps.apply (h : α →ᵇ β) : α → β 
goal: α → β

full_name: BoundedContinuousFunction.bounded
code: protected theorem bounded (f : α →ᵇ β) : ∃ C, ∀ x y : α, dist (f x) (f y) ≤ C 
goal: ∃ C, ∀ (x y : α), dist (f x) (f y) ≤ C

full_name: BoundedContinuousFunction.continuous
code: protected theorem continuous (f : α →ᵇ β) : Continuous f 
goal: Continuous ⇑f

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

full_name: BoundedContinuousFunction.isBounded_range
code: theorem isBounded_range (f : α →ᵇ β) : IsBounded (range f) 
goal: Bornology.IsBounded (Set.range ⇑f)

full_name: BoundedContinuousFunction.isBounded_image
code: theorem isBounded_image (f : α →ᵇ β) (s : Set α) : IsBounded (f '' s) 
goal: Bornology.IsBounded (⇑f '' s)

full_name: BoundedContinuousFunction.eq_of_empty
code: theorem eq_of_empty [h : IsEmpty α] (f g : α →ᵇ β) : f = g 
goal: f = g

full_name: BoundedContinuousFunction.mkOfBound
code: /-- A continuous function with an explicit bound is a bounded continuous function. -/
def mkOfBound (f : C(α, β)) (C : ℝ) (h : ∀ x y : α, dist (f x) (f y) ≤ C) : α →ᵇ β 
goal: BoundedContinuousFunction α β

full_name: BoundedContinuousFunction.mkOfBound_coe
code: @[simp]
theorem mkOfBound_coe {f} {C} {h} : (mkOfBound f C h : α → β) = (f : α → β) 
goal: ⇑(BoundedContinuousFunction.mkOfBound f C h) = ⇑f

full_name: BoundedContinuousFunction.mkOfCompact
code: /-- A continuous function on a compact space is automatically a bounded continuous function. -/
def mkOfCompact [CompactSpace α] (f : C(α, β)) : α →ᵇ β 
goal: BoundedContinuousFunction α β

full_name: BoundedContinuousFunction.mkOfCompact_apply
code: @[simp]
theorem mkOfCompact_apply [CompactSpace α] (f : C(α, β)) (a : α) : mkOfCompact f a = f a 
goal: (BoundedContinuousFunction.mkOfCompact f) a = f a

full_name: BoundedContinuousFunction.mkOfDiscrete_toFun
code: /-- If a function is bounded on a discrete space, it is automatically continuous,
and therefore gives rise to an element of the type of bounded continuous functions. -/
@[simps]
def mkOfDiscrete [DiscreteTopology α] (f : α → β) (C : ℝ) (h : ∀ x y : α, dist (f x) (f y) ≤ C) :
    α →ᵇ β 
goal: ∀ (a : α), (BoundedContinuousFunction.mkOfDiscrete f C h) a = f a

full_name: BoundedContinuousFunction.mkOfDiscrete
code: /-- If a function is bounded on a discrete space, it is automatically continuous,
and therefore gives rise to an element of the type of bounded continuous functions. -/
@[simps]
def mkOfDiscrete [DiscreteTopology α] (f : α → β) (C : ℝ) (h : ∀ x y : α, dist (f x) (f y) ≤ C) :
    α →ᵇ β 
goal: BoundedContinuousFunction α β

full_name: BoundedContinuousFunction.mkOfDiscrete_apply
code: /-- If a function is bounded on a discrete space, it is automatically continuous,
and therefore gives rise to an element of the type of bounded continuous functions. -/
@[simps]
def mkOfDiscrete [DiscreteTopology α] (f : α → β) (C : ℝ) (h : ∀ x y : α, dist (f x) (f y) ≤ C) :
    α →ᵇ β 
goal: ∀ (a : α), (BoundedContinuousFunction.mkOfDiscrete f C h) a = f a

full_name: BoundedContinuousFunction.instDist
code: /-- The uniform distance between two bounded continuous functions. -/
instance instDist : Dist (α →ᵇ β) 
goal: Dist (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.dist_eq
code: theorem dist_eq : dist f g = sInf { C | 0 ≤ C ∧ ∀ x : α, dist (f x) (g x) ≤ C } 
goal: dist f g = sInf {C | 0 ≤ C ∧ ∀ (x : α), dist (f x) (g x) ≤ C}

full_name: BoundedContinuousFunction.dist_set_exists
code: theorem dist_set_exists : ∃ C, 0 ≤ C ∧ ∀ x : α, dist (f x) (g x) ≤ C 
goal: ∃ C, 0 ≤ C ∧ ∀ (x : α), dist (f x) (g x) ≤ C

full_name: BoundedContinuousFunction.dist_coe_le_dist
code: /-- The pointwise distance is controlled by the distance between functions, by definition. -/
theorem dist_coe_le_dist (x : α) : dist (f x) (g x) ≤ dist f g 
goal: dist (f x) (g x) ≤ dist f g

full_name: _private.Mathlib.Topology.ContinuousFunction.Bounded.0.BoundedContinuousFunction.dist_nonneg'
code: private theorem dist_nonneg' : 0 ≤ dist f g 
goal: 0 ≤ dist f g

full_name: BoundedContinuousFunction.dist_le
code: /-- The distance between two functions is controlled by the supremum of the pointwise distances. -/
theorem dist_le (C0 : (0 : ℝ) ≤ C) : dist f g ≤ C ↔ ∀ x : α, dist (f x) (g x) ≤ C 
goal: dist f g ≤ C ↔ ∀ (x : α), dist (f x) (g x) ≤ C

full_name: BoundedContinuousFunction.dist_le_iff_of_nonempty
code: theorem dist_le_iff_of_nonempty [Nonempty α] : dist f g ≤ C ↔ ∀ x, dist (f x) (g x) ≤ C 
goal: dist f g ≤ C ↔ ∀ (x : α), dist (f x) (g x) ≤ C

full_name: BoundedContinuousFunction.dist_lt_of_nonempty_compact
code: theorem dist_lt_of_nonempty_compact [Nonempty α] [CompactSpace α]
    (w : ∀ x : α, dist (f x) (g x) < C) : dist f g < C 
goal: dist f g < C

full_name: BoundedContinuousFunction.dist_lt_iff_of_compact
code: theorem dist_lt_iff_of_compact [CompactSpace α] (C0 : (0 : ℝ) < C) :
    dist f g < C ↔ ∀ x : α, dist (f x) (g x) < C 
goal: dist f g < C ↔ ∀ (x : α), dist (f x) (g x) < C

full_name: BoundedContinuousFunction.dist_lt_iff_of_nonempty_compact
code: theorem dist_lt_iff_of_nonempty_compact [Nonempty α] [CompactSpace α] :
    dist f g < C ↔ ∀ x : α, dist (f x) (g x) < C 
goal: dist f g < C ↔ ∀ (x : α), dist (f x) (g x) < C

full_name: BoundedContinuousFunction.instPseudoMetricSpace
code: /-- The type of bounded continuous functions, with the uniform distance, is a pseudometric space. -/
instance instPseudoMetricSpace : PseudoMetricSpace (α →ᵇ β) 
goal: PseudoMetricSpace (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instMetricSpace
code: /-- The type of bounded continuous functions, with the uniform distance, is a metric space. -/
instance instMetricSpace {β} [MetricSpace β] : MetricSpace (α →ᵇ β) 
goal: MetricSpace (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.nndist_eq
code: theorem nndist_eq : nndist f g = sInf { C | ∀ x : α, nndist (f x) (g x) ≤ C } 
goal: nndist f g = sInf {C | ∀ (x : α), nndist (f x) (g x) ≤ C}

full_name: BoundedContinuousFunction.nndist_set_exists
code: theorem nndist_set_exists : ∃ C, ∀ x : α, nndist (f x) (g x) ≤ C 
goal: ∃ C, ∀ (x : α), nndist (f x) (g x) ≤ C

full_name: BoundedContinuousFunction.nndist_coe_le_nndist
code: theorem nndist_coe_le_nndist (x : α) : nndist (f x) (g x) ≤ nndist f g 
goal: nndist (f x) (g x) ≤ nndist f g

full_name: BoundedContinuousFunction.dist_zero_of_empty
code: /-- On an empty space, bounded continuous functions are at distance 0. -/
theorem dist_zero_of_empty [IsEmpty α] : dist f g = 0 
goal: dist f g = 0

full_name: BoundedContinuousFunction.dist_eq_iSup
code: theorem dist_eq_iSup : dist f g = ⨆ x : α, dist (f x) (g x) 
goal: dist f g = ⨆ x, dist (f x) (g x)

full_name: BoundedContinuousFunction.nndist_eq_iSup
code: theorem nndist_eq_iSup : nndist f g = ⨆ x : α, nndist (f x) (g x) 
goal: nndist f g = ⨆ x, nndist (f x) (g x)

full_name: BoundedContinuousFunction.tendsto_iff_tendstoUniformly
code: theorem tendsto_iff_tendstoUniformly {ι : Type*} {F : ι → α →ᵇ β} {f : α →ᵇ β} {l : Filter ι} :
    Tendsto F l (𝓝 f) ↔ TendstoUniformly (fun i => F i) f l 
goal: Filter.Tendsto F l (𝓝 f) ↔ TendstoUniformly (fun i => ⇑(F i)) (⇑f) l

full_name: BoundedContinuousFunction.inducing_coeFn
code: /-- The topology on `α →ᵇ β` is exactly the topology induced by the natural map to `α →ᵤ β`. -/
theorem inducing_coeFn : Inducing (UniformFun.ofFun ∘ (⇑) : (α →ᵇ β) → α →ᵤ β) 
goal: Inducing (⇑UniformFun.ofFun ∘ DFunLike.coe)

full_name: BoundedContinuousFunction.embedding_coeFn
code: theorem embedding_coeFn : Embedding (UniformFun.ofFun ∘ (⇑) : (α →ᵇ β) → α →ᵤ β) 
goal: Embedding (⇑UniformFun.ofFun ∘ DFunLike.coe)

full_name: BoundedContinuousFunction.const_apply
code: /-- Constant as a continuous bounded function. -/
@[simps! (config := .asFn)] -- Porting note: Changed `simps` to `simps!`
def const (b : β) : α →ᵇ β 
goal: ⇑(BoundedContinuousFunction.const α b) = fun x => b

full_name: BoundedContinuousFunction.const
code: /-- Constant as a continuous bounded function. -/
@[simps! (config := .asFn)] -- Porting note: Changed `simps` to `simps!`
def const (b : β) : α →ᵇ β 
goal: BoundedContinuousFunction α β

full_name: BoundedContinuousFunction.const_toFun
code: /-- Constant as a continuous bounded function. -/
@[simps! (config := .asFn)] -- Porting note: Changed `simps` to `simps!`
def const (b : β) : α →ᵇ β 
goal: ⇑(BoundedContinuousFunction.const α b) = fun x => b

full_name: BoundedContinuousFunction.const_apply'
code: theorem const_apply' (a : α) (b : β) : (const α b : α → β) a = b 
goal: (BoundedContinuousFunction.const α b) a = b

full_name: BoundedContinuousFunction.instInhabited
code: /-- If the target space is inhabited, so is the space of bounded continuous functions. -/
instance [Inhabited β] : Inhabited (α →ᵇ β) 
goal: Inhabited (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.lipschitz_evalx
code: theorem lipschitz_evalx (x : α) : LipschitzWith 1 fun f : α →ᵇ β => f x 
goal: LipschitzWith 1 fun f => f x

full_name: BoundedContinuousFunction.uniformContinuous_coe
code: theorem uniformContinuous_coe : @UniformContinuous (α →ᵇ β) (α → β) _ _ (⇑) 
goal: UniformContinuous DFunLike.coe

full_name: BoundedContinuousFunction.continuous_coe
code: theorem continuous_coe : Continuous fun (f : α →ᵇ β) x => f x 
goal: Continuous fun f x => f x

full_name: BoundedContinuousFunction.continuous_eval_const
code: /-- When `x` is fixed, `(f : α →ᵇ β) ↦ f x` is continuous. -/
@[continuity]
theorem continuous_eval_const {x : α} : Continuous fun f : α →ᵇ β => f x 
goal: Continuous fun f => f x

full_name: BoundedContinuousFunction.continuous_eval
code: /-- The evaluation map is continuous, as a joint function of `u` and `x`. -/
@[continuity]
theorem continuous_eval : Continuous fun p : (α →ᵇ β) × α => p.1 p.2 
goal: Continuous fun p => p.1 p.2

full_name: BoundedContinuousFunction.instCompleteSpace
code: /-- Bounded continuous functions taking values in a complete space form a complete space. -/
instance instCompleteSpace [CompleteSpace β] : CompleteSpace (α →ᵇ β) 
goal: CompleteSpace (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.compContinuous
code: /-- Composition of a bounded continuous function and a continuous function. -/
def compContinuous {δ : Type*} [TopologicalSpace δ] (f : α →ᵇ β) (g : C(δ, α)) : δ →ᵇ β 
goal: BoundedContinuousFunction δ β

full_name: BoundedContinuousFunction.coe_compContinuous
code: @[simp]
theorem coe_compContinuous {δ : Type*} [TopologicalSpace δ] (f : α →ᵇ β) (g : C(δ, α)) :
    ⇑(f.compContinuous g) = f ∘ g 
goal: ⇑(f.compContinuous g) = ⇑f ∘ ⇑g

full_name: BoundedContinuousFunction.compContinuous_apply
code: @[simp]
theorem compContinuous_apply {δ : Type*} [TopologicalSpace δ] (f : α →ᵇ β) (g : C(δ, α)) (x : δ) :
    f.compContinuous g x = f (g x) 
goal: (f.compContinuous g) x = f (g x)

full_name: BoundedContinuousFunction.lipschitz_compContinuous
code: theorem lipschitz_compContinuous {δ : Type*} [TopologicalSpace δ] (g : C(δ, α)) :
    LipschitzWith 1 fun f : α →ᵇ β => f.compContinuous g 
goal: LipschitzWith 1 fun f => f.compContinuous g

full_name: BoundedContinuousFunction.continuous_compContinuous
code: theorem continuous_compContinuous {δ : Type*} [TopologicalSpace δ] (g : C(δ, α)) :
    Continuous fun f : α →ᵇ β => f.compContinuous g 
goal: Continuous fun f => f.compContinuous g

full_name: BoundedContinuousFunction.restrict
code: /-- Restrict a bounded continuous function to a set. -/
def restrict (f : α →ᵇ β) (s : Set α) : s →ᵇ β 
goal: BoundedContinuousFunction (↑s) β

full_name: BoundedContinuousFunction.coe_restrict
code: @[simp]
theorem coe_restrict (f : α →ᵇ β) (s : Set α) : ⇑(f.restrict s) = f ∘ (↑) 
goal: ⇑(f.restrict s) = ⇑f ∘ Subtype.val

full_name: BoundedContinuousFunction.restrict_apply
code: @[simp]
theorem restrict_apply (f : α →ᵇ β) (s : Set α) (x : s) : f.restrict s x = f x 
goal: (f.restrict s) x = f ↑x

full_name: BoundedContinuousFunction.comp
code: /-- Composition (in the target) of a bounded continuous function with a Lipschitz map again
gives a bounded continuous function. -/
def comp (G : β → γ) {C : ℝ≥0} (H : LipschitzWith C G) (f : α →ᵇ β) : α →ᵇ γ 
goal: BoundedContinuousFunction α γ

full_name: BoundedContinuousFunction.lipschitz_comp
code: /-- The composition operator (in the target) with a Lipschitz map is Lipschitz. -/
theorem lipschitz_comp {G : β → γ} {C : ℝ≥0} (H : LipschitzWith C G) :
    LipschitzWith C (comp G H : (α →ᵇ β) → α →ᵇ γ) 
goal: LipschitzWith C (BoundedContinuousFunction.comp G H)

full_name: BoundedContinuousFunction.uniformContinuous_comp
code: /-- The composition operator (in the target) with a Lipschitz map is uniformly continuous. -/
theorem uniformContinuous_comp {G : β → γ} {C : ℝ≥0} (H : LipschitzWith C G) :
    UniformContinuous (comp G H : (α →ᵇ β) → α →ᵇ γ) 
goal: UniformContinuous (BoundedContinuousFunction.comp G H)

full_name: BoundedContinuousFunction.continuous_comp
code: /-- The composition operator (in the target) with a Lipschitz map is continuous. -/
theorem continuous_comp {G : β → γ} {C : ℝ≥0} (H : LipschitzWith C G) :
    Continuous (comp G H : (α →ᵇ β) → α →ᵇ γ) 
goal: Continuous (BoundedContinuousFunction.comp G H)

full_name: BoundedContinuousFunction.codRestrict
code: /-- Restriction (in the target) of a bounded continuous function taking values in a subset. -/
def codRestrict (s : Set β) (f : α →ᵇ β) (H : ∀ x, f x ∈ s) : α →ᵇ s 
goal: BoundedContinuousFunction α ↑s

full_name: BoundedContinuousFunction.extend
code: /-- A version of `Function.extend` for bounded continuous maps. We assume that the domain has
discrete topology, so we only need to verify boundedness. -/
nonrec def extend (f : α ↪ δ) (g : α →ᵇ β) (h : δ →ᵇ β) : δ →ᵇ β 
goal: BoundedContinuousFunction δ β

full_name: BoundedContinuousFunction.extend_apply
code: @[simp]
theorem extend_apply (f : α ↪ δ) (g : α →ᵇ β) (h : δ →ᵇ β) (x : α) : extend f g h (f x) = g x 
goal: (BoundedContinuousFunction.extend f g h) (f x) = g x

full_name: BoundedContinuousFunction.extend_comp
code: @[simp]
nonrec theorem extend_comp (f : α ↪ δ) (g : α →ᵇ β) (h : δ →ᵇ β) : extend f g h ∘ f = g 
goal: ⇑(BoundedContinuousFunction.extend f g h) ∘ ⇑f = ⇑g

full_name: BoundedContinuousFunction.extend_apply'
code: nonrec theorem extend_apply' {f : α ↪ δ} {x : δ} (hx : x ∉ range f) (g : α →ᵇ β) (h : δ →ᵇ β) :
    extend f g h x = h x 
goal: (BoundedContinuousFunction.extend f g h) x = h x

full_name: BoundedContinuousFunction.extend_of_empty
code: theorem extend_of_empty [IsEmpty α] (f : α ↪ δ) (g : α →ᵇ β) (h : δ →ᵇ β) : extend f g h = h 
goal: BoundedContinuousFunction.extend f g h = h

full_name: BoundedContinuousFunction.dist_extend_extend
code: @[simp]
theorem dist_extend_extend (f : α ↪ δ) (g₁ g₂ : α →ᵇ β) (h₁ h₂ : δ →ᵇ β) :
    dist (g₁.extend f h₁) (g₂.extend f h₂) =
      max (dist g₁ g₂) (dist (h₁.restrict (range f)ᶜ) (h₂.restrict (range f)ᶜ)) 
goal: dist (BoundedContinuousFunction.extend f g₁ h₁) (BoundedContinuousFunction.extend f g₂ h₂) =
  max (dist g₁ g₂) (dist (h₁.restrict (Set.range ⇑f)ᶜ) (h₂.restrict (Set.range ⇑f)ᶜ))

full_name: BoundedContinuousFunction.isometry_extend
code: theorem isometry_extend (f : α ↪ δ) (h : δ →ᵇ β) : Isometry fun g : α →ᵇ β => extend f g h 
goal: Isometry fun g => BoundedContinuousFunction.extend f g h

full_name: BoundedContinuousFunction.arzela_ascoli₁
code: /-- First version, with pointwise equicontinuity and range in a compact space. -/
theorem arzela_ascoli₁ [CompactSpace β] (A : Set (α →ᵇ β)) (closed : IsClosed A)
    (H : Equicontinuous ((↑) : A → α → β)) : IsCompact A 
goal: IsCompact A

full_name: BoundedContinuousFunction.arzela_ascoli₂
code: /-- Second version, with pointwise equicontinuity and range in a compact subset. -/
theorem arzela_ascoli₂ (s : Set β) (hs : IsCompact s) (A : Set (α →ᵇ β)) (closed : IsClosed A)
    (in_s : ∀ (f : α →ᵇ β) (x : α), f ∈ A → f x ∈ s) (H : Equicontinuous ((↑) : A → α → β)) :
    IsCompact A 
goal: IsCompact A

full_name: BoundedContinuousFunction.arzela_ascoli
code: /-- Third (main) version, with pointwise equicontinuity and range in a compact subset, but
without closedness. The closure is then compact. -/
theorem arzela_ascoli [T2Space β] (s : Set β) (hs : IsCompact s) (A : Set (α →ᵇ β))
    (in_s : ∀ (f : α →ᵇ β) (x : α), f ∈ A → f x ∈ s) (H : Equicontinuous ((↑) : A → α → β)) :
    IsCompact (closure A) 
goal: IsCompact (closure A)

full_name: BoundedContinuousFunction.instZero
code: @[to_additive] instance instOne : One (α →ᵇ β) 
goal: Zero (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instOne
code: @[to_additive] instance instOne : One (α →ᵇ β) 
goal: One (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.coe_one
code: @[to_additive (attr := simp)]
theorem coe_one : ((1 : α →ᵇ β) : α → β) = 1 
goal: ⇑1 = 1

full_name: BoundedContinuousFunction.coe_zero
code: @[to_additive (attr := simp)]
theorem coe_one : ((1 : α →ᵇ β) : α → β) = 1 
goal: ⇑0 = 0

full_name: BoundedContinuousFunction.mkOfCompact_zero
code: @[to_additive (attr := simp)]
theorem mkOfCompact_one [CompactSpace α] : mkOfCompact (1 : C(α, β)) = 1 
goal: BoundedContinuousFunction.mkOfCompact 0 = 0

full_name: BoundedContinuousFunction.mkOfCompact_one
code: @[to_additive (attr := simp)]
theorem mkOfCompact_one [CompactSpace α] : mkOfCompact (1 : C(α, β)) = 1 
goal: BoundedContinuousFunction.mkOfCompact 1 = 1

full_name: BoundedContinuousFunction.forall_coe_zero_iff_zero
code: @[to_additive]
theorem forall_coe_one_iff_one (f : α →ᵇ β) : (∀ x, f x = 1) ↔ f = 1 
goal: (∀ (x : α), f x = 0) ↔ f = 0

full_name: BoundedContinuousFunction.forall_coe_one_iff_one
code: @[to_additive]
theorem forall_coe_one_iff_one (f : α →ᵇ β) : (∀ x, f x = 1) ↔ f = 1 
goal: (∀ (x : α), f x = 1) ↔ f = 1

full_name: BoundedContinuousFunction.zero_compContinuous
code: @[to_additive (attr := simp)]
theorem one_compContinuous [TopologicalSpace γ] (f : C(γ, α)) : (1 : α →ᵇ β).compContinuous f = 1 
goal: BoundedContinuousFunction.compContinuous 0 f = 0

full_name: BoundedContinuousFunction.one_compContinuous
code: @[to_additive (attr := simp)]
theorem one_compContinuous [TopologicalSpace γ] (f : C(γ, α)) : (1 : α →ᵇ β).compContinuous f = 1 
goal: BoundedContinuousFunction.compContinuous 1 f = 1

full_name: BoundedContinuousFunction.instAdd
code: /-- The pointwise sum of two bounded continuous functions is again bounded continuous. -/
instance instAdd : Add (α →ᵇ β) 
goal: Add (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.coe_add
code: @[simp]
theorem coe_add : ⇑(f + g) = f + g 
goal: ⇑(f + g) = ⇑f + ⇑g

full_name: BoundedContinuousFunction.add_apply
code: theorem add_apply : (f + g) x = f x + g x 
goal: (f + g) x = f x + g x

full_name: BoundedContinuousFunction.mkOfCompact_add
code: @[simp]
theorem mkOfCompact_add [CompactSpace α] (f g : C(α, β)) :
    mkOfCompact (f + g) = mkOfCompact f + mkOfCompact g 
goal: BoundedContinuousFunction.mkOfCompact (f + g) =
  BoundedContinuousFunction.mkOfCompact f + BoundedContinuousFunction.mkOfCompact g

full_name: BoundedContinuousFunction.add_compContinuous
code: theorem add_compContinuous [TopologicalSpace γ] (h : C(γ, α)) :
    (g + f).compContinuous h = g.compContinuous h + f.compContinuous h 
goal: (g + f).compContinuous h = g.compContinuous h + f.compContinuous h

full_name: BoundedContinuousFunction.coe_nsmulRec
code: @[simp]
theorem coe_nsmulRec : ∀ n, ⇑(nsmulRec n f) = n • ⇑f
  
goal: ⇑(nsmulRec n f) = n • ⇑f

full_name: BoundedContinuousFunction.instSMulNat
code: instance instSMulNat : SMul ℕ (α →ᵇ β) 
goal: SMul ℕ (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.coe_nsmul
code: @[simp]
theorem coe_nsmul (r : ℕ) (f : α →ᵇ β) : ⇑(r • f) = r • ⇑f 
goal: ⇑(r • f) = r • ⇑f

full_name: BoundedContinuousFunction.nsmul_apply
code: @[simp]
theorem nsmul_apply (r : ℕ) (f : α →ᵇ β) (v : α) : (r • f) v = r • f v 
goal: (r • f) v = r • f v

full_name: BoundedContinuousFunction.instAddMonoid
code: instance instAddMonoid : AddMonoid (α →ᵇ β) 
goal: AddMonoid (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.coeFnAddHom
code: /-- Coercion of a `NormedAddGroupHom` is an `AddMonoidHom`. Similar to `AddMonoidHom.coeFn`. -/
@[simps]
def coeFnAddHom : (α →ᵇ β) →+ α → β 
goal: BoundedContinuousFunction α β →+ α → β

full_name: BoundedContinuousFunction.coeFnAddHom_apply
code: /-- Coercion of a `NormedAddGroupHom` is an `AddMonoidHom`. Similar to `AddMonoidHom.coeFn`. -/
@[simps]
def coeFnAddHom : (α →ᵇ β) →+ α → β 
goal: ∀ (a : BoundedContinuousFunction α β) (a_1 : α), BoundedContinuousFunction.coeFnAddHom a a_1 = a a_1

full_name: BoundedContinuousFunction.toContinuousMapAddHom
code: /-- The additive map forgetting that a bounded continuous function is bounded. -/
@[simps]
def toContinuousMapAddHom : (α →ᵇ β) →+ C(α, β) 
goal: BoundedContinuousFunction α β →+ C(α, β)

full_name: BoundedContinuousFunction.toContinuousMapAddHom_apply
code: /-- The additive map forgetting that a bounded continuous function is bounded. -/
@[simps]
def toContinuousMapAddHom : (α →ᵇ β) →+ C(α, β) 
goal: (BoundedContinuousFunction.toContinuousMapAddHom α β) self = self.toContinuousMap

full_name: BoundedContinuousFunction.instAddCommMonoid
code: @[to_additive]
instance instAddCommMonoid : AddCommMonoid (α →ᵇ β) 
goal: AddCommMonoid (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instAddAddCommMonoid
code: @[to_additive]
instance instAddCommMonoid : AddCommMonoid (α →ᵇ β) 
goal: AddCommMonoid (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.coe_sum
code: @[simp]
theorem coe_sum {ι : Type*} (s : Finset ι) (f : ι → α →ᵇ β) :
    ⇑(∑ i ∈ s, f i) = ∑ i ∈ s, (f i : α → β) 
goal: ⇑(∑ i ∈ s, f i) = ∑ i ∈ s, ⇑(f i)

full_name: BoundedContinuousFunction.sum_apply
code: theorem sum_apply {ι : Type*} (s : Finset ι) (f : ι → α →ᵇ β) (a : α) :
    (∑ i ∈ s, f i) a = ∑ i ∈ s, f i a 
goal: (∑ i ∈ s, f i) a = ∑ i ∈ s, (f i) a

full_name: BoundedContinuousFunction.instLipschitzAdd
code: instance instLipschitzAdd : LipschitzAdd (α →ᵇ β) 
goal: LipschitzAdd (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instSub
code: /-- The pointwise difference of two bounded continuous functions is again bounded continuous. -/
instance instSub : Sub (α →ᵇ R) 
goal: Sub (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.sub_apply
code: theorem sub_apply {x : α} : (f - g) x = f x - g x 
goal: (f - g) x = f x - g x

full_name: BoundedContinuousFunction.coe_sub
code: @[simp]
theorem coe_sub : ⇑(f - g) = f - g 
goal: ⇑(f - g) = ⇑f - ⇑g

full_name: BoundedContinuousFunction.instNatCast
code: instance [NatCast β] : NatCast (α →ᵇ β) 
goal: NatCast (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.natCast_apply
code: @[simp]
theorem natCast_apply [NatCast β] (n : ℕ) (x : α) : (n : α →ᵇ β) x = n 
goal: ↑n x = ↑n

full_name: BoundedContinuousFunction.instIntCast
code: instance [IntCast β] : IntCast (α →ᵇ β) 
goal: IntCast (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.intCast_apply
code: @[simp]
theorem intCast_apply [IntCast β] (m : ℤ) (x : α) : (m : α →ᵇ β) x = m 
goal: ↑m x = ↑m

full_name: BoundedContinuousFunction.instMul
code: instance instMul [Mul R] [BoundedMul R] [ContinuousMul R] :
    Mul (α →ᵇ R) 
goal: Mul (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.coe_mul
code: @[simp]
theorem coe_mul [Mul R] [BoundedMul R] [ContinuousMul R] (f g : α →ᵇ R) : ⇑(f * g) = f * g 
goal: ⇑(f * g) = ⇑f * ⇑g

full_name: BoundedContinuousFunction.mul_apply
code: theorem mul_apply [Mul R] [BoundedMul R] [ContinuousMul R] (f g : α →ᵇ R) (x : α) :
    (f * g) x = f x * g x 
goal: (f * g) x = f x * g x

full_name: BoundedContinuousFunction.instPow
code: instance instPow [Monoid R] [BoundedMul R] [ContinuousMul R] : Pow (α →ᵇ R) ℕ 
goal: Pow (BoundedContinuousFunction α R) ℕ

full_name: BoundedContinuousFunction.coe_pow
code: theorem coe_pow [Monoid R] [BoundedMul R] [ContinuousMul R] (n : ℕ) (f : α →ᵇ R) :
    ⇑(f ^ n) = (⇑f) ^ n 
goal: ⇑(f ^ n) = ⇑f ^ n

full_name: BoundedContinuousFunction.pow_apply
code: @[simp]
theorem pow_apply [Monoid R] [BoundedMul R] [ContinuousMul R] (n : ℕ) (f : α →ᵇ R) (x : α) :
    (f ^ n) x = f x ^ n 
goal: (f ^ n) x = f x ^ n

full_name: BoundedContinuousFunction.instMonoid
code: instance instMonoid [Monoid R] [BoundedMul R] [ContinuousMul R] :
    Monoid (α →ᵇ R) 
goal: Monoid (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.instCommMonoid
code: instance instCommMonoid [CommMonoid R] [BoundedMul R] [ContinuousMul R] :
    CommMonoid (α →ᵇ R) 
goal: CommMonoid (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.instSemiring
code: instance instSemiring [Semiring R] [BoundedMul R] [ContinuousMul R]
    [BoundedAdd R] [ContinuousAdd R] :
    Semiring (α →ᵇ R) 
goal: Semiring (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.instNorm
code: instance instNorm : Norm (α →ᵇ β) 
goal: Norm (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.norm_def
code: theorem norm_def : ‖f‖ = dist f 0 
goal: ‖f‖ = dist f 0

full_name: BoundedContinuousFunction.norm_eq
code: /-- The norm of a bounded continuous function is the supremum of `‖f x‖`.
We use `sInf` to ensure that the definition works if `α` has no elements. -/
theorem norm_eq (f : α →ᵇ β) : ‖f‖ = sInf { C : ℝ | 0 ≤ C ∧ ∀ x : α, ‖f x‖ ≤ C } 
goal: ‖f‖ = sInf {C | 0 ≤ C ∧ ∀ (x : α), ‖f x‖ ≤ C}

full_name: BoundedContinuousFunction.norm_eq_of_nonempty
code: /-- When the domain is non-empty, we do not need the `0 ≤ C` condition in the formula for `‖f‖` as a
`sInf`. -/
theorem norm_eq_of_nonempty [h : Nonempty α] : ‖f‖ = sInf { C : ℝ | ∀ x : α, ‖f x‖ ≤ C } 
goal: ‖f‖ = sInf {C | ∀ (x : α), ‖f x‖ ≤ C}

full_name: BoundedContinuousFunction.norm_eq_zero_of_empty
code: @[simp]
theorem norm_eq_zero_of_empty [IsEmpty α] : ‖f‖ = 0 
goal: ‖f‖ = 0

full_name: BoundedContinuousFunction.norm_coe_le_norm
code: theorem norm_coe_le_norm (x : α) : ‖f x‖ ≤ ‖f‖ 
goal: ‖f x‖ ≤ ‖f‖

full_name: BoundedContinuousFunction.neg_norm_le_apply
code: lemma neg_norm_le_apply (f : α →ᵇ ℝ) (x : α) :
    -‖f‖ ≤ f x 
goal: -‖f‖ ≤ f x

full_name: BoundedContinuousFunction.apply_le_norm
code: lemma apply_le_norm (f : α →ᵇ ℝ) (x : α) :
    f x ≤ ‖f‖ 
goal: f x ≤ ‖f‖

full_name: BoundedContinuousFunction.dist_le_two_norm'
code: theorem dist_le_two_norm' {f : γ → β} {C : ℝ} (hC : ∀ x, ‖f x‖ ≤ C) (x y : γ) :
    dist (f x) (f y) ≤ 2 * C 
goal: dist (f x) (f y) ≤ 2 * C

full_name: BoundedContinuousFunction.dist_le_two_norm
code: /-- Distance between the images of any two points is at most twice the norm of the function. -/
theorem dist_le_two_norm (x y : α) : dist (f x) (f y) ≤ 2 * ‖f‖ 
goal: dist (f x) (f y) ≤ 2 * ‖f‖

full_name: BoundedContinuousFunction.norm_le
code: /-- The norm of a function is controlled by the supremum of the pointwise norms. -/
theorem norm_le (C0 : (0 : ℝ) ≤ C) : ‖f‖ ≤ C ↔ ∀ x : α, ‖f x‖ ≤ C 
goal: ‖f‖ ≤ C ↔ ∀ (x : α), ‖f x‖ ≤ C

full_name: BoundedContinuousFunction.norm_le_of_nonempty
code: theorem norm_le_of_nonempty [Nonempty α] {f : α →ᵇ β} {M : ℝ} : ‖f‖ ≤ M ↔ ∀ x, ‖f x‖ ≤ M 
goal: ‖f‖ ≤ M ↔ ∀ (x : α), ‖f x‖ ≤ M

full_name: BoundedContinuousFunction.norm_lt_iff_of_compact
code: theorem norm_lt_iff_of_compact [CompactSpace α] {f : α →ᵇ β} {M : ℝ} (M0 : 0 < M) :
    ‖f‖ < M ↔ ∀ x, ‖f x‖ < M 
goal: ‖f‖ < M ↔ ∀ (x : α), ‖f x‖ < M

full_name: BoundedContinuousFunction.norm_lt_iff_of_nonempty_compact
code: theorem norm_lt_iff_of_nonempty_compact [Nonempty α] [CompactSpace α] {f : α →ᵇ β} {M : ℝ} :
    ‖f‖ < M ↔ ∀ x, ‖f x‖ < M 
goal: ‖f‖ < M ↔ ∀ (x : α), ‖f x‖ < M

full_name: BoundedContinuousFunction.norm_const_le
code: /-- Norm of `const α b` is less than or equal to `‖b‖`. If `α` is nonempty,
then it is equal to `‖b‖`. -/
theorem norm_const_le (b : β) : ‖const α b‖ ≤ ‖b‖ 
goal: ‖BoundedContinuousFunction.const α b‖ ≤ ‖b‖

full_name: BoundedContinuousFunction.norm_const_eq
code: @[simp]
theorem norm_const_eq [h : Nonempty α] (b : β) : ‖const α b‖ = ‖b‖ 
goal: ‖BoundedContinuousFunction.const α b‖ = ‖b‖

full_name: BoundedContinuousFunction.ofNormedAddCommGroup
code: /-- Constructing a bounded continuous function from a uniformly bounded continuous
function taking values in a normed group. -/
def ofNormedAddCommGroup {α : Type u} {β : Type v} [TopologicalSpace α] [SeminormedAddCommGroup β]
    (f : α → β) (Hf : Continuous f) (C : ℝ) (H : ∀ x, ‖f x‖ ≤ C) : α →ᵇ β 
goal: BoundedContinuousFunction α β

full_name: BoundedContinuousFunction.coe_ofNormedAddCommGroup
code: @[simp]
theorem coe_ofNormedAddCommGroup {α : Type u} {β : Type v} [TopologicalSpace α]
    [SeminormedAddCommGroup β] (f : α → β) (Hf : Continuous f) (C : ℝ) (H : ∀ x, ‖f x‖ ≤ C) :
    (ofNormedAddCommGroup f Hf C H : α → β) = f 
goal: ⇑(BoundedContinuousFunction.ofNormedAddCommGroup f Hf C H) = f

full_name: BoundedContinuousFunction.norm_ofNormedAddCommGroup_le
code: theorem norm_ofNormedAddCommGroup_le {f : α → β} (hfc : Continuous f) {C : ℝ} (hC : 0 ≤ C)
    (hfC : ∀ x, ‖f x‖ ≤ C) : ‖ofNormedAddCommGroup f hfc C hfC‖ ≤ C 
goal: ‖BoundedContinuousFunction.ofNormedAddCommGroup f hfc C hfC‖ ≤ C

full_name: BoundedContinuousFunction.ofNormedAddCommGroupDiscrete
code: /-- Constructing a bounded continuous function from a uniformly bounded
function on a discrete space, taking values in a normed group. -/
def ofNormedAddCommGroupDiscrete {α : Type u} {β : Type v} [TopologicalSpace α] [DiscreteTopology α]
    [SeminormedAddCommGroup β] (f : α → β) (C : ℝ) (H : ∀ x, norm (f x) ≤ C) : α →ᵇ β 
goal: BoundedContinuousFunction α β

full_name: BoundedContinuousFunction.coe_ofNormedAddCommGroupDiscrete
code: @[simp]
theorem coe_ofNormedAddCommGroupDiscrete {α : Type u} {β : Type v} [TopologicalSpace α]
    [DiscreteTopology α] [SeminormedAddCommGroup β] (f : α → β) (C : ℝ) (H : ∀ x, ‖f x‖ ≤ C) :
    (ofNormedAddCommGroupDiscrete f C H : α → β) = f 
goal: ⇑(BoundedContinuousFunction.ofNormedAddCommGroupDiscrete f C H) = f

full_name: BoundedContinuousFunction.normComp
code: /-- Taking the pointwise norm of a bounded continuous function with values in a
`SeminormedAddCommGroup` yields a bounded continuous function with values in ℝ. -/
def normComp : α →ᵇ ℝ 
goal: BoundedContinuousFunction α ℝ

full_name: BoundedContinuousFunction.coe_normComp
code: @[simp]
theorem coe_normComp : (f.normComp : α → ℝ) = norm ∘ f 
goal: ⇑f.normComp = norm ∘ ⇑f

full_name: BoundedContinuousFunction.norm_normComp
code: @[simp]
theorem norm_normComp : ‖f.normComp‖ = ‖f‖ 
goal: ‖f.normComp‖ = ‖f‖

full_name: BoundedContinuousFunction.bddAbove_range_norm_comp
code: theorem bddAbove_range_norm_comp : BddAbove <| Set.range <| norm ∘ f 
goal: BddAbove (Set.range (norm ∘ ⇑f))

full_name: BoundedContinuousFunction.norm_eq_iSup_norm
code: theorem norm_eq_iSup_norm : ‖f‖ = ⨆ x : α, ‖f x‖ 
goal: ‖f‖ = ⨆ x, ‖f x‖

full_name: BoundedContinuousFunction.instNormOneClass
code: /-- If `‖(1 : β)‖ = 1`, then `‖(1 : α →ᵇ β)‖ = 1` if `α` is nonempty. -/
instance instNormOneClass [Nonempty α] [One β] [NormOneClass β] : NormOneClass (α →ᵇ β) 
goal: NormOneClass (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instNeg
code: /-- The pointwise opposite of a bounded continuous function is again bounded continuous. -/
instance : Neg (α →ᵇ β) 
goal: Neg (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.coe_neg
code: @[simp]
theorem coe_neg : ⇑(-f) = -f 
goal: ⇑(-f) = -⇑f

full_name: BoundedContinuousFunction.neg_apply
code: theorem neg_apply : (-f) x = -f x 
goal: (-f) x = -f x

full_name: BoundedContinuousFunction.mkOfCompact_neg
code: @[simp]
theorem mkOfCompact_neg [CompactSpace α] (f : C(α, β)) : mkOfCompact (-f) = -mkOfCompact f 
goal: BoundedContinuousFunction.mkOfCompact (-f) = -BoundedContinuousFunction.mkOfCompact f

full_name: BoundedContinuousFunction.mkOfCompact_sub
code: @[simp]
theorem mkOfCompact_sub [CompactSpace α] (f g : C(α, β)) :
    mkOfCompact (f - g) = mkOfCompact f - mkOfCompact g 
goal: BoundedContinuousFunction.mkOfCompact (f - g) =
  BoundedContinuousFunction.mkOfCompact f - BoundedContinuousFunction.mkOfCompact g

full_name: BoundedContinuousFunction.coe_zsmulRec
code: @[simp]
theorem coe_zsmulRec : ∀ z, ⇑(zsmulRec (· • ·) z f) = z • ⇑f
  
goal: ⇑(zsmulRec (fun x x_1 => x • x_1) z f) = z • ⇑f

full_name: BoundedContinuousFunction.instSMulInt
code: instance instSMulInt : SMul ℤ (α →ᵇ β) 
goal: SMul ℤ (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.coe_zsmul
code: @[simp]
theorem coe_zsmul (r : ℤ) (f : α →ᵇ β) : ⇑(r • f) = r • ⇑f 
goal: ⇑(r • f) = r • ⇑f

full_name: BoundedContinuousFunction.zsmul_apply
code: @[simp]
theorem zsmul_apply (r : ℤ) (f : α →ᵇ β) (v : α) : (r • f) v = r • f v 
goal: (r • f) v = r • f v

full_name: BoundedContinuousFunction.instAddCommGroup
code: instance instAddCommGroup : AddCommGroup (α →ᵇ β) 
goal: AddCommGroup (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instSeminormedAddCommGroup
code: instance instSeminormedAddCommGroup : SeminormedAddCommGroup (α →ᵇ β) 
goal: SeminormedAddCommGroup (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instNormedAddCommGroup
code: instance instNormedAddCommGroup {α β} [TopologicalSpace α] [NormedAddCommGroup β] :
    NormedAddCommGroup (α →ᵇ β) 
goal: NormedAddCommGroup (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.nnnorm_def
code: theorem nnnorm_def : ‖f‖₊ = nndist f 0 
goal: ‖f‖₊ = nndist f 0

full_name: BoundedContinuousFunction.nnnorm_coe_le_nnnorm
code: theorem nnnorm_coe_le_nnnorm (x : α) : ‖f x‖₊ ≤ ‖f‖₊ 
goal: ‖f x‖₊ ≤ ‖f‖₊

full_name: BoundedContinuousFunction.nndist_le_two_nnnorm
code: theorem nndist_le_two_nnnorm (x y : α) : nndist (f x) (f y) ≤ 2 * ‖f‖₊ 
goal: nndist (f x) (f y) ≤ 2 * ‖f‖₊

full_name: BoundedContinuousFunction.nnnorm_le
code: /-- The `nnnorm` of a function is controlled by the supremum of the pointwise `nnnorm`s. -/
theorem nnnorm_le (C : ℝ≥0) : ‖f‖₊ ≤ C ↔ ∀ x : α, ‖f x‖₊ ≤ C 
goal: ‖f‖₊ ≤ C ↔ ∀ (x : α), ‖f x‖₊ ≤ C

full_name: BoundedContinuousFunction.nnnorm_const_le
code: theorem nnnorm_const_le (b : β) : ‖const α b‖₊ ≤ ‖b‖₊ 
goal: ‖BoundedContinuousFunction.const α b‖₊ ≤ ‖b‖₊

full_name: BoundedContinuousFunction.nnnorm_const_eq
code: @[simp]
theorem nnnorm_const_eq [Nonempty α] (b : β) : ‖const α b‖₊ = ‖b‖₊ 
goal: ‖BoundedContinuousFunction.const α b‖₊ = ‖b‖₊

full_name: BoundedContinuousFunction.nnnorm_eq_iSup_nnnorm
code: theorem nnnorm_eq_iSup_nnnorm : ‖f‖₊ = ⨆ x : α, ‖f x‖₊ 
goal: ‖f‖₊ = ⨆ x, ‖f x‖₊

full_name: BoundedContinuousFunction.abs_diff_coe_le_dist
code: theorem abs_diff_coe_le_dist : ‖f x - g x‖ ≤ dist f g 
goal: ‖f x - g x‖ ≤ dist f g

full_name: BoundedContinuousFunction.coe_le_coe_add_dist
code: theorem coe_le_coe_add_dist {f g : α →ᵇ ℝ} : f x ≤ g x + dist f g 
goal: f x ≤ g x + dist f g

full_name: BoundedContinuousFunction.norm_compContinuous_le
code: theorem norm_compContinuous_le [TopologicalSpace γ] (f : α →ᵇ β) (g : C(γ, α)) :
    ‖f.compContinuous g‖ ≤ ‖f‖ 
goal: ‖f.compContinuous g‖ ≤ ‖f‖

full_name: BoundedContinuousFunction.instSMul
code: instance instSMul : SMul 𝕜 (α →ᵇ β) 
goal: SMul 𝕜 (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.coe_smul
code: @[simp]
theorem coe_smul (c : 𝕜) (f : α →ᵇ β) : ⇑(c • f) = fun x => c • f x 
goal: ⇑(c • f) = fun x => c • f x

full_name: BoundedContinuousFunction.smul_apply
code: theorem smul_apply (c : 𝕜) (f : α →ᵇ β) (x : α) : (c • f) x = c • f x 
goal: (c • f) x = c • f x

full_name: BoundedContinuousFunction.instIsCentralScalar
code: instance instIsCentralScalar [SMul 𝕜ᵐᵒᵖ β] [IsCentralScalar 𝕜 β] : IsCentralScalar 𝕜 (α →ᵇ β) 
goal: IsCentralScalar 𝕜 (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instBoundedSMul
code: instance instBoundedSMul : BoundedSMul 𝕜 (α →ᵇ β) 
goal: BoundedSMul 𝕜 (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instMulAction
code: instance instMulAction : MulAction 𝕜 (α →ᵇ β) 
goal: MulAction 𝕜 (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instDistribMulAction
code: instance instDistribMulAction : DistribMulAction 𝕜 (α →ᵇ β) 
goal: DistribMulAction 𝕜 (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instModule
code: instance instModule : Module 𝕜 (α →ᵇ β) 
goal: Module 𝕜 (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.evalCLM
code: /-- The evaluation at a point, as a continuous linear map from `α →ᵇ β` to `β`. -/
def evalCLM (x : α) : (α →ᵇ β) →L[𝕜] β 
goal: BoundedContinuousFunction α β →L[𝕜] β

full_name: BoundedContinuousFunction.evalCLM_apply
code: @[simp]
theorem evalCLM_apply (x : α) (f : α →ᵇ β) : evalCLM 𝕜 x f = f x 
goal: (BoundedContinuousFunction.evalCLM 𝕜 x) f = f x

full_name: BoundedContinuousFunction.toContinuousMapLinearMap_apply
code: /-- The linear map forgetting that a bounded continuous function is bounded. -/
@[simps]
def toContinuousMapLinearMap : (α →ᵇ β) →ₗ[𝕜] C(α, β) 
goal: (BoundedContinuousFunction.toContinuousMapLinearMap α β 𝕜) self = self.toContinuousMap

full_name: BoundedContinuousFunction.toContinuousMapLinearMap
code: /-- The linear map forgetting that a bounded continuous function is bounded. -/
@[simps]
def toContinuousMapLinearMap : (α →ᵇ β) →ₗ[𝕜] C(α, β) 
goal: BoundedContinuousFunction α β →ₗ[𝕜] C(α, β)

full_name: BoundedContinuousFunction.instNormedSpace
code: instance instNormedSpace [NormedField 𝕜] [NormedSpace 𝕜 β] : NormedSpace 𝕜 (α →ᵇ β) 
goal: NormedSpace 𝕜 (BoundedContinuousFunction α β)

full_name: ContinuousLinearMap.compLeftContinuousBounded
code: /-- Postcomposition of bounded continuous functions into a normed module by a continuous linear map
is a continuous linear map.
Upgraded version of `ContinuousLinearMap.compLeftContinuous`, similar to `LinearMap.compLeft`. -/
protected def _root_.ContinuousLinearMap.compLeftContinuousBounded (g : β →L[𝕜] γ) :
    (α →ᵇ β) →L[𝕜] α →ᵇ γ 
goal: BoundedContinuousFunction α β →L[𝕜] BoundedContinuousFunction α γ

full_name: ContinuousLinearMap.compLeftContinuousBounded_apply
code: @[simp]
theorem _root_.ContinuousLinearMap.compLeftContinuousBounded_apply (g : β →L[𝕜] γ) (f : α →ᵇ β)
    (x : α) : (g.compLeftContinuousBounded α f) x = g (f x) 
goal: ((ContinuousLinearMap.compLeftContinuousBounded α g) f) x = g (f x)

full_name: BoundedContinuousFunction.instNonUnitalRing
code: instance instNonUnitalRing : NonUnitalRing (α →ᵇ R) 
goal: NonUnitalRing (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.instNonUnitalSeminormedRing
code: instance instNonUnitalSeminormedRing : NonUnitalSeminormedRing (α →ᵇ R) 
goal: NonUnitalSeminormedRing (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.instNonUnitalNormedRing
code: instance instNonUnitalNormedRing [NonUnitalNormedRing R] : NonUnitalNormedRing (α →ᵇ R) 
goal: NonUnitalNormedRing (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.coe_npowRec
code: @[simp]
theorem coe_npowRec (f : α →ᵇ R) : ∀ n, ⇑(npowRec n f) = (⇑f) ^ n
  
goal: ⇑(npowRec n f) = ⇑f ^ n

full_name: BoundedContinuousFunction.hasNatPow
code: instance hasNatPow : Pow (α →ᵇ R) ℕ 
goal: Pow (BoundedContinuousFunction α R) ℕ

full_name: BoundedContinuousFunction.instNatCast_1
code: instance : NatCast (α →ᵇ R) 
goal: NatCast (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.coe_natCast
code: @[simp, norm_cast]
theorem coe_natCast (n : ℕ) : ((n : α →ᵇ R) : α → R) = n 
goal: ⇑↑n = ↑n

full_name: BoundedContinuousFunction.coe_ofNat
code: @[simp, norm_cast]
theorem coe_ofNat (n : ℕ) [n.AtLeastTwo] :
    ((no_index OfNat.ofNat n : α →ᵇ R) : α → R) = OfNat.ofNat n 
goal: ⇑(OfNat.ofNat n) = OfNat.ofNat n

full_name: BoundedContinuousFunction.instIntCast_1
code: instance : IntCast (α →ᵇ R) 
goal: IntCast (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.coe_intCast
code: @[simp, norm_cast]
theorem coe_intCast (n : ℤ) : ((n : α →ᵇ R) : α → R) = n 
goal: ⇑↑n = ↑n

full_name: BoundedContinuousFunction.instRing
code: instance instRing : Ring (α →ᵇ R) 
goal: Ring (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.instSeminormedRing
code: instance instSeminormedRing : SeminormedRing (α →ᵇ R) 
goal: SeminormedRing (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.instNormedRing
code: instance instNormedRing [NormedRing R] : NormedRing (α →ᵇ R) 
goal: NormedRing (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.instCommRing
code: instance instCommRing [SeminormedCommRing R] : CommRing (α →ᵇ R) 
goal: CommRing (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.instSeminormedCommRing
code: instance instSeminormedCommRing [SeminormedCommRing R] : SeminormedCommRing (α →ᵇ R) 
goal: SeminormedCommRing (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.instNormedCommRing
code: instance instNormedCommRing [NormedCommRing R] : NormedCommRing (α →ᵇ R) 
goal: NormedCommRing (BoundedContinuousFunction α R)

full_name: BoundedContinuousFunction.C
code: /-- `BoundedContinuousFunction.const` as a `RingHom`. -/
def C : 𝕜 →+* α →ᵇ γ 
goal: 𝕜 →+* BoundedContinuousFunction α γ

full_name: BoundedContinuousFunction.instAlgebra
code: instance instAlgebra : Algebra 𝕜 (α →ᵇ γ) 
goal: Algebra 𝕜 (BoundedContinuousFunction α γ)

full_name: BoundedContinuousFunction.algebraMap_apply
code: @[simp]
theorem algebraMap_apply (k : 𝕜) (a : α) : algebraMap 𝕜 (α →ᵇ γ) k a = k • (1 : γ) 
goal: ((algebraMap 𝕜 (BoundedContinuousFunction α γ)) k) a = k • 1

full_name: BoundedContinuousFunction.instNormedAlgebra
code: instance instNormedAlgebra : NormedAlgebra 𝕜 (α →ᵇ γ) 
goal: NormedAlgebra 𝕜 (BoundedContinuousFunction α γ)

full_name: BoundedContinuousFunction.instSMul'
code: instance instSMul' : SMul (α →ᵇ 𝕜) (α →ᵇ β) 
goal: SMul (BoundedContinuousFunction α 𝕜) (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instModule'
code: instance instModule' : Module (α →ᵇ 𝕜) (α →ᵇ β) 
goal: Module (BoundedContinuousFunction α 𝕜) (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instBoundedSMul_1
code: instance : BoundedSMul (α →ᵇ 𝕜) (α →ᵇ β) 
goal: BoundedSMul (BoundedContinuousFunction α 𝕜) (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.NNReal.upper_bound
code: theorem NNReal.upper_bound {α : Type*} [TopologicalSpace α] (f : α →ᵇ ℝ≥0) (x : α) :
    f x ≤ nndist f 0 
goal: f x ≤ nndist f 0

full_name: BoundedContinuousFunction.instStarAddMonoid
code: instance instStarAddMonoid : StarAddMonoid (α →ᵇ β) 
goal: StarAddMonoid (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.coe_star
code: /-- The right-hand side of this equality can be parsed `star ∘ ⇑f` because of the
instance `Pi.instStarForAll`. Upon inspecting the goal, one sees `⊢ ↑(star f) = star ↑f`. -/
@[simp]
theorem coe_star (f : α →ᵇ β) : ⇑(star f) = star (⇑f) 
goal: ⇑(star f) = star ⇑f

full_name: BoundedContinuousFunction.star_apply
code: @[simp]
theorem star_apply (f : α →ᵇ β) (x : α) : star f x = star (f x) 
goal: (star f) x = star (f x)

full_name: BoundedContinuousFunction.instNormedStarGroup
code: instance instNormedStarGroup : NormedStarGroup (α →ᵇ β) 
goal: NormedStarGroup (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instStarModule
code: instance instStarModule : StarModule 𝕜 (α →ᵇ β) 
goal: StarModule 𝕜 (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instStarRing
code: instance instStarRing [NormedStarGroup β] : StarRing (α →ᵇ β) 
goal: StarRing (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instCstarRing
code: instance instCstarRing : CstarRing (α →ᵇ β) 
goal: CstarRing (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instPartialOrder
code: instance instPartialOrder : PartialOrder (α →ᵇ β) 
goal: PartialOrder (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instSup
code: instance instSup : Sup (α →ᵇ β) 
goal: Sup (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instInf
code: instance instInf : Inf (α →ᵇ β) 
goal: Inf (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.coe_sup
code: @[simp, norm_cast] lemma coe_sup (f g : α →ᵇ β) : ⇑(f ⊔ g) = ⇑f ⊔ ⇑g 
goal: ⇑(f ⊔ g) = ⇑f ⊔ ⇑g

full_name: BoundedContinuousFunction.coe_inf
code: @[simp, norm_cast] lemma coe_inf (f g : α →ᵇ β) : ⇑(f ⊓ g) = ⇑f ⊓ ⇑g 
goal: ⇑(f ⊓ g) = ⇑f ⊓ ⇑g

full_name: BoundedContinuousFunction.instSemilatticeSup
code: instance instSemilatticeSup : SemilatticeSup (α →ᵇ β) 
goal: SemilatticeSup (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instSemilatticeInf
code: instance instSemilatticeInf : SemilatticeInf (α →ᵇ β) 
goal: SemilatticeInf (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.instLattice
code: instance instLattice : Lattice (α →ᵇ β) 
goal: Lattice (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.coe_abs
code: @[simp, norm_cast] lemma coe_abs (f : α →ᵇ β) : ⇑|f| = |⇑f| 
goal: ⇑|f| = |⇑f|

full_name: BoundedContinuousFunction.coe_posPart
code: @[simp, norm_cast] lemma coe_posPart (f : α →ᵇ β) : ⇑f⁺ = (⇑f)⁺ 
goal: ⇑f⁺ = (⇑f)⁺

full_name: BoundedContinuousFunction.coe_negPart
code: @[simp, norm_cast] lemma coe_negPart (f : α →ᵇ β) : ⇑f⁻ = (⇑f)⁻ 
goal: ⇑f⁻ = (⇑f)⁻

full_name: BoundedContinuousFunction.instNormedLatticeAddCommGroup
code: instance instNormedLatticeAddCommGroup : NormedLatticeAddCommGroup (α →ᵇ β) 
goal: NormedLatticeAddCommGroup (BoundedContinuousFunction α β)

full_name: BoundedContinuousFunction.nnrealPart
code: /-- The nonnegative part of a bounded continuous `ℝ`-valued function as a bounded
continuous `ℝ≥0`-valued function. -/
def nnrealPart (f : α →ᵇ ℝ) : α →ᵇ ℝ≥0 
goal: BoundedContinuousFunction α ℝ≥0

full_name: BoundedContinuousFunction.nnrealPart_coeFn_eq
code: @[simp]
theorem nnrealPart_coeFn_eq (f : α →ᵇ ℝ) : ⇑f.nnrealPart = Real.toNNReal ∘ ⇑f 
goal: ⇑f.nnrealPart = Real.toNNReal ∘ ⇑f

full_name: BoundedContinuousFunction.nnnorm
code: /-- The absolute value of a bounded continuous `ℝ`-valued function as a bounded
continuous `ℝ≥0`-valued function. -/
def nnnorm (f : α →ᵇ ℝ) : α →ᵇ ℝ≥0 
goal: BoundedContinuousFunction α ℝ≥0

full_name: BoundedContinuousFunction.nnnorm_coeFn_eq
code: @[simp]
theorem nnnorm_coeFn_eq (f : α →ᵇ ℝ) : ⇑f.nnnorm = NNNorm.nnnorm ∘ ⇑f 
goal: ⇑f.nnnorm = nnnorm ∘ ⇑f

full_name: BoundedContinuousFunction.self_eq_nnrealPart_sub_nnrealPart_neg
code: /-- Decompose a bounded continuous function to its positive and negative parts. -/
theorem self_eq_nnrealPart_sub_nnrealPart_neg (f : α →ᵇ ℝ) :
    ⇑f = (↑) ∘ f.nnrealPart - (↑) ∘ (-f).nnrealPart 
goal: ⇑f = NNReal.toReal ∘ ⇑f.nnrealPart - NNReal.toReal ∘ ⇑(-f).nnrealPart

full_name: BoundedContinuousFunction.abs_self_eq_nnrealPart_add_nnrealPart_neg
code: /-- Express the absolute value of a bounded continuous function in terms of its
positive and negative parts. -/
theorem abs_self_eq_nnrealPart_add_nnrealPart_neg (f : α →ᵇ ℝ) :
    abs ∘ ⇑f = (↑) ∘ f.nnrealPart + (↑) ∘ (-f).nnrealPart 
goal: abs ∘ ⇑f = NNReal.toReal ∘ ⇑f.nnrealPart + NNReal.toReal ∘ ⇑(-f).nnrealPart

full_name: BoundedContinuousFunction.add_norm_nonneg
code: lemma add_norm_nonneg (f : α →ᵇ ℝ) :
    0 ≤ f + const _ ‖f‖ 
goal: 0 ≤ f + BoundedContinuousFunction.const α ‖f‖

full_name: BoundedContinuousFunction.norm_sub_nonneg
code: lemma norm_sub_nonneg (f : α →ᵇ ℝ) :
    0 ≤ const _ ‖f‖ - f 
goal: 0 ≤ BoundedContinuousFunction.const α ‖f‖ - f