ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ProbabilityTheory.Kernel.integral_deterministic
@[simp]
theorem integral_deterministic {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [CompleteSpace E] {f : β → E} {g : α → β} {a : α} (hg : Measurable g)
    [MeasurableSingletonClass β] : ∫ x, f x ∂deterministic g hg a = f (g a) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] {f : β → E} {g : α → β} {a : α} (hg : Measurable g) [MeasurableSingletonClass β]
Goal: ∫ (x : β), f x ∂(ProbabilityTheory.Kernel.deterministic g hg) a = f (g a)
-- ProbabilityTheory.Kernel.setIntegral_deterministic'
theorem setIntegral_deterministic' {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [CompleteSpace E] {f : β → E} {g : α → β} {a : α} (hg : Measurable g)
    (hf : StronglyMeasurable f) {s : Set β} (hs : MeasurableSet s) [Decidable (g a ∈ s)] :
    ∫ x in s, f x ∂deterministic g hg a = if g a ∈ s then f (g a) else 0 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] {f : β → E} {g : α → β} {a : α} (hg : Measurable g) (hf : MeasureTheory.StronglyMeasurable f) {s : Set β} (hs : MeasurableSet s) [Decidable (g a ∈ s)]
Goal: ∫ (x : β) in s, f x ∂(ProbabilityTheory.Kernel.deterministic g hg) a = if g a ∈ s then f (g a) else 0
-- ProbabilityTheory.Kernel.setIntegral_deterministic
@[simp]
theorem setIntegral_deterministic {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [CompleteSpace E] {f : β → E} {g : α → β} {a : α} (hg : Measurable g)
    [MeasurableSingletonClass β] (s : Set β) [Decidable (g a ∈ s)] :
    ∫ x in s, f x ∂deterministic g hg a = if g a ∈ s then f (g a) else 0 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] {f : β → E} {g : α → β} {a : α} (hg : Measurable g) [MeasurableSingletonClass β] (s : Set β) [Decidable (g a ∈ s)]
Goal: ∫ (x : β) in s, f x ∂(ProbabilityTheory.Kernel.deterministic g hg) a = if g a ∈ s then f (g a) else 0
-- ProbabilityTheory.Kernel.const_apply
@[simp]
theorem const_apply (μβ : Measure β) (a : α) : const α μβ a = μβ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μβ : MeasureTheory.Measure β) (a : α)
Goal: (ProbabilityTheory.Kernel.const α μβ) a = μβ
-- ProbabilityTheory.Kernel.const_zero
@[simp]
lemma const_zero : const α (0 : Measure β) = 0 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
Goal: ProbabilityTheory.Kernel.const α 0 = 0
-- ProbabilityTheory.Kernel.const_add
lemma const_add (β : Type*) [MeasurableSpace β] (μ ν : Measure α) :
    const β (μ + ν) = const β μ + const β ν 
Arguments: {α : Type u_1} {mα : MeasurableSpace α} (β : Type u_4) [MeasurableSpace β] (μ ν : MeasureTheory.Measure α)
Goal: ProbabilityTheory.Kernel.const β (μ + ν) = ProbabilityTheory.Kernel.const β μ + ProbabilityTheory.Kernel.const β ν
-- ProbabilityTheory.Kernel.sum_const
lemma sum_const [Countable ι] (μ : ι → Measure β) :
    Kernel.sum (fun n ↦ const α (μ n)) = const α (Measure.sum μ) 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} [Countable ι] (μ : ι → MeasureTheory.Measure β)
Goal: (ProbabilityTheory.Kernel.sum fun n => ProbabilityTheory.Kernel.const α (μ n)) =
  ProbabilityTheory.Kernel.const α (MeasureTheory.Measure.sum μ)
-- ProbabilityTheory.Kernel.isSFiniteKernel_const
lemma isSFiniteKernel_const [Nonempty α] {μβ : Measure β} :
    IsSFiniteKernel (const α μβ) ↔ SFinite μβ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} [Nonempty α] {μβ : MeasureTheory.Measure β}
Goal: ProbabilityTheory.IsSFiniteKernel (ProbabilityTheory.Kernel.const α μβ) ↔ MeasureTheory.SFinite μβ
-- ProbabilityTheory.Kernel.lintegral_const
@[simp]
theorem lintegral_const {f : β → ℝ≥0∞} {μ : Measure β} {a : α} :
    ∫⁻ x, f x ∂const α μ a = ∫⁻ x, f x ∂μ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : β → ℝ≥0∞} {μ : MeasureTheory.Measure β} {a : α}
Goal: ∫⁻ (x : β), f x ∂(ProbabilityTheory.Kernel.const α μ) a = ∫⁻ (x : β), f x ∂μ
-- ProbabilityTheory.Kernel.setLIntegral_const
@[simp]
theorem setLIntegral_const {f : β → ℝ≥0∞} {μ : Measure β} {a : α} {s : Set β} :
    ∫⁻ x in s, f x ∂const α μ a = ∫⁻ x in s, f x ∂μ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : β → ℝ≥0∞} {μ : MeasureTheory.Measure β} {a : α} {s : Set β}
Goal: ∫⁻ (x : β) in s, f x ∂(ProbabilityTheory.Kernel.const α μ) a = ∫⁻ (x : β) in s, f x ∂μ
-- ProbabilityTheory.Kernel.integral_const
@[simp]
theorem integral_const {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {f : β → E} {μ : Measure β} {a : α} : ∫ x, f x ∂const α μ a = ∫ x, f x ∂μ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : β → E} {μ : MeasureTheory.Measure β} {a : α}
Goal: ∫ (x : β), f x ∂(ProbabilityTheory.Kernel.const α μ) a = ∫ (x : β), f x ∂μ
-- ProbabilityTheory.Kernel.setIntegral_const
@[simp]
theorem setIntegral_const {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {f : β → E} {μ : Measure β} {a : α} {s : Set β} :
    ∫ x in s, f x ∂const α μ a = ∫ x in s, f x ∂μ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : β → E} {μ : MeasureTheory.Measure β} {a : α} {s : Set β}
Goal: ∫ (x : β) in s, f x ∂(ProbabilityTheory.Kernel.const α μ) a = ∫ (x : β) in s, f x ∂μ
-- ProbabilityTheory.Kernel.restrict_apply
theorem restrict_apply (κ : Kernel α β) (hs : MeasurableSet s) (a : α) :
    κ.restrict hs a = (κ a).restrict s 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {s : Set β} (κ : ProbabilityTheory.Kernel α β) (hs : MeasurableSet s) (a : α)
Goal: (κ.restrict hs) a = (κ a).restrict s
-- ProbabilityTheory.Kernel.restrict_apply'
theorem restrict_apply' (κ : Kernel α β) (hs : MeasurableSet s) (a : α) (ht : MeasurableSet t) :
    κ.restrict hs a t = (κ a) (t ∩ s) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {s t : Set β} (κ : ProbabilityTheory.Kernel α β) (hs : MeasurableSet s) (a : α) (ht : MeasurableSet t)
Goal: ((κ.restrict hs) a) t = (κ a) (t ∩ s)
-- ProbabilityTheory.Kernel.restrict_univ
@[simp]
theorem restrict_univ : κ.restrict MeasurableSet.univ = κ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β}
Goal: κ.restrict ⋯ = κ
-- ProbabilityTheory.Kernel.lintegral_restrict
@[simp]
theorem lintegral_restrict (κ : Kernel α β) (hs : MeasurableSet s) (a : α) (f : β → ℝ≥0∞) :
    ∫⁻ b, f b ∂κ.restrict hs a = ∫⁻ b in s, f b ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {s : Set β} (κ : ProbabilityTheory.Kernel α β) (hs : MeasurableSet s) (a : α) (f : β → ℝ≥0∞)
Goal: ∫⁻ (b : β), f b ∂(κ.restrict hs) a = ∫⁻ (b : β) in s, f b ∂κ a
-- ProbabilityTheory.Kernel.setLIntegral_restrict
@[simp]
theorem setLIntegral_restrict (κ : Kernel α β) (hs : MeasurableSet s) (a : α) (f : β → ℝ≥0∞)
    (t : Set β) : ∫⁻ b in t, f b ∂κ.restrict hs a = ∫⁻ b in t ∩ s, f b ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {s : Set β} (κ : ProbabilityTheory.Kernel α β) (hs : MeasurableSet s) (a : α) (f : β → ℝ≥0∞) (t : Set β)
Goal: ∫⁻ (b : β) in t, f b ∂(κ.restrict hs) a = ∫⁻ (b : β) in t ∩ s, f b ∂κ a
-- ProbabilityTheory.Kernel.setIntegral_restrict
@[simp]
theorem setIntegral_restrict {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    {f : β → E} {a : α} (hs : MeasurableSet s) (t : Set β) :
    ∫ x in t, f x ∂κ.restrict hs a = ∫ x in t ∩ s, f x ∂κ a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β} {s : Set β} {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] {f : β → E} {a : α} (hs : MeasurableSet s) (t : Set β)
Goal: ∫ (x : β) in t, f x ∂(κ.restrict hs) a = ∫ (x : β) in t ∩ s, f x ∂κ a
-- ProbabilityTheory.Kernel.comapRight_apply
theorem comapRight_apply (κ : Kernel α β) (hf : MeasurableEmbedding f) (a : α) :
    comapRight κ hf a = Measure.comap f (κ a) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {f : γ → β} (κ : ProbabilityTheory.Kernel α β) (hf : MeasurableEmbedding f) (a : α)
Goal: (κ.comapRight hf) a = MeasureTheory.Measure.comap f (κ a)
-- ProbabilityTheory.Kernel.comapRight_apply'
theorem comapRight_apply' (κ : Kernel α β) (hf : MeasurableEmbedding f) (a : α) {t : Set γ}
    (ht : MeasurableSet t) : comapRight κ hf a t = κ a (f '' t) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {f : γ → β} (κ : ProbabilityTheory.Kernel α β) (hf : MeasurableEmbedding f) (a : α) {t : Set γ} (ht : MeasurableSet t)
Goal: ((κ.comapRight hf) a) t = (κ a) (f '' t)
-- ProbabilityTheory.Kernel.comapRight_id
@[simp]
lemma comapRight_id (κ : Kernel α β) : comapRight κ MeasurableEmbedding.id = κ 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β)
Goal: κ.comapRight ⋯ = κ
-- ProbabilityTheory.Kernel.IsMarkovKernel.comapRight
theorem IsMarkovKernel.comapRight (κ : Kernel α β) (hf : MeasurableEmbedding f)
    (hκ : ∀ a, κ a (Set.range f) = 1) : IsMarkovKernel (comapRight κ hf) 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {mγ : MeasurableSpace γ} {f : γ → β} (κ : ProbabilityTheory.Kernel α β) (hf : MeasurableEmbedding f) (hκ : ∀ (a : α), (κ a) (Set.range f) = 1)
Goal: ProbabilityTheory.IsMarkovKernel (κ.comapRight hf)
-- ProbabilityTheory.Kernel.piecewise_apply
theorem piecewise_apply (a : α) : piecewise hs κ η a = if a ∈ s then κ a else η a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ η : ProbabilityTheory.Kernel α β} {s : Set α} {hs : MeasurableSet s} [DecidablePred fun x => x ∈ s] (a : α)
Goal: (ProbabilityTheory.Kernel.piecewise hs κ η) a = if a ∈ s then κ a else η a
-- ProbabilityTheory.Kernel.piecewise_apply'
theorem piecewise_apply' (a : α) (t : Set β) :
    piecewise hs κ η a t = if a ∈ s then κ a t else η a t 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ η : ProbabilityTheory.Kernel α β} {s : Set α} {hs : MeasurableSet s} [DecidablePred fun x => x ∈ s] (a : α) (t : Set β)
Goal: ((ProbabilityTheory.Kernel.piecewise hs κ η) a) t = if a ∈ s then (κ a) t else (η a) t
-- ProbabilityTheory.Kernel.lintegral_piecewise
theorem lintegral_piecewise (a : α) (g : β → ℝ≥0∞) :
    ∫⁻ b, g b ∂piecewise hs κ η a = if a ∈ s then ∫⁻ b, g b ∂κ a else ∫⁻ b, g b ∂η a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ η : ProbabilityTheory.Kernel α β} {s : Set α} {hs : MeasurableSet s} [DecidablePred fun x => x ∈ s] (a : α) (g : β → ℝ≥0∞)
Goal: ∫⁻ (b : β), g b ∂(ProbabilityTheory.Kernel.piecewise hs κ η) a =
  if a ∈ s then ∫⁻ (b : β), g b ∂κ a else ∫⁻ (b : β), g b ∂η a
-- ProbabilityTheory.Kernel.setLIntegral_piecewise
theorem setLIntegral_piecewise (a : α) (g : β → ℝ≥0∞) (t : Set β) :
    ∫⁻ b in t, g b ∂piecewise hs κ η a =
      if a ∈ s then ∫⁻ b in t, g b ∂κ a else ∫⁻ b in t, g b ∂η a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ η : ProbabilityTheory.Kernel α β} {s : Set α} {hs : MeasurableSet s} [DecidablePred fun x => x ∈ s] (a : α) (g : β → ℝ≥0∞) (t : Set β)
Goal: ∫⁻ (b : β) in t, g b ∂(ProbabilityTheory.Kernel.piecewise hs κ η) a =
  if a ∈ s then ∫⁻ (b : β) in t, g b ∂κ a else ∫⁻ (b : β) in t, g b ∂η a
-- ProbabilityTheory.Kernel.integral_piecewise
theorem integral_piecewise {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (a : α) (g : β → E) :
    ∫ b, g b ∂piecewise hs κ η a = if a ∈ s then ∫ b, g b ∂κ a else ∫ b, g b ∂η a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ η : ProbabilityTheory.Kernel α β} {s : Set α} {hs : MeasurableSet s} [DecidablePred fun x => x ∈ s] {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] (a : α) (g : β → E)
Goal: ∫ (b : β), g b ∂(ProbabilityTheory.Kernel.piecewise hs κ η) a =
  if a ∈ s then ∫ (b : β), g b ∂κ a else ∫ (b : β), g b ∂η a
-- ProbabilityTheory.Kernel.setIntegral_piecewise
theorem setIntegral_piecewise {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (a : α) (g : β → E) (t : Set β) :
    ∫ b in t, g b ∂piecewise hs κ η a =
      if a ∈ s then ∫ b in t, g b ∂κ a else ∫ b in t, g b ∂η a 
Arguments: {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ η : ProbabilityTheory.Kernel α β} {s : Set α} {hs : MeasurableSet s} [DecidablePred fun x => x ∈ s] {E : Type u_4} [NormedAddCommGroup E] [NormedSpace ℝ E] (a : α) (g : β → E) (t : Set β)
Goal: ∫ (b : β) in t, g b ∂(ProbabilityTheory.Kernel.piecewise hs κ η) a =
  if a ∈ s then ∫ (b : β) in t, g b ∂κ a else ∫ (b : β) in t, g b ∂η a
-- ProbabilityTheory.gaussianPDFReal_def
lemma gaussianPDFReal_def (μ : ℝ) (v : ℝ≥0) :
    gaussianPDFReal μ v =
      fun x ↦ (Real.sqrt (2 * π * v))⁻¹ * rexp (- (x - μ)^2 / (2 * v)) 
Arguments: (μ : ℝ) (v : ℝ≥0)
Goal: ProbabilityTheory.gaussianPDFReal μ v = fun x => (√(2 * π * ↑v))⁻¹ * rexp (-(x - μ) ^ 2 / (2 * ↑v))
-- ProbabilityTheory.gaussianPDFReal_zero_var
@[simp]
lemma gaussianPDFReal_zero_var (m : ℝ) : gaussianPDFReal m 0 = 0 
Arguments: (m : ℝ)
Goal: ProbabilityTheory.gaussianPDFReal m 0 = 0
-- ProbabilityTheory.gaussianPDFReal_pos
lemma gaussianPDFReal_pos (μ : ℝ) (v : ℝ≥0) (x : ℝ) (hv : v ≠ 0) : 0 < gaussianPDFReal μ v x 
Arguments: (μ : ℝ) (v : ℝ≥0) (x : ℝ) (hv : v ≠ 0)
Goal: 0 < ProbabilityTheory.gaussianPDFReal μ v x
-- ProbabilityTheory.gaussianPDFReal_nonneg
lemma gaussianPDFReal_nonneg (μ : ℝ) (v : ℝ≥0) (x : ℝ) : 0 ≤ gaussianPDFReal μ v x 
Arguments: (μ : ℝ) (v : ℝ≥0) (x : ℝ)
Goal: 0 ≤ ProbabilityTheory.gaussianPDFReal μ v x
-- ProbabilityTheory.measurable_gaussianPDFReal
lemma measurable_gaussianPDFReal (μ : ℝ) (v : ℝ≥0) : Measurable (gaussianPDFReal μ v) 
Arguments: (μ : ℝ) (v : ℝ≥0)
Goal: Measurable (ProbabilityTheory.gaussianPDFReal μ v)
-- ProbabilityTheory.stronglyMeasurable_gaussianPDFReal
lemma stronglyMeasurable_gaussianPDFReal (μ : ℝ) (v : ℝ≥0) :
    StronglyMeasurable (gaussianPDFReal μ v) 
Arguments: (μ : ℝ) (v : ℝ≥0)
Goal: MeasureTheory.StronglyMeasurable (ProbabilityTheory.gaussianPDFReal μ v)
-- ProbabilityTheory.integrable_gaussianPDFReal
lemma integrable_gaussianPDFReal (μ : ℝ) (v : ℝ≥0) :
    Integrable (gaussianPDFReal μ v) 
Arguments: (μ : ℝ) (v : ℝ≥0)
Goal: MeasureTheory.Integrable (ProbabilityTheory.gaussianPDFReal μ v) MeasureTheory.volume
-- ProbabilityTheory.lintegral_gaussianPDFReal_eq_one
lemma lintegral_gaussianPDFReal_eq_one (μ : ℝ) {v : ℝ≥0} (h : v ≠ 0) :
    ∫⁻ x, ENNReal.ofReal (gaussianPDFReal μ v x) = 1 
Arguments: (μ : ℝ) {v : ℝ≥0} (h : v ≠ 0)
Goal: ∫⁻ (x : ℝ), ENNReal.ofReal (ProbabilityTheory.gaussianPDFReal μ v x) = 1
-- ProbabilityTheory.integral_gaussianPDFReal_eq_one
lemma integral_gaussianPDFReal_eq_one (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) :
    ∫ x, gaussianPDFReal μ v x = 1 
Arguments: (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0)
Goal: ∫ (x : ℝ), ProbabilityTheory.gaussianPDFReal μ v x = 1
-- ProbabilityTheory.gaussianPDFReal_sub
lemma gaussianPDFReal_sub {μ : ℝ} {v : ℝ≥0} (x y : ℝ) :
    gaussianPDFReal μ v (x - y) = gaussianPDFReal (μ + y) v x 
Arguments: {μ : ℝ} {v : ℝ≥0} (x y : ℝ)
Goal: ProbabilityTheory.gaussianPDFReal μ v (x - y) = ProbabilityTheory.gaussianPDFReal (μ + y) v x
-- ProbabilityTheory.gaussianPDFReal_add
lemma gaussianPDFReal_add {μ : ℝ} {v : ℝ≥0} (x y : ℝ) :
    gaussianPDFReal μ v (x + y) = gaussianPDFReal (μ - y) v x 
Arguments: {μ : ℝ} {v : ℝ≥0} (x y : ℝ)
Goal: ProbabilityTheory.gaussianPDFReal μ v (x + y) = ProbabilityTheory.gaussianPDFReal (μ - y) v x
-- ProbabilityTheory.gaussianPDFReal_inv_mul
lemma gaussianPDFReal_inv_mul {μ : ℝ} {v : ℝ≥0} {c : ℝ} (hc : c ≠ 0) (x : ℝ) :
    gaussianPDFReal μ v (c⁻¹ * x) = |c| * gaussianPDFReal (c * μ) (⟨c^2, sq_nonneg _⟩ * v) x 
Arguments: {μ : ℝ} {v : ℝ≥0} {c : ℝ} (hc : c ≠ 0) (x : ℝ)
Goal: ProbabilityTheory.gaussianPDFReal μ v (c⁻¹ * x) = |c| * ProbabilityTheory.gaussianPDFReal (c * μ) (⟨c ^ 2, ⋯⟩ * v) x
-- ProbabilityTheory.gaussianPDFReal_mul
lemma gaussianPDFReal_mul {μ : ℝ} {v : ℝ≥0} {c : ℝ} (hc : c ≠ 0) (x : ℝ) :
    gaussianPDFReal μ v (c * x)
      = |c⁻¹| * gaussianPDFReal (c⁻¹ * μ) (⟨(c^2)⁻¹, inv_nonneg.mpr (sq_nonneg _)⟩ * v) x 
Arguments: {μ : ℝ} {v : ℝ≥0} {c : ℝ} (hc : c ≠ 0) (x : ℝ)
Goal: ProbabilityTheory.gaussianPDFReal μ v (c * x) =
  |c⁻¹| * ProbabilityTheory.gaussianPDFReal (c⁻¹ * μ) (⟨(c ^ 2)⁻¹, ⋯⟩ * v) x
-- ProbabilityTheory.gaussianPDF_def
lemma gaussianPDF_def (μ : ℝ) (v : ℝ≥0) :
    gaussianPDF μ v = fun x ↦ ENNReal.ofReal (gaussianPDFReal μ v x) 
Arguments: (μ : ℝ) (v : ℝ≥0)
Goal: ProbabilityTheory.gaussianPDF μ v = fun x => ENNReal.ofReal (ProbabilityTheory.gaussianPDFReal μ v x)
-- ProbabilityTheory.gaussianPDF_zero_var
@[simp]
lemma gaussianPDF_zero_var (μ : ℝ) : gaussianPDF μ 0 = 0 
Arguments: (μ : ℝ)
Goal: ProbabilityTheory.gaussianPDF μ 0 = 0
-- ProbabilityTheory.gaussianPDF_pos
lemma gaussianPDF_pos (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) (x : ℝ) : 0 < gaussianPDF μ v x 
Arguments: (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) (x : ℝ)
Goal: 0 < ProbabilityTheory.gaussianPDF μ v x
-- ProbabilityTheory.measurable_gaussianPDF
@[measurability]
lemma measurable_gaussianPDF (μ : ℝ) (v : ℝ≥0) : Measurable (gaussianPDF μ v) 
Arguments: (μ : ℝ) (v : ℝ≥0)
Goal: Measurable (ProbabilityTheory.gaussianPDF μ v)
-- ProbabilityTheory.lintegral_gaussianPDF_eq_one
@[simp]
lemma lintegral_gaussianPDF_eq_one (μ : ℝ) {v : ℝ≥0} (h : v ≠ 0) :
    ∫⁻ x, gaussianPDF μ v x = 1 
Arguments: (μ : ℝ) {v : ℝ≥0} (h : v ≠ 0)
Goal: ∫⁻ (x : ℝ), ProbabilityTheory.gaussianPDF μ v x = 1
-- ProbabilityTheory.gaussianReal_of_var_ne_zero
lemma gaussianReal_of_var_ne_zero (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) :
    gaussianReal μ v = volume.withDensity (gaussianPDF μ v) 
Arguments: (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0)
Goal: ProbabilityTheory.gaussianReal μ v = MeasureTheory.volume.withDensity (ProbabilityTheory.gaussianPDF μ v)
-- ProbabilityTheory.gaussianReal_zero_var
@[simp]
lemma gaussianReal_zero_var (μ : ℝ) : gaussianReal μ 0 = Measure.dirac μ 
Arguments: (μ : ℝ)
Goal: ProbabilityTheory.gaussianReal μ 0 = MeasureTheory.Measure.dirac μ
-- ProbabilityTheory.gaussianReal_apply
lemma gaussianReal_apply (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) (s : Set ℝ) :
    gaussianReal μ v s = ∫⁻ x in s, gaussianPDF μ v x 
Arguments: (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) (s : Set ℝ)
Goal: (ProbabilityTheory.gaussianReal μ v) s = ∫⁻ (x : ℝ) in s, ProbabilityTheory.gaussianPDF μ v x
-- ProbabilityTheory.gaussianReal_apply_eq_integral
lemma gaussianReal_apply_eq_integral (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) (s : Set ℝ) :
    gaussianReal μ v s = ENNReal.ofReal (∫ x in s, gaussianPDFReal μ v x) 
Arguments: (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) (s : Set ℝ)
Goal: (ProbabilityTheory.gaussianReal μ v) s = ENNReal.ofReal (∫ (x : ℝ) in s, ProbabilityTheory.gaussianPDFReal μ v x)
-- ProbabilityTheory.gaussianReal_absolutelyContinuous
lemma gaussianReal_absolutelyContinuous (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) :
    gaussianReal μ v ≪ volume 
Arguments: (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0)
Goal: ProbabilityTheory.gaussianReal μ v ≪ MeasureTheory.volume
-- ProbabilityTheory.gaussianReal_absolutelyContinuous'
lemma gaussianReal_absolutelyContinuous' (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0) :
    volume ≪ gaussianReal μ v 
Arguments: (μ : ℝ) {v : ℝ≥0} (hv : v ≠ 0)
Goal: MeasureTheory.volume ≪ ProbabilityTheory.gaussianReal μ v
-- ProbabilityTheory.rnDeriv_gaussianReal
lemma rnDeriv_gaussianReal (μ : ℝ) (v : ℝ≥0) :
    ∂(gaussianReal μ v)/∂volume =ₐₛ gaussianPDF μ v 
Arguments: (μ : ℝ) (v : ℝ≥0)
Goal: (ProbabilityTheory.gaussianReal μ v).rnDeriv MeasureTheory.volume =ᵐ[MeasureTheory.volume]
  ProbabilityTheory.gaussianPDF μ v
-- MeasurableEmbedding.gaussianReal_comap_apply
lemma _root_.MeasurableEmbedding.gaussianReal_comap_apply (hv : v ≠ 0)
    {f : ℝ → ℝ} (hf : MeasurableEmbedding f)
    {f' : ℝ → ℝ} (h_deriv : ∀ x, HasDerivAt f (f' x) x) {s : Set ℝ} (hs : MeasurableSet s) :
    (gaussianReal μ v).comap f s
      = ENNReal.ofReal (∫ x in s, |f' x| * gaussianPDFReal μ v (f x)) 
Arguments: {μ : ℝ} {v : ℝ≥0} (hv : v ≠ 0) {f : ℝ → ℝ} (hf : MeasurableEmbedding f) {f' : ℝ → ℝ} (h_deriv : ∀ (x : ℝ), HasDerivAt f (f' x) x) {s : Set ℝ} (hs : MeasurableSet s)
Goal: (MeasureTheory.Measure.comap f (ProbabilityTheory.gaussianReal μ v)) s =
  ENNReal.ofReal (∫ (x : ℝ) in s, |f' x| * ProbabilityTheory.gaussianPDFReal μ v (f x))
-- MeasurableEquiv.gaussianReal_map_symm_apply
lemma _root_.MeasurableEquiv.gaussianReal_map_symm_apply (hv : v ≠ 0) (f : ℝ ≃ᵐ ℝ) {f' : ℝ → ℝ}
    (h_deriv : ∀ x, HasDerivAt f (f' x) x) {s : Set ℝ} (hs : MeasurableSet s) :
    (gaussianReal μ v).map f.symm s
      = ENNReal.ofReal (∫ x in s, |f' x| * gaussianPDFReal μ v (f x)) 
Arguments: {μ : ℝ} {v : ℝ≥0} (hv : v ≠ 0) (f : ℝ ≃ᵐ ℝ) {f' : ℝ → ℝ} (h_deriv : ∀ (x : ℝ), HasDerivAt (⇑f) (f' x) x) {s : Set ℝ} (hs : MeasurableSet s)
Goal: (MeasureTheory.Measure.map (⇑f.symm) (ProbabilityTheory.gaussianReal μ v)) s =
  ENNReal.ofReal (∫ (x : ℝ) in s, |f' x| * ProbabilityTheory.gaussianPDFReal μ v (f x))
-- ProbabilityTheory.gaussianReal_map_add_const
lemma gaussianReal_map_add_const (y : ℝ) :
    (gaussianReal μ v).map (· + y) = gaussianReal (μ + y) v 
Arguments: {μ : ℝ} {v : ℝ≥0} (y : ℝ)
Goal: MeasureTheory.Measure.map (fun x => x + y) (ProbabilityTheory.gaussianReal μ v) =
  ProbabilityTheory.gaussianReal (μ + y) v
-- ProbabilityTheory.gaussianReal_map_const_add
lemma gaussianReal_map_const_add (y : ℝ) :
    (gaussianReal μ v).map (y + ·) = gaussianReal (μ + y) v 
Arguments: {μ : ℝ} {v : ℝ≥0} (y : ℝ)
Goal: MeasureTheory.Measure.map (fun x => y + x) (ProbabilityTheory.gaussianReal μ v) =
  ProbabilityTheory.gaussianReal (μ + y) v
-- ProbabilityTheory.gaussianReal_map_const_mul
lemma gaussianReal_map_const_mul (c : ℝ) :
    (gaussianReal μ v).map (c * ·) = gaussianReal (c * μ) (⟨c^2, sq_nonneg _⟩ * v) 
Arguments: {μ : ℝ} {v : ℝ≥0} (c : ℝ)
Goal: MeasureTheory.Measure.map (fun x => c * x) (ProbabilityTheory.gaussianReal μ v) =
  ProbabilityTheory.gaussianReal (c * μ) (⟨c ^ 2, ⋯⟩ * v)
-- ProbabilityTheory.gaussianReal_map_mul_const
lemma gaussianReal_map_mul_const (c : ℝ) :
    (gaussianReal μ v).map (· * c) = gaussianReal (c * μ) (⟨c^2, sq_nonneg _⟩ * v) 
Arguments: {μ : ℝ} {v : ℝ≥0} (c : ℝ)
Goal: MeasureTheory.Measure.map (fun x => x * c) (ProbabilityTheory.gaussianReal μ v) =
  ProbabilityTheory.gaussianReal (c * μ) (⟨c ^ 2, ⋯⟩ * v)
-- ProbabilityTheory.gaussianReal_add_const
lemma gaussianReal_add_const {X : Ω → ℝ} (hX : Measure.map X ℙ = gaussianReal μ v) (y : ℝ) :
    Measure.map (fun ω ↦ X ω + y) ℙ = gaussianReal (μ + y) v 
Arguments: {μ : ℝ} {v : ℝ≥0} {Ω : Type} [MeasureTheory.MeasureSpace Ω] {X : Ω → ℝ} (hX : MeasureTheory.Measure.map X MeasureTheory.volume = ProbabilityTheory.gaussianReal μ v) (y : ℝ)
Goal: MeasureTheory.Measure.map (fun ω => X ω + y) MeasureTheory.volume = ProbabilityTheory.gaussianReal (μ + y) v
-- ProbabilityTheory.gaussianReal_const_add
lemma gaussianReal_const_add {X : Ω → ℝ} (hX : Measure.map X ℙ = gaussianReal μ v) (y : ℝ) :
    Measure.map (fun ω ↦ y + X ω) ℙ = gaussianReal (μ + y) v 
Arguments: {μ : ℝ} {v : ℝ≥0} {Ω : Type} [MeasureTheory.MeasureSpace Ω] {X : Ω → ℝ} (hX : MeasureTheory.Measure.map X MeasureTheory.volume = ProbabilityTheory.gaussianReal μ v) (y : ℝ)
Goal: MeasureTheory.Measure.map (fun ω => y + X ω) MeasureTheory.volume = ProbabilityTheory.gaussianReal (μ + y) v