-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
theorem HasStrictFDerivAt.of_local_left_inverse {f : E → F} {f' : E ≃L[𝕜] F} {g : F → E} {a : F}
    (hg : ContinuousAt g a) (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) (g a))
    (hfg : ∀ᶠ y in 𝓝 a, f (g y) = y) : HasStrictFDerivAt g (f'.symm : F →L[𝕜] E) a

Proof state:
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
⊢ (fun p => f' (g p.1 - g p.2) - (p.1 - p.2)) =o[𝓝 (a, a)] fun p => p.1 - p.2

Tactic:
refine ((hf.isLittleO.comp_tendsto hg).symm.congr'
  (hfg.mono ?_) (Eventually.of_forall fun _ => rfl)).trans_isBigO ?_

Result:
case refine_1
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
⊢ ∀ (x : F × F),
    f (g x.1) = x.1 ∧ f (g x.2) = x.2 →
      (fun x => ↑f' ((Prod.map g g x).1 - (Prod.map g g x).2) - (f (Prod.map g g x).1 - f (Prod.map g g x).2)) x =
        f' (g x.1 - g x.2) - (x.1 - x.2)

case refine_2
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
⊢ ((fun p => p.1 - p.2) ∘ Prod.map g g) =O[𝓝 (a, a)] fun p => p.1 - p.2

Proof state:
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
this : (fun p => g p.1 - g p.2 - f'.symm (p.1 - p.2)) =O[𝓝 (a, a)] fun p => f' (g p.1 - g p.2) - (p.1 - p.2)
⊢ HasStrictFDerivAt g (↑f'.symm) a

Tactic:
refine .of_isLittleO <| this.trans_isLittleO ?_

Result:
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
this : (fun p => g p.1 - g p.2 - f'.symm (p.1 - p.2)) =O[𝓝 (a, a)] fun p => f' (g p.1 - g p.2) - (p.1 - p.2)
⊢ (fun p => f' (g p.1 - g p.2) - (p.1 - p.2)) =o[𝓝 (a, a)] fun p => p.1 - p.2

Proof state:
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
this : (fun p => g p.1 - g p.2 - f'.symm (p.1 - p.2)) =O[𝓝 (a, a)] fun p => f' (g p.1 - g p.2) - (p.1 - p.2)
⊢ (fun p => f' (g p.1 - g p.2) - (p.1 - p.2)) =o[𝓝 (a, a)] fun p => p.1 - p.2

Tactic:
clear this

Result:
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
⊢ (fun p => f' (g p.1 - g p.2) - (p.1 - p.2)) =o[𝓝 (a, a)] fun p => p.1 - p.2

Proof state:
case refine_2
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
⊢ ((fun p => p.1 - p.2) ∘ Prod.map g g) =O[𝓝 (a, a)] fun p => p.1 - p.2

Tactic:
refine (hf.isBigO_sub_rev.comp_tendsto hg).congr' (Eventually.of_forall fun _ => rfl)
  (hfg.mono ?_)

Result:
case refine_2
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
⊢ ∀ (x : F × F),
    f (g x.1) = x.1 ∧ f (g x.2) = x.2 → ((fun p => f p.1 - f p.2) ∘ Prod.map g g) x = (fun p => p.1 - p.2) x

Proof state:
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hfg : ∀ᶠ (y : F) in 𝓝 a, f (g y) = y
hg : ContinuousAt (Prod.map g g) (a, a)
⊢ HasStrictFDerivAt g (↑f'.symm) a

Tactic:
replace hfg := hfg.prod_mk_nhds hfg

Result:
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
⊢ HasStrictFDerivAt g (↑f'.symm) a

Proof state:
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
⊢ HasStrictFDerivAt g (↑f'.symm) a

Tactic:
have :
  (fun p : F × F => g p.1 - g p.2 - f'.symm (p.1 - p.2)) =O[𝓝 (a, a)] fun p : F × F =>
    f' (g p.1 - g p.2) - (p.1 - p.2) := by
  refine ((f'.symm : F →L[𝕜] E).isBigO_comp _ _).congr (fun x => ?_) fun _ => rfl
  simp

Result:
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (Prod.map g g) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.1) = p.1 ∧ f (g p.2) = p.2
this : (fun p => g p.1 - g p.2 - f'.symm (p.1 - p.2)) =O[𝓝 (a, a)] fun p => f' (g p.1 - g p.2) - (p.1 - p.2)
⊢ HasStrictFDerivAt g (↑f'.symm) a