File: Mathlib/MeasureTheory/Integral/SetToL1.lean

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

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

full_name: MeasureTheory.FinMeasAdditive
code: /-- A set function is `FinMeasAdditive` if its value on the union of two disjoint measurable
sets with finite measure is the sum of its values on each set. -/
def FinMeasAdditive {β} [AddMonoid β] {_ : MeasurableSpace α} (μ : Measure α) (T : Set α → β) :
    Prop 
goal: {x : MeasurableSpace α} → MeasureTheory.Measure α → (Set α → β) → Prop

full_name: MeasureTheory.FinMeasAdditive.zero
code: theorem zero : FinMeasAdditive μ (0 : Set α → β) 
goal: MeasureTheory.FinMeasAdditive μ 0

full_name: MeasureTheory.FinMeasAdditive.add
code: theorem add (hT : FinMeasAdditive μ T) (hT' : FinMeasAdditive μ T') :
    FinMeasAdditive μ (T + T') 
goal: MeasureTheory.FinMeasAdditive μ (T + T')

full_name: MeasureTheory.FinMeasAdditive.smul
code: theorem smul [Monoid 𝕜] [DistribMulAction 𝕜 β] (hT : FinMeasAdditive μ T) (c : 𝕜) :
    FinMeasAdditive μ fun s => c • T s 
goal: MeasureTheory.FinMeasAdditive μ fun s => c • T s

full_name: MeasureTheory.FinMeasAdditive.of_eq_top_imp_eq_top
code: theorem of_eq_top_imp_eq_top {μ' : Measure α} (h : ∀ s, MeasurableSet s → μ s = ∞ → μ' s = ∞)
    (hT : FinMeasAdditive μ T) : FinMeasAdditive μ' T 
goal: MeasureTheory.FinMeasAdditive μ' T

full_name: MeasureTheory.FinMeasAdditive.of_smul_measure
code: theorem of_smul_measure (c : ℝ≥0∞) (hc_ne_top : c ≠ ∞) (hT : FinMeasAdditive (c • μ) T) :
    FinMeasAdditive μ T 
goal: MeasureTheory.FinMeasAdditive μ T

full_name: MeasureTheory.FinMeasAdditive.smul_measure
code: theorem smul_measure (c : ℝ≥0∞) (hc_ne_zero : c ≠ 0) (hT : FinMeasAdditive μ T) :
    FinMeasAdditive (c • μ) T 
goal: MeasureTheory.FinMeasAdditive (c • μ) T

full_name: MeasureTheory.FinMeasAdditive.smul_measure_iff
code: theorem smul_measure_iff (c : ℝ≥0∞) (hc_ne_zero : c ≠ 0) (hc_ne_top : c ≠ ∞) :
    FinMeasAdditive (c • μ) T ↔ FinMeasAdditive μ T 
goal: MeasureTheory.FinMeasAdditive (c • μ) T ↔ MeasureTheory.FinMeasAdditive μ T

full_name: MeasureTheory.FinMeasAdditive.map_empty_eq_zero
code: theorem map_empty_eq_zero {β} [AddCancelMonoid β] {T : Set α → β} (hT : FinMeasAdditive μ T) :
    T ∅ = 0 
goal: T ∅ = 0

full_name: MeasureTheory.FinMeasAdditive.map_iUnion_fin_meas_set_eq_sum
code: theorem map_iUnion_fin_meas_set_eq_sum (T : Set α → β) (T_empty : T ∅ = 0)
    (h_add : FinMeasAdditive μ T) {ι} (S : ι → Set α) (sι : Finset ι)
    (hS_meas : ∀ i, MeasurableSet (S i)) (hSp : ∀ i ∈ sι, μ (S i) ≠ ∞)
    (h_disj : ∀ᵉ (i ∈ sι) (j ∈ sι), i ≠ j → Disjoint (S i) (S j)) :
    T (⋃ i ∈ sι, S i) = ∑ i ∈ sι, T (S i) 
goal: T (⋃ i ∈ sι, S i) = ∑ i ∈ sι, T (S i)

full_name: MeasureTheory.DominatedFinMeasAdditive
code: /-- A `FinMeasAdditive` set function whose norm on every set is less than the measure of the
set (up to a multiplicative constant). -/
def DominatedFinMeasAdditive {β} [SeminormedAddCommGroup β] {_ : MeasurableSpace α} (μ : Measure α)
    (T : Set α → β) (C : ℝ) : Prop 
goal: {x : MeasurableSpace α} → MeasureTheory.Measure α → (Set α → β) → ℝ → Prop

full_name: MeasureTheory.DominatedFinMeasAdditive.zero
code: theorem zero {m : MeasurableSpace α} (μ : Measure α) (hC : 0 ≤ C) :
    DominatedFinMeasAdditive μ (0 : Set α → β) C 
goal: MeasureTheory.DominatedFinMeasAdditive μ 0 C

full_name: MeasureTheory.DominatedFinMeasAdditive.eq_zero_of_measure_zero
code: theorem eq_zero_of_measure_zero {β : Type*} [NormedAddCommGroup β] {T : Set α → β} {C : ℝ}
    (hT : DominatedFinMeasAdditive μ T C) {s : Set α} (hs : MeasurableSet s) (hs_zero : μ s = 0) :
    T s = 0 
goal: T s = 0

full_name: MeasureTheory.DominatedFinMeasAdditive.eq_zero
code: theorem eq_zero {β : Type*} [NormedAddCommGroup β] {T : Set α → β} {C : ℝ} {m : MeasurableSpace α}
    (hT : DominatedFinMeasAdditive (0 : Measure α) T C) {s : Set α} (hs : MeasurableSet s) :
    T s = 0 
goal: T s = 0

full_name: MeasureTheory.DominatedFinMeasAdditive.add
code: theorem add (hT : DominatedFinMeasAdditive μ T C) (hT' : DominatedFinMeasAdditive μ T' C') :
    DominatedFinMeasAdditive μ (T + T') (C + C') 
goal: MeasureTheory.DominatedFinMeasAdditive μ (T + T') (C + C')

full_name: MeasureTheory.DominatedFinMeasAdditive.smul
code: theorem smul [NormedField 𝕜] [NormedSpace 𝕜 β] (hT : DominatedFinMeasAdditive μ T C) (c : 𝕜) :
    DominatedFinMeasAdditive μ (fun s => c • T s) (‖c‖ * C) 
goal: MeasureTheory.DominatedFinMeasAdditive μ (fun s => c • T s) (‖c‖ * C)

full_name: MeasureTheory.DominatedFinMeasAdditive.of_measure_le
code: theorem of_measure_le {μ' : Measure α} (h : μ ≤ μ') (hT : DominatedFinMeasAdditive μ T C)
    (hC : 0 ≤ C) : DominatedFinMeasAdditive μ' T C 
goal: MeasureTheory.DominatedFinMeasAdditive μ' T C

full_name: MeasureTheory.DominatedFinMeasAdditive.add_measure_right
code: theorem add_measure_right {_ : MeasurableSpace α} (μ ν : Measure α)
    (hT : DominatedFinMeasAdditive μ T C) (hC : 0 ≤ C) : DominatedFinMeasAdditive (μ + ν) T C 
goal: ∀ {x : MeasurableSpace α} (μ ν : MeasureTheory.Measure α),
  MeasureTheory.DominatedFinMeasAdditive μ T C → 0 ≤ C → MeasureTheory.DominatedFinMeasAdditive (μ + ν) T C

full_name: MeasureTheory.DominatedFinMeasAdditive.add_measure_left
code: theorem add_measure_left {_ : MeasurableSpace α} (μ ν : Measure α)
    (hT : DominatedFinMeasAdditive ν T C) (hC : 0 ≤ C) : DominatedFinMeasAdditive (μ + ν) T C 
goal: ∀ {x : MeasurableSpace α} (μ ν : MeasureTheory.Measure α),
  MeasureTheory.DominatedFinMeasAdditive ν T C → 0 ≤ C → MeasureTheory.DominatedFinMeasAdditive (μ + ν) T C

full_name: MeasureTheory.DominatedFinMeasAdditive.of_smul_measure
code: theorem of_smul_measure (c : ℝ≥0∞) (hc_ne_top : c ≠ ∞) (hT : DominatedFinMeasAdditive (c • μ) T C) :
    DominatedFinMeasAdditive μ T (c.toReal * C) 
goal: MeasureTheory.DominatedFinMeasAdditive μ T (c.toReal * C)

full_name: MeasureTheory.DominatedFinMeasAdditive.of_measure_le_smul
code: theorem of_measure_le_smul {μ' : Measure α} (c : ℝ≥0∞) (hc : c ≠ ∞) (h : μ ≤ c • μ')
    (hT : DominatedFinMeasAdditive μ T C) (hC : 0 ≤ C) :
    DominatedFinMeasAdditive μ' T (c.toReal * C) 
goal: MeasureTheory.DominatedFinMeasAdditive μ' T (c.toReal * C)

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc
code: /-- Extend `Set α → (F →L[ℝ] F')` to `(α →ₛ F) → F'`. -/
def setToSimpleFunc {_ : MeasurableSpace α} (T : Set α → F →L[ℝ] F') (f : α →ₛ F) : F' 
goal: {x : MeasurableSpace α} → (Set α → F →L[ℝ] F') → MeasureTheory.SimpleFunc α F → F'

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_zero
code: @[simp]
theorem setToSimpleFunc_zero {m : MeasurableSpace α} (f : α →ₛ F) :
    setToSimpleFunc (0 : Set α → F →L[ℝ] F') f = 0 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc 0 f = 0

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_zero'
code: theorem setToSimpleFunc_zero' {T : Set α → E →L[ℝ] F'}
    (h_zero : ∀ s, MeasurableSet s → μ s < ∞ → T s = 0) (f : α →ₛ E) (hf : Integrable f μ) :
    setToSimpleFunc T f = 0 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T f = 0

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_zero_apply
code: @[simp]
theorem setToSimpleFunc_zero_apply {m : MeasurableSpace α} (T : Set α → F →L[ℝ] F') :
    setToSimpleFunc T (0 : α →ₛ F) = 0 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T 0 = 0

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_eq_sum_filter
code: theorem setToSimpleFunc_eq_sum_filter {m : MeasurableSpace α} (T : Set α → F →L[ℝ] F')
    (f : α →ₛ F) :
    setToSimpleFunc T f = ∑ x ∈ f.range.filter fun x => x ≠ 0, (T (f ⁻¹' {x})) x 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T f = ∑ x ∈ Finset.filter (fun x => x ≠ 0) f.range, (T (↑f ⁻¹' {x})) x

full_name: MeasureTheory.SimpleFunc.map_setToSimpleFunc
code: theorem map_setToSimpleFunc (T : Set α → F →L[ℝ] F') (h_add : FinMeasAdditive μ T) {f : α →ₛ G}
    (hf : Integrable f μ) {g : G → F} (hg : g 0 = 0) :
    (f.map g).setToSimpleFunc T = ∑ x ∈ f.range, T (f ⁻¹' {x}) (g x) 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T (MeasureTheory.SimpleFunc.map g f) = ∑ x ∈ f.range, (T (↑f ⁻¹' {x})) (g x)

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_congr'
code: theorem setToSimpleFunc_congr' (T : Set α → E →L[ℝ] F) (h_add : FinMeasAdditive μ T) {f g : α →ₛ E}
    (hf : Integrable f μ) (hg : Integrable g μ)
    (h : Pairwise fun x y => T (f ⁻¹' {x} ∩ g ⁻¹' {y}) = 0) :
    f.setToSimpleFunc T = g.setToSimpleFunc T 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T f = MeasureTheory.SimpleFunc.setToSimpleFunc T g

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_congr
code: theorem setToSimpleFunc_congr (T : Set α → E →L[ℝ] F)
    (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0) (h_add : FinMeasAdditive μ T) {f g : α →ₛ E}
    (hf : Integrable f μ) (h : f =ᵐ[μ] g) : f.setToSimpleFunc T = g.setToSimpleFunc T 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T f = MeasureTheory.SimpleFunc.setToSimpleFunc T g

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_congr_left
code: theorem setToSimpleFunc_congr_left (T T' : Set α → E →L[ℝ] F)
    (h : ∀ s, MeasurableSet s → μ s < ∞ → T s = T' s) (f : α →ₛ E) (hf : Integrable f μ) :
    setToSimpleFunc T f = setToSimpleFunc T' f 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T f = MeasureTheory.SimpleFunc.setToSimpleFunc T' f

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_add_left
code: theorem setToSimpleFunc_add_left {m : MeasurableSpace α} (T T' : Set α → F →L[ℝ] F') {f : α →ₛ F} :
    setToSimpleFunc (T + T') f = setToSimpleFunc T f + setToSimpleFunc T' f 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc (T + T') f =
  MeasureTheory.SimpleFunc.setToSimpleFunc T f + MeasureTheory.SimpleFunc.setToSimpleFunc T' f

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_add_left'
code: theorem setToSimpleFunc_add_left' (T T' T'' : Set α → E →L[ℝ] F)
    (h_add : ∀ s, MeasurableSet s → μ s < ∞ → T'' s = T s + T' s) {f : α →ₛ E}
    (hf : Integrable f μ) : setToSimpleFunc T'' f = setToSimpleFunc T f + setToSimpleFunc T' f 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T'' f =
  MeasureTheory.SimpleFunc.setToSimpleFunc T f + MeasureTheory.SimpleFunc.setToSimpleFunc T' f

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_smul_left
code: theorem setToSimpleFunc_smul_left {m : MeasurableSpace α} (T : Set α → F →L[ℝ] F') (c : ℝ)
    (f : α →ₛ F) : setToSimpleFunc (fun s => c • T s) f = c • setToSimpleFunc T f 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc (fun s => c • T s) f = c • MeasureTheory.SimpleFunc.setToSimpleFunc T f

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_smul_left'
code: theorem setToSimpleFunc_smul_left' (T T' : Set α → E →L[ℝ] F') (c : ℝ)
    (h_smul : ∀ s, MeasurableSet s → μ s < ∞ → T' s = c • T s) {f : α →ₛ E} (hf : Integrable f μ) :
    setToSimpleFunc T' f = c • setToSimpleFunc T f 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T' f = c • MeasureTheory.SimpleFunc.setToSimpleFunc T f

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_add
code: theorem setToSimpleFunc_add (T : Set α → E →L[ℝ] F) (h_add : FinMeasAdditive μ T) {f g : α →ₛ E}
    (hf : Integrable f μ) (hg : Integrable g μ) :
    setToSimpleFunc T (f + g) = setToSimpleFunc T f + setToSimpleFunc T g 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T (f + g) =
  MeasureTheory.SimpleFunc.setToSimpleFunc T f + MeasureTheory.SimpleFunc.setToSimpleFunc T g

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_neg
code: theorem setToSimpleFunc_neg (T : Set α → E →L[ℝ] F) (h_add : FinMeasAdditive μ T) {f : α →ₛ E}
    (hf : Integrable f μ) : setToSimpleFunc T (-f) = -setToSimpleFunc T f 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T (-f) = -MeasureTheory.SimpleFunc.setToSimpleFunc T f

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_sub
code: theorem setToSimpleFunc_sub (T : Set α → E →L[ℝ] F) (h_add : FinMeasAdditive μ T) {f g : α →ₛ E}
    (hf : Integrable f μ) (hg : Integrable g μ) :
    setToSimpleFunc T (f - g) = setToSimpleFunc T f - setToSimpleFunc T g 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T (f - g) =
  MeasureTheory.SimpleFunc.setToSimpleFunc T f - MeasureTheory.SimpleFunc.setToSimpleFunc T g

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_smul_real
code: theorem setToSimpleFunc_smul_real (T : Set α → E →L[ℝ] F) (h_add : FinMeasAdditive μ T) (c : ℝ)
    {f : α →ₛ E} (hf : Integrable f μ) : setToSimpleFunc T (c • f) = c • setToSimpleFunc T f 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T (c • f) = c • MeasureTheory.SimpleFunc.setToSimpleFunc T f

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_smul
code: theorem setToSimpleFunc_smul {E} [NormedAddCommGroup E] [NormedField 𝕜] [NormedSpace 𝕜 E]
    [NormedSpace ℝ E] [NormedSpace 𝕜 F] (T : Set α → E →L[ℝ] F) (h_add : FinMeasAdditive μ T)
    (h_smul : ∀ c : 𝕜, ∀ s x, T s (c • x) = c • T s x) (c : 𝕜) {f : α →ₛ E} (hf : Integrable f μ) :
    setToSimpleFunc T (c • f) = c • setToSimpleFunc T f 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T (c • f) = c • MeasureTheory.SimpleFunc.setToSimpleFunc T f

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_mono_left
code: theorem setToSimpleFunc_mono_left {m : MeasurableSpace α} (T T' : Set α → F →L[ℝ] G'')
    (hTT' : ∀ s x, T s x ≤ T' s x) (f : α →ₛ F) : setToSimpleFunc T f ≤ setToSimpleFunc T' f 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T f ≤ MeasureTheory.SimpleFunc.setToSimpleFunc T' f

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_mono_left'
code: theorem setToSimpleFunc_mono_left' (T T' : Set α → E →L[ℝ] G'')
    (hTT' : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, T s x ≤ T' s x) (f : α →ₛ E)
    (hf : Integrable f μ) : setToSimpleFunc T f ≤ setToSimpleFunc T' f 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T f ≤ MeasureTheory.SimpleFunc.setToSimpleFunc T' f

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_nonneg
code: theorem setToSimpleFunc_nonneg {m : MeasurableSpace α} (T : Set α → G' →L[ℝ] G'')
    (hT_nonneg : ∀ s x, 0 ≤ x → 0 ≤ T s x) (f : α →ₛ G') (hf : 0 ≤ f) :
    0 ≤ setToSimpleFunc T f 
goal: 0 ≤ MeasureTheory.SimpleFunc.setToSimpleFunc T f

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_nonneg'
code: theorem setToSimpleFunc_nonneg' (T : Set α → G' →L[ℝ] G'')
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) (f : α →ₛ G') (hf : 0 ≤ f)
    (hfi : Integrable f μ) : 0 ≤ setToSimpleFunc T f 
goal: 0 ≤ MeasureTheory.SimpleFunc.setToSimpleFunc T f

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_mono
code: theorem setToSimpleFunc_mono {T : Set α → G' →L[ℝ] G''} (h_add : FinMeasAdditive μ T)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f g : α →ₛ G'}
    (hfi : Integrable f μ) (hgi : Integrable g μ) (hfg : f ≤ g) :
    setToSimpleFunc T f ≤ setToSimpleFunc T g 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T f ≤ MeasureTheory.SimpleFunc.setToSimpleFunc T g

full_name: MeasureTheory.SimpleFunc.norm_setToSimpleFunc_le_sum_opNorm
code: theorem norm_setToSimpleFunc_le_sum_opNorm {m : MeasurableSpace α} (T : Set α → F' →L[ℝ] F)
    (f : α →ₛ F') : ‖f.setToSimpleFunc T‖ ≤ ∑ x ∈ f.range, ‖T (f ⁻¹' {x})‖ * ‖x‖ 
goal: ‖MeasureTheory.SimpleFunc.setToSimpleFunc T f‖ ≤ ∑ x ∈ f.range, ‖T (↑f ⁻¹' {x})‖ * ‖x‖

full_name: MeasureTheory.SimpleFunc.norm_setToSimpleFunc_le_sum_mul_norm
code: theorem norm_setToSimpleFunc_le_sum_mul_norm (T : Set α → F →L[ℝ] F') {C : ℝ}
    (hT_norm : ∀ s, MeasurableSet s → ‖T s‖ ≤ C * (μ s).toReal) (f : α →ₛ F) :
    ‖f.setToSimpleFunc T‖ ≤ C * ∑ x ∈ f.range, (μ (f ⁻¹' {x})).toReal * ‖x‖ 
goal: ‖MeasureTheory.SimpleFunc.setToSimpleFunc T f‖ ≤ C * ∑ x ∈ f.range, (μ (↑f ⁻¹' {x})).toReal * ‖x‖

full_name: MeasureTheory.SimpleFunc.norm_setToSimpleFunc_le_sum_mul_norm_of_integrable
code: theorem norm_setToSimpleFunc_le_sum_mul_norm_of_integrable (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 * ∑ x ∈ f.range, (μ (f ⁻¹' {x})).toReal * ‖x‖ 
goal: ‖MeasureTheory.SimpleFunc.setToSimpleFunc T f‖ ≤ C * ∑ x ∈ f.range, (μ (↑f ⁻¹' {x})).toReal * ‖x‖

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_indicator
code: theorem setToSimpleFunc_indicator (T : Set α → F →L[ℝ] F') (hT_empty : T ∅ = 0)
    {m : MeasurableSpace α} {s : Set α} (hs : MeasurableSet s) (x : F) :
    SimpleFunc.setToSimpleFunc T
        (SimpleFunc.piecewise s hs (SimpleFunc.const α x) (SimpleFunc.const α 0)) =
      T s x 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T
    (MeasureTheory.SimpleFunc.piecewise s hs (MeasureTheory.SimpleFunc.const α x)
      (MeasureTheory.SimpleFunc.const α 0)) =
  (T s) x

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_const'
code: theorem setToSimpleFunc_const' [Nonempty α] (T : Set α → F →L[ℝ] F') (x : F)
    {m : MeasurableSpace α} : SimpleFunc.setToSimpleFunc T (SimpleFunc.const α x) = T univ x 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T (MeasureTheory.SimpleFunc.const α x) = (T Set.univ) x

full_name: MeasureTheory.SimpleFunc.setToSimpleFunc_const
code: theorem setToSimpleFunc_const (T : Set α → F →L[ℝ] F') (hT_empty : T ∅ = 0) (x : F)
    {m : MeasurableSpace α} : SimpleFunc.setToSimpleFunc T (SimpleFunc.const α x) = T univ x 
goal: MeasureTheory.SimpleFunc.setToSimpleFunc T (MeasureTheory.SimpleFunc.const α x) = (T Set.univ) x

full_name: MeasureTheory.L1.SimpleFunc.norm_eq_sum_mul
code: theorem norm_eq_sum_mul (f : α →₁ₛ[μ] G) :
    ‖f‖ = ∑ x ∈ (toSimpleFunc f).range, (μ (toSimpleFunc f ⁻¹' {x})).toReal * ‖x‖ 
goal: ‖f‖ =
  ∑ x ∈ (MeasureTheory.Lp.simpleFunc.toSimpleFunc f).range,
    (μ (↑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f) ⁻¹' {x})).toReal * ‖x‖

full_name: MeasureTheory.L1.SimpleFunc.setToL1S
code: /-- Extend `Set α → (E →L[ℝ] F')` to `(α →₁ₛ[μ] E) → F'`. -/
def setToL1S (T : Set α → E →L[ℝ] F) (f : α →₁ₛ[μ] E) : F 
goal: F

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_eq_setToSimpleFunc
code: theorem setToL1S_eq_setToSimpleFunc (T : Set α → E →L[ℝ] F) (f : α →₁ₛ[μ] E) :
    setToL1S T f = (toSimpleFunc f).setToSimpleFunc T 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T f =
  MeasureTheory.SimpleFunc.setToSimpleFunc T (MeasureTheory.Lp.simpleFunc.toSimpleFunc f)

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_zero_left
code: @[simp]
theorem setToL1S_zero_left (f : α →₁ₛ[μ] E) : setToL1S (0 : Set α → E →L[ℝ] F) f = 0 
goal: MeasureTheory.L1.SimpleFunc.setToL1S 0 f = 0

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_zero_left'
code: theorem setToL1S_zero_left' {T : Set α → E →L[ℝ] F}
    (h_zero : ∀ s, MeasurableSet s → μ s < ∞ → T s = 0) (f : α →₁ₛ[μ] E) : setToL1S T f = 0 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T f = 0

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_congr
code: theorem setToL1S_congr (T : Set α → E →L[ℝ] F) (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0)
    (h_add : FinMeasAdditive μ T) {f g : α →₁ₛ[μ] E} (h : toSimpleFunc f =ᵐ[μ] toSimpleFunc g) :
    setToL1S T f = setToL1S T g 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T f = MeasureTheory.L1.SimpleFunc.setToL1S T g

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_congr_left
code: theorem setToL1S_congr_left (T T' : Set α → E →L[ℝ] F)
    (h : ∀ s, MeasurableSet s → μ s < ∞ → T s = T' s) (f : α →₁ₛ[μ] E) :
    setToL1S T f = setToL1S T' f 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T f = MeasureTheory.L1.SimpleFunc.setToL1S T' f

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_congr_measure
code: /-- `setToL1S` does not change if we replace the measure `μ` by `μ'` with `μ ≪ μ'`. The statement
uses two functions `f` and `f'` because they have to belong to different types, but morally these
are the same function (we have `f =ᵐ[μ] f'`). -/
theorem setToL1S_congr_measure {μ' : Measure α} (T : Set α → E →L[ℝ] F)
    (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0) (h_add : FinMeasAdditive μ T) (hμ : μ ≪ μ')
    (f : α →₁ₛ[μ] E) (f' : α →₁ₛ[μ'] E) (h : (f : α → E) =ᵐ[μ] f') :
    setToL1S T f = setToL1S T f' 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T f = MeasureTheory.L1.SimpleFunc.setToL1S T f'

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_add_left
code: theorem setToL1S_add_left (T T' : Set α → E →L[ℝ] F) (f : α →₁ₛ[μ] E) :
    setToL1S (T + T') f = setToL1S T f + setToL1S T' f 
goal: MeasureTheory.L1.SimpleFunc.setToL1S (T + T') f =
  MeasureTheory.L1.SimpleFunc.setToL1S T f + MeasureTheory.L1.SimpleFunc.setToL1S T' f

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_add_left'
code: theorem setToL1S_add_left' (T T' T'' : Set α → E →L[ℝ] F)
    (h_add : ∀ s, MeasurableSet s → μ s < ∞ → T'' s = T s + T' s) (f : α →₁ₛ[μ] E) :
    setToL1S T'' f = setToL1S T f + setToL1S T' f 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T'' f =
  MeasureTheory.L1.SimpleFunc.setToL1S T f + MeasureTheory.L1.SimpleFunc.setToL1S T' f

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_smul_left
code: theorem setToL1S_smul_left (T : Set α → E →L[ℝ] F) (c : ℝ) (f : α →₁ₛ[μ] E) :
    setToL1S (fun s => c • T s) f = c • setToL1S T f 
goal: MeasureTheory.L1.SimpleFunc.setToL1S (fun s => c • T s) f = c • MeasureTheory.L1.SimpleFunc.setToL1S T f

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_smul_left'
code: theorem setToL1S_smul_left' (T T' : Set α → E →L[ℝ] F) (c : ℝ)
    (h_smul : ∀ s, MeasurableSet s → μ s < ∞ → T' s = c • T s) (f : α →₁ₛ[μ] E) :
    setToL1S T' f = c • setToL1S T f 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T' f = c • MeasureTheory.L1.SimpleFunc.setToL1S T f

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_add
code: theorem setToL1S_add (T : Set α → E →L[ℝ] F) (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0)
    (h_add : FinMeasAdditive μ T) (f g : α →₁ₛ[μ] E) :
    setToL1S T (f + g) = setToL1S T f + setToL1S T g 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T (f + g) =
  MeasureTheory.L1.SimpleFunc.setToL1S T f + MeasureTheory.L1.SimpleFunc.setToL1S T g

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_neg
code: theorem setToL1S_neg {T : Set α → E →L[ℝ] F} (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0)
    (h_add : FinMeasAdditive μ T) (f : α →₁ₛ[μ] E) : setToL1S T (-f) = -setToL1S T f 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T (-f) = -MeasureTheory.L1.SimpleFunc.setToL1S T f

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_sub
code: theorem setToL1S_sub {T : Set α → E →L[ℝ] F} (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0)
    (h_add : FinMeasAdditive μ T) (f g : α →₁ₛ[μ] E) :
    setToL1S T (f - g) = setToL1S T f - setToL1S T g 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T (f - g) =
  MeasureTheory.L1.SimpleFunc.setToL1S T f - MeasureTheory.L1.SimpleFunc.setToL1S T g

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_smul_real
code: theorem setToL1S_smul_real (T : Set α → E →L[ℝ] F)
    (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0) (h_add : FinMeasAdditive μ T) (c : ℝ)
    (f : α →₁ₛ[μ] E) : setToL1S T (c • f) = c • setToL1S T f 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T (c • f) = c • MeasureTheory.L1.SimpleFunc.setToL1S T f

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_smul
code: theorem setToL1S_smul {E} [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedSpace 𝕜 E]
    [NormedSpace 𝕜 F] (T : Set α → E →L[ℝ] F) (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0)
    (h_add : FinMeasAdditive μ T) (h_smul : ∀ c : 𝕜, ∀ s x, T s (c • x) = c • T s x) (c : 𝕜)
    (f : α →₁ₛ[μ] E) : setToL1S T (c • f) = c • setToL1S T f 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T (c • f) = c • MeasureTheory.L1.SimpleFunc.setToL1S T f

full_name: MeasureTheory.L1.SimpleFunc.norm_setToL1S_le
code: theorem norm_setToL1S_le (T : Set α → E →L[ℝ] F) {C : ℝ}
    (hT_norm : ∀ s, MeasurableSet s → μ s < ∞ → ‖T s‖ ≤ C * (μ s).toReal) (f : α →₁ₛ[μ] E) :
    ‖setToL1S T f‖ ≤ C * ‖f‖ 
goal: ‖MeasureTheory.L1.SimpleFunc.setToL1S T f‖ ≤ C * ‖f‖

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_indicatorConst
code: theorem setToL1S_indicatorConst {T : Set α → E →L[ℝ] F} {s : Set α}
    (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0) (h_add : FinMeasAdditive μ T)
    (hs : MeasurableSet s) (hμs : μ s < ∞) (x : E) :
    setToL1S T (simpleFunc.indicatorConst 1 hs hμs.ne x) = T s x 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T (MeasureTheory.Lp.simpleFunc.indicatorConst 1 hs ⋯ x) = (T s) x

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_const
code: theorem setToL1S_const [IsFiniteMeasure μ] {T : Set α → E →L[ℝ] F}
    (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0) (h_add : FinMeasAdditive μ T) (x : E) :
    setToL1S T (simpleFunc.indicatorConst 1 MeasurableSet.univ (measure_ne_top μ _) x) = T univ x 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T (MeasureTheory.Lp.simpleFunc.indicatorConst 1 ⋯ ⋯ x) = (T Set.univ) x

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_mono_left
code: theorem setToL1S_mono_left {T T' : Set α → E →L[ℝ] G''} (hTT' : ∀ s x, T s x ≤ T' s x)
    (f : α →₁ₛ[μ] E) : setToL1S T f ≤ setToL1S T' f 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T f ≤ MeasureTheory.L1.SimpleFunc.setToL1S T' f

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_mono_left'
code: theorem setToL1S_mono_left' {T T' : Set α → E →L[ℝ] G''}
    (hTT' : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, T s x ≤ T' s x) (f : α →₁ₛ[μ] E) :
    setToL1S T f ≤ setToL1S T' f 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T f ≤ MeasureTheory.L1.SimpleFunc.setToL1S T' f

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_nonneg
code: theorem setToL1S_nonneg (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0)
    (h_add : FinMeasAdditive μ T)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f : α →₁ₛ[μ] G''}
    (hf : 0 ≤ f) : 0 ≤ setToL1S T f 
goal: 0 ≤ MeasureTheory.L1.SimpleFunc.setToL1S T f

full_name: MeasureTheory.L1.SimpleFunc.setToL1S_mono
code: theorem setToL1S_mono (h_zero : ∀ s, MeasurableSet s → μ s = 0 → T s = 0)
    (h_add : FinMeasAdditive μ T)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f g : α →₁ₛ[μ] G''}
    (hfg : f ≤ g) : setToL1S T f ≤ setToL1S T g 
goal: MeasureTheory.L1.SimpleFunc.setToL1S T f ≤ MeasureTheory.L1.SimpleFunc.setToL1S T g

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM'
code: /-- Extend `Set α → E →L[ℝ] F` to `(α →₁ₛ[μ] E) →L[𝕜] F`. -/
def setToL1SCLM' {T : Set α → E →L[ℝ] F} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C)
    (h_smul : ∀ c : 𝕜, ∀ s x, T s (c • x) = c • T s x) : (α →₁ₛ[μ] E) →L[𝕜] F 
goal: ↥(MeasureTheory.Lp.simpleFunc E 1 μ) →L[𝕜] F

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM
code: /-- Extend `Set α → E →L[ℝ] F` to `(α →₁ₛ[μ] E) →L[ℝ] F`. -/
def setToL1SCLM {T : Set α → E →L[ℝ] F} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C) :
    (α →₁ₛ[μ] E) →L[ℝ] F 
goal: ↥(MeasureTheory.Lp.simpleFunc E 1 μ) →L[ℝ] F

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_zero_left
code: @[simp]
theorem setToL1SCLM_zero_left (hT : DominatedFinMeasAdditive μ (0 : Set α → E →L[ℝ] F) C)
    (f : α →₁ₛ[μ] E) : setToL1SCLM α E μ hT f = 0 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) f = 0

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_zero_left'
code: theorem setToL1SCLM_zero_left' (hT : DominatedFinMeasAdditive μ T C)
    (h_zero : ∀ s, MeasurableSet s → μ s < ∞ → T s = 0) (f : α →₁ₛ[μ] E) :
    setToL1SCLM α E μ hT f = 0 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) f = 0

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_congr_left
code: theorem setToL1SCLM_congr_left (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (h : T = T') (f : α →₁ₛ[μ] E) :
    setToL1SCLM α E μ hT f = setToL1SCLM α E μ hT' f 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) f = (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT') f

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_congr_left'
code: theorem setToL1SCLM_congr_left' (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (h : ∀ s, MeasurableSet s → μ s < ∞ → T s = T' s)
    (f : α →₁ₛ[μ] E) : setToL1SCLM α E μ hT f = setToL1SCLM α E μ hT' f 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) f = (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT') f

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_congr_measure
code: theorem setToL1SCLM_congr_measure {μ' : Measure α} (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ' T C') (hμ : μ ≪ μ') (f : α →₁ₛ[μ] E) (f' : α →₁ₛ[μ'] E)
    (h : (f : α → E) =ᵐ[μ] f') : setToL1SCLM α E μ hT f = setToL1SCLM α E μ' hT' f' 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) f = (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ' hT') f'

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_add_left
code: theorem setToL1SCLM_add_left (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (f : α →₁ₛ[μ] E) :
    setToL1SCLM α E μ (hT.add hT') f = setToL1SCLM α E μ hT f + setToL1SCLM α E μ hT' f 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ ⋯) f =
  (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) f + (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT') f

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_add_left'
code: theorem setToL1SCLM_add_left' (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (hT'' : DominatedFinMeasAdditive μ T'' C'')
    (h_add : ∀ s, MeasurableSet s → μ s < ∞ → T'' s = T s + T' s) (f : α →₁ₛ[μ] E) :
    setToL1SCLM α E μ hT'' f = setToL1SCLM α E μ hT f + setToL1SCLM α E μ hT' f 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT'') f =
  (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) f + (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT') f

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_smul_left
code: theorem setToL1SCLM_smul_left (c : ℝ) (hT : DominatedFinMeasAdditive μ T C) (f : α →₁ₛ[μ] E) :
    setToL1SCLM α E μ (hT.smul c) f = c • setToL1SCLM α E μ hT f 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ ⋯) f = c • (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) f

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_smul_left'
code: theorem setToL1SCLM_smul_left' (c : ℝ) (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C')
    (h_smul : ∀ s, MeasurableSet s → μ s < ∞ → T' s = c • T s) (f : α →₁ₛ[μ] E) :
    setToL1SCLM α E μ hT' f = c • setToL1SCLM α E μ hT f 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT') f = c • (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) f

full_name: MeasureTheory.L1.SimpleFunc.norm_setToL1SCLM_le
code: theorem norm_setToL1SCLM_le {T : Set α → E →L[ℝ] F} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C)
    (hC : 0 ≤ C) : ‖setToL1SCLM α E μ hT‖ ≤ C 
goal: ‖MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT‖ ≤ C

full_name: MeasureTheory.L1.SimpleFunc.norm_setToL1SCLM_le'
code: theorem norm_setToL1SCLM_le' {T : Set α → E →L[ℝ] F} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C) :
    ‖setToL1SCLM α E μ hT‖ ≤ max C 0 
goal: ‖MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT‖ ≤ max C 0

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_const
code: theorem setToL1SCLM_const [IsFiniteMeasure μ] {T : Set α → E →L[ℝ] F} {C : ℝ}
    (hT : DominatedFinMeasAdditive μ T C) (x : E) :
    setToL1SCLM α E μ hT (simpleFunc.indicatorConst 1 MeasurableSet.univ (measure_ne_top μ _) x) =
      T univ x 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) (MeasureTheory.Lp.simpleFunc.indicatorConst 1 ⋯ ⋯ x) = (T Set.univ) x

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_mono_left
code: theorem setToL1SCLM_mono_left {T T' : Set α → E →L[ℝ] G''} {C C' : ℝ}
    (hT : DominatedFinMeasAdditive μ T C) (hT' : DominatedFinMeasAdditive μ T' C')
    (hTT' : ∀ s x, T s x ≤ T' s x) (f : α →₁ₛ[μ] E) :
    setToL1SCLM α E μ hT f ≤ setToL1SCLM α E μ hT' f 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) f ≤ (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT') f

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_mono_left'
code: theorem setToL1SCLM_mono_left' {T T' : Set α → E →L[ℝ] G''} {C C' : ℝ}
    (hT : DominatedFinMeasAdditive μ T C) (hT' : DominatedFinMeasAdditive μ T' C')
    (hTT' : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, T s x ≤ T' s x) (f : α →₁ₛ[μ] E) :
    setToL1SCLM α E μ hT f ≤ setToL1SCLM α E μ hT' f 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) f ≤ (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT') f

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_nonneg
code: theorem setToL1SCLM_nonneg {T : Set α → G' →L[ℝ] G''} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f : α →₁ₛ[μ] G'}
    (hf : 0 ≤ f) : 0 ≤ setToL1SCLM α G' μ hT f 
goal: 0 ≤ (MeasureTheory.L1.SimpleFunc.setToL1SCLM α G' μ hT) f

full_name: MeasureTheory.L1.SimpleFunc.setToL1SCLM_mono
code: theorem setToL1SCLM_mono {T : Set α → G' →L[ℝ] G''} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f g : α →₁ₛ[μ] G'}
    (hfg : f ≤ g) : setToL1SCLM α G' μ hT f ≤ setToL1SCLM α G' μ hT g 
goal: (MeasureTheory.L1.SimpleFunc.setToL1SCLM α G' μ hT) f ≤ (MeasureTheory.L1.SimpleFunc.setToL1SCLM α G' μ hT) g

full_name: MeasureTheory.L1.setToL1'
code: /-- Extend `set α → (E →L[ℝ] F)` to `(α →₁[μ] E) →L[𝕜] F`. -/
def setToL1' (hT : DominatedFinMeasAdditive μ T C)
    (h_smul : ∀ c : 𝕜, ∀ s x, T s (c • x) = c • T s x) : (α →₁[μ] E) →L[𝕜] F 
goal: ↥(MeasureTheory.Lp E 1 μ) →L[𝕜] F

full_name: MeasureTheory.L1.setToL1
code: /-- Extend `Set α → E →L[ℝ] F` to `(α →₁[μ] E) →L[ℝ] F`. -/
def setToL1 (hT : DominatedFinMeasAdditive μ T C) : (α →₁[μ] E) →L[ℝ] F 
goal: ↥(MeasureTheory.Lp E 1 μ) →L[ℝ] F

full_name: MeasureTheory.L1.setToL1_eq_setToL1SCLM
code: theorem setToL1_eq_setToL1SCLM (hT : DominatedFinMeasAdditive μ T C) (f : α →₁ₛ[μ] E) :
    setToL1 hT f = setToL1SCLM α E μ hT f 
goal: (MeasureTheory.L1.setToL1 hT) ↑f = (MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT) f

full_name: MeasureTheory.L1.setToL1_eq_setToL1'
code: theorem setToL1_eq_setToL1' (hT : DominatedFinMeasAdditive μ T C)
    (h_smul : ∀ c : 𝕜, ∀ s x, T s (c • x) = c • T s x) (f : α →₁[μ] E) :
    setToL1 hT f = setToL1' 𝕜 hT h_smul f 
goal: (MeasureTheory.L1.setToL1 hT) f = (MeasureTheory.L1.setToL1' 𝕜 hT h_smul) f

full_name: MeasureTheory.L1.setToL1_zero_left
code: @[simp]
theorem setToL1_zero_left (hT : DominatedFinMeasAdditive μ (0 : Set α → E →L[ℝ] F) C)
    (f : α →₁[μ] E) : setToL1 hT f = 0 
goal: (MeasureTheory.L1.setToL1 hT) f = 0

full_name: MeasureTheory.L1.setToL1_zero_left'
code: theorem setToL1_zero_left' (hT : DominatedFinMeasAdditive μ T C)
    (h_zero : ∀ s, MeasurableSet s → μ s < ∞ → T s = 0) (f : α →₁[μ] E) : setToL1 hT f = 0 
goal: (MeasureTheory.L1.setToL1 hT) f = 0

full_name: MeasureTheory.L1.setToL1_congr_left
code: theorem setToL1_congr_left (T T' : Set α → E →L[ℝ] F) {C C' : ℝ}
    (hT : DominatedFinMeasAdditive μ T C) (hT' : DominatedFinMeasAdditive μ T' C') (h : T = T')
    (f : α →₁[μ] E) : setToL1 hT f = setToL1 hT' f 
goal: (MeasureTheory.L1.setToL1 hT) f = (MeasureTheory.L1.setToL1 hT') f

full_name: MeasureTheory.L1.setToL1_congr_left'
code: theorem setToL1_congr_left' (T T' : Set α → E →L[ℝ] F) {C C' : ℝ}
    (hT : DominatedFinMeasAdditive μ T C) (hT' : DominatedFinMeasAdditive μ T' C')
    (h : ∀ s, MeasurableSet s → μ s < ∞ → T s = T' s) (f : α →₁[μ] E) :
    setToL1 hT f = setToL1 hT' f 
goal: (MeasureTheory.L1.setToL1 hT) f = (MeasureTheory.L1.setToL1 hT') f

full_name: MeasureTheory.L1.setToL1_add_left
code: theorem setToL1_add_left (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (f : α →₁[μ] E) :
    setToL1 (hT.add hT') f = setToL1 hT f + setToL1 hT' f 
goal: (MeasureTheory.L1.setToL1 ⋯) f = (MeasureTheory.L1.setToL1 hT) f + (MeasureTheory.L1.setToL1 hT') f

full_name: MeasureTheory.L1.setToL1_add_left'
code: theorem setToL1_add_left' (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (hT'' : DominatedFinMeasAdditive μ T'' C'')
    (h_add : ∀ s, MeasurableSet s → μ s < ∞ → T'' s = T s + T' s) (f : α →₁[μ] E) :
    setToL1 hT'' f = setToL1 hT f + setToL1 hT' f 
goal: (MeasureTheory.L1.setToL1 hT'') f = (MeasureTheory.L1.setToL1 hT) f + (MeasureTheory.L1.setToL1 hT') f

full_name: MeasureTheory.L1.setToL1_smul_left
code: theorem setToL1_smul_left (hT : DominatedFinMeasAdditive μ T C) (c : ℝ) (f : α →₁[μ] E) :
    setToL1 (hT.smul c) f = c • setToL1 hT f 
goal: (MeasureTheory.L1.setToL1 ⋯) f = c • (MeasureTheory.L1.setToL1 hT) f

full_name: MeasureTheory.L1.setToL1_smul_left'
code: theorem setToL1_smul_left' (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (c : ℝ)
    (h_smul : ∀ s, MeasurableSet s → μ s < ∞ → T' s = c • T s) (f : α →₁[μ] E) :
    setToL1 hT' f = c • setToL1 hT f 
goal: (MeasureTheory.L1.setToL1 hT') f = c • (MeasureTheory.L1.setToL1 hT) f

full_name: MeasureTheory.L1.setToL1_smul
code: theorem setToL1_smul (hT : DominatedFinMeasAdditive μ T C)
    (h_smul : ∀ c : 𝕜, ∀ s x, T s (c • x) = c • T s x) (c : 𝕜) (f : α →₁[μ] E) :
    setToL1 hT (c • f) = c • setToL1 hT f 
goal: (MeasureTheory.L1.setToL1 hT) (c • f) = c • (MeasureTheory.L1.setToL1 hT) f

full_name: MeasureTheory.L1.setToL1_simpleFunc_indicatorConst
code: theorem setToL1_simpleFunc_indicatorConst (hT : DominatedFinMeasAdditive μ T C) {s : Set α}
    (hs : MeasurableSet s) (hμs : μ s < ∞) (x : E) :
    setToL1 hT (simpleFunc.indicatorConst 1 hs hμs.ne x) = T s x 
goal: (MeasureTheory.L1.setToL1 hT) ↑(MeasureTheory.Lp.simpleFunc.indicatorConst 1 hs ⋯ x) = (T s) x

full_name: MeasureTheory.L1.setToL1_indicatorConstLp
code: theorem setToL1_indicatorConstLp (hT : DominatedFinMeasAdditive μ T C) {s : Set α}
    (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (x : E) :
    setToL1 hT (indicatorConstLp 1 hs hμs x) = T s x 
goal: (MeasureTheory.L1.setToL1 hT) (MeasureTheory.indicatorConstLp 1 hs hμs x) = (T s) x

full_name: MeasureTheory.L1.setToL1_const
code: theorem setToL1_const [IsFiniteMeasure μ] (hT : DominatedFinMeasAdditive μ T C) (x : E) :
    setToL1 hT (indicatorConstLp 1 MeasurableSet.univ (measure_ne_top _ _) x) = T univ x 
goal: (MeasureTheory.L1.setToL1 hT) (MeasureTheory.indicatorConstLp 1 ⋯ ⋯ x) = (T Set.univ) x

full_name: MeasureTheory.L1.setToL1_mono_left'
code: theorem setToL1_mono_left' {T T' : Set α → E →L[ℝ] G''} {C C' : ℝ}
    (hT : DominatedFinMeasAdditive μ T C) (hT' : DominatedFinMeasAdditive μ T' C')
    (hTT' : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, T s x ≤ T' s x) (f : α →₁[μ] E) :
    setToL1 hT f ≤ setToL1 hT' f 
goal: (MeasureTheory.L1.setToL1 hT) f ≤ (MeasureTheory.L1.setToL1 hT') f

full_name: MeasureTheory.L1.setToL1_mono_left
code: theorem setToL1_mono_left {T T' : Set α → E →L[ℝ] G''} {C C' : ℝ}
    (hT : DominatedFinMeasAdditive μ T C) (hT' : DominatedFinMeasAdditive μ T' C')
    (hTT' : ∀ s x, T s x ≤ T' s x) (f : α →₁[μ] E) : setToL1 hT f ≤ setToL1 hT' f 
goal: (MeasureTheory.L1.setToL1 hT) f ≤ (MeasureTheory.L1.setToL1 hT') f

full_name: MeasureTheory.L1.setToL1_nonneg
code: theorem setToL1_nonneg {T : Set α → G' →L[ℝ] G''} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f : α →₁[μ] G'}
    (hf : 0 ≤ f) : 0 ≤ setToL1 hT f 
goal: 0 ≤ (MeasureTheory.L1.setToL1 hT) f

full_name: MeasureTheory.L1.setToL1_mono
code: theorem setToL1_mono {T : Set α → G' →L[ℝ] G''} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f g : α →₁[μ] G'}
    (hfg : f ≤ g) : setToL1 hT f ≤ setToL1 hT g 
goal: (MeasureTheory.L1.setToL1 hT) f ≤ (MeasureTheory.L1.setToL1 hT) g

full_name: MeasureTheory.L1.norm_setToL1_le_norm_setToL1SCLM
code: theorem norm_setToL1_le_norm_setToL1SCLM (hT : DominatedFinMeasAdditive μ T C) :
    ‖setToL1 hT‖ ≤ ‖setToL1SCLM α E μ hT‖ 
goal: ‖MeasureTheory.L1.setToL1 hT‖ ≤ ‖MeasureTheory.L1.SimpleFunc.setToL1SCLM α E μ hT‖

full_name: MeasureTheory.L1.norm_setToL1_le_mul_norm
code: theorem norm_setToL1_le_mul_norm (hT : DominatedFinMeasAdditive μ T C) (hC : 0 ≤ C)
    (f : α →₁[μ] E) : ‖setToL1 hT f‖ ≤ C * ‖f‖ 
goal: ‖(MeasureTheory.L1.setToL1 hT) f‖ ≤ C * ‖f‖

full_name: MeasureTheory.L1.norm_setToL1_le_mul_norm'
code: theorem norm_setToL1_le_mul_norm' (hT : DominatedFinMeasAdditive μ T C) (f : α →₁[μ] E) :
    ‖setToL1 hT f‖ ≤ max C 0 * ‖f‖ 
goal: ‖(MeasureTheory.L1.setToL1 hT) f‖ ≤ max C 0 * ‖f‖

full_name: MeasureTheory.L1.norm_setToL1_le
code: theorem norm_setToL1_le (hT : DominatedFinMeasAdditive μ T C) (hC : 0 ≤ C) : ‖setToL1 hT‖ ≤ C 
goal: ‖MeasureTheory.L1.setToL1 hT‖ ≤ C

full_name: MeasureTheory.L1.norm_setToL1_le'
code: theorem norm_setToL1_le' (hT : DominatedFinMeasAdditive μ T C) : ‖setToL1 hT‖ ≤ max C 0 
goal: ‖MeasureTheory.L1.setToL1 hT‖ ≤ max C 0

full_name: MeasureTheory.L1.setToL1_lipschitz
code: theorem setToL1_lipschitz (hT : DominatedFinMeasAdditive μ T C) :
    LipschitzWith (Real.toNNReal C) (setToL1 hT) 
goal: LipschitzWith C.toNNReal ⇑(MeasureTheory.L1.setToL1 hT)

full_name: MeasureTheory.L1.tendsto_setToL1
code: /-- If `fs i → f` in `L1`, then `setToL1 hT (fs i) → setToL1 hT f`. -/
theorem tendsto_setToL1 (hT : DominatedFinMeasAdditive μ T C) (f : α →₁[μ] E) {ι}
    (fs : ι → α →₁[μ] E) {l : Filter ι} (hfs : Tendsto fs l (𝓝 f)) :
    Tendsto (fun i => setToL1 hT (fs i)) l (𝓝 <| setToL1 hT f) 
goal: Filter.Tendsto (fun i => (MeasureTheory.L1.setToL1 hT) (fs i)) l (𝓝 ((MeasureTheory.L1.setToL1 hT) f))

full_name: MeasureTheory.setToFun
code: /-- Extend `T : Set α → E →L[ℝ] F` to `(α → E) → F` (for integrable functions `α → E`). We set it to
0 if the function is not integrable. -/
def setToFun (hT : DominatedFinMeasAdditive μ T C) (f : α → E) : F 
goal: F

full_name: MeasureTheory.setToFun_eq
code: theorem setToFun_eq (hT : DominatedFinMeasAdditive μ T C) (hf : Integrable f μ) :
    setToFun μ T hT f = L1.setToL1 hT (hf.toL1 f) 
goal: MeasureTheory.setToFun μ T hT f = (MeasureTheory.L1.setToL1 hT) (MeasureTheory.Integrable.toL1 f hf)

full_name: MeasureTheory.L1.setToFun_eq_setToL1
code: theorem L1.setToFun_eq_setToL1 (hT : DominatedFinMeasAdditive μ T C) (f : α →₁[μ] E) :
    setToFun μ T hT f = L1.setToL1 hT f 
goal: MeasureTheory.setToFun μ T hT ↑↑f = (MeasureTheory.L1.setToL1 hT) f

full_name: MeasureTheory.setToFun_undef
code: theorem setToFun_undef (hT : DominatedFinMeasAdditive μ T C) (hf : ¬Integrable f μ) :
    setToFun μ T hT f = 0 
goal: MeasureTheory.setToFun μ T hT f = 0

full_name: MeasureTheory.setToFun_non_aEStronglyMeasurable
code: theorem setToFun_non_aEStronglyMeasurable (hT : DominatedFinMeasAdditive μ T C)
    (hf : ¬AEStronglyMeasurable f μ) : setToFun μ T hT f = 0 
goal: MeasureTheory.setToFun μ T hT f = 0

full_name: MeasureTheory.setToFun_congr_left
code: theorem setToFun_congr_left (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (h : T = T') (f : α → E) :
    setToFun μ T hT f = setToFun μ T' hT' f 
goal: MeasureTheory.setToFun μ T hT f = MeasureTheory.setToFun μ T' hT' f

full_name: MeasureTheory.setToFun_congr_left'
code: theorem setToFun_congr_left' (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (h : ∀ s, MeasurableSet s → μ s < ∞ → T s = T' s)
    (f : α → E) : setToFun μ T hT f = setToFun μ T' hT' f 
goal: MeasureTheory.setToFun μ T hT f = MeasureTheory.setToFun μ T' hT' f

full_name: MeasureTheory.setToFun_add_left
code: theorem setToFun_add_left (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (f : α → E) :
    setToFun μ (T + T') (hT.add hT') f = setToFun μ T hT f + setToFun μ T' hT' f 
goal: MeasureTheory.setToFun μ (T + T') ⋯ f = MeasureTheory.setToFun μ T hT f + MeasureTheory.setToFun μ T' hT' f

full_name: MeasureTheory.setToFun_add_left'
code: theorem setToFun_add_left' (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (hT'' : DominatedFinMeasAdditive μ T'' C'')
    (h_add : ∀ s, MeasurableSet s → μ s < ∞ → T'' s = T s + T' s) (f : α → E) :
    setToFun μ T'' hT'' f = setToFun μ T hT f + setToFun μ T' hT' f 
goal: MeasureTheory.setToFun μ T'' hT'' f = MeasureTheory.setToFun μ T hT f + MeasureTheory.setToFun μ T' hT' f

full_name: MeasureTheory.setToFun_smul_left
code: theorem setToFun_smul_left (hT : DominatedFinMeasAdditive μ T C) (c : ℝ) (f : α → E) :
    setToFun μ (fun s => c • T s) (hT.smul c) f = c • setToFun μ T hT f 
goal: MeasureTheory.setToFun μ (fun s => c • T s) ⋯ f = c • MeasureTheory.setToFun μ T hT f

full_name: MeasureTheory.setToFun_smul_left'
code: theorem setToFun_smul_left' (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (c : ℝ)
    (h_smul : ∀ s, MeasurableSet s → μ s < ∞ → T' s = c • T s) (f : α → E) :
    setToFun μ T' hT' f = c • setToFun μ T hT f 
goal: MeasureTheory.setToFun μ T' hT' f = c • MeasureTheory.setToFun μ T hT f

full_name: MeasureTheory.setToFun_zero
code: @[simp]
theorem setToFun_zero (hT : DominatedFinMeasAdditive μ T C) : setToFun μ T hT (0 : α → E) = 0 
goal: MeasureTheory.setToFun μ T hT 0 = 0

full_name: MeasureTheory.setToFun_zero_left
code: @[simp]
theorem setToFun_zero_left {hT : DominatedFinMeasAdditive μ (0 : Set α → E →L[ℝ] F) C} :
    setToFun μ 0 hT f = 0 
goal: MeasureTheory.setToFun μ 0 hT f = 0

full_name: MeasureTheory.setToFun_zero_left'
code: theorem setToFun_zero_left' (hT : DominatedFinMeasAdditive μ T C)
    (h_zero : ∀ s, MeasurableSet s → μ s < ∞ → T s = 0) : setToFun μ T hT f = 0 
goal: MeasureTheory.setToFun μ T hT f = 0

full_name: MeasureTheory.setToFun_add
code: theorem setToFun_add (hT : DominatedFinMeasAdditive μ T C) (hf : Integrable f μ)
    (hg : Integrable g μ) : setToFun μ T hT (f + g) = setToFun μ T hT f + setToFun μ T hT g 
goal: MeasureTheory.setToFun μ T hT (f + g) = MeasureTheory.setToFun μ T hT f + MeasureTheory.setToFun μ T hT g

full_name: MeasureTheory.setToFun_finset_sum'
code: theorem setToFun_finset_sum' (hT : DominatedFinMeasAdditive μ T C) {ι} (s : Finset ι)
    {f : ι → α → E} (hf : ∀ i ∈ s, Integrable (f i) μ) :
    setToFun μ T hT (∑ i ∈ s, f i) = ∑ i ∈ s, setToFun μ T hT (f i) 
goal: MeasureTheory.setToFun μ T hT (∑ i ∈ s, f i) = ∑ i ∈ s, MeasureTheory.setToFun μ T hT (f i)

full_name: MeasureTheory.setToFun_finset_sum
code: theorem setToFun_finset_sum (hT : DominatedFinMeasAdditive μ T C) {ι} (s : Finset ι) {f : ι → α → E}
    (hf : ∀ i ∈ s, Integrable (f i) μ) :
    (setToFun μ T hT fun a => ∑ i ∈ s, f i a) = ∑ i ∈ s, setToFun μ T hT (f i) 
goal: (MeasureTheory.setToFun μ T hT fun a => ∑ i ∈ s, f i a) = ∑ i ∈ s, MeasureTheory.setToFun μ T hT (f i)

full_name: MeasureTheory.setToFun_neg
code: theorem setToFun_neg (hT : DominatedFinMeasAdditive μ T C) (f : α → E) :
    setToFun μ T hT (-f) = -setToFun μ T hT f 
goal: MeasureTheory.setToFun μ T hT (-f) = -MeasureTheory.setToFun μ T hT f

full_name: MeasureTheory.setToFun_sub
code: theorem setToFun_sub (hT : DominatedFinMeasAdditive μ T C) (hf : Integrable f μ)
    (hg : Integrable g μ) : setToFun μ T hT (f - g) = setToFun μ T hT f - setToFun μ T hT g 
goal: MeasureTheory.setToFun μ T hT (f - g) = MeasureTheory.setToFun μ T hT f - MeasureTheory.setToFun μ T hT g

full_name: MeasureTheory.setToFun_smul
code: theorem setToFun_smul [NontriviallyNormedField 𝕜] [NormedSpace 𝕜 E] [NormedSpace 𝕜 F]
    (hT : DominatedFinMeasAdditive μ T C) (h_smul : ∀ c : 𝕜, ∀ s x, T s (c • x) = c • T s x) (c : 𝕜)
    (f : α → E) : setToFun μ T hT (c • f) = c • setToFun μ T hT f 
goal: MeasureTheory.setToFun μ T hT (c • f) = c • MeasureTheory.setToFun μ T hT f

full_name: MeasureTheory.setToFun_congr_ae
code: theorem setToFun_congr_ae (hT : DominatedFinMeasAdditive μ T C) (h : f =ᵐ[μ] g) :
    setToFun μ T hT f = setToFun μ T hT g 
goal: MeasureTheory.setToFun μ T hT f = MeasureTheory.setToFun μ T hT g

full_name: MeasureTheory.setToFun_measure_zero
code: theorem setToFun_measure_zero (hT : DominatedFinMeasAdditive μ T C) (h : μ = 0) :
    setToFun μ T hT f = 0 
goal: MeasureTheory.setToFun μ T hT f = 0

full_name: MeasureTheory.setToFun_measure_zero'
code: theorem setToFun_measure_zero' (hT : DominatedFinMeasAdditive μ T C)
    (h : ∀ s, MeasurableSet s → μ s < ∞ → μ s = 0) : setToFun μ T hT f = 0 
goal: MeasureTheory.setToFun μ T hT f = 0

full_name: MeasureTheory.setToFun_toL1
code: theorem setToFun_toL1 (hT : DominatedFinMeasAdditive μ T C) (hf : Integrable f μ) :
    setToFun μ T hT (hf.toL1 f) = setToFun μ T hT f 
goal: MeasureTheory.setToFun μ T hT ↑↑(MeasureTheory.Integrable.toL1 f hf) = MeasureTheory.setToFun μ T hT f

full_name: MeasureTheory.setToFun_indicator_const
code: theorem setToFun_indicator_const (hT : DominatedFinMeasAdditive μ T C) {s : Set α}
    (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (x : E) :
    setToFun μ T hT (s.indicator fun _ => x) = T s x 
goal: MeasureTheory.setToFun μ T hT (s.indicator fun x_1 => x) = (T s) x

full_name: MeasureTheory.setToFun_const
code: theorem setToFun_const [IsFiniteMeasure μ] (hT : DominatedFinMeasAdditive μ T C) (x : E) :
    (setToFun μ T hT fun _ => x) = T univ x 
goal: (MeasureTheory.setToFun μ T hT fun x_1 => x) = (T Set.univ) x

full_name: MeasureTheory.setToFun_mono_left'
code: theorem setToFun_mono_left' {T T' : Set α → E →L[ℝ] G''} {C C' : ℝ}
    (hT : DominatedFinMeasAdditive μ T C) (hT' : DominatedFinMeasAdditive μ T' C')
    (hTT' : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, T s x ≤ T' s x) (f : α → E) :
    setToFun μ T hT f ≤ setToFun μ T' hT' f 
goal: MeasureTheory.setToFun μ T hT f ≤ MeasureTheory.setToFun μ T' hT' f

full_name: MeasureTheory.setToFun_mono_left
code: theorem setToFun_mono_left {T T' : Set α → E →L[ℝ] G''} {C C' : ℝ}
    (hT : DominatedFinMeasAdditive μ T C) (hT' : DominatedFinMeasAdditive μ T' C')
    (hTT' : ∀ s x, T s x ≤ T' s x) (f : α →₁[μ] E) : setToFun μ T hT f ≤ setToFun μ T' hT' f 
goal: MeasureTheory.setToFun μ T hT ↑↑f ≤ MeasureTheory.setToFun μ T' hT' ↑↑f

full_name: MeasureTheory.setToFun_nonneg
code: theorem setToFun_nonneg {T : Set α → G' →L[ℝ] G''} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f : α → G'}
    (hf : 0 ≤ᵐ[μ] f) : 0 ≤ setToFun μ T hT f 
goal: 0 ≤ MeasureTheory.setToFun μ T hT f

full_name: MeasureTheory.setToFun_mono
code: theorem setToFun_mono {T : Set α → G' →L[ℝ] G''} {C : ℝ} (hT : DominatedFinMeasAdditive μ T C)
    (hT_nonneg : ∀ s, MeasurableSet s → μ s < ∞ → ∀ x, 0 ≤ x → 0 ≤ T s x) {f g : α → G'}
    (hf : Integrable f μ) (hg : Integrable g μ) (hfg : f ≤ᵐ[μ] g) :
    setToFun μ T hT f ≤ setToFun μ T hT g 
goal: MeasureTheory.setToFun μ T hT f ≤ MeasureTheory.setToFun μ T hT g

full_name: MeasureTheory.continuous_setToFun
code: @[continuity]
theorem continuous_setToFun (hT : DominatedFinMeasAdditive μ T C) :
    Continuous fun f : α →₁[μ] E => setToFun μ T hT f 
goal: Continuous fun f => MeasureTheory.setToFun μ T hT ↑↑f

full_name: MeasureTheory.tendsto_setToFun_of_L1
code: /-- If `F i → f` in `L1`, then `setToFun μ T hT (F i) → setToFun μ T hT f`. -/
theorem tendsto_setToFun_of_L1 (hT : DominatedFinMeasAdditive μ T C) {ι} (f : α → E)
    (hfi : Integrable f μ) {fs : ι → α → E} {l : Filter ι} (hfsi : ∀ᶠ i in l, Integrable (fs i) μ)
    (hfs : Tendsto (fun i => ∫⁻ x, ‖fs i x - f x‖₊ ∂μ) l (𝓝 0)) :
    Tendsto (fun i => setToFun μ T hT (fs i)) l (𝓝 <| setToFun μ T hT f) 
goal: Filter.Tendsto (fun i => MeasureTheory.setToFun μ T hT (fs i)) l (𝓝 (MeasureTheory.setToFun μ T hT f))

full_name: MeasureTheory.tendsto_setToFun_approxOn_of_measurable
code: theorem tendsto_setToFun_approxOn_of_measurable (hT : DominatedFinMeasAdditive μ T C)
    [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 => setToFun μ T hT (SimpleFunc.approxOn f hfm s y₀ h₀ n)) atTop
      (𝓝 <| setToFun μ T hT f) 
goal: Filter.Tendsto (fun n => MeasureTheory.setToFun μ T hT ↑(MeasureTheory.SimpleFunc.approxOn f hfm s y₀ h₀ n))
  Filter.atTop (𝓝 (MeasureTheory.setToFun μ T hT f))

full_name: MeasureTheory.tendsto_setToFun_approxOn_of_measurable_of_range_subset
code: theorem tendsto_setToFun_approxOn_of_measurable_of_range_subset
    (hT : DominatedFinMeasAdditive μ T C) [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 => setToFun μ T hT (SimpleFunc.approxOn f fmeas s 0 (hs <| by simp) n)) atTop
      (𝓝 <| setToFun μ T hT f) 
goal: Filter.Tendsto (fun n => MeasureTheory.setToFun μ T hT ↑(MeasureTheory.SimpleFunc.approxOn f fmeas s 0 ⋯ n))
  Filter.atTop (𝓝 (MeasureTheory.setToFun μ T hT f))

full_name: MeasureTheory.continuous_L1_toL1
code: /-- Auxiliary lemma for `setToFun_congr_measure`: the function sending `f : α →₁[μ] G` to
`f : α →₁[μ'] G` is continuous when `μ' ≤ c' • μ` for `c' ≠ ∞`. -/
theorem continuous_L1_toL1 {μ' : Measure α} (c' : ℝ≥0∞) (hc' : c' ≠ ∞) (hμ'_le : μ' ≤ c' • μ) :
    Continuous fun f : α →₁[μ] G =>
      (Integrable.of_measure_le_smul c' hc' hμ'_le (L1.integrable_coeFn f)).toL1 f 
goal: Continuous fun f => MeasureTheory.Integrable.toL1 ↑↑f ⋯

full_name: MeasureTheory.setToFun_congr_measure_of_integrable
code: theorem setToFun_congr_measure_of_integrable {μ' : Measure α} (c' : ℝ≥0∞) (hc' : c' ≠ ∞)
    (hμ'_le : μ' ≤ c' • μ) (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ' T C') (f : α → E) (hfμ : Integrable f μ) :
    setToFun μ T hT f = setToFun μ' T hT' f 
goal: MeasureTheory.setToFun μ T hT f = MeasureTheory.setToFun μ' T hT' f

full_name: MeasureTheory.setToFun_congr_measure
code: theorem setToFun_congr_measure {μ' : Measure α} (c c' : ℝ≥0∞) (hc : c ≠ ∞) (hc' : c' ≠ ∞)
    (hμ_le : μ ≤ c • μ') (hμ'_le : μ' ≤ c' • μ) (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ' T C') (f : α → E) :
    setToFun μ T hT f = setToFun μ' T hT' f 
goal: MeasureTheory.setToFun μ T hT f = MeasureTheory.setToFun μ' T hT' f

full_name: MeasureTheory.setToFun_congr_measure_of_add_right
code: theorem setToFun_congr_measure_of_add_right {μ' : Measure α}
    (hT_add : DominatedFinMeasAdditive (μ + μ') T C') (hT : DominatedFinMeasAdditive μ T C)
    (f : α → E) (hf : Integrable f (μ + μ')) :
    setToFun (μ + μ') T hT_add f = setToFun μ T hT f 
goal: MeasureTheory.setToFun (μ + μ') T hT_add f = MeasureTheory.setToFun μ T hT f

full_name: MeasureTheory.setToFun_congr_measure_of_add_left
code: theorem setToFun_congr_measure_of_add_left {μ' : Measure α}
    (hT_add : DominatedFinMeasAdditive (μ + μ') T C') (hT : DominatedFinMeasAdditive μ' T C)
    (f : α → E) (hf : Integrable f (μ + μ')) :
    setToFun (μ + μ') T hT_add f = setToFun μ' T hT f 
goal: MeasureTheory.setToFun (μ + μ') T hT_add f = MeasureTheory.setToFun μ' T hT f

full_name: MeasureTheory.setToFun_top_smul_measure
code: theorem setToFun_top_smul_measure (hT : DominatedFinMeasAdditive (∞ • μ) T C) (f : α → E) :
    setToFun (∞ • μ) T hT f = 0 
goal: MeasureTheory.setToFun (⊤ • μ) T hT f = 0

full_name: MeasureTheory.setToFun_congr_smul_measure
code: theorem setToFun_congr_smul_measure (c : ℝ≥0∞) (hc_ne_top : c ≠ ∞)
    (hT : DominatedFinMeasAdditive μ T C) (hT_smul : DominatedFinMeasAdditive (c • μ) T C')
    (f : α → E) : setToFun μ T hT f = setToFun (c • μ) T hT_smul f 
goal: MeasureTheory.setToFun μ T hT f = MeasureTheory.setToFun (c • μ) T hT_smul f

full_name: MeasureTheory.norm_setToFun_le_mul_norm
code: theorem norm_setToFun_le_mul_norm (hT : DominatedFinMeasAdditive μ T C) (f : α →₁[μ] E)
    (hC : 0 ≤ C) : ‖setToFun μ T hT f‖ ≤ C * ‖f‖ 
goal: ‖MeasureTheory.setToFun μ T hT ↑↑f‖ ≤ C * ‖f‖

full_name: MeasureTheory.norm_setToFun_le_mul_norm'
code: theorem norm_setToFun_le_mul_norm' (hT : DominatedFinMeasAdditive μ T C) (f : α →₁[μ] E) :
    ‖setToFun μ T hT f‖ ≤ max C 0 * ‖f‖ 
goal: ‖MeasureTheory.setToFun μ T hT ↑↑f‖ ≤ max C 0 * ‖f‖

full_name: MeasureTheory.norm_setToFun_le
code: theorem norm_setToFun_le (hT : DominatedFinMeasAdditive μ T C) (hf : Integrable f μ) (hC : 0 ≤ C) :
    ‖setToFun μ T hT f‖ ≤ C * ‖hf.toL1 f‖ 
goal: ‖MeasureTheory.setToFun μ T hT f‖ ≤ C * ‖MeasureTheory.Integrable.toL1 f hf‖

full_name: MeasureTheory.norm_setToFun_le'
code: theorem norm_setToFun_le' (hT : DominatedFinMeasAdditive μ T C) (hf : Integrable f μ) :
    ‖setToFun μ T hT f‖ ≤ max C 0 * ‖hf.toL1 f‖ 
goal: ‖MeasureTheory.setToFun μ T hT f‖ ≤ max C 0 * ‖MeasureTheory.Integrable.toL1 f hf‖

full_name: MeasureTheory.tendsto_setToFun_of_dominated_convergence
code: /-- Lebesgue dominated convergence theorem provides sufficient conditions under which almost
  everywhere convergence of a sequence of functions implies the convergence of their image by
  `setToFun`.
  We could weaken the condition `bound_integrable` to require `HasFiniteIntegral bound μ` instead
  (i.e. not requiring that `bound` is measurable), but in all applications proving integrability
  is easier. -/
theorem tendsto_setToFun_of_dominated_convergence (hT : DominatedFinMeasAdditive μ T C)
    {fs : ℕ → α → E} {f : α → E} (bound : α → ℝ)
    (fs_measurable : ∀ n, AEStronglyMeasurable (fs n) μ) (bound_integrable : Integrable bound μ)
    (h_bound : ∀ n, ∀ᵐ a ∂μ, ‖fs n a‖ ≤ bound a)
    (h_lim : ∀ᵐ a ∂μ, Tendsto (fun n => fs n a) atTop (𝓝 (f a))) :
    Tendsto (fun n => setToFun μ T hT (fs n)) atTop (𝓝 <| setToFun μ T hT f) 
goal: Filter.Tendsto (fun n => MeasureTheory.setToFun μ T hT (fs n)) Filter.atTop (𝓝 (MeasureTheory.setToFun μ T hT f))

full_name: MeasureTheory.tendsto_setToFun_filter_of_dominated_convergence
code: /-- Lebesgue dominated convergence theorem for filters with a countable basis -/
theorem tendsto_setToFun_filter_of_dominated_convergence (hT : DominatedFinMeasAdditive μ T C) {ι}
    {l : Filter ι} [l.IsCountablyGenerated] {fs : ι → α → E} {f : α → E} (bound : α → ℝ)
    (hfs_meas : ∀ᶠ n in l, AEStronglyMeasurable (fs n) μ)
    (h_bound : ∀ᶠ n in l, ∀ᵐ a ∂μ, ‖fs n a‖ ≤ bound a) (bound_integrable : Integrable bound μ)
    (h_lim : ∀ᵐ a ∂μ, Tendsto (fun n => fs n a) l (𝓝 (f a))) :
    Tendsto (fun n => setToFun μ T hT (fs n)) l (𝓝 <| setToFun μ T hT f) 
goal: Filter.Tendsto (fun n => MeasureTheory.setToFun μ T hT (fs n)) l (𝓝 (MeasureTheory.setToFun μ T hT f))

full_name: MeasureTheory.continuousWithinAt_setToFun_of_dominated
code: theorem continuousWithinAt_setToFun_of_dominated (hT : DominatedFinMeasAdditive μ T C)
    {fs : X → α → E} {x₀ : X} {bound : α → ℝ} {s : Set X}
    (hfs_meas : ∀ᶠ x in 𝓝[s] x₀, AEStronglyMeasurable (fs x) μ)
    (h_bound : ∀ᶠ x in 𝓝[s] x₀, ∀ᵐ a ∂μ, ‖fs x a‖ ≤ bound a) (bound_integrable : Integrable bound μ)
    (h_cont : ∀ᵐ a ∂μ, ContinuousWithinAt (fun x => fs x a) s x₀) :
    ContinuousWithinAt (fun x => setToFun μ T hT (fs x)) s x₀ 
goal: ContinuousWithinAt (fun x => MeasureTheory.setToFun μ T hT (fs x)) s x₀

full_name: MeasureTheory.continuousAt_setToFun_of_dominated
code: theorem continuousAt_setToFun_of_dominated (hT : DominatedFinMeasAdditive μ T C) {fs : X → α → E}
    {x₀ : X} {bound : α → ℝ} (hfs_meas : ∀ᶠ x in 𝓝 x₀, AEStronglyMeasurable (fs x) μ)
    (h_bound : ∀ᶠ x in 𝓝 x₀, ∀ᵐ a ∂μ, ‖fs x a‖ ≤ bound a) (bound_integrable : Integrable bound μ)
    (h_cont : ∀ᵐ a ∂μ, ContinuousAt (fun x => fs x a) x₀) :
    ContinuousAt (fun x => setToFun μ T hT (fs x)) x₀ 
goal: ContinuousAt (fun x => MeasureTheory.setToFun μ T hT (fs x)) x₀

full_name: MeasureTheory.continuousOn_setToFun_of_dominated
code: theorem continuousOn_setToFun_of_dominated (hT : DominatedFinMeasAdditive μ T C) {fs : X → α → E}
    {bound : α → ℝ} {s : Set X} (hfs_meas : ∀ x ∈ s, AEStronglyMeasurable (fs x) μ)
    (h_bound : ∀ x ∈ s, ∀ᵐ a ∂μ, ‖fs x a‖ ≤ bound a) (bound_integrable : Integrable bound μ)
    (h_cont : ∀ᵐ a ∂μ, ContinuousOn (fun x => fs x a) s) :
    ContinuousOn (fun x => setToFun μ T hT (fs x)) s 
goal: ContinuousOn (fun x => MeasureTheory.setToFun μ T hT (fs x)) s

full_name: MeasureTheory.continuous_setToFun_of_dominated
code: theorem continuous_setToFun_of_dominated (hT : DominatedFinMeasAdditive μ T C) {fs : X → α → E}
    {bound : α → ℝ} (hfs_meas : ∀ x, AEStronglyMeasurable (fs x) μ)
    (h_bound : ∀ x, ∀ᵐ a ∂μ, ‖fs x a‖ ≤ bound a) (bound_integrable : Integrable bound μ)
    (h_cont : ∀ᵐ a ∂μ, Continuous fun x => fs x a) : Continuous fun x => setToFun μ T hT (fs x) 
goal: Continuous fun x => MeasureTheory.setToFun μ T hT (fs x)