Theorem: Measurable.lintegral_kernel_prod_right
File: Mathlib/Probability/Kernel/MeasurableIntegral.lean

tactic: let F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
⊢ Measurable fun a => ∫⁻ (b : β), f a b ∂κ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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 (uncurry f) hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
inst✝ : IsSFiniteKernel η
f : α → β → ℝ≥0∞
hf : Measurable (uncurry f)
F : ℕ → SimpleFunc (α × β) ℝ≥0∞ := SimpleFunc.eapprox (uncurry f)
⊢ Measurable fun a => ∫⁻ (b : β), f a b ∂κ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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

tactic: simp only [Prod.forall, uncurry_apply_pair] at h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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

tactic: simp_rw [this]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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
⊢ Measurable fun a => ∫⁻ (b : β), ⨆ n, ↑(F n) (a, b) ∂κ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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
⊢ Measurable fun a => ⨆ n, ∫⁻ (b : β), ↑(F n) (a, b) ∂κ a

tactic: refine measurable_iSup fun n => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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
⊢ Measurable fun a => ⨆ n, ∫⁻ (b : β), ↑(F n) (a, b) ∂κ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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 : ℕ
⊢ Measurable fun a => ∫⁻ (b : β), ↑(F n) (a, b) ∂κ a

tactic: refine SimpleFunc.induction
  (P := fun f => Measurable (fun (a : α) => ∫⁻ (b : β), f (a, b) ∂κ a)) ?_ ?_ (F n)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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 : ℕ
⊢ Measurable fun a => ∫⁻ (b : β), ↑(F n) (a, b) ∂κ a
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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∞) {s : Set (α × β)} (hs : MeasurableSet s),
    (fun f => Measurable fun a => ∫⁻ (b : β), ↑f (a, b) ∂κ a)
      (SimpleFunc.piecewise s hs (SimpleFunc.const (α × β) c) (SimpleFunc.const (α × β) 0))

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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 a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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
⊢ ∀ (a : α), ∫⁻ (b : β), ⨆ n, ↑(F n) (a, b) ∂κ a = ⨆ n, ∫⁻ (b : β), ↑(F n) (a, b) ∂κ a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
inst✝¹ : IsSFiniteKernel κ
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
a : α
⊢ ∫⁻ (b : β), ⨆ n, ↑(F n) (a, b) ∂κ a = ⨆ n, ∫⁻ (b : β), ↑(F n) (a, b) ∂κ a

tactic: rw [lintegral_iSup]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
inst✝¹ : IsSFiniteKernel κ
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
a : α
⊢ ∫⁻ (b : β), ⨆ n, ↑(F n) (a, b) ∂κ a = ⨆ n, ∫⁻ (b : β), ↑(F n) (a, b) ∂κ a
state_after: case hf
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
inst✝¹ : IsSFiniteKernel κ
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
a : α
⊢ ∀ (n : ℕ), Measurable fun b => ↑(F n) (a, b)

case h_mono
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
inst✝¹ : IsSFiniteKernel κ
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
a : α
⊢ Monotone fun n b => ↑(F n) (a, b)

tactic: exact fun n => (F n).measurable.comp measurable_prod_mk_left
state_before: case hf
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
inst✝¹ : IsSFiniteKernel κ
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
a : α
⊢ ∀ (n : ℕ), Measurable fun b => ↑(F n) (a, b)
state_after: no goals

tactic: exact fun i j hij b => SimpleFunc.monotone_eapprox (uncurry f) hij _
state_before: case h_mono
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
inst✝¹ : IsSFiniteKernel κ
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
a : α
⊢ Monotone fun n b => ↑(F n) (a, b)
state_after: no goals

tactic: intro c t ht
state_before: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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∞) {s : Set (α × β)} (hs : MeasurableSet s),
    (fun f => Measurable fun a => ∫⁻ (b : β), ↑f (a, b) ∂κ a)
      (SimpleFunc.piecewise s hs (SimpleFunc.const (α × β) c) (SimpleFunc.const (α × β) 0))
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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 : β), ↑(SimpleFunc.piecewise t ht (SimpleFunc.const (α × β) c) (SimpleFunc.const (α × β) 0)) (a, b) ∂κ a

tactic: simp only [SimpleFunc.const_zero, SimpleFunc.coe_piecewise, SimpleFunc.coe_const,
  SimpleFunc.coe_zero, Set.piecewise_eq_indicator]
state_before: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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 : β), ↑(SimpleFunc.piecewise t ht (SimpleFunc.const (α × β) c) (SimpleFunc.const (α × β) 0)) (a, b) ∂κ a
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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
state_before: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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
state_after: no goals

tactic: intro g₁ g₂ _ hm₁ hm₂
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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)
state_after: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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

tactic: simp only [SimpleFunc.coe_add, Pi.add_apply]
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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
state_after: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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₁ (a, b) + ↑g₂ (a, b) ∂κ a

tactic: have 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 := by
  ext1 a
  rw [Pi.add_apply]
  erw [lintegral_add_left (g₁.measurable.comp measurable_prod_mk_left)]
  simp_rw [Function.comp_apply]
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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₁ (a, b) + ↑g₂ (a, b) ∂κ a
state_after: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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]
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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
state_after: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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₂
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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)
state_after: no goals

tactic: ext1 a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
inst✝¹ : IsSFiniteKernel κ
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
⊢ (fun a => ∫⁻ (b : β), ↑g₁ (a, b) + ↑g₂ (a, b) ∂κ a) =
    (fun a => ∫⁻ (b : β), ↑g₁ (a, b) ∂κ a) + fun a => ∫⁻ (b : β), ↑g₂ (a, b) ∂κ a
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝¹ : α
inst✝¹ : IsSFiniteKernel κ
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]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝¹ : α
inst✝¹ : IsSFiniteKernel κ
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
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝¹ : α
inst✝¹ : IsSFiniteKernel κ
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

tactic: erw [lintegral_add_left (g₁.measurable.comp measurable_prod_mk_left)]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝¹ : α
inst✝¹ : IsSFiniteKernel κ
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
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝¹ : α
inst✝¹ : IsSFiniteKernel κ
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 : α
⊢ ∫⁻ (a_1 : β), (↑g₁ ∘ Prod.mk a) a_1 ∂κ a + ∫⁻ (a_1 : β), ↑g₂ (a, a_1) ∂κ a =
    ∫⁻ (b : β), ↑g₁ (a, b) ∂κ a + ∫⁻ (b : β), ↑g₂ (a, b) ∂κ a

tactic: simp_rw [Function.comp_apply]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝¹ : α
inst✝¹ : IsSFiniteKernel κ
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 : α
⊢ ∫⁻ (a_1 : β), (↑g₁ ∘ Prod.mk a) a_1 ∂κ a + ∫⁻ (a_1 : β), ↑g₂ (a, a_1) ∂κ a =
    ∫⁻ (b : β), ↑g₁ (a, b) ∂κ a + ∫⁻ (b : β), ↑g₂ (a, b) ∂κ a
state_after: no goals