Theorem: Complex.GammaAux_recurrence1
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

tactic: induction' n with n hn generalizing s
state_before: s : ℂ
n : ℕ
h1 : -s.re < ↑n
⊢ GammaAux n s = GammaAux n (s + 1) / s
state_after: case zero
s : ℂ
h1 : -s.re < ↑0
⊢ GammaAux 0 s = GammaAux 0 (s + 1) / s

case succ
n : ℕ
hn : ∀ (s : ℂ), -s.re < ↑n → GammaAux n s = GammaAux n (s + 1) / s
s : ℂ
h1 : -s.re < ↑(n + 1)
⊢ GammaAux (n + 1) s = GammaAux (n + 1) (s + 1) / s

tactic: simp only [Nat.zero_eq, CharP.cast_eq_zero, Left.neg_neg_iff] at h1
state_before: case zero
s : ℂ
h1 : -s.re < ↑0
⊢ GammaAux 0 s = GammaAux 0 (s + 1) / s
state_after: case zero
s : ℂ
h1 : 0 < s.re
⊢ GammaAux 0 s = GammaAux 0 (s + 1) / s

tactic: dsimp only [GammaAux]
state_before: case zero
s : ℂ
h1 : 0 < s.re
⊢ GammaAux 0 s = GammaAux 0 (s + 1) / s
state_after: case zero
s : ℂ
h1 : 0 < s.re
⊢ s.GammaIntegral = (s + 1).GammaIntegral / s

tactic: rw [GammaIntegral_add_one h1]
state_before: case zero
s : ℂ
h1 : 0 < s.re
⊢ s.GammaIntegral = (s + 1).GammaIntegral / s
state_after: case zero
s : ℂ
h1 : 0 < s.re
⊢ s.GammaIntegral = s * s.GammaIntegral / s

tactic: rw [mul_comm, mul_div_cancel_right₀]
state_before: case zero
s : ℂ
h1 : 0 < s.re
⊢ s.GammaIntegral = s * s.GammaIntegral / s
state_after: case zero.hb
s : ℂ
h1 : 0 < s.re
⊢ s ≠ 0

tactic: contrapose! h1
state_before: case zero.hb
s : ℂ
h1 : 0 < s.re
⊢ s ≠ 0
state_after: case zero.hb
s : ℂ
h1 : s = 0
⊢ s.re ≤ 0

tactic: rw [h1]
state_before: case zero.hb
s : ℂ
h1 : s = 0
⊢ s.re ≤ 0
state_after: case zero.hb
s : ℂ
h1 : s = 0
⊢ re 0 ≤ 0

tactic: simp
state_before: case zero.hb
s : ℂ
h1 : s = 0
⊢ re 0 ≤ 0
state_after: no goals

tactic: dsimp only [GammaAux]
state_before: case succ
n : ℕ
hn : ∀ (s : ℂ), -s.re < ↑n → GammaAux n s = GammaAux n (s + 1) / s
s : ℂ
h1 : -s.re < ↑(n + 1)
⊢ GammaAux (n + 1) s = GammaAux (n + 1) (s + 1) / s
state_after: case succ
n : ℕ
hn : ∀ (s : ℂ), -s.re < ↑n → GammaAux n s = GammaAux n (s + 1) / s
s : ℂ
h1 : -s.re < ↑(n + 1)
⊢ GammaAux n (s + 1) / s = GammaAux n (s + 1 + 1) / (s + 1) / s

tactic: have hh1 : -(s + 1).re < n := by
  rw [Nat.cast_add, Nat.cast_one] at h1
  rw [add_re, one_re]; linarith
state_before: case succ
n : ℕ
hn : ∀ (s : ℂ), -s.re < ↑n → GammaAux n s = GammaAux n (s + 1) / s
s : ℂ
h1 : -s.re < ↑(n + 1)
⊢ GammaAux n (s + 1) / s = GammaAux n (s + 1 + 1) / (s + 1) / s
state_after: case succ
n : ℕ
hn : ∀ (s : ℂ), -s.re < ↑n → GammaAux n s = GammaAux n (s + 1) / s
s : ℂ
h1 : -s.re < ↑(n + 1)
hh1 : -(s + 1).re < ↑n
⊢ GammaAux n (s + 1) / s = GammaAux n (s + 1 + 1) / (s + 1) / s

tactic: rw [← hn (s + 1) hh1]
state_before: case succ
n : ℕ
hn : ∀ (s : ℂ), -s.re < ↑n → GammaAux n s = GammaAux n (s + 1) / s
s : ℂ
h1 : -s.re < ↑(n + 1)
hh1 : -(s + 1).re < ↑n
⊢ GammaAux n (s + 1) / s = GammaAux n (s + 1 + 1) / (s + 1) / s
state_after: no goals

tactic: rw [Nat.cast_add, Nat.cast_one] at h1
state_before: n : ℕ
hn : ∀ (s : ℂ), -s.re < ↑n → GammaAux n s = GammaAux n (s + 1) / s
s : ℂ
h1 : -s.re < ↑(n + 1)
⊢ -(s + 1).re < ↑n
state_after: n : ℕ
hn : ∀ (s : ℂ), -s.re < ↑n → GammaAux n s = GammaAux n (s + 1) / s
s : ℂ
h1 : -s.re < ↑n + 1
⊢ -(s + 1).re < ↑n

tactic: rw [add_re, one_re]
state_before: n : ℕ
hn : ∀ (s : ℂ), -s.re < ↑n → GammaAux n s = GammaAux n (s + 1) / s
s : ℂ
h1 : -s.re < ↑n + 1
⊢ -(s + 1).re < ↑n
state_after: n : ℕ
hn : ∀ (s : ℂ), -s.re < ↑n → GammaAux n s = GammaAux n (s + 1) / s
s : ℂ
h1 : -s.re < ↑n + 1
⊢ -(s.re + 1) < ↑n

tactic: linarith
state_before: n : ℕ
hn : ∀ (s : ℂ), -s.re < ↑n → GammaAux n s = GammaAux n (s + 1) / s
s : ℂ
h1 : -s.re < ↑n + 1
⊢ -(s.re + 1) < ↑n
state_after: no goals