ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/MeasureTheory/Order/UpperLower.lean

full_name: _private.Mathlib.MeasureTheory.Order.UpperLower.0.aux₀
code: /-- If we can fit a small ball inside a set `s` intersected with any neighborhood of `x`, then the
density of `s` near `x` is not `0`.

Along with `aux₁`, this proves that `x` is a Lebesgue point of `s`. This will be used to prove that
the frontier of an order-connected set is null. -/
private lemma aux₀
    (h : ∀ δ, 0 < δ →
      ∃ y, closedBall y (δ / 4) ⊆ closedBall x δ ∧ closedBall y (δ / 4) ⊆ interior s) :
    ¬Tendsto (fun r ↦ volume (closure s ∩ closedBall x r) / volume (closedBall x r)) (𝓝[>] 0)
        (𝓝 0) 
goal: ¬Filter.Tendsto
    (fun r => MeasureTheory.volume (closure s ∩ Metric.closedBall x r) / MeasureTheory.volume (Metric.closedBall x r))
    (𝓝[>] 0) (𝓝 0)

full_name: _private.Mathlib.MeasureTheory.Order.UpperLower.0.aux₁
code: /-- If we can fit a small ball inside a set `sᶜ` intersected with any neighborhood of `x`, then the
density of `s` near `x` is not `1`.

Along with `aux₀`, this proves that `x` is a Lebesgue point of `s`. This will be used to prove that
the frontier of an order-connected set is null. -/
private lemma aux₁
    (h : ∀ δ, 0 < δ →
      ∃ y, closedBall y (δ / 4) ⊆ closedBall x δ ∧ closedBall y (δ / 4) ⊆ interior sᶜ) :
    ¬Tendsto (fun r ↦ volume (closure s ∩ closedBall x r) / volume (closedBall x r)) (𝓝[>] 0)
        (𝓝 1) 
goal: ¬Filter.Tendsto
    (fun r => MeasureTheory.volume (closure s ∩ Metric.closedBall x r) / MeasureTheory.volume (Metric.closedBall x r))
    (𝓝[>] 0) (𝓝 1)

full_name: IsUpperSet.null_frontier
code: theorem IsUpperSet.null_frontier (hs : IsUpperSet s) : volume (frontier s) = 0 
goal: MeasureTheory.volume (frontier s) = 0

full_name: IsLowerSet.null_frontier
code: theorem IsLowerSet.null_frontier (hs : IsLowerSet s) : volume (frontier s) = 0 
goal: MeasureTheory.volume (frontier s) = 0

full_name: Set.OrdConnected.null_frontier
code: theorem Set.OrdConnected.null_frontier (hs : s.OrdConnected) : volume (frontier s) = 0 
goal: MeasureTheory.volume (frontier s) = 0

full_name: Set.OrdConnected.nullMeasurableSet
code: protected theorem Set.OrdConnected.nullMeasurableSet (hs : s.OrdConnected) : NullMeasurableSet s 
goal: MeasureTheory.NullMeasurableSet s MeasureTheory.volume

full_name: IsAntichain.volume_eq_zero
code: theorem IsAntichain.volume_eq_zero [Nonempty ι] (hs : IsAntichain (· ≤ ·) s) : volume s = 0 
goal: MeasureTheory.volume s = 0
File: Mathlib/MeasureTheory/Covering/OneDim.lean

full_name: Real.Icc_mem_vitaliFamily_at_right
code: theorem Icc_mem_vitaliFamily_at_right {x y : ℝ} (hxy : x < y) :
    Icc x y ∈ (vitaliFamily (volume : Measure ℝ) 1).setsAt x 
goal: Set.Icc x y ∈ (IsUnifLocDoublingMeasure.vitaliFamily MeasureTheory.volume 1).setsAt x

full_name: Real.tendsto_Icc_vitaliFamily_right
code: theorem tendsto_Icc_vitaliFamily_right (x : ℝ) :
    Tendsto (fun y => Icc x y) (𝓝[>] x) ((vitaliFamily (volume : Measure ℝ) 1).filterAt x) 
goal: Filter.Tendsto (fun y => Set.Icc x y) (𝓝[>] x)
  ((IsUnifLocDoublingMeasure.vitaliFamily MeasureTheory.volume 1).filterAt x)

full_name: Real.Icc_mem_vitaliFamily_at_left
code: theorem Icc_mem_vitaliFamily_at_left {x y : ℝ} (hxy : x < y) :
    Icc x y ∈ (vitaliFamily (volume : Measure ℝ) 1).setsAt y 
goal: Set.Icc x y ∈ (IsUnifLocDoublingMeasure.vitaliFamily MeasureTheory.volume 1).setsAt y

full_name: Real.tendsto_Icc_vitaliFamily_left
code: theorem tendsto_Icc_vitaliFamily_left (x : ℝ) :
    Tendsto (fun y => Icc y x) (𝓝[<] x) ((vitaliFamily (volume : Measure ℝ) 1).filterAt x) 
goal: Filter.Tendsto (fun y => Set.Icc y x) (𝓝[<] x)
  ((IsUnifLocDoublingMeasure.vitaliFamily MeasureTheory.volume 1).filterAt x)
File: Mathlib/MeasureTheory/Function/Floor.lean

full_name: Int.measurable_floor
code: theorem Int.measurable_floor [OpensMeasurableSpace R] : Measurable (Int.floor : R → ℤ) 
goal: Measurable Int.floor

full_name: Measurable.floor
code: @[measurability]
theorem Measurable.floor [OpensMeasurableSpace R] {f : α → R} (hf : Measurable f) :
    Measurable fun x => ⌊f x⌋ 
goal: Measurable fun x => ⌊f x⌋

full_name: Int.measurable_ceil
code: theorem Int.measurable_ceil [OpensMeasurableSpace R] : Measurable (Int.ceil : R → ℤ) 
goal: Measurable Int.ceil

full_name: Measurable.ceil
code: @[measurability]
theorem Measurable.ceil [OpensMeasurableSpace R] {f : α → R} (hf : Measurable f) :
    Measurable fun x => ⌈f x⌉ 
goal: Measurable fun x => ⌈f x⌉

full_name: measurable_fract
code: theorem measurable_fract [BorelSpace R] : Measurable (Int.fract : R → R) 
goal: Measurable Int.fract

full_name: Measurable.fract
code: @[measurability]
theorem Measurable.fract [BorelSpace R] {f : α → R} (hf : Measurable f) :
    Measurable fun x => Int.fract (f x) 
goal: Measurable fun x => Int.fract (f x)

full_name: MeasurableSet.image_fract
code: theorem MeasurableSet.image_fract [BorelSpace R] {s : Set R} (hs : MeasurableSet s) :
    MeasurableSet (Int.fract '' s) 
goal: MeasurableSet (Int.fract '' s)

full_name: Nat.measurable_floor
code: theorem Nat.measurable_floor : Measurable (Nat.floor : R → ℕ) 
goal: Measurable Nat.floor

full_name: Measurable.nat_floor
code: @[measurability]
theorem Measurable.nat_floor (hf : Measurable f) : Measurable fun x => ⌊f x⌋₊ 
goal: Measurable fun x => ⌊f x⌋₊

full_name: Nat.measurable_ceil
code: theorem Nat.measurable_ceil : Measurable (Nat.ceil : R → ℕ) 
goal: Measurable Nat.ceil

full_name: Measurable.nat_ceil
code: @[measurability]
theorem Measurable.nat_ceil (hf : Measurable f) : Measurable fun x => ⌈f x⌉₊ 
goal: Measurable fun x => ⌈f x⌉₊
File: Mathlib/MeasureTheory/Category/MeasCat.lean

full_name: MeasCat
code: /-- The category of measurable spaces and measurable functions. -/
def MeasCat : Type (u + 1) 
goal: Type (u + 1)

full_name: MeasCat.instCoeSortType
code: instance : CoeSort MeasCat Type* 
goal: CoeSort MeasCat (Type u_1)

full_name: MeasCat.instMeasurableSpaceα
code: instance (X : MeasCat) : MeasurableSpace X 
goal: MeasurableSpace ↑X

full_name: MeasCat.of
code: /-- Construct a bundled `MeasCat` from the underlying type and the typeclass. -/
def of (α : Type u) [ms : MeasurableSpace α] : MeasCat 
goal: MeasCat

full_name: MeasCat.coe_of
code: @[simp]
theorem coe_of (X : Type u) [MeasurableSpace X] : (of X : Type u) = X 
goal: ↑(MeasCat.of X) = X

full_name: MeasCat.unbundledHom
code: instance unbundledHom : UnbundledHom @Measurable 
goal: CategoryTheory.UnbundledHom @Measurable

full_name: MeasCat.instConcreteCategory
code: instance : ConcreteCategory MeasCat 
goal: CategoryTheory.ConcreteCategory MeasCat

full_name: MeasCat.instInhabited
code: instance : Inhabited MeasCat 
goal: Inhabited MeasCat

full_name: MeasCat.Measure
code: /-- `Measure X` is the measurable space of measures over the measurable space `X`. It is the
weakest measurable space, s.t. `fun μ ↦ μ s` is measurable for all measurable sets `s` in `X`. An
important purpose is to assign a monadic structure on it, the Giry monad. In the Giry monad,
the pure values are the Dirac measure, and the bind operation maps to the integral:
`(μ >>= ν) s = ∫ x. (ν x) s dμ`.

In probability theory, the `MeasCat`-morphisms `X → Prob X` are (sub-)Markov kernels (here `Prob` is
the restriction of `Measure` to (sub-)probability space.)
-/
def Measure : MeasCat ⥤ MeasCat 
goal: MeasCat ⥤ MeasCat

full_name: MeasCat.Giry
code: /-- The Giry monad, i.e. the monadic structure associated with `Measure`. -/
def Giry : CategoryTheory.Monad MeasCat 
goal: CategoryTheory.Monad MeasCat

full_name: MeasCat.Integral
code: /-- An example for an algebra on `Measure`: the nonnegative Lebesgue integral is a hom, behaving
nicely under the monad operations. -/
def Integral : Giry.Algebra 
goal: MeasCat.Giry.Algebra

full_name: TopCat.hasForgetToMeasCat
code: instance TopCat.hasForgetToMeasCat : HasForget₂ TopCat.{u} MeasCat.{u} 
goal: CategoryTheory.HasForget₂ TopCat MeasCat

full_name: Borel
code: /-- The Borel functor, the canonical embedding of topological spaces into measurable spaces. -/
abbrev Borel : TopCat.{u} ⥤ MeasCat.{u} 
goal: TopCat ⥤ MeasCat
File: Mathlib/MeasureTheory/Function/LpOrder.lean

full_name: MeasureTheory.Lp.coeFn_le
code: theorem coeFn_le (f g : Lp E p μ) : f ≤ᵐ[μ] g ↔ f ≤ g 
goal: ↑↑f ≤ᵐ[μ] ↑↑g ↔ f ≤ g

full_name: MeasureTheory.Lp.coeFn_nonneg
code: theorem coeFn_nonneg (f : Lp E p μ) : 0 ≤ᵐ[μ] f ↔ 0 ≤ f 
goal: 0 ≤ᵐ[μ] ↑↑f ↔ 0 ≤ f

full_name: MeasureTheory.Lp.instCovariantClassLE
code: instance instCovariantClassLE : CovariantClass (Lp E p μ) (Lp E p μ) (· + ·) (· ≤ ·) 
goal: CovariantClass (↥(MeasureTheory.Lp E p μ)) (↥(MeasureTheory.Lp E p μ)) (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: MeasureTheory.Lp.instOrderedAddCommGroup
code: instance instOrderedAddCommGroup : OrderedAddCommGroup (Lp E p μ) 
goal: OrderedAddCommGroup ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Memℒp.sup
code: theorem _root_.MeasureTheory.Memℒp.sup {f g : α → E} (hf : Memℒp f p μ) (hg : Memℒp g p μ) :
    Memℒp (f ⊔ g) p μ 
goal: MeasureTheory.Memℒp (f ⊔ g) p μ

full_name: MeasureTheory.Memℒp.inf
code: theorem _root_.MeasureTheory.Memℒp.inf {f g : α → E} (hf : Memℒp f p μ) (hg : Memℒp g p μ) :
    Memℒp (f ⊓ g) p μ 
goal: MeasureTheory.Memℒp (f ⊓ g) p μ

full_name: MeasureTheory.Memℒp.abs
code: theorem _root_.MeasureTheory.Memℒp.abs {f : α → E} (hf : Memℒp f p μ) : Memℒp |f| p μ 
goal: MeasureTheory.Memℒp |f| p μ

full_name: MeasureTheory.Lp.instLattice
code: instance instLattice : Lattice (Lp E p μ) 
goal: Lattice ↥(MeasureTheory.Lp E p μ)

full_name: MeasureTheory.Lp.coeFn_sup
code: theorem coeFn_sup (f g : Lp E p μ) : ⇑(f ⊔ g) =ᵐ[μ] ⇑f ⊔ ⇑g 
goal: ↑↑(f ⊔ g) =ᵐ[μ] ↑↑f ⊔ ↑↑g

full_name: MeasureTheory.Lp.coeFn_inf
code: theorem coeFn_inf (f g : Lp E p μ) : ⇑(f ⊓ g) =ᵐ[μ] ⇑f ⊓ ⇑g 
goal: ↑↑(f ⊓ g) =ᵐ[μ] ↑↑f ⊓ ↑↑g

full_name: MeasureTheory.Lp.coeFn_abs
code: theorem coeFn_abs (f : Lp E p μ) : ⇑|f| =ᵐ[μ] fun x => |f x| 
goal: ↑↑|f| =ᵐ[μ] fun x => |↑↑f x|

full_name: MeasureTheory.Lp.instNormedLatticeAddCommGroup
code: noncomputable instance instNormedLatticeAddCommGroup [Fact (1 ≤ p)] :
    NormedLatticeAddCommGroup (Lp E p μ) 
goal: NormedLatticeAddCommGroup ↥(MeasureTheory.Lp E p μ)
File: Mathlib/MeasureTheory/Function/SpecialFunctions/Inner.lean

full_name: «_aux_Mathlib_MeasureTheory_Function_SpecialFunctions_Inner___macroRules_term⟪_,_⟫_1»
code: local notation "⟪" x ", " y "⟫" => @inner 𝕜 _ _ x y
goal: Lean.Macro

full_name: Measurable.inner
code: @[aesop safe 20 apply (rule_sets := [Measurable])]
theorem Measurable.inner {_ : MeasurableSpace α} [MeasurableSpace E] [OpensMeasurableSpace E]
    [SecondCountableTopology E] {f g : α → E} (hf : Measurable f)
    (hg : Measurable g) : Measurable fun t => ⟪f t, g t⟫ 
goal: ∀ {x : MeasurableSpace α} [inst : MeasurableSpace E] [inst_1 : OpensMeasurableSpace E]
  [inst_2 : SecondCountableTopology E] {f g : α → E}, Measurable f → Measurable g → Measurable fun t => ⟪f t, g t⟫_𝕜

full_name: Measurable.const_inner
code: @[measurability]
theorem Measurable.const_inner {_ : MeasurableSpace α} [MeasurableSpace E] [OpensMeasurableSpace E]
    [SecondCountableTopology E] {c : E} {f : α → E} (hf : Measurable f) :
    Measurable fun t => ⟪c, f t⟫ 
goal: ∀ {x : MeasurableSpace α} [inst : MeasurableSpace E] [inst_1 : OpensMeasurableSpace E]
  [inst_2 : SecondCountableTopology E] {c : E} {f : α → E}, Measurable f → Measurable fun t => ⟪c, f t⟫_𝕜

full_name: Measurable.inner_const
code: @[measurability]
theorem Measurable.inner_const {_ : MeasurableSpace α} [MeasurableSpace E] [OpensMeasurableSpace E]
    [SecondCountableTopology E] {c : E} {f : α → E} (hf : Measurable f) :
    Measurable fun t => ⟪f t, c⟫ 
goal: ∀ {x : MeasurableSpace α} [inst : MeasurableSpace E] [inst_1 : OpensMeasurableSpace E]
  [inst_2 : SecondCountableTopology E] {c : E} {f : α → E}, Measurable f → Measurable fun t => ⟪f t, c⟫_𝕜

full_name: AEMeasurable.inner
code: @[aesop safe 20 apply (rule_sets := [Measurable])]
theorem AEMeasurable.inner {m : MeasurableSpace α} [MeasurableSpace E] [OpensMeasurableSpace E]
    [SecondCountableTopology E] {μ : MeasureTheory.Measure α} {f g : α → E}
    (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) : AEMeasurable (fun x => ⟪f x, g x⟫) μ 
goal: AEMeasurable (fun x => ⟪f x, g x⟫_𝕜) μ

full_name: AEMeasurable.const_inner
code: @[measurability]
theorem AEMeasurable.const_inner {m : MeasurableSpace α} [MeasurableSpace E]
    [OpensMeasurableSpace E] [SecondCountableTopology E]
    {μ : MeasureTheory.Measure α} {f : α → E} {c : E} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => ⟪c, f x⟫) μ 
goal: AEMeasurable (fun x => ⟪c, f x⟫_𝕜) μ

full_name: AEMeasurable.inner_const
code: @[measurability]
theorem AEMeasurable.inner_const {m : MeasurableSpace α} [MeasurableSpace E]
    [OpensMeasurableSpace E] [SecondCountableTopology E]
    {μ : MeasureTheory.Measure α} {f : α → E} {c : E} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => ⟪f x, c⟫) μ 
goal: AEMeasurable (fun x => ⟪f x, c⟫_𝕜) μ
File: Mathlib/MeasureTheory/Function/SpecialFunctions/Arctan.lean

full_name: Real.measurable_arctan
code: @[measurability]
theorem measurable_arctan : Measurable arctan 
goal: Measurable Real.arctan

full_name: Measurable.arctan
code: @[measurability]
theorem Measurable.arctan : Measurable fun x => arctan (f x) 
goal: Measurable fun x => Real.arctan (f x)
File: Mathlib/MeasureTheory/Function/SpecialFunctions/RCLike.lean

full_name: RCLike.measurable_re
code: @[measurability]
theorem measurable_re : Measurable (re : 𝕜 → ℝ) 
goal: Measurable ⇑RCLike.re

full_name: RCLike.measurable_im
code: @[measurability]
theorem measurable_im : Measurable (im : 𝕜 → ℝ) 
goal: Measurable ⇑RCLike.im

full_name: Measurable.re
code: @[measurability]
theorem Measurable.re (hf : Measurable f) : Measurable fun x => RCLike.re (f x) 
goal: Measurable fun x => RCLike.re (f x)

full_name: AEMeasurable.re
code: @[measurability]
theorem AEMeasurable.re (hf : AEMeasurable f μ) : AEMeasurable (fun x => RCLike.re (f x)) μ 
goal: AEMeasurable (fun x => RCLike.re (f x)) μ

full_name: Measurable.im
code: @[measurability]
theorem Measurable.im (hf : Measurable f) : Measurable fun x => RCLike.im (f x) 
goal: Measurable fun x => RCLike.im (f x)

full_name: AEMeasurable.im
code: @[measurability]
theorem AEMeasurable.im (hf : AEMeasurable f μ) : AEMeasurable (fun x => RCLike.im (f x)) μ 
goal: AEMeasurable (fun x => RCLike.im (f x)) μ

full_name: RCLike.measurable_ofReal
code: @[measurability]
theorem RCLike.measurable_ofReal : Measurable ((↑) : ℝ → 𝕜) 
goal: Measurable RCLike.ofReal

full_name: measurable_of_re_im
code: theorem measurable_of_re_im (hre : Measurable fun x => RCLike.re (f x))
    (him : Measurable fun x => RCLike.im (f x)) : Measurable f 
goal: Measurable f

full_name: aemeasurable_of_re_im
code: theorem aemeasurable_of_re_im (hre : AEMeasurable (fun x => RCLike.re (f x)) μ)
    (him : AEMeasurable (fun x => RCLike.im (f x)) μ) : AEMeasurable f μ 
goal: AEMeasurable f μ
File: Mathlib/MeasureTheory/Function/AEMeasurableOrder.lean

full_name: MeasureTheory.aemeasurable_of_exist_almost_disjoint_supersets
code: /-- If a function `f : α → β` is such that the level sets `{f < p}` and `{q < f}` have measurable
supersets which are disjoint up to measure zero when `p < q`, then `f` is almost-everywhere
measurable. It is even enough to have this for `p` and `q` in a countable dense set. -/
theorem MeasureTheory.aemeasurable_of_exist_almost_disjoint_supersets {α : Type*}
    {m : MeasurableSpace α} (μ : Measure α) {β : Type*} [CompleteLinearOrder β] [DenselyOrdered β]
    [TopologicalSpace β] [OrderTopology β] [SecondCountableTopology β] [MeasurableSpace β]
    [BorelSpace β] (s : Set β) (s_count : s.Countable) (s_dense : Dense s) (f : α → β)
    (h : ∀ p ∈ s, ∀ q ∈ s, p < q → ∃ u v, MeasurableSet u ∧ MeasurableSet v ∧
      { x | f x < p } ⊆ u ∧ { x | q < f x } ⊆ v ∧ μ (u ∩ v) = 0) :
    AEMeasurable f μ 
goal: AEMeasurable f μ

full_name: ENNReal.aemeasurable_of_exist_almost_disjoint_supersets
code: /-- If a function `f : α → ℝ≥0∞` is such that the level sets `{f < p}` and `{q < f}` have measurable
supersets which are disjoint up to measure zero when `p` and `q` are finite numbers satisfying
`p < q`, then `f` is almost-everywhere measurable. -/
theorem ENNReal.aemeasurable_of_exist_almost_disjoint_supersets {α : Type*} {m : MeasurableSpace α}
    (μ : Measure α) (f : α → ℝ≥0∞)
    (h : ∀ (p : ℝ≥0) (q : ℝ≥0), p < q →
      ∃ u v, MeasurableSet u ∧ MeasurableSet v ∧
        { x | f x < p } ⊆ u ∧ { x | (q : ℝ≥0∞) < f x } ⊆ v ∧ μ (u ∩ v) = 0) :
    AEMeasurable f μ 
goal: AEMeasurable f μ
File: Mathlib/MeasureTheory/Function/LpSeminorm/ChebyshevMarkov.lean

full_name: MeasureTheory.pow_mul_meas_ge_le_eLpNorm
code: theorem pow_mul_meas_ge_le_eLpNorm (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞)
    (hf : AEStronglyMeasurable f μ) (ε : ℝ≥0∞) :
    (ε * μ { x | ε ≤ (‖f x‖₊ : ℝ≥0∞) ^ p.toReal }) ^ (1 / p.toReal) ≤ eLpNorm f p μ 
goal: (ε * μ {x | ε ≤ ↑‖f x‖₊ ^ p.toReal}) ^ (1 / p.toReal) ≤ MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.mul_meas_ge_le_pow_eLpNorm
code: theorem mul_meas_ge_le_pow_eLpNorm (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞)
    (hf : AEStronglyMeasurable f μ) (ε : ℝ≥0∞) :
    ε * μ { x | ε ≤ (‖f x‖₊ : ℝ≥0∞) ^ p.toReal } ≤ eLpNorm f p μ ^ p.toReal 
goal: ε * μ {x | ε ≤ ↑‖f x‖₊ ^ p.toReal} ≤ MeasureTheory.eLpNorm f p μ ^ p.toReal

full_name: MeasureTheory.mul_meas_ge_le_pow_eLpNorm'
code: /-- A version of Chebyshev-Markov's inequality using Lp-norms. -/
theorem mul_meas_ge_le_pow_eLpNorm' (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞)
    (hf : AEStronglyMeasurable f μ) (ε : ℝ≥0∞) :
    ε ^ p.toReal * μ { x | ε ≤ ‖f x‖₊ } ≤ eLpNorm f p μ ^ p.toReal 
goal: ε ^ p.toReal * μ {x | ε ≤ ↑‖f x‖₊} ≤ MeasureTheory.eLpNorm f p μ ^ p.toReal

full_name: MeasureTheory.meas_ge_le_mul_pow_eLpNorm
code: theorem meas_ge_le_mul_pow_eLpNorm (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞)
    (hf : AEStronglyMeasurable f μ) {ε : ℝ≥0∞} (hε : ε ≠ 0) :
    μ { x | ε ≤ ‖f x‖₊ } ≤ ε⁻¹ ^ p.toReal * eLpNorm f p μ ^ p.toReal 
goal: μ {x | ε ≤ ↑‖f x‖₊} ≤ ε⁻¹ ^ p.toReal * MeasureTheory.eLpNorm f p μ ^ p.toReal
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Inner.lean

full_name: MeasureTheory.StronglyMeasurable.inner
code: protected theorem inner {𝕜 : Type*} {E : Type*} [RCLike 𝕜] [NormedAddCommGroup E]
    [InnerProductSpace 𝕜 E] {_ : MeasurableSpace α} {f g : α → E} (hf : StronglyMeasurable f)
    (hg : StronglyMeasurable g) : StronglyMeasurable fun t => @inner 𝕜 _ _ (f t) (g t) 
goal: ∀ {x : MeasurableSpace α} {f g : α → E},
  MeasureTheory.StronglyMeasurable f →
    MeasureTheory.StronglyMeasurable g → MeasureTheory.StronglyMeasurable fun t => ⟪f t, g t⟫_𝕜

full_name: MeasureTheory.AEStronglyMeasurable.«_aux_Mathlib_MeasureTheory_Function_StronglyMeasurable_Inner___macroRules_MeasureTheory_AEStronglyMeasurable_term⟪_,_⟫_1»
code: local notation "⟪" x ", " y "⟫" => @inner 𝕜 _ _ x y
goal: Lean.Macro

full_name: MeasureTheory.AEStronglyMeasurable.re
code: protected theorem re {f : α → 𝕜} (hf : AEStronglyMeasurable f μ) :
    AEStronglyMeasurable (fun x => RCLike.re (f x)) μ 
goal: MeasureTheory.AEStronglyMeasurable (fun x => RCLike.re (f x)) μ

full_name: MeasureTheory.AEStronglyMeasurable.im
code: protected theorem im {f : α → 𝕜} (hf : AEStronglyMeasurable f μ) :
    AEStronglyMeasurable (fun x => RCLike.im (f x)) μ 
goal: MeasureTheory.AEStronglyMeasurable (fun x => RCLike.im (f x)) μ

full_name: MeasureTheory.AEStronglyMeasurable.inner
code: protected theorem inner {_ : MeasurableSpace α} {μ : Measure α} {f g : α → E}
    (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) :
    AEStronglyMeasurable (fun x => ⟪f x, g x⟫) μ 
goal: ∀ {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → E},
  MeasureTheory.AEStronglyMeasurable f μ →
    MeasureTheory.AEStronglyMeasurable g μ → MeasureTheory.AEStronglyMeasurable (fun x => ⟪f x, g x⟫_𝕜) μ
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Lp.lean

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Function_StronglyMeasurable_Lp___macroRules_MeasureTheory_term_→ₛ__1»
code: local infixr:25 " →ₛ " => SimpleFunc
goal: Lean.Macro

full_name: MeasureTheory._aux_Mathlib_MeasureTheory_Function_StronglyMeasurable_Lp___unexpand_MeasureTheory_SimpleFunc_1
code: local infixr:25 " →ₛ " => SimpleFunc
goal: Lean.PrettyPrinter.Unexpander

full_name: MeasureTheory.Memℒp.finStronglyMeasurable_of_stronglyMeasurable
code: theorem Memℒp.finStronglyMeasurable_of_stronglyMeasurable (hf : Memℒp f p μ)
    (hf_meas : StronglyMeasurable f) (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    FinStronglyMeasurable f μ 
goal: MeasureTheory.FinStronglyMeasurable f μ

full_name: MeasureTheory.Memℒp.aefinStronglyMeasurable
code: theorem Memℒp.aefinStronglyMeasurable (hf : Memℒp f p μ) (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    AEFinStronglyMeasurable f μ 
goal: MeasureTheory.AEFinStronglyMeasurable f μ

full_name: MeasureTheory.Integrable.aefinStronglyMeasurable
code: theorem Integrable.aefinStronglyMeasurable (hf : Integrable f μ) : AEFinStronglyMeasurable f μ 
goal: MeasureTheory.AEFinStronglyMeasurable f μ

full_name: MeasureTheory.Lp.finStronglyMeasurable
code: theorem Lp.finStronglyMeasurable (f : Lp G p μ) (hp_ne_zero : p ≠ 0) (hp_ne_top : p ≠ ∞) :
    FinStronglyMeasurable f μ 
goal: MeasureTheory.FinStronglyMeasurable (↑↑f) μ
File: Mathlib/MeasureTheory/Function/LpSeminorm/Trim.lean

full_name: MeasureTheory.eLpNorm'_trim
code: theorem eLpNorm'_trim (hm : m ≤ m0) {f : α → E} (hf : StronglyMeasurable[m] f) :
    eLpNorm' f q (μ.trim hm) = eLpNorm' f q μ 
goal: MeasureTheory.eLpNorm' f q (μ.trim hm) = MeasureTheory.eLpNorm' f q μ

full_name: MeasureTheory.limsup_trim
code: theorem limsup_trim (hm : m ≤ m0) {f : α → ℝ≥0∞} (hf : Measurable[m] f) :
    limsup f (ae (μ.trim hm)) = limsup f (ae μ) 
goal: Filter.limsup f (MeasureTheory.ae (μ.trim hm)) = Filter.limsup f (MeasureTheory.ae μ)

full_name: MeasureTheory.essSup_trim
code: theorem essSup_trim (hm : m ≤ m0) {f : α → ℝ≥0∞} (hf : Measurable[m] f) :
    essSup f (μ.trim hm) = essSup f μ 
goal: essSup f (μ.trim hm) = essSup f μ

full_name: MeasureTheory.eLpNormEssSup_trim
code: theorem eLpNormEssSup_trim (hm : m ≤ m0) {f : α → E} (hf : StronglyMeasurable[m] f) :
    eLpNormEssSup f (μ.trim hm) = eLpNormEssSup f μ 
goal: MeasureTheory.eLpNormEssSup f (μ.trim hm) = MeasureTheory.eLpNormEssSup f μ

full_name: MeasureTheory.eLpNorm_trim
code: theorem eLpNorm_trim (hm : m ≤ m0) {f : α → E} (hf : StronglyMeasurable[m] f) :
    eLpNorm f p (μ.trim hm) = eLpNorm f p μ 
goal: MeasureTheory.eLpNorm f p (μ.trim hm) = MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.eLpNorm_trim_ae
code: theorem eLpNorm_trim_ae (hm : m ≤ m0) {f : α → E} (hf : AEStronglyMeasurable f (μ.trim hm)) :
    eLpNorm f p (μ.trim hm) = eLpNorm f p μ 
goal: MeasureTheory.eLpNorm f p (μ.trim hm) = MeasureTheory.eLpNorm f p μ

full_name: MeasureTheory.memℒp_of_memℒp_trim
code: theorem memℒp_of_memℒp_trim (hm : m ≤ m0) {f : α → E} (hf : Memℒp f p (μ.trim hm)) : Memℒp f p μ 
goal: MeasureTheory.Memℒp f p μ