ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Logic/Pairwise.lean

full_name: Pairwise
code: /-- A relation `r` holds pairwise if `r i j` for all `i ≠ j`. -/
def Pairwise (r : α → α → Prop) 
goal: Prop

full_name: Pairwise.mono
code: theorem Pairwise.mono (hr : Pairwise r) (h : ∀ ⦃i j⦄, r i j → p i j) : Pairwise p 
goal: Pairwise p

full_name: Pairwise.eq
code: protected theorem Pairwise.eq (h : Pairwise r) : ¬r a b → a = b 
goal: ¬r a b → a = b

full_name: Subsingleton.pairwise
code: protected lemma Subsingleton.pairwise [Subsingleton α] : Pairwise r 
goal: Pairwise r

full_name: Function.injective_iff_pairwise_ne
code: theorem Function.injective_iff_pairwise_ne : Injective f ↔ Pairwise ((· ≠ ·) on f) 
goal: Function.Injective f ↔ Pairwise ((fun x x_1 => x ≠ x_1) on f)

full_name: Pairwise.comp_of_injective
code: lemma Pairwise.comp_of_injective (hr : Pairwise r) {f : β → α} (hf : Injective f) :
    Pairwise (r on f) 
goal: Pairwise (r on f)

full_name: Pairwise.of_comp_of_surjective
code: lemma Pairwise.of_comp_of_surjective {f : β → α} (hr : Pairwise (r on f)) (hf : Surjective f) :
    Pairwise r 
goal: Pairwise r

full_name: Function.Bijective.pairwise_comp_iff
code: lemma Function.Bijective.pairwise_comp_iff {f : β → α} (hf : Bijective f) :
    Pairwise (r on f) ↔ Pairwise r 
goal: Pairwise (r on f) ↔ Pairwise r

full_name: Set.Pairwise
code: /-- The relation `r` holds pairwise on the set `s` if `r x y` for all *distinct* `x y ∈ s`. -/
protected def Pairwise (s : Set α) (r : α → α → Prop) 
goal: Prop

full_name: Set.pairwise_of_forall
code: theorem pairwise_of_forall (s : Set α) (r : α → α → Prop) (h : ∀ a b, r a b) : s.Pairwise r 
goal: s.Pairwise r

full_name: Set.Pairwise.imp_on
code: theorem Pairwise.imp_on (h : s.Pairwise r) (hrp : s.Pairwise fun ⦃a b : α⦄ => r a b → p a b) :
    s.Pairwise p 
goal: s.Pairwise p

full_name: Set.Pairwise.imp
code: theorem Pairwise.imp (h : s.Pairwise r) (hpq : ∀ ⦃a b : α⦄, r a b → p a b) : s.Pairwise p 
goal: s.Pairwise p

full_name: Set.Pairwise.eq
code: protected theorem Pairwise.eq (hs : s.Pairwise r) (ha : a ∈ s) (hb : b ∈ s) (h : ¬r a b) : a = b 
goal: a = b

full_name: Reflexive.set_pairwise_iff
code: theorem _root_.Reflexive.set_pairwise_iff (hr : Reflexive r) :
    s.Pairwise r ↔ ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ s → r a b 
goal: s.Pairwise r ↔ ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → r a b

full_name: Set.Pairwise.on_injective
code: theorem Pairwise.on_injective (hs : s.Pairwise r) (hf : Function.Injective f) (hfs : ∀ x, f x ∈ s) :
    Pairwise (r on f) 
goal: Pairwise (r on f)

full_name: Pairwise.set_pairwise
code: theorem Pairwise.set_pairwise (h : Pairwise r) (s : Set α) : s.Pairwise r 
goal: s.Pairwise r
File: Mathlib/Logic/Encodable/Lattice.lean

full_name: Encodable.iSup_decode₂
code: theorem iSup_decode₂ [CompleteLattice α] (f : β → α) :
    ⨆ (i : ℕ) (b ∈ decode₂ β i), f b = (⨆ b, f b) 
goal: ⨆ i, ⨆ b ∈ Encodable.decode₂ β i, f b = ⨆ b, f b

full_name: Encodable.iUnion_decode₂
code: theorem iUnion_decode₂ (f : β → Set α) : ⋃ (i : ℕ) (b ∈ decode₂ β i), f b = ⋃ b, f b 
goal: ⋃ i, ⋃ b ∈ Encodable.decode₂ β i, f b = ⋃ b, f b

full_name: Encodable.iUnion_decode₂_cases
code: theorem iUnion_decode₂_cases {f : β → Set α} {C : Set α → Prop} (H0 : C ∅) (H1 : ∀ b, C (f b)) {n} :
    C (⋃ b ∈ decode₂ β n, f b) 
goal: C (⋃ b ∈ Encodable.decode₂ β n, f b)

full_name: Encodable.iUnion_decode₂_disjoint_on
code: theorem iUnion_decode₂_disjoint_on {f : β → Set α} (hd : Pairwise (Disjoint on f)) :
    Pairwise (Disjoint on fun i => ⋃ b ∈ decode₂ β i, f b) 
goal: Pairwise (Disjoint on fun i => ⋃ b ∈ Encodable.decode₂ β i, f b)
File: Mathlib/Probability/Notation.lean

full_name: ProbabilityTheory.«_aux_Mathlib_Probability_Notation___macroRules_ProbabilityTheory_term𝔼[_|_]_1»
code: scoped[ProbabilityTheory] notation "𝔼[" X "|" m "]" =>
  MeasureTheory.condexp m MeasureTheory.MeasureSpace.volume X
goal: Lean.Macro

full_name: ProbabilityTheory._aux_Mathlib_Probability_Notation___unexpand_MeasureTheory_condexp_1
code: scoped[ProbabilityTheory] notation "𝔼[" X "|" m "]" =>
  MeasureTheory.condexp m MeasureTheory.MeasureSpace.volume X
goal: Lean.PrettyPrinter.Unexpander

full_name: ProbabilityTheory.«_aux_Mathlib_Probability_Notation___macroRules_ProbabilityTheory_term_[_]_1»
code: scoped[ProbabilityTheory] notation P "[" X "]" => ∫ x, ↑(X x) ∂P
goal: Lean.Macro

full_name: ProbabilityTheory.«_aux_Mathlib_Probability_Notation___macroRules_ProbabilityTheory_term𝔼[_]_1»
code: scoped[ProbabilityTheory] notation "𝔼[" X "]" => ∫ a, (X : _ → _) a
goal: Lean.Macro

full_name: ProbabilityTheory._aux_Mathlib_Probability_Notation___unexpand_MeasureTheory_condexp_2
code: scoped[ProbabilityTheory] notation P "⟦" s "|" m "⟧" =>
  MeasureTheory.condexp m P (Set.indicator s fun ω => (1 : ℝ))
goal: Lean.PrettyPrinter.Unexpander

full_name: ProbabilityTheory.«_aux_Mathlib_Probability_Notation___macroRules_ProbabilityTheory_term_⟦_|_⟧_1»
code: scoped[ProbabilityTheory] notation P "⟦" s "|" m "⟧" =>
  MeasureTheory.condexp m P (Set.indicator s fun ω => (1 : ℝ))
goal: Lean.Macro

full_name: ProbabilityTheory.«_aux_Mathlib_Probability_Notation___macroRules_ProbabilityTheory_term_=ₐₛ__1»
code: scoped[ProbabilityTheory] notation:50 X " =ₐₛ " Y:50 => X =ᵐ[MeasureTheory.MeasureSpace.volume] Y
goal: Lean.Macro

full_name: ProbabilityTheory.«_aux_Mathlib_Probability_Notation___macroRules_ProbabilityTheory_term_≤ₐₛ__1»
code: scoped[ProbabilityTheory] notation:50 X " ≤ₐₛ " Y:50 => X ≤ᵐ[MeasureTheory.MeasureSpace.volume] Y
goal: Lean.Macro

full_name: ProbabilityTheory._aux_Mathlib_Probability_Notation___unexpand_MeasureTheory_Measure_rnDeriv_1
code: scoped[ProbabilityTheory] notation "∂" P "/∂" Q:100 => MeasureTheory.Measure.rnDeriv P Q
goal: Lean.PrettyPrinter.Unexpander

full_name: ProbabilityTheory.«_aux_Mathlib_Probability_Notation___macroRules_ProbabilityTheory_term∂_/∂__1»
code: scoped[ProbabilityTheory] notation "∂" P "/∂" Q:100 => MeasureTheory.Measure.rnDeriv P Q
goal: Lean.Macro

full_name: ProbabilityTheory._aux_Mathlib_Probability_Notation___unexpand_MeasureTheory_MeasureSpace_volume_1
code: scoped[ProbabilityTheory] notation "ℙ" => MeasureTheory.MeasureSpace.volume
goal: Lean.PrettyPrinter.Unexpander

full_name: ProbabilityTheory._aux_Mathlib_Probability_Notation___macroRules_ProbabilityTheory_termℙ_1
code: scoped[ProbabilityTheory] notation "ℙ" => MeasureTheory.MeasureSpace.volume
goal: Lean.Macro
File: Mathlib/Probability/Distributions/Poisson.lean

full_name: ProbabilityTheory.poissonPMFReal
code: /-- The pmf of the Poisson distribution depending on its rate, as a function to ℝ -/
noncomputable
def poissonPMFReal (r : ℝ≥0) (n : ℕ) : ℝ 
goal: ℝ

full_name: ProbabilityTheory.poissonPMFRealSum
code: lemma poissonPMFRealSum (r : ℝ≥0) : HasSum (fun n ↦ poissonPMFReal r n) 1 
goal: HasSum (fun n => ProbabilityTheory.poissonPMFReal r n) 1

full_name: ProbabilityTheory.poissonPMFReal_pos
code: /-- The Poisson pmf is positive for all natural numbers -/
lemma poissonPMFReal_pos {r : ℝ≥0} {n : ℕ} (hr : 0 < r) : 0 < poissonPMFReal r n 
goal: 0 < ProbabilityTheory.poissonPMFReal r n

full_name: ProbabilityTheory.poissonPMFReal_nonneg
code: lemma poissonPMFReal_nonneg {r : ℝ≥0} {n : ℕ} : 0 ≤ poissonPMFReal r n 
goal: 0 ≤ ProbabilityTheory.poissonPMFReal r n

full_name: ProbabilityTheory.poissonPMF
code: /-- The pmf of the Poisson distribution depending on its rate, as a PMF. -/
noncomputable
def poissonPMF (r : ℝ≥0) : PMF ℕ 
goal: PMF ℕ

full_name: ProbabilityTheory.measurable_poissonPMFReal
code: /-- The Poisson pmf is measurable. -/
@[measurability]
lemma measurable_poissonPMFReal (r : ℝ≥0) : Measurable (poissonPMFReal r) 
goal: Measurable (ProbabilityTheory.poissonPMFReal r)

full_name: ProbabilityTheory.stronglyMeasurable_poissonPMFReal
code: @[measurability]
lemma stronglyMeasurable_poissonPMFReal (r : ℝ≥0) : StronglyMeasurable (poissonPMFReal r) 
goal: MeasureTheory.StronglyMeasurable (ProbabilityTheory.poissonPMFReal r)

full_name: ProbabilityTheory.poissonMeasure
code: /-- Measure defined by the Poisson distribution -/
noncomputable
def poissonMeasure (r : ℝ≥0) : Measure ℕ 
goal: MeasureTheory.Measure ℕ

full_name: ProbabilityTheory.isProbabilityMeasurePoisson
code: instance isProbabilityMeasurePoisson (r : ℝ≥0) :
    IsProbabilityMeasure (poissonMeasure r) 
goal: MeasureTheory.IsProbabilityMeasure (ProbabilityTheory.poissonMeasure r)
File: Mathlib/Probability/Distributions/Geometric.lean

full_name: ProbabilityTheory.geometricPMFReal
code: /-- The pmf of the geometric distribution depending on its success probability. -/
noncomputable
def geometricPMFReal (p : ℝ) (n : ℕ) : ℝ 
goal: ℝ

full_name: ProbabilityTheory.geometricPMFRealSum
code: lemma geometricPMFRealSum (hp_pos : 0 < p) (hp_le_one : p ≤ 1) :
    HasSum (fun n ↦ geometricPMFReal p n) 1 
goal: HasSum (fun n => ProbabilityTheory.geometricPMFReal p n) 1

full_name: ProbabilityTheory.geometricPMFReal_pos
code: /-- The geometric pmf is positive for all natural numbers -/
lemma geometricPMFReal_pos {n : ℕ} (hp_pos : 0 < p) (hp_lt_one : p < 1) :
    0 < geometricPMFReal p n 
goal: 0 < ProbabilityTheory.geometricPMFReal p n

full_name: ProbabilityTheory.geometricPMFReal_nonneg
code: lemma geometricPMFReal_nonneg {n : ℕ} (hp_pos : 0 < p) (hp_le_one : p ≤ 1) :
    0 ≤ geometricPMFReal p n 
goal: 0 ≤ ProbabilityTheory.geometricPMFReal p n

full_name: ProbabilityTheory.geometricPMF
code: /-- Geometric distribution with success probability `p`. -/
noncomputable
def geometricPMF (hp_pos : 0 < p) (hp_le_one : p ≤ 1) : PMF ℕ 
goal: PMF ℕ

full_name: ProbabilityTheory.measurable_geometricPMFReal
code: /-- The geometric pmf is measurable. -/
@[measurability]
lemma measurable_geometricPMFReal : Measurable (geometricPMFReal p) 
goal: Measurable (ProbabilityTheory.geometricPMFReal p)

full_name: ProbabilityTheory.stronglyMeasurable_geometricPMFReal
code: @[measurability]
lemma stronglyMeasurable_geometricPMFReal : StronglyMeasurable (geometricPMFReal p) 
goal: MeasureTheory.StronglyMeasurable (ProbabilityTheory.geometricPMFReal p)

full_name: ProbabilityTheory.geometricMeasure
code: /-- Measure defined by the geometric distribution -/
noncomputable
def geometricMeasure (hp_pos : 0 < p) (hp_le_one : p ≤ 1) : Measure ℕ 
goal: MeasureTheory.Measure ℕ

full_name: ProbabilityTheory.isProbabilityMeasureGeometric
code: lemma isProbabilityMeasureGeometric (hp_pos : 0 < p) (hp_le_one : p ≤ 1) :
    IsProbabilityMeasure (geometricMeasure hp_pos hp_le_one) 
goal: MeasureTheory.IsProbabilityMeasure (ProbabilityTheory.geometricMeasure hp_pos hp_le_one)
File: Mathlib/Probability/Kernel/Invariance.lean

full_name: ProbabilityTheory.Kernel.bind_add
code: @[simp]
theorem bind_add (μ ν : Measure α) (κ : Kernel α β) : (μ + ν).bind κ = μ.bind κ + ν.bind κ 
goal: (μ + ν).bind ⇑κ = μ.bind ⇑κ + ν.bind ⇑κ

full_name: ProbabilityTheory.Kernel.bind_smul
code: @[simp]
theorem bind_smul (κ : Kernel α β) (μ : Measure α) (r : ℝ≥0∞) : (r • μ).bind κ = r • μ.bind κ 
goal: (r • μ).bind ⇑κ = r • μ.bind ⇑κ

full_name: ProbabilityTheory.Kernel.const_bind_eq_comp_const
code: theorem const_bind_eq_comp_const (κ : Kernel α β) (μ : Measure α) :
    const α (μ.bind κ) = κ ∘ₖ const α μ 
goal: ProbabilityTheory.Kernel.const α (μ.bind ⇑κ) = κ ∘ₖ ProbabilityTheory.Kernel.const α μ

full_name: ProbabilityTheory.Kernel.comp_const_apply_eq_bind
code: theorem comp_const_apply_eq_bind (κ : Kernel α β) (μ : Measure α) (a : α) :
    (κ ∘ₖ const α μ) a = μ.bind κ 
goal: (κ ∘ₖ ProbabilityTheory.Kernel.const α μ) a = μ.bind ⇑κ

full_name: ProbabilityTheory.Kernel.Invariant
code: /-- A measure `μ` is invariant with respect to the kernel `κ` if the push-forward measure of `μ`
along `κ` equals `μ`. -/
def Invariant (κ : Kernel α α) (μ : Measure α) : Prop 
goal: Prop

full_name: ProbabilityTheory.Kernel.Invariant.def
code: theorem Invariant.def (hκ : Invariant κ μ) : μ.bind κ = μ 
goal: μ.bind ⇑κ = μ

full_name: ProbabilityTheory.Kernel.Invariant.comp_const
code: theorem Invariant.comp_const (hκ : Invariant κ μ) : κ ∘ₖ const α μ = const α μ 
goal: κ ∘ₖ ProbabilityTheory.Kernel.const α μ = ProbabilityTheory.Kernel.const α μ

full_name: ProbabilityTheory.Kernel.Invariant.comp
code: theorem Invariant.comp [IsSFiniteKernel κ] (hκ : Invariant κ μ) (hη : Invariant η μ) :
    Invariant (κ ∘ₖ η) μ 
goal: (κ ∘ₖ η).Invariant μ
File: Mathlib/Probability/Cdf.lean

full_name: ProbabilityTheory.cdf
code: /-- Cumulative distribution function of a real measure. The definition currently makes sense only
for probability measures. In that case, it satisfies `cdf μ x = (μ (Iic x)).toReal` (see
`ProbabilityTheory.cdf_eq_toReal`). -/
noncomputable
def cdf (μ : Measure ℝ) : StieltjesFunction 
goal: StieltjesFunction

full_name: ProbabilityTheory.cdf_nonneg
code: /-- The cdf is non-negative. -/
lemma cdf_nonneg (x : ℝ) : 0 ≤ cdf μ x 
goal: 0 ≤ ↑(ProbabilityTheory.cdf μ) x

full_name: ProbabilityTheory.cdf_le_one
code: /-- The cdf is lower or equal to 1. -/
lemma cdf_le_one (x : ℝ) : cdf μ x ≤ 1 
goal: ↑(ProbabilityTheory.cdf μ) x ≤ 1

full_name: ProbabilityTheory.monotone_cdf
code: /-- The cdf is monotone. -/
lemma monotone_cdf : Monotone (cdf μ) 
goal: Monotone ↑(ProbabilityTheory.cdf μ)

full_name: ProbabilityTheory.tendsto_cdf_atBot
code: /-- The cdf tends to 0 at -∞. -/
lemma tendsto_cdf_atBot : Tendsto (cdf μ) atBot (𝓝 0) 
goal: Filter.Tendsto (↑(ProbabilityTheory.cdf μ)) Filter.atBot (𝓝 0)

full_name: ProbabilityTheory.tendsto_cdf_atTop
code: /-- The cdf tends to 1 at +∞. -/
lemma tendsto_cdf_atTop : Tendsto (cdf μ) atTop (𝓝 1) 
goal: Filter.Tendsto (↑(ProbabilityTheory.cdf μ)) Filter.atTop (𝓝 1)

full_name: ProbabilityTheory.ofReal_cdf
code: lemma ofReal_cdf [IsProbabilityMeasure μ] (x : ℝ) : ENNReal.ofReal (cdf μ x) = μ (Iic x) 
goal: ENNReal.ofReal (↑(ProbabilityTheory.cdf μ) x) = μ (Set.Iic x)

full_name: ProbabilityTheory.cdf_eq_toReal
code: lemma cdf_eq_toReal [IsProbabilityMeasure μ] (x : ℝ) : cdf μ x = (μ (Iic x)).toReal 
goal: ↑(ProbabilityTheory.cdf μ) x = (μ (Set.Iic x)).toReal

full_name: ProbabilityTheory.instIsProbabilityMeasurecdf
code: instance instIsProbabilityMeasurecdf : IsProbabilityMeasure (cdf μ).measure 
goal: MeasureTheory.IsProbabilityMeasure (ProbabilityTheory.cdf μ).measure

full_name: ProbabilityTheory.measure_cdf
code: /-- The measure associated to the cdf of a probability measure is the same probability measure. -/
lemma measure_cdf [IsProbabilityMeasure μ] : (cdf μ).measure = μ 
goal: (ProbabilityTheory.cdf μ).measure = μ

full_name: ProbabilityTheory.cdf_measure_stieltjesFunction
code: lemma cdf_measure_stieltjesFunction (f : StieltjesFunction) (hf0 : Tendsto f atBot (𝓝 0))
    (hf1 : Tendsto f atTop (𝓝 1)) :
    cdf f.measure = f 
goal: ProbabilityTheory.cdf f.measure = f

full_name: MeasureTheory.Measure.eq_of_cdf
code: /-- If two real probability distributions have the same cdf, they are equal. -/
lemma MeasureTheory.Measure.eq_of_cdf (μ ν : Measure ℝ) [IsProbabilityMeasure μ]
    [IsProbabilityMeasure ν] (h : cdf μ = cdf ν) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.cdf_eq_iff
code: @[simp] lemma MeasureTheory.Measure.cdf_eq_iff (μ ν : Measure ℝ) [IsProbabilityMeasure μ]
    [IsProbabilityMeasure ν] :
    cdf μ = cdf ν ↔ μ = ν 
goal: ProbabilityTheory.cdf μ = ProbabilityTheory.cdf ν ↔ μ = ν
File: Mathlib/Probability/ConditionalExpectation.lean

full_name: MeasureTheory.condexp_indep_eq
code: /-- If `m₁, m₂` are independent σ-algebras and `f` is `m₁`-measurable, then `𝔼[f | m₂] = 𝔼[f]`
almost everywhere. -/
theorem condexp_indep_eq (hle₁ : m₁ ≤ m) (hle₂ : m₂ ≤ m) [SigmaFinite (μ.trim hle₂)]
    (hf : StronglyMeasurable[m₁] f) (hindp : Indep m₁ m₂ μ) : μ[f|m₂] =ᵐ[μ] fun _ => μ[f] 
goal: μ[f|m₂] =ᵐ[μ] fun x => ∫ (x : Ω), f x ∂μ
File: Mathlib/Probability/ProbabilityMassFunction/Integrals.lean

full_name: PMF.integral_eq_tsum
code: theorem integral_eq_tsum (p : PMF α) (f : α → E) (hf : Integrable f p.toMeasure) :
    ∫ a, f a ∂(p.toMeasure) = ∑' a, (p a).toReal • f a 
goal: ∫ (a : α), f a ∂p.toMeasure = ∑' (a : α), (p a).toReal • f a

full_name: PMF.integral_eq_sum
code: theorem integral_eq_sum [Fintype α] (p : PMF α) (f : α → E) :
    ∫ a, f a ∂(p.toMeasure) = ∑ a, (p a).toReal • f a 
goal: ∫ (a : α), f a ∂p.toMeasure = ∑ a : α, (p a).toReal • f a

full_name: PMF.bernoulli_expectation
code: theorem bernoulli_expectation {p : ℝ≥0∞} (h : p ≤ 1) :
    ∫ b, cond b 1 0 ∂((bernoulli p h).toMeasure) = p.toReal 
goal: ∫ (b : Bool), bif b then 1 else 0 ∂(PMF.bernoulli p h).toMeasure = p.toReal
File: Mathlib/Probability/BorelCantelli.lean

full_name: ProbabilityTheory.iIndepFun.indep_comap_natural_of_lt
code: theorem iIndepFun.indep_comap_natural_of_lt (hf : ∀ i, StronglyMeasurable (f i))
    (hfi : iIndepFun (fun _ => mβ) f μ) (hij : i < j) :
    Indep (MeasurableSpace.comap (f j) mβ) (Filtration.natural f hf i) μ 
goal: ProbabilityTheory.Indep (MeasurableSpace.comap (f j) mβ) (↑(MeasureTheory.Filtration.natural f hf) i) μ

full_name: ProbabilityTheory.iIndepFun.condexp_natural_ae_eq_of_lt
code: theorem iIndepFun.condexp_natural_ae_eq_of_lt [SecondCountableTopology β] [CompleteSpace β]
    [NormedSpace ℝ β] (hf : ∀ i, StronglyMeasurable (f i)) (hfi : iIndepFun (fun _ => mβ) f μ)
    (hij : i < j) : μ[f j|Filtration.natural f hf i] =ᵐ[μ] fun _ => μ[f j] 
goal: μ[f j|↑(MeasureTheory.Filtration.natural f hf) i] =ᵐ[μ] fun x => ∫ (x : Ω), f j x ∂μ

full_name: ProbabilityTheory.iIndepSet.condexp_indicator_filtrationOfSet_ae_eq
code: theorem iIndepSet.condexp_indicator_filtrationOfSet_ae_eq (hsm : ∀ n, MeasurableSet (s n))
    (hs : iIndepSet s μ) (hij : i < j) :
    μ[(s j).indicator (fun _ => 1 : Ω → ℝ)|filtrationOfSet hsm i] =ᵐ[μ]
    fun _ => (μ (s j)).toReal 
goal: μ[(s j).indicator fun x => 1|↑(MeasureTheory.filtrationOfSet hsm) i] =ᵐ[μ] fun x => (μ (s j)).toReal

full_name: ProbabilityTheory.measure_limsup_eq_one
code: /-- **The second Borel-Cantelli lemma**: Given a sequence of independent sets `(sₙ)` such that
`∑ n, μ sₙ = ∞`, `limsup sₙ` has measure 1. -/
theorem measure_limsup_eq_one {s : ℕ → Set Ω} (hsm : ∀ n, MeasurableSet (s n)) (hs : iIndepSet s μ)
    (hs' : (∑' n, μ (s n)) = ∞) : μ (limsup s atTop) = 1 
goal: μ (Filter.limsup s Filter.atTop) = 1
File: Mathlib/Probability/ProbabilityMassFunction/Binomial.lean

full_name: PMF.binomial
code: /-- The binomial `PMF`: the probability of observing exactly `i` “heads” in a sequence of `n`
independent coin tosses, each having probability `p` of coming up “heads”. -/
noncomputable
def binomial (p : ℝ≥0∞) (h : p ≤ 1) (n : ℕ) : PMF (Fin (n + 1)) 
goal: PMF (Fin (n + 1))

full_name: PMF.binomial_apply
code: theorem binomial_apply (p : ℝ≥0∞) (h : p ≤ 1) (n : ℕ) (i : Fin (n + 1)) :
    binomial p h n i = p^(i : ℕ) * (1-p)^((Fin.last n - i) : ℕ) * (n.choose i : ℕ) 
goal: (PMF.binomial p h n) i = p ^ ↑i * (1 - p) ^ (↑(Fin.last n) - ↑i) * ↑(n.choose ↑i)

full_name: PMF.binomial_apply_zero
code: @[simp]
theorem binomial_apply_zero (p : ℝ≥0∞) (h : p ≤ 1) (n : ℕ) :
    binomial p h n 0 = (1-p)^n 
goal: (PMF.binomial p h n) 0 = (1 - p) ^ n

full_name: PMF.binomial_apply_last
code: @[simp]
theorem binomial_apply_last (p : ℝ≥0∞) (h : p ≤ 1) (n : ℕ) :
    binomial p h n (.last n) = p^n 
goal: (PMF.binomial p h n) (Fin.last n) = p ^ n

full_name: PMF.binomial_apply_self
code: theorem binomial_apply_self (p : ℝ≥0∞) (h : p ≤ 1) (n : ℕ) :
    binomial p h n n = p^n 
goal: (PMF.binomial p h n) ↑n = p ^ n

full_name: PMF.binomial_one_eq_bernoulli
code: /-- The binomial distribution on one coin is the bernoully distribution. -/
theorem binomial_one_eq_bernoulli (p : ℝ≥0∞) (h : p ≤ 1) :
    binomial p h 1 = (bernoulli p h).map (cond · 1 0) 
goal: PMF.binomial p h 1 = PMF.map (fun x => bif x then 1 else 0) (PMF.bernoulli p h)
File: Mathlib/RingTheory/Polynomial/IrreducibleRing.lean

full_name: Polynomial.Monic.irreducible_of_irreducible_map_of_isPrime_nilradical
code: /-- A polynomial over an irreducible ring `R` is irreducible if it is monic and irreducible after
mapping into an integral domain `S` (https://math.stackexchange.com/a/4843432/235999).
A generalization to `Polynomial.Monic.irreducible_of_irreducible_map`. -/
theorem Polynomial.Monic.irreducible_of_irreducible_map_of_isPrime_nilradical
    {R S : Type*} [CommRing R] [(nilradical R).IsPrime] [CommRing S] [IsDomain S]
    (φ : R →+* S) (f : R[X]) (hm : f.Monic) (hi : Irreducible (f.map φ)) : Irreducible f 
goal: Irreducible f
File: Mathlib/RingTheory/Polynomial/Tower.lean

full_name: Polynomial.aeval_map_algebraMap
code: @[simp]
theorem aeval_map_algebraMap (x : B) (p : R[X]) : aeval x (map (algebraMap R A) p) = aeval x p 
goal: (Polynomial.aeval x) (Polynomial.map (algebraMap R A) p) = (Polynomial.aeval x) p

full_name: Polynomial.eval_map_algebraMap
code: @[simp]
lemma eval_map_algebraMap (P : R[X]) (a : A) :
    (map (algebraMap R A) P).eval a = aeval a P 
goal: Polynomial.eval a (Polynomial.map (algebraMap R A) P) = (Polynomial.aeval a) P

full_name: Polynomial.aeval_algebraMap_apply
code: theorem aeval_algebraMap_apply (x : A) (p : R[X]) :
    aeval (algebraMap A B x) p = algebraMap A B (aeval x p) 
goal: (Polynomial.aeval ((algebraMap A B) x)) p = (algebraMap A B) ((Polynomial.aeval x) p)

full_name: Polynomial.aeval_algebraMap_eq_zero_iff
code: @[simp]
theorem aeval_algebraMap_eq_zero_iff [NoZeroSMulDivisors A B] [Nontrivial B] (x : A) (p : R[X]) :
    aeval (algebraMap A B x) p = 0 ↔ aeval x p = 0 
goal: (Polynomial.aeval ((algebraMap A B) x)) p = 0 ↔ (Polynomial.aeval x) p = 0

full_name: Polynomial.aeval_algebraMap_eq_zero_iff_of_injective
code: theorem aeval_algebraMap_eq_zero_iff_of_injective {x : A} {p : R[X]}
    (h : Function.Injective (algebraMap A B)) : aeval (algebraMap A B x) p = 0 ↔ aeval x p = 0 
goal: (Polynomial.aeval ((algebraMap A B) x)) p = 0 ↔ (Polynomial.aeval x) p = 0

full_name: Subalgebra.aeval_coe
code: @[simp]
theorem aeval_coe (S : Subalgebra R A) (x : S) (p : R[X]) : aeval (x : A) p = aeval x p 
goal: (Polynomial.aeval ↑x) p = ↑((Polynomial.aeval x) p)
File: Mathlib/RingTheory/Polynomial/Selmer.lean

full_name: Polynomial.X_pow_sub_X_sub_one_irreducible_aux
code: theorem X_pow_sub_X_sub_one_irreducible_aux (z : ℂ) : ¬(z ^ n = z + 1 ∧ z ^ n + z ^ 2 = 0) 
goal: ¬(z ^ n = z + 1 ∧ z ^ n + z ^ 2 = 0)

full_name: Polynomial.X_pow_sub_X_sub_one_irreducible
code: theorem X_pow_sub_X_sub_one_irreducible (hn1 : n ≠ 1) : Irreducible (X ^ n - X - 1 : ℤ[X]) 
goal: Irreducible (Polynomial.X ^ n - Polynomial.X - 1)

full_name: Polynomial.X_pow_sub_X_sub_one_irreducible_rat
code: theorem X_pow_sub_X_sub_one_irreducible_rat (hn1 : n ≠ 1) : Irreducible (X ^ n - X - 1 : ℚ[X]) 
goal: Irreducible (Polynomial.X ^ n - Polynomial.X - 1)
File: Mathlib/RingTheory/Coprime/Ideal.lean

full_name: Ideal.iSup_iInf_eq_top_iff_pairwise
code: /-- A finite family of ideals is pairwise coprime (that is, any two of them generate the whole ring)
iff when taking all the possible intersections of all but one of these ideals, the resulting family
of ideals still generate the whole ring.

For example with three ideals : `I ⊔ J = I ⊔ K = J ⊔ K = ⊤ ↔ (I ⊓ J) ⊔ (I ⊓ K) ⊔ (J ⊓ K) = ⊤`.

When ideals are all of the form `I i = R ∙ s i`, this is equivalent to the
`exists_sum_eq_one_iff_pairwise_coprime` lemma. -/
theorem iSup_iInf_eq_top_iff_pairwise {t : Finset ι} (h : t.Nonempty) (I : ι → Ideal R) :
    (⨆ i ∈ t, ⨅ (j) (_ : j ∈ t) (_ : j ≠ i), I j) = ⊤ ↔
      (t : Set ι).Pairwise fun i j => I i ⊔ I j = ⊤ 
goal: ⨆ i ∈ t, ⨅ j ∈ t, ⨅ (_ : j ≠ i), I j = ⊤ ↔ (↑t).Pairwise fun i j => I i ⊔ I j = ⊤