File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

full_name: MeasureTheory.FiniteMeasure
code: /-- Finite measures are defined as the subtype of measures that have the property of being finite
measures (i.e., their total mass is finite). -/
def _root_.MeasureTheory.FiniteMeasure (Ω : Type*) [MeasurableSpace Ω] : Type _ 
goal: Type u_2

full_name: MeasureTheory.FiniteMeasure.toMeasure
code: /-- Coercion from `MeasureTheory.FiniteMeasure Ω` to `MeasureTheory.Measure Ω`. -/
@[coe]
def toMeasure : FiniteMeasure Ω → Measure Ω 
goal: MeasureTheory.FiniteMeasure Ω → MeasureTheory.Measure Ω

full_name: MeasureTheory.FiniteMeasure.instCoe
code: /-- A finite measure can be interpreted as a measure. -/
instance instCoe : Coe (FiniteMeasure Ω) (MeasureTheory.Measure Ω) 
goal: Coe (MeasureTheory.FiniteMeasure Ω) (MeasureTheory.Measure Ω)

full_name: MeasureTheory.FiniteMeasure.isFiniteMeasure
code: instance isFiniteMeasure (μ : FiniteMeasure Ω) : IsFiniteMeasure (μ : Measure Ω) 
goal: MeasureTheory.IsFiniteMeasure ↑μ

full_name: MeasureTheory.FiniteMeasure.val_eq_toMeasure
code: @[simp]
theorem val_eq_toMeasure (ν : FiniteMeasure Ω) : ν.val = (ν : Measure Ω) 
goal: ↑ν = ↑ν

full_name: MeasureTheory.FiniteMeasure.toMeasure_injective
code: theorem toMeasure_injective : Function.Injective ((↑) : FiniteMeasure Ω → Measure Ω) 
goal: Function.Injective MeasureTheory.FiniteMeasure.toMeasure

full_name: MeasureTheory.FiniteMeasure.instFunLike
code: instance instFunLike : FunLike (FiniteMeasure Ω) (Set Ω) ℝ≥0 
goal: FunLike (MeasureTheory.FiniteMeasure Ω) (Set Ω) ℝ≥0

full_name: MeasureTheory.FiniteMeasure.coeFn_def
code: lemma coeFn_def (μ : FiniteMeasure Ω) : μ = fun s ↦ ((μ : Measure Ω) s).toNNReal 
goal: ⇑μ = fun s => (↑μ s).toNNReal

full_name: MeasureTheory.FiniteMeasure.coeFn_mk
code: lemma coeFn_mk (μ : Measure Ω) (hμ) :
    DFunLike.coe (F := FiniteMeasure Ω) ⟨μ, hμ⟩ = fun s ↦ (μ s).toNNReal 
goal: ⇑⟨μ, hμ⟩ = fun s => (μ s).toNNReal

full_name: MeasureTheory.FiniteMeasure.mk_apply
code: @[simp, norm_cast]
lemma mk_apply (μ : Measure Ω) (hμ) (s : Set Ω) :
    DFunLike.coe (F := FiniteMeasure Ω) ⟨μ, hμ⟩ s = (μ s).toNNReal 
goal: ⟨μ, hμ⟩ s = (μ s).toNNReal

full_name: MeasureTheory.FiniteMeasure.ennreal_coeFn_eq_coeFn_toMeasure
code: @[simp]
theorem ennreal_coeFn_eq_coeFn_toMeasure (ν : FiniteMeasure Ω) (s : Set Ω) :
    (ν s : ℝ≥0∞) = (ν : Measure Ω) s 
goal: ↑(ν s) = ↑ν s

full_name: MeasureTheory.FiniteMeasure.apply_mono
code: theorem apply_mono (μ : FiniteMeasure Ω) {s₁ s₂ : Set Ω} (h : s₁ ⊆ s₂) : μ s₁ ≤ μ s₂ 
goal: μ s₁ ≤ μ s₂

full_name: MeasureTheory.FiniteMeasure.mass
code: /-- The (total) mass of a finite measure `μ` is `μ univ`, i.e., the cast to `NNReal` of
`(μ : measure Ω) univ`. -/
def mass (μ : FiniteMeasure Ω) : ℝ≥0 
goal: ℝ≥0

full_name: MeasureTheory.FiniteMeasure.apply_le_mass
code: @[simp] theorem apply_le_mass (μ : FiniteMeasure Ω) (s : Set Ω) : μ s ≤ μ.mass 
goal: μ s ≤ μ.mass

full_name: MeasureTheory.FiniteMeasure.ennreal_mass
code: @[simp]
theorem ennreal_mass {μ : FiniteMeasure Ω} : (μ.mass : ℝ≥0∞) = (μ : Measure Ω) univ 
goal: ↑μ.mass = ↑μ Set.univ

full_name: MeasureTheory.FiniteMeasure.instZero
code: instance instZero : Zero (FiniteMeasure Ω) 
goal: Zero (MeasureTheory.FiniteMeasure Ω)

full_name: MeasureTheory.FiniteMeasure.coeFn_zero
code: @[simp, norm_cast] lemma coeFn_zero : ⇑(0 : FiniteMeasure Ω) = 0 
goal: ⇑0 = 0

full_name: MeasureTheory.FiniteMeasure.zero_mass
code: @[simp]
theorem zero_mass : (0 : FiniteMeasure Ω).mass = 0 
goal: MeasureTheory.FiniteMeasure.mass 0 = 0

full_name: MeasureTheory.FiniteMeasure.mass_zero_iff
code: @[simp]
theorem mass_zero_iff (μ : FiniteMeasure Ω) : μ.mass = 0 ↔ μ = 0 
goal: μ.mass = 0 ↔ μ = 0

full_name: MeasureTheory.FiniteMeasure.mass_nonzero_iff
code: theorem mass_nonzero_iff (μ : FiniteMeasure Ω) : μ.mass ≠ 0 ↔ μ ≠ 0 
goal: μ.mass ≠ 0 ↔ μ ≠ 0

full_name: MeasureTheory.FiniteMeasure.eq_of_forall_toMeasure_apply_eq
code: @[ext]
theorem eq_of_forall_toMeasure_apply_eq (μ ν : FiniteMeasure Ω)
    (h : ∀ s : Set Ω, MeasurableSet s → (μ : Measure Ω) s = (ν : Measure Ω) s) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.FiniteMeasure.eq_of_forall_apply_eq
code: theorem eq_of_forall_apply_eq (μ ν : FiniteMeasure Ω)
    (h : ∀ s : Set Ω, MeasurableSet s → μ s = ν s) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.FiniteMeasure.instInhabited
code: instance instInhabited : Inhabited (FiniteMeasure Ω) 
goal: Inhabited (MeasureTheory.FiniteMeasure Ω)

full_name: MeasureTheory.FiniteMeasure.instAdd
code: instance instAdd : Add (FiniteMeasure Ω) 
goal: Add (MeasureTheory.FiniteMeasure Ω)

full_name: MeasureTheory.FiniteMeasure.instSMul
code: instance instSMul : SMul R (FiniteMeasure Ω) 
goal: SMul R (MeasureTheory.FiniteMeasure Ω)

full_name: MeasureTheory.FiniteMeasure.toMeasure_zero
code: @[simp, norm_cast]
theorem toMeasure_zero : ((↑) : FiniteMeasure Ω → Measure Ω) 0 = 0 
goal: ↑0 = 0

full_name: MeasureTheory.FiniteMeasure.toMeasure_add
code: @[norm_cast]
theorem toMeasure_add (μ ν : FiniteMeasure Ω) : ↑(μ + ν) = (↑μ + ↑ν : Measure Ω) 
goal: ↑(μ + ν) = ↑μ + ↑ν

full_name: MeasureTheory.FiniteMeasure.toMeasure_smul
code: @[simp, norm_cast]
theorem toMeasure_smul (c : R) (μ : FiniteMeasure Ω) : ↑(c • μ) = c • (μ : Measure Ω) 
goal: ↑(c • μ) = c • ↑μ

full_name: MeasureTheory.FiniteMeasure.coeFn_add
code: @[simp, norm_cast]
theorem coeFn_add (μ ν : FiniteMeasure Ω) : (⇑(μ + ν) : Set Ω → ℝ≥0) = (⇑μ + ⇑ν : Set Ω → ℝ≥0) 
goal: ⇑(μ + ν) = ⇑μ + ⇑ν

full_name: MeasureTheory.FiniteMeasure.coeFn_smul
code: @[simp, norm_cast]
theorem coeFn_smul [IsScalarTower R ℝ≥0 ℝ≥0] (c : R) (μ : FiniteMeasure Ω) :
    (⇑(c • μ) : Set Ω → ℝ≥0) = c • (⇑μ : Set Ω → ℝ≥0) 
goal: ⇑(c • μ) = c • ⇑μ

full_name: MeasureTheory.FiniteMeasure.instAddCommMonoid
code: instance instAddCommMonoid : AddCommMonoid (FiniteMeasure Ω) 
goal: AddCommMonoid (MeasureTheory.FiniteMeasure Ω)

full_name: MeasureTheory.FiniteMeasure.toMeasureAddMonoidHom_apply
code: /-- Coercion is an `AddMonoidHom`. -/
@[simps]
def toMeasureAddMonoidHom : FiniteMeasure Ω →+ Measure Ω 
goal: ∀ (a : MeasureTheory.FiniteMeasure Ω), MeasureTheory.FiniteMeasure.toMeasureAddMonoidHom a = ↑a

full_name: MeasureTheory.FiniteMeasure.toMeasureAddMonoidHom
code: /-- Coercion is an `AddMonoidHom`. -/
@[simps]
def toMeasureAddMonoidHom : FiniteMeasure Ω →+ Measure Ω 
goal: MeasureTheory.FiniteMeasure Ω →+ MeasureTheory.Measure Ω

full_name: MeasureTheory.FiniteMeasure.instModuleNNReal
code: instance {Ω : Type*} [MeasurableSpace Ω] : Module ℝ≥0 (FiniteMeasure Ω) 
goal: Module ℝ≥0 (MeasureTheory.FiniteMeasure Ω)

full_name: MeasureTheory.FiniteMeasure.smul_apply
code: @[simp]
theorem smul_apply [IsScalarTower R ℝ≥0 ℝ≥0] (c : R) (μ : FiniteMeasure Ω) (s : Set Ω) :
    (c • μ) s = c • μ s 
goal: (c • μ) s = c • μ s

full_name: MeasureTheory.FiniteMeasure.restrict
code: /-- Restrict a finite measure μ to a set A. -/
def restrict (μ : FiniteMeasure Ω) (A : Set Ω) : FiniteMeasure Ω 
goal: MeasureTheory.FiniteMeasure Ω

full_name: MeasureTheory.FiniteMeasure.restrict_measure_eq
code: theorem restrict_measure_eq (μ : FiniteMeasure Ω) (A : Set Ω) :
    (μ.restrict A : Measure Ω) = (μ : Measure Ω).restrict A 
goal: ↑(μ.restrict A) = (↑μ).restrict A

full_name: MeasureTheory.FiniteMeasure.restrict_apply_measure
code: theorem restrict_apply_measure (μ : FiniteMeasure Ω) (A : Set Ω) {s : Set Ω}
    (s_mble : MeasurableSet s) : (μ.restrict A : Measure Ω) s = (μ : Measure Ω) (s ∩ A) 
goal: ↑(μ.restrict A) s = ↑μ (s ∩ A)

full_name: MeasureTheory.FiniteMeasure.restrict_apply
code: theorem restrict_apply (μ : FiniteMeasure Ω) (A : Set Ω) {s : Set Ω} (s_mble : MeasurableSet s) :
    (μ.restrict A) s = μ (s ∩ A) 
goal: (μ.restrict A) s = μ (s ∩ A)

full_name: MeasureTheory.FiniteMeasure.restrict_mass
code: theorem restrict_mass (μ : FiniteMeasure Ω) (A : Set Ω) : (μ.restrict A).mass = μ A 
goal: (μ.restrict A).mass = μ A

full_name: MeasureTheory.FiniteMeasure.restrict_eq_zero_iff
code: theorem restrict_eq_zero_iff (μ : FiniteMeasure Ω) (A : Set Ω) : μ.restrict A = 0 ↔ μ A = 0 
goal: μ.restrict A = 0 ↔ μ A = 0

full_name: MeasureTheory.FiniteMeasure.restrict_nonzero_iff
code: theorem restrict_nonzero_iff (μ : FiniteMeasure Ω) (A : Set Ω) : μ.restrict A ≠ 0 ↔ μ A ≠ 0 
goal: μ.restrict A ≠ 0 ↔ μ A ≠ 0

full_name: MeasureTheory.FiniteMeasure.ext_of_forall_lintegral_eq
code: /-- Two finite Borel measures are equal if the integrals of all bounded continuous functions with
respect to both agree. -/
theorem ext_of_forall_lintegral_eq [HasOuterApproxClosed Ω] [BorelSpace Ω]
    {μ ν : FiniteMeasure Ω} (h : ∀ (f : Ω →ᵇ ℝ≥0), ∫⁻ x, f x ∂μ = ∫⁻ x, f x ∂ν) :
    μ = ν 
goal: μ = ν

full_name: MeasureTheory.FiniteMeasure.testAgainstNN
code: /-- The pairing of a finite (Borel) measure `μ` with a nonnegative bounded continuous
function is obtained by (Lebesgue) integrating the (test) function against the measure.
This is `MeasureTheory.FiniteMeasure.testAgainstNN`. -/
def testAgainstNN (μ : FiniteMeasure Ω) (f : Ω →ᵇ ℝ≥0) : ℝ≥0 
goal: ℝ≥0

full_name: MeasureTheory.FiniteMeasure.testAgainstNN_coe_eq
code: @[simp]
theorem testAgainstNN_coe_eq {μ : FiniteMeasure Ω} {f : Ω →ᵇ ℝ≥0} :
    (μ.testAgainstNN f : ℝ≥0∞) = ∫⁻ ω, f ω ∂(μ : Measure Ω) 
goal: ↑(μ.testAgainstNN f) = ∫⁻ (ω : Ω), ↑(f ω) ∂↑μ

full_name: MeasureTheory.FiniteMeasure.testAgainstNN_const
code: theorem testAgainstNN_const (μ : FiniteMeasure Ω) (c : ℝ≥0) :
    μ.testAgainstNN (BoundedContinuousFunction.const Ω c) = c * μ.mass 
goal: μ.testAgainstNN (BoundedContinuousFunction.const Ω c) = c * μ.mass

full_name: MeasureTheory.FiniteMeasure.testAgainstNN_mono
code: theorem testAgainstNN_mono (μ : FiniteMeasure Ω) {f g : Ω →ᵇ ℝ≥0} (f_le_g : (f : Ω → ℝ≥0) ≤ g) :
    μ.testAgainstNN f ≤ μ.testAgainstNN g 
goal: μ.testAgainstNN f ≤ μ.testAgainstNN g

full_name: MeasureTheory.FiniteMeasure.testAgainstNN_zero
code: @[simp]
theorem testAgainstNN_zero (μ : FiniteMeasure Ω) : μ.testAgainstNN 0 = 0 
goal: μ.testAgainstNN 0 = 0

full_name: MeasureTheory.FiniteMeasure.testAgainstNN_one
code: @[simp]
theorem testAgainstNN_one (μ : FiniteMeasure Ω) : μ.testAgainstNN 1 = μ.mass 
goal: μ.testAgainstNN 1 = μ.mass

full_name: MeasureTheory.FiniteMeasure.zero_testAgainstNN_apply
code: @[simp]
theorem zero_testAgainstNN_apply (f : Ω →ᵇ ℝ≥0) : (0 : FiniteMeasure Ω).testAgainstNN f = 0 
goal: MeasureTheory.FiniteMeasure.testAgainstNN 0 f = 0

full_name: MeasureTheory.FiniteMeasure.zero_testAgainstNN
code: theorem zero_testAgainstNN : (0 : FiniteMeasure Ω).testAgainstNN = 0 
goal: MeasureTheory.FiniteMeasure.testAgainstNN 0 = 0

full_name: MeasureTheory.FiniteMeasure.smul_testAgainstNN_apply
code: @[simp]
theorem smul_testAgainstNN_apply (c : ℝ≥0) (μ : FiniteMeasure Ω) (f : Ω →ᵇ ℝ≥0) :
    (c • μ).testAgainstNN f = c • μ.testAgainstNN f 
goal: (c • μ).testAgainstNN f = c • μ.testAgainstNN f

full_name: MeasureTheory.FiniteMeasure.testAgainstNN_add
code: theorem testAgainstNN_add (μ : FiniteMeasure Ω) (f₁ f₂ : Ω →ᵇ ℝ≥0) :
    μ.testAgainstNN (f₁ + f₂) = μ.testAgainstNN f₁ + μ.testAgainstNN f₂ 
goal: μ.testAgainstNN (f₁ + f₂) = μ.testAgainstNN f₁ + μ.testAgainstNN f₂

full_name: MeasureTheory.FiniteMeasure.testAgainstNN_smul
code: theorem testAgainstNN_smul [IsScalarTower R ℝ≥0 ℝ≥0] [PseudoMetricSpace R] [Zero R]
    [BoundedSMul R ℝ≥0] (μ : FiniteMeasure Ω) (c : R) (f : Ω →ᵇ ℝ≥0) :
    μ.testAgainstNN (c • f) = c • μ.testAgainstNN f 
goal: μ.testAgainstNN (c • f) = c • μ.testAgainstNN f

full_name: MeasureTheory.FiniteMeasure.testAgainstNN_lipschitz_estimate
code: theorem testAgainstNN_lipschitz_estimate (μ : FiniteMeasure Ω) (f g : Ω →ᵇ ℝ≥0) :
    μ.testAgainstNN f ≤ μ.testAgainstNN g + nndist f g * μ.mass 
goal: μ.testAgainstNN f ≤ μ.testAgainstNN g + nndist f g * μ.mass

full_name: MeasureTheory.FiniteMeasure.testAgainstNN_lipschitz
code: theorem testAgainstNN_lipschitz (μ : FiniteMeasure Ω) :
    LipschitzWith μ.mass fun f : Ω →ᵇ ℝ≥0 => μ.testAgainstNN f 
goal: LipschitzWith μ.mass fun f => μ.testAgainstNN f

full_name: MeasureTheory.FiniteMeasure.toWeakDualBCNN
code: /-- Finite measures yield elements of the `WeakDual` of bounded continuous nonnegative
functions via `MeasureTheory.FiniteMeasure.testAgainstNN`, i.e., integration. -/
def toWeakDualBCNN (μ : FiniteMeasure Ω) : WeakDual ℝ≥0 (Ω →ᵇ ℝ≥0) 
goal: WeakDual ℝ≥0 (Ω →ᵇ ℝ≥0)

full_name: MeasureTheory.FiniteMeasure.coe_toWeakDualBCNN
code: @[simp]
theorem coe_toWeakDualBCNN (μ : FiniteMeasure Ω) : ⇑μ.toWeakDualBCNN = μ.testAgainstNN 
goal: ⇑μ.toWeakDualBCNN = μ.testAgainstNN

full_name: MeasureTheory.FiniteMeasure.toWeakDualBCNN_apply
code: @[simp]
theorem toWeakDualBCNN_apply (μ : FiniteMeasure Ω) (f : Ω →ᵇ ℝ≥0) :
    μ.toWeakDualBCNN f = (∫⁻ x, f x ∂(μ : Measure Ω)).toNNReal 
goal: μ.toWeakDualBCNN f = (∫⁻ (x : Ω), ↑(f x) ∂↑μ).toNNReal

full_name: MeasureTheory.FiniteMeasure.instTopologicalSpace
code: /-- The topology of weak convergence on `MeasureTheory.FiniteMeasure Ω` is inherited (induced)
from the weak-* topology on `WeakDual ℝ≥0 (Ω →ᵇ ℝ≥0)` via the function
`MeasureTheory.FiniteMeasure.toWeakDualBCNN`. -/
instance instTopologicalSpace : TopologicalSpace (FiniteMeasure Ω) 
goal: TopologicalSpace (MeasureTheory.FiniteMeasure Ω)

full_name: MeasureTheory.FiniteMeasure.toWeakDualBCNN_continuous
code: theorem toWeakDualBCNN_continuous : Continuous (@toWeakDualBCNN Ω _ _ _) 
goal: Continuous MeasureTheory.FiniteMeasure.toWeakDualBCNN

full_name: MeasureTheory.FiniteMeasure.continuous_testAgainstNN_eval
code: /-- Integration of (nonnegative bounded continuous) test functions against finite Borel measures
depends continuously on the measure. -/
theorem continuous_testAgainstNN_eval (f : Ω →ᵇ ℝ≥0) :
    Continuous fun μ : FiniteMeasure Ω => μ.testAgainstNN f 
goal: Continuous fun μ => μ.testAgainstNN f

full_name: MeasureTheory.FiniteMeasure.continuous_mass
code: /-- The total mass of a finite measure depends continuously on the measure. -/
theorem continuous_mass : Continuous fun μ : FiniteMeasure Ω => μ.mass 
goal: Continuous fun μ => μ.mass

full_name: Filter.Tendsto.mass
code: /-- Convergence of finite measures implies the convergence of their total masses. -/
theorem _root_.Filter.Tendsto.mass {γ : Type*} {F : Filter γ} {μs : γ → FiniteMeasure Ω}
    {μ : FiniteMeasure Ω} (h : Tendsto μs F (𝓝 μ)) : Tendsto (fun i => (μs i).mass) F (𝓝 μ.mass) 
goal: Filter.Tendsto (fun i => (μs i).mass) F (𝓝 μ.mass)

full_name: MeasureTheory.FiniteMeasure.tendsto_iff_weak_star_tendsto
code: theorem tendsto_iff_weak_star_tendsto {γ : Type*} {F : Filter γ} {μs : γ → FiniteMeasure Ω}
    {μ : FiniteMeasure Ω} :
    Tendsto μs F (𝓝 μ) ↔ Tendsto (fun i => (μs i).toWeakDualBCNN) F (𝓝 μ.toWeakDualBCNN) 
goal: Filter.Tendsto μs F (𝓝 μ) ↔ Filter.Tendsto (fun i => (μs i).toWeakDualBCNN) F (𝓝 μ.toWeakDualBCNN)

full_name: MeasureTheory.FiniteMeasure.tendsto_iff_forall_toWeakDualBCNN_tendsto
code: theorem tendsto_iff_forall_toWeakDualBCNN_tendsto {γ : Type*} {F : Filter γ}
    {μs : γ → FiniteMeasure Ω} {μ : FiniteMeasure Ω} :
    Tendsto μs F (𝓝 μ) ↔
      ∀ f : Ω →ᵇ ℝ≥0, Tendsto (fun i => (μs i).toWeakDualBCNN f) F (𝓝 (μ.toWeakDualBCNN f)) 
goal: Filter.Tendsto μs F (𝓝 μ) ↔
  ∀ (f : Ω →ᵇ ℝ≥0), Filter.Tendsto (fun i => (μs i).toWeakDualBCNN f) F (𝓝 (μ.toWeakDualBCNN f))

full_name: MeasureTheory.FiniteMeasure.tendsto_iff_forall_testAgainstNN_tendsto
code: theorem tendsto_iff_forall_testAgainstNN_tendsto {γ : Type*} {F : Filter γ}
    {μs : γ → FiniteMeasure Ω} {μ : FiniteMeasure Ω} :
    Tendsto μs F (𝓝 μ) ↔
      ∀ f : Ω →ᵇ ℝ≥0, Tendsto (fun i => (μs i).testAgainstNN f) F (𝓝 (μ.testAgainstNN f)) 
goal: Filter.Tendsto μs F (𝓝 μ) ↔ ∀ (f : Ω →ᵇ ℝ≥0), Filter.Tendsto (fun i => (μs i).testAgainstNN f) F (𝓝 (μ.testAgainstNN f))

full_name: MeasureTheory.FiniteMeasure.tendsto_zero_testAgainstNN_of_tendsto_zero_mass
code: /-- If the total masses of finite measures tend to zero, then the measures tend to
zero. This formulation concerns the associated functionals on bounded continuous
nonnegative test functions. See `MeasureTheory.FiniteMeasure.tendsto_zero_of_tendsto_zero_mass` for
a formulation stating the weak convergence of measures. -/
theorem tendsto_zero_testAgainstNN_of_tendsto_zero_mass {γ : Type*} {F : Filter γ}
    {μs : γ → FiniteMeasure Ω} (mass_lim : Tendsto (fun i => (μs i).mass) F (𝓝 0)) (f : Ω →ᵇ ℝ≥0) :
    Tendsto (fun i => (μs i).testAgainstNN f) F (𝓝 0) 
goal: Filter.Tendsto (fun i => (μs i).testAgainstNN f) F (𝓝 0)

full_name: MeasureTheory.FiniteMeasure.tendsto_zero_of_tendsto_zero_mass
code: /-- If the total masses of finite measures tend to zero, then the measures tend to zero. -/
theorem tendsto_zero_of_tendsto_zero_mass {γ : Type*} {F : Filter γ} {μs : γ → FiniteMeasure Ω}
    (mass_lim : Tendsto (fun i => (μs i).mass) F (𝓝 0)) : Tendsto μs F (𝓝 0) 
goal: Filter.Tendsto μs F (𝓝 0)

full_name: MeasureTheory.FiniteMeasure.tendsto_iff_forall_lintegral_tendsto
code: /-- A characterization of weak convergence in terms of integrals of bounded continuous
nonnegative functions. -/
theorem tendsto_iff_forall_lintegral_tendsto {γ : Type*} {F : Filter γ} {μs : γ → FiniteMeasure Ω}
    {μ : FiniteMeasure Ω} :
    Tendsto μs F (𝓝 μ) ↔
      ∀ f : Ω →ᵇ ℝ≥0,
        Tendsto (fun i => ∫⁻ x, f x ∂(μs i : Measure Ω)) F (𝓝 (∫⁻ x, f x ∂(μ : Measure Ω))) 
goal: Filter.Tendsto μs F (𝓝 μ) ↔
  ∀ (f : Ω →ᵇ ℝ≥0), Filter.Tendsto (fun i => ∫⁻ (x : Ω), ↑(f x) ∂↑(μs i)) F (𝓝 (∫⁻ (x : Ω), ↑(f x) ∂↑μ))

full_name: MeasureTheory.FiniteMeasure.injective_toWeakDualBCNN
code: /-- The mapping `toWeakDualBCNN` from finite Borel measures to the weak dual of `Ω →ᵇ ℝ≥0` is
injective, if in the underlying space `Ω`, indicator functions of closed sets have decreasing
approximations by sequences of continuous functions (in particular if `Ω` is pseudometrizable). -/
lemma injective_toWeakDualBCNN :
    Injective (toWeakDualBCNN : FiniteMeasure Ω → WeakDual ℝ≥0 (Ω →ᵇ ℝ≥0)) 
goal: Function.Injective MeasureTheory.FiniteMeasure.toWeakDualBCNN

full_name: MeasureTheory.FiniteMeasure.embedding_toWeakDualBCNN
code: lemma embedding_toWeakDualBCNN :
    Embedding (toWeakDualBCNN : FiniteMeasure Ω → WeakDual ℝ≥0 (Ω →ᵇ ℝ≥0)) 
goal: Embedding MeasureTheory.FiniteMeasure.toWeakDualBCNN

full_name: MeasureTheory.FiniteMeasure.t2Space
code: /-- On topological spaces where indicators of closed sets have decreasing approximating sequences of
continuous functions (`HasOuterApproxClosed`), the topology of weak convergence of finite Borel
measures is Hausdorff (`T2Space`). -/
instance t2Space : T2Space (FiniteMeasure Ω) 
goal: T2Space (MeasureTheory.FiniteMeasure Ω)

full_name: MeasureTheory.FiniteMeasure.tendsto_lintegral_nn_of_le_const
code: /-- A bounded convergence theorem for a finite measure:
If a sequence of bounded continuous non-negative functions are uniformly bounded by a constant
and tend pointwise to a limit, then their integrals (`MeasureTheory.lintegral`) against the finite
measure tend to the integral of the limit.

A related result with more general assumptions is
`MeasureTheory.tendsto_lintegral_nn_filter_of_le_const`.
-/
theorem tendsto_lintegral_nn_of_le_const (μ : FiniteMeasure Ω) {fs : ℕ → Ω →ᵇ ℝ≥0} {c : ℝ≥0}
    (fs_le_const : ∀ n ω, fs n ω ≤ c) {f : Ω → ℝ≥0}
    (fs_lim : ∀ ω, Tendsto (fun n => fs n ω) atTop (𝓝 (f ω))) :
    Tendsto (fun n => ∫⁻ ω, fs n ω ∂(μ : Measure Ω)) atTop (𝓝 (∫⁻ ω, f ω ∂(μ : Measure Ω))) 
goal: Filter.Tendsto (fun n => ∫⁻ (ω : Ω), ↑((fs n) ω) ∂↑μ) Filter.atTop (𝓝 (∫⁻ (ω : Ω), ↑(f ω) ∂↑μ))

full_name: MeasureTheory.FiniteMeasure.tendsto_testAgainstNN_filter_of_le_const
code: /-- A bounded convergence theorem for a finite measure:
If bounded continuous non-negative functions are uniformly bounded by a constant and tend to a
limit, then their integrals against the finite measure tend to the integral of the limit.
This formulation assumes:
 * the functions tend to a limit along a countably generated filter;
 * the limit is in the almost everywhere sense;
 * boundedness holds almost everywhere;
 * integration is the pairing against non-negative continuous test functions
   (`MeasureTheory.FiniteMeasure.testAgainstNN`).

A related result using `MeasureTheory.lintegral` for integration is
`MeasureTheory.FiniteMeasure.tendsto_lintegral_nn_filter_of_le_const`.
-/
theorem tendsto_testAgainstNN_filter_of_le_const {ι : Type*} {L : Filter ι}
    [L.IsCountablyGenerated] {μ : FiniteMeasure Ω} {fs : ι → Ω →ᵇ ℝ≥0} {c : ℝ≥0}
    (fs_le_const : ∀ᶠ i in L, ∀ᵐ ω : Ω ∂(μ : Measure Ω), fs i ω ≤ c) {f : Ω →ᵇ ℝ≥0}
    (fs_lim : ∀ᵐ ω : Ω ∂(μ : Measure Ω), Tendsto (fun i => fs i ω) L (𝓝 (f ω))) :
    Tendsto (fun i => μ.testAgainstNN (fs i)) L (𝓝 (μ.testAgainstNN f)) 
goal: Filter.Tendsto (fun i => μ.testAgainstNN (fs i)) L (𝓝 (μ.testAgainstNN f))

full_name: MeasureTheory.FiniteMeasure.tendsto_testAgainstNN_of_le_const
code: /-- A bounded convergence theorem for a finite measure:
If a sequence of bounded continuous non-negative functions are uniformly bounded by a constant and
tend pointwise to a limit, then their integrals (`MeasureTheory.FiniteMeasure.testAgainstNN`)
against the finite measure tend to the integral of the limit.

Related results:
 * `MeasureTheory.FiniteMeasure.tendsto_testAgainstNN_filter_of_le_const`:
   more general assumptions
 * `MeasureTheory.FiniteMeasure.tendsto_lintegral_nn_of_le_const`:
   using `MeasureTheory.lintegral` for integration.
-/
theorem tendsto_testAgainstNN_of_le_const {μ : FiniteMeasure Ω} {fs : ℕ → Ω →ᵇ ℝ≥0} {c : ℝ≥0}
    (fs_le_const : ∀ n ω, fs n ω ≤ c) {f : Ω →ᵇ ℝ≥0}
    (fs_lim : ∀ ω, Tendsto (fun n => fs n ω) atTop (𝓝 (f ω))) :
    Tendsto (fun n => μ.testAgainstNN (fs n)) atTop (𝓝 (μ.testAgainstNN f)) 
goal: Filter.Tendsto (fun n => μ.testAgainstNN (fs n)) Filter.atTop (𝓝 (μ.testAgainstNN f))

full_name: MeasureTheory.FiniteMeasure.tendsto_of_forall_integral_tendsto
code: theorem tendsto_of_forall_integral_tendsto {γ : Type*} {F : Filter γ} {μs : γ → FiniteMeasure Ω}
    {μ : FiniteMeasure Ω}
    (h :
      ∀ f : Ω →ᵇ ℝ,
        Tendsto (fun i => ∫ x, f x ∂(μs i : Measure Ω)) F (𝓝 (∫ x, f x ∂(μ : Measure Ω)))) :
    Tendsto μs F (𝓝 μ) 
goal: Filter.Tendsto μs F (𝓝 μ)

full_name: MeasureTheory.FiniteMeasure.tendsto_iff_forall_integral_tendsto
code: /-- A characterization of weak convergence in terms of integrals of bounded continuous
real-valued functions. -/
theorem tendsto_iff_forall_integral_tendsto {γ : Type*} {F : Filter γ} {μs : γ → FiniteMeasure Ω}
    {μ : FiniteMeasure Ω} :
    Tendsto μs F (𝓝 μ) ↔
      ∀ f : Ω →ᵇ ℝ,
        Tendsto (fun i => ∫ x, f x ∂(μs i : Measure Ω)) F (𝓝 (∫ x, f x ∂(μ : Measure Ω))) 
goal: Filter.Tendsto μs F (𝓝 μ) ↔ ∀ (f : Ω →ᵇ ℝ), Filter.Tendsto (fun i => ∫ (x : Ω), f x ∂↑(μs i)) F (𝓝 (∫ (x : Ω), f x ∂↑μ))

full_name: MeasureTheory.FiniteMeasure.map
code: /-- The push-forward of a finite measure by a function between measurable spaces. -/
noncomputable def map (ν : FiniteMeasure Ω) (f : Ω → Ω') : FiniteMeasure Ω' 
goal: MeasureTheory.FiniteMeasure Ω'

full_name: MeasureTheory.FiniteMeasure.toMeasure_map
code: @[simp] lemma toMeasure_map (ν : FiniteMeasure Ω) (f : Ω → Ω') :
    (ν.map f).toMeasure = ν.toMeasure.map f 
goal: ↑(ν.map f) = MeasureTheory.Measure.map f ↑ν

full_name: MeasureTheory.FiniteMeasure.map_apply'
code: /-- Note that this is an equality of elements of `ℝ≥0∞`. See also
`MeasureTheory.FiniteMeasure.map_apply` for the corresponding equality as elements of `ℝ≥0`. -/
lemma map_apply' (ν : FiniteMeasure Ω) {f : Ω → Ω'} (f_aemble : AEMeasurable f ν)
    {A : Set Ω'} (A_mble : MeasurableSet A) :
    (ν.map f : Measure Ω') A = (ν : Measure Ω) (f ⁻¹' A) 
goal: ↑(ν.map f) A = ↑ν (f ⁻¹' A)

full_name: MeasureTheory.FiniteMeasure.map_apply_of_aemeasurable
code: lemma map_apply_of_aemeasurable (ν : FiniteMeasure Ω) {f : Ω → Ω'} (f_aemble : AEMeasurable f ν)
    {A : Set Ω'} (A_mble : MeasurableSet A) :
    ν.map f A = ν (f ⁻¹' A) 
goal: (ν.map f) A = ν (f ⁻¹' A)

full_name: MeasureTheory.FiniteMeasure.map_apply
code: lemma map_apply (ν : FiniteMeasure Ω) {f : Ω → Ω'} (f_mble : Measurable f)
    {A : Set Ω'} (A_mble : MeasurableSet A) :
    ν.map f A = ν (f ⁻¹' A) 
goal: (ν.map f) A = ν (f ⁻¹' A)

full_name: MeasureTheory.FiniteMeasure.map_add
code: @[simp] lemma map_add {f : Ω → Ω'} (f_mble : Measurable f) (ν₁ ν₂ : FiniteMeasure Ω) :
    (ν₁ + ν₂).map f = ν₁.map f + ν₂.map f 
goal: (ν₁ + ν₂).map f = ν₁.map f + ν₂.map f

full_name: MeasureTheory.FiniteMeasure.map_smul
code: @[simp] lemma map_smul {f : Ω → Ω'} (c : ℝ≥0) (ν : FiniteMeasure Ω) :
    (c • ν).map f = c • (ν.map f) 
goal: (c • ν).map f = c • ν.map f

full_name: MeasureTheory.FiniteMeasure.mapHom
code: /-- The push-forward of a finite measure by a function between measurable spaces as a linear map. -/
noncomputable def mapHom {f : Ω → Ω'} (f_mble : Measurable f) :
    FiniteMeasure Ω →ₗ[ℝ≥0] FiniteMeasure Ω' 
goal: MeasureTheory.FiniteMeasure Ω →ₗ[ℝ≥0] MeasureTheory.FiniteMeasure Ω'

full_name: MeasureTheory.FiniteMeasure.tendsto_map_of_tendsto_of_continuous
code: /-- If `f : X → Y` is continuous and `Y` is equipped with the Borel sigma algebra, then
(weak) convergence of `FiniteMeasure`s on `X` implies (weak) convergence of the push-forwards
of these measures by `f`. -/
lemma tendsto_map_of_tendsto_of_continuous {ι : Type*} {L : Filter ι}
    (νs : ι → FiniteMeasure Ω) (ν : FiniteMeasure Ω) (lim : Tendsto νs L (𝓝 ν))
    {f : Ω → Ω'} (f_cont : Continuous f) :
    Tendsto (fun i ↦ (νs i).map f) L (𝓝 (ν.map f)) 
goal: Filter.Tendsto (fun i => (νs i).map f) L (𝓝 (ν.map f))

full_name: MeasureTheory.FiniteMeasure.continuous_map
code: /-- If `f : X → Y` is continuous and `Y` is equipped with the Borel sigma algebra, then
the push-forward of finite measures `f* : FiniteMeasure X → FiniteMeasure Y` is continuous
(in the topologies of weak convergence of measures). -/
lemma continuous_map {f : Ω → Ω'} (f_cont : Continuous f) :
    Continuous (fun ν ↦ FiniteMeasure.map ν f) 
goal: Continuous fun ν => ν.map f

full_name: MeasureTheory.FiniteMeasure.mapCLM
code: /-- The push-forward of a finite measure by a continuous function between Borel spaces as
a continuous linear map. -/
noncomputable def mapCLM {f : Ω → Ω'} (f_cont : Continuous f) :
    FiniteMeasure Ω →L[ℝ≥0] FiniteMeasure Ω' 
goal: MeasureTheory.FiniteMeasure Ω →L[ℝ≥0] MeasureTheory.FiniteMeasure Ω'