ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ProbabilityTheory.setIntegral_condKernel_univ_left
lemma setIntegral_condKernel_univ_left (a : α) {t : Set Ω} (ht : MeasurableSet t)
    (hf : IntegrableOn f (Set.univ ×ˢ t) (κ a)) :
    ∫ b, ∫ ω in t, f (b, ω) ∂(Kernel.condKernel κ (a, b)) ∂(Kernel.fst κ a)
      = ∫ x in Set.univ ×ˢ t, f x ∂(κ a) 
Arguments: {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] [MeasurableSpace.CountableOrCountablyGenerated α β] {κ : ProbabilityTheory.Kernel α (β × Ω)} [ProbabilityTheory.IsFiniteKernel κ] {E : Type u_4} {f : β × Ω → E} [NormedAddCommGroup E] [NormedSpace ℝ E] (a : α) {t : Set Ω} (ht : MeasurableSet t) (hf : MeasureTheory.IntegrableOn f (Set.univ ×ˢ t) (κ a))
Goal: ∫ (b : β), ∫ (ω : Ω) in t, f (b, ω) ∂κ.condKernel (a, b) ∂κ.fst a = ∫ (x : β × Ω) in Set.univ ×ˢ t, f x ∂κ a
-- MeasureTheory.Measure.lintegral_condKernel_mem
lemma lintegral_condKernel_mem {s : Set (β × Ω)} (hs : MeasurableSet s) :
    ∫⁻ x, ρ.condKernel x {y | (x, y) ∈ s} ∂ρ.fst = ρ s 
Arguments: {β : Type u_2} {Ω : Type u_3} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {s : Set (β × Ω)} (hs : MeasurableSet s)
Goal: ∫⁻ (x : β), (ρ.condKernel x) {y | (x, y) ∈ s} ∂ρ.fst = ρ s
-- MeasureTheory.Measure.setLIntegral_condKernel_eq_measure_prod
lemma setLIntegral_condKernel_eq_measure_prod {s : Set β} (hs : MeasurableSet s) {t : Set Ω}
    (ht : MeasurableSet t) :
    ∫⁻ b in s, ρ.condKernel b t ∂ρ.fst = ρ (s ×ˢ t) 
Arguments: {β : Type u_2} {Ω : Type u_3} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {s : Set β} (hs : MeasurableSet s) {t : Set Ω} (ht : MeasurableSet t)
Goal: ∫⁻ (b : β) in s, (ρ.condKernel b) t ∂ρ.fst = ρ (s ×ˢ t)
-- MeasureTheory.Measure.lintegral_condKernel
lemma lintegral_condKernel (hf : Measurable f) :
    ∫⁻ b, ∫⁻ ω, f (b, ω) ∂(ρ.condKernel b) ∂ρ.fst = ∫⁻ x, f x ∂ρ 
Arguments: {β : Type u_2} {Ω : Type u_3} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {f : β × Ω → ℝ≥0∞} (hf : Measurable f)
Goal: ∫⁻ (b : β), ∫⁻ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫⁻ (x : β × Ω), f x ∂ρ
-- MeasureTheory.Measure.setLIntegral_condKernel
lemma setLIntegral_condKernel (hf : Measurable f) {s : Set β}
    (hs : MeasurableSet s) {t : Set Ω} (ht : MeasurableSet t) :
    ∫⁻ b in s, ∫⁻ ω in t, f (b, ω) ∂(ρ.condKernel b) ∂ρ.fst
      = ∫⁻ x in s ×ˢ t, f x ∂ρ 
Arguments: {β : Type u_2} {Ω : Type u_3} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {f : β × Ω → ℝ≥0∞} (hf : Measurable f) {s : Set β} (hs : MeasurableSet s) {t : Set Ω} (ht : MeasurableSet t)
Goal: ∫⁻ (b : β) in s, ∫⁻ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫⁻ (x : β × Ω) in s ×ˢ t, f x ∂ρ
-- MeasureTheory.Measure.setLIntegral_condKernel_univ_right
lemma setLIntegral_condKernel_univ_right (hf : Measurable f) {s : Set β}
    (hs : MeasurableSet s) :
    ∫⁻ b in s, ∫⁻ ω, f (b, ω) ∂(ρ.condKernel b) ∂ρ.fst
      = ∫⁻ x in s ×ˢ Set.univ, f x ∂ρ 
Arguments: {β : Type u_2} {Ω : Type u_3} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {f : β × Ω → ℝ≥0∞} (hf : Measurable f) {s : Set β} (hs : MeasurableSet s)
Goal: ∫⁻ (b : β) in s, ∫⁻ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫⁻ (x : β × Ω) in s ×ˢ Set.univ, f x ∂ρ
-- MeasureTheory.Measure.setLIntegral_condKernel_univ_left
lemma setLIntegral_condKernel_univ_left (hf : Measurable f) {t : Set Ω}
    (ht : MeasurableSet t) :
    ∫⁻ b, ∫⁻ ω in t, f (b, ω) ∂(ρ.condKernel b) ∂ρ.fst
      = ∫⁻ x in Set.univ ×ˢ t, f x ∂ρ 
Arguments: {β : Type u_2} {Ω : Type u_3} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {f : β × Ω → ℝ≥0∞} (hf : Measurable f) {t : Set Ω} (ht : MeasurableSet t)
Goal: ∫⁻ (b : β), ∫⁻ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫⁻ (x : β × Ω) in Set.univ ×ˢ t, f x ∂ρ
-- MeasureTheory.AEStronglyMeasurable.integral_condKernel
lemma _root_.MeasureTheory.AEStronglyMeasurable.integral_condKernel
    (hf : AEStronglyMeasurable f ρ) :
    AEStronglyMeasurable (fun x ↦ ∫ y, f (x, y) ∂ρ.condKernel x) ρ.fst 
Arguments: {β : Type u_2} {Ω : Type u_3} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {E : Type u_4} {f : β × Ω → E} [NormedAddCommGroup E] [NormedSpace ℝ E] (hf : MeasureTheory.AEStronglyMeasurable f ρ)
Goal: MeasureTheory.AEStronglyMeasurable (fun x => ∫ (y : Ω), f (x, y) ∂ρ.condKernel x) ρ.fst
-- MeasureTheory.Measure.integral_condKernel
lemma integral_condKernel (hf : Integrable f ρ) :
    ∫ b, ∫ ω, f (b, ω) ∂(ρ.condKernel b) ∂ρ.fst = ∫ x, f x ∂ρ 
Arguments: {β : Type u_2} {Ω : Type u_3} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {E : Type u_4} {f : β × Ω → E} [NormedAddCommGroup E] [NormedSpace ℝ E] (hf : MeasureTheory.Integrable f ρ)
Goal: ∫ (b : β), ∫ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫ (x : β × Ω), f x ∂ρ
-- MeasureTheory.Measure.setIntegral_condKernel
lemma setIntegral_condKernel {s : Set β} (hs : MeasurableSet s)
    {t : Set Ω} (ht : MeasurableSet t) (hf : IntegrableOn f (s ×ˢ t) ρ) :
    ∫ b in s, ∫ ω in t, f (b, ω) ∂(ρ.condKernel b) ∂ρ.fst = ∫ x in s ×ˢ t, f x ∂ρ 
Arguments: {β : Type u_2} {Ω : Type u_3} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {E : Type u_4} {f : β × Ω → E} [NormedAddCommGroup E] [NormedSpace ℝ E] {s : Set β} (hs : MeasurableSet s) {t : Set Ω} (ht : MeasurableSet t) (hf : MeasureTheory.IntegrableOn f (s ×ˢ t) ρ)
Goal: ∫ (b : β) in s, ∫ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫ (x : β × Ω) in s ×ˢ t, f x ∂ρ
-- MeasureTheory.Measure.setIntegral_condKernel_univ_right
lemma setIntegral_condKernel_univ_right {s : Set β} (hs : MeasurableSet s)
    (hf : IntegrableOn f (s ×ˢ Set.univ) ρ) :
    ∫ b in s, ∫ ω, f (b, ω) ∂(ρ.condKernel b) ∂ρ.fst = ∫ x in s ×ˢ Set.univ, f x ∂ρ 
Arguments: {β : Type u_2} {Ω : Type u_3} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {E : Type u_4} {f : β × Ω → E} [NormedAddCommGroup E] [NormedSpace ℝ E] {s : Set β} (hs : MeasurableSet s) (hf : MeasureTheory.IntegrableOn f (s ×ˢ Set.univ) ρ)
Goal: ∫ (b : β) in s, ∫ (ω : Ω), f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫ (x : β × Ω) in s ×ˢ Set.univ, f x ∂ρ
-- MeasureTheory.Measure.setIntegral_condKernel_univ_left
lemma setIntegral_condKernel_univ_left {t : Set Ω} (ht : MeasurableSet t)
    (hf : IntegrableOn f (Set.univ ×ˢ t) ρ) :
    ∫ b, ∫ ω in t, f (b, ω) ∂(ρ.condKernel b) ∂ρ.fst = ∫ x in Set.univ ×ˢ t, f x ∂ρ 
Arguments: {β : Type u_2} {Ω : Type u_3} {mβ : MeasurableSpace β} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] {ρ : MeasureTheory.Measure (β × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {E : Type u_4} {f : β × Ω → E} [NormedAddCommGroup E] [NormedSpace ℝ E] {t : Set Ω} (ht : MeasurableSet t) (hf : MeasureTheory.IntegrableOn f (Set.univ ×ˢ t) ρ)
Goal: ∫ (b : β), ∫ (ω : Ω) in t, f (b, ω) ∂ρ.condKernel b ∂ρ.fst = ∫ (x : β × Ω) in Set.univ ×ˢ t, f x ∂ρ
-- MeasureTheory.AEStronglyMeasurable.ae_integrable_condKernel_iff
theorem AEStronglyMeasurable.ae_integrable_condKernel_iff {f : α × Ω → F}
    (hf : AEStronglyMeasurable f ρ) :
    (∀ᵐ a ∂ρ.fst, Integrable (fun ω ↦ f (a, ω)) (ρ.condKernel a)) ∧
      Integrable (fun a ↦ ∫ ω, ‖f (a, ω)‖ ∂ρ.condKernel a) ρ.fst ↔ Integrable f ρ 
Arguments: {α : Type u_1} {Ω : Type u_2} {F : Type u_4} {mα : MeasurableSpace α} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] [NormedAddCommGroup F] {ρ : MeasureTheory.Measure (α × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {f : α × Ω → F} (hf : MeasureTheory.AEStronglyMeasurable f ρ)
Goal: (∀ᵐ (a : α) ∂ρ.fst, MeasureTheory.Integrable (fun ω => f (a, ω)) (ρ.condKernel a)) ∧
    MeasureTheory.Integrable (fun a => ∫ (ω : Ω), ‖f (a, ω)‖ ∂ρ.condKernel a) ρ.fst ↔
  MeasureTheory.Integrable f ρ
-- MeasureTheory.Integrable.condKernel_ae
theorem Integrable.condKernel_ae {f : α × Ω → F} (hf_int : Integrable f ρ) :
    ∀ᵐ a ∂ρ.fst, Integrable (fun ω ↦ f (a, ω)) (ρ.condKernel a) 
Arguments: {α : Type u_1} {Ω : Type u_2} {F : Type u_4} {mα : MeasurableSpace α} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] [NormedAddCommGroup F] {ρ : MeasureTheory.Measure (α × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {f : α × Ω → F} (hf_int : MeasureTheory.Integrable f ρ)
Goal: ∀ᵐ (a : α) ∂ρ.fst, MeasureTheory.Integrable (fun ω => f (a, ω)) (ρ.condKernel a)
-- MeasureTheory.Integrable.integral_norm_condKernel
theorem Integrable.integral_norm_condKernel {f : α × Ω → F} (hf_int : Integrable f ρ) :
    Integrable (fun x ↦ ∫ y, ‖f (x, y)‖ ∂ρ.condKernel x) ρ.fst 
Arguments: {α : Type u_1} {Ω : Type u_2} {F : Type u_4} {mα : MeasurableSpace α} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] [NormedAddCommGroup F] {ρ : MeasureTheory.Measure (α × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {f : α × Ω → F} (hf_int : MeasureTheory.Integrable f ρ)
Goal: MeasureTheory.Integrable (fun x => ∫ (y : Ω), ‖f (x, y)‖ ∂ρ.condKernel x) ρ.fst
-- MeasureTheory.Integrable.norm_integral_condKernel
theorem Integrable.norm_integral_condKernel {f : α × Ω → E} (hf_int : Integrable f ρ) :
    Integrable (fun x ↦ ‖∫ y, f (x, y) ∂ρ.condKernel x‖) ρ.fst 
Arguments: {α : Type u_1} {Ω : Type u_2} {E : Type u_3} {mα : MeasurableSpace α} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] [NormedAddCommGroup E] [NormedSpace ℝ E] {ρ : MeasureTheory.Measure (α × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {f : α × Ω → E} (hf_int : MeasureTheory.Integrable f ρ)
Goal: MeasureTheory.Integrable (fun x => ‖∫ (y : Ω), f (x, y) ∂ρ.condKernel x‖) ρ.fst
-- MeasureTheory.Integrable.integral_condKernel
theorem Integrable.integral_condKernel {f : α × Ω → E} (hf_int : Integrable f ρ) :
    Integrable (fun x ↦ ∫ y, f (x, y) ∂ρ.condKernel x) ρ.fst 
Arguments: {α : Type u_1} {Ω : Type u_2} {E : Type u_3} {mα : MeasurableSpace α} [MeasurableSpace Ω] [StandardBorelSpace Ω] [Nonempty Ω] [NormedAddCommGroup E] [NormedSpace ℝ E] {ρ : MeasureTheory.Measure (α × Ω)} [MeasureTheory.IsFiniteMeasure ρ] {f : α × Ω → E} (hf_int : MeasureTheory.Integrable f ρ)
Goal: MeasureTheory.Integrable (fun x => ∫ (y : Ω), f (x, y) ∂ρ.condKernel x) ρ.fst
-- ProbabilityTheory.cond_isProbabilityMeasure_of_finite
theorem cond_isProbabilityMeasure_of_finite (hcs : μ s ≠ 0) (hs : μ s ≠ ∞) :
    IsProbabilityMeasure μ[|s] 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s : Set Ω} (hcs : μ s ≠ 0) (hs : μ s ≠ ⊤)
Goal: MeasureTheory.IsProbabilityMeasure (ProbabilityTheory.cond μ s)
-- ProbabilityTheory.cond_isProbabilityMeasure
theorem cond_isProbabilityMeasure [IsFiniteMeasure μ] (hcs : μ s ≠ 0) :
    IsProbabilityMeasure μ[|s] 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s : Set Ω} [MeasureTheory.IsFiniteMeasure μ] (hcs : μ s ≠ 0)
Goal: MeasureTheory.IsProbabilityMeasure (ProbabilityTheory.cond μ s)
-- ProbabilityTheory.cond_toMeasurable_eq
theorem cond_toMeasurable_eq :
    μ[|(toMeasurable μ s)] = μ[|s] 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s : Set Ω}
Goal: ProbabilityTheory.cond μ (MeasureTheory.toMeasurable μ s) = ProbabilityTheory.cond μ s
-- ProbabilityTheory.cond_absolutelyContinuous
lemma cond_absolutelyContinuous : μ[|s] ≪ μ 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s : Set Ω}
Goal: ProbabilityTheory.cond μ s ≪ μ
-- ProbabilityTheory.absolutelyContinuous_cond_univ
lemma absolutelyContinuous_cond_univ [IsFiniteMeasure μ] : μ ≪ μ[|univ] 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [MeasureTheory.IsFiniteMeasure μ]
Goal: μ ≪ ProbabilityTheory.cond μ Set.univ
-- ProbabilityTheory.cond_empty
@[simp]
theorem cond_empty : μ[|∅] = 0 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω)
Goal: ProbabilityTheory.cond μ ∅ = 0
-- ProbabilityTheory.cond_univ
@[simp]
theorem cond_univ [IsProbabilityMeasure μ] : μ[|Set.univ] = μ 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) [MeasureTheory.IsProbabilityMeasure μ]
Goal: ProbabilityTheory.cond μ Set.univ = μ
-- ProbabilityTheory.cond_eq_zero
@[simp] lemma cond_eq_zero (hμs : μ s ≠ ⊤) : μ[|s] = 0 ↔ μ s = 0 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s : Set Ω} (hμs : μ s ≠ ⊤)
Goal: ProbabilityTheory.cond μ s = 0 ↔ μ s = 0
-- ProbabilityTheory.cond_eq_zero_of_meas_eq_zero
lemma cond_eq_zero_of_meas_eq_zero (hμs : μ s = 0) : μ[|s] = 0 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s : Set Ω} (hμs : μ s = 0)
Goal: ProbabilityTheory.cond μ s = 0
-- ProbabilityTheory.cond_apply
theorem cond_apply (hms : MeasurableSet s) (t : Set Ω) : μ[t|s] = (μ s)⁻¹ * μ (s ∩ t) 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s : Set Ω} (hms : MeasurableSet s) (t : Set Ω)
Goal: (ProbabilityTheory.cond μ s) t = (μ s)⁻¹ * μ (s ∩ t)
-- ProbabilityTheory.cond_apply'
theorem cond_apply' {t : Set Ω} (hA : MeasurableSet t) : μ[t|s] = (μ s)⁻¹ * μ (s ∩ t) 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s t : Set Ω} (hA : MeasurableSet t)
Goal: (ProbabilityTheory.cond μ s) t = (μ s)⁻¹ * μ (s ∩ t)
-- ProbabilityTheory.cond_inter_self
theorem cond_inter_self (hms : MeasurableSet s) (t : Set Ω) : μ[s ∩ t|s] = μ[t|s] 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s : Set Ω} (hms : MeasurableSet s) (t : Set Ω)
Goal: (ProbabilityTheory.cond μ s) (s ∩ t) = (ProbabilityTheory.cond μ s) t
-- ProbabilityTheory.inter_pos_of_cond_ne_zero
theorem inter_pos_of_cond_ne_zero (hms : MeasurableSet s) (hcst : μ[t|s] ≠ 0) : 0 < μ (s ∩ t) 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s t : Set Ω} (hms : MeasurableSet s) (hcst : (ProbabilityTheory.cond μ s) t ≠ 0)
Goal: 0 < μ (s ∩ t)
-- ProbabilityTheory.cond_pos_of_inter_ne_zero
theorem cond_pos_of_inter_ne_zero [IsFiniteMeasure μ]
    (hms : MeasurableSet s) (hci : μ (s ∩ t) ≠ 0) : 0 < μ[|s] t 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s t : Set Ω} [MeasureTheory.IsFiniteMeasure μ] (hms : MeasurableSet s) (hci : μ (s ∩ t) ≠ 0)
Goal: 0 < (ProbabilityTheory.cond μ s) t
-- ProbabilityTheory.cond_cond_eq_cond_inter'
lemma cond_cond_eq_cond_inter' (hms : MeasurableSet s) (hmt : MeasurableSet t) (hcs : μ s ≠ ∞) :
    μ[|s][|t] = μ[|s ∩ t] 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s t : Set Ω} (hms : MeasurableSet s) (hmt : MeasurableSet t) (hcs : μ s ≠ ⊤)
Goal: ProbabilityTheory.cond (ProbabilityTheory.cond μ s) t = ProbabilityTheory.cond μ (s ∩ t)
-- ProbabilityTheory.cond_cond_eq_cond_inter
theorem cond_cond_eq_cond_inter [IsFiniteMeasure μ] (hms : MeasurableSet s)
    (hmt : MeasurableSet t) : μ[|s][|t] = μ[|s ∩ t] 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s t : Set Ω} [MeasureTheory.IsFiniteMeasure μ] (hms : MeasurableSet s) (hmt : MeasurableSet t)
Goal: ProbabilityTheory.cond (ProbabilityTheory.cond μ s) t = ProbabilityTheory.cond μ (s ∩ t)
-- ProbabilityTheory.cond_mul_eq_inter'
theorem cond_mul_eq_inter' (hms : MeasurableSet s) (hcs' : μ s ≠ ∞) (t : Set Ω) :
    μ[t|s] * μ s = μ (s ∩ t) 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s : Set Ω} (hms : MeasurableSet s) (hcs' : μ s ≠ ⊤) (t : Set Ω)
Goal: (ProbabilityTheory.cond μ s) t * μ s = μ (s ∩ t)
-- ProbabilityTheory.cond_mul_eq_inter
theorem cond_mul_eq_inter [IsFiniteMeasure μ] (hms : MeasurableSet s) (t : Set Ω) :
    μ[t|s] * μ s = μ (s ∩ t) 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s : Set Ω} [MeasureTheory.IsFiniteMeasure μ] (hms : MeasurableSet s) (t : Set Ω)
Goal: (ProbabilityTheory.cond μ s) t * μ s = μ (s ∩ t)
-- ProbabilityTheory.cond_add_cond_compl_eq
theorem cond_add_cond_compl_eq [IsFiniteMeasure μ] (hms : MeasurableSet s) :
    μ[t|s] * μ s + μ[t|sᶜ] * μ sᶜ = μ t 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s t : Set Ω} [MeasureTheory.IsFiniteMeasure μ] (hms : MeasurableSet s)
Goal: (ProbabilityTheory.cond μ s) t * μ s + (ProbabilityTheory.cond μ sᶜ) t * μ sᶜ = μ t
-- ProbabilityTheory.cond_eq_inv_mul_cond_mul
theorem cond_eq_inv_mul_cond_mul [IsFiniteMeasure μ]
    (hms : MeasurableSet s) (hmt : MeasurableSet t) : μ[t|s] = (μ s)⁻¹ * μ[s|t] * μ t 
Arguments: {Ω : Type u_1} {m : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω) {s t : Set Ω} [MeasureTheory.IsFiniteMeasure μ] (hms : MeasurableSet s) (hmt : MeasurableSet t)
Goal: (ProbabilityTheory.cond μ s) t = (μ s)⁻¹ * (ProbabilityTheory.cond μ t) s * μ t
-- ProbabilityTheory.comap_cond
lemma comap_cond {i : Ω' → Ω} (hi : MeasurableEmbedding i) (hi' : ∀ᵐ ω ∂μ, ω ∈ range i)
    (hs : MeasurableSet s) : comap i μ[|s] = (comap i μ)[|i ⁻¹' s] 
Arguments: {Ω : Type u_1} {Ω' : Type u_2} {m : MeasurableSpace Ω} {m' : MeasurableSpace Ω'} (μ : MeasureTheory.Measure Ω) {s : Set Ω} {i : Ω' → Ω} (hi : MeasurableEmbedding i) (hi' : ∀ᵐ (ω : Ω) ∂μ, ω ∈ Set.range i) (hs : MeasurableSet s)
Goal: MeasureTheory.Measure.comap i (ProbabilityTheory.cond μ s) =
  ProbabilityTheory.cond (MeasureTheory.Measure.comap i μ) (i ⁻¹' s)
-- ProbabilityTheory.sum_meas_smul_cond_fiber
lemma sum_meas_smul_cond_fiber {X : Ω → α} (hX : Measurable X) (μ : Measure Ω) [IsFiniteMeasure μ] :
    ∑ x, μ (X ⁻¹' {x}) • μ[|X ← x] = μ 
Arguments: {Ω : Type u_1} {α : Type u_3} {m : MeasurableSpace Ω} [Fintype α] [MeasurableSpace α] [DiscreteMeasurableSpace α] {X : Ω → α} (hX : Measurable X) (μ : MeasureTheory.Measure Ω) [MeasureTheory.IsFiniteMeasure μ]
Goal: ∑ x : α, μ (X ⁻¹' {x}) • ProbabilityTheory.cond μ (X ⁻¹' {x}) = μ
-- Turing.ToPartrec.Code.zero'_eval
@[simp]
theorem zero'_eval : zero'.eval = fun v => pure (0 :: v) 
Goal: Turing.ToPartrec.Code.zero'.eval = fun v => pure (0 :: v)
-- Turing.ToPartrec.Code.succ_eval
@[simp]
theorem succ_eval : succ.eval = fun v => pure [v.headI.succ] 
Goal: Turing.ToPartrec.Code.succ.eval = fun v => pure [v.headI.succ]
-- Turing.ToPartrec.Code.tail_eval
@[simp]
theorem tail_eval : tail.eval = fun v => pure v.tail 
Goal: Turing.ToPartrec.Code.tail.eval = fun v => pure v.tail
-- Turing.ToPartrec.Code.cons_eval
@[simp]
theorem cons_eval (f fs) : (cons f fs).eval = fun v => do {
    let n ← Code.eval f v
    let ns ← Code.eval fs v
    pure (n.headI :: ns) } 
Arguments: (f fs : Turing.ToPartrec.Code)
Goal: (f.cons fs).eval = fun v => do
  let n ← f.eval v
  let ns ← fs.eval v
  pure (n.headI :: ns)
-- Turing.ToPartrec.Code.comp_eval
@[simp]
theorem comp_eval (f g) : (comp f g).eval = fun v => g.eval v >>= f.eval 
Arguments: (f g : Turing.ToPartrec.Code)
Goal: (f.comp g).eval = fun v => g.eval v >>= f.eval
-- Turing.ToPartrec.Code.case_eval
@[simp]
theorem case_eval (f g) :
    (case f g).eval = fun v => v.headI.rec (f.eval v.tail) fun y _ => g.eval (y::v.tail) 
Arguments: (f g : Turing.ToPartrec.Code)
Goal: (f.case g).eval = fun v => Nat.rec (f.eval v.tail) (fun y x => g.eval (y :: v.tail)) v.headI
-- Turing.ToPartrec.Code.fix_eval
@[simp]
theorem fix_eval (f) : (fix f).eval =
    PFun.fix fun v => (f.eval v).map fun v =>
      if v.headI = 0 then Sum.inl v.tail else Sum.inr v.tail 
Arguments: (f : Turing.ToPartrec.Code)
Goal: f.fix.eval = PFun.fix fun v => Part.map (fun v => if v.headI = 0 then Sum.inl v.tail else Sum.inr v.tail) (f.eval v)
-- Turing.ToPartrec.Code.nil_eval
@[simp]
theorem nil_eval (v) : nil.eval v = pure [] 
Arguments: (v : List ℕ)
Goal: Turing.ToPartrec.Code.nil.eval v = pure []
-- Turing.ToPartrec.Code.id_eval
@[simp]
theorem id_eval (v) : id.eval v = pure v 
Arguments: (v : List ℕ)
Goal: Turing.ToPartrec.Code.id.eval v = pure v
-- Turing.ToPartrec.Code.head_eval
@[simp]
theorem head_eval (v) : head.eval v = pure [v.headI] 
Arguments: (v : List ℕ)
Goal: Turing.ToPartrec.Code.head.eval v = pure [v.headI]
-- Turing.ToPartrec.Code.zero_eval
@[simp]
theorem zero_eval (v) : zero.eval v = pure [0] 
Arguments: (v : List ℕ)
Goal: Turing.ToPartrec.Code.zero.eval v = pure [0]
-- Turing.ToPartrec.Code.pred_eval
@[simp]
theorem pred_eval (v) : pred.eval v = pure [v.headI.pred] 
Arguments: (v : List ℕ)
Goal: Turing.ToPartrec.Code.pred.eval v = pure [v.headI.pred]
-- Turing.ToPartrec.Code.exists_code.comp
theorem exists_code.comp {m n} {f : Vector ℕ n →. ℕ} {g : Fin n → Vector ℕ m →. ℕ}
    (hf : ∃ c : Code, ∀ v : Vector ℕ n, c.eval v.1 = pure <$> f v)
    (hg : ∀ i, ∃ c : Code, ∀ v : Vector ℕ m, c.eval v.1 = pure <$> g i v) :
    ∃ c : Code, ∀ v : Vector ℕ m, c.eval v.1 = pure <$> ((Vector.mOfFn fun i => g i v) >>= f) 
Arguments: {m n : ℕ} {f : Mathlib.Vector ℕ n →. ℕ} {g : Fin n → Mathlib.Vector ℕ m →. ℕ} (hf : ∃ c, ∀ (v : Mathlib.Vector ℕ n), c.eval ↑v = pure <$> f v) (hg : ∀ (i : Fin n), ∃ c, ∀ (v : Mathlib.Vector ℕ m), c.eval ↑v = pure <$> g i v)
Goal: ∃ c, ∀ (v : Mathlib.Vector ℕ m), c.eval ↑v = pure <$> ((Mathlib.Vector.mOfFn fun i => g i v) >>= f)
-- Turing.ToPartrec.Code.exists_code
theorem exists_code {n} {f : Vector ℕ n →. ℕ} (hf : Nat.Partrec' f) :
    ∃ c : Code, ∀ v : Vector ℕ n, c.eval v.1 = pure <$> f v 
Arguments: {n : ℕ} {f : Mathlib.Vector ℕ n →. ℕ} (hf : Nat.Partrec' f)
Goal: ∃ c, ∀ (v : Mathlib.Vector ℕ n), c.eval ↑v = pure <$> f v
-- Turing.ToPartrec.Cont.then_eval
theorem Cont.then_eval {k k' : Cont} {v} : (k.then k').eval v = k.eval v >>= k'.eval 
Arguments: {k k' : Turing.ToPartrec.Cont} {v : List ℕ}
Goal: (k.then k').eval v = k.eval v >>= k'.eval
-- Turing.ToPartrec.stepNormal_then
theorem stepNormal_then (c) (k k' : Cont) (v) :
    stepNormal c (k.then k') v = (stepNormal c k v).then k' 
Arguments: (c : Turing.ToPartrec.Code) (k k' : Turing.ToPartrec.Cont) (v : List ℕ)
Goal: Turing.ToPartrec.stepNormal c (k.then k') v = (Turing.ToPartrec.stepNormal c k v).then k'
-- Turing.ToPartrec.stepRet_then
theorem stepRet_then {k k' : Cont} {v} : stepRet (k.then k') v = (stepRet k v).then k' 
Arguments: {k k' : Turing.ToPartrec.Cont} {v : List ℕ}
Goal: Turing.ToPartrec.stepRet (k.then k') v = (Turing.ToPartrec.stepRet k v).then k'
-- Turing.ToPartrec.Code.Ok.zero
theorem Code.Ok.zero {c} (h : Code.Ok c) {v} :
    Turing.eval step (stepNormal c Cont.halt v) = Cfg.halt <$> Code.eval c v 
Arguments: {c : Turing.ToPartrec.Code} (h : c.Ok) {v : List ℕ}
Goal: Turing.eval Turing.ToPartrec.step (Turing.ToPartrec.stepNormal c Turing.ToPartrec.Cont.halt v) =
  Turing.ToPartrec.Cfg.halt <$> c.eval v
-- Turing.ToPartrec.stepNormal.is_ret
theorem stepNormal.is_ret (c k v) : ∃ k' v', stepNormal c k v = Cfg.ret k' v' 
Arguments: (c : Turing.ToPartrec.Code) (k : Turing.ToPartrec.Cont) (v : List ℕ)
Goal: ∃ k' v', Turing.ToPartrec.stepNormal c k v = Turing.ToPartrec.Cfg.ret k' v'
-- Turing.ToPartrec.cont_eval_fix
theorem cont_eval_fix {f k v} (fok : Code.Ok f) :
    Turing.eval step (stepNormal f (Cont.fix f k) v) =
      f.fix.eval v >>= fun v => Turing.eval step (Cfg.ret k v) 
Arguments: {f : Turing.ToPartrec.Code} {k : Turing.ToPartrec.Cont} {v : List ℕ} (fok : f.Ok)
Goal: Turing.eval Turing.ToPartrec.step (Turing.ToPartrec.stepNormal f (Turing.ToPartrec.Cont.fix f k) v) = do
  let v ← f.fix.eval v
  Turing.eval Turing.ToPartrec.step (Turing.ToPartrec.Cfg.ret k v)
-- Turing.ToPartrec.code_is_ok
theorem code_is_ok (c) : Code.Ok c 
Arguments: (c : Turing.ToPartrec.Code)
Goal: c.Ok
-- Turing.ToPartrec.stepNormal_eval
theorem stepNormal_eval (c v) : eval step (stepNormal c Cont.halt v) = Cfg.halt <$> c.eval v 
Arguments: (c : Turing.ToPartrec.Code) (v : List ℕ)
Goal: Turing.eval Turing.ToPartrec.step (Turing.ToPartrec.stepNormal c Turing.ToPartrec.Cont.halt v) =
  Turing.ToPartrec.Cfg.halt <$> c.eval v