l3lab/ntp-mathlib huggingface dataset:
theorem hasStrictDerivAt_rpow_const {x p : ℝ} (hx : x ≠ 0 ∨ 1 ≤ p) :
    HasStrictDerivAt (fun x => x ^ p) (p * x ^ (p - 1)) x :=
  ContDiffAt.hasStrictDerivAt' (contDiffAt_rpow_const (by 

Proof state:
z x✝ y x p : ℝ
hx : x ≠ 0 ∨ 1 ≤ p
⊢ x ≠ 0 ∨ ↑One.one ≤ p

Next tactic:
rwa [← Nat.cast_one] at hx
theorem ContDiffAt.rpow_const_of_le (hf : ContDiffAt ℝ m f x) (h : ↑m ≤ p) :
    ContDiffAt ℝ m (fun x => f x ^ p) x := by
  

Proof state:
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : E → ℝ
f' g' : E →L[ℝ] ℝ
x : E
s : Set E
c p : ℝ
n : ℕ∞
m : ℕ
hf : ContDiffAt ℝ (↑m) f x
h : ↑m ≤ p
⊢ ContDiffAt ℝ (↑m) (fun x => f x ^ p) x

Next tactic:
rw [← contDiffWithinAt_univ] at *
theorem ContDiffAt.rpow_const_of_le (hf : ContDiffAt ℝ m f x) (h : ↑m ≤ p) :
    ContDiffAt ℝ m (fun x => f x ^ p) x := by
  rw [← contDiffWithinAt_univ] at *; 

Proof state:
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : E → ℝ
f' g' : E →L[ℝ] ℝ
x : E
s : Set E
c p : ℝ
n : ℕ∞
m : ℕ
hf : ContDiffWithinAt ℝ (↑m) f Set.univ x
h : ↑m ≤ p
⊢ ContDiffWithinAt ℝ (↑m) (fun x => f x ^ p) Set.univ x

Next tactic:
exact hf.rpow_const_of_le h
theorem HasDerivWithinAt.rpow (hf : HasDerivWithinAt f f' s x) (hg : HasDerivWithinAt g g' s x)
    (h : 0 < f x) : HasDerivWithinAt (fun x => f x ^ g x)
      (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) s x := by
  

Proof state:
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
h : 0 < f x
⊢ HasDerivWithinAt (fun x => f x ^ g x) (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) s x

Next tactic:
convert (hf.hasFDerivWithinAt.rpow hg.hasFDerivWithinAt h).hasDerivWithinAt using 1
theorem HasDerivWithinAt.rpow (hf : HasDerivWithinAt f f' s x) (hg : HasDerivWithinAt g g' s x)
    (h : 0 < f x) : HasDerivWithinAt (fun x => f x ^ g x)
      (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) s x := by
  convert (hf.hasFDerivWithinAt.rpow hg.hasFDerivWithinAt h).hasDerivWithinAt using 1
  

Proof state:
case h.e'_7
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
h : 0 < f x
⊢ f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x) =
    ((g x * f x ^ (g x - 1)) • ContinuousLinearMap.smulRight 1 f' +
        (f x ^ g x * Real.log (f x)) • ContinuousLinearMap.smulRight 1 g')
      1

Next tactic:
dsimp
theorem HasDerivWithinAt.rpow (hf : HasDerivWithinAt f f' s x) (hg : HasDerivWithinAt g g' s x)
    (h : 0 < f x) : HasDerivWithinAt (fun x => f x ^ g x)
      (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) s x := by
  convert (hf.hasFDerivWithinAt.rpow hg.hasFDerivWithinAt h).hasDerivWithinAt using 1
  dsimp; 

Proof state:
case h.e'_7
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hg : HasDerivWithinAt g g' s x
h : 0 < f x
⊢ f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x) =
    g x * f x ^ (g x - 1) * (1 * f') + f x ^ g x * Real.log (f x) * (1 * g')

Next tactic:
ring
theorem HasDerivAt.rpow (hf : HasDerivAt f f' x) (hg : HasDerivAt g g' x) (h : 0 < f x) :
    HasDerivAt (fun x => f x ^ g x)
      (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) x := by
  

Proof state:
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivAt f f' x
hg : HasDerivAt g g' x
h : 0 < f x
⊢ HasDerivAt (fun x => f x ^ g x) (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) x

Next tactic:
rw [← hasDerivWithinAt_univ] at *
theorem HasDerivAt.rpow (hf : HasDerivAt f f' x) (hg : HasDerivAt g g' x) (h : 0 < f x) :
    HasDerivAt (fun x => f x ^ g x)
      (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) x := by
  rw [← hasDerivWithinAt_univ] at *
  

Proof state:
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' Set.univ x
hg : HasDerivWithinAt g g' Set.univ x
h : 0 < f x
⊢ HasDerivWithinAt (fun x => f x ^ g x) (f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) Set.univ x

Next tactic:
exact hf.rpow hg h
theorem HasDerivWithinAt.rpow_const (hf : HasDerivWithinAt f f' s x) (hx : f x ≠ 0 ∨ 1 ≤ p) :
    HasDerivWithinAt (fun y => f y ^ p) (f' * p * f x ^ (p - 1)) s x := by
  

Proof state:
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hx : f x ≠ 0 ∨ 1 ≤ p
⊢ HasDerivWithinAt (fun y => f y ^ p) (f' * p * f x ^ (p - 1)) s x

Next tactic:
convert (hasDerivAt_rpow_const hx).comp_hasDerivWithinAt x hf using 1
theorem HasDerivWithinAt.rpow_const (hf : HasDerivWithinAt f f' s x) (hx : f x ≠ 0 ∨ 1 ≤ p) :
    HasDerivWithinAt (fun y => f y ^ p) (f' * p * f x ^ (p - 1)) s x := by
  convert (hasDerivAt_rpow_const hx).comp_hasDerivWithinAt x hf using 1
  

Proof state:
case h.e'_7
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' s x
hx : f x ≠ 0 ∨ 1 ≤ p
⊢ f' * p * f x ^ (p - 1) = p * f x ^ (p - 1) * f'

Next tactic:
ring
theorem HasDerivAt.rpow_const (hf : HasDerivAt f f' x) (hx : f x ≠ 0 ∨ 1 ≤ p) :
    HasDerivAt (fun y => f y ^ p) (f' * p * f x ^ (p - 1)) x := by
  

Proof state:
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivAt f f' x
hx : f x ≠ 0 ∨ 1 ≤ p
⊢ HasDerivAt (fun y => f y ^ p) (f' * p * f x ^ (p - 1)) x

Next tactic:
rw [← hasDerivWithinAt_univ] at *
theorem HasDerivAt.rpow_const (hf : HasDerivAt f f' x) (hx : f x ≠ 0 ∨ 1 ≤ p) :
    HasDerivAt (fun y => f y ^ p) (f' * p * f x ^ (p - 1)) x := by
  rw [← hasDerivWithinAt_univ] at *
  

Proof state:
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' Set.univ x
hx : f x ≠ 0 ∨ 1 ≤ p
⊢ HasDerivWithinAt (fun y => f y ^ p) (f' * p * f x ^ (p - 1)) Set.univ x

Next tactic:
exact hf.rpow_const hx
lemma isTheta_deriv_rpow_const_atTop {p : ℝ} (hp : p ≠ 0) :
    deriv (fun (x:ℝ) => x ^ p) =Θ[atTop] fun x => x ^ (p-1) := by
  

Proof state:
f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
⊢ (deriv fun x => x ^ p) =Θ[atTop] fun x => x ^ (p - 1)

Next tactic:
calc deriv (fun (x:ℝ) => x ^ p) =ᶠ[atTop] fun x => p * x ^ (p - 1) := by
              filter_upwards [eventually_ne_atTop 0] with x hx
              rw [Real.deriv_rpow_const (Or.inl hx)]
       _ =Θ[atTop] fun x => x ^ (p-1) :=
              Asymptotics.IsTheta.const_mul_left hp Asymptotics.isTheta_rfl
lemma isTheta_deriv_rpow_const_atTop {p : ℝ} (hp : p ≠ 0) :
    deriv (fun (x:ℝ) => x ^ p) =Θ[atTop] fun x => x ^ (p-1) := by
  calc deriv (fun (x:ℝ) => x ^ p) =ᶠ[atTop] fun x => p * x ^ (p - 1) := by
              

Proof state:
f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
⊢ (deriv fun x => x ^ p) =ᶠ[atTop] fun x => p * x ^ (p - 1)

Next tactic:
filter_upwards [eventually_ne_atTop 0] with x hx
lemma isTheta_deriv_rpow_const_atTop {p : ℝ} (hp : p ≠ 0) :
    deriv (fun (x:ℝ) => x ^ p) =Θ[atTop] fun x => x ^ (p-1) := by
  calc deriv (fun (x:ℝ) => x ^ p) =ᶠ[atTop] fun x => p * x ^ (p - 1) := by
              filter_upwards [eventually_ne_atTop 0] with x hx
              

Proof state:
case h
f g : ℝ → ℝ
f' g' x✝ y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
x : ℝ
hx : x ≠ 0
⊢ deriv (fun x => x ^ p) x = p * x ^ (p - 1)

Next tactic:
rw [Real.deriv_rpow_const (Or.inl hx)]
lemma isBigO_deriv_rpow_const_atTop (p : ℝ) :
    deriv (fun (x:ℝ) => x ^ p) =O[atTop] fun x => x ^ (p-1) := by
  

Proof state:
f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
⊢ (deriv fun x => x ^ p) =O[atTop] fun x => x ^ (p - 1)

Next tactic:
rcases eq_or_ne p 0 with rfl | hp
lemma isBigO_deriv_rpow_const_atTop (p : ℝ) :
    deriv (fun (x:ℝ) => x ^ p) =O[atTop] fun x => x ^ (p-1) := by
  rcases eq_or_ne p 0 with rfl | hp
  

Proof state:
case inl
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
⊢ (deriv fun x => x ^ 0) =O[atTop] fun x => x ^ (0 - 1)
case inr f g : ℝ → ℝ f' g' x y p✝ : ℝ s : Set ℝ p : ℝ hp : p ≠ 0 ⊢ (deriv fun x => x ^ p) =O[atTop] fun x => x ^ (p - 1)

Next tactic:
case inl =>
    simp [zero_sub, Real.rpow_neg_one, Real.rpow_zero, deriv_const', Asymptotics.isBigO_zero]
lemma isBigO_deriv_rpow_const_atTop (p : ℝ) :
    deriv (fun (x:ℝ) => x ^ p) =O[atTop] fun x => x ^ (p-1) := by
  rcases eq_or_ne p 0 with rfl | hp
  

Proof state:
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
⊢ (deriv fun x => x ^ 0) =O[atTop] fun x => x ^ (0 - 1)

Next tactic:
case inl =>
    simp [zero_sub, Real.rpow_neg_one, Real.rpow_zero, deriv_const', Asymptotics.isBigO_zero]
lemma isBigO_deriv_rpow_const_atTop (p : ℝ) :
    deriv (fun (x:ℝ) => x ^ p) =O[atTop] fun x => x ^ (p-1) := by
  rcases eq_or_ne p 0 with rfl | hp
  case inl =>
    

Proof state:
f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
⊢ (deriv fun x => x ^ 0) =O[atTop] fun x => x ^ (0 - 1)

Next tactic:
simp [zero_sub, Real.rpow_neg_one, Real.rpow_zero, deriv_const', Asymptotics.isBigO_zero]
lemma isBigO_deriv_rpow_const_atTop (p : ℝ) :
    deriv (fun (x:ℝ) => x ^ p) =O[atTop] fun x => x ^ (p-1) := by
  rcases eq_or_ne p 0 with rfl | hp
  case inl =>
    simp [zero_sub, Real.rpow_neg_one, Real.rpow_zero, deriv_const', Asymptotics.isBigO_zero]
  

Proof state:
case inr
f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
⊢ (deriv fun x => x ^ p) =O[atTop] fun x => x ^ (p - 1)

Next tactic:
case inr =>
    exact (isTheta_deriv_rpow_const_atTop hp).1
lemma isBigO_deriv_rpow_const_atTop (p : ℝ) :
    deriv (fun (x:ℝ) => x ^ p) =O[atTop] fun x => x ^ (p-1) := by
  rcases eq_or_ne p 0 with rfl | hp
  case inl =>
    simp [zero_sub, Real.rpow_neg_one, Real.rpow_zero, deriv_const', Asymptotics.isBigO_zero]
  

Proof state:
f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
⊢ (deriv fun x => x ^ p) =O[atTop] fun x => x ^ (p - 1)

Next tactic:
case inr =>
    exact (isTheta_deriv_rpow_const_atTop hp).1
lemma isBigO_deriv_rpow_const_atTop (p : ℝ) :
    deriv (fun (x:ℝ) => x ^ p) =O[atTop] fun x => x ^ (p-1) := by
  rcases eq_or_ne p 0 with rfl | hp
  case inl =>
    simp [zero_sub, Real.rpow_neg_one, Real.rpow_zero, deriv_const', Asymptotics.isBigO_zero]
  case inr =>
    

Proof state:
f g : ℝ → ℝ
f' g' x y p✝ : ℝ
s : Set ℝ
p : ℝ
hp : p ≠ 0
⊢ (deriv fun x => x ^ p) =O[atTop] fun x => x ^ (p - 1)

Next tactic:
exact (isTheta_deriv_rpow_const_atTop hp).1
/-- The function `(1 + t/x) ^ x` tends to `exp t` at `+∞`. -/
theorem tendsto_one_plus_div_rpow_exp (t : ℝ) :
    Tendsto (fun x : ℝ => (1 + t / x) ^ x) atTop (𝓝 (exp t)) := by
  

Proof state:
t : ℝ
⊢ Tendsto (fun x => (1 + t / x) ^ x) atTop (𝓝 (rexp t))

Next tactic:
apply ((Real.continuous_exp.tendsto _).comp (tendsto_mul_log_one_plus_div_atTop t)).congr' _
/-- The function `(1 + t/x) ^ x` tends to `exp t` at `+∞`. -/
theorem tendsto_one_plus_div_rpow_exp (t : ℝ) :
    Tendsto (fun x : ℝ => (1 + t / x) ^ x) atTop (𝓝 (exp t)) := by
  apply ((Real.continuous_exp.tendsto _).comp (tendsto_mul_log_one_plus_div_atTop t)).congr' _
  

Proof state:
t : ℝ
⊢ (rexp ∘ fun x => x * log (1 + t / x)) =ᶠ[atTop] fun x => (1 + t / x) ^ x

Next tactic:
have h₁ : (1 : ℝ) / 2 < 1 := by linarith
/-- The function `(1 + t/x) ^ x` tends to `exp t` at `+∞`. -/
theorem tendsto_one_plus_div_rpow_exp (t : ℝ) :
    Tendsto (fun x : ℝ => (1 + t / x) ^ x) atTop (𝓝 (exp t)) := by
  apply ((Real.continuous_exp.tendsto _).comp (tendsto_mul_log_one_plus_div_atTop t)).congr' _
  have h₁ : (1 : ℝ) / 2 < 1 := by 

Proof state:
t : ℝ
⊢ 1 / 2 < 1

Next tactic:
linarith
/-- The function `(1 + t/x) ^ x` tends to `exp t` at `+∞`. -/
theorem tendsto_one_plus_div_rpow_exp (t : ℝ) :
    Tendsto (fun x : ℝ => (1 + t / x) ^ x) atTop (𝓝 (exp t)) := by
  apply ((Real.continuous_exp.tendsto _).comp (tendsto_mul_log_one_plus_div_atTop t)).congr' _
  have h₁ : (1 : ℝ) / 2 < 1 := by linarith
  

Proof state:
t : ℝ
h₁ : 1 / 2 < 1
⊢ (rexp ∘ fun x => x * log (1 + t / x)) =ᶠ[atTop] fun x => (1 + t / x) ^ x

Next tactic:
have h₂ : Tendsto (fun x : ℝ => 1 + t / x) atTop (𝓝 1) := by
    simpa using (tendsto_inv_atTop_zero.const_mul t).const_add 1
/-- The function `(1 + t/x) ^ x` tends to `exp t` at `+∞`. -/
theorem tendsto_one_plus_div_rpow_exp (t : ℝ) :
    Tendsto (fun x : ℝ => (1 + t / x) ^ x) atTop (𝓝 (exp t)) := by
  apply ((Real.continuous_exp.tendsto _).comp (tendsto_mul_log_one_plus_div_atTop t)).congr' _
  have h₁ : (1 : ℝ) / 2 < 1 := by linarith
  have h₂ : Tendsto (fun x : ℝ => 1 + t / x) atTop (𝓝 1) := by
    

Proof state:
t : ℝ
h₁ : 1 / 2 < 1
⊢ Tendsto (fun x => 1 + t / x) atTop (𝓝 1)

Next tactic:
simpa using (tendsto_inv_atTop_zero.const_mul t).const_add 1
/-- The function `(1 + t/x) ^ x` tends to `exp t` at `+∞`. -/
theorem tendsto_one_plus_div_rpow_exp (t : ℝ) :
    Tendsto (fun x : ℝ => (1 + t / x) ^ x) atTop (𝓝 (exp t)) := by
  apply ((Real.continuous_exp.tendsto _).comp (tendsto_mul_log_one_plus_div_atTop t)).congr' _
  have h₁ : (1 : ℝ) / 2 < 1 := by linarith
  have h₂ : Tendsto (fun x : ℝ => 1 + t / x) atTop (𝓝 1) := by
    simpa using (tendsto_inv_atTop_zero.const_mul t).const_add 1
  

Proof state:
t : ℝ
h₁ : 1 / 2 < 1
h₂ : Tendsto (fun x => 1 + t / x) atTop (𝓝 1)
⊢ (rexp ∘ fun x => x * log (1 + t / x)) =ᶠ[atTop] fun x => (1 + t / x) ^ x

Next tactic:
refine' (eventually_ge_of_tendsto_gt h₁ h₂).mono fun x hx => _
/-- The function `(1 + t/x) ^ x` tends to `exp t` at `+∞`. -/
theorem tendsto_one_plus_div_rpow_exp (t : ℝ) :
    Tendsto (fun x : ℝ => (1 + t / x) ^ x) atTop (𝓝 (exp t)) := by
  apply ((Real.continuous_exp.tendsto _).comp (tendsto_mul_log_one_plus_div_atTop t)).congr' _
  have h₁ : (1 : ℝ) / 2 < 1 := by linarith
  have h₂ : Tendsto (fun x : ℝ => 1 + t / x) atTop (𝓝 1) := by
    simpa using (tendsto_inv_atTop_zero.const_mul t).const_add 1
  refine' (eventually_ge_of_tendsto_gt h₁ h₂).mono fun x hx => _
  

Proof state:
t : ℝ
h₁ : 1 / 2 < 1
h₂ : Tendsto (fun x => 1 + t / x) atTop (𝓝 1)
x : ℝ
hx : 1 / 2 ≤ 1 + t / x
⊢ (rexp ∘ fun x => x * log (1 + t / x)) x = (fun x => (1 + t / x) ^ x) x

Next tactic:
have hx' : 0 < 1 + t / x := by linarith
/-- The function `(1 + t/x) ^ x` tends to `exp t` at `+∞`. -/
theorem tendsto_one_plus_div_rpow_exp (t : ℝ) :
    Tendsto (fun x : ℝ => (1 + t / x) ^ x) atTop (𝓝 (exp t)) := by
  apply ((Real.continuous_exp.tendsto _).comp (tendsto_mul_log_one_plus_div_atTop t)).congr' _
  have h₁ : (1 : ℝ) / 2 < 1 := by linarith
  have h₂ : Tendsto (fun x : ℝ => 1 + t / x) atTop (𝓝 1) := by
    simpa using (tendsto_inv_atTop_zero.const_mul t).const_add 1
  refine' (eventually_ge_of_tendsto_gt h₁ h₂).mono fun x hx => _
  have hx' : 0 < 1 + t / x := by 

Proof state:
t : ℝ
h₁ : 1 / 2 < 1
h₂ : Tendsto (fun x => 1 + t / x) atTop (𝓝 1)
x : ℝ
hx : 1 / 2 ≤ 1 + t / x
⊢ 0 < 1 + t / x

Next tactic:
linarith
/-- The function `(1 + t/x) ^ x` tends to `exp t` at `+∞`. -/
theorem tendsto_one_plus_div_rpow_exp (t : ℝ) :
    Tendsto (fun x : ℝ => (1 + t / x) ^ x) atTop (𝓝 (exp t)) := by
  apply ((Real.continuous_exp.tendsto _).comp (tendsto_mul_log_one_plus_div_atTop t)).congr' _
  have h₁ : (1 : ℝ) / 2 < 1 := by linarith
  have h₂ : Tendsto (fun x : ℝ => 1 + t / x) atTop (𝓝 1) := by
    simpa using (tendsto_inv_atTop_zero.const_mul t).const_add 1
  refine' (eventually_ge_of_tendsto_gt h₁ h₂).mono fun x hx => _
  have hx' : 0 < 1 + t / x := by linarith
  

Proof state:
t : ℝ
h₁ : 1 / 2 < 1
h₂ : Tendsto (fun x => 1 + t / x) atTop (𝓝 1)
x : ℝ
hx : 1 / 2 ≤ 1 + t / x
hx' : 0 < 1 + t / x
⊢ (rexp ∘ fun x => x * log (1 + t / x)) x = (fun x => (1 + t / x) ^ x) x

Next tactic:
simp [mul_comm x, exp_mul, exp_log hx']
/-- The function `(1 + t/x) ^ x` tends to `exp t` at `+∞` for naturals `x`. -/
theorem tendsto_one_plus_div_pow_exp (t : ℝ) :
    Tendsto (fun x : ℕ => (1 + t / (x : ℝ)) ^ x) atTop (𝓝 (Real.exp t)) :=
  ((tendsto_one_plus_div_rpow_exp t).comp tendsto_nat_cast_atTop_atTop).congr (by 

Proof state:
t : ℝ
⊢ ∀ (x : ℕ), ((fun x => (1 + t / x) ^ x) ∘ Nat.cast) x = (1 + t / ↑x) ^ x

Next tactic:
simp
@[reassoc]
lemma comm (h : HomologyMapData φ h₁ h₂) :
    h.left.φH ≫ h₂.iso.hom = h₁.iso.hom ≫ h.right.φH := by
  

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
h : HomologyMapData φ h₁ h₂
⊢ h.left.φH ≫ h₂.iso.hom = h₁.iso.hom ≫ h.right.φH

Next tactic:
simp only [← cancel_epi h₁.left.π, ← cancel_mono h₂.right.ι, assoc,
    LeftHomologyMapData.commπ_assoc, HomologyData.comm, LeftHomologyMapData.commi_assoc,
    RightHomologyMapData.commι, HomologyData.comm_assoc, RightHomologyMapData.commp]
instance : Subsingleton (HomologyMapData φ h₁ h₂) := ⟨by
  

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
⊢ ∀ (a b : HomologyMapData φ h₁ h₂), a = b

Next tactic:
rintro ⟨left₁, right₁⟩ ⟨left₂, right₂⟩
instance : Subsingleton (HomologyMapData φ h₁ h₂) := ⟨by
  rintro ⟨left₁, right₁⟩ ⟨left₂, right₂⟩
  

Proof state:
case mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
left₁ : LeftHomologyMapData φ h₁.left h₂.left
right₁ : RightHomologyMapData φ h₁.right h₂.right
left₂ : LeftHomologyMapData φ h₁.left h₂.left
right₂ : RightHomologyMapData φ h₁.right h₂.right
⊢ { left := left₁, right := right₁ } = { left := left₂, right := right₂ }

Next tactic:
simp only [mk.injEq, eq_iff_true_of_subsingleton, and_self]
lemma congr_left_φH {γ₁ γ₂ : HomologyMapData φ h₁ h₂} (eq : γ₁ = γ₂) :
    γ₁.left.φH = γ₂.left.φH := by 

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
γ₁ γ₂ : HomologyMapData φ h₁ h₂
eq : γ₁ = γ₂
⊢ γ₁.left.φH = γ₂.left.φH

Next tactic:
rw [eq]
/-- A homology data for a short complex `S` induces a homology data for `S.op`. -/
@[simps]
def op (h : S.HomologyData) : S.op.HomologyData where
  left := h.right.op
  right := h.left.op
  iso := h.iso.op
  comm := Quiver.Hom.unop_inj (by 

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
h : HomologyData S
⊢ ((RightHomologyData.op h.right).π ≫ (Iso.op h.iso).hom ≫ (LeftHomologyData.op h.left).ι).unop =
    ((RightHomologyData.op h.right).i ≫ (LeftHomologyData.op h.left).p).unop

Next tactic:
simp
/-- A homology data for a short complex `S` in the opposite category
induces a homology data for `S.unop`. -/
@[simps]
def unop {S : ShortComplex Cᵒᵖ} (h : S.HomologyData) : S.unop.HomologyData where
  left := h.right.unop
  right := h.left.unop
  iso := h.iso.unop
  comm := Quiver.Hom.op_inj (by 

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S✝ S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
S : ShortComplex Cᵒᵖ
h : HomologyData S
⊢ ((RightHomologyData.unop h.right).π ≫ (Iso.unop h.iso).hom ≫ (LeftHomologyData.unop h.left).ι).op =
    ((RightHomologyData.unop h.right).i ≫ (LeftHomologyData.unop h.left).p).op

Next tactic:
simp
@[simp]
lemma LeftHomologyData.homologyIso_leftHomologyData [S.HasHomology] :
    S.leftHomologyData.homologyIso = S.leftHomologyIso.symm := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
inst✝ : HasHomology S
⊢ homologyIso (leftHomologyData S) = (ShortComplex.leftHomologyIso S).symm

Next tactic:
ext
@[simp]
lemma LeftHomologyData.homologyIso_leftHomologyData [S.HasHomology] :
    S.leftHomologyData.homologyIso = S.leftHomologyIso.symm := by
  ext
  

Proof state:
case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
inst✝ : HasHomology S
⊢ (homologyIso (leftHomologyData S)).hom = (ShortComplex.leftHomologyIso S).symm.hom

Next tactic:
dsimp [homologyIso, leftHomologyIso, ShortComplex.leftHomologyIso]
@[simp]
lemma LeftHomologyData.homologyIso_leftHomologyData [S.HasHomology] :
    S.leftHomologyData.homologyIso = S.leftHomologyIso.symm := by
  ext
  dsimp [homologyIso, leftHomologyIso, ShortComplex.leftHomologyIso]
  

Proof state:
case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
inst✝ : HasHomology S
⊢ leftHomologyMap' (𝟙 S) (homologyData S).left (leftHomologyData S) ≫
      leftHomologyMap' (𝟙 S) (leftHomologyData S) (leftHomologyData S) =
    leftHomologyMap' (𝟙 S) (homologyData S).left (leftHomologyData S)

Next tactic:
rw [← leftHomologyMap'_comp, comp_id]
@[simp]
lemma RightHomologyData.homologyIso_rightHomologyData [S.HasHomology] :
    S.rightHomologyData.homologyIso = S.rightHomologyIso.symm := by
  

Proof state:
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
inst✝ : HasHomology S
⊢ homologyIso (rightHomologyData S) = (ShortComplex.rightHomologyIso S).symm

Next tactic:
ext
@[simp]
lemma RightHomologyData.homologyIso_rightHomologyData [S.HasHomology] :
    S.rightHomologyData.homologyIso = S.rightHomologyIso.symm := by
  ext
  

Proof state:
case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
inst✝ : HasHomology S
⊢ (homologyIso (rightHomologyData S)).hom = (ShortComplex.rightHomologyIso S).symm.hom

Next tactic:
dsimp [homologyIso, rightHomologyIso]
@[simp]
lemma RightHomologyData.homologyIso_rightHomologyData [S.HasHomology] :
    S.rightHomologyData.homologyIso = S.rightHomologyIso.symm := by
  ext
  dsimp [homologyIso, rightHomologyIso]
  

Proof state:
case w
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : HomologyData S₁
h₂ : HomologyData S₂
inst✝ : HasHomology S
⊢ (ShortComplex.rightHomologyIso S).inv ≫ rightHomologyMap' (𝟙 S) (rightHomologyData S) (rightHomologyData S) =
    (ShortComplex.rightHomologyIso S).inv

Next tactic:
erw [rightHomologyMap'_id, comp_id]
lemma homologyMap_eq :
    homologyMap φ = h₁.homologyIso.hom ≫ γ.φH ≫ h₂.homologyIso.inv := by
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁✝ : HomologyData S₁
h₂✝ : HomologyData S₂
h₁ : LeftHomologyData S₁
h₂ : LeftHomologyData S₂
γ : LeftHomologyMapData φ h₁ h₂
inst✝¹ : HasHomology S₁
inst✝ : HasHomology S₂
⊢ homologyMap φ = (LeftHomologyData.homologyIso h₁).hom ≫ γ.φH ≫ (LeftHomologyData.homologyIso h₂).inv

Next tactic:
dsimp [homologyMap, LeftHomologyData.homologyIso, leftHomologyIso,
    LeftHomologyData.leftHomologyIso, homologyMap']
lemma homologyMap_eq :
    homologyMap φ = h₁.homologyIso.hom ≫ γ.φH ≫ h₂.homologyIso.inv := by
  dsimp [homologyMap, LeftHomologyData.homologyIso, leftHomologyIso,
    LeftHomologyData.leftHomologyIso, homologyMap']
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁✝ : HomologyData S₁
h₂✝ : HomologyData S₂
h₁ : LeftHomologyData S₁
h₂ : LeftHomologyData S₂
γ : LeftHomologyMapData φ h₁ h₂
inst✝¹ : HasHomology S₁
inst✝ : HasHomology S₂
⊢ leftHomologyMap' φ (homologyData S₁).left (homologyData S₂).left =
    (leftHomologyMap' (𝟙 S₁) (homologyData S₁).left (leftHomologyData S₁) ≫
        leftHomologyMap' (𝟙 S₁) (leftHomologyData S₁) h₁) ≫
      γ.φH ≫
        leftHomologyMap' (𝟙 S₂) h₂ (leftHomologyData S₂) ≫
          leftHomologyMap' (𝟙 S₂) (leftHomologyData S₂) (homologyData S₂).left

Next tactic:
simp only [← γ.leftHomologyMap'_eq, ← leftHomologyMap'_comp, id_comp, comp_id]
lemma homologyMap_comm :
    homologyMap φ ≫ h₂.homologyIso.hom = h₁.homologyIso.hom ≫ γ.φH := by
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁✝ : HomologyData S₁
h₂✝ : HomologyData S₂
h₁ : LeftHomologyData S₁
h₂ : LeftHomologyData S₂
γ : LeftHomologyMapData φ h₁ h₂
inst✝¹ : HasHomology S₁
inst✝ : HasHomology S₂
⊢ homologyMap φ ≫ (LeftHomologyData.homologyIso h₂).hom = (LeftHomologyData.homologyIso h₁).hom ≫ γ.φH

Next tactic:
simp only [γ.homologyMap_eq, assoc, Iso.inv_hom_id, comp_id]