File: Mathlib/Probability/Independence/Basic.lean

full_name: ProbabilityTheory.iIndepSets
code: /-- A family of sets of sets `π : ι → Set (Set Ω)` is independent 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) = ∏ i ∈ s, μ (f i) `.
It will be used for families of pi_systems. -/
def iIndepSets {_mΩ : MeasurableSpace Ω}
    (π : ι → Set (Set Ω)) (μ : Measure Ω := by volume_tac) : Prop 
goal: Prop

full_name: ProbabilityTheory.IndepSets
code: /-- Two sets of sets `s₁, s₂` are independent with respect to a measure `μ` if for any sets
`t₁ ∈ p₁, t₂ ∈ s₂`, then `μ (t₁ ∩ t₂) = μ (t₁) * μ (t₂)` -/
def IndepSets {_mΩ : MeasurableSpace Ω}
    (s1 s2 : Set (Set Ω)) (μ : Measure Ω := by volume_tac) : Prop 
goal: Prop

full_name: ProbabilityTheory.iIndep
code: /-- A family of measurable space structures (i.e. of σ-algebras) is independent 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 independent 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) = ∏ i ∈ s, μ (f i)`. -/
def iIndep (m : ι → MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : Measure Ω := by volume_tac) :
    Prop 
goal: Prop

full_name: ProbabilityTheory.Indep
code: /-- Two measurable space structures (or σ-algebras) `m₁, m₂` are independent with respect to a
measure `μ` (defined on a third σ-algebra) if for any sets `t₁ ∈ m₁, t₂ ∈ m₂`,
`μ (t₁ ∩ t₂) = μ (t₁) * μ (t₂)` -/
def Indep (m₁ m₂ : MeasurableSpace Ω)
    {_mΩ : MeasurableSpace Ω} (μ : Measure Ω := by volume_tac) : Prop 
goal: Prop

full_name: ProbabilityTheory.iIndepSet
code: /-- A family of sets is independent if the family of measurable space structures they generate is
independent. For a set `s`, the generated measurable space has measurable sets `∅, s, sᶜ, univ`. -/
def iIndepSet {_mΩ : MeasurableSpace Ω} (s : ι → Set Ω) (μ : Measure Ω := by volume_tac) : Prop 
goal: Prop

full_name: ProbabilityTheory.IndepSet
code: /-- Two sets are independent if the two measurable space structures they generate are independent.
For a set `s`, the generated measurable space structure has measurable sets `∅, s, sᶜ, univ`. -/
def IndepSet {_mΩ : MeasurableSpace Ω} (s t : Set Ω) (μ : Measure Ω := by volume_tac) : Prop 
goal: Prop

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

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

full_name: ProbabilityTheory.iIndepSets_iff
code: lemma iIndepSets_iff (π : ι → Set (Set Ω)) (μ : Measure Ω) :
    iIndepSets π μ ↔ ∀ (s : Finset ι) {f : ι → Set Ω} (_H : ∀ i, i ∈ s → f i ∈ π i),
      μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i) 
goal: ∀ {x : MeasurableSpace Ω} (π : ι → Set (Set Ω)) (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.iIndepSets π μ ↔
    ∀ (s : Finset ι) {f : ι → Set Ω}, (∀ i ∈ s, f i ∈ π i) → μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i)

full_name: ProbabilityTheory.iIndepSets.meas_biInter
code: lemma iIndepSets.meas_biInter (h : iIndepSets π μ) (s : Finset ι) {f : ι → Set Ω}
    (hf : ∀ i, i ∈ s → f i ∈ π i) : μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i) 
goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω},
  ProbabilityTheory.iIndepSets π μ →
    ∀ (s : Finset ι) {f : ι → Set Ω}, (∀ i ∈ s, f i ∈ π i) → μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i)

full_name: ProbabilityTheory.iIndepSets.meas_iInter
code: lemma iIndepSets.meas_iInter [Fintype ι] (h : iIndepSets π μ) (hs : ∀ i, s i ∈ π i) :
    μ (⋂ i, s i) = ∏ i, μ (s i) 
goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s : ι → Set Ω} [inst : Fintype ι],
  ProbabilityTheory.iIndepSets π μ → (∀ (i : ι), s i ∈ π i) → μ (⋂ i, s i) = ∏ i : ι, μ (s i)

full_name: ProbabilityTheory.IndepSets_iff
code: lemma IndepSets_iff (s1 s2 : Set (Set Ω)) (μ : Measure Ω) :
    IndepSets s1 s2 μ ↔ ∀ t1 t2 : Set Ω, t1 ∈ s1 → t2 ∈ s2 → (μ (t1 ∩ t2) = μ t1 * μ t2) 
goal: ∀ {x : MeasurableSpace Ω} (s1 s2 : Set (Set Ω)) (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.IndepSets s1 s2 μ ↔ ∀ (t1 t2 : Set Ω), t1 ∈ s1 → t2 ∈ s2 → μ (t1 ∩ t2) = μ t1 * μ t2

full_name: ProbabilityTheory.iIndep_iff_iIndepSets
code: lemma iIndep_iff_iIndepSets (m : ι → MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : Measure Ω) :
    iIndep m μ ↔ iIndepSets (fun x ↦ {s | MeasurableSet[m x] s}) μ 
goal: ProbabilityTheory.iIndep m μ ↔ ProbabilityTheory.iIndepSets (fun x => {s | MeasurableSet s}) μ

full_name: ProbabilityTheory.iIndep.iIndepSets'
code: lemma iIndep.iIndepSets' {m : ι → MeasurableSpace Ω}
    {_ : MeasurableSpace Ω} {μ : Measure Ω} (hμ : iIndep m μ) :
    iIndepSets (fun x ↦ {s | MeasurableSet[m x] s}) μ 
goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω},
  ProbabilityTheory.iIndep m μ → ProbabilityTheory.iIndepSets (fun x => {s | MeasurableSet s}) μ

full_name: ProbabilityTheory.iIndep_iff
code: lemma iIndep_iff (m : ι → MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : Measure Ω) :
    iIndep m μ ↔ ∀ (s : Finset ι) {f : ι → Set Ω} (_H : ∀ i, i ∈ s → MeasurableSet[m i] (f i)),
      μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i) 
goal: ProbabilityTheory.iIndep m μ ↔
  ∀ (s : Finset ι) {f : ι → Set Ω}, (∀ i ∈ s, MeasurableSet (f i)) → μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i)

full_name: ProbabilityTheory.iIndep.meas_biInter
code: lemma iIndep.meas_biInter (hμ : iIndep m μ) (hs : ∀ i, i ∈ S → MeasurableSet[m i] (s i)) :
    μ (⋂ i ∈ S, s i) = ∏ i ∈ S, μ (s i) 
goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {S : Finset ι} {s : ι → Set Ω},
  ProbabilityTheory.iIndep m μ → (∀ i ∈ S, MeasurableSet (s i)) → μ (⋂ i ∈ S, s i) = ∏ i ∈ S, μ (s i)

full_name: ProbabilityTheory.iIndep.meas_iInter
code: lemma iIndep.meas_iInter [Fintype ι] (hμ : iIndep m μ) (hs : ∀ i, MeasurableSet[m i] (s i)) :
    μ (⋂ i, s i) = ∏ i, μ (s i) 
goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s : ι → Set Ω} [inst : Fintype ι],
  ProbabilityTheory.iIndep m μ → (∀ (i : ι), MeasurableSet (s i)) → μ (⋂ i, s i) = ∏ i : ι, μ (s i)

full_name: ProbabilityTheory.Indep_iff_IndepSets
code: lemma Indep_iff_IndepSets (m₁ m₂ : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : Measure Ω) :
    Indep m₁ m₂ μ ↔ IndepSets {s | MeasurableSet[m₁] s} {s | MeasurableSet[m₂] s} μ 
goal: ProbabilityTheory.Indep m₁ m₂ μ ↔ ProbabilityTheory.IndepSets {s | MeasurableSet s} {s | MeasurableSet s} μ

full_name: ProbabilityTheory.Indep_iff
code: lemma Indep_iff (m₁ m₂ : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : Measure Ω) :
    Indep m₁ m₂ μ
      ↔ ∀ t1 t2, MeasurableSet[m₁] t1 → MeasurableSet[m₂] t2 → μ (t1 ∩ t2) = μ t1 * μ t2 
goal: ProbabilityTheory.Indep m₁ m₂ μ ↔ ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2

full_name: ProbabilityTheory.iIndepSet_iff_iIndep
code: lemma iIndepSet_iff_iIndep (s : ι → Set Ω) (μ : Measure Ω) :
    iIndepSet s μ ↔ iIndep (fun i ↦ generateFrom {s i}) μ 
goal: ∀ {x : MeasurableSpace Ω} (s : ι → Set Ω) (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.iIndepSet s μ ↔ ProbabilityTheory.iIndep (fun i => MeasurableSpace.generateFrom {s i}) μ

full_name: ProbabilityTheory.iIndepSet_iff
code: lemma iIndepSet_iff (s : ι → Set Ω) (μ : Measure Ω) :
    iIndepSet s μ ↔ ∀ (s' : Finset ι) {f : ι → Set Ω}
      (_H : ∀ i, i ∈ s' → MeasurableSet[generateFrom {s i}] (f i)),
      μ (⋂ i ∈ s', f i) = ∏ i ∈ s', μ (f i) 
goal: ∀ {x : MeasurableSpace Ω} (s : ι → Set Ω) (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.iIndepSet s μ ↔
    ∀ (s' : Finset ι) {f : ι → Set Ω}, (∀ i ∈ s', MeasurableSet (f i)) → μ (⋂ i ∈ s', f i) = ∏ i ∈ s', μ (f i)

full_name: ProbabilityTheory.IndepSet_iff_Indep
code: lemma IndepSet_iff_Indep (s t : Set Ω) (μ : Measure Ω) :
    IndepSet s t μ ↔ Indep (generateFrom {s}) (generateFrom {t}) μ 
goal: ∀ {x : MeasurableSpace Ω} (s t : Set Ω) (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.IndepSet s t μ ↔
    ProbabilityTheory.Indep (MeasurableSpace.generateFrom {s}) (MeasurableSpace.generateFrom {t}) μ

full_name: ProbabilityTheory.IndepSet_iff
code: lemma IndepSet_iff (s t : Set Ω) (μ : Measure Ω) :
    IndepSet s t μ ↔ ∀ t1 t2, MeasurableSet[generateFrom {s}] t1
      → MeasurableSet[generateFrom {t}] t2 → μ (t1 ∩ t2) = μ t1 * μ t2 
goal: ∀ {x : MeasurableSpace Ω} (s t : Set Ω) (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.IndepSet s t μ ↔ ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2

full_name: ProbabilityTheory.iIndepFun_iff_iIndep
code: lemma iIndepFun_iff_iIndep {β : ι → Type*}
    (m : ∀ x : ι, MeasurableSpace (β x)) (f : ∀ x : ι, Ω → β x) (μ : Measure Ω) :
    iIndepFun m f μ ↔ iIndep (fun x ↦ (m x).comap (f x)) μ 
goal: ∀ {x : MeasurableSpace Ω} {β : ι → Type u_6} (m : (x : ι) → MeasurableSpace (β x)) (f : (x : ι) → Ω → β x)
  (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.iIndepFun m f μ ↔ ProbabilityTheory.iIndep (fun x => MeasurableSpace.comap (f x) (m x)) μ

full_name: ProbabilityTheory.iIndepFun.iIndep
code: protected lemma iIndepFun.iIndep {m : ∀ i, MeasurableSpace (κ i)} {f : ∀ x : ι, Ω → κ x}
    (hf : iIndepFun m f μ) :
    iIndep (fun x ↦ (m x).comap (f x)) μ 
goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {m : (i : ι) → MeasurableSpace (κ i)} {f : (x : ι) → Ω → κ x},
  ProbabilityTheory.iIndepFun m f μ → ProbabilityTheory.iIndep (fun x => MeasurableSpace.comap (f x) (m x)) μ

full_name: ProbabilityTheory.iIndepFun_iff
code: lemma iIndepFun_iff {β : ι → Type*}
    (m : ∀ x : ι, MeasurableSpace (β x)) (f : ∀ x : ι, Ω → β x) (μ : Measure Ω) :
    iIndepFun m f μ ↔ ∀ (s : Finset ι) {f' : ι → Set Ω}
      (_H : ∀ i, i ∈ s → MeasurableSet[(m i).comap (f i)] (f' i)),
      μ (⋂ i ∈ s, f' i) = ∏ i ∈ s, μ (f' i) 
goal: ∀ {x : MeasurableSpace Ω} {β : ι → Type u_6} (m : (x : ι) → MeasurableSpace (β x)) (f : (x : ι) → Ω → β x)
  (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.iIndepFun m f μ ↔
    ∀ (s : Finset ι) {f' : ι → Set Ω}, (∀ i ∈ s, MeasurableSet (f' i)) → μ (⋂ i ∈ s, f' i) = ∏ i ∈ s, μ (f' i)

full_name: ProbabilityTheory.iIndepFun.meas_biInter
code: lemma iIndepFun.meas_biInter {m : ∀ i, MeasurableSpace (κ i)} {f : ∀ x : ι, Ω → κ x}
    (hf : iIndepFun m f μ) (hs : ∀ i, i ∈ S → MeasurableSet[(m i).comap (f i)] (s i)) :
    μ (⋂ i ∈ S, s i) = ∏ i ∈ S, μ (s i) 
goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {S : Finset ι} {s : ι → Set Ω}
  {m : (i : ι) → MeasurableSpace (κ i)} {f : (x : ι) → Ω → κ x},
  ProbabilityTheory.iIndepFun m f μ → (∀ i ∈ S, MeasurableSet (s i)) → μ (⋂ i ∈ S, s i) = ∏ i ∈ S, μ (s i)

full_name: ProbabilityTheory.iIndepFun.meas_iInter
code: lemma iIndepFun.meas_iInter [Fintype ι] {m : ∀ i, MeasurableSpace (κ i)} {f : ∀ x : ι, Ω → κ x}
    (hf : iIndepFun m f μ) (hs : ∀ i, MeasurableSet[(m i).comap (f i)] (s i)) :
    μ (⋂ i, s i) = ∏ i, μ (s i) 
goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s : ι → Set Ω} [inst : Fintype ι]
  {m : (i : ι) → MeasurableSpace (κ i)} {f : (x : ι) → Ω → κ x},
  ProbabilityTheory.iIndepFun m f μ → (∀ (i : ι), MeasurableSet (s i)) → μ (⋂ i, s i) = ∏ i : ι, μ (s i)

full_name: ProbabilityTheory.IndepFun_iff_Indep
code: lemma IndepFun_iff_Indep [mβ : MeasurableSpace β]
    [mγ : MeasurableSpace γ] (f : Ω → β) (g : Ω → γ) (μ : Measure Ω) :
    IndepFun f g μ ↔ Indep (MeasurableSpace.comap f mβ) (MeasurableSpace.comap g mγ) μ 
goal: ∀ {x : MeasurableSpace Ω} [mβ : MeasurableSpace β] [mγ : MeasurableSpace γ] (f : Ω → β) (g : Ω → γ)
  (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.IndepFun f g μ ↔ ProbabilityTheory.Indep (MeasurableSpace.comap f mβ) (MeasurableSpace.comap g mγ) μ

full_name: ProbabilityTheory.IndepFun_iff
code: lemma IndepFun_iff {β γ} [mβ : MeasurableSpace β] [mγ : MeasurableSpace γ]
    (f : Ω → β) (g : Ω → γ) (μ : Measure Ω) :
    IndepFun f g μ ↔ ∀ t1 t2, MeasurableSet[MeasurableSpace.comap f mβ] t1
      → MeasurableSet[MeasurableSpace.comap g mγ] t2 → μ (t1 ∩ t2) = μ t1 * μ t2 
goal: ∀ {x : MeasurableSpace Ω} {β : Type u_6} {γ : Type u_7} [mβ : MeasurableSpace β] [mγ : MeasurableSpace γ] (f : Ω → β)
  (g : Ω → γ) (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.IndepFun f g μ ↔ ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2

full_name: ProbabilityTheory.IndepFun.meas_inter
code: lemma IndepFun.meas_inter [mβ : MeasurableSpace β] [mγ : MeasurableSpace γ] {f : Ω → β} {g : Ω → γ}
    (hfg : IndepFun f g μ) {s t : Set Ω} (hs : MeasurableSet[mβ.comap f] s)
    (ht : MeasurableSet[mγ.comap g] t) :
    μ (s ∩ t) = μ s * μ t 
goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [mβ : MeasurableSpace β] [mγ : MeasurableSpace γ] {f : Ω → β}
  {g : Ω → γ},
  ProbabilityTheory.IndepFun f g μ → ∀ {s t : Set Ω}, MeasurableSet s → MeasurableSet t → μ (s ∩ t) = μ s * μ t

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

full_name: ProbabilityTheory.Indep.symm
code: @[symm]
theorem Indep.symm (h : Indep m₁ m₂ μ) : Indep m₂ m₁ μ 
goal: ProbabilityTheory.Indep m₂ m₁ μ

full_name: ProbabilityTheory.indep_bot_right
code: theorem indep_bot_right [IsProbabilityMeasure μ] : Indep m' ⊥ μ 
goal: ProbabilityTheory.Indep m' ⊥ μ

full_name: ProbabilityTheory.indep_bot_left
code: theorem indep_bot_left [IsProbabilityMeasure μ] : Indep ⊥ m' μ 
goal: ProbabilityTheory.Indep ⊥ m' μ

full_name: ProbabilityTheory.indepSet_empty_right
code: theorem indepSet_empty_right [IsProbabilityMeasure μ] (s : Set Ω) : IndepSet s ∅ μ 
goal: ProbabilityTheory.IndepSet s ∅ μ

full_name: ProbabilityTheory.indepSet_empty_left
code: theorem indepSet_empty_left [IsProbabilityMeasure μ] (s : Set Ω) : IndepSet ∅ s μ 
goal: ProbabilityTheory.IndepSet ∅ s μ

full_name: ProbabilityTheory.indepSets_of_indepSets_of_le_left
code: theorem indepSets_of_indepSets_of_le_left {s₁ s₂ s₃ : Set (Set Ω)}
    (h_indep : IndepSets s₁ s₂ μ) (h31 : s₃ ⊆ s₁) :
    IndepSets s₃ s₂ μ 
goal: ProbabilityTheory.IndepSets s₃ s₂ μ

full_name: ProbabilityTheory.indepSets_of_indepSets_of_le_right
code: theorem indepSets_of_indepSets_of_le_right {s₁ s₂ s₃ : Set (Set Ω)}
    (h_indep : IndepSets s₁ s₂ μ) (h32 : s₃ ⊆ s₂) :
    IndepSets s₁ s₃ μ 
goal: ProbabilityTheory.IndepSets s₁ s₃ μ

full_name: ProbabilityTheory.indep_of_indep_of_le_left
code: theorem indep_of_indep_of_le_left (h_indep : Indep m₁ m₂ μ) (h31 : m₃ ≤ m₁) :
    Indep m₃ m₂ μ 
goal: ProbabilityTheory.Indep m₃ m₂ μ

full_name: ProbabilityTheory.indep_of_indep_of_le_right
code: theorem indep_of_indep_of_le_right (h_indep : Indep m₁ m₂ μ) (h32 : m₃ ≤ m₂) :
    Indep m₁ m₃ μ 
goal: ProbabilityTheory.Indep m₁ m₃ μ

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

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

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

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

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

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

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

full_name: ProbabilityTheory.indepSets_singleton_iff
code: theorem indepSets_singleton_iff {s t : Set Ω} :
    IndepSets {s} {t} μ ↔ μ (s ∩ t) = μ s * μ t 
goal: ProbabilityTheory.IndepSets {s} {t} μ ↔ μ (s ∩ t) = μ s * μ t

full_name: ProbabilityTheory.iIndepSets.indepSets
code: theorem iIndepSets.indepSets {s : ι → Set (Set Ω)}
    (h_indep : iIndepSets s μ) {i j : ι} (hij : i ≠ j) : IndepSets (s i) (s j) μ 
goal: ProbabilityTheory.IndepSets (s i) (s j) μ

full_name: ProbabilityTheory.iIndep.indep
code: theorem iIndep.indep
    (h_indep : iIndep m μ) {i j : ι} (hij : i ≠ j) : Indep (m i) (m j) μ 
goal: ProbabilityTheory.Indep (m i) (m j) μ

full_name: ProbabilityTheory.iIndepFun.indepFun
code: theorem iIndepFun.indepFun {β : ι → Type*}
    {m : ∀ x, MeasurableSpace (β x)} {f : ∀ i, Ω → β i} (hf_Indep : iIndepFun m f μ) {i j : ι}
    (hij : i ≠ j) :
    IndepFun (f i) (f j) μ 
goal: ProbabilityTheory.IndepFun (f i) (f j) μ

full_name: ProbabilityTheory.iIndep.iIndepSets
code: theorem iIndep.iIndepSets
    {s : ι → Set (Set Ω)} (hms : ∀ n, m n = generateFrom (s n)) (h_indep : iIndep m μ) :
    iIndepSets s μ 
goal: ProbabilityTheory.iIndepSets s μ

full_name: ProbabilityTheory.Indep.indepSets
code: theorem Indep.indepSets {s1 s2 : Set (Set Ω)}
    (h_indep : Indep (generateFrom s1) (generateFrom s2) μ) :
    IndepSets s1 s2 μ 
goal: ProbabilityTheory.IndepSets s1 s2 μ

full_name: ProbabilityTheory.IndepSets.indep
code: theorem IndepSets.indep [IsProbabilityMeasure μ]
    {p1 p2 : Set (Set Ω)} (h1 : m1 ≤ _mΩ) (h2 : m2 ≤ _mΩ) (hp1 : IsPiSystem p1)
    (hp2 : IsPiSystem p2) (hpm1 : m1 = generateFrom p1) (hpm2 : m2 = generateFrom p2)
    (hyp : IndepSets p1 p2 μ) :
    Indep m1 m2 μ 
goal: ProbabilityTheory.Indep m1 m2 μ

full_name: ProbabilityTheory.IndepSets.indep'
code: theorem IndepSets.indep' [IsProbabilityMeasure μ]
    {p1 p2 : Set (Set Ω)} (hp1m : ∀ s ∈ p1, MeasurableSet s) (hp2m : ∀ s ∈ p2, MeasurableSet s)
    (hp1 : IsPiSystem p1) (hp2 : IsPiSystem p2) (hyp : IndepSets p1 p2 μ) :
    Indep (generateFrom p1) (generateFrom p2) μ 
goal: ProbabilityTheory.Indep (MeasurableSpace.generateFrom p1) (MeasurableSpace.generateFrom p2) μ

full_name: ProbabilityTheory.indepSets_piiUnionInter_of_disjoint
code: theorem indepSets_piiUnionInter_of_disjoint [IsProbabilityMeasure μ] {s : ι → Set (Set Ω)}
    {S T : Set ι} (h_indep : iIndepSets s μ) (hST : Disjoint S T) :
    IndepSets (piiUnionInter s S) (piiUnionInter s T) μ 
goal: ProbabilityTheory.IndepSets (piiUnionInter s S) (piiUnionInter s T) μ

full_name: ProbabilityTheory.iIndepSet.indep_generateFrom_of_disjoint
code: theorem iIndepSet.indep_generateFrom_of_disjoint [IsProbabilityMeasure μ] {s : ι → Set Ω}
    (hsm : ∀ n, MeasurableSet (s n)) (hs : iIndepSet s μ) (S T : Set ι) (hST : Disjoint S T) :
    Indep (generateFrom { t | ∃ n ∈ S, s n = t }) (generateFrom { t | ∃ k ∈ T, s k = t }) μ 
goal: ProbabilityTheory.Indep (MeasurableSpace.generateFrom {t | ∃ n ∈ S, s n = t})
  (MeasurableSpace.generateFrom {t | ∃ k ∈ T, s k = t}) μ

full_name: ProbabilityTheory.indep_iSup_of_disjoint
code: theorem indep_iSup_of_disjoint [IsProbabilityMeasure μ]
    (h_le : ∀ i, m i ≤ _mΩ) (h_indep : iIndep m μ) {S T : Set ι} (hST : Disjoint S T) :
    Indep (⨆ i ∈ S, m i) (⨆ i ∈ T, m i) μ 
goal: ProbabilityTheory.Indep (⨆ i ∈ S, m i) (⨆ i ∈ T, m i) μ

full_name: ProbabilityTheory.indep_iSup_of_directed_le
code: theorem indep_iSup_of_directed_le
    [IsProbabilityMeasure μ] (h_indep : ∀ i, Indep (m i) m1 μ)
    (h_le : ∀ i, m i ≤ _mΩ) (h_le' : m1 ≤ _mΩ) (hm : Directed (· ≤ ·) m) :
    Indep (⨆ i, m i) m1 μ 
goal: ProbabilityTheory.Indep (⨆ i, m i) m1 μ

full_name: ProbabilityTheory.iIndepSet.indep_generateFrom_lt
code: theorem iIndepSet.indep_generateFrom_lt [Preorder ι] [IsProbabilityMeasure μ] {s : ι → Set Ω}
    (hsm : ∀ n, MeasurableSet (s n)) (hs : iIndepSet s μ) (i : ι) :
    Indep (generateFrom {s i}) (generateFrom { t | ∃ j < i, s j = t }) μ 
goal: ProbabilityTheory.Indep (MeasurableSpace.generateFrom {s i}) (MeasurableSpace.generateFrom {t | ∃ j < i, s j = t}) μ

full_name: ProbabilityTheory.iIndepSet.indep_generateFrom_le
code: theorem iIndepSet.indep_generateFrom_le [LinearOrder ι] [IsProbabilityMeasure μ] {s : ι → Set Ω}
    (hsm : ∀ n, MeasurableSet (s n)) (hs : iIndepSet s μ) (i : ι) {k : ι} (hk : i < k) :
    Indep (generateFrom {s k}) (generateFrom { t | ∃ j ≤ i, s j = t }) μ 
goal: ProbabilityTheory.Indep (MeasurableSpace.generateFrom {s k}) (MeasurableSpace.generateFrom {t | ∃ j ≤ i, s j = t}) μ

full_name: ProbabilityTheory.iIndepSet.indep_generateFrom_le_nat
code: theorem iIndepSet.indep_generateFrom_le_nat [IsProbabilityMeasure μ] {s : ℕ → Set Ω}
    (hsm : ∀ n, MeasurableSet (s n)) (hs : iIndepSet s μ) (n : ℕ) :
    Indep (generateFrom {s (n + 1)}) (generateFrom { t | ∃ k ≤ n, s k = t }) μ 
goal: ProbabilityTheory.Indep (MeasurableSpace.generateFrom {s (n + 1)}) (MeasurableSpace.generateFrom {t | ∃ k ≤ n, s k = t})
  μ

full_name: ProbabilityTheory.indep_iSup_of_monotone
code: theorem indep_iSup_of_monotone [SemilatticeSup ι] [IsProbabilityMeasure μ]
    (h_indep : ∀ i, Indep (m i) m1 μ) (h_le : ∀ i, m i ≤ _mΩ) (h_le' : m1 ≤ _mΩ) (hm : Monotone m) :
    Indep (⨆ i, m i) m1 μ 
goal: ProbabilityTheory.Indep (⨆ i, m i) m1 μ

full_name: ProbabilityTheory.indep_iSup_of_antitone
code: theorem indep_iSup_of_antitone [SemilatticeInf ι] [IsProbabilityMeasure μ]
    (h_indep : ∀ i, Indep (m i) m1 μ) (h_le : ∀ i, m i ≤ _mΩ) (h_le' : m1 ≤ _mΩ) (hm : Antitone m) :
    Indep (⨆ i, m i) m1 μ 
goal: ProbabilityTheory.Indep (⨆ i, m i) m1 μ

full_name: ProbabilityTheory.iIndepSets.piiUnionInter_of_not_mem
code: theorem iIndepSets.piiUnionInter_of_not_mem {π : ι → Set (Set Ω)} {a : ι} {S : Finset ι}
    (hp_ind : iIndepSets π μ) (haS : a ∉ S) :
    IndepSets (piiUnionInter π S) (π a) μ 
goal: ProbabilityTheory.IndepSets (piiUnionInter π ↑S) (π a) μ

full_name: ProbabilityTheory.iIndepSets.iIndep
code: /-- The measurable space structures generated by independent pi-systems are independent. -/
theorem iIndepSets.iIndep [IsProbabilityMeasure μ]
    (h_le : ∀ i, m i ≤ _mΩ) (π : ι → Set (Set Ω)) (h_pi : ∀ n, IsPiSystem (π n))
    (h_generate : ∀ i, m i = generateFrom (π i)) (h_ind : iIndepSets π μ) :
    iIndep m μ 
goal: ProbabilityTheory.iIndep m μ

full_name: ProbabilityTheory.indepSet_iff_indepSets_singleton
code: theorem indepSet_iff_indepSets_singleton (hs_meas : MeasurableSet s)
    (ht_meas : MeasurableSet t) (μ : Measure Ω := by volume_tac)
    [IsProbabilityMeasure μ] : IndepSet s t μ ↔ IndepSets {s} {t} μ 
goal: ProbabilityTheory.IndepSet s t μ ↔ ProbabilityTheory.IndepSets {s} {t} μ

full_name: ProbabilityTheory.indepSet_iff_measure_inter_eq_mul
code: theorem indepSet_iff_measure_inter_eq_mul (hs_meas : MeasurableSet s)
    (ht_meas : MeasurableSet t) (μ : Measure Ω := by volume_tac)
    [IsProbabilityMeasure μ] : IndepSet s t μ ↔ μ (s ∩ t) = μ s * μ t 
goal: ProbabilityTheory.IndepSet s t μ ↔ μ (s ∩ t) = μ s * μ t

full_name: ProbabilityTheory.IndepSets.indepSet_of_mem
code: theorem IndepSets.indepSet_of_mem (hs : s ∈ S) (ht : t ∈ T)
    (hs_meas : MeasurableSet s) (ht_meas : MeasurableSet t)
    (μ : Measure Ω := by volume_tac) [IsProbabilityMeasure μ]
    (h_indep : IndepSets S T μ) :
    IndepSet s t μ 
goal: ProbabilityTheory.IndepSet s t μ

full_name: ProbabilityTheory.Indep.indepSet_of_measurableSet
code: theorem Indep.indepSet_of_measurableSet
    (h_indep : Indep m₁ m₂ μ) {s t : Set Ω} (hs : MeasurableSet[m₁] s) (ht : MeasurableSet[m₂] t) :
    IndepSet s t μ 
goal: ProbabilityTheory.IndepSet s t μ

full_name: ProbabilityTheory.indep_iff_forall_indepSet
code: theorem indep_iff_forall_indepSet (μ : Measure Ω) :
    Indep m₁ m₂ μ ↔ ∀ s t, MeasurableSet[m₁] s → MeasurableSet[m₂] t → IndepSet s t μ 
goal: ProbabilityTheory.Indep m₁ m₂ μ ↔ ∀ (s t : Set Ω), MeasurableSet s → MeasurableSet t → ProbabilityTheory.IndepSet s t μ

full_name: ProbabilityTheory.iIndep_comap_mem_iff
code: theorem iIndep_comap_mem_iff {f : ι → Set Ω} :
    iIndep (fun i => MeasurableSpace.comap (· ∈ f i) ⊤) μ ↔ iIndepSet f μ 
goal: ProbabilityTheory.iIndep (fun i => MeasurableSpace.comap (fun x => x ∈ f i) ⊤) μ ↔ ProbabilityTheory.iIndepSet f μ

full_name: ProbabilityTheory.iIndepSets_singleton_iff
code: theorem iIndepSets_singleton_iff {s : ι → Set Ω} :
    iIndepSets (fun i ↦ {s i}) μ ↔ ∀ t, μ (⋂ i ∈ t, s i) = ∏ i ∈ t, μ (s i) 
goal: ProbabilityTheory.iIndepSets (fun i => {s i}) μ ↔ ∀ (t : Finset ι), μ (⋂ i ∈ t, s i) = ∏ i ∈ t, μ (s i)

full_name: ProbabilityTheory.iIndepSet_iff_iIndepSets_singleton
code: theorem iIndepSet_iff_iIndepSets_singleton {f : ι → Set Ω} (hf : ∀ i, MeasurableSet (f i)) :
    iIndepSet f μ ↔ iIndepSets (fun i ↦ {f i}) μ 
goal: ProbabilityTheory.iIndepSet f μ ↔ ProbabilityTheory.iIndepSets (fun i => {f i}) μ

full_name: ProbabilityTheory.iIndepSet_iff_meas_biInter
code: theorem iIndepSet_iff_meas_biInter {f : ι → Set Ω} (hf : ∀ i, MeasurableSet (f i)) :
    iIndepSet f μ ↔ ∀ s, μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i) 
goal: ProbabilityTheory.iIndepSet f μ ↔ ∀ (s : Finset ι), μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i)

full_name: ProbabilityTheory.iIndepSets.iIndepSet_of_mem
code: theorem iIndepSets.iIndepSet_of_mem {π : ι → Set (Set Ω)} {f : ι → Set Ω}
    (hfπ : ∀ i, f i ∈ π i) (hf : ∀ i, MeasurableSet (f i))
    (hπ : iIndepSets π μ) : iIndepSet f μ 
goal: ProbabilityTheory.iIndepSet f μ

full_name: ProbabilityTheory.indepFun_iff_measure_inter_preimage_eq_mul
code: theorem indepFun_iff_measure_inter_preimage_eq_mul {mβ : MeasurableSpace β}
    {mβ' : MeasurableSpace β'} :
    IndepFun f g μ ↔
      ∀ s t, MeasurableSet s → MeasurableSet t
        → μ (f ⁻¹' s ∩ g ⁻¹' t) = μ (f ⁻¹' s) * μ (g ⁻¹' t) 
goal: ProbabilityTheory.IndepFun f g μ ↔
  ∀ (s : Set β) (t : Set β'), MeasurableSet s → MeasurableSet t → μ (f ⁻¹' s ∩ g ⁻¹' t) = μ (f ⁻¹' s) * μ (g ⁻¹' t)

full_name: ProbabilityTheory.iIndepFun_iff_measure_inter_preimage_eq_mul
code: theorem iIndepFun_iff_measure_inter_preimage_eq_mul {ι : Type*} {β : ι → Type*}
    (m : ∀ x, MeasurableSpace (β x)) (f : ∀ i, Ω → β i) :
    iIndepFun m f μ ↔
      ∀ (S : Finset ι) {sets : ∀ i : ι, Set (β i)} (_H : ∀ i, i ∈ S → MeasurableSet[m i] (sets i)),
        μ (⋂ i ∈ S, f i ⁻¹' sets i) = ∏ i ∈ S, μ (f i ⁻¹' sets i) 
goal: ProbabilityTheory.iIndepFun m f μ ↔
  ∀ (S : Finset ι) {sets : (i : ι) → Set (β i)},
    (∀ i ∈ S, MeasurableSet (sets i)) → μ (⋂ i ∈ S, f i ⁻¹' sets i) = ∏ i ∈ S, μ (f i ⁻¹' sets i)

full_name: ProbabilityTheory.indepFun_iff_indepSet_preimage
code: theorem indepFun_iff_indepSet_preimage {mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'}
    [IsProbabilityMeasure μ] (hf : Measurable f) (hg : Measurable g) :
    IndepFun f g μ ↔
      ∀ s t, MeasurableSet s → MeasurableSet t → IndepSet (f ⁻¹' s) (g ⁻¹' t) μ 
goal: ProbabilityTheory.IndepFun f g μ ↔
  ∀ (s : Set β) (t : Set β'), MeasurableSet s → MeasurableSet t → ProbabilityTheory.IndepSet (f ⁻¹' s) (g ⁻¹' t) μ

full_name: ProbabilityTheory.indepFun_iff_map_prod_eq_prod_map_map
code: theorem indepFun_iff_map_prod_eq_prod_map_map {mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'}
    [IsFiniteMeasure μ] (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
    IndepFun f g μ ↔ μ.map (fun ω ↦ (f ω, g ω)) = (μ.map f).prod (μ.map g) 
goal: ProbabilityTheory.IndepFun f g μ ↔
  MeasureTheory.Measure.map (fun ω => (f ω, g ω)) μ =
    (MeasureTheory.Measure.map f μ).prod (MeasureTheory.Measure.map g μ)

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

full_name: ProbabilityTheory.IndepFun.ae_eq
code: theorem IndepFun.ae_eq {mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'}
    {f' : Ω → β} {g' : Ω → β'} (hfg : IndepFun f g μ)
    (hf : f =ᵐ[μ] f') (hg : g =ᵐ[μ] g') : IndepFun f' g' μ 
goal: ProbabilityTheory.IndepFun f' g' μ

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

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

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

full_name: ProbabilityTheory.iIndepFun.of_subsingleton
code: @[nontriviality]
lemma iIndepFun.of_subsingleton [IsProbabilityMeasure μ] [Subsingleton ι] : iIndepFun m f μ 
goal: ProbabilityTheory.iIndepFun m f μ

full_name: ProbabilityTheory.iIndepFun.isProbabilityMeasure
code: lemma iIndepFun.isProbabilityMeasure (h : iIndepFun m f μ) : IsProbabilityMeasure μ 
goal: MeasureTheory.IsProbabilityMeasure μ

full_name: ProbabilityTheory.iIndepFun.indepFun_finset
code: /-- If `f` is a family of mutually independent random variables (`iIndepFun m f μ`) and `S, T` are
two disjoint finite index sets, then the tuple formed by `f i` for `i ∈ S` is independent of the
tuple `(f i)_i` for `i ∈ T`. -/
lemma iIndepFun.indepFun_finset (S T : Finset ι) (hST : Disjoint S T) (hf_Indep : iIndepFun m f μ)
    (hf_meas : ∀ i, Measurable (f i)) :
    IndepFun (fun a (i : S) ↦ f i a) (fun a (i : T) ↦ f i a) μ 
goal: ProbabilityTheory.IndepFun (fun a i => f (↑i) a) (fun a i => f (↑i) a) μ

full_name: ProbabilityTheory.iIndepFun.indepFun_prod_mk
code: lemma iIndepFun.indepFun_prod_mk (hf_Indep : iIndepFun m f μ) (hf_meas : ∀ i, Measurable (f i))
    (i j k : ι) (hik : i ≠ k) (hjk : j ≠ k) :
    IndepFun (fun a => (f i a, f j a)) (f k) μ 
goal: ProbabilityTheory.IndepFun (fun a => (f i a, f j a)) (f k) μ

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

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

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

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

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

full_name: ProbabilityTheory.iIndepFun.indepFun_mul_mul
code: @[to_additive]
lemma iIndepFun.indepFun_mul_mul (hf_indep : iIndepFun (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) :
    IndepFun (f i * f j) (f k * f l) μ 
goal: ProbabilityTheory.IndepFun (f i * f j) (f k * f l) μ

full_name: ProbabilityTheory.iIndepFun.indepFun_add_add
code: @[to_additive]
lemma iIndepFun.indepFun_mul_mul (hf_indep : iIndepFun (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) :
    IndepFun (f i * f j) (f k * f l) μ 
goal: ProbabilityTheory.IndepFun (f i + f j) (f k + f l) μ

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

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

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

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

full_name: ProbabilityTheory.iIndepFun.indepFun_sub_sub
code: @[to_additive]
lemma iIndepFun.indepFun_div_div (hf_indep : iIndepFun (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) :
    IndepFun (f i / f j) (f k / f l) μ 
goal: ProbabilityTheory.IndepFun (f i - f j) (f k - f l) μ

full_name: ProbabilityTheory.iIndepFun.indepFun_div_div
code: @[to_additive]
lemma iIndepFun.indepFun_div_div (hf_indep : iIndepFun (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) :
    IndepFun (f i / f j) (f k / f l) μ 
goal: ProbabilityTheory.IndepFun (f i / f j) (f k / f l) μ

full_name: ProbabilityTheory.iIndepFun.indepFun_finset_prod_of_not_mem
code: @[to_additive]
lemma iIndepFun.indepFun_finset_prod_of_not_mem (hf_Indep : iIndepFun (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) {s : Finset ι} {i : ι} (hi : i ∉ s) :
    IndepFun (∏ j ∈ s, f j) (f i) μ 
goal: ProbabilityTheory.IndepFun (∏ j ∈ s, f j) (f i) μ

full_name: ProbabilityTheory.iIndepFun.indepFun_finset_sum_of_not_mem
code: @[to_additive]
lemma iIndepFun.indepFun_finset_prod_of_not_mem (hf_Indep : iIndepFun (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) {s : Finset ι} {i : ι} (hi : i ∉ s) :
    IndepFun (∏ j ∈ s, f j) (f i) μ 
goal: ProbabilityTheory.IndepFun (∑ j ∈ s, f j) (f i) μ

full_name: ProbabilityTheory.iIndepFun.indepFun_prod_range_succ
code: @[to_additive]
lemma iIndepFun.indepFun_prod_range_succ {f : ℕ → Ω → β} (hf_Indep : iIndepFun (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) (n : ℕ) : IndepFun (∏ j ∈ Finset.range n, f j) (f n) μ 
goal: ProbabilityTheory.IndepFun (∏ j ∈ Finset.range n, f j) (f n) μ

full_name: ProbabilityTheory.iIndepFun.indepFun_sum_range_succ
code: @[to_additive]
lemma iIndepFun.indepFun_prod_range_succ {f : ℕ → Ω → β} (hf_Indep : iIndepFun (fun _ ↦ m) f μ)
    (hf_meas : ∀ i, Measurable (f i)) (n : ℕ) : IndepFun (∏ j ∈ Finset.range n, f j) (f n) μ 
goal: ProbabilityTheory.IndepFun (∑ j ∈ Finset.range n, f j) (f n) μ

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