ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/ModelTheory/Ultraproducts.lean

full_name: FirstOrder.Language.Ultraproduct.setoidPrestructure
code: instance setoidPrestructure : L.Prestructure ((u : Filter α).productSetoid M) 
goal: L.Prestructure ((↑u).productSetoid M)

full_name: FirstOrder.Language.Ultraproduct.structure
code: instance «structure» : L.Structure ((u : Filter α).Product M) 
goal: L.Structure ((↑u).Product M)

full_name: FirstOrder.Language.Ultraproduct.funMap_cast
code: theorem funMap_cast {n : ℕ} (f : L.Functions n) (x : Fin n → ∀ a, M a) :
    (funMap f fun i => (x i : (u : Filter α).Product M)) =
      (fun a => funMap f fun i => x i a : (u : Filter α).Product M) 
goal: (FirstOrder.Language.Structure.funMap f fun i => Quotient.mk' (x i)) =
  Quotient.mk' fun a => FirstOrder.Language.Structure.funMap f fun i => x i a

full_name: FirstOrder.Language.Ultraproduct.term_realize_cast
code: theorem term_realize_cast {β : Type*} (x : β → ∀ a, M a) (t : L.Term β) :
    (t.realize fun i => (x i : (u : Filter α).Product M)) =
      (fun a => t.realize fun i => x i a : (u : Filter α).Product M) 
goal: FirstOrder.Language.Term.realize (fun i => Quotient.mk' (x i)) t =
  Quotient.mk' fun a => FirstOrder.Language.Term.realize (fun i => x i a) t

full_name: FirstOrder.Language.Ultraproduct.boundedFormula_realize_cast
code: theorem boundedFormula_realize_cast {β : Type*} {n : ℕ} (φ : L.BoundedFormula β n)
    (x : β → ∀ a, M a) (v : Fin n → ∀ a, M a) :
    (φ.Realize (fun i : β => (x i : (u : Filter α).Product M))
        (fun i => (v i : (u : Filter α).Product M))) ↔
      ∀ᶠ a : α in u, φ.Realize (fun i : β => x i a) fun i => v i a 
goal: (φ.Realize (fun i => Quotient.mk' (x i)) fun i => Quotient.mk' (v i)) ↔
  ∀ᶠ (a : α) in ↑u, φ.Realize (fun i => x i a) fun i => v i a

full_name: FirstOrder.Language.Ultraproduct.realize_formula_cast
code: theorem realize_formula_cast {β : Type*} (φ : L.Formula β) (x : β → ∀ a, M a) :
    (φ.Realize fun i => (x i : (u : Filter α).Product M)) ↔
      ∀ᶠ a : α in u, φ.Realize fun i => x i a 
goal: (φ.Realize fun i => Quotient.mk' (x i)) ↔ ∀ᶠ (a : α) in ↑u, φ.Realize fun i => x i a

full_name: FirstOrder.Language.Ultraproduct.sentence_realize
code: /-- **Łoś's Theorem**: A sentence is true in an ultraproduct if and only if the set of structures
it is true in is in the ultrafilter. -/
theorem sentence_realize (φ : L.Sentence) :
    (u : Filter α).Product M ⊨ φ ↔ ∀ᶠ a : α in u, M a ⊨ φ 
goal: (↑u).Product M ⊨ φ ↔ ∀ᶠ (a : α) in ↑u, M a ⊨ φ

full_name: FirstOrder.Language.Ultraproduct.Product.instNonempty
code: nonrec instance Product.instNonempty : Nonempty ((u : Filter α).Product M) 
goal: Nonempty ((↑u).Product M)
File: Mathlib/ModelTheory/Algebra/Ring/FreeCommRing.lean

full_name: _private.Mathlib.ModelTheory.Algebra.Ring.FreeCommRing.0.FirstOrder.Ring.exists_term_realize_eq_freeCommRing
code: private theorem exists_term_realize_eq_freeCommRing (p : FreeCommRing α) :
    ∃ t : Language.ring.Term α,
      (t.realize FreeCommRing.of : FreeCommRing α) = p 
goal: ∃ t, FirstOrder.Language.Term.realize FreeCommRing.of t = p

full_name: FirstOrder.Ring.termOfFreeCommRing
code: /-- Make a `Language.ring.Term α` from an element of `FreeCommRing α` -/
noncomputable def termOfFreeCommRing (p : FreeCommRing α) : Language.ring.Term α 
goal: FirstOrder.Language.ring.Term α

full_name: FirstOrder.Ring.realize_termOfFreeCommRing
code: @[simp]
theorem realize_termOfFreeCommRing (p : FreeCommRing α) (v : α → R) :
    (termOfFreeCommRing p).realize v = FreeCommRing.lift v p 
goal: FirstOrder.Language.Term.realize v (FirstOrder.Ring.termOfFreeCommRing p) = (FreeCommRing.lift v) p
File: Mathlib/MeasureTheory/Integral/LebesgueNormedSpace.lean

full_name: aemeasurable_withDensity_iff
code: theorem aemeasurable_withDensity_iff {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [SecondCountableTopology E] [MeasurableSpace E] [BorelSpace E] {f : α → ℝ≥0}
    (hf : Measurable f) {g : α → E} :
    AEMeasurable g (μ.withDensity fun x => (f x : ℝ≥0∞)) ↔
      AEMeasurable (fun x => (f x : ℝ) • g x) μ 
goal: AEMeasurable g (μ.withDensity fun x => ↑(f x)) ↔ AEMeasurable (fun x => ↑(f x) • g x) μ
File: Mathlib/MeasureTheory/Integral/IntervalAverage.lean

full_name: «_aux_Mathlib_MeasureTheory_Integral_IntervalAverage___macroRules_term⨍_In_.._,__1»
code: notation3 "⨍ "(...)" in "a".."b",
  "r:60:(scoped f => average (Measure.restrict volume (uIoc a b)) f) => r
goal: Lean.Macro

full_name: interval_average_symm
code: theorem interval_average_symm (f : ℝ → E) (a b : ℝ) : (⨍ x in a..b, f x) = ⨍ x in b..a, f x 
goal: ⨍ (x : ℝ) in a..b, f x = ⨍ (x : ℝ) in b..a, f x

full_name: interval_average_eq
code: theorem interval_average_eq (f : ℝ → E) (a b : ℝ) :
    (⨍ x in a..b, f x) = (b - a)⁻¹ • ∫ x in a..b, f x 
goal: ⨍ (x : ℝ) in a..b, f x = (b - a)⁻¹ • ∫ (x : ℝ) in a..b, f x

full_name: interval_average_eq_div
code: theorem interval_average_eq_div (f : ℝ → ℝ) (a b : ℝ) :
    (⨍ x in a..b, f x) = (∫ x in a..b, f x) / (b - a) 
goal: ⨍ (x : ℝ) in a..b, f x = (∫ (x : ℝ) in a..b, f x) / (b - a)
File: Mathlib/MeasureTheory/Integral/ExpDecay.lean

full_name: exp_neg_integrableOn_Ioi
code: /-- `exp (-b * x)` is integrable on `(a, ∞)`. -/
theorem exp_neg_integrableOn_Ioi (a : ℝ) {b : ℝ} (h : 0 < b) :
    IntegrableOn (fun x : ℝ => exp (-b * x)) (Ioi a) 
goal: MeasureTheory.IntegrableOn (fun x => rexp (-b * x)) (Set.Ioi a) MeasureTheory.volume

full_name: integrable_of_isBigO_exp_neg
code: /-- If `f` is continuous on `[a, ∞)`, and is `O (exp (-b * x))` at `∞` for some `b > 0`, then
`f` is integrable on `(a, ∞)`. -/
theorem integrable_of_isBigO_exp_neg {f : ℝ → ℝ} {a b : ℝ} (h0 : 0 < b)
    (hf : ContinuousOn f (Ici a)) (ho : f =O[atTop] fun x => exp (-b * x)) :
    IntegrableOn f (Ioi a) 
goal: MeasureTheory.IntegrableOn f (Set.Ioi a) MeasureTheory.volume
File: Mathlib/MeasureTheory/Integral/RieszMarkovKakutani.lean

full_name: rieszContentAux
code: /-- Given a positive linear functional Λ on X, for `K ⊆ X` compact define
`λ(K) = inf {Λf | 1≤f on K}`. When X is a compact Hausdorff space, this will be shown to be a
content, and will be shown to agree with the Riesz measure on the compact subsets `K ⊆ X`. -/
def rieszContentAux : Compacts X → ℝ≥0 
goal: TopologicalSpace.Compacts X → ℝ≥0

full_name: rieszContentAux_image_nonempty
code: /-- For any compact subset `K ⊆ X`, there exist some bounded continuous nonnegative
functions f on X such that `f ≥ 1` on K. -/
theorem rieszContentAux_image_nonempty (K : Compacts X) :
    (Λ '' { f : X →ᵇ ℝ≥0 | ∀ x ∈ K, (1 : ℝ≥0) ≤ f x }).Nonempty 
goal: (⇑Λ '' {f | ∀ x ∈ K, 1 ≤ f x}).Nonempty

full_name: rieszContentAux_mono
code: /-- Riesz content λ (associated with a positive linear functional Λ) is
monotone: if `K₁ ⊆ K₂` are compact subsets in X, then `λ(K₁) ≤ λ(K₂)`. -/
theorem rieszContentAux_mono {K₁ K₂ : Compacts X} (h : K₁ ≤ K₂) :
    rieszContentAux Λ K₁ ≤ rieszContentAux Λ K₂ 
goal: rieszContentAux Λ K₁ ≤ rieszContentAux Λ K₂

full_name: rieszContentAux_le
code: /-- Any bounded continuous nonnegative f such that `f ≥ 1` on K gives an upper bound on the
content of K; namely `λ(K) ≤ Λ f`. -/
theorem rieszContentAux_le {K : Compacts X} {f : X →ᵇ ℝ≥0} (h : ∀ x ∈ K, (1 : ℝ≥0) ≤ f x) :
    rieszContentAux Λ K ≤ Λ f 
goal: rieszContentAux Λ K ≤ Λ f

full_name: exists_lt_rieszContentAux_add_pos
code: /-- The Riesz content can be approximated arbitrarily well by evaluating the positive linear
functional on test functions: for any `ε > 0`, there exists a bounded continuous nonnegative
function f on X such that `f ≥ 1` on K and such that `λ(K) ≤ Λ f < λ(K) + ε`. -/
theorem exists_lt_rieszContentAux_add_pos (K : Compacts X) {ε : ℝ≥0} (εpos : 0 < ε) :
    ∃ f : X →ᵇ ℝ≥0, (∀ x ∈ K, (1 : ℝ≥0) ≤ f x) ∧ Λ f < rieszContentAux Λ K + ε 
goal: ∃ f, (∀ x ∈ K, 1 ≤ f x) ∧ Λ f < rieszContentAux Λ K + ε

full_name: rieszContentAux_sup_le
code: /-- The Riesz content λ associated to a given positive linear functional Λ is
finitely subadditive: `λ(K₁ ∪ K₂) ≤ λ(K₁) + λ(K₂)` for any compact subsets `K₁, K₂ ⊆ X`. -/
theorem rieszContentAux_sup_le (K1 K2 : Compacts X) :
    rieszContentAux Λ (K1 ⊔ K2) ≤ rieszContentAux Λ K1 + rieszContentAux Λ K2 
goal: rieszContentAux Λ (K1 ⊔ K2) ≤ rieszContentAux Λ K1 + rieszContentAux Λ K2
File: Mathlib/MeasureTheory/Integral/Pi.lean

full_name: MeasureTheory.Integrable.fin_nat_prod
code: /-- On a finite product space in `n` variables, for a natural number `n`, a product of integrable
functions depending on each coordinate is integrable. -/
theorem Integrable.fin_nat_prod {n : ℕ} {E : Fin n → Type*}
    [∀ i, MeasureSpace (E i)] [∀ i, SigmaFinite (volume : Measure (E i))]
    {f : (i : Fin n) → E i → 𝕜} (hf : ∀ i, Integrable (f i)) :
    Integrable (fun (x : (i : Fin n) → E i) ↦ ∏ i, f i (x i)) 
goal: MeasureTheory.Integrable (fun x => ∏ i : Fin n, f i (x i)) MeasureTheory.volume

full_name: MeasureTheory.Integrable.fintype_prod_dep
code: /-- On a finite product space, a product of integrable functions depending on each coordinate is
integrable. Version with dependent target. -/
theorem Integrable.fintype_prod_dep {ι : Type*} [Fintype ι] {E : ι → Type*}
    {f : (i : ι) → E i → 𝕜} [∀ i, MeasureSpace (E i)] [∀ i, SigmaFinite (volume : Measure (E i))]
    (hf : ∀ i, Integrable (f i)) :
    Integrable (fun (x : (i : ι) → E i) ↦ ∏ i, f i (x i)) 
goal: MeasureTheory.Integrable (fun x => ∏ i : ι, f i (x i)) MeasureTheory.volume

full_name: MeasureTheory.Integrable.fintype_prod
code: /-- On a finite product space, a product of integrable functions depending on each coordinate is
integrable. -/
theorem Integrable.fintype_prod {ι : Type*} [Fintype ι] {E : Type*}
    {f : ι → E → 𝕜} [MeasureSpace E] [SigmaFinite (volume : Measure E)]
    (hf : ∀ i, Integrable (f i)) :
    Integrable (fun (x : ι → E) ↦ ∏ i, f i (x i)) 
goal: MeasureTheory.Integrable (fun x => ∏ i : ι, f i (x i)) MeasureTheory.volume

full_name: MeasureTheory.integral_fin_nat_prod_eq_prod
code: /-- A version of **Fubini's theorem** in `n` variables, for a natural number `n`. -/
theorem integral_fin_nat_prod_eq_prod {n : ℕ} {E : Fin n → Type*}
    [∀ i, MeasureSpace (E i)] [∀ i, SigmaFinite (volume : Measure (E i))]
    (f : (i : Fin n) → E i → 𝕜) :
    ∫ x : (i : Fin n) → E i, ∏ i, f i (x i) = ∏ i, ∫ x, f i x 
goal: ∫ (x : (i : Fin n) → E i), ∏ i : Fin n, f i (x i) = ∏ i : Fin n, ∫ (x : E i), f i x

full_name: MeasureTheory.integral_fintype_prod_eq_prod
code: /-- A version of **Fubini's theorem** with the variables indexed by a general finite type. -/
theorem integral_fintype_prod_eq_prod (ι : Type*) [Fintype ι] {E : ι → Type*}
    (f : (i : ι) → E i → 𝕜) [∀ i, MeasureSpace (E i)] [∀ i, SigmaFinite (volume : Measure (E i))] :
    ∫ x : (i : ι) → E i, ∏ i, f i (x i) = ∏ i, ∫ x, f i x 
goal: ∫ (x : (i : ι) → E i), ∏ i : ι, f i (x i) = ∏ i : ι, ∫ (x : E i), f i x

full_name: MeasureTheory.integral_fintype_prod_eq_pow
code: theorem integral_fintype_prod_eq_pow {E : Type*} (ι : Type*) [Fintype ι] (f : E → 𝕜)
    [MeasureSpace E] [SigmaFinite (volume : Measure E)] :
    ∫ x : ι → E, ∏ i, f (x i) = (∫ x, f x) ^ (card ι) 
goal: ∫ (x : ι → E), ∏ i : ι, f (x i) = (∫ (x : E), f x) ^ Fintype.card ι
File: Mathlib/MeasureTheory/Integral/Indicator.lean

full_name: MeasureTheory.tendsto_measure_of_tendsto_indicator
code: /-- If the indicators of measurable sets `Aᵢ` tend pointwise to the indicator of a set `A`
and we eventually have `Aᵢ ⊆ B` for some set `B` of finite measure, then the measures of `Aᵢ`
tend to the measure of `A`. -/
lemma tendsto_measure_of_tendsto_indicator [NeBot L] {μ : Measure α}
    (As_mble : ∀ i, MeasurableSet (As i)) {B : Set α} (B_mble : MeasurableSet B)
    (B_finmeas : μ B ≠ ∞) (As_le_B : ∀ᶠ i in L, As i ⊆ B)
    (h_lim : ∀ x, ∀ᶠ i in L, x ∈ As i ↔ x ∈ A) :
    Tendsto (fun i ↦ μ (As i)) L (𝓝 (μ A)) 
goal: Filter.Tendsto (fun i => μ (As i)) L (nhds (μ A))

full_name: MeasureTheory.tendsto_measure_of_tendsto_indicator_of_isFiniteMeasure
code: /-- If `μ` is a finite measure and the indicators of measurable sets `Aᵢ` tend pointwise to
the indicator of a set `A`, then the measures `μ Aᵢ` tend to the measure `μ A`. -/
lemma tendsto_measure_of_tendsto_indicator_of_isFiniteMeasure [NeBot L]
    (μ : Measure α) [IsFiniteMeasure μ] (As_mble : ∀ i, MeasurableSet (As i))
    (h_lim : ∀ x, ∀ᶠ i in L, x ∈ As i ↔ x ∈ A) :
    Tendsto (fun i ↦ μ (As i)) L (𝓝 (μ A)) 
goal: Filter.Tendsto (fun i => μ (As i)) L (nhds (μ A))
File: Mathlib/MeasureTheory/Order/Group/Lattice.lean

full_name: measurable_oneLePart
code: @[to_additive (attr := measurability)]
theorem measurable_oneLePart : Measurable (oneLePart : α → α) 
goal: Measurable oneLePart

full_name: measurable_posPart
code: @[to_additive (attr := measurability)]
theorem measurable_oneLePart : Measurable (oneLePart : α → α) 
goal: Measurable posPart

full_name: Measurable.posPart
code: @[to_additive (attr := measurability)]
protected theorem Measurable.oneLePart : Measurable fun x ↦ oneLePart (f x) 
goal: Measurable fun x => (f x)⁺

full_name: Measurable.oneLePart
code: @[to_additive (attr := measurability)]
protected theorem Measurable.oneLePart : Measurable fun x ↦ oneLePart (f x) 
goal: Measurable fun x => (f x)⁺ᵐ

full_name: measurable_negPart
code: @[to_additive (attr := measurability)]
theorem measurable_leOnePart : Measurable (leOnePart : α → α) 
goal: Measurable negPart

full_name: measurable_leOnePart
code: @[to_additive (attr := measurability)]
theorem measurable_leOnePart : Measurable (leOnePart : α → α) 
goal: Measurable leOnePart

full_name: Measurable.leOnePart
code: @[to_additive (attr := measurability)]
protected theorem Measurable.leOnePart : Measurable fun x ↦ leOnePart (f x) 
goal: Measurable fun x => (f x)⁻ᵐ

full_name: Measurable.negPart
code: @[to_additive (attr := measurability)]
protected theorem Measurable.leOnePart : Measurable fun x ↦ leOnePart (f x) 
goal: Measurable fun x => (f x)⁻

full_name: measurable_abs
code: @[to_additive (attr := measurability)]
theorem measurable_mabs : Measurable (mabs : α → α) 
goal: Measurable abs

full_name: measurable_mabs
code: @[to_additive (attr := measurability)]
theorem measurable_mabs : Measurable (mabs : α → α) 
goal: Measurable mabs

full_name: Measurable.mabs
code: @[to_additive (attr := measurability)]
protected theorem Measurable.mabs : Measurable fun x ↦ mabs (f x) 
goal: Measurable fun x => mabs (f x)

full_name: Measurable.abs
code: @[to_additive (attr := measurability)]
protected theorem Measurable.mabs : Measurable fun x ↦ mabs (f x) 
goal: Measurable fun x => |f x|
File: Mathlib/MeasureTheory/Constructions/Polish/EmbeddingReal.lean

full_name: MeasureTheory.exists_nat_measurableEquiv_range_coe_fin_of_finite
code: theorem exists_nat_measurableEquiv_range_coe_fin_of_finite [Finite α] :
    ∃ n : ℕ, Nonempty (α ≃ᵐ range ((↑) : Fin n → ℝ)) 
goal: ∃ n, Nonempty (α ≃ᵐ ↑(Set.range fun x => ↑↑x))

full_name: MeasureTheory.measurableEquiv_range_coe_nat_of_infinite_of_countable
code: theorem measurableEquiv_range_coe_nat_of_infinite_of_countable [Infinite α] [Countable α] :
    Nonempty (α ≃ᵐ range ((↑) : ℕ → ℝ)) 
goal: Nonempty (α ≃ᵐ ↑(Set.range Nat.cast))

full_name: MeasureTheory.exists_subset_real_measurableEquiv
code: /-- Any standard Borel space is measurably equivalent to a subset of the reals. -/
theorem exists_subset_real_measurableEquiv : ∃ s : Set ℝ, MeasurableSet s ∧ Nonempty (α ≃ᵐ s) 
goal: ∃ s, MeasurableSet s ∧ Nonempty (α ≃ᵐ ↑s)

full_name: MeasureTheory.exists_measurableEmbedding_real
code: /-- Any standard Borel space embeds measurably into the reals. -/
theorem exists_measurableEmbedding_real : ∃ f : α → ℝ, MeasurableEmbedding f 
goal: ∃ f, MeasurableEmbedding f

full_name: MeasureTheory.embeddingReal
code: /-- A measurable embedding of a standard Borel space into `ℝ`. -/
noncomputable
def embeddingReal (Ω : Type*) [MeasurableSpace Ω] [StandardBorelSpace Ω] : Ω → ℝ 
goal: Ω → ℝ

full_name: MeasureTheory.measurableEmbedding_embeddingReal
code: lemma measurableEmbedding_embeddingReal (Ω : Type*) [MeasurableSpace Ω] [StandardBorelSpace Ω] :
    MeasurableEmbedding (embeddingReal Ω) 
goal: MeasurableEmbedding (MeasureTheory.embeddingReal Ω)
File: Mathlib/MeasureTheory/Constructions/UnitInterval.lean

full_name: unitInterval.instMeasureSpaceElemReal
code: noncomputable instance : MeasureSpace I 
goal: MeasureTheory.MeasureSpace ↑I

full_name: unitInterval.volume_def
code: theorem volume_def : (volume : Measure I) = volume.comap Subtype.val 
goal: MeasureTheory.volume = MeasureTheory.Measure.comap Subtype.val MeasureTheory.volume

full_name: unitInterval.instIsProbabilityMeasureElemRealVolume
code: instance : IsProbabilityMeasure (volume : Measure I) 
goal: MeasureTheory.IsProbabilityMeasure MeasureTheory.volume

full_name: unitInterval.measurable_symm
code: @[measurability]
theorem measurable_symm : Measurable symm 
goal: Measurable σ
File: Mathlib/MeasureTheory/Integral/Gamma.lean

full_name: integral_rpow_mul_exp_neg_rpow
code: theorem integral_rpow_mul_exp_neg_rpow {p q : ℝ} (hp : 0 < p) (hq : - 1 < q) :
    ∫ x in Ioi (0 : ℝ), x ^ q * exp (- x ^ p) = (1 / p) * Gamma ((q + 1) / p) 
goal: ∫ (x : ℝ) in Set.Ioi 0, x ^ q * rexp (-x ^ p) = 1 / p * Real.Gamma ((q + 1) / p)

full_name: integral_rpow_mul_exp_neg_mul_rpow
code: theorem integral_rpow_mul_exp_neg_mul_rpow {p q b : ℝ} (hp : 0 < p) (hq : - 1 < q) (hb : 0 < b) :
    ∫ x in Ioi (0 : ℝ), x ^ q * exp (- b * x ^ p) =
      b ^ (-(q + 1) / p) * (1 / p) * Gamma ((q + 1) / p) 
goal: ∫ (x : ℝ) in Set.Ioi 0, x ^ q * rexp (-b * x ^ p) = b ^ (-(q + 1) / p) * (1 / p) * Real.Gamma ((q + 1) / p)

full_name: integral_exp_neg_rpow
code: theorem integral_exp_neg_rpow {p : ℝ} (hp : 0 < p) :
    ∫ x in Ioi (0 : ℝ), exp (- x ^ p) = Gamma (1 / p + 1) 
goal: ∫ (x : ℝ) in Set.Ioi 0, rexp (-x ^ p) = Real.Gamma (1 / p + 1)

full_name: integral_exp_neg_mul_rpow
code: theorem integral_exp_neg_mul_rpow {p b : ℝ} (hp : 0 < p) (hb : 0 < b) :
    ∫ x in Ioi (0 : ℝ), exp (- b * x ^ p) = b ^ (- 1 / p) * Gamma (1 / p + 1) 
goal: ∫ (x : ℝ) in Set.Ioi 0, rexp (-b * x ^ p) = b ^ (-1 / p) * Real.Gamma (1 / p + 1)

full_name: Complex.integral_rpow_mul_exp_neg_rpow
code: theorem Complex.integral_rpow_mul_exp_neg_rpow {p q : ℝ} (hp : 1 ≤ p) (hq : - 2 < q) :
    ∫ x : ℂ, ‖x‖ ^ q * rexp (- ‖x‖ ^ p) = (2 * π / p) * Real.Gamma ((q + 2) / p) 
goal: ∫ (x : ℂ), ‖x‖ ^ q * rexp (-‖x‖ ^ p) = 2 * π / p * Real.Gamma ((q + 2) / p)

full_name: Complex.integral_rpow_mul_exp_neg_mul_rpow
code: theorem Complex.integral_rpow_mul_exp_neg_mul_rpow {p q b : ℝ} (hp : 1 ≤ p) (hq : - 2 < q)
    (hb : 0 < b) :
    ∫ x : ℂ, ‖x‖ ^ q * rexp (- b * ‖x‖ ^ p) = (2 * π / p) *
      b ^ (-(q + 2) / p) * Real.Gamma ((q + 2) / p) 
goal: ∫ (x : ℂ), ‖x‖ ^ q * rexp (-b * ‖x‖ ^ p) = 2 * π / p * b ^ (-(q + 2) / p) * Real.Gamma ((q + 2) / p)

full_name: Complex.integral_exp_neg_rpow
code: theorem Complex.integral_exp_neg_rpow {p : ℝ} (hp : 1 ≤ p) :
    ∫ x : ℂ, rexp (- ‖x‖ ^ p) = π * Real.Gamma (2 / p + 1) 
goal: ∫ (x : ℂ), rexp (-‖x‖ ^ p) = π * Real.Gamma (2 / p + 1)

full_name: Complex.integral_exp_neg_mul_rpow
code: theorem Complex.integral_exp_neg_mul_rpow {p b : ℝ} (hp : 1 ≤ p) (hb : 0 < b) :
    ∫ x : ℂ, rexp (- b * ‖x‖ ^ p) = π * b ^ (-2 / p) * Real.Gamma (2 / p + 1) 
goal: ∫ (x : ℂ), rexp (-b * ‖x‖ ^ p) = π * b ^ (-2 / p) * Real.Gamma (2 / p + 1)
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Complex.lean

full_name: RCLike.measurableSpace
code: instance (priority := 900) RCLike.measurableSpace {𝕜 : Type*} [RCLike 𝕜] : MeasurableSpace 𝕜 
goal: MeasurableSpace 𝕜

full_name: RCLike.borelSpace
code: instance (priority := 900) RCLike.borelSpace {𝕜 : Type*} [RCLike 𝕜] : BorelSpace 𝕜 
goal: BorelSpace 𝕜

full_name: Complex.measurableSpace
code: instance Complex.measurableSpace : MeasurableSpace ℂ 
goal: MeasurableSpace ℂ

full_name: Complex.borelSpace
code: instance Complex.borelSpace : BorelSpace ℂ 
goal: BorelSpace ℂ
File: Mathlib/MeasureTheory/Constructions/BorelSpace/ContinuousLinearMap.lean

full_name: ContinuousLinearMap.measurable
code: @[fun_prop, measurability]
protected theorem measurable (L : E →L[𝕜] F) : Measurable L 
goal: Measurable ⇑L

full_name: ContinuousLinearMap.measurable_comp
code: @[fun_prop]
theorem measurable_comp (L : E →L[𝕜] F) {φ : α → E} (φ_meas : Measurable φ) :
    Measurable fun a : α => L (φ a) 
goal: Measurable fun a => L (φ a)

full_name: ContinuousLinearMap.instMeasurableSpace
code: instance instMeasurableSpace : MeasurableSpace (E →L[𝕜] F) 
goal: MeasurableSpace (E →L[𝕜] F)

full_name: ContinuousLinearMap.instBorelSpace
code: instance instBorelSpace : BorelSpace (E →L[𝕜] F) 
goal: BorelSpace (E →L[𝕜] F)

full_name: ContinuousLinearMap.measurable_apply
code: @[fun_prop, measurability]
theorem measurable_apply [MeasurableSpace F] [BorelSpace F] (x : E) :
    Measurable fun f : E →L[𝕜] F => f x 
goal: Measurable fun f => f x

full_name: ContinuousLinearMap.measurable_apply'
code: @[measurability]
theorem measurable_apply' [MeasurableSpace E] [OpensMeasurableSpace E] [MeasurableSpace F]
    [BorelSpace F] : Measurable fun (x : E) (f : E →L[𝕜] F) => f x 
goal: Measurable fun x f => f x

full_name: ContinuousLinearMap.measurable_coe
code: @[measurability]
theorem measurable_coe [MeasurableSpace F] [BorelSpace F] :
    Measurable fun (f : E →L[𝕜] F) (x : E) => f x 
goal: Measurable fun f x => f x

full_name: Measurable.apply_continuousLinearMap
code: @[fun_prop, measurability]
theorem Measurable.apply_continuousLinearMap {φ : α → F →L[𝕜] E} (hφ : Measurable φ) (v : F) :
    Measurable fun a => φ a v 
goal: Measurable fun a => (φ a) v

full_name: AEMeasurable.apply_continuousLinearMap
code: @[measurability]
theorem AEMeasurable.apply_continuousLinearMap {φ : α → F →L[𝕜] E} {μ : Measure α}
    (hφ : AEMeasurable φ μ) (v : F) : AEMeasurable (fun a => φ a v) μ 
goal: AEMeasurable (fun a => (φ a) v) μ

full_name: measurable_smul_const
code: theorem measurable_smul_const {f : α → 𝕜} {c : E} (hc : c ≠ 0) :
    (Measurable fun x => f x • c) ↔ Measurable f 
goal: (Measurable fun x => f x • c) ↔ Measurable f

full_name: aemeasurable_smul_const
code: theorem aemeasurable_smul_const {f : α → 𝕜} {μ : Measure α} {c : E} (hc : c ≠ 0) :
    AEMeasurable (fun x => f x • c) μ ↔ AEMeasurable f μ 
goal: AEMeasurable (fun x => f x • c) μ ↔ AEMeasurable f μ