ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Primrec.list_ofFn
theorem list_ofFn :
    ∀ {n} {f : Fin n → α → σ}, (∀ i, Primrec (f i)) → Primrec fun a => List.ofFn fun i => f i a
  
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {n : ℕ} {f : Fin n → α → σ}
Goal: (∀ (i : Fin n), Primrec (f i)) → Primrec fun a => List.ofFn fun i => f i a
-- Primrec.vector_ofFn
theorem vector_ofFn {n} {f : Fin n → α → σ} (hf : ∀ i, Primrec (f i)) :
    Primrec fun a => Vector.ofFn fun i => f i a 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {n : ℕ} {f : Fin n → α → σ} (hf : ∀ (i : Fin n), Primrec (f i))
Goal: Primrec fun a => Mathlib.Vector.ofFn fun i => f i a
-- Primrec.vector_get'
theorem vector_get' {n} : Primrec (@Vector.get α n) 
Arguments: {α : Type u_1} [Primcodable α] {n : ℕ}
Goal: Primrec Mathlib.Vector.get
-- Primrec.vector_ofFn'
theorem vector_ofFn' {n} : Primrec (@Vector.ofFn α n) 
Arguments: {α : Type u_1} [Primcodable α] {n : ℕ}
Goal: Primrec Mathlib.Vector.ofFn
-- Primrec.fin_app
theorem fin_app {n} : Primrec₂ (@id (Fin n → σ)) 
Arguments: {σ : Type u_4} [Primcodable σ] {n : ℕ}
Goal: Primrec₂ id
-- Primrec.fin_curry₁
theorem fin_curry₁ {n} {f : Fin n → α → σ} : Primrec₂ f ↔ ∀ i, Primrec (f i) 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {n : ℕ} {f : Fin n → α → σ}
Goal: Primrec₂ f ↔ ∀ (i : Fin n), Primrec (f i)
-- Primrec.fin_curry
theorem fin_curry {n} {f : α → Fin n → σ} : Primrec f ↔ Primrec₂ f 
Arguments: {α : Type u_1} {σ : Type u_4} [Primcodable α] [Primcodable σ] {n : ℕ} {f : α → Fin n → σ}
Goal: Primrec f ↔ Primrec₂ f
-- Nat.Primrec'.to_prim
theorem to_prim {n f} (pf : @Nat.Primrec' n f) : Primrec f 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n → ℕ} (pf : Nat.Primrec' f)
Goal: Primrec f
-- Nat.Primrec'.of_eq
theorem of_eq {n} {f g : Vector ℕ n → ℕ} (hf : Primrec' f) (H : ∀ i, f i = g i) : Primrec' g 
Arguments: {n : ℕ} {f g : Mathlib.Vector ℕ n → ℕ} (hf : Nat.Primrec' f) (H : ∀ (i : Mathlib.Vector ℕ n), f i = g i)
Goal: Nat.Primrec' g
-- Nat.Primrec'.const
theorem const {n} : ∀ m, @Primrec' n fun _ => m
  
Arguments: {n : ℕ} (m : ℕ)
Goal: Nat.Primrec' fun x => m
-- Nat.Primrec'.head
theorem head {n : ℕ} : @Primrec' n.succ head 
Arguments: {n : ℕ}
Goal: Nat.Primrec' Mathlib.Vector.head
-- Nat.Primrec'.tail
theorem tail {n f} (hf : @Primrec' n f) : @Primrec' n.succ fun v => f v.tail 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n → ℕ} (hf : Nat.Primrec' f)
Goal: Nat.Primrec' fun v => f v.tail
-- Nat.Primrec'.nil
protected theorem nil {n} : @Vec n 0 fun _ => nil 
Arguments: {n : ℕ}
Goal: Nat.Primrec'.Vec fun x => Mathlib.Vector.nil
-- Nat.Primrec'.cons
protected theorem cons {n m f g} (hf : @Primrec' n f) (hg : @Vec n m g) :
    Vec fun v => f v ::ᵥ g v 
Arguments: {n m : ℕ} {f : Mathlib.Vector ℕ n → ℕ} {g : Mathlib.Vector ℕ n → Mathlib.Vector ℕ m} (hf : Nat.Primrec' f) (hg : Nat.Primrec'.Vec g)
Goal: Nat.Primrec'.Vec fun v => f v ::ᵥ g v
-- Nat.Primrec'.idv
theorem idv {n} : @Vec n n id 
Arguments: {n : ℕ}
Goal: Nat.Primrec'.Vec id
-- Nat.Primrec'.comp'
theorem comp' {n m f g} (hf : @Primrec' m f) (hg : @Vec n m g) : Primrec' fun v => f (g v) 
Arguments: {n m : ℕ} {f : Mathlib.Vector ℕ m → ℕ} {g : Mathlib.Vector ℕ n → Mathlib.Vector ℕ m} (hf : Nat.Primrec' f) (hg : Nat.Primrec'.Vec g)
Goal: Nat.Primrec' fun v => f (g v)
-- Nat.Primrec'.comp₁
theorem comp₁ (f : ℕ → ℕ) (hf : @Primrec' 1 fun v => f v.head) {n g} (hg : @Primrec' n g) :
    Primrec' fun v => f (g v) 
Arguments: (f : ℕ → ℕ) (hf : Nat.Primrec' fun v => f v.head) {n : ℕ} {g : Mathlib.Vector ℕ n → ℕ} (hg : Nat.Primrec' g)
Goal: Nat.Primrec' fun v => f (g v)
-- Nat.Primrec'.comp₂
theorem comp₂ (f : ℕ → ℕ → ℕ) (hf : @Primrec' 2 fun v => f v.head v.tail.head) {n g h}
    (hg : @Primrec' n g) (hh : @Primrec' n h) : Primrec' fun v => f (g v) (h v) 
Arguments: (f : ℕ → ℕ → ℕ) (hf : Nat.Primrec' fun v => f v.head v.tail.head) {n : ℕ} {g h : Mathlib.Vector ℕ n → ℕ} (hg : Nat.Primrec' g) (hh : Nat.Primrec' h)
Goal: Nat.Primrec' fun v => f (g v) (h v)
-- Nat.Primrec'.prec'
theorem prec' {n f g h} (hf : @Primrec' n f) (hg : @Primrec' n g) (hh : @Primrec' (n + 2) h) :
    @Primrec' n fun v => (f v).rec (g v) fun y IH : ℕ => h (y ::ᵥ IH ::ᵥ v) 
Arguments: {n : ℕ} {f g : Mathlib.Vector ℕ n → ℕ} {h : Mathlib.Vector ℕ (n + 2) → ℕ} (hf : Nat.Primrec' f) (hg : Nat.Primrec' g) (hh : Nat.Primrec' h)
Goal: Nat.Primrec' fun v => Nat.rec (g v) (fun y IH => h (y ::ᵥ IH ::ᵥ v)) (f v)
-- Nat.Primrec'.pred
theorem pred : @Primrec' 1 fun v => v.head.pred 
Goal: Nat.Primrec' fun v => v.head.pred
-- Nat.Primrec'.add
theorem add : @Primrec' 2 fun v => v.head + v.tail.head 
Goal: Nat.Primrec' fun v => v.head + v.tail.head
-- Nat.Primrec'.sub
theorem sub : @Primrec' 2 fun v => v.head - v.tail.head 
Goal: Nat.Primrec' fun v => v.head - v.tail.head
-- Nat.Primrec'.mul
theorem mul : @Primrec' 2 fun v => v.head * v.tail.head 
Goal: Nat.Primrec' fun v => v.head * v.tail.head
-- Nat.Primrec'.if_lt
theorem if_lt {n a b f g} (ha : @Primrec' n a) (hb : @Primrec' n b) (hf : @Primrec' n f)
    (hg : @Primrec' n g) : @Primrec' n fun v => if a v < b v then f v else g v 
Arguments: {n : ℕ} {a b f g : Mathlib.Vector ℕ n → ℕ} (ha : Nat.Primrec' a) (hb : Nat.Primrec' b) (hf : Nat.Primrec' f) (hg : Nat.Primrec' g)
Goal: Nat.Primrec' fun v => if a v < b v then f v else g v
-- Nat.Primrec'.natPair
theorem natPair : @Primrec' 2 fun v => v.head.pair v.tail.head 
Goal: Nat.Primrec' fun v => Nat.pair v.head v.tail.head
-- Nat.Primrec'.encode
protected theorem encode : ∀ {n}, @Primrec' n encode
  
Arguments: {n : ℕ}
Goal: Nat.Primrec' Encodable.encode
-- Nat.Primrec'.sqrt
theorem sqrt : @Primrec' 1 fun v => v.head.sqrt 
Goal: Nat.Primrec' fun v => v.head.sqrt
-- Nat.Primrec'.unpair₁
theorem unpair₁ {n f} (hf : @Primrec' n f) : @Primrec' n fun v => (f v).unpair.1 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n → ℕ} (hf : Nat.Primrec' f)
Goal: Nat.Primrec' fun v => (Nat.unpair (f v)).1
-- Nat.Primrec'.unpair₂
theorem unpair₂ {n f} (hf : @Primrec' n f) : @Primrec' n fun v => (f v).unpair.2 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n → ℕ} (hf : Nat.Primrec' f)
Goal: Nat.Primrec' fun v => (Nat.unpair (f v)).2
-- Nat.Primrec'.of_prim
theorem of_prim {n f} : Primrec f → @Primrec' n f 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n → ℕ}
Goal: Primrec f → Nat.Primrec' f
-- Nat.Primrec'.prim_iff
theorem prim_iff {n f} : @Primrec' n f ↔ Primrec f 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n → ℕ}
Goal: Nat.Primrec' f ↔ Primrec f
-- Nat.Primrec'.prim_iff₁
theorem prim_iff₁ {f : ℕ → ℕ} : (@Primrec' 1 fun v => f v.head) ↔ Primrec f 
Arguments: {f : ℕ → ℕ}
Goal: (Nat.Primrec' fun v => f v.head) ↔ Primrec f
-- Nat.Primrec'.prim_iff₂
theorem prim_iff₂ {f : ℕ → ℕ → ℕ} : (@Primrec' 2 fun v => f v.head v.tail.head) ↔ Primrec₂ f 
Arguments: {f : ℕ → ℕ → ℕ}
Goal: (Nat.Primrec' fun v => f v.head v.tail.head) ↔ Primrec₂ f
-- Nat.Primrec'.vec_iff
theorem vec_iff {m n f} : @Vec m n f ↔ Primrec f 
Arguments: {m n : ℕ} {f : Mathlib.Vector ℕ m → Mathlib.Vector ℕ n}
Goal: Nat.Primrec'.Vec f ↔ Primrec f
-- Primrec.nat_sqrt
theorem Primrec.nat_sqrt : Primrec Nat.sqrt 
Goal: Primrec Nat.sqrt
-- ProbabilityTheory.poissonPMFRealSum
lemma poissonPMFRealSum (r : ℝ≥0) : HasSum (fun n ↦ poissonPMFReal r n) 1 
Arguments: (r : ℝ≥0)
Goal: HasSum (fun n => ProbabilityTheory.poissonPMFReal r n) 1
-- ProbabilityTheory.poissonPMFReal_pos
lemma poissonPMFReal_pos {r : ℝ≥0} {n : ℕ} (hr : 0 < r) : 0 < poissonPMFReal r n 
Arguments: {r : ℝ≥0} {n : ℕ} (hr : 0 < r)
Goal: 0 < ProbabilityTheory.poissonPMFReal r n
-- ProbabilityTheory.poissonPMFReal_nonneg
lemma poissonPMFReal_nonneg {r : ℝ≥0} {n : ℕ} : 0 ≤ poissonPMFReal r n 
Arguments: {r : ℝ≥0} {n : ℕ}
Goal: 0 ≤ ProbabilityTheory.poissonPMFReal r n
-- ProbabilityTheory.measurable_poissonPMFReal
@[measurability]
lemma measurable_poissonPMFReal (r : ℝ≥0) : Measurable (poissonPMFReal r) 
Arguments: (r : ℝ≥0)
Goal: Measurable (ProbabilityTheory.poissonPMFReal r)
-- ProbabilityTheory.stronglyMeasurable_poissonPMFReal
@[measurability]
lemma stronglyMeasurable_poissonPMFReal (r : ℝ≥0) : StronglyMeasurable (poissonPMFReal r) 
Arguments: (r : ℝ≥0)
Goal: MeasureTheory.StronglyMeasurable (ProbabilityTheory.poissonPMFReal r)
-- ProbabilityTheory.geometricPMFRealSum
lemma geometricPMFRealSum (hp_pos : 0 < p) (hp_le_one : p ≤ 1) :
    HasSum (fun n ↦ geometricPMFReal p n) 1 
Arguments: {p : ℝ} (hp_pos : 0 < p) (hp_le_one : p ≤ 1)
Goal: HasSum (fun n => ProbabilityTheory.geometricPMFReal p n) 1
-- ProbabilityTheory.geometricPMFReal_pos
lemma geometricPMFReal_pos {n : ℕ} (hp_pos : 0 < p) (hp_lt_one : p < 1) :
    0 < geometricPMFReal p n 
Arguments: {p : ℝ} {n : ℕ} (hp_pos : 0 < p) (hp_lt_one : p < 1)
Goal: 0 < ProbabilityTheory.geometricPMFReal p n
-- ProbabilityTheory.geometricPMFReal_nonneg
lemma geometricPMFReal_nonneg {n : ℕ} (hp_pos : 0 < p) (hp_le_one : p ≤ 1) :
    0 ≤ geometricPMFReal p n 
Arguments: {p : ℝ} {n : ℕ} (hp_pos : 0 < p) (hp_le_one : p ≤ 1)
Goal: 0 ≤ ProbabilityTheory.geometricPMFReal p n
-- ProbabilityTheory.measurable_geometricPMFReal
@[measurability]
lemma measurable_geometricPMFReal : Measurable (geometricPMFReal p) 
Arguments: {p : ℝ}
Goal: Measurable (ProbabilityTheory.geometricPMFReal p)
-- ProbabilityTheory.stronglyMeasurable_geometricPMFReal
@[measurability]
lemma stronglyMeasurable_geometricPMFReal : StronglyMeasurable (geometricPMFReal p) 
Arguments: {p : ℝ}
Goal: MeasureTheory.StronglyMeasurable (ProbabilityTheory.geometricPMFReal p)
-- ProbabilityTheory.isProbabilityMeasureGeometric
lemma isProbabilityMeasureGeometric (hp_pos : 0 < p) (hp_le_one : p ≤ 1) :
    IsProbabilityMeasure (geometricMeasure hp_pos hp_le_one) 
Arguments: {p : ℝ} (hp_pos : 0 < p) (hp_le_one : p ≤ 1)
Goal: MeasureTheory.IsProbabilityMeasure (ProbabilityTheory.geometricMeasure hp_pos hp_le_one)
-- ProbabilityTheory.iIndepSets_iff
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) 
Arguments: {Ω : Type u_1} {ι : Type u_2}
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)
-- ProbabilityTheory.iIndepSets.meas_biInter
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) 
Arguments: {Ω : Type u_1} {ι : Type u_2} {π : ι → Set (Set Ω)}
Goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω},
  ProbabilityTheory.iIndepSets π μ →
    ∀ (s : Finset ι) {f : ι → Set Ω}, (∀ i ∈ s, f i ∈ π i) → μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i)
-- ProbabilityTheory.iIndepSets.meas_iInter
lemma iIndepSets.meas_iInter [Fintype ι] (h : iIndepSets π μ) (hs : ∀ i, s i ∈ π i) :
    μ (⋂ i, s i) = ∏ i, μ (s i) 
Arguments: {Ω : Type u_1} {ι : Type u_2} {π : ι → Set (Set Ω)}
Goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s : ι → Set Ω} [inst : Fintype ι],
  ProbabilityTheory.iIndepSets π μ → (∀ (i : ι), s i ∈ π i) → μ (⋂ i, s i) = ∏ i : ι, μ (s i)
-- ProbabilityTheory.IndepSets_iff
lemma IndepSets_iff (s1 s2 : Set (Set Ω)) (μ : Measure Ω) :
    IndepSets s1 s2 μ ↔ ∀ t1 t2 : Set Ω, t1 ∈ s1 → t2 ∈ s2 → (μ (t1 ∩ t2) = μ t1 * μ t2) 
Arguments: {Ω : Type u_1}
Goal: ∀ {x : MeasurableSpace Ω} (s1 s2 : Set (Set Ω)) (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.IndepSets s1 s2 μ ↔ ∀ (t1 t2 : Set Ω), t1 ∈ s1 → t2 ∈ s2 → μ (t1 ∩ t2) = μ t1 * μ t2
-- ProbabilityTheory.iIndep_iff_iIndepSets
lemma iIndep_iff_iIndepSets (m : ι → MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : Measure Ω) :
    iIndep m μ ↔ iIndepSets (fun x ↦ {s | MeasurableSet[m x] s}) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} (m : ι → MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω)
Goal: ProbabilityTheory.iIndep m μ ↔ ProbabilityTheory.iIndepSets (fun x => {s | MeasurableSet s}) μ
-- ProbabilityTheory.iIndep.iIndepSets'
lemma iIndep.iIndepSets' {m : ι → MeasurableSpace Ω}
    {_ : MeasurableSpace Ω} {μ : Measure Ω} (hμ : iIndep m μ) :
    iIndepSets (fun x ↦ {s | MeasurableSet[m x] s}) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {m : ι → MeasurableSpace Ω}
Goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω},
  ProbabilityTheory.iIndep m μ → ProbabilityTheory.iIndepSets (fun x => {s | MeasurableSet s}) μ
-- ProbabilityTheory.iIndep_iff
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) 
Arguments: {Ω : Type u_1} {ι : Type u_2} (m : ι → MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω)
Goal: ProbabilityTheory.iIndep m μ ↔
  ∀ (s : Finset ι) {f : ι → Set Ω}, (∀ i ∈ s, MeasurableSet (f i)) → μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i)
-- ProbabilityTheory.iIndep.meas_biInter
lemma iIndep.meas_biInter (hμ : iIndep m μ) (hs : ∀ i, i ∈ S → MeasurableSet[m i] (s i)) :
    μ (⋂ i ∈ S, s i) = ∏ i ∈ S, μ (s i) 
Arguments: {Ω : Type u_1} {ι : Type u_2} {m : ι → MeasurableSpace Ω}
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)
-- ProbabilityTheory.iIndep.meas_iInter
lemma iIndep.meas_iInter [Fintype ι] (hμ : iIndep m μ) (hs : ∀ i, MeasurableSet[m i] (s i)) :
    μ (⋂ i, s i) = ∏ i, μ (s i) 
Arguments: {Ω : Type u_1} {ι : Type u_2} {m : ι → MeasurableSpace Ω}
Goal: ∀ {x : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s : ι → Set Ω} [inst : Fintype ι],
  ProbabilityTheory.iIndep m μ → (∀ (i : ι), MeasurableSet (s i)) → μ (⋂ i, s i) = ∏ i : ι, μ (s i)
-- ProbabilityTheory.Indep_iff_IndepSets
lemma Indep_iff_IndepSets (m₁ m₂ : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : Measure Ω) :
    Indep m₁ m₂ μ ↔ IndepSets {s | MeasurableSet[m₁] s} {s | MeasurableSet[m₂] s} μ 
Arguments: {Ω : Type u_1} (m₁ m₂ : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω)
Goal: ProbabilityTheory.Indep m₁ m₂ μ ↔ ProbabilityTheory.IndepSets {s | MeasurableSet s} {s | MeasurableSet s} μ
-- ProbabilityTheory.Indep_iff
lemma Indep_iff (m₁ m₂ : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : Measure Ω) :
    Indep m₁ m₂ μ
      ↔ ∀ t1 t2, MeasurableSet[m₁] t1 → MeasurableSet[m₂] t2 → μ (t1 ∩ t2) = μ t1 * μ t2 
Arguments: {Ω : Type u_1} (m₁ m₂ : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω)
Goal: ProbabilityTheory.Indep m₁ m₂ μ ↔ ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2
-- ProbabilityTheory.iIndepSet_iff_iIndep
lemma iIndepSet_iff_iIndep (s : ι → Set Ω) (μ : Measure Ω) :
    iIndepSet s μ ↔ iIndep (fun i ↦ generateFrom {s i}) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2}
Goal: ∀ {x : MeasurableSpace Ω} (s : ι → Set Ω) (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.iIndepSet s μ ↔ ProbabilityTheory.iIndep (fun i => MeasurableSpace.generateFrom {s i}) μ
-- ProbabilityTheory.iIndepSet_iff
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) 
Arguments: {Ω : Type u_1} {ι : Type u_2}
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)
-- ProbabilityTheory.IndepSet_iff_Indep
lemma IndepSet_iff_Indep (s t : Set Ω) (μ : Measure Ω) :
    IndepSet s t μ ↔ Indep (generateFrom {s}) (generateFrom {t}) μ 
Arguments: {Ω : Type u_1}
Goal: ∀ {x : MeasurableSpace Ω} (s t : Set Ω) (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.IndepSet s t μ ↔
    ProbabilityTheory.Indep (MeasurableSpace.generateFrom {s}) (MeasurableSpace.generateFrom {t}) μ
-- ProbabilityTheory.IndepSet_iff
lemma IndepSet_iff (s t : Set Ω) (μ : Measure Ω) :
    IndepSet s t μ ↔ ∀ t1 t2, MeasurableSet[generateFrom {s}] t1
      → MeasurableSet[generateFrom {t}] t2 → μ (t1 ∩ t2) = μ t1 * μ t2 
Arguments: {Ω : Type u_1}
Goal: ∀ {x : MeasurableSpace Ω} (s t : Set Ω) (μ : MeasureTheory.Measure Ω),
  ProbabilityTheory.IndepSet s t μ ↔ ∀ (t1 t2 : Set Ω), MeasurableSet t1 → MeasurableSet t2 → μ (t1 ∩ t2) = μ t1 * μ t2
-- ProbabilityTheory.iIndepFun_iff_iIndep
lemma iIndepFun_iff_iIndep {β : ι → Type*}
    (m : ∀ x : ι, MeasurableSpace (β x)) (f : ∀ x : ι, Ω → β x) (μ : Measure Ω) :
    iIndepFun m f μ ↔ iIndep (fun x ↦ (m x).comap (f x)) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2}
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)) μ
-- ProbabilityTheory.iIndepFun.iIndep
protected lemma iIndepFun.iIndep {m : ∀ i, MeasurableSpace (κ i)} {f : ∀ x : ι, Ω → κ x}
    (hf : iIndepFun m f μ) :
    iIndep (fun x ↦ (m x).comap (f x)) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {κ : ι → Type u_5}
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)) μ
-- ProbabilityTheory.iIndepFun_iff
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) 
Arguments: {Ω : Type u_1} {ι : Type u_2}
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)
-- ProbabilityTheory.iIndepFun.meas_biInter
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) 
Arguments: {Ω : Type u_1} {ι : Type u_2} {κ : ι → Type u_5}
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)
-- ProbabilityTheory.iIndepFun.meas_iInter
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) 
Arguments: {Ω : Type u_1} {ι : Type u_2} {κ : ι → Type u_5}
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)
-- ProbabilityTheory.IndepFun_iff_Indep
lemma IndepFun_iff_Indep [mβ : MeasurableSpace β]
    [mγ : MeasurableSpace γ] (f : Ω → β) (g : Ω → γ) (μ : Measure Ω) :
    IndepFun f g μ ↔ Indep (MeasurableSpace.comap f mβ) (MeasurableSpace.comap g mγ) μ 
Arguments: {Ω : Type u_1} {β : Type u_3} {γ : Type u_4}
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γ) μ
-- ProbabilityTheory.IndepFun_iff
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 
Arguments: {Ω : Type u_1}
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
-- ProbabilityTheory.IndepFun.meas_inter
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 
Arguments: {Ω : Type u_1} {β : Type u_3} {γ : Type u_4}
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
-- ProbabilityTheory.IndepSets.symm
@[symm]
theorem IndepSets.symm {s₁ s₂ : Set (Set Ω)} (h : IndepSets s₁ s₂ μ) : IndepSets s₂ s₁ μ 
Arguments: {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s₁ s₂ : Set (Set Ω)} (h : ProbabilityTheory.IndepSets s₁ s₂ μ)
Goal: ProbabilityTheory.IndepSets s₂ s₁ μ
-- ProbabilityTheory.Indep.symm
@[symm]
theorem Indep.symm (h : Indep m₁ m₂ μ) : Indep m₂ m₁ μ 
Arguments: {Ω : Type u_1} {m₁ m₂ _mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} (h : ProbabilityTheory.Indep m₁ m₂ μ)
Goal: ProbabilityTheory.Indep m₂ m₁ μ
-- ProbabilityTheory.indep_bot_right
theorem indep_bot_right [IsProbabilityMeasure μ] : Indep m' ⊥ μ 
Arguments: {Ω : Type u_1} (m' : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure μ]
Goal: ProbabilityTheory.Indep m' ⊥ μ
-- ProbabilityTheory.indep_bot_left
theorem indep_bot_left [IsProbabilityMeasure μ] : Indep ⊥ m' μ 
Arguments: {Ω : Type u_1} (m' : MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure μ]
Goal: ProbabilityTheory.Indep ⊥ m' μ
-- ProbabilityTheory.indepSet_empty_right
theorem indepSet_empty_right [IsProbabilityMeasure μ] (s : Set Ω) : IndepSet s ∅ μ 
Arguments: {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure μ] (s : Set Ω)
Goal: ProbabilityTheory.IndepSet s ∅ μ
-- ProbabilityTheory.indepSet_empty_left
theorem indepSet_empty_left [IsProbabilityMeasure μ] (s : Set Ω) : IndepSet ∅ s μ 
Arguments: {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [MeasureTheory.IsProbabilityMeasure μ] (s : Set Ω)
Goal: ProbabilityTheory.IndepSet ∅ s μ
-- ProbabilityTheory.indepSets_of_indepSets_of_le_left
theorem indepSets_of_indepSets_of_le_left {s₁ s₂ s₃ : Set (Set Ω)}
    (h_indep : IndepSets s₁ s₂ μ) (h31 : s₃ ⊆ s₁) :
    IndepSets s₃ s₂ μ 
Arguments: {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s₁ s₂ s₃ : Set (Set Ω)} (h_indep : ProbabilityTheory.IndepSets s₁ s₂ μ) (h31 : s₃ ⊆ s₁)
Goal: ProbabilityTheory.IndepSets s₃ s₂ μ
-- ProbabilityTheory.indepSets_of_indepSets_of_le_right
theorem indepSets_of_indepSets_of_le_right {s₁ s₂ s₃ : Set (Set Ω)}
    (h_indep : IndepSets s₁ s₂ μ) (h32 : s₃ ⊆ s₂) :
    IndepSets s₁ s₃ μ 
Arguments: {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s₁ s₂ s₃ : Set (Set Ω)} (h_indep : ProbabilityTheory.IndepSets s₁ s₂ μ) (h32 : s₃ ⊆ s₂)
Goal: ProbabilityTheory.IndepSets s₁ s₃ μ
-- ProbabilityTheory.indep_of_indep_of_le_left
theorem indep_of_indep_of_le_left (h_indep : Indep m₁ m₂ μ) (h31 : m₃ ≤ m₁) :
    Indep m₃ m₂ μ 
Arguments: {Ω : Type u_1} {m₁ m₂ m₃ _mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} (h_indep : ProbabilityTheory.Indep m₁ m₂ μ) (h31 : m₃ ≤ m₁)
Goal: ProbabilityTheory.Indep m₃ m₂ μ
-- ProbabilityTheory.indep_of_indep_of_le_right
theorem indep_of_indep_of_le_right (h_indep : Indep m₁ m₂ μ) (h32 : m₃ ≤ m₂) :
    Indep m₁ m₃ μ 
Arguments: {Ω : Type u_1} {m₁ m₂ m₃ _mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} (h_indep : ProbabilityTheory.Indep m₁ m₂ μ) (h32 : m₃ ≤ m₂)
Goal: ProbabilityTheory.Indep m₁ m₃ μ