File: Mathlib/Probability/Independence/Kernel.lean

full_name: ProbabilityTheory.Kernel.iIndepSets
code: /-- A family of sets of sets `π : ι → Set (Set Ω)` is independent with respect to a kernel `κ` and
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 `∀ᵐ a ∂μ, κ a (⋂ i in s, f i) = ∏ i ∈ s, κ a (f i)`.
It will be used for families of pi_systems. -/
def iIndepSets {_mΩ : MeasurableSpace Ω}
    (π : ι → Set (Set Ω)) (κ : Kernel α Ω) (μ : Measure α := by volume_tac) : Prop 
goal: Prop

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

full_name: ProbabilityTheory.Kernel.iIndep
code: /-- A family of measurable space structures (i.e. of σ-algebras) is independent with respect to a
kernel `κ` and a measure `μ` if the family of sets of measurable sets they define is independent. -/
def iIndep (m : ι → MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (κ : Kernel α Ω)
    (μ : Measure α := by volume_tac) : Prop 
goal: Prop

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

full_name: ProbabilityTheory.Kernel.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 Ω) (κ : Kernel α Ω)
    (μ : Measure α := by volume_tac) : Prop 
goal: Prop

full_name: ProbabilityTheory.Kernel.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 Ω) (κ : Kernel α Ω)
    (μ : Measure α := by volume_tac) : Prop 
goal: Prop

full_name: ProbabilityTheory.Kernel.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) (κ : Kernel α Ω)
    (μ : Measure α := by volume_tac) : Prop 
goal: Prop

full_name: ProbabilityTheory.Kernel.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 Ω} [mβ : MeasurableSpace β] [mγ : MeasurableSpace γ]
    (f : Ω → β) (g : Ω → γ) (κ : Kernel α Ω)
    (μ : Measure α := by volume_tac) : Prop 
goal: Prop

full_name: ProbabilityTheory.Kernel.iIndepSets.meas_biInter
code: lemma iIndepSets.meas_biInter (h : iIndepSets π κ μ) (s : Finset ι)
    {f : ι → Set Ω} (hf : ∀ i, i ∈ s → f i ∈ π i) :
    ∀ᵐ a ∂μ, κ a (⋂ i ∈ s, f i) = ∏ i ∈ s, κ a (f i) 
goal: ∀ᵐ (a : α) ∂μ, (κ a) (⋂ i ∈ s, f i) = ∏ i ∈ s, (κ a) (f i)

full_name: ProbabilityTheory.Kernel.iIndepSets.meas_iInter
code: lemma iIndepSets.meas_iInter [Fintype ι] (h : iIndepSets π κ μ) (hs : ∀ i, s i ∈ π i) :
    ∀ᵐ a ∂μ, κ a (⋂ i, s i) = ∏ i, κ a (s i) 
goal: ∀ᵐ (a : α) ∂μ, (κ a) (⋂ i, s i) = ∏ i : ι, (κ a) (s i)

full_name: ProbabilityTheory.Kernel.iIndep.iIndepSets'
code: lemma iIndep.iIndepSets' (hμ : iIndep m κ μ) :
    iIndepSets (fun x ↦ {s | MeasurableSet[m x] s}) κ μ 
goal: ProbabilityTheory.Kernel.iIndepSets (fun x => {s | MeasurableSet s}) κ μ

full_name: ProbabilityTheory.Kernel.iIndep.meas_biInter
code: lemma iIndep.meas_biInter (hμ : iIndep m κ μ) (hs : ∀ i, i ∈ S → MeasurableSet[m i] (s i)) :
    ∀ᵐ a ∂μ, κ a (⋂ i ∈ S, s i) = ∏ i ∈ S, κ a (s i) 
goal: ∀ᵐ (a : α) ∂μ, (κ a) (⋂ i ∈ S, s i) = ∏ i ∈ S, (κ a) (s i)

full_name: ProbabilityTheory.Kernel.iIndep.meas_iInter
code: lemma iIndep.meas_iInter [Fintype ι] (h : iIndep m κ μ) (hs : ∀ i, MeasurableSet[m i] (s i)) :
    ∀ᵐ a ∂μ, κ a (⋂ i, s i) = ∏ i, κ a (s i) 
goal: ∀ᵐ (a : α) ∂μ, (κ a) (⋂ i, s i) = ∏ i : ι, (κ a) (s i)

full_name: ProbabilityTheory.Kernel.iIndepFun.iIndep
code: protected lemma iIndepFun.iIndep (hf : iIndepFun mβ f κ μ) :
    iIndep (fun x ↦ (mβ x).comap (f x)) κ μ 
goal: ProbabilityTheory.Kernel.iIndep (fun x => MeasurableSpace.comap (f x) (mβ x)) κ μ

full_name: ProbabilityTheory.Kernel.iIndepFun.meas_biInter
code: lemma iIndepFun.meas_biInter (hf : iIndepFun mβ f κ μ)
    (hs : ∀ i, i ∈ S → MeasurableSet[(mβ i).comap (f i)] (s i)) :
    ∀ᵐ a ∂μ, κ a (⋂ i ∈ S, s i) = ∏ i ∈ S, κ a (s i) 
goal: ∀ᵐ (a : α) ∂μ, (κ a) (⋂ i ∈ S, s i) = ∏ i ∈ S, (κ a) (s i)

full_name: ProbabilityTheory.Kernel.iIndepFun.meas_iInter
code: lemma iIndepFun.meas_iInter [Fintype ι] (hf : iIndepFun mβ f κ μ)
    (hs : ∀ i, MeasurableSet[(mβ i).comap (f i)] (s i)) :
    ∀ᵐ a ∂μ, κ a (⋂ i, s i) = ∏ i, κ a (s i) 
goal: ∀ᵐ (a : α) ∂μ, (κ a) (⋂ i, s i) = ∏ i : ι, (κ a) (s i)

full_name: ProbabilityTheory.Kernel.IndepFun.meas_inter
code: lemma IndepFun.meas_inter {β γ : Type*} [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) :
    ∀ᵐ a ∂μ, κ a (s ∩ t) = κ a s * κ a t 
goal: ∀ᵐ (a : α) ∂μ, (κ a) (s ∩ t) = (κ a) s * (κ a) t

full_name: ProbabilityTheory.Kernel.IndepSets.symm
code: @[symm]
theorem IndepSets.symm {_mΩ : MeasurableSpace Ω} {κ : Kernel α Ω} {μ : Measure α}
    {s₁ s₂ : Set (Set Ω)} (h : IndepSets s₁ s₂ κ μ) :
    IndepSets s₂ s₁ κ μ 
goal: ProbabilityTheory.Kernel.IndepSets s₂ s₁ κ μ

full_name: ProbabilityTheory.Kernel.Indep.symm
code: @[symm]
theorem Indep.symm {m₁ m₂ : MeasurableSpace Ω} {_mΩ : MeasurableSpace Ω} {κ : Kernel α Ω}
    {μ : Measure α} (h : Indep m₁ m₂ κ μ) :
    Indep m₂ m₁ κ μ 
goal: ProbabilityTheory.Kernel.Indep m₂ m₁ κ μ

full_name: ProbabilityTheory.Kernel.indep_bot_right
code: theorem indep_bot_right (m' : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} [IsMarkovKernel κ] :
    Indep m' ⊥ κ μ 
goal: ProbabilityTheory.Kernel.Indep m' ⊥ κ μ

full_name: ProbabilityTheory.Kernel.indep_bot_left
code: theorem indep_bot_left (m' : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} [IsMarkovKernel κ] :
    Indep ⊥ m' κ μ 
goal: ProbabilityTheory.Kernel.Indep ⊥ m' κ μ

full_name: ProbabilityTheory.Kernel.indepSet_empty_right
code: theorem indepSet_empty_right {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} [IsMarkovKernel κ] (s : Set Ω) :
    IndepSet s ∅ κ μ 
goal: ProbabilityTheory.Kernel.IndepSet s ∅ κ μ

full_name: ProbabilityTheory.Kernel.indepSet_empty_left
code: theorem indepSet_empty_left {_mΩ : MeasurableSpace Ω} {κ : Kernel α Ω}
    {μ : Measure α} [IsMarkovKernel κ] (s : Set Ω) :
    IndepSet ∅ s κ μ 
goal: ProbabilityTheory.Kernel.IndepSet ∅ s κ μ

full_name: ProbabilityTheory.Kernel.indepSets_of_indepSets_of_le_left
code: theorem indepSets_of_indepSets_of_le_left {s₁ s₂ s₃ : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} (h_indep : IndepSets s₁ s₂ κ μ) (h31 : s₃ ⊆ s₁) :
    IndepSets s₃ s₂ κ μ 
goal: ProbabilityTheory.Kernel.IndepSets s₃ s₂ κ μ

full_name: ProbabilityTheory.Kernel.indepSets_of_indepSets_of_le_right
code: theorem indepSets_of_indepSets_of_le_right {s₁ s₂ s₃ : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} (h_indep : IndepSets s₁ s₂ κ μ) (h32 : s₃ ⊆ s₂) :
    IndepSets s₁ s₃ κ μ 
goal: ProbabilityTheory.Kernel.IndepSets s₁ s₃ κ μ

full_name: ProbabilityTheory.Kernel.indep_of_indep_of_le_left
code: theorem indep_of_indep_of_le_left {m₁ m₂ m₃ : MeasurableSpace Ω} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} (h_indep : Indep m₁ m₂ κ μ) (h31 : m₃ ≤ m₁) :
    Indep m₃ m₂ κ μ 
goal: ProbabilityTheory.Kernel.Indep m₃ m₂ κ μ

full_name: ProbabilityTheory.Kernel.indep_of_indep_of_le_right
code: theorem indep_of_indep_of_le_right {m₁ m₂ m₃ : MeasurableSpace Ω} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} (h_indep : Indep m₁ m₂ κ μ) (h32 : m₃ ≤ m₂) :
    Indep m₁ m₃ κ μ 
goal: ProbabilityTheory.Kernel.Indep m₁ m₃ κ μ

full_name: ProbabilityTheory.Kernel.IndepSets.union
code: theorem IndepSets.union {s₁ s₂ s' : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α}
    (h₁ : IndepSets s₁ s' κ μ) (h₂ : IndepSets s₂ s' κ μ) :
    IndepSets (s₁ ∪ s₂) s' κ μ 
goal: ProbabilityTheory.Kernel.IndepSets (s₁ ∪ s₂) s' κ μ

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

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

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

full_name: ProbabilityTheory.Kernel.IndepSets.inter
code: theorem IndepSets.inter {s₁ s' : Set (Set Ω)} (s₂ : Set (Set Ω)) {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} (h₁ : IndepSets s₁ s' κ μ) :
    IndepSets (s₁ ∩ s₂) s' κ μ 
goal: ProbabilityTheory.Kernel.IndepSets (s₁ ∩ s₂) s' κ μ

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

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

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

full_name: ProbabilityTheory.Kernel.iIndepSets_singleton_iff
code: theorem iIndepSets_singleton_iff {s : ι → Set Ω} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} :
    iIndepSets (fun i ↦ {s i}) κ μ ↔
      ∀ S : Finset ι, ∀ᵐ a ∂μ, κ a (⋂ i ∈ S, s i) = ∏ i ∈ S, κ a (s i) 
goal: ProbabilityTheory.Kernel.iIndepSets (fun i => {s i}) κ μ ↔
  ∀ (S : Finset ι), ∀ᵐ (a : α) ∂μ, (κ a) (⋂ i ∈ S, s i) = ∏ i ∈ S, (κ a) (s i)

full_name: ProbabilityTheory.Kernel.indepSets_singleton_iff
code: theorem indepSets_singleton_iff {s t : Set Ω} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} :
    IndepSets {s} {t} κ μ ↔ ∀ᵐ a ∂μ, κ a (s ∩ t) = κ a s * κ a t 
goal: ProbabilityTheory.Kernel.IndepSets {s} {t} κ μ ↔ ∀ᵐ (a : α) ∂μ, (κ a) (s ∩ t) = (κ a) s * (κ a) t

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

full_name: ProbabilityTheory.Kernel.iIndep.indep
code: theorem iIndep.indep {m : ι → MeasurableSpace Ω} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α}
    (h_indep : iIndep m κ μ) {i j : ι} (hij : i ≠ j) : Indep (m i) (m j) κ μ 
goal: ProbabilityTheory.Kernel.Indep (m i) (m j) κ μ

full_name: ProbabilityTheory.Kernel.iIndepFun.indepFun
code: theorem iIndepFun.indepFun {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} {β : ι → 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.Kernel.IndepFun (f i) (f j) κ μ

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

full_name: ProbabilityTheory.Kernel.Indep.indepSets
code: theorem Indep.indepSets {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} {s1 s2 : Set (Set Ω)}
    (h_indep : Indep (generateFrom s1) (generateFrom s2) κ μ) :
    IndepSets s1 s2 κ μ 
goal: ProbabilityTheory.Kernel.IndepSets s1 s2 κ μ

full_name: ProbabilityTheory.Kernel.IndepSets.indep_aux
code: theorem IndepSets.indep_aux {m₂ m : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} [IsMarkovKernel κ] {p1 p2 : Set (Set Ω)} (h2 : m₂ ≤ m)
    (hp2 : IsPiSystem p2) (hpm2 : m₂ = generateFrom p2) (hyp : IndepSets p1 p2 κ μ) {t1 t2 : Set Ω}
    (ht1 : t1 ∈ p1) (ht1m : MeasurableSet[m] t1) (ht2m : MeasurableSet[m₂] t2) :
    ∀ᵐ a ∂μ, κ a (t1 ∩ t2) = κ a t1 * κ a t2 
goal: ∀ᵐ (a : α) ∂μ, (κ a) (t1 ∩ t2) = (κ a) t1 * (κ a) t2

full_name: ProbabilityTheory.Kernel.IndepSets.indep
code: /-- The measurable space structures generated by independent pi-systems are independent. -/
theorem IndepSets.indep {m1 m2 m : MeasurableSpace Ω} {κ : Kernel α Ω} {μ : Measure α}
    [IsMarkovKernel κ] {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.Kernel.Indep m1 m2 κ μ

full_name: ProbabilityTheory.Kernel.IndepSets.indep'
code: theorem IndepSets.indep' {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} [IsMarkovKernel κ]
    {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.Kernel.Indep (MeasurableSpace.generateFrom p1) (MeasurableSpace.generateFrom p2) κ μ

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

full_name: ProbabilityTheory.Kernel.iIndepSet.indep_generateFrom_of_disjoint
code: theorem iIndepSet.indep_generateFrom_of_disjoint [IsMarkovKernel κ] {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.Kernel.Indep (MeasurableSpace.generateFrom {t | ∃ n ∈ S, s n = t})
  (MeasurableSpace.generateFrom {t | ∃ k ∈ T, s k = t}) κ μ

full_name: ProbabilityTheory.Kernel.indep_iSup_of_disjoint
code: theorem indep_iSup_of_disjoint [IsMarkovKernel κ] {m : ι → MeasurableSpace Ω}
    (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.Kernel.Indep (⨆ i ∈ S, m i) (⨆ i ∈ T, m i) κ μ

full_name: ProbabilityTheory.Kernel.indep_iSup_of_directed_le
code: theorem indep_iSup_of_directed_le {Ω} {m : ι → MeasurableSpace Ω} {m' m0 : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} [IsMarkovKernel κ] (h_indep : ∀ i, Indep (m i) m' κ μ)
    (h_le : ∀ i, m i ≤ m0) (h_le' : m' ≤ m0) (hm : Directed (· ≤ ·) m) :
    Indep (⨆ i, m i) m' κ μ 
goal: ProbabilityTheory.Kernel.Indep (⨆ i, m i) m' κ μ

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

full_name: ProbabilityTheory.Kernel.iIndepSet.indep_generateFrom_le
code: theorem iIndepSet.indep_generateFrom_le [LinearOrder ι] [IsMarkovKernel κ] {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.Kernel.Indep (MeasurableSpace.generateFrom {s k})
  (MeasurableSpace.generateFrom {t | ∃ j ≤ i, s j = t}) κ μ

full_name: ProbabilityTheory.Kernel.iIndepSet.indep_generateFrom_le_nat
code: theorem iIndepSet.indep_generateFrom_le_nat [IsMarkovKernel κ] {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.Kernel.Indep (MeasurableSpace.generateFrom {s (n + 1)})
  (MeasurableSpace.generateFrom {t | ∃ k ≤ n, s k = t}) κ μ

full_name: ProbabilityTheory.Kernel.indep_iSup_of_monotone
code: theorem indep_iSup_of_monotone [SemilatticeSup ι] {Ω} {m : ι → MeasurableSpace Ω}
    {m' m0 : MeasurableSpace Ω} {κ : Kernel α Ω} {μ : Measure α} [IsMarkovKernel κ]
    (h_indep : ∀ i, Indep (m i) m' κ μ) (h_le : ∀ i, m i ≤ m0) (h_le' : m' ≤ m0)
    (hm : Monotone m) :
    Indep (⨆ i, m i) m' κ μ 
goal: ProbabilityTheory.Kernel.Indep (⨆ i, m i) m' κ μ

full_name: ProbabilityTheory.Kernel.indep_iSup_of_antitone
code: theorem indep_iSup_of_antitone [SemilatticeInf ι] {Ω} {m : ι → MeasurableSpace Ω}
    {m' m0 : MeasurableSpace Ω} {κ : Kernel α Ω} {μ : Measure α} [IsMarkovKernel κ]
    (h_indep : ∀ i, Indep (m i) m' κ μ) (h_le : ∀ i, m i ≤ m0) (h_le' : m' ≤ m0)
    (hm : Antitone m) :
    Indep (⨆ i, m i) m' κ μ 
goal: ProbabilityTheory.Kernel.Indep (⨆ i, m i) m' κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepSets (piiUnionInter π ↑S) (π a) κ μ

full_name: ProbabilityTheory.Kernel.iIndepSets.iIndep
code: /-- The measurable space structures generated by independent pi-systems are independent. -/
theorem iIndepSets.iIndep [IsMarkovKernel κ] (m : ι → MeasurableSpace Ω)
    (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.Kernel.iIndep m κ μ

full_name: ProbabilityTheory.Kernel.iIndepSet_iff_iIndepSets_singleton
code: theorem iIndepSet_iff_iIndepSets_singleton {_mΩ : MeasurableSpace Ω} {κ : Kernel α Ω}
    [IsMarkovKernel κ] {μ : Measure α} {f : ι → Set Ω}
    (hf : ∀ i, MeasurableSet (f i)) :
    iIndepSet f κ μ ↔ iIndepSets (fun i ↦ {f i}) κ μ 
goal: ProbabilityTheory.Kernel.iIndepSet f κ μ ↔ ProbabilityTheory.Kernel.iIndepSets (fun i => {f i}) κ μ

full_name: ProbabilityTheory.Kernel.iIndepSet_iff_meas_biInter
code: theorem iIndepSet_iff_meas_biInter {_mΩ : MeasurableSpace Ω} {κ : Kernel α Ω}
    [IsMarkovKernel κ] {μ : Measure α} {f : ι → Set Ω} (hf : ∀ i, MeasurableSet (f i)) :
    iIndepSet f κ μ ↔ ∀ s, ∀ᵐ a ∂μ, κ a (⋂ i ∈ s, f i) = ∏ i ∈ s, κ a (f i) 
goal: ProbabilityTheory.Kernel.iIndepSet f κ μ ↔ ∀ (s : Finset ι), ∀ᵐ (a : α) ∂μ, (κ a) (⋂ i ∈ s, f i) = ∏ i ∈ s, (κ a) (f i)

full_name: ProbabilityTheory.Kernel.iIndepSets.iIndepSet_of_mem
code: theorem iIndepSets.iIndepSet_of_mem {_mΩ : MeasurableSpace Ω} {κ : Kernel α Ω}
    [IsMarkovKernel κ] {μ : Measure α} {π : ι → Set (Set Ω)} {f : ι → Set Ω}
    (hfπ : ∀ i, f i ∈ π i) (hf : ∀ i, MeasurableSet (f i))
    (hπ : iIndepSets π κ μ) :
    iIndepSet f κ μ 
goal: ProbabilityTheory.Kernel.iIndepSet f κ μ

full_name: ProbabilityTheory.Kernel.indepSet_iff_indepSets_singleton
code: theorem indepSet_iff_indepSets_singleton {m0 : MeasurableSpace Ω} (hs_meas : MeasurableSet s)
    (ht_meas : MeasurableSet t) (κ : Kernel α Ω) (μ : Measure α)
    [IsMarkovKernel κ] :
    IndepSet s t κ μ ↔ IndepSets {s} {t} κ μ 
goal: ProbabilityTheory.Kernel.IndepSet s t κ μ ↔ ProbabilityTheory.Kernel.IndepSets {s} {t} κ μ

full_name: ProbabilityTheory.Kernel.indepSet_iff_measure_inter_eq_mul
code: theorem indepSet_iff_measure_inter_eq_mul {_m0 : MeasurableSpace Ω} (hs_meas : MeasurableSet s)
    (ht_meas : MeasurableSet t) (κ : Kernel α Ω) (μ : Measure α)
    [IsMarkovKernel κ] :
    IndepSet s t κ μ ↔ ∀ᵐ a ∂μ, κ a (s ∩ t) = κ a s * κ a t 
goal: ProbabilityTheory.Kernel.IndepSet s t κ μ ↔ ∀ᵐ (a : α) ∂μ, (κ a) (s ∩ t) = (κ a) s * (κ a) t

full_name: ProbabilityTheory.Kernel.IndepSets.indepSet_of_mem
code: theorem IndepSets.indepSet_of_mem {_m0 : MeasurableSpace Ω} (hs : s ∈ S) (ht : t ∈ T)
    (hs_meas : MeasurableSet s) (ht_meas : MeasurableSet t)
    (κ : Kernel α Ω) (μ : Measure α) [IsMarkovKernel κ]
    (h_indep : IndepSets S T κ μ) :
    IndepSet s t κ μ 
goal: ProbabilityTheory.Kernel.IndepSet s t κ μ

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

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

full_name: ProbabilityTheory.Kernel.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
        → ∀ᵐ a ∂μ, κ a (f ⁻¹' s ∩ g ⁻¹' t) = κ a (f ⁻¹' s) * κ a (g ⁻¹' t) 
goal: ProbabilityTheory.Kernel.IndepFun f g κ μ ↔
  ∀ (s : Set β) (t : Set β'),
    MeasurableSet s → MeasurableSet t → ∀ᵐ (a : α) ∂μ, (κ a) (f ⁻¹' s ∩ g ⁻¹' t) = (κ a) (f ⁻¹' s) * (κ a) (g ⁻¹' t)

full_name: ProbabilityTheory.Kernel.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)),
        ∀ᵐ a ∂μ, κ a (⋂ i ∈ S, (f i) ⁻¹' (sets i)) = ∏ i ∈ S, κ a ((f i) ⁻¹' (sets i)) 
goal: ProbabilityTheory.Kernel.iIndepFun m f κ μ ↔
  ∀ (S : Finset ι) {sets : (i : ι) → Set (β i)},
    (∀ i ∈ S, MeasurableSet (sets i)) → ∀ᵐ (a : α) ∂μ, (κ a) (⋂ i ∈ S, f i ⁻¹' sets i) = ∏ i ∈ S, (κ a) (f i ⁻¹' sets i)

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

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

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

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (φ ∘ f) (ψ ∘ g) κ μ

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

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

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

full_name: ProbabilityTheory.Kernel.iIndepFun.ae_isProbabilityMeasure
code: lemma iIndepFun.ae_isProbabilityMeasure (h : iIndepFun m f κ μ) :
    ∀ᵐ a ∂μ, IsProbabilityMeasure (κ a) 
goal: ∀ᵐ (a : α) ∂μ, MeasureTheory.IsProbabilityMeasure (κ a)

full_name: ProbabilityTheory.Kernel.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`. -/
theorem iIndepFun.indepFun_finset [IsMarkovKernel κ] (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.Kernel.IndepFun (fun a i => f (↑i) a) (fun a i => f (↑i) a) κ μ

full_name: ProbabilityTheory.Kernel.iIndepFun.indepFun_prod_mk
code: theorem iIndepFun.indepFun_prod_mk [IsMarkovKernel κ] (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.Kernel.IndepFun (fun a => (f i a, f j a)) (f k) κ μ

full_name: ProbabilityTheory.Kernel.iIndepFun.indepFun_prod_mk_prod_mk
code: lemma iIndepFun.indepFun_prod_mk_prod_mk [IsMarkovKernel κ] (hf_indep : iIndepFun 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 (fun a ↦ (f i a, f j a)) (fun a ↦ (f k a, f l a)) κ μ 
goal: ProbabilityTheory.Kernel.IndepFun (fun a => (f i a, f j a)) (fun a => (f k a, f l a)) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (f i + f j) (f k) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (f i * f j) (f k) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (f i) (f j * f k) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (f i) (f j + f k) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (f i * f j) (f k * f l) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (f i + f j) (f k + f l) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (f i / f j) (f k) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (f i - f j) (f k) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (f i) (f j / f k) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (f i) (f j - f k) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (f i / f j) (f k / f l) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.IndepFun (f i - f j) (f k - f l) κ μ

full_name: ProbabilityTheory.Kernel.iIndepFun.indepFun_finset_prod_of_not_mem
code: @[to_additive]
theorem 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.Kernel.IndepFun (∏ j ∈ s, f j) (f i) κ μ

full_name: ProbabilityTheory.Kernel.iIndepFun.indepFun_finset_sum_of_not_mem
code: @[to_additive]
theorem 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.Kernel.IndepFun (∑ j ∈ s, f j) (f i) κ μ

full_name: ProbabilityTheory.Kernel.iIndepFun.indepFun_sum_range_succ
code: @[to_additive]
theorem 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.Kernel.IndepFun (∑ j ∈ Finset.range n, f j) (f n) κ μ

full_name: ProbabilityTheory.Kernel.iIndepFun.indepFun_prod_range_succ
code: @[to_additive]
theorem 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.Kernel.IndepFun (∏ j ∈ Finset.range n, f j) (f n) κ μ

full_name: ProbabilityTheory.Kernel.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.Kernel.iIndepFun (fun _n => m) (fun n => (s n).indicator fun _ω => 1) κ μ