File: Mathlib/Probability/Independence/Conditional.lean

full_name: ProbabilityTheory.iCondIndepSets
code: /-- A family of sets of sets `π : ι → Set (Set Ω)` is conditionally independent given `m'` with
respect to a measure `μ` if for any finite set of indices `s = {i_1, ..., i_n}`, for any sets
`f i_1 ∈ π i_1, ..., f i_n ∈ π i_n`, then `μ⟦⋂ i in s, f i | m'⟧ =ᵐ[μ] ∏ i ∈ s, μ⟦f i | m'⟧`.
See `ProbabilityTheory.iCondIndepSets_iff`.
It will be used for families of pi_systems. -/
def iCondIndepSets (π : ι → Set (Set Ω)) (μ : Measure Ω := by volume_tac) [IsFiniteMeasure μ] :
    Prop 
goal: Prop

full_name: ProbabilityTheory.CondIndepSets
code: /-- Two sets of sets `s₁, s₂` are conditionally independent given `m'` with respect to a measure
`μ` if for any sets `t₁ ∈ s₁, t₂ ∈ s₂`, then `μ⟦t₁ ∩ t₂ | m'⟧ =ᵐ[μ] μ⟦t₁ | m'⟧ * μ⟦t₂ | m'⟧`.
See `ProbabilityTheory.condIndepSets_iff`. -/
def CondIndepSets (s1 s2 : Set (Set Ω)) (μ : Measure Ω := by volume_tac) [IsFiniteMeasure μ] :
    Prop 
goal: Prop

full_name: ProbabilityTheory.iCondIndep
code: /-- A family of measurable space structures (i.e. of σ-algebras) is conditionally independent given
`m'` with respect to a measure `μ` (typically defined on a finer σ-algebra) if the family of sets of
measurable sets they define is independent. `m : ι → MeasurableSpace Ω` is conditionally independent
given `m'` with respect to measure `μ` if for any finite set of indices `s = {i_1, ..., i_n}`, for
any sets `f i_1 ∈ m i_1, ..., f i_n ∈ m i_n`, then
`μ⟦⋂ i in s, f i | m'⟧ =ᵐ[μ] ∏ i ∈ s, μ⟦f i | m'⟧ `.
See `ProbabilityTheory.iCondIndep_iff`. -/
def iCondIndep (m : ι → MeasurableSpace Ω)
    (μ : @Measure Ω mΩ := by volume_tac) [IsFiniteMeasure μ] : Prop 
goal: Prop

full_name: ProbabilityTheory.CondIndep
code: /-- Two measurable space structures (or σ-algebras) `m₁, m₂` are conditionally independent given
`m'` with respect to a measure `μ` (defined on a third σ-algebra) if for any sets
`t₁ ∈ m₁, t₂ ∈ m₂`, `μ⟦t₁ ∩ t₂ | m'⟧ =ᵐ[μ] μ⟦t₁ | m'⟧ * μ⟦t₂ | m'⟧`.
See `ProbabilityTheory.condIndep_iff`. -/
def CondIndep (m' m₁ m₂ : MeasurableSpace Ω)
    {mΩ : MeasurableSpace Ω} [StandardBorelSpace Ω] [Nonempty Ω]
    (hm' : m' ≤ mΩ) (μ : Measure Ω := by volume_tac) [IsFiniteMeasure μ] : Prop 
goal: Prop

full_name: ProbabilityTheory.iCondIndepSet
code: /-- A family of sets is conditionally independent if the family of measurable space structures they
generate is conditionally independent. For a set `s`, the generated measurable space has measurable
sets `∅, s, sᶜ, univ`.
See `ProbabilityTheory.iCondIndepSet_iff`. -/
def iCondIndepSet (s : ι → Set Ω) (μ : Measure Ω := by volume_tac) [IsFiniteMeasure μ] : Prop 
goal: Prop

full_name: ProbabilityTheory.CondIndepSet
code: /-- Two sets are conditionally independent if the two measurable space structures they generate are
conditionally independent. For a set `s`, the generated measurable space structure has measurable
sets `∅, s, sᶜ, univ`.
See `ProbabilityTheory.condIndepSet_iff`. -/
def CondIndepSet (s t : Set Ω) (μ : Measure Ω := by volume_tac) [IsFiniteMeasure μ] : Prop 
goal: Prop

full_name: ProbabilityTheory.iCondIndepFun
code: /-- A family of functions defined on the same space `Ω` and taking values in possibly different
spaces, each with a measurable space structure, is conditionally independent if the family of
measurable space structures they generate on `Ω` is conditionally independent. For a function `g`
with codomain having measurable space structure `m`, the generated measurable space structure is
`m.comap g`.
See `ProbabilityTheory.iCondIndepFun_iff`. -/
def iCondIndepFun {β : ι → Type*} (m : ∀ x : ι, MeasurableSpace (β x))
    (f : ∀ x : ι, Ω → β x) (μ : Measure Ω := by volume_tac) [IsFiniteMeasure μ] : Prop 
goal: Prop

full_name: ProbabilityTheory.CondIndepFun
code: /-- Two functions are conditionally independent if the two measurable space structures they generate
are conditionally independent. For a function `f` with codomain having measurable space structure
`m`, the generated measurable space structure is `m.comap f`.
See `ProbabilityTheory.condIndepFun_iff`. -/
def CondIndepFun {β γ : Type*} [MeasurableSpace β] [MeasurableSpace γ]
    (f : Ω → β) (g : Ω → γ) (μ : Measure Ω := by volume_tac) [IsFiniteMeasure μ] : Prop 
goal: Prop

full_name: ProbabilityTheory.iCondIndepSets_iff
code: lemma iCondIndepSets_iff (π : ι → Set (Set Ω)) (hπ : ∀ i s (_hs : s ∈ π i), MeasurableSet s)
    (μ : Measure Ω) [IsFiniteMeasure μ] :
    iCondIndepSets m' hm' π μ ↔ ∀ (s : Finset ι) {f : ι → Set Ω} (_H : ∀ i, i ∈ s → f i ∈ π i),
      μ⟦⋂ i ∈ s, f i | m'⟧ =ᵐ[μ] ∏ i ∈ s, (μ⟦f i | m'⟧) 
goal: ProbabilityTheory.iCondIndepSets m' hm' π μ ↔
  ∀ (s : Finset ι) {f : ι → Set Ω},
    (∀ i ∈ s, f i ∈ π i) → μ[(⋂ i ∈ s, f i).indicator fun ω => 1|m'] =ᵐ[μ] ∏ i ∈ s, μ[(f i).indicator fun ω => 1|m']

full_name: ProbabilityTheory.condIndepSets_iff
code: lemma condIndepSets_iff (s1 s2 : Set (Set Ω)) (hs1 : ∀ s ∈ s1, MeasurableSet s)
    (hs2 : ∀ s ∈ s2, MeasurableSet s) (μ : Measure Ω) [IsFiniteMeasure μ] :
    CondIndepSets m' hm' s1 s2 μ ↔ ∀ (t1 t2 : Set Ω) (_ : t1 ∈ s1) (_ : t2 ∈ s2),
      (μ⟦t1 ∩ t2 | m'⟧) =ᵐ[μ] (μ⟦t1 | m'⟧) * (μ⟦t2 | m'⟧) 
goal: ProbabilityTheory.CondIndepSets m' hm' s1 s2 μ ↔
  ∀ (t1 t2 : Set Ω),
    t1 ∈ s1 →
      t2 ∈ s2 → μ[(t1 ∩ t2).indicator fun ω => 1|m'] =ᵐ[μ] μ[t1.indicator fun ω => 1|m'] * μ[t2.indicator fun ω => 1|m']

full_name: ProbabilityTheory.iCondIndepSets_singleton_iff
code: lemma iCondIndepSets_singleton_iff (s : ι → Set Ω) (hπ : ∀ i, MeasurableSet (s i))
    (μ : Measure Ω) [IsFiniteMeasure μ] :
    iCondIndepSets m' hm' (fun i ↦ {s i}) μ ↔ ∀ S : Finset ι,
      μ⟦⋂ i ∈ S, s i | m'⟧ =ᵐ[μ] ∏ i ∈ S, (μ⟦s i | m'⟧) 
goal: ProbabilityTheory.iCondIndepSets m' hm' (fun i => {s i}) μ ↔
  ∀ (S : Finset ι), μ[(⋂ i ∈ S, s i).indicator fun ω => 1|m'] =ᵐ[μ] ∏ i ∈ S, μ[(s i).indicator fun ω => 1|m']

full_name: ProbabilityTheory.condIndepSets_singleton_iff
code: theorem condIndepSets_singleton_iff {μ : Measure Ω} [IsFiniteMeasure μ]
    {s t : Set Ω} (hs : MeasurableSet s) (ht : MeasurableSet t) :
    CondIndepSets m' hm' {s} {t} μ ↔ (μ⟦s ∩ t | m'⟧) =ᵐ[μ] (μ⟦s | m'⟧) * (μ⟦t | m'⟧) 
goal: ProbabilityTheory.CondIndepSets m' hm' {s} {t} μ ↔
  μ[(s ∩ t).indicator fun ω => 1|m'] =ᵐ[μ] μ[s.indicator fun ω => 1|m'] * μ[t.indicator fun ω => 1|m']

full_name: ProbabilityTheory.iCondIndep_iff_iCondIndepSets
code: lemma iCondIndep_iff_iCondIndepSets (m : ι → MeasurableSpace Ω)
    (μ : @Measure Ω mΩ) [IsFiniteMeasure μ] :
    iCondIndep m' hm' m μ ↔ iCondIndepSets m' hm' (fun x ↦ {s | MeasurableSet[m x] s}) μ 
goal: ProbabilityTheory.iCondIndep m' hm' m μ ↔ ProbabilityTheory.iCondIndepSets m' hm' (fun x => {s | MeasurableSet s}) μ

full_name: ProbabilityTheory.iCondIndep_iff
code: lemma iCondIndep_iff (m : ι → MeasurableSpace Ω) (hm : ∀ i, m i ≤ mΩ)
    (μ : @Measure Ω mΩ) [IsFiniteMeasure μ] :
    iCondIndep m' hm' m μ
      ↔ ∀ (s : Finset ι) {f : ι → Set Ω} (_H : ∀ i, i ∈ s → MeasurableSet[m i] (f i)),
      μ⟦⋂ i ∈ s, f i | m'⟧ =ᵐ[μ] ∏ i ∈ s, (μ⟦f i | m'⟧) 
goal: ProbabilityTheory.iCondIndep m' hm' m μ ↔
  ∀ (s : Finset ι) {f : ι → Set Ω},
    (∀ i ∈ s, MeasurableSet (f i)) →
      μ[(⋂ i ∈ s, f i).indicator fun ω => 1|m'] =ᵐ[μ] ∏ i ∈ s, μ[(f i).indicator fun ω => 1|m']

full_name: ProbabilityTheory.condIndep_iff_condIndepSets
code: lemma condIndep_iff_condIndepSets (m' m₁ m₂ : MeasurableSpace Ω) {mΩ : MeasurableSpace Ω}
    [StandardBorelSpace Ω] [Nonempty Ω] (hm' : m' ≤ mΩ) (μ : Measure Ω ) [IsFiniteMeasure μ] :
    CondIndep m' m₁ m₂ hm' μ
      ↔ CondIndepSets m' hm' {s | MeasurableSet[m₁] s} {s | MeasurableSet[m₂] s} μ 
goal: ProbabilityTheory.CondIndep m' m₁ m₂ hm' μ ↔
  ProbabilityTheory.CondIndepSets m' hm' {s | MeasurableSet s} {s | MeasurableSet s} μ

full_name: ProbabilityTheory.condIndep_iff
code: lemma condIndep_iff (m' m₁ m₂ : MeasurableSpace Ω)
    {mΩ : MeasurableSpace Ω} [StandardBorelSpace Ω] [Nonempty Ω]
    (hm' : m' ≤ mΩ) (hm₁ : m₁ ≤ mΩ) (hm₂ : m₂ ≤ mΩ) (μ : Measure Ω) [IsFiniteMeasure μ] :
    CondIndep m' m₁ m₂ hm' μ
      ↔ ∀ t1 t2, MeasurableSet[m₁] t1 → MeasurableSet[m₂] t2
        → (μ⟦t1 ∩ t2 | m'⟧) =ᵐ[μ] (μ⟦t1 | m'⟧) * (μ⟦t2 | m'⟧) 
goal: ProbabilityTheory.CondIndep m' m₁ m₂ hm' μ ↔
  ∀ (t1 t2 : Set Ω),
    MeasurableSet t1 →
      MeasurableSet t2 →
        μ[(t1 ∩ t2).indicator fun ω => 1|m'] =ᵐ[μ] μ[t1.indicator fun ω => 1|m'] * μ[t2.indicator fun ω => 1|m']

full_name: ProbabilityTheory.iCondIndepSet_iff_iCondIndep
code: lemma iCondIndepSet_iff_iCondIndep (s : ι → Set Ω) (μ : Measure Ω) [IsFiniteMeasure μ] :
    iCondIndepSet m' hm' s μ ↔ iCondIndep m' hm' (fun i ↦ generateFrom {s i}) μ 
goal: ProbabilityTheory.iCondIndepSet m' hm' s μ ↔
  ProbabilityTheory.iCondIndep m' hm' (fun i => MeasurableSpace.generateFrom {s i}) μ

full_name: ProbabilityTheory.iCondIndepSet_iff_iCondIndepSets_singleton
code: theorem iCondIndepSet_iff_iCondIndepSets_singleton (s : ι → Set Ω) (hs : ∀ i, MeasurableSet (s i))
    (μ : Measure Ω) [IsFiniteMeasure μ] :
    iCondIndepSet m' hm' s μ ↔ iCondIndepSets m' hm' (fun i ↦ {s i}) μ 
goal: ProbabilityTheory.iCondIndepSet m' hm' s μ ↔ ProbabilityTheory.iCondIndepSets m' hm' (fun i => {s i}) μ

full_name: ProbabilityTheory.iCondIndepSet_iff
code: lemma iCondIndepSet_iff (s : ι → Set Ω) (hs : ∀ i, MeasurableSet (s i))
    (μ : Measure Ω) [IsFiniteMeasure μ] :
    iCondIndepSet m' hm' s μ ↔
      ∀ S : Finset ι, μ⟦⋂ i ∈ S, s i | m'⟧ =ᵐ[μ] ∏ i ∈ S, μ⟦s i | m'⟧ 
goal: ProbabilityTheory.iCondIndepSet m' hm' s μ ↔
  ∀ (S : Finset ι), μ[(⋂ i ∈ S, s i).indicator fun ω => 1|m'] =ᵐ[μ] ∏ i ∈ S, μ[(s i).indicator fun ω => 1|m']

full_name: ProbabilityTheory.condIndepSet_iff_condIndep
code: lemma condIndepSet_iff_condIndep (s t : Set Ω) (μ : Measure Ω) [IsFiniteMeasure μ] :
    CondIndepSet m' hm' s t μ ↔ CondIndep m' (generateFrom {s}) (generateFrom {t}) hm' μ 
goal: ProbabilityTheory.CondIndepSet m' hm' s t μ ↔
  ProbabilityTheory.CondIndep m' (MeasurableSpace.generateFrom {s}) (MeasurableSpace.generateFrom {t}) hm' μ

full_name: ProbabilityTheory.condIndepSet_iff_condIndepSets_singleton
code: theorem condIndepSet_iff_condIndepSets_singleton {s t : Set Ω} (hs_meas : MeasurableSet s)
    (ht_meas : MeasurableSet t) (μ : Measure Ω) [IsFiniteMeasure μ] :
    CondIndepSet m' hm' s t μ ↔ CondIndepSets m' hm' {s} {t} μ 
goal: ProbabilityTheory.CondIndepSet m' hm' s t μ ↔ ProbabilityTheory.CondIndepSets m' hm' {s} {t} μ

full_name: ProbabilityTheory.condIndepSet_iff
code: lemma condIndepSet_iff (s t : Set Ω) (hs : MeasurableSet s) (ht : MeasurableSet t)
    (μ : Measure Ω) [IsFiniteMeasure μ] :
    CondIndepSet m' hm' s t μ ↔ (μ⟦s ∩ t | m'⟧) =ᵐ[μ] (μ⟦s | m'⟧) * (μ⟦t | m'⟧) 
goal: ProbabilityTheory.CondIndepSet m' hm' s t μ ↔
  μ[(s ∩ t).indicator fun ω => 1|m'] =ᵐ[μ] μ[s.indicator fun ω => 1|m'] * μ[t.indicator fun ω => 1|m']

full_name: ProbabilityTheory.iCondIndepFun_iff_iCondIndep
code: lemma iCondIndepFun_iff_iCondIndep {β : ι → Type*}
    (m : ∀ x : ι, MeasurableSpace (β x)) (f : ∀ x : ι, Ω → β x)
    (μ : Measure Ω) [IsFiniteMeasure μ] :
    iCondIndepFun m' hm' m f μ
      ↔ iCondIndep m' hm' (fun x ↦ MeasurableSpace.comap (f x) (m x)) μ 
goal: ProbabilityTheory.iCondIndepFun m' hm' m f μ ↔
  ProbabilityTheory.iCondIndep m' hm' (fun x => MeasurableSpace.comap (f x) (m x)) μ

full_name: ProbabilityTheory.iCondIndepFun_iff
code: lemma iCondIndepFun_iff {β : ι → Type*}
    (m : ∀ x : ι, MeasurableSpace (β x)) (f : ∀ x : ι, Ω → β x) (hf : ∀ i, Measurable (f i))
    (μ : Measure Ω) [IsFiniteMeasure μ] :
    iCondIndepFun m' hm' m f μ
      ↔ ∀ (s : Finset ι) {g : ι → Set Ω} (_H : ∀ i, i ∈ s → MeasurableSet[(m i).comap (f i)] (g i)),
      μ⟦⋂ i ∈ s, g i | m'⟧ =ᵐ[μ] ∏ i ∈ s, (μ⟦g i | m'⟧) 
goal: ProbabilityTheory.iCondIndepFun m' hm' m f μ ↔
  ∀ (s : Finset ι) {g : ι → Set Ω},
    (∀ i ∈ s, MeasurableSet (g i)) →
      μ[(⋂ i ∈ s, g i).indicator fun ω => 1|m'] =ᵐ[μ] ∏ i ∈ s, μ[(g i).indicator fun ω => 1|m']

full_name: ProbabilityTheory.condIndepFun_iff_condIndep
code: lemma condIndepFun_iff_condIndep {β γ : Type*} [mβ : MeasurableSpace β]
    [mγ : MeasurableSpace γ] (f : Ω → β) (g : Ω → γ) (μ : Measure Ω) [IsFiniteMeasure μ] :
    CondIndepFun m' hm' f g μ
      ↔ CondIndep m' (MeasurableSpace.comap f mβ) (MeasurableSpace.comap g mγ) hm' μ 
goal: ProbabilityTheory.CondIndepFun m' hm' f g μ ↔
  ProbabilityTheory.CondIndep m' (MeasurableSpace.comap f mβ) (MeasurableSpace.comap g mγ) hm' μ

full_name: ProbabilityTheory.condIndepFun_iff
code: lemma condIndepFun_iff {β γ : Type*} [mβ : MeasurableSpace β] [mγ : MeasurableSpace γ]
    (f : Ω → β) (g : Ω → γ) (hf : Measurable f) (hg : Measurable g)
    (μ : Measure Ω) [IsFiniteMeasure μ] :
    CondIndepFun m' hm' f g μ ↔ ∀ t1 t2, MeasurableSet[MeasurableSpace.comap f mβ] t1
      → MeasurableSet[MeasurableSpace.comap g mγ] t2
        → (μ⟦t1 ∩ t2 | m'⟧) =ᵐ[μ] (μ⟦t1 | m'⟧) * (μ⟦t2 | m'⟧) 
goal: ProbabilityTheory.CondIndepFun m' hm' f g μ ↔
  ∀ (t1 t2 : Set Ω),
    MeasurableSet t1 →
      MeasurableSet t2 →
        μ[(t1 ∩ t2).indicator fun ω => 1|m'] =ᵐ[μ] μ[t1.indicator fun ω => 1|m'] * μ[t2.indicator fun ω => 1|m']

full_name: ProbabilityTheory.CondIndepSets.symm
code: @[symm]
theorem CondIndepSets.symm {s₁ s₂ : Set (Set Ω)}
    (h : CondIndepSets m' hm' s₁ s₂ μ) : CondIndepSets m' hm' s₂ s₁ μ 
goal: ProbabilityTheory.CondIndepSets m' hm' s₂ s₁ μ

full_name: ProbabilityTheory.condIndepSets_of_condIndepSets_of_le_left
code: theorem condIndepSets_of_condIndepSets_of_le_left {s₁ s₂ s₃ : Set (Set Ω)}
    (h_indep : CondIndepSets m' hm' s₁ s₂ μ) (h31 : s₃ ⊆ s₁) :
    CondIndepSets m' hm' s₃ s₂ μ 
goal: ProbabilityTheory.CondIndepSets m' hm' s₃ s₂ μ

full_name: ProbabilityTheory.condIndepSets_of_condIndepSets_of_le_right
code: theorem condIndepSets_of_condIndepSets_of_le_right {s₁ s₂ s₃ : Set (Set Ω)}
    (h_indep : CondIndepSets m' hm' s₁ s₂ μ) (h32 : s₃ ⊆ s₂) :
    CondIndepSets m' hm' s₁ s₃ μ 
goal: ProbabilityTheory.CondIndepSets m' hm' s₁ s₃ μ

full_name: ProbabilityTheory.CondIndepSets.union
code: theorem CondIndepSets.union {s₁ s₂ s' : Set (Set Ω)}
    (h₁ : CondIndepSets m' hm' s₁ s' μ) (h₂ : CondIndepSets m' hm' s₂ s' μ) :
    CondIndepSets m' hm' (s₁ ∪ s₂) s' μ 
goal: ProbabilityTheory.CondIndepSets m' hm' (s₁ ∪ s₂) s' μ

full_name: ProbabilityTheory.CondIndepSets.union_iff
code: @[simp]
theorem CondIndepSets.union_iff {s₁ s₂ s' : Set (Set Ω)}  :
    CondIndepSets m' hm' (s₁ ∪ s₂) s' μ
      ↔ CondIndepSets m' hm' s₁ s' μ ∧ CondIndepSets m' hm' s₂ s' μ 
goal: ProbabilityTheory.CondIndepSets m' hm' (s₁ ∪ s₂) s' μ ↔
  ProbabilityTheory.CondIndepSets m' hm' s₁ s' μ ∧ ProbabilityTheory.CondIndepSets m' hm' s₂ s' μ

full_name: ProbabilityTheory.CondIndepSets.iUnion
code: theorem CondIndepSets.iUnion {s : ι → Set (Set Ω)} {s' : Set (Set Ω)}
    (hyp : ∀ n, CondIndepSets m' hm' (s n) s' μ) :
    CondIndepSets m' hm' (⋃ n, s n) s' μ 
goal: ProbabilityTheory.CondIndepSets m' hm' (⋃ n, s n) s' μ

full_name: ProbabilityTheory.CondIndepSets.bUnion
code: theorem CondIndepSets.bUnion {s : ι → Set (Set Ω)} {s' : Set (Set Ω)}
    {u : Set ι} (hyp : ∀ n ∈ u, CondIndepSets m' hm' (s n) s' μ) :
    CondIndepSets m' hm' (⋃ n ∈ u, s n) s' μ 
goal: ProbabilityTheory.CondIndepSets m' hm' (⋃ n ∈ u, s n) s' μ

full_name: ProbabilityTheory.CondIndepSets.inter
code: theorem CondIndepSets.inter {s₁ s' : Set (Set Ω)} (s₂ : Set (Set Ω))
    (h₁ : CondIndepSets m' hm' s₁ s' μ) :
    CondIndepSets m' hm' (s₁ ∩ s₂) s' μ 
goal: ProbabilityTheory.CondIndepSets m' hm' (s₁ ∩ s₂) s' μ

full_name: ProbabilityTheory.CondIndepSets.iInter
code: theorem CondIndepSets.iInter {s : ι → Set (Set Ω)} {s' : Set (Set Ω)}
    (h : ∃ n, CondIndepSets m' hm' (s n) s' μ) :
    CondIndepSets m' hm' (⋂ n, s n) s' μ 
goal: ProbabilityTheory.CondIndepSets m' hm' (⋂ n, s n) s' μ

full_name: ProbabilityTheory.CondIndepSets.bInter
code: theorem CondIndepSets.bInter {s : ι → Set (Set Ω)} {s' : Set (Set Ω)}
    {u : Set ι} (h : ∃ n ∈ u, CondIndepSets m' hm' (s n) s' μ) :
    CondIndepSets m' hm' (⋂ n ∈ u, s n) s' μ 
goal: ProbabilityTheory.CondIndepSets m' hm' (⋂ n ∈ u, s n) s' μ

full_name: ProbabilityTheory.condIndepSet_empty_right
code: theorem condIndepSet_empty_right (s : Set Ω) : CondIndepSet m' hm' s ∅ μ 
goal: ProbabilityTheory.CondIndepSet m' hm' s ∅ μ

full_name: ProbabilityTheory.condIndepSet_empty_left
code: theorem condIndepSet_empty_left (s : Set Ω) : CondIndepSet m' hm' ∅ s μ 
goal: ProbabilityTheory.CondIndepSet m' hm' ∅ s μ

full_name: ProbabilityTheory.CondIndep.symm
code: @[symm]
theorem CondIndep.symm {m' m₁ m₂ : MeasurableSpace Ω} {mΩ : MeasurableSpace Ω}
    [StandardBorelSpace Ω] [Nonempty Ω] {hm' : m' ≤ mΩ} {μ : Measure Ω} [IsFiniteMeasure μ]
    (h : CondIndep m' m₁ m₂ hm' μ) :
    CondIndep m' m₂ m₁ hm' μ 
goal: ProbabilityTheory.CondIndep m' m₂ m₁ hm' μ

full_name: ProbabilityTheory.condIndep_bot_right
code: theorem condIndep_bot_right (m₁ : MeasurableSpace Ω) {m' : MeasurableSpace Ω}
    {mΩ : MeasurableSpace Ω} [StandardBorelSpace Ω] [Nonempty Ω]
    {hm' : m' ≤ mΩ} {μ : Measure Ω} [IsFiniteMeasure μ] :
    CondIndep m' m₁ ⊥ hm' μ 
goal: ProbabilityTheory.CondIndep m' m₁ ⊥ hm' μ

full_name: ProbabilityTheory.condIndep_bot_left
code: theorem condIndep_bot_left (m₁ : MeasurableSpace Ω) {m' : MeasurableSpace Ω}
    {mΩ : MeasurableSpace Ω} [StandardBorelSpace Ω] [Nonempty Ω]
    {hm' : m' ≤ mΩ} {μ : Measure Ω} [IsFiniteMeasure μ] :
    CondIndep m' ⊥ m₁ hm' μ 
goal: ProbabilityTheory.CondIndep m' ⊥ m₁ hm' μ

full_name: ProbabilityTheory.condIndep_of_condIndep_of_le_left
code: theorem condIndep_of_condIndep_of_le_left {m' m₁ m₂ m₃ : MeasurableSpace Ω}
    {mΩ : MeasurableSpace Ω} [StandardBorelSpace Ω] [Nonempty Ω]
    {hm' : m' ≤ mΩ} {μ : Measure Ω} [IsFiniteMeasure μ]
    (h_indep : CondIndep m' m₁ m₂ hm' μ) (h31 : m₃ ≤ m₁) :
    CondIndep m' m₃ m₂ hm' μ 
goal: ProbabilityTheory.CondIndep m' m₃ m₂ hm' μ

full_name: ProbabilityTheory.condIndep_of_condIndep_of_le_right
code: theorem condIndep_of_condIndep_of_le_right {m' m₁ m₂ m₃ : MeasurableSpace Ω}
    {mΩ : MeasurableSpace Ω} [StandardBorelSpace Ω] [Nonempty Ω]
    {hm' : m' ≤ mΩ} {μ : Measure Ω} [IsFiniteMeasure μ]
    (h_indep : CondIndep m' m₁ m₂ hm' μ) (h32 : m₃ ≤ m₂) :
    CondIndep m' m₁ m₃ hm' μ 
goal: ProbabilityTheory.CondIndep m' m₁ m₃ hm' μ

full_name: ProbabilityTheory.iCondIndepSets.condIndepSets
code: theorem iCondIndepSets.condIndepSets {s : ι → Set (Set Ω)}
    (h_indep : iCondIndepSets m' hm' s μ) {i j : ι} (hij : i ≠ j) :
    CondIndepSets m' hm' (s i) (s j) μ 
goal: ProbabilityTheory.CondIndepSets m' hm' (s i) (s j) μ

full_name: ProbabilityTheory.iCondIndep.condIndep
code: theorem iCondIndep.condIndep {m : ι → MeasurableSpace Ω}
    (h_indep : iCondIndep m' hm' m μ) {i j : ι} (hij : i ≠ j) :
      CondIndep m' (m i) (m j) hm' μ 
goal: ProbabilityTheory.CondIndep m' (m i) (m j) hm' μ

full_name: ProbabilityTheory.iCondIndepFun.condIndepFun
code: theorem iCondIndepFun.condIndepFun {β : ι → Type*}
    {m : ∀ x, MeasurableSpace (β x)} {f : ∀ i, Ω → β i}
    (hf_Indep : iCondIndepFun m' hm' m f μ) {i j : ι} (hij : i ≠ j) :
    CondIndepFun m' hm' (f i) (f j) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i) (f j) μ

full_name: ProbabilityTheory.iCondIndep.iCondIndepSets
code: theorem iCondIndep.iCondIndepSets {m : ι → MeasurableSpace Ω}
    {s : ι → Set (Set Ω)} (hms : ∀ n, m n = generateFrom (s n))
    (h_indep : iCondIndep m' hm' m μ) :
    iCondIndepSets m' hm' s μ 
goal: ProbabilityTheory.iCondIndepSets m' hm' s μ

full_name: ProbabilityTheory.CondIndep.condIndepSets
code: theorem CondIndep.condIndepSets {s1 s2 : Set (Set Ω)}
    (h_indep : CondIndep m' (generateFrom s1) (generateFrom s2) hm' μ) :
    CondIndepSets m' hm' s1 s2 μ 
goal: ProbabilityTheory.CondIndepSets m' hm' s1 s2 μ

full_name: ProbabilityTheory.CondIndepSets.condIndep
code: theorem CondIndepSets.condIndep
    {p1 p2 : Set (Set Ω)} (h1 : m₁ ≤ mΩ) (h2 : m₂ ≤ mΩ)
    (hp1 : IsPiSystem p1) (hp2 : IsPiSystem p2)
    (hpm1 : m₁ = generateFrom p1) (hpm2 : m₂ = generateFrom p2)
    (hyp : CondIndepSets m' hm' p1 p2 μ) :
    CondIndep m' m₁ m₂ hm' μ 
goal: ProbabilityTheory.CondIndep m' m₁ m₂ hm' μ

full_name: ProbabilityTheory.CondIndepSets.condIndep'
code: theorem CondIndepSets.condIndep'
    {p1 p2 : Set (Set Ω)} (hp1m : ∀ s ∈ p1, MeasurableSet s) (hp2m : ∀ s ∈ p2, MeasurableSet s)
    (hp1 : IsPiSystem p1) (hp2 : IsPiSystem p2) (hyp : CondIndepSets m' hm' p1 p2 μ) :
    CondIndep m' (generateFrom p1) (generateFrom p2) hm' μ 
goal: ProbabilityTheory.CondIndep m' (MeasurableSpace.generateFrom p1) (MeasurableSpace.generateFrom p2) hm' μ

full_name: ProbabilityTheory.condIndepSets_piiUnionInter_of_disjoint
code: theorem condIndepSets_piiUnionInter_of_disjoint {s : ι → Set (Set Ω)}
    {S T : Set ι} (h_indep : iCondIndepSets m' hm' s μ) (hST : Disjoint S T) :
    CondIndepSets m' hm' (piiUnionInter s S) (piiUnionInter s T) μ 
goal: ProbabilityTheory.CondIndepSets m' hm' (piiUnionInter s S) (piiUnionInter s T) μ

full_name: ProbabilityTheory.iCondIndepSet.condIndep_generateFrom_of_disjoint
code: theorem iCondIndepSet.condIndep_generateFrom_of_disjoint {s : ι → Set Ω}
    (hsm : ∀ n, MeasurableSet (s n)) (hs : iCondIndepSet m' hm' s μ) (S T : Set ι)
    (hST : Disjoint S T) :
    CondIndep m' (generateFrom { t | ∃ n ∈ S, s n = t })
      (generateFrom { t | ∃ k ∈ T, s k = t }) hm' μ 
goal: ProbabilityTheory.CondIndep m' (MeasurableSpace.generateFrom {t | ∃ n ∈ S, s n = t})
  (MeasurableSpace.generateFrom {t | ∃ k ∈ T, s k = t}) hm' μ

full_name: ProbabilityTheory.condIndep_iSup_of_disjoint
code: theorem condIndep_iSup_of_disjoint {m : ι → MeasurableSpace Ω}
    (h_le : ∀ i, m i ≤ mΩ) (h_indep : iCondIndep m' hm' m μ) {S T : Set ι} (hST : Disjoint S T) :
    CondIndep m' (⨆ i ∈ S, m i) (⨆ i ∈ T, m i) hm' μ 
goal: ProbabilityTheory.CondIndep m' (⨆ i ∈ S, m i) (⨆ i ∈ T, m i) hm' μ

full_name: ProbabilityTheory.condIndep_iSup_of_directed_le
code: theorem condIndep_iSup_of_directed_le {m : ι → MeasurableSpace Ω}
    (h_indep : ∀ i, CondIndep m' (m i) m₁ hm' μ)
    (h_le : ∀ i, m i ≤ mΩ) (h_le' : m₁ ≤ mΩ) (hm : Directed (· ≤ ·) m) :
    CondIndep m' (⨆ i, m i) m₁ hm' μ 
goal: ProbabilityTheory.CondIndep m' (⨆ i, m i) m₁ hm' μ

full_name: ProbabilityTheory.iCondIndepSet.condIndep_generateFrom_lt
code: theorem iCondIndepSet.condIndep_generateFrom_lt [Preorder ι] {s : ι → Set Ω}
    (hsm : ∀ n, MeasurableSet (s n)) (hs : iCondIndepSet m' hm' s μ) (i : ι) :
    CondIndep m' (generateFrom {s i}) (generateFrom { t | ∃ j < i, s j = t }) hm' μ 
goal: ProbabilityTheory.CondIndep m' (MeasurableSpace.generateFrom {s i})
  (MeasurableSpace.generateFrom {t | ∃ j < i, s j = t}) hm' μ

full_name: ProbabilityTheory.iCondIndepSet.condIndep_generateFrom_le
code: theorem iCondIndepSet.condIndep_generateFrom_le [LinearOrder ι] {s : ι → Set Ω}
    (hsm : ∀ n, MeasurableSet (s n)) (hs : iCondIndepSet m' hm' s μ) (i : ι) {k : ι} (hk : i < k) :
    CondIndep m' (generateFrom {s k}) (generateFrom { t | ∃ j ≤ i, s j = t }) hm' μ 
goal: ProbabilityTheory.CondIndep m' (MeasurableSpace.generateFrom {s k})
  (MeasurableSpace.generateFrom {t | ∃ j ≤ i, s j = t}) hm' μ

full_name: ProbabilityTheory.iCondIndepSet.condIndep_generateFrom_le_nat
code: theorem iCondIndepSet.condIndep_generateFrom_le_nat {s : ℕ → Set Ω}
    (hsm : ∀ n, MeasurableSet (s n)) (hs : iCondIndepSet m' hm' s μ) (n : ℕ) :
    CondIndep m' (generateFrom {s (n + 1)}) (generateFrom { t | ∃ k ≤ n, s k = t }) hm' μ 
goal: ProbabilityTheory.CondIndep m' (MeasurableSpace.generateFrom {s (n + 1)})
  (MeasurableSpace.generateFrom {t | ∃ k ≤ n, s k = t}) hm' μ

full_name: ProbabilityTheory.condIndep_iSup_of_monotone
code: theorem condIndep_iSup_of_monotone [SemilatticeSup ι] {m : ι → MeasurableSpace Ω}
    (h_indep : ∀ i, CondIndep m' (m i) m₁ hm' μ) (h_le : ∀ i, m i ≤ mΩ) (h_le' : m₁ ≤ mΩ)
    (hm : Monotone m) :
    CondIndep m' (⨆ i, m i) m₁ hm' μ 
goal: ProbabilityTheory.CondIndep m' (⨆ i, m i) m₁ hm' μ

full_name: ProbabilityTheory.condIndep_iSup_of_antitone
code: theorem condIndep_iSup_of_antitone [SemilatticeInf ι] {m : ι → MeasurableSpace Ω}
    (h_indep : ∀ i, CondIndep m' (m i) m₁ hm' μ) (h_le : ∀ i, m i ≤ mΩ) (h_le' : m₁ ≤ mΩ)
    (hm : Antitone m) :
    CondIndep m' (⨆ i, m i) m₁ hm' μ 
goal: ProbabilityTheory.CondIndep m' (⨆ i, m i) m₁ hm' μ

full_name: ProbabilityTheory.iCondIndepSets.piiUnionInter_of_not_mem
code: theorem iCondIndepSets.piiUnionInter_of_not_mem {π : ι → Set (Set Ω)} {a : ι} {S : Finset ι}
    (hp_ind : iCondIndepSets m' hm' π μ) (haS : a ∉ S) :
    CondIndepSets m' hm' (piiUnionInter π S) (π a) μ 
goal: ProbabilityTheory.CondIndepSets m' hm' (piiUnionInter π ↑S) (π a) μ

full_name: ProbabilityTheory.iCondIndepSets.iCondIndep
code: /-- The σ-algebras generated by conditionally independent pi-systems are conditionally independent.
-/
theorem iCondIndepSets.iCondIndep (m : ι → MeasurableSpace Ω)
    (h_le : ∀ i, m i ≤ mΩ) (π : ι → Set (Set Ω)) (h_pi : ∀ n, IsPiSystem (π n))
    (h_generate : ∀ i, m i = generateFrom (π i)) (h_ind : iCondIndepSets m' hm' π μ) :
    iCondIndep m' hm' m μ 
goal: ProbabilityTheory.iCondIndep m' hm' m μ

full_name: ProbabilityTheory.CondIndepSets.condIndepSet_of_mem
code: theorem CondIndepSets.condIndepSet_of_mem (hs : s ∈ S) (ht : t ∈ T)
    (hs_meas : MeasurableSet s) (ht_meas : MeasurableSet t) (μ : Measure Ω) [IsFiniteMeasure μ]
    (h_indep : CondIndepSets m' hm' S T μ) :
    CondIndepSet m' hm' s t μ 
goal: ProbabilityTheory.CondIndepSet m' hm' s t μ

full_name: ProbabilityTheory.CondIndep.condIndepSet_of_measurableSet
code: theorem CondIndep.condIndepSet_of_measurableSet {μ : Measure Ω} [IsFiniteMeasure μ]
    (h_indep : CondIndep m' m₁ m₂ hm' μ) {s t : Set Ω} (hs : MeasurableSet[m₁] s)
    (ht : MeasurableSet[m₂] t) :
    CondIndepSet m' hm' s t μ 
goal: ProbabilityTheory.CondIndepSet m' hm' s t μ

full_name: ProbabilityTheory.condIndep_iff_forall_condIndepSet
code: theorem condIndep_iff_forall_condIndepSet (μ : Measure Ω) [IsFiniteMeasure μ] :
    CondIndep m' m₁ m₂ hm' μ ↔ ∀ s t, MeasurableSet[m₁] s → MeasurableSet[m₂] t
      → CondIndepSet m' hm' s t μ 
goal: ProbabilityTheory.CondIndep m' m₁ m₂ hm' μ ↔
  ∀ (s t : Set Ω), MeasurableSet s → MeasurableSet t → ProbabilityTheory.CondIndepSet m' hm' s t μ

full_name: ProbabilityTheory.condIndepFun_iff_condexp_inter_preimage_eq_mul
code: theorem condIndepFun_iff_condexp_inter_preimage_eq_mul {mβ : MeasurableSpace β}
    {mβ' : MeasurableSpace β'} (hf : Measurable f) (hg : Measurable g) :
    CondIndepFun m' hm' f g μ ↔
      ∀ s t, MeasurableSet s → MeasurableSet t
        → (μ⟦f ⁻¹' s ∩ g ⁻¹' t | m'⟧) =ᵐ[μ] fun ω ↦ (μ⟦f ⁻¹' s | m'⟧) ω * (μ⟦g ⁻¹' t | m'⟧) ω 
goal: ProbabilityTheory.CondIndepFun m' hm' f g μ ↔
  ∀ (s : Set β) (t : Set β'),
    MeasurableSet s →
      MeasurableSet t →
        μ[(f ⁻¹' s ∩ g ⁻¹' t).indicator fun ω => 1|m'] =ᵐ[μ] fun ω =>
          (μ[(f ⁻¹' s).indicator fun ω => 1|m']) ω * (μ[(g ⁻¹' t).indicator fun ω => 1|m']) ω

full_name: ProbabilityTheory.iCondIndepFun_iff_condexp_inter_preimage_eq_mul
code: theorem iCondIndepFun_iff_condexp_inter_preimage_eq_mul {β : ι → Type*}
    (m : ∀ x, MeasurableSpace (β x)) (f : ∀ i, Ω → β i) (hf : ∀ i, Measurable (f i)) :
    iCondIndepFun m' hm' m f μ ↔
      ∀ (S : Finset ι) {sets : ∀ i : ι, Set (β i)} (_H : ∀ i, i ∈ S → MeasurableSet[m i] (sets i)),
        (μ⟦⋂ i ∈ S, f i ⁻¹' sets i| m'⟧) =ᵐ[μ] ∏ i ∈ S, (μ⟦f i ⁻¹' sets i | m'⟧) 
goal: ProbabilityTheory.iCondIndepFun m' hm' m f μ ↔
  ∀ (S : Finset ι) {sets : (i : ι) → Set (β i)},
    (∀ i ∈ S, MeasurableSet (sets i)) →
      μ[(⋂ i ∈ S, f i ⁻¹' sets i).indicator fun ω => 1|m'] =ᵐ[μ] ∏ i ∈ S, μ[(f i ⁻¹' sets i).indicator fun ω => 1|m']

full_name: ProbabilityTheory.condIndepFun_iff_condIndepSet_preimage
code: theorem condIndepFun_iff_condIndepSet_preimage {mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'}
    (hf : Measurable f) (hg : Measurable g) :
    CondIndepFun m' hm' f g μ ↔
      ∀ s t, MeasurableSet s → MeasurableSet t → CondIndepSet m' hm' (f ⁻¹' s) (g ⁻¹' t) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' f g μ ↔
  ∀ (s : Set β) (t : Set β'),
    MeasurableSet s → MeasurableSet t → ProbabilityTheory.CondIndepSet m' hm' (f ⁻¹' s) (g ⁻¹' t) μ

full_name: ProbabilityTheory.CondIndepFun.symm
code: @[symm]
nonrec theorem CondIndepFun.symm {_ : MeasurableSpace β} {f g : Ω → β}
    (hfg : CondIndepFun m' hm' f g μ) :
    CondIndepFun m' hm' g f μ 
goal: ∀ {x : MeasurableSpace β} {f g : Ω → β},
  ProbabilityTheory.CondIndepFun m' hm' f g μ → ProbabilityTheory.CondIndepFun m' hm' g f μ

full_name: ProbabilityTheory.CondIndepFun.comp
code: theorem CondIndepFun.comp {γ γ' : Type*} {_mβ : MeasurableSpace β} {_mβ' : MeasurableSpace β'}
    {_mγ : MeasurableSpace γ} {_mγ' : MeasurableSpace γ'} {φ : β → γ} {ψ : β' → γ'}
    (hfg : CondIndepFun m' hm' f g μ) (hφ : Measurable φ) (hψ : Measurable ψ) :
    CondIndepFun m' hm' (φ ∘ f) (ψ ∘ g) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (φ ∘ f) (ψ ∘ g) μ

full_name: ProbabilityTheory.CondIndepFun.neg_right
code: theorem CondIndepFun.neg_right {_mβ : MeasurableSpace β} {_mβ' : MeasurableSpace β'} [Neg β']
    [MeasurableNeg β'] (hfg : CondIndepFun m' hm' f g μ)  :
    CondIndepFun m' hm' f (-g) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' f (-g) μ

full_name: ProbabilityTheory.CondIndepFun.neg_left
code: theorem CondIndepFun.neg_left {_mβ : MeasurableSpace β} {_mβ' : MeasurableSpace β'} [Neg β]
    [MeasurableNeg β] (hfg : CondIndepFun m' hm' f g μ) :
    CondIndepFun m' hm' (-f) g μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (-f) g μ

full_name: ProbabilityTheory.iCondIndepFun.of_subsingleton
code: @[nontriviality]
lemma iCondIndepFun.of_subsingleton [Subsingleton ι] : iCondIndepFun m' hm' m f μ 
goal: ProbabilityTheory.iCondIndepFun m' hm' m f μ

full_name: ProbabilityTheory.iCondIndepFun.condIndepFun_finset
code: /-- If `f` is a family of mutually conditionally independent random variables
(`iCondIndepFun m' hm' m f μ`) and `S, T` are two disjoint finite index sets, then the tuple formed
by `f i` for `i ∈ S` is conditionally independent of the tuple `(f i)_i` for `i ∈ T`. -/
theorem iCondIndepFun.condIndepFun_finset {β : ι → Type*}
    {m : ∀ i, MeasurableSpace (β i)} {f : ∀ i, Ω → β i} (S T : Finset ι) (hST : Disjoint S T)
    (hf_Indep : iCondIndepFun m' hm' m f μ) (hf_meas : ∀ i, Measurable (f i)) :
    CondIndepFun m' hm' (fun a (i : S) => f i a) (fun a (i : T) => f i a) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (fun a i => f (↑i) a) (fun a i => f (↑i) a) μ

full_name: ProbabilityTheory.iCondIndepFun.condIndepFun_prod_mk
code: theorem iCondIndepFun.condIndepFun_prod_mk {β : ι → Type*}
    {m : ∀ i, MeasurableSpace (β i)} {f : ∀ i, Ω → β i} (hf_Indep : iCondIndepFun m' hm' m f μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hik : i ≠ k) (hjk : j ≠ k) :
    CondIndepFun m' hm' (fun a => (f i a, f j a)) (f k) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (fun a => (f i a, f j a)) (f k) μ

full_name: ProbabilityTheory.iCondIndepFun.condIndepFun_prod_mk_prod_mk
code: lemma iCondIndepFun.condIndepFun_prod_mk_prod_mk (h_indep : iCondIndepFun m' hm' m f μ)
    (hf : ∀ i, Measurable (f i))
    (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l) :
    CondIndepFun m' hm' (fun a ↦ (f i a, f j a)) (fun a ↦ (f k a, f l a)) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (fun a => (f i a, f j a)) (fun a => (f k a, f l a)) μ

full_name: ProbabilityTheory.iCondIndepFun.indepFun_add_left
code: @[to_additive]
lemma iCondIndepFun.indepFun_mul_left (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hik : i ≠ k) (hjk : j ≠ k) :
    CondIndepFun m' hm' (f i * f j) (f k) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i + f j) (f k) μ

full_name: ProbabilityTheory.iCondIndepFun.indepFun_mul_left
code: @[to_additive]
lemma iCondIndepFun.indepFun_mul_left (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hik : i ≠ k) (hjk : j ≠ k) :
    CondIndepFun m' hm' (f i * f j) (f k) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i * f j) (f k) μ

full_name: ProbabilityTheory.iCondIndepFun.indepFun_add_right
code: @[to_additive]
lemma iCondIndepFun.indepFun_mul_right (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hij : i ≠ j) (hik : i ≠ k) :
    CondIndepFun m' hm' (f i) (f j * f k) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i) (f j + f k) μ

full_name: ProbabilityTheory.iCondIndepFun.indepFun_mul_right
code: @[to_additive]
lemma iCondIndepFun.indepFun_mul_right (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hij : i ≠ j) (hik : i ≠ k) :
    CondIndepFun m' hm' (f i) (f j * f k) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i) (f j * f k) μ

full_name: ProbabilityTheory.iCondIndepFun.indepFun_mul_mul
code: @[to_additive]
lemma iCondIndepFun.indepFun_mul_mul (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i))
    (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l) :
    CondIndepFun m' hm' (f i * f j) (f k * f l) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i * f j) (f k * f l) μ

full_name: ProbabilityTheory.iCondIndepFun.indepFun_add_add
code: @[to_additive]
lemma iCondIndepFun.indepFun_mul_mul (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i))
    (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l) :
    CondIndepFun m' hm' (f i * f j) (f k * f l) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i + f j) (f k + f l) μ

full_name: ProbabilityTheory.iCondIndepFun.indepFun_sub_left
code: @[to_additive]
lemma iCondIndepFun.indepFun_div_left (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hik : i ≠ k) (hjk : j ≠ k) :
    CondIndepFun m' hm' (f i / f j) (f k) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i - f j) (f k) μ

full_name: ProbabilityTheory.iCondIndepFun.indepFun_div_left
code: @[to_additive]
lemma iCondIndepFun.indepFun_div_left (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hik : i ≠ k) (hjk : j ≠ k) :
    CondIndepFun m' hm' (f i / f j) (f k) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i / f j) (f k) μ

full_name: ProbabilityTheory.iCondIndepFun.indepFun_div_right
code: @[to_additive]
lemma iCondIndepFun.indepFun_div_right (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hij : i ≠ j) (hik : i ≠ k) :
    CondIndepFun m' hm' (f i) (f j / f k) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i) (f j / f k) μ

full_name: ProbabilityTheory.iCondIndepFun.indepFun_sub_right
code: @[to_additive]
lemma iCondIndepFun.indepFun_div_right (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) (i j k : ι) (hij : i ≠ j) (hik : i ≠ k) :
    CondIndepFun m' hm' (f i) (f j / f k) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i) (f j - f k) μ

full_name: ProbabilityTheory.iCondIndepFun.indepFun_sub_sub
code: @[to_additive]
lemma iCondIndepFun.indepFun_div_div (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i))
    (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l) :
    CondIndepFun m' hm' (f i / f j) (f k / f l) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i - f j) (f k - f l) μ

full_name: ProbabilityTheory.iCondIndepFun.indepFun_div_div
code: @[to_additive]
lemma iCondIndepFun.indepFun_div_div (hf_indep : iCondIndepFun m' hm' (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i))
    (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l) :
    CondIndepFun m' hm' (f i / f j) (f k / f l) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (f i / f j) (f k / f l) μ

full_name: ProbabilityTheory.iCondIndepFun.condIndepFun_finset_prod_of_not_mem
code: @[to_additive]
theorem iCondIndepFun.condIndepFun_finset_prod_of_not_mem
    (hf_Indep : iCondIndepFun m' hm' (fun _ => m) f μ) (hf_meas : ∀ i, Measurable (f i))
    {s : Finset ι} {i : ι} (hi : i ∉ s) :
    CondIndepFun m' hm' (∏ j ∈ s, f j) (f i) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (∏ j ∈ s, f j) (f i) μ

full_name: ProbabilityTheory.iCondIndepFun.condIndepFun_finset_sum_of_not_mem
code: @[to_additive]
theorem iCondIndepFun.condIndepFun_finset_prod_of_not_mem
    (hf_Indep : iCondIndepFun m' hm' (fun _ => m) f μ) (hf_meas : ∀ i, Measurable (f i))
    {s : Finset ι} {i : ι} (hi : i ∉ s) :
    CondIndepFun m' hm' (∏ j ∈ s, f j) (f i) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (∑ j ∈ s, f j) (f i) μ

full_name: ProbabilityTheory.iCondIndepFun.condIndepFun_sum_range_succ
code: @[to_additive]
theorem iCondIndepFun.condIndepFun_prod_range_succ {f : ℕ → Ω → β}
    (hf_Indep : iCondIndepFun m' hm' (fun _ => m) f μ) (hf_meas : ∀ i, Measurable (f i)) (n : ℕ) :
    CondIndepFun m' hm' (∏ j ∈ Finset.range n, f j) (f n) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (∑ j ∈ Finset.range n, f j) (f n) μ

full_name: ProbabilityTheory.iCondIndepFun.condIndepFun_prod_range_succ
code: @[to_additive]
theorem iCondIndepFun.condIndepFun_prod_range_succ {f : ℕ → Ω → β}
    (hf_Indep : iCondIndepFun m' hm' (fun _ => m) f μ) (hf_meas : ∀ i, Measurable (f i)) (n : ℕ) :
    CondIndepFun m' hm' (∏ j ∈ Finset.range n, f j) (f n) μ 
goal: ProbabilityTheory.CondIndepFun m' hm' (∏ j ∈ Finset.range n, f j) (f n) μ

full_name: ProbabilityTheory.iCondIndepSet.iCondIndepFun_indicator
code: theorem iCondIndepSet.iCondIndepFun_indicator [Zero β] [One β] {m : MeasurableSpace β}
    {s : ι → Set Ω} (hs : iCondIndepSet m' hm' s μ) :
    iCondIndepFun m' hm' (fun _n => m) (fun n => (s n).indicator fun _ω => 1) μ 
goal: ProbabilityTheory.iCondIndepFun m' hm' (fun _n => m) (fun n => (s n).indicator fun _ω => 1) μ