l3lab/ntp-mathlib huggingface dataset:
/-- A closed ball is closed in the weak-* topology. We don't have a name for `E →SL[σ] F` with
weak-* topology in `mathlib`, so we use an equivalent condition (see `isClosed_induced_iff'`). -/
theorem is_weak_closed_closedBall (f₀ : E' →SL[σ₁₂] F) (r : ℝ) ⦃f : E' →SL[σ₁₂] F⦄
    (hf : ⇑f ∈ closure (((↑) : (E' →SL[σ₁₂] F) → E' → F) '' closedBall f₀ r)) :
    f ∈ closedBall f₀ r := by
  have hr : 0 ≤ r := nonempty_closedBall.1 (nonempty_image_iff.1 (closure_nonempty_iff.1 ⟨_, hf⟩))
  refine' mem_closedBall_iff_norm.2 (op_norm_le_bound _ hr fun x => _)
  

Proof state:
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedAddCommGroup F
inst✝¹¹ : NormedAddCommGroup G
inst✝¹⁰ : NormedAddCommGroup Fₗ
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NontriviallyNormedField 𝕜₂
inst✝⁷ : NontriviallyNormedField 𝕜₃
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜₂ F
inst✝⁴ : NormedSpace 𝕜₃ G
inst✝³ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f✝ g : E →SL[σ₁₂] F
x✝ y z : E
E' : Type u_11
inst✝² : SeminormedAddCommGroup E'
inst✝¹ : NormedSpace 𝕜 E'
inst✝ : RingHomIsometric σ₁₂
f₀ : E' →SL[σ₁₂] F
r : ℝ
f : E' →SL[σ₁₂] F
hf : ⇑f ∈ closure (FunLike.coe '' closedBall f₀ r)
hr : 0 ≤ r
x : E'
⊢ ‖(f - f₀) x‖ ≤ r * ‖x‖

Next tactic:
have : IsClosed { g : E' → F | ‖g x - f₀ x‖ ≤ r * ‖x‖ } :=
    isClosed_Iic.preimage ((@continuous_apply E' (fun _ => F) _ x).sub continuous_const).norm
/-- A closed ball is closed in the weak-* topology. We don't have a name for `E →SL[σ] F` with
weak-* topology in `mathlib`, so we use an equivalent condition (see `isClosed_induced_iff'`). -/
theorem is_weak_closed_closedBall (f₀ : E' →SL[σ₁₂] F) (r : ℝ) ⦃f : E' →SL[σ₁₂] F⦄
    (hf : ⇑f ∈ closure (((↑) : (E' →SL[σ₁₂] F) → E' → F) '' closedBall f₀ r)) :
    f ∈ closedBall f₀ r := by
  have hr : 0 ≤ r := nonempty_closedBall.1 (nonempty_image_iff.1 (closure_nonempty_iff.1 ⟨_, hf⟩))
  refine' mem_closedBall_iff_norm.2 (op_norm_le_bound _ hr fun x => _)
  have : IsClosed { g : E' → F | ‖g x - f₀ x‖ ≤ r * ‖x‖ } :=
    isClosed_Iic.preimage ((@continuous_apply E' (fun _ => F) _ x).sub continuous_const).norm
  

Proof state:
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedAddCommGroup F
inst✝¹¹ : NormedAddCommGroup G
inst✝¹⁰ : NormedAddCommGroup Fₗ
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NontriviallyNormedField 𝕜₂
inst✝⁷ : NontriviallyNormedField 𝕜₃
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜₂ F
inst✝⁴ : NormedSpace 𝕜₃ G
inst✝³ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f✝ g : E →SL[σ₁₂] F
x✝ y z : E
E' : Type u_11
inst✝² : SeminormedAddCommGroup E'
inst✝¹ : NormedSpace 𝕜 E'
inst✝ : RingHomIsometric σ₁₂
f₀ : E' →SL[σ₁₂] F
r : ℝ
f : E' →SL[σ₁₂] F
hf : ⇑f ∈ closure (FunLike.coe '' closedBall f₀ r)
hr : 0 ≤ r
x : E'
this : IsClosed {g | ‖g x - f₀ x‖ ≤ r * ‖x‖}
⊢ ‖(f - f₀) x‖ ≤ r * ‖x‖

Next tactic:
refine' this.closure_subset_iff.2 (image_subset_iff.2 fun g hg => _) hf
/-- A closed ball is closed in the weak-* topology. We don't have a name for `E →SL[σ] F` with
weak-* topology in `mathlib`, so we use an equivalent condition (see `isClosed_induced_iff'`). -/
theorem is_weak_closed_closedBall (f₀ : E' →SL[σ₁₂] F) (r : ℝ) ⦃f : E' →SL[σ₁₂] F⦄
    (hf : ⇑f ∈ closure (((↑) : (E' →SL[σ₁₂] F) → E' → F) '' closedBall f₀ r)) :
    f ∈ closedBall f₀ r := by
  have hr : 0 ≤ r := nonempty_closedBall.1 (nonempty_image_iff.1 (closure_nonempty_iff.1 ⟨_, hf⟩))
  refine' mem_closedBall_iff_norm.2 (op_norm_le_bound _ hr fun x => _)
  have : IsClosed { g : E' → F | ‖g x - f₀ x‖ ≤ r * ‖x‖ } :=
    isClosed_Iic.preimage ((@continuous_apply E' (fun _ => F) _ x).sub continuous_const).norm
  refine' this.closure_subset_iff.2 (image_subset_iff.2 fun g hg => _) hf
  

Proof state:
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedAddCommGroup F
inst✝¹¹ : NormedAddCommGroup G
inst✝¹⁰ : NormedAddCommGroup Fₗ
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NontriviallyNormedField 𝕜₂
inst✝⁷ : NontriviallyNormedField 𝕜₃
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜₂ F
inst✝⁴ : NormedSpace 𝕜₃ G
inst✝³ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f✝ g✝ : E →SL[σ₁₂] F
x✝ y z : E
E' : Type u_11
inst✝² : SeminormedAddCommGroup E'
inst✝¹ : NormedSpace 𝕜 E'
inst✝ : RingHomIsometric σ₁₂
f₀ : E' →SL[σ₁₂] F
r : ℝ
f : E' →SL[σ₁₂] F
hf : ⇑f ∈ closure (FunLike.coe '' closedBall f₀ r)
hr : 0 ≤ r
x : E'
this : IsClosed {g | ‖g x - f₀ x‖ ≤ r * ‖x‖}
g : E' →SL[σ₁₂] F
hg : g ∈ closedBall f₀ r
⊢ g ∈ FunLike.coe ⁻¹' {g | ‖g x - f₀ x‖ ≤ r * ‖x‖}

Next tactic:
exact (g - f₀).le_of_op_norm_le (mem_closedBall_iff_norm.1 hg) _
/-- Extension of a continuous linear map `f : E →SL[σ₁₂] F`, with `E` a normed space and `F` a
complete normed space, along a uniform and dense embedding `e : E →L[𝕜] Fₗ`.  -/
def extend : Fₗ →SL[σ₁₂] F :=
  -- extension of `f` is continuous
  have cont := (uniformContinuous_uniformly_extend h_e h_dense f.uniformContinuous).continuous
  -- extension of `f` agrees with `f` on the domain of the embedding `e`
  have eq := uniformly_extend_of_ind h_e h_dense f.uniformContinuous
  { toFun := (h_e.denseInducing h_dense).extend f
    map_add' := by
      

Proof state:
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup Fₗ
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕜₂
inst✝⁵ : NontriviallyNormedField 𝕜₃
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace 𝕜₂ F
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f g : E →SL[σ₁₂] F
x y z : E
inst✝ : CompleteSpace F
e : E →L[𝕜] Fₗ
h_dense : DenseRange ⇑e
h_e : UniformInducing ⇑e
cont : Continuous (DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f)
eq : ∀ (b : E), DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e b) = f b
⊢ ∀ (x y : Fₗ),
    DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (x + y) =
      DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) x + DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) y

Next tactic:
refine' h_dense.induction_on₂ _ _
/-- Extension of a continuous linear map `f : E →SL[σ₁₂] F`, with `E` a normed space and `F` a
complete normed space, along a uniform and dense embedding `e : E →L[𝕜] Fₗ`.  -/
def extend : Fₗ →SL[σ₁₂] F :=
  -- extension of `f` is continuous
  have cont := (uniformContinuous_uniformly_extend h_e h_dense f.uniformContinuous).continuous
  -- extension of `f` agrees with `f` on the domain of the embedding `e`
  have eq := uniformly_extend_of_ind h_e h_dense f.uniformContinuous
  { toFun := (h_e.denseInducing h_dense).extend f
    map_add' := by
      refine' h_dense.induction_on₂ _ _
      · 

Proof state:
case refine'_1
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup Fₗ
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕜₂
inst✝⁵ : NontriviallyNormedField 𝕜₃
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace 𝕜₂ F
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f g : E →SL[σ₁₂] F
x y z : E
inst✝ : CompleteSpace F
e : E →L[𝕜] Fₗ
h_dense : DenseRange ⇑e
h_e : UniformInducing ⇑e
cont : Continuous (DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f)
eq : ∀ (b : E), DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e b) = f b
⊢ IsClosed
    {q |
      DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (q.1 + q.2) =
        DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) q.1 + DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) q.2}

Next tactic:
exact isClosed_eq (cont.comp continuous_add)
          ((cont.comp continuous_fst).add (cont.comp continuous_snd))
/-- Extension of a continuous linear map `f : E →SL[σ₁₂] F`, with `E` a normed space and `F` a
complete normed space, along a uniform and dense embedding `e : E →L[𝕜] Fₗ`.  -/
def extend : Fₗ →SL[σ₁₂] F :=
  -- extension of `f` is continuous
  have cont := (uniformContinuous_uniformly_extend h_e h_dense f.uniformContinuous).continuous
  -- extension of `f` agrees with `f` on the domain of the embedding `e`
  have eq := uniformly_extend_of_ind h_e h_dense f.uniformContinuous
  { toFun := (h_e.denseInducing h_dense).extend f
    map_add' := by
      refine' h_dense.induction_on₂ _ _
      · exact isClosed_eq (cont.comp continuous_add)
          ((cont.comp continuous_fst).add (cont.comp continuous_snd))
      · 

Proof state:
case refine'_2
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup Fₗ
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕜₂
inst✝⁵ : NontriviallyNormedField 𝕜₃
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace 𝕜₂ F
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f g : E →SL[σ₁₂] F
x y z : E
inst✝ : CompleteSpace F
e : E →L[𝕜] Fₗ
h_dense : DenseRange ⇑e
h_e : UniformInducing ⇑e
cont : Continuous (DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f)
eq : ∀ (b : E), DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e b) = f b
⊢ ∀ (a₁ a₂ : E),
    DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e a₁ + e a₂) =
      DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e a₁) + DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e a₂)

Next tactic:
intro x y
/-- Extension of a continuous linear map `f : E →SL[σ₁₂] F`, with `E` a normed space and `F` a
complete normed space, along a uniform and dense embedding `e : E →L[𝕜] Fₗ`.  -/
def extend : Fₗ →SL[σ₁₂] F :=
  -- extension of `f` is continuous
  have cont := (uniformContinuous_uniformly_extend h_e h_dense f.uniformContinuous).continuous
  -- extension of `f` agrees with `f` on the domain of the embedding `e`
  have eq := uniformly_extend_of_ind h_e h_dense f.uniformContinuous
  { toFun := (h_e.denseInducing h_dense).extend f
    map_add' := by
      refine' h_dense.induction_on₂ _ _
      · exact isClosed_eq (cont.comp continuous_add)
          ((cont.comp continuous_fst).add (cont.comp continuous_snd))
      · intro x y
        

Proof state:
case refine'_2
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup Fₗ
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕜₂
inst✝⁵ : NontriviallyNormedField 𝕜₃
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace 𝕜₂ F
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f g : E →SL[σ₁₂] F
x✝ y✝ z : E
inst✝ : CompleteSpace F
e : E →L[𝕜] Fₗ
h_dense : DenseRange ⇑e
h_e : UniformInducing ⇑e
cont : Continuous (DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f)
eq : ∀ (b : E), DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e b) = f b
x y : E
⊢ DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e x + e y) =
    DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e x) + DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e y)

Next tactic:
simp only [eq, ← e.map_add]
/-- Extension of a continuous linear map `f : E →SL[σ₁₂] F`, with `E` a normed space and `F` a
complete normed space, along a uniform and dense embedding `e : E →L[𝕜] Fₗ`.  -/
def extend : Fₗ →SL[σ₁₂] F :=
  -- extension of `f` is continuous
  have cont := (uniformContinuous_uniformly_extend h_e h_dense f.uniformContinuous).continuous
  -- extension of `f` agrees with `f` on the domain of the embedding `e`
  have eq := uniformly_extend_of_ind h_e h_dense f.uniformContinuous
  { toFun := (h_e.denseInducing h_dense).extend f
    map_add' := by
      refine' h_dense.induction_on₂ _ _
      · exact isClosed_eq (cont.comp continuous_add)
          ((cont.comp continuous_fst).add (cont.comp continuous_snd))
      · intro x y
        simp only [eq, ← e.map_add]
        

Proof state:
case refine'_2
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup Fₗ
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕜₂
inst✝⁵ : NontriviallyNormedField 𝕜₃
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace 𝕜₂ F
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f g : E →SL[σ₁₂] F
x✝ y✝ z : E
inst✝ : CompleteSpace F
e : E →L[𝕜] Fₗ
h_dense : DenseRange ⇑e
h_e : UniformInducing ⇑e
cont : Continuous (DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f)
eq : ∀ (b : E), DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e b) = f b
x y : E
⊢ f (x + y) = f x + f y

Next tactic:
exact f.map_add _ _
/-- Extension of a continuous linear map `f : E →SL[σ₁₂] F`, with `E` a normed space and `F` a
complete normed space, along a uniform and dense embedding `e : E →L[𝕜] Fₗ`.  -/
def extend : Fₗ →SL[σ₁₂] F :=
  -- extension of `f` is continuous
  have cont := (uniformContinuous_uniformly_extend h_e h_dense f.uniformContinuous).continuous
  -- extension of `f` agrees with `f` on the domain of the embedding `e`
  have eq := uniformly_extend_of_ind h_e h_dense f.uniformContinuous
  { toFun := (h_e.denseInducing h_dense).extend f
    map_add' := by
      refine' h_dense.induction_on₂ _ _
      · exact isClosed_eq (cont.comp continuous_add)
          ((cont.comp continuous_fst).add (cont.comp continuous_snd))
      · intro x y
        simp only [eq, ← e.map_add]
        exact f.map_add _ _
    map_smul' := fun k => by
      

Proof state:
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup Fₗ
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕜₂
inst✝⁵ : NontriviallyNormedField 𝕜₃
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace 𝕜₂ F
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f g : E →SL[σ₁₂] F
x y z : E
inst✝ : CompleteSpace F
e : E →L[𝕜] Fₗ
h_dense : DenseRange ⇑e
h_e : UniformInducing ⇑e
cont : Continuous (DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f)
eq : ∀ (b : E), DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e b) = f b
k : 𝕜
⊢ ∀ (x : Fₗ),
    AddHom.toFun
        { toFun := DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f,
          map_add' :=
            (_ :
              ∀ (b₁ b₂ : Fₗ),
                DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (b₁ + b₂) =
                  DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₁ +
                    DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₂) }
        (k • x) =
      σ₁₂ k •
        AddHom.toFun
          { toFun := DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f,
            map_add' :=
              (_ :
                ∀ (b₁ b₂ : Fₗ),
                  DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (b₁ + b₂) =
                    DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₁ +
                      DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₂) }
          x

Next tactic:
refine' fun b => h_dense.induction_on b _ _
/-- Extension of a continuous linear map `f : E →SL[σ₁₂] F`, with `E` a normed space and `F` a
complete normed space, along a uniform and dense embedding `e : E →L[𝕜] Fₗ`.  -/
def extend : Fₗ →SL[σ₁₂] F :=
  -- extension of `f` is continuous
  have cont := (uniformContinuous_uniformly_extend h_e h_dense f.uniformContinuous).continuous
  -- extension of `f` agrees with `f` on the domain of the embedding `e`
  have eq := uniformly_extend_of_ind h_e h_dense f.uniformContinuous
  { toFun := (h_e.denseInducing h_dense).extend f
    map_add' := by
      refine' h_dense.induction_on₂ _ _
      · exact isClosed_eq (cont.comp continuous_add)
          ((cont.comp continuous_fst).add (cont.comp continuous_snd))
      · intro x y
        simp only [eq, ← e.map_add]
        exact f.map_add _ _
    map_smul' := fun k => by
      refine' fun b => h_dense.induction_on b _ _
      · 

Proof state:
case refine'_1
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup Fₗ
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕜₂
inst✝⁵ : NontriviallyNormedField 𝕜₃
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace 𝕜₂ F
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f g : E →SL[σ₁₂] F
x y z : E
inst✝ : CompleteSpace F
e : E →L[𝕜] Fₗ
h_dense : DenseRange ⇑e
h_e : UniformInducing ⇑e
cont : Continuous (DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f)
eq : ∀ (b : E), DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e b) = f b
k : 𝕜
b : Fₗ
⊢ IsClosed
    {b |
      AddHom.toFun
          { toFun := DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f,
            map_add' :=
              (_ :
                ∀ (b₁ b₂ : Fₗ),
                  DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (b₁ + b₂) =
                    DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₁ +
                      DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₂) }
          (k • b) =
        σ₁₂ k •
          AddHom.toFun
            { toFun := DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f,
              map_add' :=
                (_ :
                  ∀ (b₁ b₂ : Fₗ),
                    DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (b₁ + b₂) =
                      DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₁ +
                        DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₂) }
            b}

Next tactic:
exact isClosed_eq (cont.comp (continuous_const_smul _))
          ((continuous_const_smul _).comp cont)
/-- Extension of a continuous linear map `f : E →SL[σ₁₂] F`, with `E` a normed space and `F` a
complete normed space, along a uniform and dense embedding `e : E →L[𝕜] Fₗ`.  -/
def extend : Fₗ →SL[σ₁₂] F :=
  -- extension of `f` is continuous
  have cont := (uniformContinuous_uniformly_extend h_e h_dense f.uniformContinuous).continuous
  -- extension of `f` agrees with `f` on the domain of the embedding `e`
  have eq := uniformly_extend_of_ind h_e h_dense f.uniformContinuous
  { toFun := (h_e.denseInducing h_dense).extend f
    map_add' := by
      refine' h_dense.induction_on₂ _ _
      · exact isClosed_eq (cont.comp continuous_add)
          ((cont.comp continuous_fst).add (cont.comp continuous_snd))
      · intro x y
        simp only [eq, ← e.map_add]
        exact f.map_add _ _
    map_smul' := fun k => by
      refine' fun b => h_dense.induction_on b _ _
      · exact isClosed_eq (cont.comp (continuous_const_smul _))
          ((continuous_const_smul _).comp cont)
      · 

Proof state:
case refine'_2
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup Fₗ
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕜₂
inst✝⁵ : NontriviallyNormedField 𝕜₃
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace 𝕜₂ F
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f g : E →SL[σ₁₂] F
x y z : E
inst✝ : CompleteSpace F
e : E →L[𝕜] Fₗ
h_dense : DenseRange ⇑e
h_e : UniformInducing ⇑e
cont : Continuous (DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f)
eq : ∀ (b : E), DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e b) = f b
k : 𝕜
b : Fₗ
⊢ ∀ (a : E),
    AddHom.toFun
        { toFun := DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f,
          map_add' :=
            (_ :
              ∀ (b₁ b₂ : Fₗ),
                DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (b₁ + b₂) =
                  DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₁ +
                    DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₂) }
        (k • e a) =
      σ₁₂ k •
        AddHom.toFun
          { toFun := DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f,
            map_add' :=
              (_ :
                ∀ (b₁ b₂ : Fₗ),
                  DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (b₁ + b₂) =
                    DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₁ +
                      DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₂) }
          (e a)

Next tactic:
intro x
/-- Extension of a continuous linear map `f : E →SL[σ₁₂] F`, with `E` a normed space and `F` a
complete normed space, along a uniform and dense embedding `e : E →L[𝕜] Fₗ`.  -/
def extend : Fₗ →SL[σ₁₂] F :=
  -- extension of `f` is continuous
  have cont := (uniformContinuous_uniformly_extend h_e h_dense f.uniformContinuous).continuous
  -- extension of `f` agrees with `f` on the domain of the embedding `e`
  have eq := uniformly_extend_of_ind h_e h_dense f.uniformContinuous
  { toFun := (h_e.denseInducing h_dense).extend f
    map_add' := by
      refine' h_dense.induction_on₂ _ _
      · exact isClosed_eq (cont.comp continuous_add)
          ((cont.comp continuous_fst).add (cont.comp continuous_snd))
      · intro x y
        simp only [eq, ← e.map_add]
        exact f.map_add _ _
    map_smul' := fun k => by
      refine' fun b => h_dense.induction_on b _ _
      · exact isClosed_eq (cont.comp (continuous_const_smul _))
          ((continuous_const_smul _).comp cont)
      · intro x
        

Proof state:
case refine'_2
𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type u_3
E : Type u_4
Eₗ : Type u_5
F : Type u_6
Fₗ : Type u_7
G : Type u_8
Gₗ : Type u_9
𝓕 : Type u_10
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedAddCommGroup Fₗ
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NontriviallyNormedField 𝕜₂
inst✝⁵ : NontriviallyNormedField 𝕜₃
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedSpace 𝕜₂ F
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Fₗ
c : 𝕜
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
f g : E →SL[σ₁₂] F
x✝ y z : E
inst✝ : CompleteSpace F
e : E →L[𝕜] Fₗ
h_dense : DenseRange ⇑e
h_e : UniformInducing ⇑e
cont : Continuous (DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f)
eq : ∀ (b : E), DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (e b) = f b
k : 𝕜
b : Fₗ
x : E
⊢ AddHom.toFun
      { toFun := DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f,
        map_add' :=
          (_ :
            ∀ (b₁ b₂ : Fₗ),
              DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (b₁ + b₂) =
                DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₁ +
                  DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₂) }
      (k • e x) =
    σ₁₂ k •
      AddHom.toFun
        { toFun := DenseInducing.extend (_ : DenseInducing ⇑e) ⇑f,
          map_add' :=
            (_ :
              ∀ (b₁ b₂ : Fₗ),
                DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) (b₁ + b₂) =
                  DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₁ +
                    DenseInducing.extend (_ : DenseInducing ⇑e) (⇑f) b₂) }
        (e x)

Next tactic:
rw [← map_smul]