Theorem: hasFDerivAt_of_tendstoUniformlyOnFilter
File: Mathlib/Analysis/Calculus/UniformLimitsDeriv.lean

tactic: rw [hasFDerivAt_iff_tendsto]
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
⊢ HasFDerivAt g (g' x) x

tactic: suffices
  Tendsto (fun y : ι × E => ‖y.2 - x‖⁻¹ * ‖g y.2 - g x - (g' x) (y.2 - x)‖)
    (l.curry (𝓝 x)) (𝓝 0) by
  rw [Metric.tendsto_nhds] at this ⊢
  intro ε hε
  specialize this ε hε
  rw [eventually_curry_iff] at this
  simp only at this
  exact (eventually_const.mp this).mono (by simp only [imp_self, forall_const])
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
⊢ Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖g x' - g x - ↑(g' x) (x' - x)‖) (𝓝 x) (𝓝 0)

tactic: conv =>
  congr
  ext
  rw [← abs_norm, ← abs_inv, ← @IsROrC.norm_ofReal 𝕜 _ _, IsROrC.ofReal_inv, ← norm_smul]
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
⊢ Tendsto (fun y => ‖y.snd - x‖⁻¹ * ‖g y.snd - g x - ↑(g' x) (y.snd - x)‖) (curry l (𝓝 x)) (𝓝 0)

tactic: rw [← tendsto_zero_iff_norm_tendsto_zero]
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
⊢ Tendsto (fun x_1 => ‖(↑‖x_1.snd - x‖)⁻¹ • (g x_1.snd - g x - ↑(g' x) (x_1.snd - x))‖) (curry l (𝓝 x)) (𝓝 0)

tactic: have :
  (fun a : ι × E => (‖a.2 - x‖⁻¹ : 𝕜) • (g a.2 - g x - (g' x) (a.2 - x))) =
    ((fun a : ι × E => (‖a.2 - x‖⁻¹ : 𝕜) • (g a.2 - g x - (f a.1 a.2 - f a.1 x))) +
        fun a : ι × E =>
        (‖a.2 - x‖⁻¹ : 𝕜) • (f a.1 a.2 - f a.1 x - ((f' a.1 x) a.2 - (f' a.1 x) x))) +
      fun a : ι × E => (‖a.2 - x‖⁻¹ : 𝕜) • (f' a.1 x - g' x) (a.2 - x) := by
  ext; simp only [Pi.add_apply]; rw [← smul_add, ← smul_add]; congr
  simp only [map_sub, sub_add_sub_cancel, ContinuousLinearMap.coe_sub', Pi.sub_apply]
  abel
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
⊢ Tendsto (fun x_1 => (↑‖x_1.snd - x‖)⁻¹ • (g x_1.snd - g x - ↑(g' x) (x_1.snd - x))) (curry l (𝓝 x)) (𝓝 0)

tactic: simp_rw [this]
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
⊢ Tendsto (fun x_1 => (↑‖x_1.snd - x‖)⁻¹ • (g x_1.snd - g x - ↑(g' x) (x_1.snd - x))) (curry l (𝓝 x)) (𝓝 0)

tactic: have : 𝓝 (0 : G) = 𝓝 (0 + 0 + 0)
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
⊢ Tendsto
    (((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x))
    (curry l (𝓝 x)) (𝓝 0)

tactic: simp only [add_zero]
state_before: case this
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
⊢ 𝓝 0 = 𝓝 (0 + 0 + 0)

ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ Tendsto
    (((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x))
    (curry l (𝓝 x)) (𝓝 0)

tactic: rw [this]
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ Tendsto
    (((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x))
    (curry l (𝓝 x)) (𝓝 0)

tactic: refine' Tendsto.add (Tendsto.add _ _) _
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ Tendsto
    (((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x))
    (curry l (𝓝 x)) (𝓝 (0 + 0 + 0))

tactic: simp only
state_before: case refine'_1
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ Tendsto (fun x_1 => (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) x_1) (curry l (𝓝 x))
    (𝓝 0)

case refine'_2
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ Tendsto
    (fun x_1 => (fun a => (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) x_1)
    (curry l (𝓝 x)) (𝓝 0)

case refine'_3
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ Tendsto (fun x_1 => (fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)) x_1) (curry l (𝓝 x)) (𝓝 0)

tactic: rw [Metric.tendsto_nhds] at this ⊢
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this : Tendsto (fun y => ‖y.snd - x‖⁻¹ * ‖g y.snd - g x - ↑(g' x) (y.snd - x)‖) (curry l (𝓝 x)) (𝓝 0)
⊢ Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖g x' - g x - ↑(g' x) (x' - x)‖) (𝓝 x) (𝓝 0)

tactic: intro ε hε
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this :
  ∀ (ε : ℝ),
    ε > 0 → ∀ᶠ (x_1 : ι × E) in curry l (𝓝 x), dist (‖x_1.snd - x‖⁻¹ * ‖g x_1.snd - g x - ↑(g' x) (x_1.snd - x)‖) 0 < ε
⊢ ∀ (ε : ℝ), ε > 0 → ∀ᶠ (x_1 : E) in 𝓝 x, dist (‖x_1 - x‖⁻¹ * ‖g x_1 - g x - ↑(g' x) (x_1 - x)‖) 0 < ε

tactic: specialize this ε hε
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this :
  ∀ (ε : ℝ),
    ε > 0 → ∀ᶠ (x_1 : ι × E) in curry l (𝓝 x), dist (‖x_1.snd - x‖⁻¹ * ‖g x_1.snd - g x - ↑(g' x) (x_1.snd - x)‖) 0 < ε
ε : ℝ
hε : ε > 0
⊢ ∀ᶠ (x_1 : E) in 𝓝 x, dist (‖x_1 - x‖⁻¹ * ‖g x_1 - g x - ↑(g' x) (x_1 - x)‖) 0 < ε

tactic: rw [eventually_curry_iff] at this
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
ε : ℝ
hε : ε > 0
this : ∀ᶠ (x_1 : ι × E) in curry l (𝓝 x), dist (‖x_1.snd - x‖⁻¹ * ‖g x_1.snd - g x - ↑(g' x) (x_1.snd - x)‖) 0 < ε
⊢ ∀ᶠ (x_1 : E) in 𝓝 x, dist (‖x_1 - x‖⁻¹ * ‖g x_1 - g x - ↑(g' x) (x_1 - x)‖) 0 < ε

tactic: simp only at this
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
ε : ℝ
hε : ε > 0
this :
  ∀ᶠ (x_1 : ι) in l,
    ∀ᶠ (y : E) in 𝓝 x, dist (‖(x_1, y).snd - x‖⁻¹ * ‖g (x_1, y).snd - g x - ↑(g' x) ((x_1, y).snd - x)‖) 0 < ε
⊢ ∀ᶠ (x_1 : E) in 𝓝 x, dist (‖x_1 - x‖⁻¹ * ‖g x_1 - g x - ↑(g' x) (x_1 - x)‖) 0 < ε

tactic: exact (eventually_const.mp this).mono (by simp only [imp_self, forall_const])
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
ε : ℝ
hε : ε > 0
this : ∀ᶠ (x_1 : ι) in l, ∀ᶠ (y : E) in 𝓝 x, dist (‖y - x‖⁻¹ * ‖g y - g x - ↑(g' x) (y - x)‖) 0 < ε
⊢ ∀ᶠ (x_1 : E) in 𝓝 x, dist (‖x_1 - x‖⁻¹ * ‖g x_1 - g x - ↑(g' x) (x_1 - x)‖) 0 < ε

tactic: simp only [imp_self, forall_const]
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
ε : ℝ
hε : ε > 0
this : ∀ᶠ (x_1 : ι) in l, ∀ᶠ (y : E) in 𝓝 x, dist (‖y - x‖⁻¹ * ‖g y - g x - ↑(g' x) (y - x)‖) 0 < ε
⊢ ∀ (x_1 : E),
    dist (‖x_1 - x‖⁻¹ * ‖g x_1 - g x - ↑(g' x) (x_1 - x)‖) 0 < ε →
      dist (‖x_1 - x‖⁻¹ * ‖g x_1 - g x - ↑(g' x) (x_1 - x)‖) 0 < ε

tactic: ext
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
⊢ (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)

tactic: simp only [Pi.add_apply]
state_before: case h
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
x✝ : ι × E
⊢ (↑‖x✝.snd - x‖)⁻¹ • (g x✝.snd - g x - ↑(g' x) (x✝.snd - x)) =
    (((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
          (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
        fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x))
      x✝

tactic: rw [← smul_add, ← smul_add]
state_before: case h
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
x✝ : ι × E
⊢ (↑‖x✝.snd - x‖)⁻¹ • (g x✝.snd - g x - ↑(g' x) (x✝.snd - x)) =
    (↑‖x✝.snd - x‖)⁻¹ • (g x✝.snd - g x - (f x✝.fst x✝.snd - f x✝.fst x)) +
        (↑‖x✝.snd - x‖)⁻¹ • (f x✝.fst x✝.snd - f x✝.fst x - (↑(f' x✝.fst x) x✝.snd - ↑(f' x✝.fst x) x)) +
      (↑‖x✝.snd - x‖)⁻¹ • ↑(f' x✝.fst x - g' x) (x✝.snd - x)

tactic: congr
state_before: case h
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
x✝ : ι × E
⊢ (↑‖x✝.snd - x‖)⁻¹ • (g x✝.snd - g x - ↑(g' x) (x✝.snd - x)) =
    (↑‖x✝.snd - x‖)⁻¹ •
      (g x✝.snd - g x - (f x✝.fst x✝.snd - f x✝.fst x) +
          (f x✝.fst x✝.snd - f x✝.fst x - (↑(f' x✝.fst x) x✝.snd - ↑(f' x✝.fst x) x)) +
        ↑(f' x✝.fst x - g' x) (x✝.snd - x))

tactic: simp only [map_sub, sub_add_sub_cancel, ContinuousLinearMap.coe_sub', Pi.sub_apply]
state_before: case h.e_a
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
x✝ : ι × E
⊢ g x✝.snd - g x - ↑(g' x) (x✝.snd - x) =
    g x✝.snd - g x - (f x✝.fst x✝.snd - f x✝.fst x) +
        (f x✝.fst x✝.snd - f x✝.fst x - (↑(f' x✝.fst x) x✝.snd - ↑(f' x✝.fst x) x)) +
      ↑(f' x✝.fst x - g' x) (x✝.snd - x)

tactic: abel
state_before: case h.e_a
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
x✝ : ι × E
⊢ g x✝.snd - g x - (↑(g' x) x✝.snd - ↑(g' x) x) =
    g x✝.snd - g x - (↑(f' x✝.fst x) x✝.snd - ↑(f' x✝.fst x) x) +
      (↑(f' x✝.fst x) x✝.snd - ↑(g' x) x✝.snd - (↑(f' x✝.fst x) x - ↑(g' x) x))

tactic: have := difference_quotients_converge_uniformly hf' hf hfg
state_before: case refine'_1
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ Tendsto (fun x_1 => (↑‖x_1.snd - x‖)⁻¹ • (g x_1.snd - g x - (f x_1.fst x_1.snd - f x_1.fst x))) (curry l (𝓝 x)) (𝓝 0)

tactic: rw [Metric.tendstoUniformlyOnFilter_iff] at this
state_before: case refine'_1
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
this :
  TendstoUniformlyOnFilter (fun n y => (↑‖y - x‖)⁻¹ • (f n y - f n x)) (fun y => (↑‖y - x‖)⁻¹ • (g y - g x)) l (𝓝 x)
⊢ Tendsto (fun x_1 => (↑‖x_1.snd - x‖)⁻¹ • (g x_1.snd - g x - (f x_1.fst x_1.snd - f x_1.fst x))) (curry l (𝓝 x)) (𝓝 0)

tactic: rw [Metric.tendsto_nhds]
state_before: case refine'_1
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
this :
  ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x,
        dist ((↑‖n.snd - x‖)⁻¹ • (g n.snd - g x)) ((↑‖n.snd - x‖)⁻¹ • (f n.fst n.snd - f n.fst x)) < ε
⊢ Tendsto (fun x_1 => (↑‖x_1.snd - x‖)⁻¹ • (g x_1.snd - g x - (f x_1.fst x_1.snd - f x_1.fst x))) (curry l (𝓝 x)) (𝓝 0)

tactic: intro ε hε
state_before: case refine'_1
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
this :
  ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x,
        dist ((↑‖n.snd - x‖)⁻¹ • (g n.snd - g x)) ((↑‖n.snd - x‖)⁻¹ • (f n.fst n.snd - f n.fst x)) < ε
⊢ ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (x_1 : ι × E) in curry l (𝓝 x),
        dist ((↑‖x_1.snd - x‖)⁻¹ • (g x_1.snd - g x - (f x_1.fst x_1.snd - f x_1.fst x))) 0 < ε

tactic: apply ((this ε hε).filter_mono curry_le_prod).mono
state_before: case refine'_1
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
this :
  ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x,
        dist ((↑‖n.snd - x‖)⁻¹ • (g n.snd - g x)) ((↑‖n.snd - x‖)⁻¹ • (f n.fst n.snd - f n.fst x)) < ε
ε : ℝ
hε : ε > 0
⊢ ∀ᶠ (x_1 : ι × E) in curry l (𝓝 x),
    dist ((↑‖x_1.snd - x‖)⁻¹ • (g x_1.snd - g x - (f x_1.fst x_1.snd - f x_1.fst x))) 0 < ε

tactic: intro n hn
state_before: case refine'_1
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
this :
  ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x,
        dist ((↑‖n.snd - x‖)⁻¹ • (g n.snd - g x)) ((↑‖n.snd - x‖)⁻¹ • (f n.fst n.snd - f n.fst x)) < ε
ε : ℝ
hε : ε > 0
⊢ ∀ (x_1 : ι × E),
    dist ((↑‖x_1.snd - x‖)⁻¹ • (g x_1.snd - g x)) ((↑‖x_1.snd - x‖)⁻¹ • (f x_1.fst x_1.snd - f x_1.fst x)) < ε →
      dist ((↑‖x_1.snd - x‖)⁻¹ • (g x_1.snd - g x - (f x_1.fst x_1.snd - f x_1.fst x))) 0 < ε

tactic: rw [dist_eq_norm] at hn ⊢
state_before: case refine'_1
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
this :
  ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x,
        dist ((↑‖n.snd - x‖)⁻¹ • (g n.snd - g x)) ((↑‖n.snd - x‖)⁻¹ • (f n.fst n.snd - f n.fst x)) < ε
ε : ℝ
hε : ε > 0
n : ι × E
hn : dist ((↑‖n.snd - x‖)⁻¹ • (g n.snd - g x)) ((↑‖n.snd - x‖)⁻¹ • (f n.fst n.snd - f n.fst x)) < ε
⊢ dist ((↑‖n.snd - x‖)⁻¹ • (g n.snd - g x - (f n.fst n.snd - f n.fst x))) 0 < ε

tactic: rw [← smul_sub] at hn
state_before: case refine'_1
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
this :
  ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x,
        dist ((↑‖n.snd - x‖)⁻¹ • (g n.snd - g x)) ((↑‖n.snd - x‖)⁻¹ • (f n.fst n.snd - f n.fst x)) < ε
ε : ℝ
hε : ε > 0
n : ι × E
hn : ‖(↑‖n.snd - x‖)⁻¹ • (g n.snd - g x) - (↑‖n.snd - x‖)⁻¹ • (f n.fst n.snd - f n.fst x)‖ < ε
⊢ ‖(↑‖n.snd - x‖)⁻¹ • (g n.snd - g x - (f n.fst n.snd - f n.fst x)) - 0‖ < ε

tactic: rwa [sub_zero]
state_before: case refine'_1
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
this :
  ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x,
        dist ((↑‖n.snd - x‖)⁻¹ • (g n.snd - g x)) ((↑‖n.snd - x‖)⁻¹ • (f n.fst n.snd - f n.fst x)) < ε
ε : ℝ
hε : ε > 0
n : ι × E
hn : ‖(↑‖n.snd - x‖)⁻¹ • (g n.snd - g x - (f n.fst n.snd - f n.fst x))‖ < ε
⊢ ‖(↑‖n.snd - x‖)⁻¹ • (g n.snd - g x - (f n.fst n.snd - f n.fst x)) - 0‖ < ε

tactic: rw [Metric.tendsto_nhds]
state_before: case refine'_2
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ Tendsto
    (fun x_1 => (fun a => (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) x_1)
    (curry l (𝓝 x)) (𝓝 0)

tactic: intro ε hε
state_before: case refine'_2
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (x_1 : ι × E) in curry l (𝓝 x),
        dist ((fun a => (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) x_1)
            0 <
          ε

tactic: rw [eventually_curry_iff]
state_before: case refine'_2
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
ε : ℝ
hε : ε > 0
⊢ ∀ᶠ (x_1 : ι × E) in curry l (𝓝 x),
    dist ((fun a => (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) x_1) 0 < ε

tactic: refine' hf.curry.mono fun n hn => _
state_before: case refine'_2
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
ε : ℝ
hε : ε > 0
⊢ ∀ᶠ (x_1 : ι) in l,
    ∀ᶠ (y : E) in 𝓝 x,
      dist
          ((fun a => (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) (x_1, y))
          0 <
        ε

tactic: have := hn.self_of_nhds
state_before: case refine'_2
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
ε : ℝ
hε : ε > 0
n : ι
hn : ∀ᶠ (y : E) in 𝓝 x, HasFDerivAt (f (n, y).fst) (f' (n, y).fst (n, y).snd) (n, y).snd
⊢ ∀ᶠ (y : E) in 𝓝 x,
    dist ((fun a => (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) (n, y))
        0 <
      ε

tactic: rw [hasFDerivAt_iff_tendsto, Metric.tendsto_nhds] at this
state_before: case refine'_2
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
ε : ℝ
hε : ε > 0
n : ι
hn : ∀ᶠ (y : E) in 𝓝 x, HasFDerivAt (f (n, y).fst) (f' (n, y).fst (n, y).snd) (n, y).snd
this : HasFDerivAt (f (n, x).fst) (f' (n, x).fst (n, x).snd) (n, x).snd
⊢ ∀ᶠ (y : E) in 𝓝 x,
    dist ((fun a => (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) (n, y))
        0 <
      ε

tactic: refine' (this ε hε).mono fun y hy => _
state_before: case refine'_2
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
ε : ℝ
hε : ε > 0
n : ι
hn : ∀ᶠ (y : E) in 𝓝 x, HasFDerivAt (f (n, y).fst) (f' (n, y).fst (n, y).snd) (n, y).snd
this :
  ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (x_1 : E) in 𝓝 (n, x).snd,
        dist
            (‖x_1 - (n, x).snd‖⁻¹ *
              ‖f (n, x).fst x_1 - f (n, x).fst (n, x).snd - ↑(f' (n, x).fst (n, x).snd) (x_1 - (n, x).snd)‖)
            0 <
          ε
⊢ ∀ᶠ (y : E) in 𝓝 x,
    dist ((fun a => (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) (n, y))
        0 <
      ε

tactic: rw [dist_eq_norm] at hy ⊢
state_before: case refine'_2
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
ε : ℝ
hε : ε > 0
n : ι
hn : ∀ᶠ (y : E) in 𝓝 x, HasFDerivAt (f (n, y).fst) (f' (n, y).fst (n, y).snd) (n, y).snd
this :
  ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (x_1 : E) in 𝓝 (n, x).snd,
        dist
            (‖x_1 - (n, x).snd‖⁻¹ *
              ‖f (n, x).fst x_1 - f (n, x).fst (n, x).snd - ↑(f' (n, x).fst (n, x).snd) (x_1 - (n, x).snd)‖)
            0 <
          ε
y : E
hy :
  dist (‖y - (n, x).snd‖⁻¹ * ‖f (n, x).fst y - f (n, x).fst (n, x).snd - ↑(f' (n, x).fst (n, x).snd) (y - (n, x).snd)‖)
      0 <
    ε
⊢ dist ((fun a => (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) (n, y)) 0 <
    ε

tactic: simp only [sub_zero, map_sub, norm_mul, norm_inv, norm_norm] at hy ⊢
state_before: case refine'_2
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
ε : ℝ
hε : ε > 0
n : ι
hn : ∀ᶠ (y : E) in 𝓝 x, HasFDerivAt (f (n, y).fst) (f' (n, y).fst (n, y).snd) (n, y).snd
this :
  ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (x_1 : E) in 𝓝 (n, x).snd,
        dist
            (‖x_1 - (n, x).snd‖⁻¹ *
              ‖f (n, x).fst x_1 - f (n, x).fst (n, x).snd - ↑(f' (n, x).fst (n, x).snd) (x_1 - (n, x).snd)‖)
            0 <
          ε
y : E
hy :
  ‖‖y - (n, x).snd‖⁻¹ * ‖f (n, x).fst y - f (n, x).fst (n, x).snd - ↑(f' (n, x).fst (n, x).snd) (y - (n, x).snd)‖ - 0‖ <
    ε
⊢ ‖(fun a => (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) (n, y) - 0‖ < ε

tactic: rw [norm_smul, norm_inv, IsROrC.norm_coe_norm]
state_before: case refine'_2
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
ε : ℝ
hε : ε > 0
n : ι
hn : ∀ᶠ (y : E) in 𝓝 x, HasFDerivAt (f (n, y).fst) (f' (n, y).fst (n, y).snd) (n, y).snd
this :
  ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (x_1 : E) in 𝓝 (n, x).snd,
        dist
            (‖x_1 - (n, x).snd‖⁻¹ *
              ‖f (n, x).fst x_1 - f (n, x).fst (n, x).snd - ↑(f' (n, x).fst (n, x).snd) (x_1 - (n, x).snd)‖)
            0 <
          ε
y : E
hy : ‖y - x‖⁻¹ * ‖f n y - f n x - (↑(f' n x) y - ↑(f' n x) x)‖ < ε
⊢ ‖(↑‖y - x‖)⁻¹ • (f n y - f n x - (↑(f' n x) y - ↑(f' n x) x))‖ < ε

tactic: exact hy
state_before: case refine'_2
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝¹ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this✝ : 𝓝 0 = 𝓝 (0 + 0 + 0)
ε : ℝ
hε : ε > 0
n : ι
hn : ∀ᶠ (y : E) in 𝓝 x, HasFDerivAt (f (n, y).fst) (f' (n, y).fst (n, y).snd) (n, y).snd
this :
  ∀ (ε : ℝ),
    ε > 0 →
      ∀ᶠ (x_1 : E) in 𝓝 (n, x).snd,
        dist
            (‖x_1 - (n, x).snd‖⁻¹ *
              ‖f (n, x).fst x_1 - f (n, x).fst (n, x).snd - ↑(f' (n, x).fst (n, x).snd) (x_1 - (n, x).snd)‖)
            0 <
          ε
y : E
hy : ‖y - x‖⁻¹ * ‖f n y - f n x - (↑(f' n x) y - ↑(f' n x) x)‖ < ε
⊢ ‖y - x‖⁻¹ * ‖f n y - f n x - (↑(f' n x) y - ↑(f' n x) x)‖ < ε

tactic: refine' Tendsto.mono_left _ curry_le_prod
state_before: case refine'_3
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ Tendsto (fun x_1 => (fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)) x_1) (curry l (𝓝 x)) (𝓝 0)

tactic: have h1 : Tendsto (fun n : ι × E => g' n.2 - f' n.1 n.2) (l ×ˢ 𝓝 x) (𝓝 0) := by
  rw [Metric.tendstoUniformlyOnFilter_iff] at hf'
  exact Metric.tendsto_nhds.mpr fun ε hε => by simpa using hf' ε hε
state_before: case refine'_3
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ Tendsto (fun x_1 => (fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)) x_1) (Filter.prod l (𝓝 x)) (𝓝 0)

tactic: have h2 : Tendsto (fun n : ι => g' x - f' n x) l (𝓝 0) := by
  rw [Metric.tendsto_nhds] at h1 ⊢
  exact fun ε hε => (h1 ε hε).curry.mono fun n hn => hn.self_of_nhds
state_before: case refine'_3
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
⊢ Tendsto (fun x_1 => (fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)) x_1) (Filter.prod l (𝓝 x)) (𝓝 0)

tactic: refine' squeeze_zero_norm _
  (tendsto_zero_iff_norm_tendsto_zero.mp (tendsto_fst.comp (h2.prod_map tendsto_id)))
state_before: case refine'_3
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
⊢ Tendsto (fun x_1 => (fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)) x_1) (Filter.prod l (𝓝 x)) (𝓝 0)

tactic: intro n
state_before: case refine'_3
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
⊢ ∀ (n : ι × E),
    ‖(fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)) n‖ ≤
      ‖(Prod.fst ∘ Prod.map (fun n => g' x - f' n x) id) n‖

tactic: simp_rw [norm_smul, norm_inv, IsROrC.norm_coe_norm]
state_before: case refine'_3
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
n : ι × E
⊢ ‖(fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)) n‖ ≤
    ‖(Prod.fst ∘ Prod.map (fun n => g' x - f' n x) id) n‖

tactic: by_cases hx : x = n.2
state_before: case refine'_3
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
n : ι × E
⊢ ‖n.snd - x‖⁻¹ * ‖↑(f' n.fst x - g' x) (n.snd - x)‖ ≤ ‖(Prod.fst ∘ Prod.map (fun n => g' x - f' n x) id) n‖

tactic: have hnx : 0 < ‖n.2 - x‖ := by
  rw [norm_pos_iff]; intro hx'; exact hx (eq_of_sub_eq_zero hx').symm
state_before: case neg
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
n : ι × E
hx : ¬x = n.snd
⊢ ‖n.snd - x‖⁻¹ * ‖↑(f' n.fst x - g' x) (n.snd - x)‖ ≤ ‖(Prod.fst ∘ Prod.map (fun n => g' x - f' n x) id) n‖

tactic: rw [inv_mul_le_iff hnx, mul_comm]
state_before: case neg
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
n : ι × E
hx : ¬x = n.snd
hnx : 0 < ‖n.snd - x‖
⊢ ‖n.snd - x‖⁻¹ * ‖↑(f' n.fst x - g' x) (n.snd - x)‖ ≤ ‖(Prod.fst ∘ Prod.map (fun n => g' x - f' n x) id) n‖

tactic: simp only [Function.comp_apply, Prod_map]
state_before: case neg
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
n : ι × E
hx : ¬x = n.snd
hnx : 0 < ‖n.snd - x‖
⊢ ‖↑(f' n.fst x - g' x) (n.snd - x)‖ ≤ ‖(Prod.fst ∘ Prod.map (fun n => g' x - f' n x) id) n‖ * ‖n.snd - x‖

tactic: rw [norm_sub_rev]
state_before: case neg
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
n : ι × E
hx : ¬x = n.snd
hnx : 0 < ‖n.snd - x‖
⊢ ‖↑(f' n.fst x - g' x) (n.snd - x)‖ ≤ ‖g' x - f' n.fst x‖ * ‖n.snd - x‖

tactic: exact (f' n.1 x - g' x).le_op_norm (n.2 - x)
state_before: case neg
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
n : ι × E
hx : ¬x = n.snd
hnx : 0 < ‖n.snd - x‖
⊢ ‖↑(f' n.fst x - g' x) (n.snd - x)‖ ≤ ‖f' n.fst x - g' x‖ * ‖n.snd - x‖

tactic: rw [Metric.tendstoUniformlyOnFilter_iff] at hf'
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)

tactic: exact Metric.tendsto_nhds.mpr fun ε hε => by simpa using hf' ε hε
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : ∀ (ε : ℝ), ε > 0 → ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, dist (g' n.snd) (f' n.fst n.snd) < ε
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
⊢ Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)

tactic: simpa using hf' ε hε
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : ∀ (ε : ℝ), ε > 0 → ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, dist (g' n.snd) (f' n.fst n.snd) < ε
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
ε : ℝ
hε : ε > 0
⊢ ∀ᶠ (x : ι × E) in l ×ˢ 𝓝 x, dist (g' x.snd - f' x.fst x.snd) 0 < ε

tactic: rw [Metric.tendsto_nhds] at h1 ⊢
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
⊢ Tendsto (fun n => g' x - f' n x) l (𝓝 0)

tactic: exact fun ε hε => (h1 ε hε).curry.mono fun n hn => hn.self_of_nhds
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : ∀ (ε : ℝ), ε > 0 → ∀ᶠ (x : ι × E) in l ×ˢ 𝓝 x, dist (g' x.snd - f' x.fst x.snd) 0 < ε
⊢ ∀ (ε : ℝ), ε > 0 → ∀ᶠ (x_1 : ι) in l, dist (g' x - f' x_1 x) 0 < ε

tactic: simp [hx]
state_before: case pos
ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
n : ι × E
hx : x = n.snd
⊢ ‖n.snd - x‖⁻¹ * ‖↑(f' n.fst x - g' x) (n.snd - x)‖ ≤ ‖(Prod.fst ∘ Prod.map (fun n => g' x - f' n x) id) n‖

tactic: rw [norm_pos_iff]
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
n : ι × E
hx : ¬x = n.snd
⊢ 0 < ‖n.snd - x‖

tactic: intro hx'
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
n : ι × E
hx : ¬x = n.snd
⊢ n.snd - x ≠ 0

tactic: exact hx (eq_of_sub_eq_zero hx').symm
state_before: ι : Type u_1
l : Filter ι
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
𝕜 : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedSpace 𝕜 E
G : Type u_3
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f : ι → E → G
g : E → G
f' : ι → E → E →L[𝕜] G
g' : E → E →L[𝕜] G
x : E
inst✝ : NeBot l
hf' : TendstoUniformlyOnFilter f' g' l (𝓝 x)
hf : ∀ᶠ (n : ι × E) in l ×ˢ 𝓝 x, HasFDerivAt (f n.fst) (f' n.fst n.snd) n.snd
hfg : ∀ᶠ (y : E) in 𝓝 x, Tendsto (fun n => f n y) l (𝓝 (g y))
this✝ :
  (fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - ↑(g' x) (a.snd - x))) =
    ((fun a => (↑‖a.snd - x‖)⁻¹ • (g a.snd - g x - (f a.fst a.snd - f a.fst x))) + fun a =>
        (↑‖a.snd - x‖)⁻¹ • (f a.fst a.snd - f a.fst x - (↑(f' a.fst x) a.snd - ↑(f' a.fst x) x))) +
      fun a => (↑‖a.snd - x‖)⁻¹ • ↑(f' a.fst x - g' x) (a.snd - x)
this : 𝓝 0 = 𝓝 (0 + 0 + 0)
h1 : Tendsto (fun n => g' n.snd - f' n.fst n.snd) (l ×ˢ 𝓝 x) (𝓝 0)
h2 : Tendsto (fun n => g' x - f' n x) l (𝓝 0)
n : ι × E
hx : ¬x = n.snd
hx' : n.snd - x = 0
⊢ False