-- Mathlib/Probability/Kernel/MeasurableLIntegral.lean
theorem _root_.Measurable.lintegral_kernel_prod_right {f : α → β → ℝ≥0∞}
    (hf : Measurable (uncurry f)) : Measurable fun a => ∫⁻ b, f a b ∂κ a

Proof state:
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
⊢ Measurable fun a => ∫⁻ (b : β), f a b ∂κ a

Tactic:
have h : ∀ a, ⨆ n, F n a = uncurry f a := SimpleFunc.iSup_eapprox_apply hf

Result:
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
h : ∀ (a : α × β), ⨆ n, (F n) a = uncurry f a
⊢ Measurable fun a => ∫⁻ (b : β), f a b ∂κ a

Proof state:
case refine_2
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
h : ∀ (a : α) (b : β), ⨆ n, (F n) (a, b) = f a b
this : ∀ (a : α), ∫⁻ (b : β), ⨆ n, (F n) (a, b) ∂κ a = ⨆ n, ∫⁻ (b : β), (F n) (a, b) ∂κ a
n : ℕ
g₁ g₂ : SimpleFunc (α × β) ℝ≥0∞
a✝ : Disjoint (support ⇑g₁) (support ⇑g₂)
hm₁ : Measurable fun a => ∫⁻ (b : β), g₁ (a, b) ∂κ a
hm₂ : Measurable fun a => ∫⁻ (b : β), g₂ (a, b) ∂κ a
h_add :
  (fun a => ∫⁻ (b : β), g₁ (a, b) + g₂ (a, b) ∂κ a) =
    (fun a => ∫⁻ (b : β), g₁ (a, b) ∂κ a) + fun a => ∫⁻ (b : β), g₂ (a, b) ∂κ a
⊢ Measurable ((fun a => ∫⁻ (b : β), g₁ (a, b) ∂κ a) + fun a => ∫⁻ (b : β), g₂ (a, b) ∂κ a)

Tactic:
exact Measurable.add hm₁ hm₂

Result:
no goals

Proof state:
case refine_1
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
h : ∀ (a : α) (b : β), ⨆ n, (F n) (a, b) = f a b
this : ∀ (a : α), ∫⁻ (b : β), ⨆ n, (F n) (a, b) ∂κ a = ⨆ n, ∫⁻ (b : β), (F n) (a, b) ∂κ a
n : ℕ
c : ℝ≥0∞
t : Set (α × β)
ht : MeasurableSet t
⊢ Measurable fun a => ∫⁻ (b : β), t.indicator (Function.const (α × β) c) (a, b) ∂κ a

Tactic:
exact Kernel.measurable_lintegral_indicator_const (κ := κ) ht c

Result:
no goals

Proof state:
case h
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
h : ∀ (a : α) (b : β), ⨆ n, (F n) (a, b) = f a b
this : ∀ (a : α), ∫⁻ (b : β), ⨆ n, (F n) (a, b) ∂κ a = ⨆ n, ∫⁻ (b : β), (F n) (a, b) ∂κ a
n : ℕ
g₁ g₂ : SimpleFunc (α × β) ℝ≥0∞
a✝ : Disjoint (support ⇑g₁) (support ⇑g₂)
hm₁ : Measurable fun a => ∫⁻ (b : β), g₁ (a, b) ∂κ a
hm₂ : Measurable fun a => ∫⁻ (b : β), g₂ (a, b) ∂κ a
a : α
⊢ ∫⁻ (b : β), g₁ (a, b) + g₂ (a, b) ∂κ a =
    ((fun a => ∫⁻ (b : β), g₁ (a, b) ∂κ a) + fun a => ∫⁻ (b : β), g₂ (a, b) ∂κ a) a

Tactic:
rw [Pi.add_apply]

Result:
case h
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
h : ∀ (a : α) (b : β), ⨆ n, (F n) (a, b) = f a b
this : ∀ (a : α), ∫⁻ (b : β), ⨆ n, (F n) (a, b) ∂κ a = ⨆ n, ∫⁻ (b : β), (F n) (a, b) ∂κ a
n : ℕ
g₁ g₂ : SimpleFunc (α × β) ℝ≥0∞
a✝ : Disjoint (support ⇑g₁) (support ⇑g₂)
hm₁ : Measurable fun a => ∫⁻ (b : β), g₁ (a, b) ∂κ a
hm₂ : Measurable fun a => ∫⁻ (b : β), g₂ (a, b) ∂κ a
a : α
⊢ ∫⁻ (b : β), g₁ (a, b) + g₂ (a, b) ∂κ a = ∫⁻ (b : β), g₁ (a, b) ∂κ a + ∫⁻ (b : β), g₂ (a, b) ∂κ a

Proof state:
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
h : ∀ (a : α) (b : β), ⨆ n, (F n) (a, b) = f a b
⊢ Measurable fun a => ∫⁻ (b : β), f a b ∂κ a

Tactic:
simp_rw [← h]

Result:
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
h : ∀ (a : α) (b : β), ⨆ n, (F n) (a, b) = f a b
⊢ Measurable fun a => ∫⁻ (b : β), ⨆ n, (F n) (a, b) ∂κ a

Proof state:
case refine_2
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
h : ∀ (a : α) (b : β), ⨆ n, (F n) (a, b) = f a b
this : ∀ (a : α), ∫⁻ (b : β), ⨆ n, (F n) (a, b) ∂κ a = ⨆ n, ∫⁻ (b : β), (F n) (a, b) ∂κ a
n : ℕ
⊢ ∀ ⦃f g : SimpleFunc (α × β) ℝ≥0∞⦄,
    Disjoint (support ⇑f) (support ⇑g) →
      (fun f => Measurable fun a => ∫⁻ (b : β), f (a, b) ∂κ a) f →
        (fun f => Measurable fun a => ∫⁻ (b : β), f (a, b) ∂κ a) g →
          (fun f => Measurable fun a => ∫⁻ (b : β), f (a, b) ∂κ a) (f + g)

Tactic:
intro g₁ g₂ _ hm₁ hm₂

Result:
case refine_2
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
h : ∀ (a : α) (b : β), ⨆ n, (F n) (a, b) = f a b
this : ∀ (a : α), ∫⁻ (b : β), ⨆ n, (F n) (a, b) ∂κ a = ⨆ n, ∫⁻ (b : β), (F n) (a, b) ∂κ a
n : ℕ
g₁ g₂ : SimpleFunc (α × β) ℝ≥0∞
a✝ : Disjoint (support ⇑g₁) (support ⇑g₂)
hm₁ : Measurable fun a => ∫⁻ (b : β), g₁ (a, b) ∂κ a
hm₂ : Measurable fun a => ∫⁻ (b : β), g₂ (a, b) ∂κ a
⊢ Measurable fun a => ∫⁻ (b : β), (g₁ + g₂) (a, b) ∂κ a

Proof state:
case refine_2
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
h : ∀ (a : α) (b : β), ⨆ n, (F n) (a, b) = f a b
this : ∀ (a : α), ∫⁻ (b : β), ⨆ n, (F n) (a, b) ∂κ a = ⨆ n, ∫⁻ (b : β), (F n) (a, b) ∂κ a
n : ℕ
g₁ g₂ : SimpleFunc (α × β) ℝ≥0∞
a✝ : Disjoint (support ⇑g₁) (support ⇑g₂)
hm₁ : Measurable fun a => ∫⁻ (b : β), g₁ (a, b) ∂κ a
hm₂ : Measurable fun a => ∫⁻ (b : β), g₂ (a, b) ∂κ a
h_add :
  (fun a => ∫⁻ (b : β), g₁ (a, b) + g₂ (a, b) ∂κ a) =
    (fun a => ∫⁻ (b : β), g₁ (a, b) ∂κ a) + fun a => ∫⁻ (b : β), g₂ (a, b) ∂κ a
⊢ Measurable fun a => ∫⁻ (b : β), g₁ (a, b) + g₂ (a, b) ∂κ a

Tactic:
rw [h_add]

Result:
case refine_2
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
h : ∀ (a : α) (b : β), ⨆ n, (F n) (a, b) = f a b
this : ∀ (a : α), ∫⁻ (b : β), ⨆ n, (F n) (a, b) ∂κ a = ⨆ n, ∫⁻ (b : β), (F n) (a, b) ∂κ a
n : ℕ
g₁ g₂ : SimpleFunc (α × β) ℝ≥0∞
a✝ : Disjoint (support ⇑g₁) (support ⇑g₂)
hm₁ : Measurable fun a => ∫⁻ (b : β), g₁ (a, b) ∂κ a
hm₂ : Measurable fun a => ∫⁻ (b : β), g₂ (a, b) ∂κ a
h_add :
  (fun a => ∫⁻ (b : β), g₁ (a, b) + g₂ (a, b) ∂κ a) =
    (fun a => ∫⁻ (b : β), g₁ (a, b) ∂κ a) + fun a => ∫⁻ (b : β), g₂ (a, b) ∂κ a
⊢ Measurable ((fun a => ∫⁻ (b : β), g₁ (a, b) ∂κ a) + fun a => ∫⁻ (b : β), g₂ (a, b) ∂κ a)