l3lab/ntp-mathlib huggingface dataset:
instance : BoundedSMul 𝕜 (α →ᵇ β) where
  dist_smul_pair' c f₁ f₂ := by
    rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
    intro x
    refine' (dist_smul_pair c (f₁ x) (f₂ x)).trans _
    

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁶ : PseudoMetricSpace 𝕜
inst✝⁵ : TopologicalSpace α
inst✝⁴ : PseudoMetricSpace β
inst✝³ : Zero 𝕜
inst✝² : Zero β
inst✝¹ : SMul 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c : 𝕜
f₁ f₂ : α →ᵇ β
x : α
⊢ dist c 0 * dist (f₁ x) (f₂ x) ≤ dist c 0 * dist f₁ f₂

Next tactic:
exact mul_le_mul_of_nonneg_left (dist_coe_le_dist x) dist_nonneg
instance : BoundedSMul 𝕜 (α →ᵇ β) where
  dist_smul_pair' c f₁ f₂ := by
    rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
    intro x
    refine' (dist_smul_pair c (f₁ x) (f₂ x)).trans _
    exact mul_le_mul_of_nonneg_left (dist_coe_le_dist x) dist_nonneg
  dist_pair_smul' c₁ c₂ f := by
    

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁶ : PseudoMetricSpace 𝕜
inst✝⁵ : TopologicalSpace α
inst✝⁴ : PseudoMetricSpace β
inst✝³ : Zero 𝕜
inst✝² : Zero β
inst✝¹ : SMul 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c₁ c₂ : 𝕜
f : α →ᵇ β
⊢ dist (c₁ • f) (c₂ • f) ≤ dist c₁ c₂ * dist f 0

Next tactic:
rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
instance : BoundedSMul 𝕜 (α →ᵇ β) where
  dist_smul_pair' c f₁ f₂ := by
    rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
    intro x
    refine' (dist_smul_pair c (f₁ x) (f₂ x)).trans _
    exact mul_le_mul_of_nonneg_left (dist_coe_le_dist x) dist_nonneg
  dist_pair_smul' c₁ c₂ f := by
    rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
    

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁶ : PseudoMetricSpace 𝕜
inst✝⁵ : TopologicalSpace α
inst✝⁴ : PseudoMetricSpace β
inst✝³ : Zero 𝕜
inst✝² : Zero β
inst✝¹ : SMul 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c₁ c₂ : 𝕜
f : α →ᵇ β
⊢ ∀ (x : α), dist ((c₁ • f) x) ((c₂ • f) x) ≤ dist c₁ c₂ * dist f 0

Next tactic:
intro x
instance : BoundedSMul 𝕜 (α →ᵇ β) where
  dist_smul_pair' c f₁ f₂ := by
    rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
    intro x
    refine' (dist_smul_pair c (f₁ x) (f₂ x)).trans _
    exact mul_le_mul_of_nonneg_left (dist_coe_le_dist x) dist_nonneg
  dist_pair_smul' c₁ c₂ f := by
    rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
    intro x
    

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁶ : PseudoMetricSpace 𝕜
inst✝⁵ : TopologicalSpace α
inst✝⁴ : PseudoMetricSpace β
inst✝³ : Zero 𝕜
inst✝² : Zero β
inst✝¹ : SMul 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c₁ c₂ : 𝕜
f : α →ᵇ β
x : α
⊢ dist ((c₁ • f) x) ((c₂ • f) x) ≤ dist c₁ c₂ * dist f 0

Next tactic:
refine' (dist_pair_smul c₁ c₂ (f x)).trans _
instance : BoundedSMul 𝕜 (α →ᵇ β) where
  dist_smul_pair' c f₁ f₂ := by
    rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
    intro x
    refine' (dist_smul_pair c (f₁ x) (f₂ x)).trans _
    exact mul_le_mul_of_nonneg_left (dist_coe_le_dist x) dist_nonneg
  dist_pair_smul' c₁ c₂ f := by
    rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
    intro x
    refine' (dist_pair_smul c₁ c₂ (f x)).trans _
    

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁶ : PseudoMetricSpace 𝕜
inst✝⁵ : TopologicalSpace α
inst✝⁴ : PseudoMetricSpace β
inst✝³ : Zero 𝕜
inst✝² : Zero β
inst✝¹ : SMul 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c₁ c₂ : 𝕜
f : α →ᵇ β
x : α
⊢ dist c₁ c₂ * dist (f x) 0 ≤ dist c₁ c₂ * dist f 0

Next tactic:
refine' mul_le_mul_of_nonneg_left _ dist_nonneg
instance : BoundedSMul 𝕜 (α →ᵇ β) where
  dist_smul_pair' c f₁ f₂ := by
    rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
    intro x
    refine' (dist_smul_pair c (f₁ x) (f₂ x)).trans _
    exact mul_le_mul_of_nonneg_left (dist_coe_le_dist x) dist_nonneg
  dist_pair_smul' c₁ c₂ f := by
    rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
    intro x
    refine' (dist_pair_smul c₁ c₂ (f x)).trans _
    refine' mul_le_mul_of_nonneg_left _ dist_nonneg
    

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁶ : PseudoMetricSpace 𝕜
inst✝⁵ : TopologicalSpace α
inst✝⁴ : PseudoMetricSpace β
inst✝³ : Zero 𝕜
inst✝² : Zero β
inst✝¹ : SMul 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c₁ c₂ : 𝕜
f : α →ᵇ β
x : α
⊢ dist (f x) 0 ≤ dist f 0

Next tactic:
convert dist_coe_le_dist (β := β) x
instance : BoundedSMul 𝕜 (α →ᵇ β) where
  dist_smul_pair' c f₁ f₂ := by
    rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
    intro x
    refine' (dist_smul_pair c (f₁ x) (f₂ x)).trans _
    exact mul_le_mul_of_nonneg_left (dist_coe_le_dist x) dist_nonneg
  dist_pair_smul' c₁ c₂ f := by
    rw [dist_le (mul_nonneg dist_nonneg dist_nonneg)]
    intro x
    refine' (dist_pair_smul c₁ c₂ (f x)).trans _
    refine' mul_le_mul_of_nonneg_left _ dist_nonneg
    convert dist_coe_le_dist (β := β) x
    

Proof state:
case h.e'_3.h.e'_4
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁶ : PseudoMetricSpace 𝕜
inst✝⁵ : TopologicalSpace α
inst✝⁴ : PseudoMetricSpace β
inst✝³ : Zero 𝕜
inst✝² : Zero β
inst✝¹ : SMul 𝕜 β
inst✝ : BoundedSMul 𝕜 β
c₁ c₂ : 𝕜
f : α →ᵇ β
x : α
⊢ 0 = 0 x

Next tactic:
simp
instance normedSpace [NormedField 𝕜] [NormedSpace 𝕜 β] : NormedSpace 𝕜 (α →ᵇ β) :=
  ⟨fun c f => by
    

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : SeminormedAddCommGroup β
f✝ g : α →ᵇ β
x : α
C : ℝ
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 β
c : 𝕜
f : α →ᵇ β
⊢ ‖c • f‖ ≤ ‖c‖ * ‖f‖

Next tactic:
refine' norm_ofNormedAddCommGroup_le _ (mul_nonneg (norm_nonneg _) (norm_nonneg _)) _
instance normedSpace [NormedField 𝕜] [NormedSpace 𝕜 β] : NormedSpace 𝕜 (α →ᵇ β) :=
  ⟨fun c f => by
    refine' norm_ofNormedAddCommGroup_le _ (mul_nonneg (norm_nonneg _) (norm_nonneg _)) _
    

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : SeminormedAddCommGroup β
f✝ g : α →ᵇ β
x : α
C : ℝ
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 β
c : 𝕜
f : α →ᵇ β
⊢ ∀ (x : α), ‖(c • ⇑f.toContinuousMap) x‖ ≤ ‖c‖ * ‖f‖

Next tactic:
exact fun x =>
      norm_smul c (f x) ▸ mul_le_mul_of_nonneg_left (f.norm_coe_le_norm _) (norm_nonneg _)
/-- 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[𝕜] α →ᵇ γ :=
  LinearMap.mkContinuous
    { toFun := fun f =>
        ofNormedAddCommGroup (g ∘ f) (g.continuous.comp f.continuous) (‖g‖ * ‖f‖) fun x =>
          g.le_op_norm_of_le (f.norm_coe_le_norm x)
      map_add' := fun f g => by 

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁵ : TopologicalSpace α
inst✝⁴ : SeminormedAddCommGroup β
f✝ g✝¹ : α →ᵇ β
x : α
C : ℝ
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 β
inst✝¹ : SeminormedAddCommGroup γ
inst✝ : NormedSpace 𝕜 γ
g✝ : β →L[𝕜] γ
f g : α →ᵇ β
⊢ (fun f =>
        ofNormedAddCommGroup (⇑g✝ ∘ ⇑f) (_ : Continuous (⇑g✝ ∘ ⇑f)) (‖g✝‖ * ‖f‖)
          (_ : ∀ (x : α), ‖g✝ (f x)‖ ≤ ‖g✝‖ * ‖f‖))
      (f + g) =
    (fun f =>
          ofNormedAddCommGroup (⇑g✝ ∘ ⇑f) (_ : Continuous (⇑g✝ ∘ ⇑f)) (‖g✝‖ * ‖f‖)
            (_ : ∀ (x : α), ‖g✝ (f x)‖ ≤ ‖g✝‖ * ‖f‖))
        f +
      (fun f =>
          ofNormedAddCommGroup (⇑g✝ ∘ ⇑f) (_ : Continuous (⇑g✝ ∘ ⇑f)) (‖g✝‖ * ‖f‖)
            (_ : ∀ (x : α), ‖g✝ (f x)‖ ≤ ‖g✝‖ * ‖f‖))
        g

Next tactic:
ext
/-- 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[𝕜] α →ᵇ γ :=
  LinearMap.mkContinuous
    { toFun := fun f =>
        ofNormedAddCommGroup (g ∘ f) (g.continuous.comp f.continuous) (‖g‖ * ‖f‖) fun x =>
          g.le_op_norm_of_le (f.norm_coe_le_norm x)
      map_add' := fun f g => by ext; 

Proof state:
case h
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁵ : TopologicalSpace α
inst✝⁴ : SeminormedAddCommGroup β
f✝ g✝¹ : α →ᵇ β
x : α
C : ℝ
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 β
inst✝¹ : SeminormedAddCommGroup γ
inst✝ : NormedSpace 𝕜 γ
g✝ : β →L[𝕜] γ
f g : α →ᵇ β
x✝ : α
⊢ ((fun f =>
          ofNormedAddCommGroup (⇑g✝ ∘ ⇑f) (_ : Continuous (⇑g✝ ∘ ⇑f)) (‖g✝‖ * ‖f‖)
            (_ : ∀ (x : α), ‖g✝ (f x)‖ ≤ ‖g✝‖ * ‖f‖))
        (f + g))
      x✝ =
    ((fun f =>
            ofNormedAddCommGroup (⇑g✝ ∘ ⇑f) (_ : Continuous (⇑g✝ ∘ ⇑f)) (‖g✝‖ * ‖f‖)
              (_ : ∀ (x : α), ‖g✝ (f x)‖ ≤ ‖g✝‖ * ‖f‖))
          f +
        (fun f =>
            ofNormedAddCommGroup (⇑g✝ ∘ ⇑f) (_ : Continuous (⇑g✝ ∘ ⇑f)) (‖g✝‖ * ‖f‖)
              (_ : ∀ (x : α), ‖g✝ (f x)‖ ≤ ‖g✝‖ * ‖f‖))
          g)
      x✝

Next tactic:
simp
/-- 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[𝕜] α →ᵇ γ :=
  LinearMap.mkContinuous
    { toFun := fun f =>
        ofNormedAddCommGroup (g ∘ f) (g.continuous.comp f.continuous) (‖g‖ * ‖f‖) fun x =>
          g.le_op_norm_of_le (f.norm_coe_le_norm x)
      map_add' := fun f g => by ext; simp
      map_smul' := fun c f => by 

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁵ : TopologicalSpace α
inst✝⁴ : SeminormedAddCommGroup β
f✝ g✝ : α →ᵇ β
x : α
C : ℝ
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 β
inst✝¹ : SeminormedAddCommGroup γ
inst✝ : NormedSpace 𝕜 γ
g : β →L[𝕜] γ
c : 𝕜
f : α →ᵇ β
⊢ AddHom.toFun
      {
        toFun := fun f =>
          ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖) (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖),
        map_add' :=
          (_ :
            ∀ (f g_1 : α →ᵇ β),
              (fun f =>
                    ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                      (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖))
                  (f + g_1) =
                (fun f =>
                      ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                        (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖))
                    f +
                  (fun f =>
                      ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                        (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖))
                    g_1) }
      (c • f) =
    (RingHom.id 𝕜) c •
      AddHom.toFun
        {
          toFun := fun f =>
            ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
              (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖),
          map_add' :=
            (_ :
              ∀ (f g_1 : α →ᵇ β),
                (fun f =>
                      ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                        (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖))
                    (f + g_1) =
                  (fun f =>
                        ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                          (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖))
                      f +
                    (fun f =>
                        ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                          (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖))
                      g_1) }
        f

Next tactic:
ext
/-- 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[𝕜] α →ᵇ γ :=
  LinearMap.mkContinuous
    { toFun := fun f =>
        ofNormedAddCommGroup (g ∘ f) (g.continuous.comp f.continuous) (‖g‖ * ‖f‖) fun x =>
          g.le_op_norm_of_le (f.norm_coe_le_norm x)
      map_add' := fun f g => by ext; simp
      map_smul' := fun c f => by ext; 

Proof state:
case h
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁵ : TopologicalSpace α
inst✝⁴ : SeminormedAddCommGroup β
f✝ g✝ : α →ᵇ β
x : α
C : ℝ
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 β
inst✝¹ : SeminormedAddCommGroup γ
inst✝ : NormedSpace 𝕜 γ
g : β →L[𝕜] γ
c : 𝕜
f : α →ᵇ β
x✝ : α
⊢ (AddHom.toFun
        {
          toFun := fun f =>
            ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
              (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖),
          map_add' :=
            (_ :
              ∀ (f g_1 : α →ᵇ β),
                (fun f =>
                      ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                        (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖))
                    (f + g_1) =
                  (fun f =>
                        ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                          (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖))
                      f +
                    (fun f =>
                        ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                          (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖))
                      g_1) }
        (c • f))
      x✝ =
    ((RingHom.id 𝕜) c •
        AddHom.toFun
          {
            toFun := fun f =>
              ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖),
            map_add' :=
              (_ :
                ∀ (f g_1 : α →ᵇ β),
                  (fun f =>
                        ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                          (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖))
                      (f + g_1) =
                    (fun f =>
                          ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                            (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖))
                        f +
                      (fun f =>
                          ofNormedAddCommGroup (⇑g ∘ ⇑f) (_ : Continuous (⇑g ∘ ⇑f)) (‖g‖ * ‖f‖)
                            (_ : ∀ (x : α), ‖g (f x)‖ ≤ ‖g‖ * ‖f‖))
                        g_1) }
          f)
      x✝

Next tactic:
simp
/-- 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[𝕜] α →ᵇ γ :=
  LinearMap.mkContinuous
    { toFun := fun f =>
        ofNormedAddCommGroup (g ∘ f) (g.continuous.comp f.continuous) (‖g‖ * ‖f‖) fun x =>
          g.le_op_norm_of_le (f.norm_coe_le_norm x)
      map_add' := fun f g => by ext; simp
      map_smul' := fun c f => by ext; simp } ‖g‖ fun f =>
        norm_ofNormedAddCommGroup_le _ (mul_nonneg (norm_nonneg g) (norm_nonneg f))
          (fun x => by 

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁵ : TopologicalSpace α
inst✝⁴ : SeminormedAddCommGroup β
f✝ g✝ : α →ᵇ β
x✝ : α
C : ℝ
inst✝³ : NontriviallyNormedField 𝕜
inst✝² : NormedSpace 𝕜 β
inst✝¹ : SeminormedAddCommGroup γ
inst✝ : NormedSpace 𝕜 γ
g : β →L[𝕜] γ
f : α →ᵇ β
x : α
⊢ ‖(⇑g ∘ ⇑f) x‖ ≤ ‖g‖ * ‖f‖

Next tactic:
exact g.le_op_norm_of_le (f.norm_coe_le_norm x)
@[simp]
theorem coe_npowRec (f : α →ᵇ R) : ∀ n, ⇑(npowRec n f) = (⇑f) ^ n
  | 0 => by 

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
R : Type u_2
inst✝ : SeminormedRing R
f : α →ᵇ R
⊢ ⇑(npowRec 0 f) = ⇑f ^ 0

Next tactic:
rw [npowRec, pow_zero, coe_one]
@[simp]
theorem coe_npowRec (f : α →ᵇ R) : ∀ n, ⇑(npowRec n f) = (⇑f) ^ n
  | 0 => by rw [npowRec, pow_zero, coe_one]
  | n + 1 => by 

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
R : Type u_2
inst✝ : SeminormedRing R
f : α →ᵇ R
n : ℕ
⊢ ⇑(npowRec (n + 1) f) = ⇑f ^ (n + 1)

Next tactic:
rw [npowRec, pow_succ, coe_mul, coe_npowRec f n]
instance hasNatPow : Pow (α →ᵇ R) ℕ where
  pow f n :=
    { toContinuousMap := f.toContinuousMap ^ n
      map_bounded' := by 

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
R : Type u_2
inst✝ : SeminormedRing R
f : α →ᵇ R
n : ℕ
⊢ ∃ C,
    ∀ (x y : α),
      dist (ContinuousMap.toFun (f.toContinuousMap ^ n) x) (ContinuousMap.toFun (f.toContinuousMap ^ n) y) ≤ C

Next tactic:
simpa [coe_npowRec] using (npowRec n f).map_bounded'
@[simp]
theorem algebraMap_apply (k : 𝕜) (a : α) : algebraMap 𝕜 (α →ᵇ γ) k a = k • (1 : γ) := by
  

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁵ : NormedField 𝕜
inst✝⁴ : TopologicalSpace α
inst✝³ : SeminormedAddCommGroup β
inst✝² : NormedSpace 𝕜 β
inst✝¹ : NormedRing γ
inst✝ : NormedAlgebra 𝕜 γ
f g : α →ᵇ γ
x : α
c k : 𝕜
a : α
⊢ ((algebraMap 𝕜 (α →ᵇ γ)) k) a = k • 1

Next tactic:
rw [Algebra.algebraMap_eq_smul_one]
@[simp]
theorem algebraMap_apply (k : 𝕜) (a : α) : algebraMap 𝕜 (α →ᵇ γ) k a = k • (1 : γ) := by
  rw [Algebra.algebraMap_eq_smul_one]
  

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁵ : NormedField 𝕜
inst✝⁴ : TopologicalSpace α
inst✝³ : SeminormedAddCommGroup β
inst✝² : NormedSpace 𝕜 β
inst✝¹ : NormedRing γ
inst✝ : NormedAlgebra 𝕜 γ
f g : α →ᵇ γ
x : α
c k : 𝕜
a : α
⊢ (k • 1) a = k • 1

Next tactic:
rfl
theorem NNReal.upper_bound {α : Type*} [TopologicalSpace α] (f : α →ᵇ ℝ≥0) (x : α) :
    f x ≤ nndist f 0 := by
  

Proof state:
F : Type u_1
α✝ : Type u
β : Type v
γ : Type w
α : Type u_2
inst✝ : TopologicalSpace α
f : α →ᵇ ℝ≥0
x : α
⊢ f x ≤ nndist f 0

Next tactic:
have key : nndist (f x) ((0 : α →ᵇ ℝ≥0) x) ≤ nndist f 0 := @dist_coe_le_dist α ℝ≥0 _ _ f 0 x
theorem NNReal.upper_bound {α : Type*} [TopologicalSpace α] (f : α →ᵇ ℝ≥0) (x : α) :
    f x ≤ nndist f 0 := by
  have key : nndist (f x) ((0 : α →ᵇ ℝ≥0) x) ≤ nndist f 0 := @dist_coe_le_dist α ℝ≥0 _ _ f 0 x
  

Proof state:
F : Type u_1
α✝ : Type u
β : Type v
γ : Type w
α : Type u_2
inst✝ : TopologicalSpace α
f : α →ᵇ ℝ≥0
x : α
key : nndist (f x) (0 x) ≤ nndist f 0
⊢ f x ≤ nndist f 0

Next tactic:
simp only [coe_zero, Pi.zero_apply] at key
theorem NNReal.upper_bound {α : Type*} [TopologicalSpace α] (f : α →ᵇ ℝ≥0) (x : α) :
    f x ≤ nndist f 0 := by
  have key : nndist (f x) ((0 : α →ᵇ ℝ≥0) x) ≤ nndist f 0 := @dist_coe_le_dist α ℝ≥0 _ _ f 0 x
  simp only [coe_zero, Pi.zero_apply] at key
  

Proof state:
F : Type u_1
α✝ : Type u
β : Type v
γ : Type w
α : Type u_2
inst✝ : TopologicalSpace α
f : α →ᵇ ℝ≥0
x : α
key : nndist (f x) 0 ≤ nndist f 0
⊢ f x ≤ nndist f 0

Next tactic:
rwa [NNReal.nndist_zero_eq_val' (f x)] at key
instance : NormedStarGroup (α →ᵇ β) where
  norm_star f := by 

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
𝕜 : Type u_2
inst✝⁷ : NormedField 𝕜
inst✝⁶ : StarRing 𝕜
inst✝⁵ : TopologicalSpace α
inst✝⁴ : SeminormedAddCommGroup β
inst✝³ : StarAddMonoid β
inst✝² : NormedStarGroup β
inst✝¹ : NormedSpace 𝕜 β
inst✝ : StarModule 𝕜 β
f : α →ᵇ β
⊢ ‖star f‖ = ‖f‖

Next tactic:
simp only [norm_eq, star_apply, norm_star]
instance : CstarRing (α →ᵇ β) where
  norm_star_mul_self := by
    

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNormedRing β
inst✝¹ : StarRing β
inst✝ : CstarRing β
⊢ ∀ {x : α →ᵇ β}, ‖star x * x‖ = ‖x‖ * ‖x‖

Next tactic:
intro f
instance : CstarRing (α →ᵇ β) where
  norm_star_mul_self := by
    intro f
    

Proof state:
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNormedRing β
inst✝¹ : StarRing β
inst✝ : CstarRing β
f : α →ᵇ β
⊢ ‖star f * f‖ = ‖f‖ * ‖f‖

Next tactic:
refine' le_antisymm _ _
instance : CstarRing (α →ᵇ β) where
  norm_star_mul_self := by
    intro f
    refine' le_antisymm _ _
    · 

Proof state:
case refine'_1
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNormedRing β
inst✝¹ : StarRing β
inst✝ : CstarRing β
f : α →ᵇ β
⊢ ‖star f * f‖ ≤ ‖f‖ * ‖f‖

Next tactic:
rw [← sq, norm_le (sq_nonneg _)]
instance : CstarRing (α →ᵇ β) where
  norm_star_mul_self := by
    intro f
    refine' le_antisymm _ _
    · rw [← sq, norm_le (sq_nonneg _)]
      

Proof state:
case refine'_1
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNormedRing β
inst✝¹ : StarRing β
inst✝ : CstarRing β
f : α →ᵇ β
⊢ ∀ (x : α), ‖(star f * f) x‖ ≤ ‖f‖ ^ 2

Next tactic:
dsimp [star_apply]
instance : CstarRing (α →ᵇ β) where
  norm_star_mul_self := by
    intro f
    refine' le_antisymm _ _
    · rw [← sq, norm_le (sq_nonneg _)]
      dsimp [star_apply]
      

Proof state:
case refine'_1
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNormedRing β
inst✝¹ : StarRing β
inst✝ : CstarRing β
f : α →ᵇ β
⊢ ∀ (x : α), ‖star (f x) * f x‖ ≤ ‖f‖ ^ 2

Next tactic:
intro x
instance : CstarRing (α →ᵇ β) where
  norm_star_mul_self := by
    intro f
    refine' le_antisymm _ _
    · rw [← sq, norm_le (sq_nonneg _)]
      dsimp [star_apply]
      intro x
      

Proof state:
case refine'_1
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNormedRing β
inst✝¹ : StarRing β
inst✝ : CstarRing β
f : α →ᵇ β
x : α
⊢ ‖star (f x) * f x‖ ≤ ‖f‖ ^ 2

Next tactic:
rw [CstarRing.norm_star_mul_self, ← sq]
instance : CstarRing (α →ᵇ β) where
  norm_star_mul_self := by
    intro f
    refine' le_antisymm _ _
    · rw [← sq, norm_le (sq_nonneg _)]
      dsimp [star_apply]
      intro x
      rw [CstarRing.norm_star_mul_self, ← sq]
      

Proof state:
case refine'_1
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNormedRing β
inst✝¹ : StarRing β
inst✝ : CstarRing β
f : α →ᵇ β
x : α
⊢ ‖f x‖ ^ 2 ≤ ‖f‖ ^ 2

Next tactic:
refine' sq_le_sq' _ _
instance : CstarRing (α →ᵇ β) where
  norm_star_mul_self := by
    intro f
    refine' le_antisymm _ _
    · rw [← sq, norm_le (sq_nonneg _)]
      dsimp [star_apply]
      intro x
      rw [CstarRing.norm_star_mul_self, ← sq]
      refine' sq_le_sq' _ _
      · 

Proof state:
case refine'_1.refine'_1
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNormedRing β
inst✝¹ : StarRing β
inst✝ : CstarRing β
f : α →ᵇ β
x : α
⊢ -‖f‖ ≤ ‖f x‖

Next tactic:
linarith [norm_nonneg (f x), norm_nonneg f]
instance : CstarRing (α →ᵇ β) where
  norm_star_mul_self := by
    intro f
    refine' le_antisymm _ _
    · rw [← sq, norm_le (sq_nonneg _)]
      dsimp [star_apply]
      intro x
      rw [CstarRing.norm_star_mul_self, ← sq]
      refine' sq_le_sq' _ _
      · linarith [norm_nonneg (f x), norm_nonneg f]
      · 

Proof state:
case refine'_1.refine'_2
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNormedRing β
inst✝¹ : StarRing β
inst✝ : CstarRing β
f : α →ᵇ β
x : α
⊢ ‖f x‖ ≤ ‖f‖

Next tactic:
exact norm_coe_le_norm f x
instance : CstarRing (α →ᵇ β) where
  norm_star_mul_self := by
    intro f
    refine' le_antisymm _ _
    · rw [← sq, norm_le (sq_nonneg _)]
      dsimp [star_apply]
      intro x
      rw [CstarRing.norm_star_mul_self, ← sq]
      refine' sq_le_sq' _ _
      · linarith [norm_nonneg (f x), norm_nonneg f]
      · exact norm_coe_le_norm f x
    · 

Proof state:
case refine'_2
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : NonUnitalNormedRing β
inst✝¹ : StarRing β
inst✝ : CstarRing β
f : α →ᵇ β
⊢ ‖f‖ * ‖f‖ ≤ ‖star f * f‖

Next tactic:
rw [← sq, ← Real.le_sqrt (norm_nonneg _) (norm_nonneg _), norm_le (Real.sqrt_nonneg _)]