Theorem: HasStrictFDerivAt.of_local_left_inverse
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: replace hg := hg.prod_map' hg
state_before: 𝕜 : 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
G : Type ?u.375202
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.375297
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hg : ContinuousAt g a
hf : HasStrictFDerivAt f (↑f') (g a)
hfg : ∀ᶠ (y : F) in 𝓝 a, f (g y) = y
⊢ HasStrictFDerivAt g (↑(ContinuousLinearEquiv.symm f')) a

tactic: replace hfg := hfg.prod_mk_nhds hfg
state_before: 𝕜 : 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
G : Type ?u.375202
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.375297
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
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 (fun p => (g p.fst, g p.snd)) (a, a)
⊢ HasStrictFDerivAt g (↑(ContinuousLinearEquiv.symm f')) 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
state_before: 𝕜 : 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
G : Type ?u.375202
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.375297
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (fun p => (g p.fst, g p.snd)) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.fst) = p.fst ∧ f (g p.snd) = p.snd
⊢ HasStrictFDerivAt g (↑(ContinuousLinearEquiv.symm f')) a

tactic: refine' this.trans_isLittleO _
state_before: 𝕜 : 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
G : Type ?u.375202
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.375297
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (fun p => (g p.fst, g p.snd)) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.fst) = p.fst ∧ f (g p.snd) = p.snd
this :
  (fun p => g p.fst - g p.snd - ↑(ContinuousLinearEquiv.symm f') (p.fst - p.snd)) =O[𝓝 (a, a)] fun p =>
    ↑f' (g p.fst - g p.snd) - (p.fst - p.snd)
⊢ HasStrictFDerivAt g (↑(ContinuousLinearEquiv.symm f')) a

tactic: clear this
state_before: 𝕜 : 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
G : Type ?u.375202
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.375297
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (fun p => (g p.fst, g p.snd)) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.fst) = p.fst ∧ f (g p.snd) = p.snd
this :
  (fun p => g p.fst - g p.snd - ↑(ContinuousLinearEquiv.symm f') (p.fst - p.snd)) =O[𝓝 (a, a)] fun p =>
    ↑f' (g p.fst - g p.snd) - (p.fst - p.snd)
⊢ (fun p => ↑f' (g p.fst - g p.snd) - (p.fst - p.snd)) =o[𝓝 (a, a)] fun p => p.fst - p.snd

tactic: refine'
  ((hf.comp_tendsto hg).symm.congr' (hfg.mono _) (eventually_of_forall fun _ => rfl)).trans_isBigO
    _
state_before: 𝕜 : 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
G : Type ?u.375202
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.375297
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (fun p => (g p.fst, g p.snd)) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.fst) = p.fst ∧ f (g p.snd) = p.snd
⊢ (fun p => ↑f' (g p.fst - g p.snd) - (p.fst - p.snd)) =o[𝓝 (a, a)] fun p => p.fst - p.snd

tactic: refine' ((f'.symm : F →L[𝕜] E).isBigO_comp _ _).congr (fun x => _) fun _ => rfl
state_before: 𝕜 : 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
G : Type ?u.375202
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.375297
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (fun p => (g p.fst, g p.snd)) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.fst) = p.fst ∧ f (g p.snd) = p.snd
⊢ (fun p => g p.fst - g p.snd - ↑(ContinuousLinearEquiv.symm f') (p.fst - p.snd)) =O[𝓝 (a, a)] fun p =>
    ↑f' (g p.fst - g p.snd) - (p.fst - p.snd)

tactic: simp
state_before: 𝕜 : 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
G : Type ?u.375202
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.375297
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (fun p => (g p.fst, g p.snd)) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.fst) = p.fst ∧ f (g p.snd) = p.snd
x : F × F
⊢ ↑↑(ContinuousLinearEquiv.symm f') (↑f' (g x.fst - g x.snd) - (x.fst - x.snd)) =
    g x.fst - g x.snd - ↑(ContinuousLinearEquiv.symm f') (x.fst - x.snd)

tactic: rintro p ⟨hp1, hp2⟩
state_before: 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
G : Type ?u.375202
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.375297
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (fun p => (g p.fst, g p.snd)) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.fst) = p.fst ∧ f (g p.snd) = p.snd
⊢ ∀ (x : F × F),
    f (g x.fst) = x.fst ∧ f (g x.snd) = x.snd →
      (fun x =>
            ↑↑f' (((fun p => (g p.fst, g p.snd)) x).fst - ((fun p => (g p.fst, g p.snd)) x).snd) -
              (f ((fun p => (g p.fst, g p.snd)) x).fst - f ((fun p => (g p.fst, g p.snd)) x).snd))
          x =
        ↑f' (g x.fst - g x.snd) - (x.fst - x.snd)

tactic: simp [hp1, hp2]
state_before: case refine'_1.intro
𝕜 : 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
G : Type ?u.375202
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.375297
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (fun p => (g p.fst, g p.snd)) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.fst) = p.fst ∧ f (g p.snd) = p.snd
p : F × F
hp1 : f (g p.fst) = p.fst
hp2 : f (g p.snd) = p.snd
⊢ (fun x =>
        ↑↑f' (((fun p => (g p.fst, g p.snd)) x).fst - ((fun p => (g p.fst, g p.snd)) x).snd) -
          (f ((fun p => (g p.fst, g p.snd)) x).fst - f ((fun p => (g p.fst, g p.snd)) x).snd))
      p =
    ↑f' (g p.fst - g p.snd) - (p.fst - p.snd)

tactic: refine (hf.isBigO_sub_rev.comp_tendsto hg).congr' (eventually_of_forall fun _ => rfl)
  (hfg.mono ?_)
state_before: 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
G : Type ?u.375202
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.375297
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (fun p => (g p.fst, g p.snd)) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.fst) = p.fst ∧ f (g p.snd) = p.snd
⊢ (fun x => ((fun p => p.fst - p.snd) ∘ fun p => (g p.fst, g p.snd)) x) =O[𝓝 (a, a)] fun p => p.fst - p.snd

tactic: rintro p ⟨hp1, hp2⟩
state_before: 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
G : Type ?u.375202
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.375297
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g✝ : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → F
f' : E ≃L[𝕜] F
g : F → E
a : F
hf : HasStrictFDerivAt f (↑f') (g a)
hg : ContinuousAt (fun p => (g p.fst, g p.snd)) (a, a)
hfg : ∀ᶠ (p : F × F) in 𝓝 (a, a), f (g p.fst) = p.fst ∧ f (g p.snd) = p.snd
⊢ ∀ (x : F × F),
    f (g x.fst) = x.fst ∧ f (g x.snd) = x.snd →
      ((fun p => f p.fst - f p.snd) ∘ fun p => (g p.fst, g p.snd)) x = (fun p => p.fst - p.snd) x