File: Mathlib/Probability/Kernel/Disintegration/Density.lean

full_name: ProbabilityTheory.Kernel.densityProcess
code: /-- An `ℕ`-indexed martingale that is a density for `κ` with respect to `ν` on the sets in
`countablePartition γ n`. Used to define its limit `ProbabilityTheory.Kernel.density`, which is
a density for those kernels for all measurable sets. -/
noncomputable
def densityProcess (κ : Kernel α (γ × β)) (ν : Kernel α γ) (n : ℕ) (a : α) (x : γ) (s : Set β) :
    ℝ 
goal: ℝ

full_name: ProbabilityTheory.Kernel.densityProcess_def
code: lemma densityProcess_def (κ : Kernel α (γ × β)) (ν : Kernel α γ) (n : ℕ) (a : α) (s : Set β) :
    (fun t ↦ densityProcess κ ν n a t s)
      = fun t ↦ (κ a (countablePartitionSet n t ×ˢ s) / ν a (countablePartitionSet n t)).toReal 
goal: (fun t => κ.densityProcess ν n a t s) = fun t =>
  ((κ a) (MeasurableSpace.countablePartitionSet n t ×ˢ s) / (ν a) (MeasurableSpace.countablePartitionSet n t)).toReal

full_name: ProbabilityTheory.Kernel.measurable_densityProcess_countableFiltration_aux
code: lemma measurable_densityProcess_countableFiltration_aux (κ : Kernel α (γ × β)) (ν : Kernel α γ)
    (n : ℕ) {s : Set β} (hs : MeasurableSet s) :
    Measurable[mα.prod (countableFiltration γ n)] (fun (p : α × γ) ↦
      κ p.1 (countablePartitionSet n p.2 ×ˢ s) / ν p.1 (countablePartitionSet n p.2)) 
goal: Measurable fun p =>
  (κ p.1) (MeasurableSpace.countablePartitionSet n p.2 ×ˢ s) / (ν p.1) (MeasurableSpace.countablePartitionSet n p.2)

full_name: ProbabilityTheory.Kernel.measurable_densityProcess_aux
code: lemma measurable_densityProcess_aux (κ : Kernel α (γ × β)) (ν : Kernel α γ) (n : ℕ)
    {s : Set β} (hs : MeasurableSet s) :
    Measurable (fun (p : α × γ) ↦
      κ p.1 (countablePartitionSet n p.2 ×ˢ s) / ν p.1 (countablePartitionSet n p.2)) 
goal: Measurable fun p =>
  (κ p.1) (MeasurableSpace.countablePartitionSet n p.2 ×ˢ s) / (ν p.1) (MeasurableSpace.countablePartitionSet n p.2)

full_name: ProbabilityTheory.Kernel.measurable_densityProcess
code: lemma measurable_densityProcess (κ : Kernel α (γ × β)) (ν : Kernel α γ) (n : ℕ)
    {s : Set β} (hs : MeasurableSet s) :
    Measurable (fun (p : α × γ) ↦ densityProcess κ ν n p.1 p.2 s) 
goal: Measurable fun p => κ.densityProcess ν n p.1 p.2 s

full_name: ProbabilityTheory.Kernel.measurable_densityProcess_left
code: lemma measurable_densityProcess_left (κ : Kernel α (γ × β)) (ν : Kernel α γ) (n : ℕ)
    (x : γ) {s : Set β} (hs : MeasurableSet s) :
    Measurable (fun a ↦ densityProcess κ ν n a x s) 
goal: Measurable fun a => κ.densityProcess ν n a x s

full_name: ProbabilityTheory.Kernel.measurable_densityProcess_right
code: lemma measurable_densityProcess_right (κ : Kernel α (γ × β)) (ν : Kernel α γ) (n : ℕ)
    {s : Set β} (a : α) (hs : MeasurableSet s) :
    Measurable (fun x ↦ densityProcess κ ν n a x s) 
goal: Measurable fun x => κ.densityProcess ν n a x s

full_name: ProbabilityTheory.Kernel.measurable_countableFiltration_densityProcess
code: lemma measurable_countableFiltration_densityProcess (κ : Kernel α (γ × β)) (ν : Kernel α γ) (n : ℕ)
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    Measurable[countableFiltration γ n] (fun x ↦ densityProcess κ ν n a x s) 
goal: Measurable fun x => κ.densityProcess ν n a x s

full_name: ProbabilityTheory.Kernel.stronglyMeasurable_countableFiltration_densityProcess
code: lemma stronglyMeasurable_countableFiltration_densityProcess (κ : Kernel α (γ × β)) (ν : Kernel α γ)
    (n : ℕ) (a : α) {s : Set β} (hs : MeasurableSet s) :
    StronglyMeasurable[countableFiltration γ n] (fun x ↦ densityProcess κ ν n a x s) 
goal: MeasureTheory.StronglyMeasurable fun x => κ.densityProcess ν n a x s

full_name: ProbabilityTheory.Kernel.adapted_densityProcess
code: lemma adapted_densityProcess (κ : Kernel α (γ × β)) (ν : Kernel α γ) (a : α)
    {s : Set β} (hs : MeasurableSet s) :
    Adapted (countableFiltration γ) (fun n x ↦ densityProcess κ ν n a x s) 
goal: MeasureTheory.Adapted (ProbabilityTheory.countableFiltration γ) fun n x => κ.densityProcess ν n a x s

full_name: ProbabilityTheory.Kernel.densityProcess_nonneg
code: lemma densityProcess_nonneg (κ : Kernel α (γ × β)) (ν : Kernel α γ) (n : ℕ)
    (a : α) (x : γ) (s : Set β) :
    0 ≤ densityProcess κ ν n a x s 
goal: 0 ≤ κ.densityProcess ν n a x s

full_name: ProbabilityTheory.Kernel.meas_countablePartitionSet_le_of_fst_le
code: lemma meas_countablePartitionSet_le_of_fst_le (hκν : fst κ ≤ ν) (n : ℕ) (a : α) (x : γ)
    (s : Set β) :
    κ a (countablePartitionSet n x ×ˢ s) ≤ ν a (countablePartitionSet n x) 
goal: (κ a) (MeasurableSpace.countablePartitionSet n x ×ˢ s) ≤ (ν a) (MeasurableSpace.countablePartitionSet n x)

full_name: ProbabilityTheory.Kernel.densityProcess_le_one
code: lemma densityProcess_le_one (hκν : fst κ ≤ ν) (n : ℕ) (a : α) (x : γ) (s : Set β) :
    densityProcess κ ν n a x s ≤ 1 
goal: κ.densityProcess ν n a x s ≤ 1

full_name: ProbabilityTheory.Kernel.eLpNorm_densityProcess_le
code: lemma eLpNorm_densityProcess_le (hκν : fst κ ≤ ν) (n : ℕ) (a : α) (s : Set β) :
    eLpNorm (fun x ↦ densityProcess κ ν n a x s) 1 (ν a) ≤ ν a univ 
goal: MeasureTheory.eLpNorm (fun x => κ.densityProcess ν n a x s) 1 (ν a) ≤ (ν a) Set.univ

full_name: ProbabilityTheory.Kernel.integrable_densityProcess
code: lemma integrable_densityProcess (hκν : fst κ ≤ ν) [IsFiniteKernel ν] (n : ℕ)
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    Integrable (fun x ↦ densityProcess κ ν n a x s) (ν a) 
goal: MeasureTheory.Integrable (fun x => κ.densityProcess ν n a x s) (ν a)

full_name: ProbabilityTheory.Kernel.setIntegral_densityProcess_of_mem
code: lemma setIntegral_densityProcess_of_mem (hκν : fst κ ≤ ν) [hν : IsFiniteKernel ν]
    (n : ℕ) (a : α) {s : Set β} (hs : MeasurableSet s) {u : Set γ}
    (hu : u ∈ countablePartition γ n) :
    ∫ x in u, densityProcess κ ν n a x s ∂(ν a) = (κ a (u ×ˢ s)).toReal 
goal: ∫ (x : γ) in u, κ.densityProcess ν n a x s ∂ν a = ((κ a) (u ×ˢ s)).toReal

full_name: ProbabilityTheory.Kernel.setIntegral_densityProcess
code: lemma setIntegral_densityProcess (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (n : ℕ) (a : α) {s : Set β} (hs : MeasurableSet s) {A : Set γ}
    (hA : MeasurableSet[countableFiltration γ n] A) :
    ∫ x in A, densityProcess κ ν n a x s ∂(ν a) = (κ a (A ×ˢ s)).toReal 
goal: ∫ (x : γ) in A, κ.densityProcess ν n a x s ∂ν a = ((κ a) (A ×ˢ s)).toReal

full_name: ProbabilityTheory.Kernel.integral_densityProcess
code: lemma integral_densityProcess (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (n : ℕ) (a : α) {s : Set β} (hs : MeasurableSet s) :
    ∫ x, densityProcess κ ν n a x s ∂(ν a) = (κ a (univ ×ˢ s)).toReal 
goal: ∫ (x : γ), κ.densityProcess ν n a x s ∂ν a = ((κ a) (Set.univ ×ˢ s)).toReal

full_name: ProbabilityTheory.Kernel.setIntegral_densityProcess_of_le
code: lemma setIntegral_densityProcess_of_le (hκν : fst κ ≤ ν)
    [IsFiniteKernel ν] {n m : ℕ} (hnm : n ≤ m) (a : α) {s : Set β} (hs : MeasurableSet s)
    {A : Set γ} (hA : MeasurableSet[countableFiltration γ n] A) :
    ∫ x in A, densityProcess κ ν m a x s ∂(ν a) = (κ a (A ×ˢ s)).toReal 
goal: ∫ (x : γ) in A, κ.densityProcess ν m a x s ∂ν a = ((κ a) (A ×ˢ s)).toReal

full_name: ProbabilityTheory.Kernel.condexp_densityProcess
code: lemma condexp_densityProcess (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    {i j : ℕ} (hij : i ≤ j) (a : α) {s : Set β} (hs : MeasurableSet s) :
    (ν a)[fun x ↦ densityProcess κ ν j a x s | countableFiltration γ i]
      =ᵐ[ν a] fun x ↦ densityProcess κ ν i a x s 
goal: ν a[fun x => κ.densityProcess ν j a x s|↑(ProbabilityTheory.countableFiltration γ) i] =ᵐ[ν a] fun x =>
  κ.densityProcess ν i a x s

full_name: ProbabilityTheory.Kernel.martingale_densityProcess
code: lemma martingale_densityProcess (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    Martingale (fun n x ↦ densityProcess κ ν n a x s) (countableFiltration γ) (ν a) 
goal: MeasureTheory.Martingale (fun n x => κ.densityProcess ν n a x s) (ProbabilityTheory.countableFiltration γ) (ν a)

full_name: ProbabilityTheory.Kernel.densityProcess_mono_set
code: lemma densityProcess_mono_set (hκν : fst κ ≤ ν) (n : ℕ) (a : α) (x : γ)
    {s s' : Set β} (h : s ⊆ s') :
    densityProcess κ ν n a x s ≤ densityProcess κ ν n a x s' 
goal: κ.densityProcess ν n a x s ≤ κ.densityProcess ν n a x s'

full_name: ProbabilityTheory.Kernel.densityProcess_mono_kernel_left
code: lemma densityProcess_mono_kernel_left {κ' : Kernel α (γ × β)} (hκκ' : κ ≤ κ')
    (hκ'ν : fst κ' ≤ ν) (n : ℕ) (a : α) (x : γ) (s : Set β) :
    densityProcess κ ν n a x s ≤ densityProcess κ' ν n a x s 
goal: κ.densityProcess ν n a x s ≤ κ'.densityProcess ν n a x s

full_name: ProbabilityTheory.Kernel.densityProcess_antitone_kernel_right
code: lemma densityProcess_antitone_kernel_right {ν' : Kernel α γ}
    (hνν' : ν ≤ ν') (hκν : fst κ ≤ ν) (n : ℕ) (a : α) (x : γ) (s : Set β) :
    densityProcess κ ν' n a x s ≤ densityProcess κ ν n a x s 
goal: κ.densityProcess ν' n a x s ≤ κ.densityProcess ν n a x s

full_name: ProbabilityTheory.Kernel.densityProcess_empty
code: @[simp]
lemma densityProcess_empty (κ : Kernel α (γ × β)) (ν : Kernel α γ) (n : ℕ) (a : α) (x : γ) :
    densityProcess κ ν n a x ∅ = 0 
goal: κ.densityProcess ν n a x ∅ = 0

full_name: ProbabilityTheory.Kernel.tendsto_densityProcess_atTop_empty_of_antitone
code: lemma tendsto_densityProcess_atTop_empty_of_antitone (κ : Kernel α (γ × β)) (ν : Kernel α γ)
    [IsFiniteKernel κ] (n : ℕ) (a : α) (x : γ)
    (seq : ℕ → Set β) (hseq : Antitone seq) (hseq_iInter : ⋂ i, seq i = ∅)
    (hseq_meas : ∀ m, MeasurableSet (seq m)) :
    Tendsto (fun m ↦ densityProcess κ ν n a x (seq m)) atTop
      (𝓝 (densityProcess κ ν n a x ∅)) 
goal: Filter.Tendsto (fun m => κ.densityProcess ν n a x (seq m)) Filter.atTop (𝓝 (κ.densityProcess ν n a x ∅))

full_name: ProbabilityTheory.Kernel.tendsto_densityProcess_atTop_of_antitone
code: lemma tendsto_densityProcess_atTop_of_antitone (κ : Kernel α (γ × β)) (ν : Kernel α γ)
    [IsFiniteKernel κ] (n : ℕ) (a : α) (x : γ)
    (seq : ℕ → Set β) (hseq : Antitone seq) (hseq_iInter : ⋂ i, seq i = ∅)
    (hseq_meas : ∀ m, MeasurableSet (seq m)) :
    Tendsto (fun m ↦ densityProcess κ ν n a x (seq m)) atTop (𝓝 0) 
goal: Filter.Tendsto (fun m => κ.densityProcess ν n a x (seq m)) Filter.atTop (𝓝 0)

full_name: ProbabilityTheory.Kernel.tendsto_densityProcess_limitProcess
code: lemma tendsto_densityProcess_limitProcess (hκν : fst κ ≤ ν)
    [IsFiniteKernel ν] (a : α) {s : Set β} (hs : MeasurableSet s) :
    ∀ᵐ x ∂(ν a), Tendsto (fun n ↦ densityProcess κ ν n a x s) atTop
      (𝓝 ((countableFiltration γ).limitProcess
      (fun n x ↦ densityProcess κ ν n a x s) (ν a) x)) 
goal: ∀ᵐ (x : γ) ∂ν a,
  Filter.Tendsto (fun n => κ.densityProcess ν n a x s) Filter.atTop
    (𝓝
      (MeasureTheory.Filtration.limitProcess (fun n x => κ.densityProcess ν n a x s)
        (ProbabilityTheory.countableFiltration γ) (ν a) x))

full_name: ProbabilityTheory.Kernel.memL1_limitProcess_densityProcess
code: lemma memL1_limitProcess_densityProcess (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    Memℒp ((countableFiltration γ).limitProcess
      (fun n x ↦ densityProcess κ ν n a x s) (ν a)) 1 (ν a) 
goal: MeasureTheory.Memℒp
  (MeasureTheory.Filtration.limitProcess (fun n x => κ.densityProcess ν n a x s)
    (ProbabilityTheory.countableFiltration γ) (ν a))
  1 (ν a)

full_name: ProbabilityTheory.Kernel.tendsto_eLpNorm_one_densityProcess_limitProcess
code: lemma tendsto_eLpNorm_one_densityProcess_limitProcess (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    Tendsto (fun n ↦ eLpNorm ((fun x ↦ densityProcess κ ν n a x s)
      - (countableFiltration γ).limitProcess (fun n x ↦ densityProcess κ ν n a x s) (ν a))
      1 (ν a)) atTop (𝓝 0) 
goal: Filter.Tendsto
  (fun n =>
    MeasureTheory.eLpNorm
      ((fun x => κ.densityProcess ν n a x s) -
        MeasureTheory.Filtration.limitProcess (fun n x => κ.densityProcess ν n a x s)
          (ProbabilityTheory.countableFiltration γ) (ν a))
      1 (ν a))
  Filter.atTop (𝓝 0)

full_name: ProbabilityTheory.Kernel.tendsto_eLpNorm_one_restrict_densityProcess_limitProcess
code: lemma tendsto_eLpNorm_one_restrict_densityProcess_limitProcess [IsFiniteKernel ν]
    (hκν : fst κ ≤ ν) (a : α) {s : Set β} (hs : MeasurableSet s) (A : Set γ) :
    Tendsto (fun n ↦ eLpNorm ((fun x ↦ densityProcess κ ν n a x s)
      - (countableFiltration γ).limitProcess (fun n x ↦ densityProcess κ ν n a x s) (ν a))
      1 ((ν a).restrict A)) atTop (𝓝 0) 
goal: Filter.Tendsto
  (fun n =>
    MeasureTheory.eLpNorm
      ((fun x => κ.densityProcess ν n a x s) -
        MeasureTheory.Filtration.limitProcess (fun n x => κ.densityProcess ν n a x s)
          (ProbabilityTheory.countableFiltration γ) (ν a))
      1 ((ν a).restrict A))
  Filter.atTop (𝓝 0)

full_name: ProbabilityTheory.Kernel.density
code: /-- Density of the kernel `κ` with respect to `ν`. This is a function `α → γ → Set β → ℝ` which
is measurable on `α × γ` for all measurable sets `s : Set β` and satisfies that
`∫ x in A, density κ ν a x s ∂(ν a) = (κ a (A ×ˢ s)).toReal` for all measurable `A : Set γ`. -/
noncomputable
def density (κ : Kernel α (γ × β)) (ν : Kernel α γ) (a : α) (x : γ) (s : Set β) : ℝ 
goal: ℝ

full_name: ProbabilityTheory.Kernel.density_ae_eq_limitProcess
code: lemma density_ae_eq_limitProcess (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    (fun x ↦ density κ ν a x s)
      =ᵐ[ν a] (countableFiltration γ).limitProcess
        (fun n x ↦ densityProcess κ ν n a x s) (ν a) 
goal: (fun x => κ.density ν a x s) =ᵐ[ν a]
  MeasureTheory.Filtration.limitProcess (fun n x => κ.densityProcess ν n a x s)
    (ProbabilityTheory.countableFiltration γ) (ν a)

full_name: ProbabilityTheory.Kernel.tendsto_m_density
code: lemma tendsto_m_density (hκν : fst κ ≤ ν) (a : α) [IsFiniteKernel ν]
    {s : Set β} (hs : MeasurableSet s) :
    ∀ᵐ x ∂(ν a),
      Tendsto (fun n ↦ densityProcess κ ν n a x s) atTop (𝓝 (density κ ν a x s)) 
goal: ∀ᵐ (x : γ) ∂ν a, Filter.Tendsto (fun n => κ.densityProcess ν n a x s) Filter.atTop (𝓝 (κ.density ν a x s))

full_name: ProbabilityTheory.Kernel.measurable_density
code: lemma measurable_density (κ : Kernel α (γ × β)) (ν : Kernel α γ)
    {s : Set β} (hs : MeasurableSet s) :
    Measurable (fun (p : α × γ) ↦ density κ ν p.1 p.2 s) 
goal: Measurable fun p => κ.density ν p.1 p.2 s

full_name: ProbabilityTheory.Kernel.measurable_density_left
code: lemma measurable_density_left (κ : Kernel α (γ × β)) (ν : Kernel α γ) (x : γ)
    {s : Set β} (hs : MeasurableSet s) :
    Measurable (fun a ↦ density κ ν a x s) 
goal: Measurable fun a => κ.density ν a x s

full_name: ProbabilityTheory.Kernel.measurable_density_right
code: lemma measurable_density_right (κ : Kernel α (γ × β)) (ν : Kernel α γ)
    {s : Set β} (hs : MeasurableSet s) (a : α) :
    Measurable (fun x ↦ density κ ν a x s) 
goal: Measurable fun x => κ.density ν a x s

full_name: ProbabilityTheory.Kernel.density_mono_set
code: lemma density_mono_set (hκν : fst κ ≤ ν) (a : α) (x : γ) {s s' : Set β} (h : s ⊆ s') :
    density κ ν a x s ≤ density κ ν a x s' 
goal: κ.density ν a x s ≤ κ.density ν a x s'

full_name: ProbabilityTheory.Kernel.density_nonneg
code: lemma density_nonneg (hκν : fst κ ≤ ν) (a : α) (x : γ) (s : Set β) :
    0 ≤ density κ ν a x s 
goal: 0 ≤ κ.density ν a x s

full_name: ProbabilityTheory.Kernel.density_le_one
code: lemma density_le_one (hκν : fst κ ≤ ν) (a : α) (x : γ) (s : Set β) :
    density κ ν a x s ≤ 1 
goal: κ.density ν a x s ≤ 1

full_name: ProbabilityTheory.Kernel.eLpNorm_density_le
code: lemma eLpNorm_density_le (hκν : fst κ ≤ ν) (a : α) (s : Set β) :
    eLpNorm (fun x ↦ density κ ν a x s) 1 (ν a) ≤ ν a univ 
goal: MeasureTheory.eLpNorm (fun x => κ.density ν a x s) 1 (ν a) ≤ (ν a) Set.univ

full_name: ProbabilityTheory.Kernel.integrable_density
code: lemma integrable_density (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    Integrable (fun x ↦ density κ ν a x s) (ν a) 
goal: MeasureTheory.Integrable (fun x => κ.density ν a x s) (ν a)

full_name: ProbabilityTheory.Kernel.tendsto_setIntegral_densityProcess
code: lemma tendsto_setIntegral_densityProcess (hκν : fst κ ≤ ν)
    [IsFiniteKernel ν] (a : α) {s : Set β} (hs : MeasurableSet s) (A : Set γ) :
    Tendsto (fun i ↦ ∫ x in A, densityProcess κ ν i a x s ∂(ν a)) atTop
      (𝓝 (∫ x in A, density κ ν a x s ∂(ν a))) 
goal: Filter.Tendsto (fun i => ∫ (x : γ) in A, κ.densityProcess ν i a x s ∂ν a) Filter.atTop
  (𝓝 (∫ (x : γ) in A, κ.density ν a x s ∂ν a))

full_name: ProbabilityTheory.Kernel.setIntegral_density_of_measurableSet
code: /-- Auxiliary lemma for `setIntegral_density`. -/
lemma setIntegral_density_of_measurableSet (hκν : fst κ ≤ ν)
    [IsFiniteKernel ν] (n : ℕ) (a : α) {s : Set β} (hs : MeasurableSet s) {A : Set γ}
    (hA : MeasurableSet[countableFiltration γ n] A) :
    ∫ x in A, density κ ν a x s ∂(ν a) = (κ a (A ×ˢ s)).toReal 
goal: ∫ (x : γ) in A, κ.density ν a x s ∂ν a = ((κ a) (A ×ˢ s)).toReal

full_name: ProbabilityTheory.Kernel.integral_density
code: lemma integral_density (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    ∫ x, density κ ν a x s ∂(ν a) = (κ a (univ ×ˢ s)).toReal 
goal: ∫ (x : γ), κ.density ν a x s ∂ν a = ((κ a) (Set.univ ×ˢ s)).toReal

full_name: ProbabilityTheory.Kernel.setIntegral_density
code: lemma setIntegral_density (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) {A : Set γ} (hA : MeasurableSet A) :
    ∫ x in A, density κ ν a x s ∂(ν a) = (κ a (A ×ˢ s)).toReal 
goal: ∫ (x : γ) in A, κ.density ν a x s ∂ν a = ((κ a) (A ×ˢ s)).toReal

full_name: ProbabilityTheory.Kernel.setLIntegral_density
code: lemma setLIntegral_density (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) {A : Set γ} (hA : MeasurableSet A) :
    ∫⁻ x in A, ENNReal.ofReal (density κ ν a x s) ∂(ν a) = κ a (A ×ˢ s) 
goal: ∫⁻ (x : γ) in A, ENNReal.ofReal (κ.density ν a x s) ∂ν a = (κ a) (A ×ˢ s)

full_name: ProbabilityTheory.Kernel.lintegral_density
code: lemma lintegral_density (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) {s : Set β} (hs : MeasurableSet s) :
    ∫⁻ x, ENNReal.ofReal (density κ ν a x s) ∂(ν a) = κ a (univ ×ˢ s) 
goal: ∫⁻ (x : γ), ENNReal.ofReal (κ.density ν a x s) ∂ν a = (κ a) (Set.univ ×ˢ s)

full_name: ProbabilityTheory.Kernel.tendsto_integral_density_of_monotone
code: lemma tendsto_integral_density_of_monotone (hκν : fst κ ≤ ν) [IsFiniteKernel ν]
    (a : α) (seq : ℕ → Set β) (hseq : Monotone seq) (hseq_iUnion : ⋃ i, seq i = univ)
    (hseq_meas : ∀ m, MeasurableSet (seq m)) :
    Tendsto (fun m ↦ ∫ x, density κ ν a x (seq m) ∂(ν a)) atTop (𝓝 (κ a univ).toReal) 
goal: Filter.Tendsto (fun m => ∫ (x : γ), κ.density ν a x (seq m) ∂ν a) Filter.atTop (𝓝 ((κ a) Set.univ).toReal)

full_name: ProbabilityTheory.Kernel.tendsto_integral_density_of_antitone
code: lemma tendsto_integral_density_of_antitone (hκν : fst κ ≤ ν) [IsFiniteKernel ν] (a : α)
    (seq : ℕ → Set β) (hseq : Antitone seq) (hseq_iInter : ⋂ i, seq i = ∅)
    (hseq_meas : ∀ m, MeasurableSet (seq m)) :
    Tendsto (fun m ↦ ∫ x, density κ ν a x (seq m) ∂(ν a)) atTop (𝓝 0) 
goal: Filter.Tendsto (fun m => ∫ (x : γ), κ.density ν a x (seq m) ∂ν a) Filter.atTop (𝓝 0)

full_name: ProbabilityTheory.Kernel.tendsto_density_atTop_ae_of_antitone
code: lemma tendsto_density_atTop_ae_of_antitone (hκν : fst κ ≤ ν) [IsFiniteKernel ν] (a : α)
    (seq : ℕ → Set β) (hseq : Antitone seq) (hseq_iInter : ⋂ i, seq i = ∅)
    (hseq_meas : ∀ m, MeasurableSet (seq m)) :
    ∀ᵐ x ∂(ν a), Tendsto (fun m ↦ density κ ν a x (seq m)) atTop (𝓝 0) 
goal: ∀ᵐ (x : γ) ∂ν a, Filter.Tendsto (fun m => κ.density ν a x (seq m)) Filter.atTop (𝓝 0)

full_name: ProbabilityTheory.Kernel.densityProcess_fst_univ
code: lemma densityProcess_fst_univ [IsFiniteKernel κ] (n : ℕ) (a : α) (x : γ) :
    densityProcess κ (fst κ) n a x univ
      = if fst κ a (countablePartitionSet n x) = 0 then 0 else 1 
goal: κ.densityProcess κ.fst n a x Set.univ = if (κ.fst a) (MeasurableSpace.countablePartitionSet n x) = 0 then 0 else 1

full_name: ProbabilityTheory.Kernel.densityProcess_fst_univ_ae
code: lemma densityProcess_fst_univ_ae (κ : Kernel α (γ × β)) [IsFiniteKernel κ] (n : ℕ) (a : α) :
    ∀ᵐ x ∂(fst κ a), densityProcess κ (fst κ) n a x univ = 1 
goal: ∀ᵐ (x : γ) ∂κ.fst a, κ.densityProcess κ.fst n a x Set.univ = 1

full_name: ProbabilityTheory.Kernel.tendsto_densityProcess_fst_atTop_univ_of_monotone
code: lemma tendsto_densityProcess_fst_atTop_univ_of_monotone (κ : Kernel α (γ × β)) (n : ℕ) (a : α)
    (x : γ) (seq : ℕ → Set β) (hseq : Monotone seq) (hseq_iUnion : ⋃ i, seq i = univ) :
    Tendsto (fun m ↦ densityProcess κ (fst κ) n a x (seq m)) atTop
      (𝓝 (densityProcess κ (fst κ) n a x univ)) 
goal: Filter.Tendsto (fun m => κ.densityProcess κ.fst n a x (seq m)) Filter.atTop (𝓝 (κ.densityProcess κ.fst n a x Set.univ))

full_name: ProbabilityTheory.Kernel.tendsto_densityProcess_fst_atTop_ae_of_monotone
code: lemma tendsto_densityProcess_fst_atTop_ae_of_monotone (κ : Kernel α (γ × β)) [IsFiniteKernel κ]
    (n : ℕ) (a : α) (seq : ℕ → Set β) (hseq : Monotone seq) (hseq_iUnion : ⋃ i, seq i = univ) :
    ∀ᵐ x ∂(fst κ a), Tendsto (fun m ↦ densityProcess κ (fst κ) n a x (seq m)) atTop (𝓝 1) 
goal: ∀ᵐ (x : γ) ∂κ.fst a, Filter.Tendsto (fun m => κ.densityProcess κ.fst n a x (seq m)) Filter.atTop (𝓝 1)

full_name: ProbabilityTheory.Kernel.density_fst_univ
code: lemma density_fst_univ (κ : Kernel α (γ × β)) [IsFiniteKernel κ] (a : α) :
    ∀ᵐ x ∂(fst κ a), density κ (fst κ) a x univ = 1 
goal: ∀ᵐ (x : γ) ∂κ.fst a, κ.density κ.fst a x Set.univ = 1

full_name: ProbabilityTheory.Kernel.tendsto_density_fst_atTop_ae_of_monotone
code: lemma tendsto_density_fst_atTop_ae_of_monotone [IsFiniteKernel κ]
    (a : α) (seq : ℕ → Set β) (hseq : Monotone seq) (hseq_iUnion : ⋃ i, seq i = univ)
    (hseq_meas : ∀ m, MeasurableSet (seq m)) :
    ∀ᵐ x ∂(fst κ a), Tendsto (fun m ↦ density κ (fst κ) a x (seq m)) atTop (𝓝 1) 
goal: ∀ᵐ (x : γ) ∂κ.fst a, Filter.Tendsto (fun m => κ.density κ.fst a x (seq m)) Filter.atTop (𝓝 1)