File: Mathlib/Topology/ContinuousFunction/Compact.lean

full_name: ContinuousMap.equivBoundedOfCompact_apply
code: /-- When `α` is compact, the bounded continuous maps `α →ᵇ β` are
equivalent to `C(α, β)`.
-/
@[simps (config := .asFn)]
def equivBoundedOfCompact : C(α, β) ≃ (α →ᵇ β) 
goal: ⇑(ContinuousMap.equivBoundedOfCompact α β) = BoundedContinuousFunction.mkOfCompact

full_name: ContinuousMap.equivBoundedOfCompact_symm_apply
code: /-- When `α` is compact, the bounded continuous maps `α →ᵇ β` are
equivalent to `C(α, β)`.
-/
@[simps (config := .asFn)]
def equivBoundedOfCompact : C(α, β) ≃ (α →ᵇ β) 
goal: ⇑(ContinuousMap.equivBoundedOfCompact α β).symm = BoundedContinuousFunction.toContinuousMap

full_name: ContinuousMap.equivBoundedOfCompact
code: /-- When `α` is compact, the bounded continuous maps `α →ᵇ β` are
equivalent to `C(α, β)`.
-/
@[simps (config := .asFn)]
def equivBoundedOfCompact : C(α, β) ≃ (α →ᵇ β) 
goal: C(α, β) ≃ (α →ᵇ β)

full_name: ContinuousMap.uniformInducing_equivBoundedOfCompact
code: theorem uniformInducing_equivBoundedOfCompact : UniformInducing (equivBoundedOfCompact α β) 
goal: UniformInducing ⇑(ContinuousMap.equivBoundedOfCompact α β)

full_name: ContinuousMap.uniformEmbedding_equivBoundedOfCompact
code: theorem uniformEmbedding_equivBoundedOfCompact : UniformEmbedding (equivBoundedOfCompact α β) 
goal: UniformEmbedding ⇑(ContinuousMap.equivBoundedOfCompact α β)

full_name: ContinuousMap.addEquivBoundedOfCompact
code: /-- When `α` is compact, the bounded continuous maps `α →ᵇ 𝕜` are
additively equivalent to `C(α, 𝕜)`.
-/
-- Porting note: the following `simps` received a "maximum recursion depth" error
-- @[simps! (config := .asFn) apply symm_apply]
def addEquivBoundedOfCompact [AddMonoid β] [LipschitzAdd β] : C(α, β) ≃+ (α →ᵇ β) 
goal: C(α, β) ≃+ (α →ᵇ β)

full_name: ContinuousMap.addEquivBoundedOfCompact_symm_apply
code: @[simp]
theorem addEquivBoundedOfCompact_symm_apply [AddMonoid β] [LipschitzAdd β] :
    ⇑((addEquivBoundedOfCompact α β).symm) = toContinuousMapAddHom α β 
goal: ⇑(ContinuousMap.addEquivBoundedOfCompact α β).symm = ⇑(BoundedContinuousFunction.toContinuousMapAddHom α β)

full_name: ContinuousMap.addEquivBoundedOfCompact_apply
code: @[simp]
theorem addEquivBoundedOfCompact_apply [AddMonoid β] [LipschitzAdd β] :
    ⇑(addEquivBoundedOfCompact α β) = mkOfCompact 
goal: ⇑(ContinuousMap.addEquivBoundedOfCompact α β) = BoundedContinuousFunction.mkOfCompact

full_name: ContinuousMap.metricSpace
code: instance metricSpace : MetricSpace C(α, β) 
goal: MetricSpace C(α, β)

full_name: ContinuousMap.isometryEquivBoundedOfCompact_symm_apply
code: /-- When `α` is compact, and `β` is a metric space, the bounded continuous maps `α →ᵇ β` are
isometric to `C(α, β)`.
-/
@[simps! (config := .asFn) toEquiv apply symm_apply]
def isometryEquivBoundedOfCompact : C(α, β) ≃ᵢ (α →ᵇ β) 
goal: ⇑(ContinuousMap.isometryEquivBoundedOfCompact α β).symm = BoundedContinuousFunction.toContinuousMap

full_name: ContinuousMap.isometryEquivBoundedOfCompact
code: /-- When `α` is compact, and `β` is a metric space, the bounded continuous maps `α →ᵇ β` are
isometric to `C(α, β)`.
-/
@[simps! (config := .asFn) toEquiv apply symm_apply]
def isometryEquivBoundedOfCompact : C(α, β) ≃ᵢ (α →ᵇ β) 
goal: C(α, β) ≃ᵢ (α →ᵇ β)

full_name: ContinuousMap.isometryEquivBoundedOfCompact_toEquiv
code: /-- When `α` is compact, and `β` is a metric space, the bounded continuous maps `α →ᵇ β` are
isometric to `C(α, β)`.
-/
@[simps! (config := .asFn) toEquiv apply symm_apply]
def isometryEquivBoundedOfCompact : C(α, β) ≃ᵢ (α →ᵇ β) 
goal: (ContinuousMap.isometryEquivBoundedOfCompact α β).toEquiv = ContinuousMap.equivBoundedOfCompact α β

full_name: ContinuousMap.isometryEquivBoundedOfCompact_apply
code: /-- When `α` is compact, and `β` is a metric space, the bounded continuous maps `α →ᵇ β` are
isometric to `C(α, β)`.
-/
@[simps! (config := .asFn) toEquiv apply symm_apply]
def isometryEquivBoundedOfCompact : C(α, β) ≃ᵢ (α →ᵇ β) 
goal: ⇑(ContinuousMap.isometryEquivBoundedOfCompact α β) = BoundedContinuousFunction.mkOfCompact

full_name: BoundedContinuousFunction.dist_mkOfCompact
code: @[simp]
theorem _root_.BoundedContinuousFunction.dist_mkOfCompact (f g : C(α, β)) :
    dist (mkOfCompact f) (mkOfCompact g) = dist f g 
goal: dist (BoundedContinuousFunction.mkOfCompact f) (BoundedContinuousFunction.mkOfCompact g) = dist f g

full_name: BoundedContinuousFunction.dist_toContinuousMap
code: @[simp]
theorem _root_.BoundedContinuousFunction.dist_toContinuousMap (f g : α →ᵇ β) :
    dist f.toContinuousMap g.toContinuousMap = dist f g 
goal: dist f.toContinuousMap g.toContinuousMap = dist f g

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

full_name: ContinuousMap.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: ContinuousMap.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: ContinuousMap.dist_lt_iff_of_nonempty
code: theorem dist_lt_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: ContinuousMap.dist_lt_of_nonempty
code: theorem dist_lt_of_nonempty [Nonempty α] (w : ∀ x : α, dist (f x) (g x) < C) : dist f g < C 
goal: dist f g < C

full_name: ContinuousMap.dist_lt_iff
code: theorem dist_lt_iff (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: ContinuousMap.instCompleteSpace
code: instance [CompleteSpace β] : CompleteSpace C(α, β) 
goal: CompleteSpace C(α, β)

full_name: ContinuousMap.instNorm
code: instance : Norm C(α, E) 
goal: Norm C(α, E)

full_name: BoundedContinuousFunction.norm_mkOfCompact
code: @[simp]
theorem _root_.BoundedContinuousFunction.norm_mkOfCompact (f : C(α, E)) : ‖mkOfCompact f‖ = ‖f‖ 
goal: ‖BoundedContinuousFunction.mkOfCompact f‖ = ‖f‖

full_name: BoundedContinuousFunction.norm_toContinuousMap_eq
code: @[simp]
theorem _root_.BoundedContinuousFunction.norm_toContinuousMap_eq (f : α →ᵇ E) :
    ‖f.toContinuousMap‖ = ‖f‖ 
goal: ‖f.toContinuousMap‖ = ‖f‖

full_name: ContinuousMap.instNormedAddCommGroup
code: instance : NormedAddCommGroup C(α, E) 
goal: NormedAddCommGroup C(α, E)

full_name: ContinuousMap.instNormOneClassOfNonempty
code: instance [Nonempty α] [One E] [NormOneClass E] : NormOneClass C(α, E) 
goal: NormOneClass C(α, E)

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

full_name: ContinuousMap.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: ContinuousMap.norm_le
code: /-- The norm of a function is controlled by the supremum of the pointwise norms. -/
theorem norm_le {C : ℝ} (C0 : (0 : ℝ) ≤ C) : ‖f‖ ≤ C ↔ ∀ x : α, ‖f x‖ ≤ C 
goal: ‖f‖ ≤ C ↔ ∀ (x : α), ‖f x‖ ≤ C

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

full_name: ContinuousMap.norm_lt_iff
code: theorem norm_lt_iff {M : ℝ} (M0 : 0 < M) : ‖f‖ < M ↔ ∀ x, ‖f x‖ < M 
goal: ‖f‖ < M ↔ ∀ (x : α), ‖f x‖ < M

full_name: ContinuousMap.nnnorm_lt_iff
code: theorem nnnorm_lt_iff {M : ℝ≥0} (M0 : 0 < M) : ‖f‖₊ < M ↔ ∀ x : α, ‖f x‖₊ < M 
goal: ‖f‖₊ < M ↔ ∀ (x : α), ‖f x‖₊ < M

full_name: ContinuousMap.norm_lt_iff_of_nonempty
code: theorem norm_lt_iff_of_nonempty [Nonempty α] {M : ℝ} : ‖f‖ < M ↔ ∀ x, ‖f x‖ < M 
goal: ‖f‖ < M ↔ ∀ (x : α), ‖f x‖ < M

full_name: ContinuousMap.nnnorm_lt_iff_of_nonempty
code: theorem nnnorm_lt_iff_of_nonempty [Nonempty α] {M : ℝ≥0} : ‖f‖₊ < M ↔ ∀ x, ‖f x‖₊ < M 
goal: ‖f‖₊ < M ↔ ∀ (x : α), ‖f x‖₊ < M

full_name: ContinuousMap.apply_le_norm
code: theorem apply_le_norm (f : C(α, ℝ)) (x : α) : f x ≤ ‖f‖ 
goal: f x ≤ ‖f‖

full_name: ContinuousMap.neg_norm_le_apply
code: theorem neg_norm_le_apply (f : C(α, ℝ)) (x : α) : -‖f‖ ≤ f x 
goal: -‖f‖ ≤ f x

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

full_name: ContinuousMap.norm_restrict_mono_set
code: theorem norm_restrict_mono_set {X : Type*} [TopologicalSpace X] (f : C(X, E))
    {K L : TopologicalSpace.Compacts X} (hKL : K ≤ L) : ‖f.restrict K‖ ≤ ‖f.restrict L‖ 
goal: ‖ContinuousMap.restrict (↑K) f‖ ≤ ‖ContinuousMap.restrict (↑L) f‖

full_name: ContinuousMap.instNormedRing
code: instance : NormedRing C(α, R) 
goal: NormedRing C(α, R)

full_name: ContinuousMap.normedSpace
code: instance normedSpace : NormedSpace 𝕜 C(α, E) 
goal: NormedSpace 𝕜 C(α, E)

full_name: ContinuousMap.linearIsometryBoundedOfCompact
code: /-- When `α` is compact and `𝕜` is a normed field,
the `𝕜`-algebra of bounded continuous maps `α →ᵇ β` is
`𝕜`-linearly isometric to `C(α, β)`.
-/
def linearIsometryBoundedOfCompact : C(α, E) ≃ₗᵢ[𝕜] α →ᵇ E 
goal: C(α, E) ≃ₗᵢ[𝕜] α →ᵇ E

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

full_name: ContinuousMap.linearIsometryBoundedOfCompact_symm_apply
code: @[simp]
theorem linearIsometryBoundedOfCompact_symm_apply (f : α →ᵇ E) :
    (linearIsometryBoundedOfCompact α E 𝕜).symm f = f.toContinuousMap 
goal: (ContinuousMap.linearIsometryBoundedOfCompact α E 𝕜).symm f = f.toContinuousMap

full_name: ContinuousMap.linearIsometryBoundedOfCompact_apply_apply
code: @[simp]
theorem linearIsometryBoundedOfCompact_apply_apply (f : C(α, E)) (a : α) :
    (linearIsometryBoundedOfCompact α E 𝕜 f) a = f a 
goal: ((ContinuousMap.linearIsometryBoundedOfCompact α E 𝕜) f) a = f a

full_name: ContinuousMap.linearIsometryBoundedOfCompact_toIsometryEquiv
code: @[simp]
theorem linearIsometryBoundedOfCompact_toIsometryEquiv :
    (linearIsometryBoundedOfCompact α E 𝕜).toIsometryEquiv = isometryEquivBoundedOfCompact α E 
goal: (ContinuousMap.linearIsometryBoundedOfCompact α E 𝕜).toIsometryEquiv = ContinuousMap.isometryEquivBoundedOfCompact α E

full_name: ContinuousMap.linearIsometryBoundedOfCompact_toAddEquiv
code: @[simp] -- Porting note: adjusted LHS because `simpNF` complained it simplified.
theorem linearIsometryBoundedOfCompact_toAddEquiv :
    ((linearIsometryBoundedOfCompact α E 𝕜).toLinearEquiv : C(α, E) ≃+ (α →ᵇ E)) =
      addEquivBoundedOfCompact α E 
goal: ↑(ContinuousMap.linearIsometryBoundedOfCompact α E 𝕜).toLinearEquiv = ContinuousMap.addEquivBoundedOfCompact α E

full_name: ContinuousMap.linearIsometryBoundedOfCompact_of_compact_toEquiv
code: @[simp]
theorem linearIsometryBoundedOfCompact_of_compact_toEquiv :
    (linearIsometryBoundedOfCompact α E 𝕜).toLinearEquiv.toEquiv = equivBoundedOfCompact α E 
goal: (ContinuousMap.linearIsometryBoundedOfCompact α E 𝕜).toEquiv = ContinuousMap.equivBoundedOfCompact α E

full_name: ContinuousMap.instNormedAlgebra
code: instance : NormedAlgebra 𝕜 C(α, γ) 
goal: NormedAlgebra 𝕜 C(α, γ)

full_name: ContinuousMap.uniform_continuity
code: theorem uniform_continuity (f : C(α, β)) (ε : ℝ) (h : 0 < ε) :
    ∃ δ > 0, ∀ {x y}, dist x y < δ → dist (f x) (f y) < ε 
goal: ∃ δ > 0, ∀ {x y : α}, dist x y < δ → dist (f x) (f y) < ε

full_name: ContinuousMap.modulus
code: /-- An arbitrarily chosen modulus of uniform continuity for a given function `f` and `ε > 0`. -/
def modulus (f : C(α, β)) (ε : ℝ) (h : 0 < ε) : ℝ 
goal: ℝ

full_name: ContinuousMap.modulus_pos
code: theorem modulus_pos (f : C(α, β)) {ε : ℝ} {h : 0 < ε} : 0 < f.modulus ε h 
goal: 0 < f.modulus ε h

full_name: ContinuousMap.dist_lt_of_dist_lt_modulus
code: theorem dist_lt_of_dist_lt_modulus (f : C(α, β)) (ε : ℝ) (h : 0 < ε) {a b : α}
    (w : dist a b < f.modulus ε h) : dist (f a) (f b) < ε 
goal: dist (f a) (f b) < ε

full_name: ContinuousLinearMap.compLeftContinuousCompact
code: /-- Postcomposition of continuous functions into a normed module by a continuous linear map is a
continuous linear map.
Transferred version of `ContinuousLinearMap.compLeftContinuousBounded`,
upgraded version of `ContinuousLinearMap.compLeftContinuous`,
similar to `LinearMap.compLeft`. -/
protected def ContinuousLinearMap.compLeftContinuousCompact (g : β →L[𝕜] γ) :
    C(X, β) →L[𝕜] C(X, γ) 
goal: C(X, β) →L[𝕜] C(X, γ)

full_name: ContinuousLinearMap.toLinear_compLeftContinuousCompact
code: @[simp]
theorem ContinuousLinearMap.toLinear_compLeftContinuousCompact (g : β →L[𝕜] γ) :
    (g.compLeftContinuousCompact X : C(X, β) →ₗ[𝕜] C(X, γ)) = g.compLeftContinuous 𝕜 X 
goal: ↑(ContinuousLinearMap.compLeftContinuousCompact X g) = ContinuousLinearMap.compLeftContinuous 𝕜 X g

full_name: ContinuousLinearMap.compLeftContinuousCompact_apply
code: @[simp]
theorem ContinuousLinearMap.compLeftContinuousCompact_apply (g : β →L[𝕜] γ) (f : C(X, β)) (x : X) :
    g.compLeftContinuousCompact X f x = g (f x) 
goal: ((ContinuousLinearMap.compLeftContinuousCompact X g) f) x = g (f x)

full_name: ContinuousMap.compRightContinuousMap
code: /-- Precomposition by a continuous map is itself a continuous map between spaces of continuous maps.
-/
def compRightContinuousMap {X Y : Type*} (T : Type*) [TopologicalSpace X] [CompactSpace X]
    [TopologicalSpace Y] [CompactSpace Y] [MetricSpace T] (f : C(X, Y)) : C(C(Y, T), C(X, T)) 
goal: C(C(Y, T), C(X, T))

full_name: ContinuousMap.compRightContinuousMap_apply
code: @[simp]
theorem compRightContinuousMap_apply {X Y : Type*} (T : Type*) [TopologicalSpace X]
    [CompactSpace X] [TopologicalSpace Y] [CompactSpace Y] [MetricSpace T] (f : C(X, Y))
    (g : C(Y, T)) : (compRightContinuousMap T f) g = g.comp f 
goal: (ContinuousMap.compRightContinuousMap T f) g = g.comp f

full_name: ContinuousMap.compRightHomeomorph
code: /-- Precomposition by a homeomorphism is itself a homeomorphism between spaces of continuous maps.
-/
def compRightHomeomorph {X Y : Type*} (T : Type*) [TopologicalSpace X] [CompactSpace X]
    [TopologicalSpace Y] [CompactSpace Y] [MetricSpace T] (f : X ≃ₜ Y) : C(Y, T) ≃ₜ C(X, T) 
goal: C(Y, T) ≃ₜ C(X, T)

full_name: ContinuousMap.compRightAlgHom_continuous
code: theorem compRightAlgHom_continuous {X Y : Type*} (R A : Type*) [TopologicalSpace X]
    [CompactSpace X] [TopologicalSpace Y] [CompactSpace Y] [CommSemiring R] [Semiring A]
    [MetricSpace A] [TopologicalSemiring A] [Algebra R A] (f : C(X, Y)) :
    Continuous (compRightAlgHom R A f) 
goal: Continuous ⇑(ContinuousMap.compRightAlgHom R A f)

full_name: ContinuousMap.summable_of_locally_summable_norm
code: theorem summable_of_locally_summable_norm {ι : Type*} {F : ι → C(X, E)}
    (hF : ∀ K : Compacts X, Summable fun i => ‖(F i).restrict K‖) : Summable F 
goal: Summable F

full_name: BoundedContinuousFunction.mkOfCompact_star
code: theorem _root_.BoundedContinuousFunction.mkOfCompact_star [CompactSpace α] (f : C(α, β)) :
    mkOfCompact (star f) = star (mkOfCompact f) 
goal: BoundedContinuousFunction.mkOfCompact (star f) = star (BoundedContinuousFunction.mkOfCompact f)

full_name: ContinuousMap.instNormedStarGroup
code: instance [CompactSpace α] : NormedStarGroup C(α, β) 
goal: NormedStarGroup C(α, β)

full_name: ContinuousMap.instCstarRing
code: instance [CompactSpace α] [CstarRing β] : CstarRing C(α, β) 
goal: CstarRing C(α, β)