l3lab/ntp-mathlib huggingface dataset:
/-- Make a `SmoothVectorBundle` from a `SmoothVectorPrebundle`. -/
theorem smoothVectorBundle : @SmoothVectorBundle
    _ _ F E _ _ _ _ _ _ IB _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle a.toVectorBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle; letI := a.toVectorBundle
  { smoothOn_coordChangeL := by
      

Proof state:
𝕜 : Type u_1
B : Type u_2
B' : Type u_3
F : Type u_4
M : Type u_5
E : B → Type u_6
inst✝¹⁶ : NontriviallyNormedField 𝕜
EB : Type u_7
inst✝¹⁵ : NormedAddCommGroup EB
inst✝¹⁴ : NormedSpace 𝕜 EB
HB : Type u_8
inst✝¹³ : TopologicalSpace HB
IB : ModelWithCorners 𝕜 EB HB
inst✝¹² : TopologicalSpace B
inst✝¹¹ : ChartedSpace HB B
inst✝¹⁰ : SmoothManifoldWithCorners IB B
EM : Type u_9
inst✝⁹ : NormedAddCommGroup EM
inst✝⁸ : NormedSpace 𝕜 EM
HM : Type u_10
inst✝⁷ : TopologicalSpace HM
IM : ModelWithCorners 𝕜 EM HM
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace HM M
Is : SmoothManifoldWithCorners IM M
n : ℕ∞
inst✝⁴ : (x : B) → AddCommMonoid (E x)
inst✝³ : (x : B) → Module 𝕜 (E x)
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle 𝕜 F E
ha : IsSmooth IB a
e e' : Pretrivialization F TotalSpace.proj
this✝¹ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this✝ : FiberBundle F E := toFiberBundle a
this : VectorBundle 𝕜 F E := toVectorBundle a
⊢ ∀ (e e' : Trivialization F TotalSpace.proj) [inst : MemTrivializationAtlas e] [inst_1 : MemTrivializationAtlas e'],
    SmoothOn IB 𝓘(𝕜, F →L[𝕜] F) (fun b => ↑(Trivialization.coordChangeL 𝕜 e e' b)) (e.baseSet ∩ e'.baseSet)

Next tactic:
rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
/-- Make a `SmoothVectorBundle` from a `SmoothVectorPrebundle`. -/
theorem smoothVectorBundle : @SmoothVectorBundle
    _ _ F E _ _ _ _ _ _ IB _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle a.toVectorBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle; letI := a.toVectorBundle
  { smoothOn_coordChangeL := by
      rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
      

Proof state:
case mk.intro.intro.mk.intro.intro
𝕜 : Type u_1
B : Type u_2
B' : Type u_3
F : Type u_4
M : Type u_5
E : B → Type u_6
inst✝¹⁶ : NontriviallyNormedField 𝕜
EB : Type u_7
inst✝¹⁵ : NormedAddCommGroup EB
inst✝¹⁴ : NormedSpace 𝕜 EB
HB : Type u_8
inst✝¹³ : TopologicalSpace HB
IB : ModelWithCorners 𝕜 EB HB
inst✝¹² : TopologicalSpace B
inst✝¹¹ : ChartedSpace HB B
inst✝¹⁰ : SmoothManifoldWithCorners IB B
EM : Type u_9
inst✝⁹ : NormedAddCommGroup EM
inst✝⁸ : NormedSpace 𝕜 EM
HM : Type u_10
inst✝⁷ : TopologicalSpace HM
IM : ModelWithCorners 𝕜 EM HM
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace HM M
Is : SmoothManifoldWithCorners IM M
n : ℕ∞
inst✝⁴ : (x : B) → AddCommMonoid (E x)
inst✝³ : (x : B) → Module 𝕜 (E x)
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle 𝕜 F E
ha : IsSmooth IB a
e✝ e'✝ : Pretrivialization F TotalSpace.proj
this✝¹ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this✝ : FiberBundle F E := toFiberBundle a
this : VectorBundle 𝕜 F E := toVectorBundle a
e : Pretrivialization F TotalSpace.proj
he : e ∈ (toFiberPrebundle a).pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ (toFiberPrebundle a).pretrivializationAtlas
⊢ SmoothOn IB 𝓘(𝕜, F →L[𝕜] F)
    (fun b =>
      ↑(Trivialization.coordChangeL 𝕜 (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he)
          (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he') b))
    ((FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he).baseSet ∩
      (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he').baseSet)

Next tactic:
refine' (a.smoothOn_smoothCoordChange he he').congr _
/-- Make a `SmoothVectorBundle` from a `SmoothVectorPrebundle`. -/
theorem smoothVectorBundle : @SmoothVectorBundle
    _ _ F E _ _ _ _ _ _ IB _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle a.toVectorBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle; letI := a.toVectorBundle
  { smoothOn_coordChangeL := by
      rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
      refine' (a.smoothOn_smoothCoordChange he he').congr _
      

Proof state:
case mk.intro.intro.mk.intro.intro
𝕜 : Type u_1
B : Type u_2
B' : Type u_3
F : Type u_4
M : Type u_5
E : B → Type u_6
inst✝¹⁶ : NontriviallyNormedField 𝕜
EB : Type u_7
inst✝¹⁵ : NormedAddCommGroup EB
inst✝¹⁴ : NormedSpace 𝕜 EB
HB : Type u_8
inst✝¹³ : TopologicalSpace HB
IB : ModelWithCorners 𝕜 EB HB
inst✝¹² : TopologicalSpace B
inst✝¹¹ : ChartedSpace HB B
inst✝¹⁰ : SmoothManifoldWithCorners IB B
EM : Type u_9
inst✝⁹ : NormedAddCommGroup EM
inst✝⁸ : NormedSpace 𝕜 EM
HM : Type u_10
inst✝⁷ : TopologicalSpace HM
IM : ModelWithCorners 𝕜 EM HM
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace HM M
Is : SmoothManifoldWithCorners IM M
n : ℕ∞
inst✝⁴ : (x : B) → AddCommMonoid (E x)
inst✝³ : (x : B) → Module 𝕜 (E x)
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle 𝕜 F E
ha : IsSmooth IB a
e✝ e'✝ : Pretrivialization F TotalSpace.proj
this✝¹ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this✝ : FiberBundle F E := toFiberBundle a
this : VectorBundle 𝕜 F E := toVectorBundle a
e : Pretrivialization F TotalSpace.proj
he : e ∈ (toFiberPrebundle a).pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ (toFiberPrebundle a).pretrivializationAtlas
⊢ ∀ y ∈ e.baseSet ∩ e'.baseSet,
    ↑(Trivialization.coordChangeL 𝕜 (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he)
          (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he') y) =
      smoothCoordChange IB a he he' y

Next tactic:
intro b hb
/-- Make a `SmoothVectorBundle` from a `SmoothVectorPrebundle`. -/
theorem smoothVectorBundle : @SmoothVectorBundle
    _ _ F E _ _ _ _ _ _ IB _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle a.toVectorBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle; letI := a.toVectorBundle
  { smoothOn_coordChangeL := by
      rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
      refine' (a.smoothOn_smoothCoordChange he he').congr _
      intro b hb
      

Proof state:
case mk.intro.intro.mk.intro.intro
𝕜 : Type u_1
B : Type u_2
B' : Type u_3
F : Type u_4
M : Type u_5
E : B → Type u_6
inst✝¹⁶ : NontriviallyNormedField 𝕜
EB : Type u_7
inst✝¹⁵ : NormedAddCommGroup EB
inst✝¹⁴ : NormedSpace 𝕜 EB
HB : Type u_8
inst✝¹³ : TopologicalSpace HB
IB : ModelWithCorners 𝕜 EB HB
inst✝¹² : TopologicalSpace B
inst✝¹¹ : ChartedSpace HB B
inst✝¹⁰ : SmoothManifoldWithCorners IB B
EM : Type u_9
inst✝⁹ : NormedAddCommGroup EM
inst✝⁸ : NormedSpace 𝕜 EM
HM : Type u_10
inst✝⁷ : TopologicalSpace HM
IM : ModelWithCorners 𝕜 EM HM
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace HM M
Is : SmoothManifoldWithCorners IM M
n : ℕ∞
inst✝⁴ : (x : B) → AddCommMonoid (E x)
inst✝³ : (x : B) → Module 𝕜 (E x)
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle 𝕜 F E
ha : IsSmooth IB a
e✝ e'✝ : Pretrivialization F TotalSpace.proj
this✝¹ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this✝ : FiberBundle F E := toFiberBundle a
this : VectorBundle 𝕜 F E := toVectorBundle a
e : Pretrivialization F TotalSpace.proj
he : e ∈ (toFiberPrebundle a).pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ (toFiberPrebundle a).pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
⊢ ↑(Trivialization.coordChangeL 𝕜 (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he)
        (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he') b) =
    smoothCoordChange IB a he he' b

Next tactic:
ext v
/-- Make a `SmoothVectorBundle` from a `SmoothVectorPrebundle`. -/
theorem smoothVectorBundle : @SmoothVectorBundle
    _ _ F E _ _ _ _ _ _ IB _ _ _ _ _ _ a.totalSpaceTopology _ a.toFiberBundle a.toVectorBundle :=
  letI := a.totalSpaceTopology; letI := a.toFiberBundle; letI := a.toVectorBundle
  { smoothOn_coordChangeL := by
      rintro _ _ ⟨e, he, rfl⟩ ⟨e', he', rfl⟩
      refine' (a.smoothOn_smoothCoordChange he he').congr _
      intro b hb
      ext v
      

Proof state:
case mk.intro.intro.mk.intro.intro.h
𝕜 : Type u_1
B : Type u_2
B' : Type u_3
F : Type u_4
M : Type u_5
E : B → Type u_6
inst✝¹⁶ : NontriviallyNormedField 𝕜
EB : Type u_7
inst✝¹⁵ : NormedAddCommGroup EB
inst✝¹⁴ : NormedSpace 𝕜 EB
HB : Type u_8
inst✝¹³ : TopologicalSpace HB
IB : ModelWithCorners 𝕜 EB HB
inst✝¹² : TopologicalSpace B
inst✝¹¹ : ChartedSpace HB B
inst✝¹⁰ : SmoothManifoldWithCorners IB B
EM : Type u_9
inst✝⁹ : NormedAddCommGroup EM
inst✝⁸ : NormedSpace 𝕜 EM
HM : Type u_10
inst✝⁷ : TopologicalSpace HM
IM : ModelWithCorners 𝕜 EM HM
inst✝⁶ : TopologicalSpace M
inst✝⁵ : ChartedSpace HM M
Is : SmoothManifoldWithCorners IM M
n : ℕ∞
inst✝⁴ : (x : B) → AddCommMonoid (E x)
inst✝³ : (x : B) → Module 𝕜 (E x)
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace 𝕜 F
inst✝ : (x : B) → TopologicalSpace (E x)
a : VectorPrebundle 𝕜 F E
ha : IsSmooth IB a
e✝ e'✝ : Pretrivialization F TotalSpace.proj
this✝¹ : TopologicalSpace (TotalSpace F E) := totalSpaceTopology a
this✝ : FiberBundle F E := toFiberBundle a
this : VectorBundle 𝕜 F E := toVectorBundle a
e : Pretrivialization F TotalSpace.proj
he : e ∈ (toFiberPrebundle a).pretrivializationAtlas
e' : Pretrivialization F TotalSpace.proj
he' : e' ∈ (toFiberPrebundle a).pretrivializationAtlas
b : B
hb : b ∈ e.baseSet ∩ e'.baseSet
v : F
⊢ ↑(Trivialization.coordChangeL 𝕜 (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he)
          (FiberPrebundle.trivializationOfMemPretrivializationAtlas (toFiberPrebundle a) he') b)
      v =
    (smoothCoordChange IB a he he' b) v

Next tactic:
rw [a.smoothCoordChange_apply he he' hb v, ContinuousLinearEquiv.coe_coe,
        Trivialization.coordChangeL_apply]
theorem IsEquivalent.isBigO_symm (h : u ~[l] v) : v =O[l] u := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
h : u ~[l] v
⊢ v =O[l] u

Next tactic:
convert h.isLittleO.right_isBigO_add
theorem IsEquivalent.isBigO_symm (h : u ~[l] v) : v =O[l] u := by
  convert h.isLittleO.right_isBigO_add
  

Proof state:
case h.e'_8.h
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
h : u ~[l] v
x✝ : α
⊢ u x✝ = (u - v) x✝ + v x✝

Next tactic:
simp
@[refl]
theorem IsEquivalent.refl : u ~[l] u := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
⊢ u ~[l] u

Next tactic:
rw [IsEquivalent, sub_self]
@[refl]
theorem IsEquivalent.refl : u ~[l] u := by
  rw [IsEquivalent, sub_self]
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
⊢ 0 =o[l] u

Next tactic:
exact isLittleO_zero _ _
theorem isEquivalent_zero_iff_eventually_zero : u ~[l] 0 ↔ u =ᶠ[l] 0 := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
⊢ u ~[l] 0 ↔ u =ᶠ[l] 0

Next tactic:
rw [IsEquivalent, sub_zero]
theorem isEquivalent_zero_iff_eventually_zero : u ~[l] 0 ↔ u =ᶠ[l] 0 := by
  rw [IsEquivalent, sub_zero]
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
⊢ u =o[l] 0 ↔ u =ᶠ[l] 0

Next tactic:
exact isLittleO_zero_right_iff
theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β) := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
⊢ u ~[l] 0 ↔ u =O[l] 0

Next tactic:
refine' ⟨IsEquivalent.isBigO, fun h ↦ _⟩
theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β) := by
  refine' ⟨IsEquivalent.isBigO, fun h ↦ _⟩
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
h : u =O[l] 0
⊢ u ~[l] 0

Next tactic:
rw [isEquivalent_zero_iff_eventually_zero, eventuallyEq_iff_exists_mem]
theorem isEquivalent_zero_iff_isBigO_zero : u ~[l] 0 ↔ u =O[l] (0 : α → β) := by
  refine' ⟨IsEquivalent.isBigO, fun h ↦ _⟩
  rw [isEquivalent_zero_iff_eventually_zero, eventuallyEq_iff_exists_mem]
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
h : u =O[l] 0
⊢ ∃ s ∈ l, Set.EqOn u 0 s

Next tactic:
exact ⟨{ x : α | u x = 0 }, isBigO_zero_right_iff.mp h, fun x hx ↦ hx⟩
theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
    u ~[l] const _ c ↔ Tendsto u l (𝓝 c) := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
h : c ≠ 0
⊢ u ~[l] const α c ↔ Tendsto u l (𝓝 c)

Next tactic:
simp (config := { unfoldPartialApp := true }) only [IsEquivalent, const, isLittleO_const_iff h]
theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
    u ~[l] const _ c ↔ Tendsto u l (𝓝 c) := by
  simp (config := { unfoldPartialApp := true }) only [IsEquivalent, const, isLittleO_const_iff h]
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
h : c ≠ 0
⊢ Tendsto (u - fun x => c) l (𝓝 0) ↔ Tendsto u l (𝓝 c)

Next tactic:
constructor
theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
    u ~[l] const _ c ↔ Tendsto u l (𝓝 c) := by
  simp (config := { unfoldPartialApp := true }) only [IsEquivalent, const, isLittleO_const_iff h]
  constructor <;> 

Proof state:
case mp
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
h : c ≠ 0
⊢ Tendsto (u - fun x => c) l (𝓝 0) → Tendsto u l (𝓝 c)

Next tactic:
intro h
theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
    u ~[l] const _ c ↔ Tendsto u l (𝓝 c) := by
  simp (config := { unfoldPartialApp := true }) only [IsEquivalent, const, isLittleO_const_iff h]
  constructor <;> 

Proof state:
case mpr
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
h : c ≠ 0
⊢ Tendsto u l (𝓝 c) → Tendsto (u - fun x => c) l (𝓝 0)

Next tactic:
intro h
theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
    u ~[l] const _ c ↔ Tendsto u l (𝓝 c) := by
  simp (config := { unfoldPartialApp := true }) only [IsEquivalent, const, isLittleO_const_iff h]
  constructor <;> intro h
  · 

Proof state:
case mp
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
h✝ : c ≠ 0
h : Tendsto (u - fun x => c) l (𝓝 0)
⊢ Tendsto u l (𝓝 c)

Next tactic:
have := h.sub (tendsto_const_nhds (a := -c))
theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
    u ~[l] const _ c ↔ Tendsto u l (𝓝 c) := by
  simp (config := { unfoldPartialApp := true }) only [IsEquivalent, const, isLittleO_const_iff h]
  constructor <;> intro h
  · have := h.sub (tendsto_const_nhds (a := -c))
    

Proof state:
case mp
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
h✝ : c ≠ 0
h : Tendsto (u - fun x => c) l (𝓝 0)
this : Tendsto (fun x => (u - fun x => c) x - -c) l (𝓝 (0 - -c))
⊢ Tendsto u l (𝓝 c)

Next tactic:
simp only [Pi.sub_apply, sub_neg_eq_add, sub_add_cancel, zero_add] at this
theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
    u ~[l] const _ c ↔ Tendsto u l (𝓝 c) := by
  simp (config := { unfoldPartialApp := true }) only [IsEquivalent, const, isLittleO_const_iff h]
  constructor <;> intro h
  · have := h.sub (tendsto_const_nhds (a := -c))
    simp only [Pi.sub_apply, sub_neg_eq_add, sub_add_cancel, zero_add] at this
    

Proof state:
case mp
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
h✝ : c ≠ 0
h : Tendsto (u - fun x => c) l (𝓝 0)
this : Tendsto (fun x => u x) l (𝓝 c)
⊢ Tendsto u l (𝓝 c)

Next tactic:
exact this
theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
    u ~[l] const _ c ↔ Tendsto u l (𝓝 c) := by
  simp (config := { unfoldPartialApp := true }) only [IsEquivalent, const, isLittleO_const_iff h]
  constructor <;> intro h
  · have := h.sub (tendsto_const_nhds (a := -c))
    simp only [Pi.sub_apply, sub_neg_eq_add, sub_add_cancel, zero_add] at this
    exact this
  · 

Proof state:
case mpr
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
h✝ : c ≠ 0
h : Tendsto u l (𝓝 c)
⊢ Tendsto (u - fun x => c) l (𝓝 0)

Next tactic:
have := h.sub (tendsto_const_nhds (a := c))
theorem isEquivalent_const_iff_tendsto {c : β} (h : c ≠ 0) :
    u ~[l] const _ c ↔ Tendsto u l (𝓝 c) := by
  simp (config := { unfoldPartialApp := true }) only [IsEquivalent, const, isLittleO_const_iff h]
  constructor <;> intro h
  · have := h.sub (tendsto_const_nhds (a := -c))
    simp only [Pi.sub_apply, sub_neg_eq_add, sub_add_cancel, zero_add] at this
    exact this
  · have := h.sub (tendsto_const_nhds (a := c))
    

Proof state:
case mpr
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
h✝ : c ≠ 0
h : Tendsto u l (𝓝 c)
this : Tendsto (fun x => u x - c) l (𝓝 (c - c))
⊢ Tendsto (u - fun x => c) l (𝓝 0)

Next tactic:
rwa [sub_self] at this
theorem IsEquivalent.tendsto_const {c : β} (hu : u ~[l] const _ c) : Tendsto u l (𝓝 c) := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
hu : u ~[l] const α c
⊢ Tendsto u l (𝓝 c)

Next tactic:
rcases em <| c = 0 with rfl | h
theorem IsEquivalent.tendsto_const {c : β} (hu : u ~[l] const _ c) : Tendsto u l (𝓝 c) := by
  rcases em <| c = 0 with rfl | h
  · 

Proof state:
case inl
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
hu : u ~[l] const α 0
⊢ Tendsto u l (𝓝 0)

Next tactic:
exact (tendsto_congr' <| isEquivalent_zero_iff_eventually_zero.mp hu).mpr tendsto_const_nhds
theorem IsEquivalent.tendsto_const {c : β} (hu : u ~[l] const _ c) : Tendsto u l (𝓝 c) := by
  rcases em <| c = 0 with rfl | h
  · exact (tendsto_congr' <| isEquivalent_zero_iff_eventually_zero.mp hu).mpr tendsto_const_nhds
  · 

Proof state:
case inr
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
hu : u ~[l] const α c
h : ¬c = 0
⊢ Tendsto u l (𝓝 c)

Next tactic:
exact (isEquivalent_const_iff_tendsto h).mp hu
theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (𝓝 c)) :
    Tendsto v l (𝓝 c) := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
⊢ Tendsto v l (𝓝 c)

Next tactic:
by_cases h : c = 0
theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (𝓝 c)) :
    Tendsto v l (𝓝 c) := by
  by_cases h : c = 0
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
h : c = 0
⊢ Tendsto v l (𝓝 c)

Next tactic:
subst c
theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (𝓝 c)) :
    Tendsto v l (𝓝 c) := by
  by_cases h : c = 0
  · subst c
    

Proof state:
case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hu : Tendsto u l (𝓝 0)
⊢ Tendsto v l (𝓝 0)

Next tactic:
rw [← isLittleO_one_iff ℝ] at hu ⊢
theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (𝓝 c)) :
    Tendsto v l (𝓝 c) := by
  by_cases h : c = 0
  · subst c
    rw [← isLittleO_one_iff ℝ] at hu ⊢
    

Proof state:
case pos
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hu : u =o[l] fun _x => 1
⊢ v =o[l] fun _x => 1

Next tactic:
simpa using (huv.symm.isLittleO.trans hu).add hu
theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (𝓝 c)) :
    Tendsto v l (𝓝 c) := by
  by_cases h : c = 0
  · subst c
    rw [← isLittleO_one_iff ℝ] at hu ⊢
    simpa using (huv.symm.isLittleO.trans hu).add hu
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : Tendsto u l (𝓝 c)
h : ¬c = 0
⊢ Tendsto v l (𝓝 c)

Next tactic:
rw [← isEquivalent_const_iff_tendsto h] at hu ⊢
theorem IsEquivalent.tendsto_nhds {c : β} (huv : u ~[l] v) (hu : Tendsto u l (𝓝 c)) :
    Tendsto v l (𝓝 c) := by
  by_cases h : c = 0
  · subst c
    rw [← isLittleO_one_iff ℝ] at hu ⊢
    simpa using (huv.symm.isLittleO.trans hu).add hu
  · rw [← isEquivalent_const_iff_tendsto h] at hu ⊢
    

Proof state:
case neg
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
huv : u ~[l] v
hu : u ~[l] const α c
h : ¬c = 0
⊢ v ~[l] const α c

Next tactic:
exact huv.symm.trans hu
theorem IsEquivalent.add_isLittleO (huv : u ~[l] v) (hwv : w =o[l] v) : u + w ~[l] v := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hwv : w =o[l] v
⊢ u + w ~[l] v

Next tactic:
simpa only [IsEquivalent, add_sub_right_comm] using huv.add hwv
theorem IsEquivalent.sub_isLittleO (huv : u ~[l] v) (hwv : w =o[l] v) : u - w ~[l] v := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
hwv : w =o[l] v
⊢ u - w ~[l] v

Next tactic:
simpa only [sub_eq_add_neg] using huv.add_isLittleO hwv.neg_left
theorem IsEquivalent.neg (huv : u ~[l] v) : (fun x ↦ -u x) ~[l] fun x ↦ -v x := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
⊢ (fun x => -u x) ~[l] fun x => -v x

Next tactic:
rw [IsEquivalent]
theorem IsEquivalent.neg (huv : u ~[l] v) : (fun x ↦ -u x) ~[l] fun x ↦ -v x := by
  rw [IsEquivalent]
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
⊢ ((fun x => -u x) - fun x => -v x) =o[l] fun x => -v x

Next tactic:
convert huv.isLittleO.neg_left.neg_right
theorem IsEquivalent.neg (huv : u ~[l] v) : (fun x ↦ -u x) ~[l] fun x ↦ -v x := by
  rw [IsEquivalent]
  convert huv.isLittleO.neg_left.neg_right
  

Proof state:
case h.e'_7.h
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
huv : u ~[l] v
x✝ : α
⊢ ((fun x => -u x) - fun x => -v x) x✝ = -(u - v) x✝

Next tactic:
simp [neg_add_eq_sub]
theorem isEquivalent_iff_exists_eq_mul :
    u ~[l] v ↔ ∃ (φ : α → β) (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
⊢ u ~[l] v ↔ ∃ φ, ∃ (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v

Next tactic:
rw [IsEquivalent, isLittleO_iff_exists_eq_mul]
theorem isEquivalent_iff_exists_eq_mul :
    u ~[l] v ↔ ∃ (φ : α → β) (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v := by
  rw [IsEquivalent, isLittleO_iff_exists_eq_mul]
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
⊢ (∃ φ, ∃ (_ : Tendsto φ l (𝓝 0)), u - v =ᶠ[l] φ * v) ↔ ∃ φ, ∃ (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v

Next tactic:
constructor <;> rintro ⟨φ, hφ, h⟩ <;> [refine' ⟨φ + 1, _, _⟩; refine' ⟨φ - 1, _, _⟩]
theorem isEquivalent_iff_exists_eq_mul :
    u ~[l] v ↔ ∃ (φ : α → β) (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v := by
  rw [IsEquivalent, isLittleO_iff_exists_eq_mul]
  

Proof state:
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
⊢ (∃ φ, ∃ (_ : Tendsto φ l (𝓝 0)), u - v =ᶠ[l] φ * v) ↔ ∃ φ, ∃ (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v

Next tactic:
constructor
theorem isEquivalent_iff_exists_eq_mul :
    u ~[l] v ↔ ∃ (φ : α → β) (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v := by
  rw [IsEquivalent, isLittleO_iff_exists_eq_mul]
  constructor <;> 

Proof state:
case mp
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
⊢ (∃ φ, ∃ (_ : Tendsto φ l (𝓝 0)), u - v =ᶠ[l] φ * v) → ∃ φ, ∃ (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v

Next tactic:
rintro ⟨φ, hφ, h⟩
theorem isEquivalent_iff_exists_eq_mul :
    u ~[l] v ↔ ∃ (φ : α → β) (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v := by
  rw [IsEquivalent, isLittleO_iff_exists_eq_mul]
  constructor <;> 

Proof state:
case mpr
α : Type u_1
β : Type u_2
inst✝ : NormedField β
t u v w : α → β
l : Filter α
⊢ (∃ φ, ∃ (_ : Tendsto φ l (𝓝 1)), u =ᶠ[l] φ * v) → ∃ φ, ∃ (_ : Tendsto φ l (𝓝 0)), u - v =ᶠ[l] φ * v

Next tactic:
rintro ⟨φ, hφ, h⟩