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

full_name: Real.Gamma_integrand_isLittleO
code: /-- Asymptotic bound for the `Γ` function integrand. -/
theorem Gamma_integrand_isLittleO (s : ℝ) :
    (fun x : ℝ => exp (-x) * x ^ s) =o[atTop] fun x : ℝ => exp (-(1 / 2) * x) 
goal: (fun x => rexp (-x) * x ^ s) =o[Filter.atTop] fun x => rexp (-(1 / 2) * x)

full_name: Real.GammaIntegral_convergent
code: /-- The Euler integral for the `Γ` function converges for positive real `s`. -/
theorem GammaIntegral_convergent {s : ℝ} (h : 0 < s) :
    IntegrableOn (fun x : ℝ => exp (-x) * x ^ (s - 1)) (Ioi 0) 
goal: MeasureTheory.IntegrableOn (fun x => rexp (-x) * x ^ (s - 1)) (Set.Ioi 0) MeasureTheory.volume

full_name: Complex.GammaIntegral_convergent
code: /-- The integral defining the `Γ` function converges for complex `s` with `0 < re s`.

This is proved by reduction to the real case. -/
theorem GammaIntegral_convergent {s : ℂ} (hs : 0 < s.re) :
    IntegrableOn (fun x => (-x).exp * x ^ (s - 1) : ℝ → ℂ) (Ioi 0) 
goal: MeasureTheory.IntegrableOn (fun x => ↑(rexp (-x)) * ↑x ^ (s - 1)) (Set.Ioi 0) MeasureTheory.volume

full_name: Complex.GammaIntegral
code: /-- Euler's integral for the `Γ` function (of a complex variable `s`), defined as
`∫ x in Ioi 0, exp (-x) * x ^ (s - 1)`.

See `Complex.GammaIntegral_convergent` for a proof of the convergence of the integral for
`0 < re s`. -/
def GammaIntegral (s : ℂ) : ℂ 
goal: ℂ

full_name: Complex.GammaIntegral_conj
code: theorem GammaIntegral_conj (s : ℂ) : GammaIntegral (conj s) = conj (GammaIntegral s) 
goal: ((starRingEnd ℂ) s).GammaIntegral = (starRingEnd ℂ) s.GammaIntegral

full_name: Complex.GammaIntegral_ofReal
code: theorem GammaIntegral_ofReal (s : ℝ) :
    GammaIntegral ↑s = ↑(∫ x : ℝ in Ioi 0, Real.exp (-x) * x ^ (s - 1)) 
goal: (↑s).GammaIntegral = ↑(∫ (x : ℝ) in Set.Ioi 0, rexp (-x) * x ^ (s - 1))

full_name: Complex.GammaIntegral_one
code: @[simp]
theorem GammaIntegral_one : GammaIntegral 1 = 1 
goal: Complex.GammaIntegral 1 = 1

full_name: Complex.partialGamma
code: /-- The indefinite version of the `Γ` function, `Γ(s, X) = ∫ x ∈ 0..X, exp(-x) x ^ (s - 1)`. -/
def partialGamma (s : ℂ) (X : ℝ) : ℂ 
goal: ℂ

full_name: Complex.tendsto_partialGamma
code: theorem tendsto_partialGamma {s : ℂ} (hs : 0 < s.re) :
    Tendsto (fun X : ℝ => partialGamma s X) atTop (𝓝 <| GammaIntegral s) 
goal: Filter.Tendsto (fun X => s.partialGamma X) Filter.atTop (𝓝 s.GammaIntegral)

full_name: _private.Mathlib.Analysis.SpecialFunctions.Gamma.Basic.0.Complex.Gamma_integrand_intervalIntegrable
code: private theorem Gamma_integrand_intervalIntegrable (s : ℂ) {X : ℝ} (hs : 0 < s.re) (hX : 0 ≤ X) :
    IntervalIntegrable (fun x => (-x).exp * x ^ (s - 1) : ℝ → ℂ) volume 0 X 
goal: IntervalIntegrable (fun x => ↑(rexp (-x)) * ↑x ^ (s - 1)) MeasureTheory.volume 0 X

full_name: _private.Mathlib.Analysis.SpecialFunctions.Gamma.Basic.0.Complex.Gamma_integrand_deriv_integrable_A
code: private theorem Gamma_integrand_deriv_integrable_A {s : ℂ} (hs : 0 < s.re) {X : ℝ} (hX : 0 ≤ X) :
    IntervalIntegrable (fun x => -((-x).exp * x ^ s) : ℝ → ℂ) volume 0 X 
goal: IntervalIntegrable (fun x => -(↑(rexp (-x)) * ↑x ^ s)) MeasureTheory.volume 0 X

full_name: _private.Mathlib.Analysis.SpecialFunctions.Gamma.Basic.0.Complex.Gamma_integrand_deriv_integrable_B
code: private theorem Gamma_integrand_deriv_integrable_B {s : ℂ} (hs : 0 < s.re) {Y : ℝ} (hY : 0 ≤ Y) :
    IntervalIntegrable (fun x : ℝ => (-x).exp * (s * x ^ (s - 1)) : ℝ → ℂ) volume 0 Y 
goal: IntervalIntegrable (fun x => ↑(rexp (-x)) * (s * ↑x ^ (s - 1))) MeasureTheory.volume 0 Y

full_name: Complex.partialGamma_add_one
code: /-- The recurrence relation for the indefinite version of the `Γ` function. -/
theorem partialGamma_add_one {s : ℂ} (hs : 0 < s.re) {X : ℝ} (hX : 0 ≤ X) :
    partialGamma (s + 1) X = s * partialGamma s X - (-X).exp * X ^ s 
goal: (s + 1).partialGamma X = s * s.partialGamma X - ↑(rexp (-X)) * ↑X ^ s

full_name: Complex.GammaIntegral_add_one
code: /-- The recurrence relation for the `Γ` integral. -/
theorem GammaIntegral_add_one {s : ℂ} (hs : 0 < s.re) :
    GammaIntegral (s + 1) = s * GammaIntegral s 
goal: (s + 1).GammaIntegral = s * s.GammaIntegral

full_name: Complex.GammaAux
code: /-- The `n`th function in this family is `Γ(s)` if `-n < s.re`, and junk otherwise. -/
noncomputable def GammaAux : ℕ → ℂ → ℂ
  
goal: ℕ → ℂ → ℂ

full_name: Complex.GammaAux_recurrence1
code: theorem GammaAux_recurrence1 (s : ℂ) (n : ℕ) (h1 : -s.re < ↑n) :
    GammaAux n s = GammaAux n (s + 1) / s 
goal: Complex.GammaAux n s = Complex.GammaAux n (s + 1) / s

full_name: Complex.GammaAux_recurrence2
code: theorem GammaAux_recurrence2 (s : ℂ) (n : ℕ) (h1 : -s.re < ↑n) :
    GammaAux n s = GammaAux (n + 1) s 
goal: Complex.GammaAux n s = Complex.GammaAux (n + 1) s

full_name: Complex.Gamma_def
code: /-- The `Γ` function (of a complex variable `s`). -/
@[pp_nodot]
irreducible_def Gamma (s : ℂ) : ℂ 
goal: Complex.Gamma s = Complex.GammaAux ⌊1 - s.re⌋₊ s

full_name: Complex.wrapped._@.Mathlib.Analysis.SpecialFunctions.Gamma.Basic._hyg.3978
code: /-- The `Γ` function (of a complex variable `s`). -/
@[pp_nodot]
irreducible_def Gamma (s : ℂ) : ℂ 
goal: Subtype (Eq Complex.definition✝)

full_name: Complex.Gamma
code: /-- The `Γ` function (of a complex variable `s`). -/
@[pp_nodot]
irreducible_def Gamma (s : ℂ) : ℂ 
goal: ℂ

full_name: Complex.definition._@.Mathlib.Analysis.SpecialFunctions.Gamma.Basic._hyg.3978
code: /-- The `Γ` function (of a complex variable `s`). -/
@[pp_nodot]
irreducible_def Gamma (s : ℂ) : ℂ 
goal: ℂ

full_name: Complex.Gamma_eq_GammaAux
code: theorem Gamma_eq_GammaAux (s : ℂ) (n : ℕ) (h1 : -s.re < ↑n) : Gamma s = GammaAux n s 
goal: Complex.Gamma s = Complex.GammaAux n s

full_name: Complex.Gamma_add_one
code: /-- The recurrence relation for the `Γ` function. -/
theorem Gamma_add_one (s : ℂ) (h2 : s ≠ 0) : Gamma (s + 1) = s * Gamma s 
goal: Complex.Gamma (s + 1) = s * Complex.Gamma s

full_name: Complex.Gamma_eq_integral
code: theorem Gamma_eq_integral {s : ℂ} (hs : 0 < s.re) : Gamma s = GammaIntegral s 
goal: Complex.Gamma s = s.GammaIntegral

full_name: Complex.Gamma_one
code: @[simp]
theorem Gamma_one : Gamma 1 = 1 
goal: Complex.Gamma 1 = 1

full_name: Complex.Gamma_nat_eq_factorial
code: theorem Gamma_nat_eq_factorial (n : ℕ) : Gamma (n + 1) = n ! 
goal: Complex.Gamma (↑n + 1) = ↑n !

full_name: Complex.Gamma_ofNat_eq_factorial
code: @[simp]
theorem Gamma_ofNat_eq_factorial (n : ℕ) [(n + 1).AtLeastTwo] :
    Gamma (no_index (OfNat.ofNat (n + 1) : ℂ)) = n ! 
goal: Complex.Gamma (OfNat.ofNat (n + 1)) = ↑n !

full_name: Complex.Gamma_zero
code: /-- At `0` the Gamma function is undefined; by convention we assign it the value `0`. -/
@[simp]
theorem Gamma_zero : Gamma 0 = 0 
goal: Complex.Gamma 0 = 0

full_name: Complex.Gamma_neg_nat_eq_zero
code: /-- At `-n` for `n ∈ ℕ`, the Gamma function is undefined; by convention we assign it the value 0. -/
theorem Gamma_neg_nat_eq_zero (n : ℕ) : Gamma (-n) = 0 
goal: Complex.Gamma (-↑n) = 0

full_name: Complex.Gamma_conj
code: theorem Gamma_conj (s : ℂ) : Gamma (conj s) = conj (Gamma s) 
goal: Complex.Gamma ((starRingEnd ℂ) s) = (starRingEnd ℂ) (Complex.Gamma s)

full_name: Complex.integral_cpow_mul_exp_neg_mul_Ioi
code: /-- Expresses the integral over `Ioi 0` of `t ^ (a - 1) * exp (-(r * t))` in terms of the Gamma
function, for complex `a`. -/
lemma integral_cpow_mul_exp_neg_mul_Ioi {a : ℂ} {r : ℝ} (ha : 0 < a.re) (hr : 0 < r) :
    ∫ (t : ℝ) in Ioi 0, t ^ (a - 1) * exp (-(r * t)) = (1 / r) ^ a * Gamma a 
goal: ∫ (t : ℝ) in Set.Ioi 0, ↑t ^ (a - 1) * Complex.exp (-(↑r * ↑t)) = (1 / ↑r) ^ a * Complex.Gamma a

full_name: Complex.GammaIntegral_eq_mellin
code: /-- Rewrite the Gamma integral as an example of a Mellin transform. -/
theorem GammaIntegral_eq_mellin : GammaIntegral = mellin fun x => ↑(Real.exp (-x)) 
goal: Complex.GammaIntegral = mellin fun x => ↑(rexp (-x))

full_name: Complex.hasDerivAt_GammaIntegral
code: /-- The derivative of the `Γ` integral, at any `s ∈ ℂ` with `1 < re s`, is given by the Mellin
transform of `log t * exp (-t)`. -/
theorem hasDerivAt_GammaIntegral {s : ℂ} (hs : 0 < s.re) :
    HasDerivAt GammaIntegral (∫ t : ℝ in Ioi 0, t ^ (s - 1) * (Real.log t * Real.exp (-t))) s 
goal: HasDerivAt Complex.GammaIntegral (∫ (t : ℝ) in Set.Ioi 0, ↑t ^ (s - 1) * (↑(Real.log t) * ↑(rexp (-t)))) s

full_name: Complex.differentiableAt_GammaAux
code: theorem differentiableAt_GammaAux (s : ℂ) (n : ℕ) (h1 : 1 - s.re < n) (h2 : ∀ m : ℕ, s ≠ -m) :
    DifferentiableAt ℂ (GammaAux n) s 
goal: DifferentiableAt ℂ (Complex.GammaAux n) s

full_name: Complex.differentiableAt_Gamma
code: theorem differentiableAt_Gamma (s : ℂ) (hs : ∀ m : ℕ, s ≠ -m) : DifferentiableAt ℂ Gamma s 
goal: DifferentiableAt ℂ Complex.Gamma s

full_name: Complex.tendsto_self_mul_Gamma_nhds_zero
code: /-- At `s = 0`, the Gamma function has a simple pole with residue 1. -/
theorem tendsto_self_mul_Gamma_nhds_zero : Tendsto (fun z : ℂ => z * Gamma z) (𝓝[≠] 0) (𝓝 1) 
goal: Filter.Tendsto (fun z => z * Complex.Gamma z) (𝓝[≠] 0) (𝓝 1)

full_name: Real.Gamma
code: /-- The `Γ` function (of a real variable `s`). -/
@[pp_nodot]
def Gamma (s : ℝ) : ℝ 
goal: ℝ

full_name: Real.Gamma_eq_integral
code: theorem Gamma_eq_integral {s : ℝ} (hs : 0 < s) :
    Gamma s = ∫ x in Ioi 0, exp (-x) * x ^ (s - 1) 
goal: Real.Gamma s = ∫ (x : ℝ) in Set.Ioi 0, rexp (-x) * x ^ (s - 1)

full_name: Real.Gamma_add_one
code: theorem Gamma_add_one {s : ℝ} (hs : s ≠ 0) : Gamma (s + 1) = s * Gamma s 
goal: Real.Gamma (s + 1) = s * Real.Gamma s

full_name: Real.Gamma_one
code: @[simp]
theorem Gamma_one : Gamma 1 = 1 
goal: Real.Gamma 1 = 1

full_name: Complex.Gamma_ofReal
code: theorem _root_.Complex.Gamma_ofReal (s : ℝ) : Complex.Gamma (s : ℂ) = Gamma s 
goal: Complex.Gamma ↑s = ↑(Real.Gamma s)

full_name: Real.Gamma_nat_eq_factorial
code: theorem Gamma_nat_eq_factorial (n : ℕ) : Gamma (n + 1) = n ! 
goal: Real.Gamma (↑n + 1) = ↑n !

full_name: Real.Gamma_ofNat_eq_factorial
code: @[simp]
theorem Gamma_ofNat_eq_factorial (n : ℕ) [(n + 1).AtLeastTwo] :
    Gamma (no_index (OfNat.ofNat (n + 1) : ℝ)) = n ! 
goal: Real.Gamma (OfNat.ofNat (n + 1)) = ↑n !

full_name: Real.Gamma_zero
code: /-- At `0` the Gamma function is undefined; by convention we assign it the value `0`. -/
@[simp]
theorem Gamma_zero : Gamma 0 = 0 
goal: Real.Gamma 0 = 0

full_name: Real.Gamma_neg_nat_eq_zero
code: /-- At `-n` for `n ∈ ℕ`, the Gamma function is undefined; by convention we assign it the value `0`.
-/
theorem Gamma_neg_nat_eq_zero (n : ℕ) : Gamma (-n) = 0 
goal: Real.Gamma (-↑n) = 0

full_name: Real.Gamma_pos_of_pos
code: theorem Gamma_pos_of_pos {s : ℝ} (hs : 0 < s) : 0 < Gamma s 
goal: 0 < Real.Gamma s

full_name: Real.Gamma_nonneg_of_nonneg
code: theorem Gamma_nonneg_of_nonneg {s : ℝ} (hs : 0 ≤ s) : 0 ≤ Gamma s 
goal: 0 ≤ Real.Gamma s

full_name: Real.integral_rpow_mul_exp_neg_mul_Ioi
code: /-- Expresses the integral over `Ioi 0` of `t ^ (a - 1) * exp (-(r * t))`, for positive real `r`,
in terms of the Gamma function. -/
lemma integral_rpow_mul_exp_neg_mul_Ioi {a r : ℝ} (ha : 0 < a) (hr : 0 < r) :
    ∫ t : ℝ in Ioi 0, t ^ (a - 1) * exp (-(r * t)) = (1 / r) ^ a * Gamma a 
goal: ∫ (t : ℝ) in Set.Ioi 0, t ^ (a - 1) * rexp (-(r * t)) = (1 / r) ^ a * Real.Gamma a

full_name: Mathlib.Meta.Positivity.evalGamma
code: /-- The `positivity` extension which identifies expressions of the form `Gamma a`. -/
@[positivity Gamma (_ : ℝ)]
def _root_.Mathlib.Meta.Positivity.evalGamma : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Real.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: Real.Gamma s ≠ 0

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

full_name: Real.differentiableAt_Gamma
code: theorem differentiableAt_Gamma {s : ℝ} (hs : ∀ m : ℕ, s ≠ -m) : DifferentiableAt ℝ Gamma s 
goal: DifferentiableAt ℝ Real.Gamma s