ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ProbabilityTheory.iIndepFun.of_subsingleton
@[nontriviality]
lemma iIndepFun.of_subsingleton [IsProbabilityMeasure μ] [Subsingleton ι] : iIndepFun m f μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : ι → Type u_10} {m : (i : ι) → MeasurableSpace (β i)} {f : (i : ι) → Ω → β i} [MeasureTheory.IsProbabilityMeasure μ] [Subsingleton ι]
Goal: ProbabilityTheory.iIndepFun m f μ
-- ProbabilityTheory.iIndepFun.isProbabilityMeasure
lemma iIndepFun.isProbabilityMeasure (h : iIndepFun m f μ) : IsProbabilityMeasure μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : ι → Type u_10} {m : (i : ι) → MeasurableSpace (β i)} {f : (i : ι) → Ω → β i} (h : ProbabilityTheory.iIndepFun m f μ)
Goal: MeasureTheory.IsProbabilityMeasure μ
-- ProbabilityTheory.iIndepFun.indepFun_finset
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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : ι → Type u_10} {m : (i : ι) → MeasurableSpace (β i)} {f : (i : ι) → Ω → β i} (S T : Finset ι) (hST : Disjoint S T) (hf_Indep : ProbabilityTheory.iIndepFun m f μ) (hf_meas : ∀ (i : ι), Measurable (f i))
Goal: ProbabilityTheory.IndepFun (fun a i => f (↑i) a) (fun a i => f (↑i) a) μ
-- ProbabilityTheory.iIndepFun.indepFun_prod_mk
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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : ι → Type u_10} {m : (i : ι) → MeasurableSpace (β i)} {f : (i : ι) → Ω → β i} (hf_Indep : ProbabilityTheory.iIndepFun m f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k : ι) (hik : i ≠ k) (hjk : j ≠ k)
Goal: ProbabilityTheory.IndepFun (fun a => (f i a, f j a)) (f k) μ
-- ProbabilityTheory.iIndepFun.indepFun_prod_mk_prod_mk
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)) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : ι → Type u_10} {m : (i : ι) → MeasurableSpace (β i)} {f : (i : ι) → Ω → β i} (h_indep : ProbabilityTheory.iIndepFun m f μ) (hf : ∀ (i : ι), Measurable (f i)) (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l)
Goal: ProbabilityTheory.IndepFun (fun a => (f i a, f j a)) (fun a => (f k a, f l a)) μ
-- ProbabilityTheory.iIndepFun.indepFun_mul_left
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [Mul β] [MeasurableMul₂ β] {f : ι → Ω → β} (hf_indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k : ι) (hik : i ≠ k) (hjk : j ≠ k)
Goal: ProbabilityTheory.IndepFun (f i * f j) (f k) μ
-- ProbabilityTheory.iIndepFun.indepFun_add_left
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [Add β] [MeasurableAdd₂ β] {f : ι → Ω → β} (hf_indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k : ι) (hik : i ≠ k) (hjk : j ≠ k)
Goal: ProbabilityTheory.IndepFun (f i + f j) (f k) μ
-- ProbabilityTheory.iIndepFun.indepFun_add_right
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [Add β] [MeasurableAdd₂ β] {f : ι → Ω → β} (hf_indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k : ι) (hij : i ≠ j) (hik : i ≠ k)
Goal: ProbabilityTheory.IndepFun (f i) (f j + f k) μ
-- ProbabilityTheory.iIndepFun.indepFun_mul_right
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [Mul β] [MeasurableMul₂ β] {f : ι → Ω → β} (hf_indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k : ι) (hij : i ≠ j) (hik : i ≠ k)
Goal: ProbabilityTheory.IndepFun (f i) (f j * f k) μ
-- ProbabilityTheory.iIndepFun.indepFun_mul_mul
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [Mul β] [MeasurableMul₂ β] {f : ι → Ω → β} (hf_indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l)
Goal: ProbabilityTheory.IndepFun (f i * f j) (f k * f l) μ
-- ProbabilityTheory.iIndepFun.indepFun_add_add
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [Add β] [MeasurableAdd₂ β] {f : ι → Ω → β} (hf_indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l)
Goal: ProbabilityTheory.IndepFun (f i + f j) (f k + f l) μ
-- ProbabilityTheory.iIndepFun.indepFun_div_left
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [Div β] [MeasurableDiv₂ β] {f : ι → Ω → β} (hf_indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k : ι) (hik : i ≠ k) (hjk : j ≠ k)
Goal: ProbabilityTheory.IndepFun (f i / f j) (f k) μ
-- ProbabilityTheory.iIndepFun.indepFun_sub_left
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [Sub β] [MeasurableSub₂ β] {f : ι → Ω → β} (hf_indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k : ι) (hik : i ≠ k) (hjk : j ≠ k)
Goal: ProbabilityTheory.IndepFun (f i - f j) (f k) μ
-- ProbabilityTheory.iIndepFun.indepFun_sub_right
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [Sub β] [MeasurableSub₂ β] {f : ι → Ω → β} (hf_indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k : ι) (hij : i ≠ j) (hik : i ≠ k)
Goal: ProbabilityTheory.IndepFun (f i) (f j - f k) μ
-- ProbabilityTheory.iIndepFun.indepFun_div_right
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [Div β] [MeasurableDiv₂ β] {f : ι → Ω → β} (hf_indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k : ι) (hij : i ≠ j) (hik : i ≠ k)
Goal: ProbabilityTheory.IndepFun (f i) (f j / f k) μ
-- ProbabilityTheory.iIndepFun.indepFun_sub_sub
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [Sub β] [MeasurableSub₂ β] {f : ι → Ω → β} (hf_indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l)
Goal: ProbabilityTheory.IndepFun (f i - f j) (f k - f l) μ
-- ProbabilityTheory.iIndepFun.indepFun_div_div
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [Div β] [MeasurableDiv₂ β] {f : ι → Ω → β} (hf_indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) (i j k l : ι) (hik : i ≠ k) (hil : i ≠ l) (hjk : j ≠ k) (hjl : j ≠ l)
Goal: ProbabilityTheory.IndepFun (f i / f j) (f k / f l) μ
-- ProbabilityTheory.iIndepFun.indepFun_finset_prod_of_not_mem
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [CommMonoid β] [MeasurableMul₂ β] {f : ι → Ω → β} (hf_Indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) {s : Finset ι} {i : ι} (hi : i ∉ s)
Goal: ProbabilityTheory.IndepFun (∏ j ∈ s, f j) (f i) μ
-- ProbabilityTheory.iIndepFun.indepFun_finset_sum_of_not_mem
@[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) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [AddCommMonoid β] [MeasurableAdd₂ β] {f : ι → Ω → β} (hf_Indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ι), Measurable (f i)) {s : Finset ι} {i : ι} (hi : i ∉ s)
Goal: ProbabilityTheory.IndepFun (∑ j ∈ s, f j) (f i) μ
-- ProbabilityTheory.iIndepFun.indepFun_prod_range_succ
@[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) μ 
Arguments: {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [CommMonoid β] [MeasurableMul₂ β] {f : ℕ → Ω → β} (hf_Indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ℕ), Measurable (f i)) (n : ℕ)
Goal: ProbabilityTheory.IndepFun (∏ j ∈ Finset.range n, f j) (f n) μ
-- ProbabilityTheory.iIndepFun.indepFun_sum_range_succ
@[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) μ 
Arguments: {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10} {m : MeasurableSpace β} [AddCommMonoid β] [MeasurableAdd₂ β] {f : ℕ → Ω → β} (hf_Indep : ProbabilityTheory.iIndepFun (fun x => m) f μ) (hf_meas : ∀ (i : ℕ), Measurable (f i)) (n : ℕ)
Goal: ProbabilityTheory.IndepFun (∑ j ∈ Finset.range n, f j) (f n) μ
-- ProbabilityTheory.iIndepSet.iIndepFun_indicator
theorem iIndepSet.iIndepFun_indicator [Zero β] [One β] {m : MeasurableSpace β} {s : ι → Set Ω}
    (hs : iIndepSet s μ) :
    iIndepFun (fun _n => m) (fun n => (s n).indicator fun _ω => 1) μ 
Arguments: {Ω : Type u_1} {ι : Type u_2} {β : Type u_6} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [Zero β] [One β] {m : MeasurableSpace β} {s : ι → Set Ω} (hs : ProbabilityTheory.iIndepSet s μ)
Goal: ProbabilityTheory.iIndepFun (fun _n => m) (fun n => (s n).indicator fun _ω => 1) μ
-- Equiv.one_def
@[to_additive]
theorem one_def [One β] :
    letI := e.one
    1 = e.symm 1 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [One β]
Goal: 1 = e.symm 1
-- Equiv.zero_def
@[to_additive]
theorem one_def [One β] :
    letI := e.one
    1 = e.symm 1 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Zero β]
Goal: 0 = e.symm 0
-- Equiv.mul_def
@[to_additive]
theorem mul_def [Mul β] (x y : α) :
    letI := Equiv.mul e
    x * y = e.symm (e x * e y) 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Mul β] (x y : α)
Goal: x * y = e.symm (e x * e y)
-- Equiv.add_def
@[to_additive]
theorem mul_def [Mul β] (x y : α) :
    letI := Equiv.mul e
    x * y = e.symm (e x * e y) 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Add β] (x y : α)
Goal: x + y = e.symm (e x + e y)
-- Equiv.div_def
@[to_additive]
theorem div_def [Div β] (x y : α) :
    letI := Equiv.div e
    x / y = e.symm (e x / e y) 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Div β] (x y : α)
Goal: x / y = e.symm (e x / e y)
-- Equiv.sub_def
@[to_additive]
theorem div_def [Div β] (x y : α) :
    letI := Equiv.div e
    x / y = e.symm (e x / e y) 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Sub β] (x y : α)
Goal: x - y = e.symm (e x - e y)
-- Equiv.neg_def
@[to_additive]
theorem inv_def [Inv β] (x : α) :
    letI := Equiv.Inv e
    x⁻¹ = e.symm (e x)⁻¹ 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Neg β] (x : α)
Goal: -x = e.symm (-e x)
-- Equiv.inv_def
@[to_additive]
theorem inv_def [Inv β] (x : α) :
    letI := Equiv.Inv e
    x⁻¹ = e.symm (e x)⁻¹ 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Inv β] (x : α)
Goal: x⁻¹ = e.symm (e x)⁻¹
-- Equiv.smul_def
theorem smul_def {R : Type*} [SMul R β] (r : R) (x : α) :
    letI := e.smul R
    r • x = e.symm (r • e x) 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) {R : Type u_1} [SMul R β] (r : R) (x : α)
Goal: r • x = e.symm (r • e x)
-- Equiv.pow_def
theorem pow_def {N : Type*} [Pow β N] (n : N) (x : α) :
    letI := e.pow N
    x ^ n = e.symm (e x ^ n) 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) {N : Type u_1} [Pow β N] (n : N) (x : α)
Goal: x ^ n = e.symm (e x ^ n)
-- Equiv.addEquiv_apply
@[to_additive (attr := simp)]
theorem mulEquiv_apply (e : α ≃ β) [Mul β] (a : α) : (mulEquiv e) a = e a 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Add β] (a : α)
Goal: e.addEquiv a = e a
-- Equiv.mulEquiv_apply
@[to_additive (attr := simp)]
theorem mulEquiv_apply (e : α ≃ β) [Mul β] (a : α) : (mulEquiv e) a = e a 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Mul β] (a : α)
Goal: e.mulEquiv a = e a
-- Equiv.mulEquiv_symm_apply
@[to_additive]
theorem mulEquiv_symm_apply (e : α ≃ β) [Mul β] (b : β) :
    letI := Equiv.mul e
    (mulEquiv e).symm b = e.symm b 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Mul β] (b : β)
Goal: (MulEquiv.symm e.mulEquiv) b = e.symm b
-- Equiv.addEquiv_symm_apply
@[to_additive]
theorem mulEquiv_symm_apply (e : α ≃ β) [Mul β] (b : β) :
    letI := Equiv.mul e
    (mulEquiv e).symm b = e.symm b 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Add β] (b : β)
Goal: (AddEquiv.symm e.addEquiv) b = e.symm b
-- Equiv.ringEquiv_apply
@[simp]
theorem ringEquiv_apply (e : α ≃ β) [Add β] [Mul β] (a : α) : (ringEquiv e) a = e a 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Add β] [Mul β] (a : α)
Goal: e.ringEquiv a = e a
-- Equiv.ringEquiv_symm_apply
theorem ringEquiv_symm_apply (e : α ≃ β) [Add β] [Mul β] (b : β) : by
    letI := Equiv.add e
    letI := Equiv.mul e
    exact (ringEquiv e).symm b = e.symm b 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Add β] [Mul β] (b : β)
Goal: (RingEquiv.symm e.ringEquiv) b = e.symm b
-- Equiv.nontrivial
protected theorem nontrivial [Nontrivial β] : Nontrivial α 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β) [Nontrivial β]
Goal: Nontrivial α
-- Equiv.isDomain
protected theorem isDomain [Ring α] [Ring β] [IsDomain β] (e : α ≃+* β) : IsDomain α 
Arguments: {α : Type u} {β : Type v} [Ring α] [Ring β] [IsDomain β] (e : α ≃+* β)
Goal: IsDomain α
-- Shrink.linearEquiv_symm_apply
@[simps!]
noncomputable def _root_.Shrink.linearEquiv [Small.{v} α] [AddCommMonoid α] [Module R α] :
    Shrink.{v} α ≃ₗ[R] α 
Arguments: (α : Type u) (R : Type u_1) [Semiring R] [Small.{v, u} α] [AddCommMonoid α] [Module R α]
Goal: ∀ (a : α), (Shrink.linearEquiv α R).symm a = (AddEquiv.symm (equivShrink α).symm.addEquiv) a
-- Shrink.linearEquiv_apply
@[simps!]
noncomputable def _root_.Shrink.linearEquiv [Small.{v} α] [AddCommMonoid α] [Module R α] :
    Shrink.{v} α ≃ₗ[R] α 
Arguments: (α : Type u) (R : Type u_1) [Semiring R] [Small.{v, u} α] [AddCommMonoid α] [Module R α]
Goal: ∀ (a : Shrink.{v, u} α), (Shrink.linearEquiv α R) a = (equivShrink α).symm a
-- Equiv.algebraMap_def
lemma algebraMap_def (e : α ≃ β) [Semiring β] [Algebra R β] (r : R) :
    let semiring := Equiv.semiring e
    let algebra := Equiv.algebra R e
    (algebraMap R α) r = e.symm ((algebraMap R β) r) 
Arguments: {α : Type u} {β : Type v} (R : Type u_1) [CommSemiring R] (e : α ≃ β) [Semiring β] [Algebra R β] (r : R)
Goal: let semiring := e.semiring;
let algebra := Equiv.algebra R e;
(algebraMap R α) r = e.symm ((algebraMap R β) r)
-- Equiv.algEquiv_apply
@[simp]
theorem algEquiv_apply (e : α ≃ β) [Semiring β] [Algebra R β] (a : α) : (algEquiv R e) a = e a 
Arguments: {α : Type u} {β : Type v} (R : Type u_1) [CommSemiring R] (e : α ≃ β) [Semiring β] [Algebra R β] (a : α)
Goal: (Equiv.algEquiv R e) a = e a
-- Equiv.algEquiv_symm_apply
theorem algEquiv_symm_apply (e : α ≃ β) [Semiring β] [Algebra R β] (b : β) : by
    letI := Equiv.semiring e
    letI := Equiv.algebra R e
    exact (algEquiv R e).symm b = e.symm b 
Arguments: {α : Type u} {β : Type v} (R : Type u_1) [CommSemiring R] (e : α ≃ β) [Semiring β] [Algebra R β] (b : β)
Goal: (AlgEquiv.symm (Equiv.algEquiv R e)) b = e.symm b
-- Shrink.algEquiv_apply
@[simps!]
noncomputable def _root_.Shrink.algEquiv [Small.{v} α] [Semiring α] [Algebra R α] :
    Shrink.{v} α ≃ₐ[R] α 
Arguments: (α : Type u) (R : Type u_1) [CommSemiring R] [Small.{v, u} α] [Semiring α] [Algebra R α]
Goal: ∀ (a : Shrink.{v, u} α), (Shrink.algEquiv α R) a = (equivShrink α).symm a
-- Shrink.algEquiv_symm_apply
@[simps!]
noncomputable def _root_.Shrink.algEquiv [Small.{v} α] [Semiring α] [Algebra R α] :
    Shrink.{v} α ≃ₐ[R] α 
Arguments: (α : Type u) (R : Type u_1) [CommSemiring R] [Small.{v, u} α] [Semiring α] [Algebra R α]
Goal: ∀ (a : α), (Shrink.algEquiv α R).symm a = (equivShrink α) a
-- Finite.exists_type_zero_nonempty_mulEquiv
lemma exists_type_zero_nonempty_mulEquiv (G : Type u) [Group G] [Finite G] :
    ∃ (G' : Type) (_ : Group G') (_ : Fintype G'), Nonempty (G ≃* G') 
Arguments: (G : Type u) [Group G] [Finite G]
Goal: ∃ G' x x_1, Nonempty (G ≃* G')
-- lintegral_Iic_eq_lintegral_Iio_add_Icc
lemma lintegral_Iic_eq_lintegral_Iio_add_Icc {y z : ℝ} (f : ℝ → ℝ≥0∞) (hzy : z ≤ y) :
    ∫⁻ x in Iic y, f x = (∫⁻ x in Iio z, f x) + ∫⁻ x in Icc z y, f x 
Arguments: {y z : ℝ} (f : ℝ → ℝ≥0∞) (hzy : z ≤ y)
Goal: ∫⁻ (x : ℝ) in Set.Iic y, f x = (∫⁻ (x : ℝ) in Set.Iio z, f x) + ∫⁻ (x : ℝ) in Set.Icc z y, f x
-- ProbabilityTheory.gammaPDF_eq
lemma gammaPDF_eq (a r x : ℝ) :
    gammaPDF a r x = ENNReal.ofReal (if 0 ≤ x then
    r ^ a / (Gamma a) * x ^ (a-1) * exp (-(r * x)) else 0) 
Arguments: (a r x : ℝ)
Goal: ProbabilityTheory.gammaPDF a r x =
  ENNReal.ofReal (if 0 ≤ x then r ^ a / Real.Gamma a * x ^ (a - 1) * rexp (-(r * x)) else 0)
-- ProbabilityTheory.gammaPDF_of_neg
lemma gammaPDF_of_neg {a r x : ℝ} (hx : x < 0) : gammaPDF a r x = 0 
Arguments: {a r x : ℝ} (hx : x < 0)
Goal: ProbabilityTheory.gammaPDF a r x = 0
-- ProbabilityTheory.gammaPDF_of_nonneg
lemma gammaPDF_of_nonneg {a r x : ℝ} (hx : 0 ≤ x) :
    gammaPDF a r x = ENNReal.ofReal (r ^ a / (Gamma a) * x ^ (a-1) * exp (-(r * x))) 
Arguments: {a r x : ℝ} (hx : 0 ≤ x)
Goal: ProbabilityTheory.gammaPDF a r x = ENNReal.ofReal (r ^ a / Real.Gamma a * x ^ (a - 1) * rexp (-(r * x)))
-- ProbabilityTheory.lintegral_gammaPDF_of_nonpos
lemma lintegral_gammaPDF_of_nonpos {x a r : ℝ} (hx : x ≤ 0) :
    ∫⁻ y in Iio x, gammaPDF a r y = 0 
Arguments: {x a r : ℝ} (hx : x ≤ 0)
Goal: ∫⁻ (y : ℝ) in Set.Iio x, ProbabilityTheory.gammaPDF a r y = 0
-- ProbabilityTheory.measurable_gammaPDFReal
@[measurability]
lemma measurable_gammaPDFReal (a r : ℝ) : Measurable (gammaPDFReal a r) 
Arguments: (a r : ℝ)
Goal: Measurable (ProbabilityTheory.gammaPDFReal a r)
-- ProbabilityTheory.stronglyMeasurable_gammaPDFReal
@[measurability]
 lemma stronglyMeasurable_gammaPDFReal (a r : ℝ) :
     StronglyMeasurable (gammaPDFReal a r) 
Arguments: (a r : ℝ)
Goal: MeasureTheory.StronglyMeasurable (ProbabilityTheory.gammaPDFReal a r)
-- ProbabilityTheory.gammaPDFReal_pos
lemma gammaPDFReal_pos {x a r : ℝ} (ha : 0 < a) (hr : 0 < r) (hx : 0 < x) :
    0 < gammaPDFReal a r x 
Arguments: {x a r : ℝ} (ha : 0 < a) (hr : 0 < r) (hx : 0 < x)
Goal: 0 < ProbabilityTheory.gammaPDFReal a r x
-- ProbabilityTheory.gammaPDFReal_nonneg
lemma gammaPDFReal_nonneg {a r : ℝ} (ha : 0 < a) (hr : 0 < r) (x : ℝ) :
    0 ≤ gammaPDFReal a r x 
Arguments: {a r : ℝ} (ha : 0 < a) (hr : 0 < r) (x : ℝ)
Goal: 0 ≤ ProbabilityTheory.gammaPDFReal a r x
-- ProbabilityTheory.lintegral_gammaPDF_eq_one
@[simp]
lemma lintegral_gammaPDF_eq_one {a r : ℝ} (ha : 0 < a) (hr : 0 < r) :
    ∫⁻ x, gammaPDF a r x = 1 
Arguments: {a r : ℝ} (ha : 0 < a) (hr : 0 < r)
Goal: ∫⁻ (x : ℝ), ProbabilityTheory.gammaPDF a r x = 1
-- ProbabilityTheory.isProbabilityMeasureGamma
lemma isProbabilityMeasureGamma {a r : ℝ} (ha : 0 < a) (hr : 0 < r) :
    IsProbabilityMeasure (gammaMeasure a r) 
Arguments: {a r : ℝ} (ha : 0 < a) (hr : 0 < r)
Goal: MeasureTheory.IsProbabilityMeasure (ProbabilityTheory.gammaMeasure a r)
-- ProbabilityTheory.gammaCDFReal_eq_integral
lemma gammaCDFReal_eq_integral {a r : ℝ} (ha : 0 < a) (hr : 0 < r) (x : ℝ) :
    gammaCDFReal a r x = ∫ x in Iic x, gammaPDFReal a r x 
Arguments: {a r : ℝ} (ha : 0 < a) (hr : 0 < r) (x : ℝ)
Goal: ↑(ProbabilityTheory.gammaCDFReal a r) x = ∫ (x : ℝ) in Set.Iic x, ProbabilityTheory.gammaPDFReal a r x
-- ProbabilityTheory.gammaCDFReal_eq_lintegral
lemma gammaCDFReal_eq_lintegral {a r : ℝ} (ha : 0 < a) (hr : 0 < r) (x : ℝ) :
    gammaCDFReal a r x = ENNReal.toReal (∫⁻ x in Iic x, gammaPDF a r x) 
Arguments: {a r : ℝ} (ha : 0 < a) (hr : 0 < r) (x : ℝ)
Goal: ↑(ProbabilityTheory.gammaCDFReal a r) x = (∫⁻ (x : ℝ) in Set.Iic x, ProbabilityTheory.gammaPDF a r x).toReal
-- MeasureTheory.Measure.IsCondKernel.disintegrate
class IsCondKernel : Prop where
  disintegrate : ρ.fst ⊗ₘ ρCond = ρ
Arguments: {α : Type u_1} {Ω : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω} {ρ : MeasureTheory.Measure (α × Ω)} {ρCond : ProbabilityTheory.Kernel α Ω} [self : ρ.IsCondKernel ρCond]
Goal: ρ.fst ⊗ₘ ρCond = ρ