File: Mathlib/MeasureTheory/Integral/Bochner.lean

full_name: MeasureTheory.weightedSMul
code: /-- Given a set `s`, return the continuous linear map `fun x => (μ s).toReal • x`. The extension
of that set function through `setToL1` gives the Bochner integral of L1 functions. -/
def weightedSMul {_ : MeasurableSpace α} (μ : Measure α) (s : Set α) : F →L[ℝ] F 
goal: {x : MeasurableSpace α} → MeasureTheory.Measure α → Set α → F →L[ℝ] F

full_name: MeasureTheory.weightedSMul_apply
code: theorem weightedSMul_apply {m : MeasurableSpace α} (μ : Measure α) (s : Set α) (x : F) :
    weightedSMul μ s x = (μ s).toReal • x 
goal: (MeasureTheory.weightedSMul μ s) x = (μ s).toReal • x

full_name: MeasureTheory.weightedSMul_zero_measure
code: @[simp]
theorem weightedSMul_zero_measure {m : MeasurableSpace α} :
    weightedSMul (0 : Measure α) = (0 : Set α → F →L[ℝ] F) 
goal: MeasureTheory.weightedSMul 0 = 0

full_name: MeasureTheory.weightedSMul_empty
code: @[simp]
theorem weightedSMul_empty {m : MeasurableSpace α} (μ : Measure α) :
    weightedSMul μ ∅ = (0 : F →L[ℝ] F) 
goal: MeasureTheory.weightedSMul μ ∅ = 0

full_name: MeasureTheory.weightedSMul_add_measure
code: theorem weightedSMul_add_measure {m : MeasurableSpace α} (μ ν : Measure α) {s : Set α}
    (hμs : μ s ≠ ∞) (hνs : ν s ≠ ∞) :
    (weightedSMul (μ + ν) s : F →L[ℝ] F) = weightedSMul μ s + weightedSMul ν s 
goal: MeasureTheory.weightedSMul (μ + ν) s = MeasureTheory.weightedSMul μ s + MeasureTheory.weightedSMul ν s

full_name: MeasureTheory.weightedSMul_smul_measure
code: theorem weightedSMul_smul_measure {m : MeasurableSpace α} (μ : Measure α) (c : ℝ≥0∞) {s : Set α} :
    (weightedSMul (c • μ) s : F →L[ℝ] F) = c.toReal • weightedSMul μ s 
goal: MeasureTheory.weightedSMul (c • μ) s = c.toReal • MeasureTheory.weightedSMul μ s

full_name: MeasureTheory.weightedSMul_congr
code: theorem weightedSMul_congr (s t : Set α) (hst : μ s = μ t) :
    (weightedSMul μ s : F →L[ℝ] F) = weightedSMul μ t 
goal: MeasureTheory.weightedSMul μ s = MeasureTheory.weightedSMul μ t

full_name: MeasureTheory.weightedSMul_null
code: theorem weightedSMul_null {s : Set α} (h_zero : μ s = 0) : (weightedSMul μ s : F →L[ℝ] F) = 0 
goal: MeasureTheory.weightedSMul μ s = 0

full_name: MeasureTheory.weightedSMul_union'
code: theorem weightedSMul_union' (s t : Set α) (ht : MeasurableSet t) (hs_finite : μ s ≠ ∞)
    (ht_finite : μ t ≠ ∞) (h_inter : s ∩ t = ∅) :
    (weightedSMul μ (s ∪ t) : F →L[ℝ] F) = weightedSMul μ s + weightedSMul μ t 
goal: MeasureTheory.weightedSMul μ (s ∪ t) = MeasureTheory.weightedSMul μ s + MeasureTheory.weightedSMul μ t

full_name: MeasureTheory.weightedSMul_union
code: @[nolint unusedArguments]
theorem weightedSMul_union (s t : Set α) (_hs : MeasurableSet s) (ht : MeasurableSet t)
    (hs_finite : μ s ≠ ∞) (ht_finite : μ t ≠ ∞) (h_inter : s ∩ t = ∅) :
    (weightedSMul μ (s ∪ t) : F →L[ℝ] F) = weightedSMul μ s + weightedSMul μ t 
goal: MeasureTheory.weightedSMul μ (s ∪ t) = MeasureTheory.weightedSMul μ s + MeasureTheory.weightedSMul μ t

full_name: MeasureTheory.weightedSMul_smul
code: theorem weightedSMul_smul [NormedField 𝕜] [NormedSpace 𝕜 F] [SMulCommClass ℝ 𝕜 F] (c : 𝕜)
    (s : Set α) (x : F) : weightedSMul μ s (c • x) = c • weightedSMul μ s x 
goal: (MeasureTheory.weightedSMul μ s) (c • x) = c • (MeasureTheory.weightedSMul μ s) x

full_name: MeasureTheory.norm_weightedSMul_le
code: theorem norm_weightedSMul_le (s : Set α) : ‖(weightedSMul μ s : F →L[ℝ] F)‖ ≤ (μ s).toReal 
goal: ‖MeasureTheory.weightedSMul μ s‖ ≤ (μ s).toReal

full_name: MeasureTheory.dominatedFinMeasAdditive_weightedSMul
code: theorem dominatedFinMeasAdditive_weightedSMul {_ : MeasurableSpace α} (μ : Measure α) :
    DominatedFinMeasAdditive μ (weightedSMul μ : Set α → F →L[ℝ] F) 1 
goal: ∀ {x : MeasurableSpace α} (μ : MeasureTheory.Measure α),
  MeasureTheory.DominatedFinMeasAdditive μ (MeasureTheory.weightedSMul μ) 1

full_name: MeasureTheory.weightedSMul_nonneg
code: theorem weightedSMul_nonneg (s : Set α) (x : ℝ) (hx : 0 ≤ x) : 0 ≤ weightedSMul μ s x 
goal: 0 ≤ (MeasureTheory.weightedSMul μ s) x

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

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

full_name: MeasureTheory.SimpleFunc.posPart
code: /-- Positive part of a simple function. -/
def posPart (f : α →ₛ E) : α →ₛ E 
goal: MeasureTheory.SimpleFunc α E

full_name: MeasureTheory.SimpleFunc.negPart
code: /-- Negative part of a simple function. -/
def negPart [Neg E] (f : α →ₛ E) : α →ₛ E 
goal: MeasureTheory.SimpleFunc α E

full_name: MeasureTheory.SimpleFunc.posPart_map_norm
code: theorem posPart_map_norm (f : α →ₛ ℝ) : (posPart f).map norm = posPart f 
goal: MeasureTheory.SimpleFunc.map norm f.posPart = f.posPart

full_name: MeasureTheory.SimpleFunc.negPart_map_norm
code: theorem negPart_map_norm (f : α →ₛ ℝ) : (negPart f).map norm = negPart f 
goal: MeasureTheory.SimpleFunc.map norm f.negPart = f.negPart

full_name: MeasureTheory.SimpleFunc.posPart_sub_negPart
code: theorem posPart_sub_negPart (f : α →ₛ ℝ) : f.posPart - f.negPart = f 
goal: f.posPart - f.negPart = f

full_name: MeasureTheory.SimpleFunc.integral
code: /-- Bochner integral of simple functions whose codomain is a real `NormedSpace`.
This is equal to `∑ x ∈ f.range, (μ (f ⁻¹' {x})).toReal • x` (see `integral_eq`). -/
def integral {_ : MeasurableSpace α} (μ : Measure α) (f : α →ₛ F) : F 
goal: {x : MeasurableSpace α} → MeasureTheory.Measure α → MeasureTheory.SimpleFunc α F → F

full_name: MeasureTheory.SimpleFunc.integral_def
code: theorem integral_def {_ : MeasurableSpace α} (μ : Measure α) (f : α →ₛ F) :
    f.integral μ = f.setToSimpleFunc (weightedSMul μ) 
goal: ∀ {x : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : MeasureTheory.SimpleFunc α F),
  MeasureTheory.SimpleFunc.integral μ f = MeasureTheory.SimpleFunc.setToSimpleFunc (MeasureTheory.weightedSMul μ) f

full_name: MeasureTheory.SimpleFunc.integral_eq
code: theorem integral_eq {m : MeasurableSpace α} (μ : Measure α) (f : α →ₛ F) :
    f.integral μ = ∑ x ∈ f.range, (μ (f ⁻¹' {x})).toReal • x 
goal: MeasureTheory.SimpleFunc.integral μ f = ∑ x ∈ f.range, (μ (↑f ⁻¹' {x})).toReal • x

full_name: MeasureTheory.SimpleFunc.integral_eq_sum_filter
code: theorem integral_eq_sum_filter [DecidablePred fun x : F => x ≠ 0] {m : MeasurableSpace α}
    (f : α →ₛ F) (μ : Measure α) :
    f.integral μ = ∑ x ∈ f.range.filter fun x => x ≠ 0, (μ (f ⁻¹' {x})).toReal • x 
goal: MeasureTheory.SimpleFunc.integral μ f = ∑ x ∈ Finset.filter (fun x => x ≠ 0) f.range, (μ (↑f ⁻¹' {x})).toReal • x

full_name: MeasureTheory.SimpleFunc.integral_eq_sum_of_subset
code: /-- The Bochner integral is equal to a sum over any set that includes `f.range` (except `0`). -/
theorem integral_eq_sum_of_subset [DecidablePred fun x : F => x ≠ 0] {f : α →ₛ F} {s : Finset F}
    (hs : (f.range.filter fun x => x ≠ 0) ⊆ s) :
    f.integral μ = ∑ x ∈ s, (μ (f ⁻¹' {x})).toReal • x 
goal: MeasureTheory.SimpleFunc.integral μ f = ∑ x ∈ s, (μ (↑f ⁻¹' {x})).toReal • x

full_name: MeasureTheory.SimpleFunc.integral_const
code: @[simp]
theorem integral_const {m : MeasurableSpace α} (μ : Measure α) (y : F) :
    (const α y).integral μ = (μ univ).toReal • y 
goal: MeasureTheory.SimpleFunc.integral μ (MeasureTheory.SimpleFunc.const α y) = (μ Set.univ).toReal • y

full_name: MeasureTheory.SimpleFunc.integral_piecewise_zero
code: @[simp]
theorem integral_piecewise_zero {m : MeasurableSpace α} (f : α →ₛ F) (μ : Measure α) {s : Set α}
    (hs : MeasurableSet s) : (piecewise s hs f 0).integral μ = f.integral (μ.restrict s) 
goal: MeasureTheory.SimpleFunc.integral μ (MeasureTheory.SimpleFunc.piecewise s hs f 0) =
  MeasureTheory.SimpleFunc.integral (μ.restrict s) f

full_name: MeasureTheory.SimpleFunc.map_integral
code: /-- Calculate the integral of `g ∘ f : α →ₛ F`, where `f` is an integrable function from `α` to `E`
    and `g` is a function from `E` to `F`. We require `g 0 = 0` so that `g ∘ f` is integrable. -/
theorem map_integral (f : α →ₛ E) (g : E → F) (hf : Integrable f μ) (hg : g 0 = 0) :
    (f.map g).integral μ = ∑ x ∈ f.range, ENNReal.toReal (μ (f ⁻¹' {x})) • g x 
goal: MeasureTheory.SimpleFunc.integral μ (MeasureTheory.SimpleFunc.map g f) = ∑ x ∈ f.range, (μ (↑f ⁻¹' {x})).toReal • g x

full_name: MeasureTheory.SimpleFunc.integral_eq_lintegral'
code: /-- `SimpleFunc.integral` and `SimpleFunc.lintegral` agree when the integrand has type
    `α →ₛ ℝ≥0∞`. But since `ℝ≥0∞` is not a `NormedSpace`, we need some form of coercion.
    See `integral_eq_lintegral` for a simpler version. -/
theorem integral_eq_lintegral' {f : α →ₛ E} {g : E → ℝ≥0∞} (hf : Integrable f μ) (hg0 : g 0 = 0)
    (ht : ∀ b, g b ≠ ∞) :
    (f.map (ENNReal.toReal ∘ g)).integral μ = ENNReal.toReal (∫⁻ a, g (f a) ∂μ) 
goal: MeasureTheory.SimpleFunc.integral μ (MeasureTheory.SimpleFunc.map (ENNReal.toReal ∘ g) f) =
  (∫⁻ (a : α), g (↑f a) ∂μ).toReal

full_name: MeasureTheory.SimpleFunc.integral_congr
code: theorem integral_congr {f g : α →ₛ E} (hf : Integrable f μ) (h : f =ᵐ[μ] g) :
    f.integral μ = g.integral μ 
goal: MeasureTheory.SimpleFunc.integral μ f = MeasureTheory.SimpleFunc.integral μ g

full_name: MeasureTheory.SimpleFunc.integral_eq_lintegral
code: /-- `SimpleFunc.bintegral` and `SimpleFunc.integral` agree when the integrand has type
    `α →ₛ ℝ≥0∞`. But since `ℝ≥0∞` is not a `NormedSpace`, we need some form of coercion. -/
theorem integral_eq_lintegral {f : α →ₛ ℝ} (hf : Integrable f μ) (h_pos : 0 ≤ᵐ[μ] f) :
    f.integral μ = ENNReal.toReal (∫⁻ a, ENNReal.ofReal (f a) ∂μ) 
goal: MeasureTheory.SimpleFunc.integral μ f = (∫⁻ (a : α), ENNReal.ofReal (↑f a) ∂μ).toReal

full_name: MeasureTheory.SimpleFunc.integral_add
code: theorem integral_add {f g : α →ₛ E} (hf : Integrable f μ) (hg : Integrable g μ) :
    integral μ (f + g) = integral μ f + integral μ g 
goal: MeasureTheory.SimpleFunc.integral μ (f + g) =
  MeasureTheory.SimpleFunc.integral μ f + MeasureTheory.SimpleFunc.integral μ g

full_name: MeasureTheory.SimpleFunc.integral_neg
code: theorem integral_neg {f : α →ₛ E} (hf : Integrable f μ) : integral μ (-f) = -integral μ f 
goal: MeasureTheory.SimpleFunc.integral μ (-f) = -MeasureTheory.SimpleFunc.integral μ f

full_name: MeasureTheory.SimpleFunc.integral_sub
code: theorem integral_sub {f g : α →ₛ E} (hf : Integrable f μ) (hg : Integrable g μ) :
    integral μ (f - g) = integral μ f - integral μ g 
goal: MeasureTheory.SimpleFunc.integral μ (f - g) =
  MeasureTheory.SimpleFunc.integral μ f - MeasureTheory.SimpleFunc.integral μ g

full_name: MeasureTheory.SimpleFunc.integral_smul
code: theorem integral_smul (c : 𝕜) {f : α →ₛ E} (hf : Integrable f μ) :
    integral μ (c • f) = c • integral μ f 
goal: MeasureTheory.SimpleFunc.integral μ (c • f) = c • MeasureTheory.SimpleFunc.integral μ f

full_name: MeasureTheory.SimpleFunc.norm_setToSimpleFunc_le_integral_norm
code: theorem norm_setToSimpleFunc_le_integral_norm (T : Set α → E →L[ℝ] F) {C : ℝ}
    (hT_norm : ∀ s, MeasurableSet s → μ s < ∞ → ‖T s‖ ≤ C * (μ s).toReal) {f : α →ₛ E}
    (hf : Integrable f μ) : ‖f.setToSimpleFunc T‖ ≤ C * (f.map norm).integral μ 
goal: ‖MeasureTheory.SimpleFunc.setToSimpleFunc T f‖ ≤
  C * MeasureTheory.SimpleFunc.integral μ (MeasureTheory.SimpleFunc.map norm f)

full_name: MeasureTheory.SimpleFunc.norm_integral_le_integral_norm
code: theorem norm_integral_le_integral_norm (f : α →ₛ E) (hf : Integrable f μ) :
    ‖f.integral μ‖ ≤ (f.map norm).integral μ 
goal: ‖MeasureTheory.SimpleFunc.integral μ f‖ ≤ MeasureTheory.SimpleFunc.integral μ (MeasureTheory.SimpleFunc.map norm f)

full_name: MeasureTheory.SimpleFunc.integral_add_measure
code: theorem integral_add_measure {ν} (f : α →ₛ E) (hf : Integrable f (μ + ν)) :
    f.integral (μ + ν) = f.integral μ + f.integral ν 
goal: MeasureTheory.SimpleFunc.integral (μ + ν) f =
  MeasureTheory.SimpleFunc.integral μ f + MeasureTheory.SimpleFunc.integral ν f

full_name: MeasureTheory.L1.SimpleFunc.norm_eq_integral
code: theorem norm_eq_integral (f : α →₁ₛ[μ] E) : ‖f‖ = ((toSimpleFunc f).map norm).integral μ 
goal: ‖f‖ =
  MeasureTheory.SimpleFunc.integral μ (MeasureTheory.SimpleFunc.map norm (MeasureTheory.Lp.simpleFunc.toSimpleFunc f))

full_name: MeasureTheory.L1.SimpleFunc.posPart
code: /-- Positive part of a simple function in L1 space.  -/
nonrec def posPart (f : α →₁ₛ[μ] ℝ) : α →₁ₛ[μ] ℝ 
goal: ↥(MeasureTheory.Lp.simpleFunc ℝ 1 μ)

full_name: MeasureTheory.L1.SimpleFunc.negPart
code: /-- Negative part of a simple function in L1 space. -/
def negPart (f : α →₁ₛ[μ] ℝ) : α →₁ₛ[μ] ℝ 
goal: ↥(MeasureTheory.Lp.simpleFunc ℝ 1 μ)

full_name: MeasureTheory.L1.SimpleFunc.coe_posPart
code: @[norm_cast]
theorem coe_posPart (f : α →₁ₛ[μ] ℝ) : (posPart f : α →₁[μ] ℝ) = Lp.posPart (f : α →₁[μ] ℝ) 
goal: ↑(MeasureTheory.L1.SimpleFunc.posPart f) = MeasureTheory.Lp.posPart ↑f

full_name: MeasureTheory.L1.SimpleFunc.coe_negPart
code: @[norm_cast]
theorem coe_negPart (f : α →₁ₛ[μ] ℝ) : (negPart f : α →₁[μ] ℝ) = Lp.negPart (f : α →₁[μ] ℝ) 
goal: ↑(MeasureTheory.L1.SimpleFunc.negPart f) = MeasureTheory.Lp.negPart ↑f

full_name: MeasureTheory.L1.SimpleFunc.integral
code: /-- The Bochner integral over simple functions in L1 space. -/
def integral (f : α →₁ₛ[μ] E) : E 
goal: E

full_name: MeasureTheory.L1.SimpleFunc.integral_eq_integral
code: theorem integral_eq_integral (f : α →₁ₛ[μ] E) : integral f = (toSimpleFunc f).integral μ 
goal: MeasureTheory.L1.SimpleFunc.integral f =
  MeasureTheory.SimpleFunc.integral μ (MeasureTheory.Lp.simpleFunc.toSimpleFunc f)

full_name: MeasureTheory.L1.SimpleFunc.integral_eq_lintegral
code: nonrec theorem integral_eq_lintegral {f : α →₁ₛ[μ] ℝ} (h_pos : 0 ≤ᵐ[μ] toSimpleFunc f) :
    integral f = ENNReal.toReal (∫⁻ a, ENNReal.ofReal ((toSimpleFunc f) a) ∂μ) 
goal: MeasureTheory.L1.SimpleFunc.integral f =
  (∫⁻ (a : α), ENNReal.ofReal (↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f) a) ∂μ).toReal

full_name: MeasureTheory.L1.SimpleFunc.integral_eq_setToL1S
code: theorem integral_eq_setToL1S (f : α →₁ₛ[μ] E) : integral f = setToL1S (weightedSMul μ) f 
goal: MeasureTheory.L1.SimpleFunc.integral f = MeasureTheory.L1.SimpleFunc.setToL1S (MeasureTheory.weightedSMul μ) f

full_name: MeasureTheory.L1.SimpleFunc.integral_congr
code: nonrec theorem integral_congr {f g : α →₁ₛ[μ] E} (h : toSimpleFunc f =ᵐ[μ] toSimpleFunc g) :
    integral f = integral g 
goal: MeasureTheory.L1.SimpleFunc.integral f = MeasureTheory.L1.SimpleFunc.integral g

full_name: MeasureTheory.L1.SimpleFunc.integral_add
code: theorem integral_add (f g : α →₁ₛ[μ] E) : integral (f + g) = integral f + integral g 
goal: MeasureTheory.L1.SimpleFunc.integral (f + g) =
  MeasureTheory.L1.SimpleFunc.integral f + MeasureTheory.L1.SimpleFunc.integral g

full_name: MeasureTheory.L1.SimpleFunc.integral_smul
code: theorem integral_smul (c : 𝕜) (f : α →₁ₛ[μ] E) : integral (c • f) = c • integral f 
goal: MeasureTheory.L1.SimpleFunc.integral (c • f) = c • MeasureTheory.L1.SimpleFunc.integral f

full_name: MeasureTheory.L1.SimpleFunc.norm_integral_le_norm
code: theorem norm_integral_le_norm (f : α →₁ₛ[μ] E) : ‖integral f‖ ≤ ‖f‖ 
goal: ‖MeasureTheory.L1.SimpleFunc.integral f‖ ≤ ‖f‖

full_name: MeasureTheory.L1.SimpleFunc.integralCLM'
code: /-- The Bochner integral over simple functions in L1 space as a continuous linear map. -/
def integralCLM' : (α →₁ₛ[μ] E) →L[𝕜] E 
goal: ↥(MeasureTheory.Lp.simpleFunc E 1 μ) →L[𝕜] E

full_name: MeasureTheory.L1.SimpleFunc.integralCLM
code: /-- The Bochner integral over simple functions in L1 space as a continuous linear map over ℝ. -/
def integralCLM : (α →₁ₛ[μ] E) →L[ℝ] E 
goal: ↥(MeasureTheory.Lp.simpleFunc E 1 μ) →L[ℝ] E

full_name: MeasureTheory.L1.SimpleFunc._aux_Mathlib_MeasureTheory_Integral_Bochner___unexpand_MeasureTheory_L1_SimpleFunc_integralCLM_1
code: local notation "Integral" => integralCLM α E μ
goal: Lean.PrettyPrinter.Unexpander

full_name: MeasureTheory.L1.SimpleFunc._aux_Mathlib_MeasureTheory_Integral_Bochner___macroRules_MeasureTheory_L1_SimpleFunc_termIntegral_1
code: local notation "Integral" => integralCLM α E μ
goal: Lean.Macro

full_name: MeasureTheory.L1.SimpleFunc.norm_Integral_le_one
code: theorem norm_Integral_le_one : ‖Integral‖ ≤ 1 
goal: ‖MeasureTheory.L1.SimpleFunc.integralCLM α E μ‖ ≤ 1

full_name: MeasureTheory.L1.SimpleFunc.posPart_toSimpleFunc
code: theorem posPart_toSimpleFunc (f : α →₁ₛ[μ] ℝ) :
    toSimpleFunc (posPart f) =ᵐ[μ] (toSimpleFunc f).posPart 
goal: ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc (MeasureTheory.L1.SimpleFunc.posPart f)) =ᵐ[μ]
  ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f).posPart

full_name: MeasureTheory.L1.SimpleFunc.negPart_toSimpleFunc
code: theorem negPart_toSimpleFunc (f : α →₁ₛ[μ] ℝ) :
    toSimpleFunc (negPart f) =ᵐ[μ] (toSimpleFunc f).negPart 
goal: ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc (MeasureTheory.L1.SimpleFunc.negPart f)) =ᵐ[μ]
  ↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f).negPart

full_name: MeasureTheory.L1.SimpleFunc.integral_eq_norm_posPart_sub
code: theorem integral_eq_norm_posPart_sub (f : α →₁ₛ[μ] ℝ) : integral f = ‖posPart f‖ - ‖negPart f‖ 
goal: MeasureTheory.L1.SimpleFunc.integral f =
  ‖MeasureTheory.L1.SimpleFunc.posPart f‖ - ‖MeasureTheory.L1.SimpleFunc.negPart f‖

full_name: MeasureTheory.L1._aux_Mathlib_MeasureTheory_Integral_Bochner___macroRules_MeasureTheory_L1_termIntegral_1
code: local notation "Integral" => @integralCLM α E _ _ _ _ _ μ _
goal: Lean.Macro

full_name: MeasureTheory.L1.integralCLM'
code: /-- The Bochner integral in L1 space as a continuous linear map. -/
nonrec def integralCLM' : (α →₁[μ] E) →L[𝕜] E 
goal: ↥(MeasureTheory.Lp E 1 μ) →L[𝕜] E

full_name: MeasureTheory.L1.integralCLM
code: /-- The Bochner integral in L1 space as a continuous linear map over ℝ. -/
def integralCLM : (α →₁[μ] E) →L[ℝ] E 
goal: ↥(MeasureTheory.Lp E 1 μ) →L[ℝ] E

full_name: MeasureTheory.L1.definition._@.Mathlib.MeasureTheory.Integral.Bochner._hyg.9173
code: /-- The Bochner integral in L1 space -/
irreducible_def integral : (α →₁[μ] E) → E 
goal: ↥(MeasureTheory.Lp E 1 μ) → E

full_name: MeasureTheory.L1.integral_def
code: /-- The Bochner integral in L1 space -/
irreducible_def integral : (α →₁[μ] E) → E 
goal: MeasureTheory.L1.integral = ⇑MeasureTheory.L1.integralCLM

full_name: MeasureTheory.L1.integral
code: /-- The Bochner integral in L1 space -/
irreducible_def integral : (α →₁[μ] E) → E 
goal: ↥(MeasureTheory.Lp E 1 μ) → E

full_name: MeasureTheory.L1.wrapped._@.Mathlib.MeasureTheory.Integral.Bochner._hyg.9173
code: /-- The Bochner integral in L1 space -/
irreducible_def integral : (α →₁[μ] E) → E 
goal: Subtype (Eq @MeasureTheory.L1.definition✝)

full_name: MeasureTheory.L1.integral_eq
code: theorem integral_eq (f : α →₁[μ] E) : integral f = integralCLM (E := E) f 
goal: MeasureTheory.L1.integral f = MeasureTheory.L1.integralCLM f

full_name: MeasureTheory.L1.integral_eq_setToL1
code: theorem integral_eq_setToL1 (f : α →₁[μ] E) :
    integral f = setToL1 (E := E) (dominatedFinMeasAdditive_weightedSMul μ) f 
goal: MeasureTheory.L1.integral f = (MeasureTheory.L1.setToL1 ⋯) f

full_name: MeasureTheory.L1.SimpleFunc.integral_L1_eq_integral
code: @[norm_cast]
theorem SimpleFunc.integral_L1_eq_integral (f : α →₁ₛ[μ] E) :
    L1.integral (f : α →₁[μ] E) = SimpleFunc.integral f 
goal: MeasureTheory.L1.integral ↑f = MeasureTheory.L1.SimpleFunc.integral f

full_name: MeasureTheory.L1.integral_zero
code: @[simp]
theorem integral_zero : integral (0 : α →₁[μ] E) = 0 
goal: MeasureTheory.L1.integral 0 = 0

full_name: MeasureTheory.L1.integral_add
code: @[integral_simps]
theorem integral_add (f g : α →₁[μ] E) : integral (f + g) = integral f + integral g 
goal: MeasureTheory.L1.integral (f + g) = MeasureTheory.L1.integral f + MeasureTheory.L1.integral g

full_name: MeasureTheory.L1.integral_neg
code: @[integral_simps]
theorem integral_neg (f : α →₁[μ] E) : integral (-f) = -integral f 
goal: MeasureTheory.L1.integral (-f) = -MeasureTheory.L1.integral f

full_name: MeasureTheory.L1.integral_sub
code: @[integral_simps]
theorem integral_sub (f g : α →₁[μ] E) : integral (f - g) = integral f - integral g 
goal: MeasureTheory.L1.integral (f - g) = MeasureTheory.L1.integral f - MeasureTheory.L1.integral g

full_name: MeasureTheory.L1.integral_smul
code: @[integral_simps]
theorem integral_smul (c : 𝕜) (f : α →₁[μ] E) : integral (c • f) = c • integral f 
goal: MeasureTheory.L1.integral (c • f) = c • MeasureTheory.L1.integral f

full_name: MeasureTheory.L1._aux_Mathlib_MeasureTheory_Integral_Bochner___macroRules_MeasureTheory_L1_termIntegral_2
code: local notation "Integral" => @integralCLM α E _ _ μ _ _
goal: Lean.Macro

full_name: MeasureTheory.L1._aux_Mathlib_MeasureTheory_Integral_Bochner___macroRules_MeasureTheory_L1_termSIntegral_1
code: local notation "sIntegral" => @SimpleFunc.integralCLM α E _ _ μ _
goal: Lean.Macro

full_name: MeasureTheory.L1.norm_Integral_le_one
code: theorem norm_Integral_le_one : ‖integralCLM (α := α) (E := E) (μ := μ)‖ ≤ 1 
goal: ‖MeasureTheory.L1.integralCLM‖ ≤ 1

full_name: MeasureTheory.L1.nnnorm_Integral_le_one
code: theorem nnnorm_Integral_le_one : ‖integralCLM (α := α) (E := E) (μ := μ)‖₊ ≤ 1 
goal: ‖MeasureTheory.L1.integralCLM‖₊ ≤ 1

full_name: MeasureTheory.L1.norm_integral_le
code: theorem norm_integral_le (f : α →₁[μ] E) : ‖integral f‖ ≤ ‖f‖ 
goal: ‖MeasureTheory.L1.integral f‖ ≤ ‖f‖

full_name: MeasureTheory.L1.nnnorm_integral_le
code: theorem nnnorm_integral_le (f : α →₁[μ] E) : ‖integral f‖₊ ≤ ‖f‖₊ 
goal: ‖MeasureTheory.L1.integral f‖₊ ≤ ‖f‖₊

full_name: MeasureTheory.L1.continuous_integral
code: @[continuity]
theorem continuous_integral : Continuous fun f : α →₁[μ] E => integral f 
goal: Continuous fun f => MeasureTheory.L1.integral f

full_name: MeasureTheory.L1.integral_eq_norm_posPart_sub
code: theorem integral_eq_norm_posPart_sub (f : α →₁[μ] ℝ) :
    integral f = ‖Lp.posPart f‖ - ‖Lp.negPart f‖ 
goal: MeasureTheory.L1.integral f = ‖MeasureTheory.Lp.posPart f‖ - ‖MeasureTheory.Lp.negPart f‖

full_name: MeasureTheory.wrapped._@.Mathlib.MeasureTheory.Integral.Bochner._hyg.11716
code: /-- The Bochner integral -/
irreducible_def integral {_ : MeasurableSpace α} (μ : Measure α) (f : α → G) : G 
goal: Subtype (Eq @MeasureTheory.definition✝)

full_name: MeasureTheory.integral
code: /-- The Bochner integral -/
irreducible_def integral {_ : MeasurableSpace α} (μ : Measure α) (f : α → G) : G 
goal: {x : MeasurableSpace α} → MeasureTheory.Measure α → (α → G) → G

full_name: MeasureTheory.integral_def
code: /-- The Bochner integral -/
irreducible_def integral {_ : MeasurableSpace α} (μ : Measure α) (f : α → G) : G 
goal: ∀ {x : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → G),
  MeasureTheory.integral μ f =
    if x_1 : CompleteSpace G then
      if hf : MeasureTheory.Integrable f μ then MeasureTheory.L1.integral (MeasureTheory.Integrable.toL1 f hf) else 0
    else 0

full_name: MeasureTheory.definition._@.Mathlib.MeasureTheory.Integral.Bochner._hyg.11716
code: /-- The Bochner integral -/
irreducible_def integral {_ : MeasurableSpace α} (μ : Measure α) (f : α → G) : G 
goal: {x : MeasurableSpace α} → MeasureTheory.Measure α → (α → G) → G

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_Bochner___macroRules_MeasureTheory_term∫_,_∂__1»
code: @[inherit_doc MeasureTheory.integral]
notation3 "∫ "(...)", "r:60:(scoped f => f)" ∂"μ:70 => integral μ r
goal: Lean.Macro

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_Bochner___macroRules_MeasureTheory_term∫_,__1»
code: @[inherit_doc MeasureTheory.integral]
notation3 "∫ "(...)", "r:60:(scoped f => integral volume f) => r
goal: Lean.Macro

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_Bochner___macroRules_MeasureTheory_term∫_In_,_∂__1»
code: @[inherit_doc MeasureTheory.integral]
notation3 "∫ "(...)" in "s", "r:60:(scoped f => f)" ∂"μ:70 => integral (Measure.restrict μ s) r
goal: Lean.Macro

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_Bochner___macroRules_MeasureTheory_term∫_In_,__1»
code: @[inherit_doc MeasureTheory.integral]
notation3 "∫ "(...)" in "s", "r:60:(scoped f => integral (Measure.restrict volume s) f) => r
goal: Lean.Macro

full_name: MeasureTheory.integral_eq
code: theorem integral_eq (f : α → E) (hf : Integrable f μ) : ∫ a, f a ∂μ = L1.integral (hf.toL1 f) 
goal: ∫ (a : α), f a ∂μ = MeasureTheory.L1.integral (MeasureTheory.Integrable.toL1 f hf)

full_name: MeasureTheory.integral_eq_setToFun
code: theorem integral_eq_setToFun (f : α → E) :
    ∫ a, f a ∂μ = setToFun μ (weightedSMul μ) (dominatedFinMeasAdditive_weightedSMul μ) f 
goal: ∫ (a : α), f a ∂μ = MeasureTheory.setToFun μ (MeasureTheory.weightedSMul μ) ⋯ f

full_name: MeasureTheory.L1.integral_eq_integral
code: theorem L1.integral_eq_integral (f : α →₁[μ] E) : L1.integral f = ∫ a, f a ∂μ 
goal: MeasureTheory.L1.integral f = ∫ (a : α), ↑↑f a ∂μ

full_name: MeasureTheory.integral_undef
code: theorem integral_undef {f : α → G} (h : ¬Integrable f μ) : ∫ a, f a ∂μ = 0 
goal: ∫ (a : α), f a ∂μ = 0

full_name: MeasureTheory.Integrable.of_integral_ne_zero
code: theorem Integrable.of_integral_ne_zero {f : α → G} (h : ∫ a, f a ∂μ ≠ 0) : Integrable f μ 
goal: MeasureTheory.Integrable f μ

full_name: MeasureTheory.integral_non_aestronglyMeasurable
code: theorem integral_non_aestronglyMeasurable {f : α → G} (h : ¬AEStronglyMeasurable f μ) :
    ∫ a, f a ∂μ = 0 
goal: ∫ (a : α), f a ∂μ = 0

full_name: MeasureTheory.integral_zero
code: @[simp]
theorem integral_zero : ∫ _ : α, (0 : G) ∂μ = 0 
goal: ∫ (x : α), 0 ∂μ = 0

full_name: MeasureTheory.integral_zero'
code: @[simp]
theorem integral_zero' : integral μ (0 : α → G) = 0 
goal: MeasureTheory.integral μ 0 = 0

full_name: MeasureTheory.integrable_of_integral_eq_one
code: theorem integrable_of_integral_eq_one {f : α → ℝ} (h : ∫ x, f x ∂μ = 1) : Integrable f μ 
goal: MeasureTheory.Integrable f μ

full_name: MeasureTheory.integral_add
code: theorem integral_add {f g : α → G} (hf : Integrable f μ) (hg : Integrable g μ) :
    ∫ a, f a + g a ∂μ = ∫ a, f a ∂μ + ∫ a, g a ∂μ 
goal: ∫ (a : α), f a + g a ∂μ = ∫ (a : α), f a ∂μ + ∫ (a : α), g a ∂μ

full_name: MeasureTheory.integral_add'
code: theorem integral_add' {f g : α → G} (hf : Integrable f μ) (hg : Integrable g μ) :
    ∫ a, (f + g) a ∂μ = ∫ a, f a ∂μ + ∫ a, g a ∂μ 
goal: ∫ (a : α), (f + g) a ∂μ = ∫ (a : α), f a ∂μ + ∫ (a : α), g a ∂μ

full_name: MeasureTheory.integral_finset_sum
code: theorem integral_finset_sum {ι} (s : Finset ι) {f : ι → α → G} (hf : ∀ i ∈ s, Integrable (f i) μ) :
    ∫ a, ∑ i ∈ s, f i a ∂μ = ∑ i ∈ s, ∫ a, f i a ∂μ 
goal: ∫ (a : α), ∑ i ∈ s, f i a ∂μ = ∑ i ∈ s, ∫ (a : α), f i a ∂μ

full_name: MeasureTheory.integral_neg
code: @[integral_simps]
theorem integral_neg (f : α → G) : ∫ a, -f a ∂μ = -∫ a, f a ∂μ 
goal: ∫ (a : α), -f a ∂μ = -∫ (a : α), f a ∂μ

full_name: MeasureTheory.integral_neg'
code: theorem integral_neg' (f : α → G) : ∫ a, (-f) a ∂μ = -∫ a, f a ∂μ 
goal: ∫ (a : α), (-f) a ∂μ = -∫ (a : α), f a ∂μ

full_name: MeasureTheory.integral_sub
code: theorem integral_sub {f g : α → G} (hf : Integrable f μ) (hg : Integrable g μ) :
    ∫ a, f a - g a ∂μ = ∫ a, f a ∂μ - ∫ a, g a ∂μ 
goal: ∫ (a : α), f a - g a ∂μ = ∫ (a : α), f a ∂μ - ∫ (a : α), g a ∂μ

full_name: MeasureTheory.integral_sub'
code: theorem integral_sub' {f g : α → G} (hf : Integrable f μ) (hg : Integrable g μ) :
    ∫ a, (f - g) a ∂μ = ∫ a, f a ∂μ - ∫ a, g a ∂μ 
goal: ∫ (a : α), (f - g) a ∂μ = ∫ (a : α), f a ∂μ - ∫ (a : α), g a ∂μ

full_name: MeasureTheory.integral_smul
code: @[integral_simps]
theorem integral_smul [NormedSpace 𝕜 G] [SMulCommClass ℝ 𝕜 G] (c : 𝕜) (f : α → G) :
    ∫ a, c • f a ∂μ = c • ∫ a, f a ∂μ 
goal: ∫ (a : α), c • f a ∂μ = c • ∫ (a : α), f a ∂μ

full_name: MeasureTheory.integral_mul_left
code: theorem integral_mul_left {L : Type*} [RCLike L] (r : L) (f : α → L) :
    ∫ a, r * f a ∂μ = r * ∫ a, f a ∂μ 
goal: ∫ (a : α), r * f a ∂μ = r * ∫ (a : α), f a ∂μ

full_name: MeasureTheory.integral_mul_right
code: theorem integral_mul_right {L : Type*} [RCLike L] (r : L) (f : α → L) :
    ∫ a, f a * r ∂μ = (∫ a, f a ∂μ) * r 
goal: ∫ (a : α), f a * r ∂μ = (∫ (a : α), f a ∂μ) * r

full_name: MeasureTheory.integral_div
code: theorem integral_div {L : Type*} [RCLike L] (r : L) (f : α → L) :
    ∫ a, f a / r ∂μ = (∫ a, f a ∂μ) / r 
goal: ∫ (a : α), f a / r ∂μ = (∫ (a : α), f a ∂μ) / r

full_name: MeasureTheory.integral_congr_ae
code: theorem integral_congr_ae {f g : α → G} (h : f =ᵐ[μ] g) : ∫ a, f a ∂μ = ∫ a, g a ∂μ 
goal: ∫ (a : α), f a ∂μ = ∫ (a : α), g a ∂μ

full_name: MeasureTheory.L1.integral_of_fun_eq_integral
code: @[simp, nolint simpNF]
theorem L1.integral_of_fun_eq_integral {f : α → G} (hf : Integrable f μ) :
    ∫ a, (hf.toL1 f) a ∂μ = ∫ a, f a ∂μ 
goal: ∫ (a : α), ↑↑(MeasureTheory.Integrable.toL1 f hf) a ∂μ = ∫ (a : α), f a ∂μ

full_name: MeasureTheory.continuous_integral
code: @[continuity]
theorem continuous_integral : Continuous fun f : α →₁[μ] G => ∫ a, f a ∂μ 
goal: Continuous fun f => ∫ (a : α), ↑↑f a ∂μ

full_name: MeasureTheory.norm_integral_le_lintegral_norm
code: theorem norm_integral_le_lintegral_norm (f : α → G) :
    ‖∫ a, f a ∂μ‖ ≤ ENNReal.toReal (∫⁻ a, ENNReal.ofReal ‖f a‖ ∂μ) 
goal: ‖∫ (a : α), f a ∂μ‖ ≤ (∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ).toReal

full_name: MeasureTheory.ennnorm_integral_le_lintegral_ennnorm
code: theorem ennnorm_integral_le_lintegral_ennnorm (f : α → G) :
    (‖∫ a, f a ∂μ‖₊ : ℝ≥0∞) ≤ ∫⁻ a, ‖f a‖₊ ∂μ 
goal: ↑‖∫ (a : α), f a ∂μ‖₊ ≤ ∫⁻ (a : α), ↑‖f a‖₊ ∂μ

full_name: MeasureTheory.integral_eq_zero_of_ae
code: theorem integral_eq_zero_of_ae {f : α → G} (hf : f =ᵐ[μ] 0) : ∫ a, f a ∂μ = 0 
goal: ∫ (a : α), f a ∂μ = 0

full_name: MeasureTheory.HasFiniteIntegral.tendsto_setIntegral_nhds_zero
code: /-- If `f` has finite integral, then `∫ x in s, f x ∂μ` is absolutely continuous in `s`: it tends
to zero as `μ s` tends to zero. -/
theorem HasFiniteIntegral.tendsto_setIntegral_nhds_zero {ι} {f : α → G}
    (hf : HasFiniteIntegral f μ) {l : Filter ι} {s : ι → Set α} (hs : Tendsto (μ ∘ s) l (𝓝 0)) :
    Tendsto (fun i => ∫ x in s i, f x ∂μ) l (𝓝 0) 
goal: Filter.Tendsto (fun i => ∫ (x : α) in s i, f x ∂μ) l (𝓝 0)

full_name: MeasureTheory.Integrable.tendsto_setIntegral_nhds_zero
code: /-- If `f` is integrable, then `∫ x in s, f x ∂μ` is absolutely continuous in `s`: it tends
to zero as `μ s` tends to zero. -/
theorem Integrable.tendsto_setIntegral_nhds_zero {ι} {f : α → G} (hf : Integrable f μ)
    {l : Filter ι} {s : ι → Set α} (hs : Tendsto (μ ∘ s) l (𝓝 0)) :
    Tendsto (fun i => ∫ x in s i, f x ∂μ) l (𝓝 0) 
goal: Filter.Tendsto (fun i => ∫ (x : α) in s i, f x ∂μ) l (𝓝 0)

full_name: MeasureTheory.tendsto_integral_of_L1
code: /-- If `F i → f` in `L1`, then `∫ x, F i x ∂μ → ∫ x, f x ∂μ`. -/
theorem tendsto_integral_of_L1 {ι} (f : α → G) (hfi : Integrable f μ) {F : ι → α → G} {l : Filter ι}
    (hFi : ∀ᶠ i in l, Integrable (F i) μ)
    (hF : Tendsto (fun i => ∫⁻ x, ‖F i x - f x‖₊ ∂μ) l (𝓝 0)) :
    Tendsto (fun i => ∫ x, F i x ∂μ) l (𝓝 <| ∫ x, f x ∂μ) 
goal: Filter.Tendsto (fun i => ∫ (x : α), F i x ∂μ) l (𝓝 (∫ (x : α), f x ∂μ))

full_name: MeasureTheory.tendsto_integral_of_L1'
code: /-- If `F i → f` in `L1`, then `∫ x, F i x ∂μ → ∫ x, f x ∂μ`. -/
lemma tendsto_integral_of_L1' {ι} (f : α → G) (hfi : Integrable f μ) {F : ι → α → G} {l : Filter ι}
    (hFi : ∀ᶠ i in l, Integrable (F i) μ) (hF : Tendsto (fun i ↦ eLpNorm (F i - f) 1 μ) l (𝓝 0)) :
    Tendsto (fun i ↦ ∫ x, F i x ∂μ) l (𝓝 (∫ x, f x ∂μ)) 
goal: Filter.Tendsto (fun i => ∫ (x : α), F i x ∂μ) l (𝓝 (∫ (x : α), f x ∂μ))

full_name: MeasureTheory.tendsto_setIntegral_of_L1
code: /-- If `F i → f` in `L1`, then `∫ x in s, F i x ∂μ → ∫ x in s, f x ∂μ`. -/
lemma tendsto_setIntegral_of_L1 {ι} (f : α → G) (hfi : Integrable f μ) {F : ι → α → G}
    {l : Filter ι}
    (hFi : ∀ᶠ i in l, Integrable (F i) μ) (hF : Tendsto (fun i ↦ ∫⁻ x, ‖F i x - f x‖₊ ∂μ) l (𝓝 0))
    (s : Set α) :
    Tendsto (fun i ↦ ∫ x in s, F i x ∂μ) l (𝓝 (∫ x in s, f x ∂μ)) 
goal: Filter.Tendsto (fun i => ∫ (x : α) in s, F i x ∂μ) l (𝓝 (∫ (x : α) in s, f x ∂μ))

full_name: MeasureTheory.tendsto_setIntegral_of_L1'
code: /-- If `F i → f` in `L1`, then `∫ x in s, F i x ∂μ → ∫ x in s, f x ∂μ`. -/
lemma tendsto_setIntegral_of_L1' {ι} (f : α → G) (hfi : Integrable f μ) {F : ι → α → G}
    {l : Filter ι}
    (hFi : ∀ᶠ i in l, Integrable (F i) μ) (hF : Tendsto (fun i ↦ eLpNorm (F i - f) 1 μ) l (𝓝 0))
    (s : Set α) :
    Tendsto (fun i ↦ ∫ x in s, F i x ∂μ) l (𝓝 (∫ x in s, f x ∂μ)) 
goal: Filter.Tendsto (fun i => ∫ (x : α) in s, F i x ∂μ) l (𝓝 (∫ (x : α) in s, f x ∂μ))

full_name: MeasureTheory.continuousWithinAt_of_dominated
code: theorem continuousWithinAt_of_dominated {F : X → α → G} {x₀ : X} {bound : α → ℝ} {s : Set X}
    (hF_meas : ∀ᶠ x in 𝓝[s] x₀, AEStronglyMeasurable (F x) μ)
    (h_bound : ∀ᶠ x in 𝓝[s] x₀, ∀ᵐ a ∂μ, ‖F x a‖ ≤ bound a) (bound_integrable : Integrable bound μ)
    (h_cont : ∀ᵐ a ∂μ, ContinuousWithinAt (fun x => F x a) s x₀) :
    ContinuousWithinAt (fun x => ∫ a, F x a ∂μ) s x₀ 
goal: ContinuousWithinAt (fun x => ∫ (a : α), F x a ∂μ) s x₀

full_name: MeasureTheory.continuousAt_of_dominated
code: theorem continuousAt_of_dominated {F : X → α → G} {x₀ : X} {bound : α → ℝ}
    (hF_meas : ∀ᶠ x in 𝓝 x₀, AEStronglyMeasurable (F x) μ)
    (h_bound : ∀ᶠ x in 𝓝 x₀, ∀ᵐ a ∂μ, ‖F x a‖ ≤ bound a) (bound_integrable : Integrable bound μ)
    (h_cont : ∀ᵐ a ∂μ, ContinuousAt (fun x => F x a) x₀) :
    ContinuousAt (fun x => ∫ a, F x a ∂μ) x₀ 
goal: ContinuousAt (fun x => ∫ (a : α), F x a ∂μ) x₀

full_name: MeasureTheory.continuousOn_of_dominated
code: theorem continuousOn_of_dominated {F : X → α → G} {bound : α → ℝ} {s : Set X}
    (hF_meas : ∀ x ∈ s, AEStronglyMeasurable (F x) μ)
    (h_bound : ∀ x ∈ s, ∀ᵐ a ∂μ, ‖F x a‖ ≤ bound a) (bound_integrable : Integrable bound μ)
    (h_cont : ∀ᵐ a ∂μ, ContinuousOn (fun x => F x a) s) :
    ContinuousOn (fun x => ∫ a, F x a ∂μ) s 
goal: ContinuousOn (fun x => ∫ (a : α), F x a ∂μ) s

full_name: MeasureTheory.continuous_of_dominated
code: theorem continuous_of_dominated {F : X → α → G} {bound : α → ℝ}
    (hF_meas : ∀ x, AEStronglyMeasurable (F x) μ) (h_bound : ∀ x, ∀ᵐ a ∂μ, ‖F x a‖ ≤ bound a)
    (bound_integrable : Integrable bound μ) (h_cont : ∀ᵐ a ∂μ, Continuous fun x => F x a) :
    Continuous fun x => ∫ a, F x a ∂μ 
goal: Continuous fun x => ∫ (a : α), F x a ∂μ

full_name: MeasureTheory.integral_eq_lintegral_pos_part_sub_lintegral_neg_part
code: /-- The Bochner integral of a real-valued function `f : α → ℝ` is the difference between the
  integral of the positive part of `f` and the integral of the negative part of `f`.  -/
theorem integral_eq_lintegral_pos_part_sub_lintegral_neg_part {f : α → ℝ} (hf : Integrable f μ) :
    ∫ a, f a ∂μ =
      ENNReal.toReal (∫⁻ a, .ofReal (f a) ∂μ) - ENNReal.toReal (∫⁻ a, .ofReal (-f a) ∂μ) 
goal: ∫ (a : α), f a ∂μ = (∫⁻ (a : α), ENNReal.ofReal (f a) ∂μ).toReal - (∫⁻ (a : α), ENNReal.ofReal (-f a) ∂μ).toReal

full_name: MeasureTheory.integral_eq_lintegral_of_nonneg_ae
code: theorem integral_eq_lintegral_of_nonneg_ae {f : α → ℝ} (hf : 0 ≤ᵐ[μ] f)
    (hfm : AEStronglyMeasurable f μ) :
    ∫ a, f a ∂μ = ENNReal.toReal (∫⁻ a, ENNReal.ofReal (f a) ∂μ) 
goal: ∫ (a : α), f a ∂μ = (∫⁻ (a : α), ENNReal.ofReal (f a) ∂μ).toReal

full_name: MeasureTheory.integral_norm_eq_lintegral_nnnorm
code: theorem integral_norm_eq_lintegral_nnnorm {P : Type*} [NormedAddCommGroup P] {f : α → P}
    (hf : AEStronglyMeasurable f μ) : ∫ x, ‖f x‖ ∂μ = ENNReal.toReal (∫⁻ x, ‖f x‖₊ ∂μ) 
goal: ∫ (x : α), ‖f x‖ ∂μ = (∫⁻ (x : α), ↑‖f x‖₊ ∂μ).toReal

full_name: MeasureTheory.ofReal_integral_norm_eq_lintegral_nnnorm
code: theorem ofReal_integral_norm_eq_lintegral_nnnorm {P : Type*} [NormedAddCommGroup P] {f : α → P}
    (hf : Integrable f μ) : ENNReal.ofReal (∫ x, ‖f x‖ ∂μ) = ∫⁻ x, ‖f x‖₊ ∂μ 
goal: ENNReal.ofReal (∫ (x : α), ‖f x‖ ∂μ) = ∫⁻ (x : α), ↑‖f x‖₊ ∂μ

full_name: MeasureTheory.integral_eq_integral_pos_part_sub_integral_neg_part
code: theorem integral_eq_integral_pos_part_sub_integral_neg_part {f : α → ℝ} (hf : Integrable f μ) :
    ∫ a, f a ∂μ = ∫ a, (Real.toNNReal (f a) : ℝ) ∂μ - ∫ a, (Real.toNNReal (-f a) : ℝ) ∂μ 
goal: ∫ (a : α), f a ∂μ = ∫ (a : α), ↑(f a).toNNReal ∂μ - ∫ (a : α), ↑(-f a).toNNReal ∂μ

full_name: MeasureTheory.integral_nonneg_of_ae
code: theorem integral_nonneg_of_ae {f : α → ℝ} (hf : 0 ≤ᵐ[μ] f) : 0 ≤ ∫ a, f a ∂μ 
goal: 0 ≤ ∫ (a : α), f a ∂μ

full_name: MeasureTheory.lintegral_coe_eq_integral
code: theorem lintegral_coe_eq_integral (f : α → ℝ≥0) (hfi : Integrable (fun x => (f x : ℝ)) μ) :
    ∫⁻ a, f a ∂μ = ENNReal.ofReal (∫ a, f a ∂μ) 
goal: ∫⁻ (a : α), ↑(f a) ∂μ = ENNReal.ofReal (∫ (a : α), ↑(f a) ∂μ)

full_name: MeasureTheory.ofReal_integral_eq_lintegral_ofReal
code: theorem ofReal_integral_eq_lintegral_ofReal {f : α → ℝ} (hfi : Integrable f μ) (f_nn : 0 ≤ᵐ[μ] f) :
    ENNReal.ofReal (∫ x, f x ∂μ) = ∫⁻ x, ENNReal.ofReal (f x) ∂μ 
goal: ENNReal.ofReal (∫ (x : α), f x ∂μ) = ∫⁻ (x : α), ENNReal.ofReal (f x) ∂μ

full_name: MeasureTheory.integral_toReal
code: theorem integral_toReal {f : α → ℝ≥0∞} (hfm : AEMeasurable f μ) (hf : ∀ᵐ x ∂μ, f x < ∞) :
    ∫ a, (f a).toReal ∂μ = (∫⁻ a, f a ∂μ).toReal 
goal: ∫ (a : α), (f a).toReal ∂μ = (∫⁻ (a : α), f a ∂μ).toReal

full_name: MeasureTheory.lintegral_coe_le_coe_iff_integral_le
code: theorem lintegral_coe_le_coe_iff_integral_le {f : α → ℝ≥0} (hfi : Integrable (fun x => (f x : ℝ)) μ)
    {b : ℝ≥0} : ∫⁻ a, f a ∂μ ≤ b ↔ ∫ a, (f a : ℝ) ∂μ ≤ b 
goal: ∫⁻ (a : α), ↑(f a) ∂μ ≤ ↑b ↔ ∫ (a : α), ↑(f a) ∂μ ≤ ↑b

full_name: MeasureTheory.integral_coe_le_of_lintegral_coe_le
code: theorem integral_coe_le_of_lintegral_coe_le {f : α → ℝ≥0} {b : ℝ≥0} (h : ∫⁻ a, f a ∂μ ≤ b) :
    ∫ a, (f a : ℝ) ∂μ ≤ b 
goal: ∫ (a : α), ↑(f a) ∂μ ≤ ↑b

full_name: MeasureTheory.integral_nonneg
code: theorem integral_nonneg {f : α → ℝ} (hf : 0 ≤ f) : 0 ≤ ∫ a, f a ∂μ 
goal: 0 ≤ ∫ (a : α), f a ∂μ

full_name: MeasureTheory.integral_nonpos_of_ae
code: theorem integral_nonpos_of_ae {f : α → ℝ} (hf : f ≤ᵐ[μ] 0) : ∫ a, f a ∂μ ≤ 0 
goal: ∫ (a : α), f a ∂μ ≤ 0

full_name: MeasureTheory.integral_nonpos
code: theorem integral_nonpos {f : α → ℝ} (hf : f ≤ 0) : ∫ a, f a ∂μ ≤ 0 
goal: ∫ (a : α), f a ∂μ ≤ 0

full_name: MeasureTheory.integral_eq_zero_iff_of_nonneg_ae
code: theorem integral_eq_zero_iff_of_nonneg_ae {f : α → ℝ} (hf : 0 ≤ᵐ[μ] f) (hfi : Integrable f μ) :
    ∫ x, f x ∂μ = 0 ↔ f =ᵐ[μ] 0 
goal: ∫ (x : α), f x ∂μ = 0 ↔ f =ᵐ[μ] 0

full_name: MeasureTheory.integral_eq_zero_iff_of_nonneg
code: theorem integral_eq_zero_iff_of_nonneg {f : α → ℝ} (hf : 0 ≤ f) (hfi : Integrable f μ) :
    ∫ x, f x ∂μ = 0 ↔ f =ᵐ[μ] 0 
goal: ∫ (x : α), f x ∂μ = 0 ↔ f =ᵐ[μ] 0

full_name: MeasureTheory.integral_eq_iff_of_ae_le
code: lemma integral_eq_iff_of_ae_le {f g : α → ℝ}
    (hf : Integrable f μ) (hg : Integrable g μ) (hfg : f ≤ᵐ[μ] g) :
    ∫ a, f a ∂μ = ∫ a, g a ∂μ ↔ f =ᵐ[μ] g 
goal: ∫ (a : α), f a ∂μ = ∫ (a : α), g a ∂μ ↔ f =ᵐ[μ] g

full_name: MeasureTheory.integral_pos_iff_support_of_nonneg_ae
code: theorem integral_pos_iff_support_of_nonneg_ae {f : α → ℝ} (hf : 0 ≤ᵐ[μ] f) (hfi : Integrable f μ) :
    (0 < ∫ x, f x ∂μ) ↔ 0 < μ (Function.support f) 
goal: 0 < ∫ (x : α), f x ∂μ ↔ 0 < μ (Function.support f)

full_name: MeasureTheory.integral_pos_iff_support_of_nonneg
code: theorem integral_pos_iff_support_of_nonneg {f : α → ℝ} (hf : 0 ≤ f) (hfi : Integrable f μ) :
    (0 < ∫ x, f x ∂μ) ↔ 0 < μ (Function.support f) 
goal: 0 < ∫ (x : α), f x ∂μ ↔ 0 < μ (Function.support f)

full_name: MeasureTheory.integral_exp_pos
code: lemma integral_exp_pos {μ : Measure α} {f : α → ℝ} [hμ : NeZero μ]
    (hf : Integrable (fun x ↦ Real.exp (f x)) μ) :
    0 < ∫ x, Real.exp (f x) ∂μ 
goal: 0 < ∫ (x : α), Real.exp (f x) ∂μ

full_name: MeasureTheory.integral_tendsto_of_tendsto_of_monotone
code: /-- Monotone convergence theorem for real-valued functions and Bochner integrals -/
lemma integral_tendsto_of_tendsto_of_monotone {μ : Measure α} {f : ℕ → α → ℝ} {F : α → ℝ}
    (hf : ∀ n, Integrable (f n) μ) (hF : Integrable F μ) (h_mono : ∀ᵐ x ∂μ, Monotone fun n ↦ f n x)
    (h_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n ↦ f n x) atTop (𝓝 (F x))) :
    Tendsto (fun n ↦ ∫ x, f n x ∂μ) atTop (𝓝 (∫ x, F x ∂μ)) 
goal: Filter.Tendsto (fun n => ∫ (x : α), f n x ∂μ) Filter.atTop (𝓝 (∫ (x : α), F x ∂μ))

full_name: MeasureTheory.integral_tendsto_of_tendsto_of_antitone
code: /-- Monotone convergence theorem for real-valued functions and Bochner integrals -/
lemma integral_tendsto_of_tendsto_of_antitone {μ : Measure α} {f : ℕ → α → ℝ} {F : α → ℝ}
    (hf : ∀ n, Integrable (f n) μ) (hF : Integrable F μ) (h_mono : ∀ᵐ x ∂μ, Antitone fun n ↦ f n x)
    (h_tendsto : ∀ᵐ x ∂μ, Tendsto (fun n ↦ f n x) atTop (𝓝 (F x))) :
    Tendsto (fun n ↦ ∫ x, f n x ∂μ) atTop (𝓝 (∫ x, F x ∂μ)) 
goal: Filter.Tendsto (fun n => ∫ (x : α), f n x ∂μ) Filter.atTop (𝓝 (∫ (x : α), F x ∂μ))

full_name: MeasureTheory.tendsto_of_integral_tendsto_of_monotone
code: /-- If a monotone sequence of functions has an upper bound and the sequence of integrals of these
functions tends to the integral of the upper bound, then the sequence of functions converges
almost everywhere to the upper bound. -/
lemma tendsto_of_integral_tendsto_of_monotone {μ : Measure α} {f : ℕ → α → ℝ} {F : α → ℝ}
    (hf_int : ∀ n, Integrable (f n) μ) (hF_int : Integrable F μ)
    (hf_tendsto : Tendsto (fun i ↦ ∫ a, f i a ∂μ) atTop (𝓝 (∫ a, F a ∂μ)))
    (hf_mono : ∀ᵐ a ∂μ, Monotone (fun i ↦ f i a))
    (hf_bound : ∀ᵐ a ∂μ, ∀ i, f i a ≤ F a) :
    ∀ᵐ a ∂μ, Tendsto (fun i ↦ f i a) atTop (𝓝 (F a)) 
goal: ∀ᵐ (a : α) ∂μ, Filter.Tendsto (fun i => f i a) Filter.atTop (𝓝 (F a))

full_name: MeasureTheory.tendsto_of_integral_tendsto_of_antitone
code: /-- If an antitone sequence of functions has a lower bound and the sequence of integrals of these
functions tends to the integral of the lower bound, then the sequence of functions converges
almost everywhere to the lower bound. -/
lemma tendsto_of_integral_tendsto_of_antitone {μ : Measure α} {f : ℕ → α → ℝ} {F : α → ℝ}
    (hf_int : ∀ n, Integrable (f n) μ) (hF_int : Integrable F μ)
    (hf_tendsto : Tendsto (fun i ↦ ∫ a, f i a ∂μ) atTop (𝓝 (∫ a, F a ∂μ)))
    (hf_mono : ∀ᵐ a ∂μ, Antitone (fun i ↦ f i a))
    (hf_bound : ∀ᵐ a ∂μ, ∀ i, F a ≤ f i a) :
    ∀ᵐ a ∂μ, Tendsto (fun i ↦ f i a) atTop (𝓝 (F a)) 
goal: ∀ᵐ (a : α) ∂μ, Filter.Tendsto (fun i => f i a) Filter.atTop (𝓝 (F a))

full_name: MeasureTheory.L1.norm_eq_integral_norm
code: theorem L1.norm_eq_integral_norm (f : α →₁[μ] H) : ‖f‖ = ∫ a, ‖f a‖ ∂μ 
goal: ‖f‖ = ∫ (a : α), ‖↑↑f a‖ ∂μ

full_name: MeasureTheory.L1.dist_eq_integral_dist
code: theorem L1.dist_eq_integral_dist (f g : α →₁[μ] H) : dist f g = ∫ a, dist (f a) (g a) ∂μ 
goal: dist f g = ∫ (a : α), dist (↑↑f a) (↑↑g a) ∂μ

full_name: MeasureTheory.L1.norm_of_fun_eq_integral_norm
code: theorem L1.norm_of_fun_eq_integral_norm {f : α → H} (hf : Integrable f μ) :
    ‖hf.toL1 f‖ = ∫ a, ‖f a‖ ∂μ 
goal: ‖MeasureTheory.Integrable.toL1 f hf‖ = ∫ (a : α), ‖f a‖ ∂μ

full_name: MeasureTheory.Memℒp.eLpNorm_eq_integral_rpow_norm
code: theorem Memℒp.eLpNorm_eq_integral_rpow_norm {f : α → H} {p : ℝ≥0∞} (hp1 : p ≠ 0) (hp2 : p ≠ ∞)
    (hf : Memℒp f p μ) :
    eLpNorm f p μ = ENNReal.ofReal ((∫ a, ‖f a‖ ^ p.toReal ∂μ) ^ p.toReal⁻¹) 
goal: MeasureTheory.eLpNorm f p μ = ENNReal.ofReal ((∫ (a : α), ‖f a‖ ^ p.toReal ∂μ) ^ p.toReal⁻¹)

full_name: MeasureTheory.integral_mono_ae
code: theorem integral_mono_ae {f g : α → ℝ} (hf : Integrable f μ) (hg : Integrable g μ) (h : f ≤ᵐ[μ] g) :
    ∫ a, f a ∂μ ≤ ∫ a, g a ∂μ 
goal: ∫ (a : α), f a ∂μ ≤ ∫ (a : α), g a ∂μ

full_name: MeasureTheory.integral_mono
code: @[mono]
theorem integral_mono {f g : α → ℝ} (hf : Integrable f μ) (hg : Integrable g μ) (h : f ≤ g) :
    ∫ a, f a ∂μ ≤ ∫ a, g a ∂μ 
goal: ∫ (a : α), f a ∂μ ≤ ∫ (a : α), g a ∂μ

full_name: MeasureTheory.integral_mono_of_nonneg
code: theorem integral_mono_of_nonneg {f g : α → ℝ} (hf : 0 ≤ᵐ[μ] f) (hgi : Integrable g μ)
    (h : f ≤ᵐ[μ] g) : ∫ a, f a ∂μ ≤ ∫ a, g a ∂μ 
goal: ∫ (a : α), f a ∂μ ≤ ∫ (a : α), g a ∂μ

full_name: MeasureTheory.integral_mono_measure
code: theorem integral_mono_measure {f : α → ℝ} {ν} (hle : μ ≤ ν) (hf : 0 ≤ᵐ[ν] f)
    (hfi : Integrable f ν) : ∫ a, f a ∂μ ≤ ∫ a, f a ∂ν 
goal: ∫ (a : α), f a ∂μ ≤ ∫ (a : α), f a ∂ν

full_name: MeasureTheory.norm_integral_le_integral_norm
code: theorem norm_integral_le_integral_norm (f : α → G) : ‖∫ a, f a ∂μ‖ ≤ ∫ a, ‖f a‖ ∂μ 
goal: ‖∫ (a : α), f a ∂μ‖ ≤ ∫ (a : α), ‖f a‖ ∂μ

full_name: MeasureTheory.norm_integral_le_of_norm_le
code: theorem norm_integral_le_of_norm_le {f : α → G} {g : α → ℝ} (hg : Integrable g μ)
    (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ g x) : ‖∫ x, f x ∂μ‖ ≤ ∫ x, g x ∂μ 
goal: ‖∫ (x : α), f x ∂μ‖ ≤ ∫ (x : α), g x ∂μ

full_name: MeasureTheory.SimpleFunc.integral_eq_integral
code: theorem SimpleFunc.integral_eq_integral (f : α →ₛ E) (hfi : Integrable f μ) :
    f.integral μ = ∫ x, f x ∂μ 
goal: MeasureTheory.SimpleFunc.integral μ f = ∫ (x : α), ↑f x ∂μ

full_name: MeasureTheory.SimpleFunc.integral_eq_sum
code: theorem SimpleFunc.integral_eq_sum (f : α →ₛ E) (hfi : Integrable f μ) :
    ∫ x, f x ∂μ = ∑ x ∈ f.range, ENNReal.toReal (μ (f ⁻¹' {x})) • x 
goal: ∫ (x : α), ↑f x ∂μ = ∑ x ∈ f.range, (μ (↑f ⁻¹' {x})).toReal • x

full_name: MeasureTheory.integral_const
code: @[simp]
theorem integral_const (c : E) : ∫ _ : α, c ∂μ = (μ univ).toReal • c 
goal: ∫ (x : α), c ∂μ = (μ Set.univ).toReal • c

full_name: MeasureTheory.norm_integral_le_of_norm_le_const
code: theorem norm_integral_le_of_norm_le_const [IsFiniteMeasure μ] {f : α → G} {C : ℝ}
    (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) : ‖∫ x, f x ∂μ‖ ≤ C * (μ univ).toReal 
goal: ‖∫ (x : α), f x ∂μ‖ ≤ C * (μ Set.univ).toReal

full_name: MeasureTheory.tendsto_integral_approxOn_of_measurable
code: theorem tendsto_integral_approxOn_of_measurable [MeasurableSpace E] [BorelSpace E] {f : α → E}
    {s : Set E} [SeparableSpace s] (hfi : Integrable f μ) (hfm : Measurable f)
    (hs : ∀ᵐ x ∂μ, f x ∈ closure s) {y₀ : E} (h₀ : y₀ ∈ s) (h₀i : Integrable (fun _ => y₀) μ) :
    Tendsto (fun n => (SimpleFunc.approxOn f hfm s y₀ h₀ n).integral μ)
      atTop (𝓝 <| ∫ x, f x ∂μ) 
goal: Filter.Tendsto (fun n => MeasureTheory.SimpleFunc.integral μ (MeasureTheory.SimpleFunc.approxOn f hfm s y₀ h₀ n))
  Filter.atTop (𝓝 (∫ (x : α), f x ∂μ))

full_name: MeasureTheory.tendsto_integral_approxOn_of_measurable_of_range_subset
code: theorem tendsto_integral_approxOn_of_measurable_of_range_subset [MeasurableSpace E] [BorelSpace E]
    {f : α → E} (fmeas : Measurable f) (hf : Integrable f μ) (s : Set E) [SeparableSpace s]
    (hs : range f ∪ {0} ⊆ s) :
    Tendsto (fun n => (SimpleFunc.approxOn f fmeas s 0 (hs <| by simp) n).integral μ) atTop
      (𝓝 <| ∫ x, f x ∂μ) 
goal: Filter.Tendsto (fun n => MeasureTheory.SimpleFunc.integral μ (MeasureTheory.SimpleFunc.approxOn f fmeas s 0 ⋯ n))
  Filter.atTop (𝓝 (∫ (x : α), f x ∂μ))

full_name: MeasureTheory.tendsto_integral_norm_approxOn_sub
code: theorem tendsto_integral_norm_approxOn_sub [MeasurableSpace E] [BorelSpace E] {f : α → E}
    (fmeas : Measurable f) (hf : Integrable f μ) [SeparableSpace (range f ∪ {0} : Set E)] :
    Tendsto (fun n ↦ ∫ x, ‖SimpleFunc.approxOn f fmeas (range f ∪ {0}) 0 (by simp) n x - f x‖ ∂μ)
      atTop (𝓝 0) 
goal: Filter.Tendsto (fun n => ∫ (x : α), ‖↑(MeasureTheory.SimpleFunc.approxOn f fmeas (Set.range f ∪ {0}) 0 ⋯ n) x - f x‖ ∂μ)
  Filter.atTop (𝓝 0)

full_name: MeasureTheory.integral_add_measure
code: theorem integral_add_measure {f : α → G} (hμ : Integrable f μ) (hν : Integrable f ν) :
    ∫ x, f x ∂(μ + ν) = ∫ x, f x ∂μ + ∫ x, f x ∂ν 
goal: ∫ (x : α), f x ∂(μ + ν) = ∫ (x : α), f x ∂μ + ∫ (x : α), f x ∂ν

full_name: MeasureTheory.integral_zero_measure
code: @[simp]
theorem integral_zero_measure {m : MeasurableSpace α} (f : α → G) :
    (∫ x, f x ∂(0 : Measure α)) = 0 
goal: ∫ (x : α), f x ∂0 = 0

full_name: MeasureTheory.integral_finset_sum_measure
code: theorem integral_finset_sum_measure {ι} {m : MeasurableSpace α} {f : α → G} {μ : ι → Measure α}
    {s : Finset ι} (hf : ∀ i ∈ s, Integrable f (μ i)) :
    ∫ a, f a ∂(∑ i ∈ s, μ i) = ∑ i ∈ s, ∫ a, f a ∂μ i 
goal: ∫ (a : α), f a ∂∑ i ∈ s, μ i = ∑ i ∈ s, ∫ (a : α), f a ∂μ i

full_name: MeasureTheory.nndist_integral_add_measure_le_lintegral
code: theorem nndist_integral_add_measure_le_lintegral
    {f : α → G} (h₁ : Integrable f μ) (h₂ : Integrable f ν) :
    (nndist (∫ x, f x ∂μ) (∫ x, f x ∂(μ + ν)) : ℝ≥0∞) ≤ ∫⁻ x, ‖f x‖₊ ∂ν 
goal: ↑(nndist (∫ (x : α), f x ∂μ) (∫ (x : α), f x ∂(μ + ν))) ≤ ∫⁻ (x : α), ↑‖f x‖₊ ∂ν

full_name: MeasureTheory.hasSum_integral_measure
code: theorem hasSum_integral_measure {ι} {m : MeasurableSpace α} {f : α → G} {μ : ι → Measure α}
    (hf : Integrable f (Measure.sum μ)) :
    HasSum (fun i => ∫ a, f a ∂μ i) (∫ a, f a ∂Measure.sum μ) 
goal: HasSum (fun i => ∫ (a : α), f a ∂μ i) (∫ (a : α), f a ∂MeasureTheory.Measure.sum μ)

full_name: MeasureTheory.integral_sum_measure
code: theorem integral_sum_measure {ι} {_ : MeasurableSpace α} {f : α → G} {μ : ι → Measure α}
    (hf : Integrable f (Measure.sum μ)) : ∫ a, f a ∂Measure.sum μ = ∑' i, ∫ a, f a ∂μ i 
goal: ∀ {x : MeasurableSpace α} {f : α → G} {μ : ι → MeasureTheory.Measure α},
  MeasureTheory.Integrable f (MeasureTheory.Measure.sum μ) →
    ∫ (a : α), f a ∂MeasureTheory.Measure.sum μ = ∑' (i : ι), ∫ (a : α), f a ∂μ i

full_name: MeasureTheory.integral_smul_measure
code: @[simp]
theorem integral_smul_measure (f : α → G) (c : ℝ≥0∞) :
    ∫ x, f x ∂c • μ = c.toReal • ∫ x, f x ∂μ 
goal: ∫ (x : α), f x ∂c • μ = c.toReal • ∫ (x : α), f x ∂μ

full_name: MeasureTheory.integral_smul_nnreal_measure
code: @[simp]
theorem integral_smul_nnreal_measure (f : α → G) (c : ℝ≥0) :
    ∫ x, f x ∂(c • μ) = c • ∫ x, f x ∂μ 
goal: ∫ (x : α), f x ∂c • μ = c • ∫ (x : α), f x ∂μ

full_name: MeasureTheory.integral_map_of_stronglyMeasurable
code: theorem integral_map_of_stronglyMeasurable {β} [MeasurableSpace β] {φ : α → β} (hφ : Measurable φ)
    {f : β → G} (hfm : StronglyMeasurable f) : ∫ y, f y ∂Measure.map φ μ = ∫ x, f (φ x) ∂μ 
goal: ∫ (y : β), f y ∂MeasureTheory.Measure.map φ μ = ∫ (x : α), f (φ x) ∂μ

full_name: MeasureTheory.integral_map
code: theorem integral_map {β} [MeasurableSpace β] {φ : α → β} (hφ : AEMeasurable φ μ) {f : β → G}
    (hfm : AEStronglyMeasurable f (Measure.map φ μ)) :
    ∫ y, f y ∂Measure.map φ μ = ∫ x, f (φ x) ∂μ 
goal: ∫ (y : β), f y ∂MeasureTheory.Measure.map φ μ = ∫ (x : α), f (φ x) ∂μ

full_name: MeasurableEmbedding.integral_map
code: theorem _root_.MeasurableEmbedding.integral_map {β} {_ : MeasurableSpace β} {f : α → β}
    (hf : MeasurableEmbedding f) (g : β → G) : ∫ y, g y ∂Measure.map f μ = ∫ x, g (f x) ∂μ 
goal: ∀ {x : MeasurableSpace β} {f : α → β},
  MeasurableEmbedding f → ∀ (g : β → G), ∫ (y : β), g y ∂MeasureTheory.Measure.map f μ = ∫ (x : α), g (f x) ∂μ

full_name: ClosedEmbedding.integral_map
code: theorem _root_.ClosedEmbedding.integral_map {β} [TopologicalSpace α] [BorelSpace α]
    [TopologicalSpace β] [MeasurableSpace β] [BorelSpace β] {φ : α → β} (hφ : ClosedEmbedding φ)
    (f : β → G) : ∫ y, f y ∂Measure.map φ μ = ∫ x, f (φ x) ∂μ 
goal: ∫ (y : β), f y ∂MeasureTheory.Measure.map φ μ = ∫ (x : α), f (φ x) ∂μ

full_name: MeasureTheory.integral_map_equiv
code: theorem integral_map_equiv {β} [MeasurableSpace β] (e : α ≃ᵐ β) (f : β → G) :
    ∫ y, f y ∂Measure.map e μ = ∫ x, f (e x) ∂μ 
goal: ∫ (y : β), f y ∂MeasureTheory.Measure.map (⇑e) μ = ∫ (x : α), f (e x) ∂μ

full_name: MeasureTheory.MeasurePreserving.integral_comp
code: theorem MeasurePreserving.integral_comp {β} {_ : MeasurableSpace β} {f : α → β} {ν}
    (h₁ : MeasurePreserving f μ ν) (h₂ : MeasurableEmbedding f) (g : β → G) :
    ∫ x, g (f x) ∂μ = ∫ y, g y ∂ν 
goal: ∀ {x : MeasurableSpace β} {f : α → β} {ν : MeasureTheory.Measure β},
  MeasureTheory.MeasurePreserving f μ ν →
    MeasurableEmbedding f → ∀ (g : β → G), ∫ (x : α), g (f x) ∂μ = ∫ (y : β), g y ∂ν

full_name: MeasureTheory.MeasurePreserving.integral_comp'
code: theorem MeasurePreserving.integral_comp' {β} [MeasurableSpace β] {ν} {f : α ≃ᵐ β}
    (h : MeasurePreserving f μ ν) (g : β → G) :
    ∫ x, g (f x) ∂μ = ∫ y, g y ∂ν 
goal: ∫ (x : α), g (f x) ∂μ = ∫ (y : β), g y ∂ν

full_name: MeasureTheory.integral_subtype_comap
code: theorem integral_subtype_comap {α} [MeasurableSpace α] {μ : Measure α} {s : Set α}
    (hs : MeasurableSet s) (f : α → G) :
    ∫ x : s, f (x : α) ∂(Measure.comap Subtype.val μ) = ∫ x in s, f x ∂μ 
goal: ∫ (x : ↑s), f ↑x ∂MeasureTheory.Measure.comap Subtype.val μ = ∫ (x : α) in s, f x ∂μ

full_name: MeasureTheory.integral_subtype
code: theorem integral_subtype {α} [MeasureSpace α] {s : Set α} (hs : MeasurableSet s) (f : α → G) :
    ∫ x : s, f x = ∫ x in s, f x 
goal: ∫ (x : ↑s), f ↑x = ∫ (x : α) in s, f x

full_name: MeasureTheory.integral_dirac'
code: @[simp]
theorem integral_dirac' [MeasurableSpace α] (f : α → E) (a : α) (hfm : StronglyMeasurable f) :
    ∫ x, f x ∂Measure.dirac a = f a 
goal: ∫ (x : α), f x ∂MeasureTheory.Measure.dirac a = f a

full_name: MeasureTheory.integral_dirac
code: @[simp]
theorem integral_dirac [MeasurableSpace α] [MeasurableSingletonClass α] (f : α → E) (a : α) :
    ∫ x, f x ∂Measure.dirac a = f a 
goal: ∫ (x : α), f x ∂MeasureTheory.Measure.dirac a = f a

full_name: MeasureTheory.setIntegral_dirac'
code: theorem setIntegral_dirac' {mα : MeasurableSpace α} {f : α → E} (hf : StronglyMeasurable f) (a : α)
    {s : Set α} (hs : MeasurableSet s) [Decidable (a ∈ s)] :
    ∫ x in s, f x ∂Measure.dirac a = if a ∈ s then f a else 0 
goal: ∫ (x : α) in s, f x ∂MeasureTheory.Measure.dirac a = if a ∈ s then f a else 0

full_name: MeasureTheory.setIntegral_dirac
code: theorem setIntegral_dirac [MeasurableSpace α] [MeasurableSingletonClass α] (f : α → E) (a : α)
    (s : Set α) [Decidable (a ∈ s)] :
    ∫ x in s, f x ∂Measure.dirac a = if a ∈ s then f a else 0 
goal: ∫ (x : α) in s, f x ∂MeasureTheory.Measure.dirac a = if a ∈ s then f a else 0

full_name: MeasureTheory.mul_meas_ge_le_integral_of_nonneg
code: /-- **Markov's inequality** also known as **Chebyshev's first inequality**. -/
theorem mul_meas_ge_le_integral_of_nonneg {f : α → ℝ} (hf_nonneg : 0 ≤ᵐ[μ] f)
    (hf_int : Integrable f μ) (ε : ℝ) : ε * (μ { x | ε ≤ f x }).toReal ≤ ∫ x, f x ∂μ 
goal: ε * (μ {x | ε ≤ f x}).toReal ≤ ∫ (x : α), f x ∂μ

full_name: MeasureTheory.integral_mul_norm_le_Lp_mul_Lq
code: /-- Hölder's inequality for the integral of a product of norms. The integral of the product of two
norms of functions is bounded by the product of their `ℒp` and `ℒq` seminorms when `p` and `q` are
conjugate exponents. -/
theorem integral_mul_norm_le_Lp_mul_Lq {E} [NormedAddCommGroup E] {f g : α → E} {p q : ℝ}
    (hpq : p.IsConjExponent q) (hf : Memℒp f (ENNReal.ofReal p) μ)
    (hg : Memℒp g (ENNReal.ofReal q) μ) :
    ∫ a, ‖f a‖ * ‖g a‖ ∂μ ≤ (∫ a, ‖f a‖ ^ p ∂μ) ^ (1 / p) * (∫ a, ‖g a‖ ^ q ∂μ) ^ (1 / q) 
goal: ∫ (a : α), ‖f a‖ * ‖g a‖ ∂μ ≤ (∫ (a : α), ‖f a‖ ^ p ∂μ) ^ (1 / p) * (∫ (a : α), ‖g a‖ ^ q ∂μ) ^ (1 / q)

full_name: MeasureTheory.integral_mul_le_Lp_mul_Lq_of_nonneg
code: /-- Hölder's inequality for functions `α → ℝ`. The integral of the product of two nonnegative
functions is bounded by the product of their `ℒp` and `ℒq` seminorms when `p` and `q` are conjugate
exponents. -/
theorem integral_mul_le_Lp_mul_Lq_of_nonneg {p q : ℝ} (hpq : p.IsConjExponent q) {f g : α → ℝ}
    (hf_nonneg : 0 ≤ᵐ[μ] f) (hg_nonneg : 0 ≤ᵐ[μ] g) (hf : Memℒp f (ENNReal.ofReal p) μ)
    (hg : Memℒp g (ENNReal.ofReal q) μ) :
    ∫ a, f a * g a ∂μ ≤ (∫ a, f a ^ p ∂μ) ^ (1 / p) * (∫ a, g a ^ q ∂μ) ^ (1 / q) 
goal: ∫ (a : α), f a * g a ∂μ ≤ (∫ (a : α), f a ^ p ∂μ) ^ (1 / p) * (∫ (a : α), g a ^ q ∂μ) ^ (1 / q)

full_name: MeasureTheory.integral_countable'
code: theorem integral_countable' [Countable α] [MeasurableSingletonClass α] {μ : Measure α}
    {f : α → E} (hf : Integrable f μ) :
    ∫ a, f a ∂μ = ∑' a, (μ {a}).toReal • f a 
goal: ∫ (a : α), f a ∂μ = ∑' (a : α), (μ {a}).toReal • f a

full_name: MeasureTheory.integral_singleton'
code: theorem integral_singleton' {μ : Measure α} {f : α → E} (hf : StronglyMeasurable f) (a : α) :
    ∫ a in {a}, f a ∂μ = (μ {a}).toReal • f a 
goal: ∫ (a : α) in {a}, f a ∂μ = (μ {a}).toReal • f a

full_name: MeasureTheory.integral_singleton
code: theorem integral_singleton [MeasurableSingletonClass α] {μ : Measure α} (f : α → E) (a : α) :
    ∫ a in {a}, f a ∂μ = (μ {a}).toReal • f a 
goal: ∫ (a : α) in {a}, f a ∂μ = (μ {a}).toReal • f a

full_name: MeasureTheory.integral_countable
code: theorem integral_countable [MeasurableSingletonClass α] (f : α → E) {s : Set α} (hs : s.Countable)
    (hf : Integrable f (μ.restrict s)) :
    ∫ a in s, f a ∂μ = ∑' a : s, (μ {(a : α)}).toReal • f a 
goal: ∫ (a : α) in s, f a ∂μ = ∑' (a : ↑s), (μ {↑a}).toReal • f ↑a

full_name: MeasureTheory.integral_finset
code: theorem integral_finset [MeasurableSingletonClass α] (s : Finset α) (f : α → E)
    (hf : Integrable f (μ.restrict s)) :
    ∫ x in s, f x ∂μ = ∑ x ∈ s, (μ {x}).toReal • f x 
goal: ∫ (x : α) in ↑s, f x ∂μ = ∑ x ∈ s, (μ {x}).toReal • f x

full_name: MeasureTheory.integral_fintype
code: theorem integral_fintype [MeasurableSingletonClass α] [Fintype α] (f : α → E)
    (hf : Integrable f μ) :
    ∫ x, f x ∂μ = ∑ x, (μ {x}).toReal • f x 
goal: ∫ (x : α), f x ∂μ = ∑ x : α, (μ {x}).toReal • f x

full_name: MeasureTheory.integral_unique
code: theorem integral_unique [Unique α] (f : α → E) : ∫ x, f x ∂μ = (μ univ).toReal • f default 
goal: ∫ (x : α), f x ∂μ = (μ Set.univ).toReal • f default

full_name: MeasureTheory.integral_pos_of_integrable_nonneg_nonzero
code: theorem integral_pos_of_integrable_nonneg_nonzero [TopologicalSpace α] [Measure.IsOpenPosMeasure μ]
    {f : α → ℝ} {x : α} (f_cont : Continuous f) (f_int : Integrable f μ) (f_nonneg : 0 ≤ f)
    (f_x : f x ≠ 0) : 0 < ∫ x, f x ∂μ 
goal: 0 < ∫ (x : α), f x ∂μ

full_name: MeasureTheory.SimpleFunc.toLargerSpace
code: /-- Simple function seen as simple function of a larger `MeasurableSpace`. -/
def SimpleFunc.toLargerSpace (hm : m ≤ m0) (f : @SimpleFunc β m γ) : SimpleFunc β γ 
goal: MeasureTheory.SimpleFunc β γ

full_name: MeasureTheory.SimpleFunc.coe_toLargerSpace_eq
code: theorem SimpleFunc.coe_toLargerSpace_eq (hm : m ≤ m0) (f : @SimpleFunc β m γ) :
    ⇑(f.toLargerSpace hm) = f 
goal: ↑(MeasureTheory.SimpleFunc.toLargerSpace hm f) = ↑f

full_name: MeasureTheory.integral_simpleFunc_larger_space
code: theorem integral_simpleFunc_larger_space (hm : m ≤ m0) (f : @SimpleFunc β m F)
    (hf_int : Integrable f μ) :
    ∫ x, f x ∂μ = ∑ x ∈ @SimpleFunc.range β F m f, ENNReal.toReal (μ (f ⁻¹' {x})) • x 
goal: ∫ (x : β), ↑f x ∂μ = ∑ x ∈ f.range, (μ (↑f ⁻¹' {x})).toReal • x

full_name: MeasureTheory.integral_trim_simpleFunc
code: theorem integral_trim_simpleFunc (hm : m ≤ m0) (f : @SimpleFunc β m F) (hf_int : Integrable f μ) :
    ∫ x, f x ∂μ = ∫ x, f x ∂μ.trim hm 
goal: ∫ (x : β), ↑f x ∂μ = ∫ (x : β), ↑f x ∂μ.trim hm

full_name: MeasureTheory.integral_trim
code: theorem integral_trim (hm : m ≤ m0) {f : β → G} (hf : StronglyMeasurable[m] f) :
    ∫ x, f x ∂μ = ∫ x, f x ∂μ.trim hm 
goal: ∫ (x : β), f x ∂μ = ∫ (x : β), f x ∂μ.trim hm

full_name: MeasureTheory.integral_trim_ae
code: theorem integral_trim_ae (hm : m ≤ m0) {f : β → G} (hf : AEStronglyMeasurable f (μ.trim hm)) :
    ∫ x, f x ∂μ = ∫ x, f x ∂μ.trim hm 
goal: ∫ (x : β), f x ∂μ = ∫ (x : β), f x ∂μ.trim hm

full_name: MeasureTheory.ae_eq_trim_of_stronglyMeasurable
code: theorem ae_eq_trim_of_stronglyMeasurable [TopologicalSpace γ] [MetrizableSpace γ] (hm : m ≤ m0)
    {f g : β → γ} (hf : StronglyMeasurable[m] f) (hg : StronglyMeasurable[m] g)
    (hfg : f =ᵐ[μ] g) : f =ᵐ[μ.trim hm] g 
goal: f =ᵐ[μ.trim hm] g

full_name: MeasureTheory.ae_eq_trim_iff
code: theorem ae_eq_trim_iff [TopologicalSpace γ] [MetrizableSpace γ] (hm : m ≤ m0) {f g : β → γ}
    (hf : StronglyMeasurable[m] f) (hg : StronglyMeasurable[m] g) :
    f =ᵐ[μ.trim hm] g ↔ f =ᵐ[μ] g 
goal: f =ᵐ[μ.trim hm] g ↔ f =ᵐ[μ] g

full_name: MeasureTheory.ae_le_trim_of_stronglyMeasurable
code: theorem ae_le_trim_of_stronglyMeasurable [LinearOrder γ] [TopologicalSpace γ]
    [OrderClosedTopology γ] [PseudoMetrizableSpace γ] (hm : m ≤ m0) {f g : β → γ}
    (hf : StronglyMeasurable[m] f) (hg : StronglyMeasurable[m] g) (hfg : f ≤ᵐ[μ] g) :
    f ≤ᵐ[μ.trim hm] g 
goal: f ≤ᵐ[μ.trim hm] g

full_name: MeasureTheory.ae_le_trim_iff
code: theorem ae_le_trim_iff [LinearOrder γ] [TopologicalSpace γ] [OrderClosedTopology γ]
    [PseudoMetrizableSpace γ] (hm : m ≤ m0) {f g : β → γ} (hf : StronglyMeasurable[m] f)
    (hg : StronglyMeasurable[m] g) : f ≤ᵐ[μ.trim hm] g ↔ f ≤ᵐ[μ] g 
goal: f ≤ᵐ[μ.trim hm] g ↔ f ≤ᵐ[μ] g

full_name: MeasureTheory.eLpNorm_one_le_of_le
code: theorem eLpNorm_one_le_of_le {r : ℝ≥0} (hfint : Integrable f μ) (hfint' : 0 ≤ ∫ x, f x ∂μ)
    (hf : ∀ᵐ ω ∂μ, f ω ≤ r) : eLpNorm f 1 μ ≤ 2 * μ Set.univ * r 
goal: MeasureTheory.eLpNorm f 1 μ ≤ 2 * μ Set.univ * ↑r

full_name: MeasureTheory.eLpNorm_one_le_of_le'
code: theorem eLpNorm_one_le_of_le' {r : ℝ} (hfint : Integrable f μ) (hfint' : 0 ≤ ∫ x, f x ∂μ)
    (hf : ∀ᵐ ω ∂μ, f ω ≤ r) : eLpNorm f 1 μ ≤ 2 * μ Set.univ * ENNReal.ofReal r 
goal: MeasureTheory.eLpNorm f 1 μ ≤ 2 * μ Set.univ * ENNReal.ofReal r

full_name: Mathlib.Meta.Positivity.evalIntegral
code: /-- Positivity extension for integrals.

This extension only proves non-negativity, strict positivity is more delicate for integration and
requires more assumptions. -/
@[positivity MeasureTheory.integral _ _]
def evalIntegral : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt