File: Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean

full_name: Complex.betaIntegral
code: /-- The Beta function `Β (u, v)`, defined as `∫ x:ℝ in 0..1, x ^ (u - 1) * (1 - x) ^ (v - 1)`. -/
noncomputable def betaIntegral (u v : ℂ) : ℂ 
goal: ℂ

full_name: Complex.betaIntegral_convergent_left
code: /-- Auxiliary lemma for `betaIntegral_convergent`, showing convergence at the left endpoint. -/
theorem betaIntegral_convergent_left {u : ℂ} (hu : 0 < re u) (v : ℂ) :
    IntervalIntegrable (fun x =>
      (x : ℂ) ^ (u - 1) * (1 - (x : ℂ)) ^ (v - 1) : ℝ → ℂ) volume 0 (1 / 2) 
goal: IntervalIntegrable (fun x => ↑x ^ (u - 1) * (1 - ↑x) ^ (v - 1)) MeasureTheory.volume 0 (1 / 2)

full_name: Complex.betaIntegral_convergent
code: /-- The Beta integral is convergent for all `u, v` of positive real part. -/
theorem betaIntegral_convergent {u v : ℂ} (hu : 0 < re u) (hv : 0 < re v) :
    IntervalIntegrable (fun x =>
      (x : ℂ) ^ (u - 1) * (1 - (x : ℂ)) ^ (v - 1) : ℝ → ℂ) volume 0 1 
goal: IntervalIntegrable (fun x => ↑x ^ (u - 1) * (1 - ↑x) ^ (v - 1)) MeasureTheory.volume 0 1

full_name: Complex.betaIntegral_symm
code: theorem betaIntegral_symm (u v : ℂ) : betaIntegral v u = betaIntegral u v 
goal: v.betaIntegral u = u.betaIntegral v

full_name: Complex.betaIntegral_eval_one_right
code: theorem betaIntegral_eval_one_right {u : ℂ} (hu : 0 < re u) : betaIntegral u 1 = 1 / u 
goal: u.betaIntegral 1 = 1 / u

full_name: Complex.betaIntegral_scaled
code: theorem betaIntegral_scaled (s t : ℂ) {a : ℝ} (ha : 0 < a) :
    ∫ x in (0)..a, (x : ℂ) ^ (s - 1) * ((a : ℂ) - x) ^ (t - 1) =
    (a : ℂ) ^ (s + t - 1) * betaIntegral s t 
goal: ∫ (x : ℝ) in 0 ..a, ↑x ^ (s - 1) * (↑a - ↑x) ^ (t - 1) = ↑a ^ (s + t - 1) * s.betaIntegral t

full_name: Complex.Gamma_mul_Gamma_eq_betaIntegral
code: /-- Relation between Beta integral and Gamma function.  -/
theorem Gamma_mul_Gamma_eq_betaIntegral {s t : ℂ} (hs : 0 < re s) (ht : 0 < re t) :
    Gamma s * Gamma t = Gamma (s + t) * betaIntegral s t 
goal: Complex.Gamma s * Complex.Gamma t = Complex.Gamma (s + t) * s.betaIntegral t

full_name: Complex.betaIntegral_recurrence
code: /-- Recurrence formula for the Beta function. -/
theorem betaIntegral_recurrence {u v : ℂ} (hu : 0 < re u) (hv : 0 < re v) :
    u * betaIntegral u (v + 1) = v * betaIntegral (u + 1) v 
goal: u * u.betaIntegral (v + 1) = v * (u + 1).betaIntegral v

full_name: Complex.betaIntegral_eval_nat_add_one_right
code: /-- Explicit formula for the Beta function when second argument is a positive integer. -/
theorem betaIntegral_eval_nat_add_one_right {u : ℂ} (hu : 0 < re u) (n : ℕ) :
    betaIntegral u (n + 1) = n ! / ∏ j ∈ Finset.range (n + 1), (u + j) 
goal: u.betaIntegral (↑n + 1) = ↑n ! / ∏ j ∈ Finset.range (n + 1), (u + ↑j)

full_name: Complex.GammaSeq
code: /-- The sequence with `n`-th term `n ^ s * n! / (s * (s + 1) * ... * (s + n))`, for complex `s`.
We will show that this tends to `Γ(s)` as `n → ∞`. -/
noncomputable def GammaSeq (s : ℂ) (n : ℕ) 
goal: ℂ

full_name: Complex.GammaSeq_eq_betaIntegral_of_re_pos
code: theorem GammaSeq_eq_betaIntegral_of_re_pos {s : ℂ} (hs : 0 < re s) (n : ℕ) :
    GammaSeq s n = (n : ℂ) ^ s * betaIntegral s (n + 1) 
goal: s.GammaSeq n = ↑n ^ s * s.betaIntegral (↑n + 1)

full_name: Complex.GammaSeq_add_one_left
code: theorem GammaSeq_add_one_left (s : ℂ) {n : ℕ} (hn : n ≠ 0) :
    GammaSeq (s + 1) n / s = n / (n + 1 + s) * GammaSeq s n 
goal: (s + 1).GammaSeq n / s = ↑n / (↑n + 1 + s) * s.GammaSeq n

full_name: Complex.GammaSeq_eq_approx_Gamma_integral
code: theorem GammaSeq_eq_approx_Gamma_integral {s : ℂ} (hs : 0 < re s) {n : ℕ} (hn : n ≠ 0) :
    GammaSeq s n = ∫ x : ℝ in (0)..n, ↑((1 - x / n) ^ n) * (x : ℂ) ^ (s - 1) 
goal: s.GammaSeq n = ∫ (x : ℝ) in 0 ..↑n, ↑((1 - x / ↑n) ^ n) * ↑x ^ (s - 1)

full_name: Complex.approx_Gamma_integral_tendsto_Gamma_integral
code: /-- The main techical lemma for `GammaSeq_tendsto_Gamma`, expressing the integral defining the
Gamma function for `0 < re s` as the limit of a sequence of integrals over finite intervals. -/
theorem approx_Gamma_integral_tendsto_Gamma_integral {s : ℂ} (hs : 0 < re s) :
    Tendsto (fun n : ℕ => ∫ x : ℝ in (0)..n, ((1 - x / n) ^ n : ℝ) * (x : ℂ) ^ (s - 1)) atTop
      (𝓝 <| Gamma s) 
goal: Filter.Tendsto (fun n => ∫ (x : ℝ) in 0 ..↑n, ↑((1 - x / ↑n) ^ n) * ↑x ^ (s - 1)) Filter.atTop (𝓝 (Complex.Gamma s))

full_name: Complex.GammaSeq_tendsto_Gamma
code: /-- Euler's limit formula for the complex Gamma function. -/
theorem GammaSeq_tendsto_Gamma (s : ℂ) : Tendsto (GammaSeq s) atTop (𝓝 <| Gamma s) 
goal: Filter.Tendsto s.GammaSeq Filter.atTop (𝓝 (Complex.Gamma s))

full_name: Complex.GammaSeq_mul
code: theorem GammaSeq_mul (z : ℂ) {n : ℕ} (hn : n ≠ 0) :
    GammaSeq z n * GammaSeq (1 - z) n =
      n / (n + ↑1 - z) * (↑1 / (z * ∏ j ∈ Finset.range n, (↑1 - z ^ 2 / ((j : ℂ) + 1) ^ 2))) 
goal: z.GammaSeq n * (1 - z).GammaSeq n = ↑n / (↑n + 1 - z) * (1 / (z * ∏ j ∈ Finset.range n, (1 - z ^ 2 / (↑j + 1) ^ 2)))

full_name: Complex.Gamma_mul_Gamma_one_sub
code: /-- Euler's reflection formula for the complex Gamma function. -/
theorem Gamma_mul_Gamma_one_sub (z : ℂ) : Gamma z * Gamma (1 - z) = π / sin (π * z) 
goal: Complex.Gamma z * Complex.Gamma (1 - z) = ↑π / Complex.sin (↑π * z)

full_name: Complex.Gamma_ne_zero
code: /-- The Gamma function does not vanish on `ℂ` (except at non-positive integers, where the function
is mathematically undefined and we set it to `0` by convention). -/
theorem Gamma_ne_zero {s : ℂ} (hs : ∀ m : ℕ, s ≠ -m) : Gamma s ≠ 0 
goal: Complex.Gamma s ≠ 0

full_name: Complex.Gamma_eq_zero_iff
code: theorem Gamma_eq_zero_iff (s : ℂ) : Gamma s = 0 ↔ ∃ m : ℕ, s = -m 
goal: Complex.Gamma s = 0 ↔ ∃ m, s = -↑m

full_name: Complex.Gamma_ne_zero_of_re_pos
code: /-- A weaker, but easier-to-apply, version of `Complex.Gamma_ne_zero`. -/
theorem Gamma_ne_zero_of_re_pos {s : ℂ} (hs : 0 < re s) : Gamma s ≠ 0 
goal: Complex.Gamma s ≠ 0

full_name: Real.GammaSeq
code: /-- The sequence with `n`-th term `n ^ s * n! / (s * (s + 1) * ... * (s + n))`, for real `s`. We
will show that this tends to `Γ(s)` as `n → ∞`. -/
noncomputable def GammaSeq (s : ℝ) (n : ℕ) 
goal: ℝ

full_name: Real.GammaSeq_tendsto_Gamma
code: /-- Euler's limit formula for the real Gamma function. -/
theorem GammaSeq_tendsto_Gamma (s : ℝ) : Tendsto (GammaSeq s) atTop (𝓝 <| Gamma s) 
goal: Filter.Tendsto s.GammaSeq Filter.atTop (𝓝 (Real.Gamma s))

full_name: Real.Gamma_mul_Gamma_one_sub
code: /-- Euler's reflection formula for the real Gamma function. -/
theorem Gamma_mul_Gamma_one_sub (s : ℝ) : Gamma s * Gamma (1 - s) = π / sin (π * s) 
goal: Real.Gamma s * Real.Gamma (1 - s) = π / Real.sin (π * s)

full_name: Complex.one_div_Gamma_eq_self_mul_one_div_Gamma_add_one
code: /-- A reformulation of the Gamma recurrence relation which is true for `s = 0` as well. -/
theorem one_div_Gamma_eq_self_mul_one_div_Gamma_add_one (s : ℂ) :
    (Gamma s)⁻¹ = s * (Gamma (s + 1))⁻¹ 
goal: (Complex.Gamma s)⁻¹ = s * (Complex.Gamma (s + 1))⁻¹

full_name: Complex.differentiable_one_div_Gamma
code: /-- The reciprocal of the Gamma function is differentiable everywhere
(including the points where Gamma itself is not). -/
theorem differentiable_one_div_Gamma : Differentiable ℂ fun s : ℂ => (Gamma s)⁻¹ 
goal: Differentiable ℂ fun s => (Complex.Gamma s)⁻¹

full_name: Complex.Gamma_mul_Gamma_add_half
code: theorem Gamma_mul_Gamma_add_half (s : ℂ) :
    Gamma s * Gamma (s + 1 / 2) = Gamma (2 * s) * (2 : ℂ) ^ (1 - 2 * s) * ↑(√π) 
goal: Complex.Gamma s * Complex.Gamma (s + 1 / 2) = Complex.Gamma (2 * s) * 2 ^ (1 - 2 * s) * ↑√π

full_name: Real.Gamma_mul_Gamma_add_half
code: theorem Gamma_mul_Gamma_add_half (s : ℝ) :
    Gamma s * Gamma (s + 1 / 2) = Gamma (2 * s) * (2 : ℝ) ^ (1 - 2 * s) * √π 
goal: Real.Gamma s * Real.Gamma (s + 1 / 2) = Real.Gamma (2 * s) * 2 ^ (1 - 2 * s) * √π