File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

full_name: MeasureTheory.ProbabilityMeasure
code: /-- Probability measures are defined as the subtype of measures that have the property of being
probability measures (i.e., their total mass is one). -/
def ProbabilityMeasure (Ω : Type*) [MeasurableSpace Ω] : Type _ 
goal: Type u_1

full_name: MeasureTheory.ProbabilityMeasure.instInhabited
code: instance [Inhabited Ω] : Inhabited (ProbabilityMeasure Ω) 
goal: Inhabited (MeasureTheory.ProbabilityMeasure Ω)

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

full_name: MeasureTheory.ProbabilityMeasure.instCoeMeasure
code: /-- A probability measure can be interpreted as a measure. -/
instance : Coe (ProbabilityMeasure Ω) (MeasureTheory.Measure Ω) 
goal: Coe (MeasureTheory.ProbabilityMeasure Ω) (MeasureTheory.Measure Ω)

full_name: MeasureTheory.ProbabilityMeasure.instIsProbabilityMeasureToMeasure
code: instance (μ : ProbabilityMeasure Ω) : IsProbabilityMeasure (μ : Measure Ω) 
goal: MeasureTheory.IsProbabilityMeasure ↑μ

full_name: MeasureTheory.ProbabilityMeasure.coe_mk
code: @[simp, norm_cast] lemma coe_mk (μ : Measure Ω) (hμ) : toMeasure ⟨μ, hμ⟩ = μ 
goal: ↑⟨μ, hμ⟩ = μ

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

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

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

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

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

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

full_name: MeasureTheory.ProbabilityMeasure.coeFn_univ
code: @[simp, norm_cast]
theorem coeFn_univ (ν : ProbabilityMeasure Ω) : ν univ = 1 
goal: ν Set.univ = 1

full_name: MeasureTheory.ProbabilityMeasure.coeFn_univ_ne_zero
code: theorem coeFn_univ_ne_zero (ν : ProbabilityMeasure Ω) : ν univ ≠ 0 
goal: ν Set.univ ≠ 0

full_name: MeasureTheory.ProbabilityMeasure.toFiniteMeasure
code: /-- A probability measure can be interpreted as a finite measure. -/
def toFiniteMeasure (μ : ProbabilityMeasure Ω) : FiniteMeasure Ω 
goal: MeasureTheory.FiniteMeasure Ω

full_name: MeasureTheory.ProbabilityMeasure.coeFn_toFiniteMeasure
code: @[simp] lemma coeFn_toFiniteMeasure (μ : ProbabilityMeasure Ω) : ⇑μ.toFiniteMeasure = μ 
goal: ⇑μ.toFiniteMeasure = ⇑μ

full_name: MeasureTheory.ProbabilityMeasure.toFiniteMeasure_apply
code: lemma toFiniteMeasure_apply (μ : ProbabilityMeasure Ω) (s : Set Ω) :
    μ.toFiniteMeasure s = μ s 
goal: μ.toFiniteMeasure s = μ s

full_name: MeasureTheory.ProbabilityMeasure.toMeasure_comp_toFiniteMeasure_eq_toMeasure
code: @[simp]
theorem toMeasure_comp_toFiniteMeasure_eq_toMeasure (ν : ProbabilityMeasure Ω) :
    (ν.toFiniteMeasure : Measure Ω) = (ν : Measure Ω) 
goal: ↑ν.toFiniteMeasure = ↑ν

full_name: MeasureTheory.ProbabilityMeasure.coeFn_comp_toFiniteMeasure_eq_coeFn
code: @[simp]
theorem coeFn_comp_toFiniteMeasure_eq_coeFn (ν : ProbabilityMeasure Ω) :
    (ν.toFiniteMeasure : Set Ω → ℝ≥0) = (ν : Set Ω → ℝ≥0) 
goal: ⇑ν.toFiniteMeasure = ⇑ν

full_name: MeasureTheory.ProbabilityMeasure.toFiniteMeasure_apply_eq_apply
code: @[simp]
theorem toFiniteMeasure_apply_eq_apply (ν : ProbabilityMeasure Ω) (s : Set Ω) :
    ν.toFiniteMeasure s = ν s 
goal: ν.toFiniteMeasure s = ν s

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

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

full_name: MeasureTheory.ProbabilityMeasure.apply_le_one
code: @[simp] theorem apply_le_one (μ : ProbabilityMeasure Ω) (s : Set Ω) : μ s ≤ 1 
goal: μ s ≤ 1

full_name: MeasureTheory.ProbabilityMeasure.nonempty
code: theorem nonempty (μ : ProbabilityMeasure Ω) : Nonempty Ω 
goal: Nonempty Ω

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

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

full_name: MeasureTheory.ProbabilityMeasure.mass_toFiniteMeasure
code: @[simp]
theorem mass_toFiniteMeasure (μ : ProbabilityMeasure Ω) : μ.toFiniteMeasure.mass = 1 
goal: μ.toFiniteMeasure.mass = 1

full_name: MeasureTheory.ProbabilityMeasure.toFiniteMeasure_nonzero
code: theorem toFiniteMeasure_nonzero (μ : ProbabilityMeasure Ω) : μ.toFiniteMeasure ≠ 0 
goal: μ.toFiniteMeasure ≠ 0

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

full_name: MeasureTheory.ProbabilityMeasure.instTopologicalSpace
code: /-- The topology of weak convergence on `MeasureTheory.ProbabilityMeasure Ω`. This is inherited
(induced) from the topology of weak convergence of finite measures via the inclusion
`MeasureTheory.ProbabilityMeasure.toFiniteMeasure`. -/
instance : TopologicalSpace (ProbabilityMeasure Ω) 
goal: TopologicalSpace (MeasureTheory.ProbabilityMeasure Ω)

full_name: MeasureTheory.ProbabilityMeasure.toFiniteMeasure_continuous
code: theorem toFiniteMeasure_continuous :
    Continuous (toFiniteMeasure : ProbabilityMeasure Ω → FiniteMeasure Ω) 
goal: Continuous MeasureTheory.ProbabilityMeasure.toFiniteMeasure

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

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

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

full_name: MeasureTheory.ProbabilityMeasure.toWeakDualBCNN_continuous
code: theorem toWeakDualBCNN_continuous : Continuous fun μ : ProbabilityMeasure Ω => μ.toWeakDualBCNN 
goal: Continuous fun μ => μ.toWeakDualBCNN

full_name: MeasureTheory.ProbabilityMeasure.continuous_testAgainstNN_eval
code: theorem continuous_testAgainstNN_eval (f : Ω →ᵇ ℝ≥0) :
    Continuous fun μ : ProbabilityMeasure Ω => μ.toFiniteMeasure.testAgainstNN f 
goal: Continuous fun μ => μ.toFiniteMeasure.testAgainstNN f

full_name: MeasureTheory.ProbabilityMeasure.toFiniteMeasure_embedding
code: theorem toFiniteMeasure_embedding (Ω : Type*) [MeasurableSpace Ω] [TopologicalSpace Ω]
    [OpensMeasurableSpace Ω] :
    Embedding (toFiniteMeasure : ProbabilityMeasure Ω → FiniteMeasure Ω) 
goal: Embedding MeasureTheory.ProbabilityMeasure.toFiniteMeasure

full_name: MeasureTheory.ProbabilityMeasure.tendsto_nhds_iff_toFiniteMeasure_tendsto_nhds
code: theorem tendsto_nhds_iff_toFiniteMeasure_tendsto_nhds {δ : Type*} (F : Filter δ)
    {μs : δ → ProbabilityMeasure Ω} {μ₀ : ProbabilityMeasure Ω} :
    Tendsto μs F (𝓝 μ₀) ↔ Tendsto (toFiniteMeasure ∘ μs) F (𝓝 μ₀.toFiniteMeasure) 
goal: Filter.Tendsto μs F (𝓝 μ₀) ↔
  Filter.Tendsto (MeasureTheory.ProbabilityMeasure.toFiniteMeasure ∘ μs) F (𝓝 μ₀.toFiniteMeasure)

full_name: MeasureTheory.ProbabilityMeasure.tendsto_iff_forall_lintegral_tendsto
code: /-- A characterization of weak convergence of probability measures by the condition that the
integrals of every continuous bounded nonnegative function converge to the integral of the function
against the limit measure. -/
theorem tendsto_iff_forall_lintegral_tendsto {γ : Type*} {F : Filter γ}
    {μs : γ → ProbabilityMeasure Ω} {μ : ProbabilityMeasure Ω} :
    Tendsto μs F (𝓝 μ) ↔
      ∀ f : Ω →ᵇ ℝ≥0,
        Tendsto (fun i => ∫⁻ ω, f ω ∂(μs i : Measure Ω)) F (𝓝 (∫⁻ ω, f ω ∂(μ : Measure Ω))) 
goal: Filter.Tendsto μs F (𝓝 μ) ↔
  ∀ (f : Ω →ᵇ ℝ≥0), Filter.Tendsto (fun i => ∫⁻ (ω : Ω), ↑(f ω) ∂↑(μs i)) F (𝓝 (∫⁻ (ω : Ω), ↑(f ω) ∂↑μ))

full_name: MeasureTheory.ProbabilityMeasure.tendsto_iff_forall_integral_tendsto
code: /-- The characterization of weak convergence of probability measures by the usual (defining)
condition that the integrals of every continuous bounded function converge to the integral of the
function against the limit measure. -/
theorem tendsto_iff_forall_integral_tendsto {γ : Type*} {F : Filter γ}
    {μs : γ → ProbabilityMeasure Ω} {μ : ProbabilityMeasure Ω} :
    Tendsto μs F (𝓝 μ) ↔
      ∀ f : Ω →ᵇ ℝ,
        Tendsto (fun i => ∫ ω, f ω ∂(μs i : Measure Ω)) F (𝓝 (∫ ω, f ω ∂(μ : Measure Ω))) 
goal: Filter.Tendsto μs F (𝓝 μ) ↔ ∀ (f : Ω →ᵇ ℝ), Filter.Tendsto (fun i => ∫ (ω : Ω), f ω ∂↑(μs i)) F (𝓝 (∫ (ω : Ω), f ω ∂↑μ))

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

full_name: MeasureTheory.FiniteMeasure.normalize
code: /-- Normalize a finite measure so that it becomes a probability measure, i.e., divide by the
total mass. -/
def normalize : ProbabilityMeasure Ω 
goal: MeasureTheory.ProbabilityMeasure Ω

full_name: MeasureTheory.FiniteMeasure.self_eq_mass_mul_normalize
code: @[simp]
theorem self_eq_mass_mul_normalize (s : Set Ω) : μ s = μ.mass * μ.normalize s 
goal: μ s = μ.mass * μ.normalize s

full_name: MeasureTheory.FiniteMeasure.self_eq_mass_smul_normalize
code: theorem self_eq_mass_smul_normalize : μ = μ.mass • μ.normalize.toFiniteMeasure 
goal: μ = μ.mass • μ.normalize.toFiniteMeasure

full_name: MeasureTheory.FiniteMeasure.normalize_eq_of_nonzero
code: theorem normalize_eq_of_nonzero (nonzero : μ ≠ 0) (s : Set Ω) : μ.normalize s = μ.mass⁻¹ * μ s 
goal: μ.normalize s = μ.mass⁻¹ * μ s

full_name: MeasureTheory.FiniteMeasure.normalize_eq_inv_mass_smul_of_nonzero
code: theorem normalize_eq_inv_mass_smul_of_nonzero (nonzero : μ ≠ 0) :
    μ.normalize.toFiniteMeasure = μ.mass⁻¹ • μ 
goal: μ.normalize.toFiniteMeasure = μ.mass⁻¹ • μ

full_name: MeasureTheory.FiniteMeasure.toMeasure_normalize_eq_of_nonzero
code: theorem toMeasure_normalize_eq_of_nonzero (nonzero : μ ≠ 0) :
    (μ.normalize : Measure Ω) = μ.mass⁻¹ • μ 
goal: ↑μ.normalize = μ.mass⁻¹ • ↑μ

full_name: ProbabilityMeasure.toFiniteMeasure_normalize_eq_self
code: @[simp]
theorem _root_.ProbabilityMeasure.toFiniteMeasure_normalize_eq_self {m0 : MeasurableSpace Ω}
    (μ : ProbabilityMeasure Ω) : μ.toFiniteMeasure.normalize = μ 
goal: μ.toFiniteMeasure.normalize = μ

full_name: MeasureTheory.FiniteMeasure.average_eq_integral_normalize
code: /-- Averaging with respect to a finite measure is the same as integrating against
`MeasureTheory.FiniteMeasure.normalize`. -/
theorem average_eq_integral_normalize {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (nonzero : μ ≠ 0) (f : Ω → E) :
    average (μ : Measure Ω) f = ∫ ω, f ω ∂(μ.normalize : Measure Ω) 
goal: MeasureTheory.average (↑μ) f = ∫ (ω : Ω), f ω ∂↑μ.normalize

full_name: MeasureTheory.FiniteMeasure.testAgainstNN_eq_mass_mul
code: theorem testAgainstNN_eq_mass_mul (f : Ω →ᵇ ℝ≥0) :
    μ.testAgainstNN f = μ.mass * μ.normalize.toFiniteMeasure.testAgainstNN f 
goal: μ.testAgainstNN f = μ.mass * μ.normalize.toFiniteMeasure.testAgainstNN f

full_name: MeasureTheory.FiniteMeasure.normalize_testAgainstNN
code: theorem normalize_testAgainstNN (nonzero : μ ≠ 0) (f : Ω →ᵇ ℝ≥0) :
    μ.normalize.toFiniteMeasure.testAgainstNN f = μ.mass⁻¹ * μ.testAgainstNN f 
goal: μ.normalize.toFiniteMeasure.testAgainstNN f = μ.mass⁻¹ * μ.testAgainstNN f

full_name: MeasureTheory.FiniteMeasure.tendsto_testAgainstNN_of_tendsto_normalize_testAgainstNN_of_tendsto_mass
code: theorem tendsto_testAgainstNN_of_tendsto_normalize_testAgainstNN_of_tendsto_mass {γ : Type*}
    {F : Filter γ} {μs : γ → FiniteMeasure Ω}
    (μs_lim : Tendsto (fun i => (μs i).normalize) F (𝓝 μ.normalize))
    (mass_lim : Tendsto (fun i => (μs i).mass) F (𝓝 μ.mass)) (f : Ω →ᵇ ℝ≥0) :
    Tendsto (fun i => (μs i).testAgainstNN f) F (𝓝 (μ.testAgainstNN f)) 
goal: Filter.Tendsto (fun i => (μs i).testAgainstNN f) F (𝓝 (μ.testAgainstNN f))

full_name: MeasureTheory.FiniteMeasure.tendsto_normalize_testAgainstNN_of_tendsto
code: theorem tendsto_normalize_testAgainstNN_of_tendsto {γ : Type*} {F : Filter γ}
    {μs : γ → FiniteMeasure Ω} (μs_lim : Tendsto μs F (𝓝 μ)) (nonzero : μ ≠ 0) (f : Ω →ᵇ ℝ≥0) :
    Tendsto (fun i => (μs i).normalize.toFiniteMeasure.testAgainstNN f) F
      (𝓝 (μ.normalize.toFiniteMeasure.testAgainstNN f)) 
goal: Filter.Tendsto (fun i => (μs i).normalize.toFiniteMeasure.testAgainstNN f) F
  (𝓝 (μ.normalize.toFiniteMeasure.testAgainstNN f))

full_name: MeasureTheory.FiniteMeasure.tendsto_of_tendsto_normalize_testAgainstNN_of_tendsto_mass
code: /-- If the normalized versions of finite measures converge weakly and their total masses
also converge, then the finite measures themselves converge weakly. -/
theorem tendsto_of_tendsto_normalize_testAgainstNN_of_tendsto_mass {γ : Type*} {F : Filter γ}
    {μs : γ → FiniteMeasure Ω} (μs_lim : Tendsto (fun i => (μs i).normalize) F (𝓝 μ.normalize))
    (mass_lim : Tendsto (fun i => (μs i).mass) F (𝓝 μ.mass)) : Tendsto μs F (𝓝 μ) 
goal: Filter.Tendsto μs F (𝓝 μ)

full_name: MeasureTheory.FiniteMeasure.tendsto_normalize_of_tendsto
code: /-- If finite measures themselves converge weakly to a nonzero limit measure, then their
normalized versions also converge weakly. -/
theorem tendsto_normalize_of_tendsto {γ : Type*} {F : Filter γ} {μs : γ → FiniteMeasure Ω}
    (μs_lim : Tendsto μs F (𝓝 μ)) (nonzero : μ ≠ 0) :
    Tendsto (fun i => (μs i).normalize) F (𝓝 μ.normalize) 
goal: Filter.Tendsto (fun i => (μs i).normalize) F (𝓝 μ.normalize)

full_name: MeasureTheory.FiniteMeasure.tendsto_normalize_iff_tendsto
code: /-- The weak convergence of finite measures to a nonzero limit can be characterized by the weak
convergence of both their normalized versions (probability measures) and their total masses. -/
theorem tendsto_normalize_iff_tendsto {γ : Type*} {F : Filter γ} {μs : γ → FiniteMeasure Ω}
    (nonzero : μ ≠ 0) :
    Tendsto (fun i => (μs i).normalize) F (𝓝 μ.normalize) ∧
        Tendsto (fun i => (μs i).mass) F (𝓝 μ.mass) ↔
      Tendsto μs F (𝓝 μ) 
goal: Filter.Tendsto (fun i => (μs i).normalize) F (𝓝 μ.normalize) ∧ Filter.Tendsto (fun i => (μs i).mass) F (𝓝 μ.mass) ↔
  Filter.Tendsto μs F (𝓝 μ)

full_name: MeasureTheory.ProbabilityMeasure.map
code: /-- The push-forward of a probability measure by a measurable function. -/
noncomputable def map (ν : ProbabilityMeasure Ω) {f : Ω → Ω'} (f_aemble : AEMeasurable f ν) :
    ProbabilityMeasure Ω' 
goal: MeasureTheory.ProbabilityMeasure Ω'

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

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

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

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

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

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