[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
a : α
⊢ compProdFun κ η a ∅ = 0
[PROOFSTEP]
simp only [compProdFun, Set.mem_empty_iff_false, Set.setOf_false, measure_empty, MeasureTheory.lintegral_const,
  zero_mul]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
⊢ compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i)
[PROOFSTEP]
have h_Union : (fun b => η (a, b) {c : γ | (b, c) ∈ ⋃ i, f i}) = fun b => η (a, b) (⋃ i, {c : γ | (b, c) ∈ f i}) :=
  by
  ext1 b
  congr with c
  simp only [Set.mem_iUnion, Set.iSup_eq_iUnion, Set.mem_setOf_eq]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
⊢ (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
[PROOFSTEP]
ext1 b
[GOAL]
case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
b : β
⊢ ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i} = ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
[PROOFSTEP]
congr with c
[GOAL]
case h.e_a.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
b : β
c : γ
⊢ c ∈ {c | (b, c) ∈ ⋃ (i : ℕ), f i} ↔ c ∈ ⋃ (i : ℕ), {c | (b, c) ∈ f i}
[PROOFSTEP]
simp only [Set.mem_iUnion, Set.iSup_eq_iUnion, Set.mem_setOf_eq]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
⊢ compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i)
[PROOFSTEP]
rw [compProdFun, h_Union]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
⊢ ∫⁻ (b : β), ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i}) ∂↑κ a = ∑' (i : ℕ), compProdFun κ η a (f i)
[PROOFSTEP]
have h_tsum : (fun b => η (a, b) (⋃ i, {c : γ | (b, c) ∈ f i})) = fun b => ∑' i, η (a, b) {c : γ | (b, c) ∈ f i} :=
  by
  ext1 b
  rw [measure_iUnion]
  · intro i j hij s hsi hsj c hcs
    have hbci : {(b, c)} ⊆ f i := by rw [Set.singleton_subset_iff]; exact hsi hcs
    have hbcj : {(b, c)} ⊆ f j := by rw [Set.singleton_subset_iff]; exact hsj hcs
    simpa only [Set.bot_eq_empty, Set.le_eq_subset, Set.singleton_subset_iff, Set.mem_empty_iff_false] using
      hf_disj hij hbci hbcj
  ·
    -- Porting note: behavior of `@` changed relative to lean 3, was
          -- exact fun i => (@measurable_prod_mk_left β γ _ _ b) _ (hf_meas i)exact fun i =>
      (@measurable_prod_mk_left β γ _ _ b) (hf_meas i)
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
⊢ (fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})) = fun b => ∑' (i : ℕ), ↑↑(↑η (a, b)) {c | (b, c) ∈ f i}
[PROOFSTEP]
ext1 b
[GOAL]
case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
b : β
⊢ ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i}) = ∑' (i : ℕ), ↑↑(↑η (a, b)) {c | (b, c) ∈ f i}
[PROOFSTEP]
rw [measure_iUnion]
[GOAL]
case h.hn
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
b : β
⊢ Pairwise (Disjoint on fun i => {c | (b, c) ∈ f i})
[PROOFSTEP]
intro i j hij s hsi hsj c hcs
[GOAL]
case h.hn
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
b : β
i j : ℕ
hij : i ≠ j
s : Set γ
hsi : s ≤ (fun i => {c | (b, c) ∈ f i}) i
hsj : s ≤ (fun i => {c | (b, c) ∈ f i}) j
c : γ
hcs : c ∈ s
⊢ c ∈ ⊥
[PROOFSTEP]
have hbci : {(b, c)} ⊆ f i := by rw [Set.singleton_subset_iff]; exact hsi hcs
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
b : β
i j : ℕ
hij : i ≠ j
s : Set γ
hsi : s ≤ (fun i => {c | (b, c) ∈ f i}) i
hsj : s ≤ (fun i => {c | (b, c) ∈ f i}) j
c : γ
hcs : c ∈ s
⊢ {(b, c)} ⊆ f i
[PROOFSTEP]
rw [Set.singleton_subset_iff]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
b : β
i j : ℕ
hij : i ≠ j
s : Set γ
hsi : s ≤ (fun i => {c | (b, c) ∈ f i}) i
hsj : s ≤ (fun i => {c | (b, c) ∈ f i}) j
c : γ
hcs : c ∈ s
⊢ (b, c) ∈ f i
[PROOFSTEP]
exact hsi hcs
[GOAL]
case h.hn
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
b : β
i j : ℕ
hij : i ≠ j
s : Set γ
hsi : s ≤ (fun i => {c | (b, c) ∈ f i}) i
hsj : s ≤ (fun i => {c | (b, c) ∈ f i}) j
c : γ
hcs : c ∈ s
hbci : {(b, c)} ⊆ f i
⊢ c ∈ ⊥
[PROOFSTEP]
have hbcj : {(b, c)} ⊆ f j := by rw [Set.singleton_subset_iff]; exact hsj hcs
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
b : β
i j : ℕ
hij : i ≠ j
s : Set γ
hsi : s ≤ (fun i => {c | (b, c) ∈ f i}) i
hsj : s ≤ (fun i => {c | (b, c) ∈ f i}) j
c : γ
hcs : c ∈ s
hbci : {(b, c)} ⊆ f i
⊢ {(b, c)} ⊆ f j
[PROOFSTEP]
rw [Set.singleton_subset_iff]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
b : β
i j : ℕ
hij : i ≠ j
s : Set γ
hsi : s ≤ (fun i => {c | (b, c) ∈ f i}) i
hsj : s ≤ (fun i => {c | (b, c) ∈ f i}) j
c : γ
hcs : c ∈ s
hbci : {(b, c)} ⊆ f i
⊢ (b, c) ∈ f j
[PROOFSTEP]
exact hsj hcs
[GOAL]
case h.hn
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
b : β
i j : ℕ
hij : i ≠ j
s : Set γ
hsi : s ≤ (fun i => {c | (b, c) ∈ f i}) i
hsj : s ≤ (fun i => {c | (b, c) ∈ f i}) j
c : γ
hcs : c ∈ s
hbci : {(b, c)} ⊆ f i
hbcj : {(b, c)} ⊆ f j
⊢ c ∈ ⊥
[PROOFSTEP]
simpa only [Set.bot_eq_empty, Set.le_eq_subset, Set.singleton_subset_iff, Set.mem_empty_iff_false] using
  hf_disj hij hbci hbcj
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
b : β
⊢ ∀ (i : ℕ), MeasurableSet {c | (b, c) ∈ f i}
[PROOFSTEP]
exact fun i => (@measurable_prod_mk_left β γ _ _ b) (hf_meas i)
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
h_tsum :
  (fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})) = fun b => ∑' (i : ℕ), ↑↑(↑η (a, b)) {c | (b, c) ∈ f i}
⊢ ∫⁻ (b : β), ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i}) ∂↑κ a = ∑' (i : ℕ), compProdFun κ η a (f i)
[PROOFSTEP]
rw [h_tsum, lintegral_tsum]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
h_tsum :
  (fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})) = fun b => ∑' (i : ℕ), ↑↑(↑η (a, b)) {c | (b, c) ∈ f i}
⊢ ∑' (i : ℕ), ∫⁻ (a_1 : β), ↑↑(↑η (a, a_1)) {c | (a_1, c) ∈ f i} ∂↑κ a = ∑' (i : ℕ), compProdFun κ η a (f i)
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
h_tsum :
  (fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})) = fun b => ∑' (i : ℕ), ↑↑(↑η (a, b)) {c | (b, c) ∈ f i}
⊢ ∀ (i : ℕ), AEMeasurable fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ f i}
[PROOFSTEP]
intro i
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
h_tsum :
  (fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})) = fun b => ∑' (i : ℕ), ↑↑(↑η (a, b)) {c | (b, c) ∈ f i}
i : ℕ
⊢ AEMeasurable fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ f i}
[PROOFSTEP]
have hm : MeasurableSet {p : (α × β) × γ | (p.1.2, p.2) ∈ f i} := measurable_fst.snd.prod_mk measurable_snd (hf_meas i)
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : ℕ → Set (β × γ)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf_disj : Pairwise (Disjoint on f)
h_Union :
  (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ ⋃ (i : ℕ), f i}) = fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})
h_tsum :
  (fun b => ↑↑(↑η (a, b)) (⋃ (i : ℕ), {c | (b, c) ∈ f i})) = fun b => ∑' (i : ℕ), ↑↑(↑η (a, b)) {c | (b, c) ∈ f i}
i : ℕ
hm : MeasurableSet {p | (p.fst.snd, p.snd) ∈ f i}
⊢ AEMeasurable fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ f i}
[PROOFSTEP]
exact ((measurable_kernel_prod_mk_left hm).comp measurable_prod_mk_left).aemeasurable
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ compProdFun κ η a s = ∑' (n : ℕ), compProdFun κ (seq η n) a s
[PROOFSTEP]
simp_rw [compProdFun, (measure_sum_seq η _).symm]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ ∫⁻ (b : β), ↑↑(Measure.sum fun n => ↑(seq η n) (a, b)) {c | (b, c) ∈ s} ∂↑κ a =
    ∑' (n : ℕ), ∫⁻ (b : β), ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s} ∂↑κ a
[PROOFSTEP]
have :
  ∫⁻ b, Measure.sum (fun n => seq η n (a, b)) {c : γ | (b, c) ∈ s} ∂κ a =
    ∫⁻ b, ∑' n, seq η n (a, b) {c : γ | (b, c) ∈ s} ∂κ a :=
  by
  congr
  ext1 b
  rw [Measure.sum_apply]
  exact measurable_prod_mk_left hs
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ ∫⁻ (b : β), ↑↑(Measure.sum fun n => ↑(seq η n) (a, b)) {c | (b, c) ∈ s} ∂↑κ a =
    ∫⁻ (b : β), ∑' (n : ℕ), ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s} ∂↑κ a
[PROOFSTEP]
congr
[GOAL]
case e_f
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ (fun b => ↑↑(Measure.sum fun n => ↑(seq η n) (a, b)) {c | (b, c) ∈ s}) = fun b =>
    ∑' (n : ℕ), ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s}
[PROOFSTEP]
ext1 b
[GOAL]
case e_f.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
b : β
⊢ ↑↑(Measure.sum fun n => ↑(seq η n) (a, b)) {c | (b, c) ∈ s} = ∑' (n : ℕ), ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s}
[PROOFSTEP]
rw [Measure.sum_apply]
[GOAL]
case e_f.h.hs
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
b : β
⊢ MeasurableSet {c | (b, c) ∈ s}
[PROOFSTEP]
exact measurable_prod_mk_left hs
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
this :
  ∫⁻ (b : β), ↑↑(Measure.sum fun n => ↑(seq η n) (a, b)) {c | (b, c) ∈ s} ∂↑κ a =
    ∫⁻ (b : β), ∑' (n : ℕ), ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s} ∂↑κ a
⊢ ∫⁻ (b : β), ↑↑(Measure.sum fun n => ↑(seq η n) (a, b)) {c | (b, c) ∈ s} ∂↑κ a =
    ∑' (n : ℕ), ∫⁻ (b : β), ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s} ∂↑κ a
[PROOFSTEP]
rw [this, lintegral_tsum]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
this :
  ∫⁻ (b : β), ↑↑(Measure.sum fun n => ↑(seq η n) (a, b)) {c | (b, c) ∈ s} ∂↑κ a =
    ∫⁻ (b : β), ∑' (n : ℕ), ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s} ∂↑κ a
⊢ ∀ (i : ℕ), AEMeasurable fun b => ↑↑(↑(seq η i) (a, b)) {c | (b, c) ∈ s}
[PROOFSTEP]
exact fun n =>
  ((measurable_kernel_prod_mk_left (κ := (seq η n)) ((measurable_fst.snd.prod_mk measurable_snd) hs)).comp
      measurable_prod_mk_left).aemeasurable
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel κ
a : α
s : Set (β × γ)
⊢ compProdFun κ η a s = ∑' (n : ℕ), compProdFun (seq κ n) η a s
[PROOFSTEP]
simp_rw [compProdFun, (measure_sum_seq κ _).symm, lintegral_sum_measure]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ compProdFun κ η a s = ∑' (n : ℕ) (m : ℕ), compProdFun (seq κ n) (seq η m) a s
[PROOFSTEP]
simp_rw [compProdFun_tsum_left κ η a s, compProdFun_tsum_right _ η a hs]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
⊢ Measurable fun a => compProdFun κ η a s
[PROOFSTEP]
simp only [compProdFun]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
⊢ Measurable fun a => ∫⁻ (b : β), ↑↑(↑η (a, b)) {c | (b, c) ∈ s} ∂↑κ a
[PROOFSTEP]
have h_meas : Measurable (Function.uncurry fun a b => η (a, b) {c : γ | (b, c) ∈ s}) :=
  by
  have : (Function.uncurry fun a b => η (a, b) {c : γ | (b, c) ∈ s}) = fun p => η p {c : γ | (p.2, c) ∈ s} :=
    by
    ext1 p
    have hp_eq_mk : p = (p.fst, p.snd) := Prod.mk.eta.symm
    rw [hp_eq_mk, Function.uncurry_apply_pair]
  rw [this]
  exact measurable_kernel_prod_mk_left (measurable_fst.snd.prod_mk measurable_snd hs)
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
⊢ Measurable (Function.uncurry fun a b => ↑↑(↑η (a, b)) {c | (b, c) ∈ s})
[PROOFSTEP]
have : (Function.uncurry fun a b => η (a, b) {c : γ | (b, c) ∈ s}) = fun p => η p {c : γ | (p.2, c) ∈ s} :=
  by
  ext1 p
  have hp_eq_mk : p = (p.fst, p.snd) := Prod.mk.eta.symm
  rw [hp_eq_mk, Function.uncurry_apply_pair]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
⊢ (Function.uncurry fun a b => ↑↑(↑η (a, b)) {c | (b, c) ∈ s}) = fun p => ↑↑(↑η p) {c | (p.snd, c) ∈ s}
[PROOFSTEP]
ext1 p
[GOAL]
case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
p : α × β
⊢ Function.uncurry (fun a b => ↑↑(↑η (a, b)) {c | (b, c) ∈ s}) p = ↑↑(↑η p) {c | (p.snd, c) ∈ s}
[PROOFSTEP]
have hp_eq_mk : p = (p.fst, p.snd) := Prod.mk.eta.symm
[GOAL]
case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
p : α × β
hp_eq_mk : p = (p.fst, p.snd)
⊢ Function.uncurry (fun a b => ↑↑(↑η (a, b)) {c | (b, c) ∈ s}) p = ↑↑(↑η p) {c | (p.snd, c) ∈ s}
[PROOFSTEP]
rw [hp_eq_mk, Function.uncurry_apply_pair]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
this : (Function.uncurry fun a b => ↑↑(↑η (a, b)) {c | (b, c) ∈ s}) = fun p => ↑↑(↑η p) {c | (p.snd, c) ∈ s}
⊢ Measurable (Function.uncurry fun a b => ↑↑(↑η (a, b)) {c | (b, c) ∈ s})
[PROOFSTEP]
rw [this]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
this : (Function.uncurry fun a b => ↑↑(↑η (a, b)) {c | (b, c) ∈ s}) = fun p => ↑↑(↑η p) {c | (p.snd, c) ∈ s}
⊢ Measurable fun p => ↑↑(↑η p) {c | (p.snd, c) ∈ s}
[PROOFSTEP]
exact measurable_kernel_prod_mk_left (measurable_fst.snd.prod_mk measurable_snd hs)
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
hs : MeasurableSet s
h_meas : Measurable (Function.uncurry fun a b => ↑↑(↑η (a, b)) {c | (b, c) ∈ s})
⊢ Measurable fun a => ∫⁻ (b : β), ↑↑(↑η (a, b)) {c | (b, c) ∈ s} ∂↑κ a
[PROOFSTEP]
exact h_meas.lintegral_kernel_prod_right
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hs : MeasurableSet s
⊢ Measurable fun a => compProdFun κ η a s
[PROOFSTEP]
simp_rw [compProdFun_tsum_right κ η _ hs]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hs : MeasurableSet s
⊢ Measurable fun a => ∑' (n : ℕ), compProdFun κ (seq η n) a s
[PROOFSTEP]
refine' Measurable.ennreal_tsum fun n => _
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hs : MeasurableSet s
n : ℕ
⊢ Measurable fun a => compProdFun κ (seq η n) a s
[PROOFSTEP]
simp only [compProdFun]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hs : MeasurableSet s
n : ℕ
⊢ Measurable fun a => ∫⁻ (b : β), ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s} ∂↑κ a
[PROOFSTEP]
have h_meas : Measurable (Function.uncurry fun a b => seq η n (a, b) {c : γ | (b, c) ∈ s}) :=
  by
  have :
    (Function.uncurry fun a b => seq η n (a, b) {c : γ | (b, c) ∈ s}) = fun p => seq η n p {c : γ | (p.2, c) ∈ s} :=
    by
    ext1 p
    have hp_eq_mk : p = (p.fst, p.snd) := Prod.mk.eta.symm
    rw [hp_eq_mk, Function.uncurry_apply_pair]
  rw [this]
  exact measurable_kernel_prod_mk_left (measurable_fst.snd.prod_mk measurable_snd hs)
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hs : MeasurableSet s
n : ℕ
⊢ Measurable (Function.uncurry fun a b => ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s})
[PROOFSTEP]
have : (Function.uncurry fun a b => seq η n (a, b) {c : γ | (b, c) ∈ s}) = fun p => seq η n p {c : γ | (p.2, c) ∈ s} :=
  by
  ext1 p
  have hp_eq_mk : p = (p.fst, p.snd) := Prod.mk.eta.symm
  rw [hp_eq_mk, Function.uncurry_apply_pair]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hs : MeasurableSet s
n : ℕ
⊢ (Function.uncurry fun a b => ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s}) = fun p => ↑↑(↑(seq η n) p) {c | (p.snd, c) ∈ s}
[PROOFSTEP]
ext1 p
[GOAL]
case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hs : MeasurableSet s
n : ℕ
p : α × β
⊢ Function.uncurry (fun a b => ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s}) p = ↑↑(↑(seq η n) p) {c | (p.snd, c) ∈ s}
[PROOFSTEP]
have hp_eq_mk : p = (p.fst, p.snd) := Prod.mk.eta.symm
[GOAL]
case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hs : MeasurableSet s
n : ℕ
p : α × β
hp_eq_mk : p = (p.fst, p.snd)
⊢ Function.uncurry (fun a b => ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s}) p = ↑↑(↑(seq η n) p) {c | (p.snd, c) ∈ s}
[PROOFSTEP]
rw [hp_eq_mk, Function.uncurry_apply_pair]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hs : MeasurableSet s
n : ℕ
this :
  (Function.uncurry fun a b => ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s}) = fun p => ↑↑(↑(seq η n) p) {c | (p.snd, c) ∈ s}
⊢ Measurable (Function.uncurry fun a b => ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s})
[PROOFSTEP]
rw [this]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hs : MeasurableSet s
n : ℕ
this :
  (Function.uncurry fun a b => ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s}) = fun p => ↑↑(↑(seq η n) p) {c | (p.snd, c) ∈ s}
⊢ Measurable fun p => ↑↑(↑(seq η n) p) {c | (p.snd, c) ∈ s}
[PROOFSTEP]
exact measurable_kernel_prod_mk_left (measurable_fst.snd.prod_mk measurable_snd hs)
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hs : MeasurableSet s
n : ℕ
h_meas : Measurable (Function.uncurry fun a b => ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s})
⊢ Measurable fun a => ∫⁻ (b : β), ↑↑(↑(seq η n) (a, b)) {c | (b, c) ∈ s} ∂↑κ a
[PROOFSTEP]
exact h_meas.lintegral_kernel_prod_right
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel κ ∧ IsSFiniteKernel η
⊢ (fun a =>
      Measure.ofMeasurable (fun s x => compProdFun κ η a s) (_ : compProdFun κ η a ∅ = 0)
        (_ :
          ∀ (f : ℕ → Set (β × γ)),
            (∀ (i : ℕ), MeasurableSet (f i)) →
              Pairwise (Disjoint on f) → compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i))) ∈
    kernel α (β × γ)
[PROOFSTEP]
have : IsSFiniteKernel κ := h.1
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel κ ∧ IsSFiniteKernel η
this : IsSFiniteKernel κ
⊢ (fun a =>
      Measure.ofMeasurable (fun s x => compProdFun κ η a s) (_ : compProdFun κ η a ∅ = 0)
        (_ :
          ∀ (f : ℕ → Set (β × γ)),
            (∀ (i : ℕ), MeasurableSet (f i)) →
              Pairwise (Disjoint on f) → compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i))) ∈
    kernel α (β × γ)
[PROOFSTEP]
have : IsSFiniteKernel η := h.2
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel κ ∧ IsSFiniteKernel η
this✝ : IsSFiniteKernel κ
this : IsSFiniteKernel η
⊢ (fun a =>
      Measure.ofMeasurable (fun s x => compProdFun κ η a s) (_ : compProdFun κ η a ∅ = 0)
        (_ :
          ∀ (f : ℕ → Set (β × γ)),
            (∀ (i : ℕ), MeasurableSet (f i)) →
              Pairwise (Disjoint on f) → compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i))) ∈
    kernel α (β × γ)
[PROOFSTEP]
refine' Measure.measurable_of_measurable_coe _ fun s hs => _
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel κ ∧ IsSFiniteKernel η
this✝ : IsSFiniteKernel κ
this : IsSFiniteKernel η
s : Set (β × γ)
hs : MeasurableSet s
⊢ Measurable fun b =>
    ↑↑(Measure.ofMeasurable (fun s x => compProdFun κ η b s) (_ : compProdFun κ η b ∅ = 0)
            (_ :
              ∀ (f : ℕ → Set (β × γ)),
                (∀ (i : ℕ), MeasurableSet (f i)) →
                  Pairwise (Disjoint on f) → compProdFun κ η b (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η b (f i)))
      s
[PROOFSTEP]
have :
  (fun a =>
      Measure.ofMeasurable (fun s _ => compProdFun κ η a s) (compProdFun_empty κ η a) (compProdFun_iUnion κ η a) s) =
    fun a => compProdFun κ η a s :=
  by ext1 a; rwa [Measure.ofMeasurable_apply]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel κ ∧ IsSFiniteKernel η
this✝ : IsSFiniteKernel κ
this : IsSFiniteKernel η
s : Set (β × γ)
hs : MeasurableSet s
⊢ (fun a =>
      ↑↑(Measure.ofMeasurable (fun s x => compProdFun κ η a s) (_ : compProdFun κ η a ∅ = 0)
              (_ :
                ∀ (f : ℕ → Set (β × γ)),
                  (∀ (i : ℕ), MeasurableSet (f i)) →
                    Pairwise (Disjoint on f) →
                      compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i)))
        s) =
    fun a => compProdFun κ η a s
[PROOFSTEP]
ext1 a
[GOAL]
case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel κ ∧ IsSFiniteKernel η
this✝ : IsSFiniteKernel κ
this : IsSFiniteKernel η
s : Set (β × γ)
hs : MeasurableSet s
a : α
⊢ ↑↑(Measure.ofMeasurable (fun s x => compProdFun κ η a s) (_ : compProdFun κ η a ∅ = 0)
            (_ :
              ∀ (f : ℕ → Set (β × γ)),
                (∀ (i : ℕ), MeasurableSet (f i)) →
                  Pairwise (Disjoint on f) → compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i)))
      s =
    compProdFun κ η a s
[PROOFSTEP]
rwa [Measure.ofMeasurable_apply]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel κ ∧ IsSFiniteKernel η
this✝¹ : IsSFiniteKernel κ
this✝ : IsSFiniteKernel η
s : Set (β × γ)
hs : MeasurableSet s
this :
  (fun a =>
      ↑↑(Measure.ofMeasurable (fun s x => compProdFun κ η a s) (_ : compProdFun κ η a ∅ = 0)
              (_ :
                ∀ (f : ℕ → Set (β × γ)),
                  (∀ (i : ℕ), MeasurableSet (f i)) →
                    Pairwise (Disjoint on f) →
                      compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i)))
        s) =
    fun a => compProdFun κ η a s
⊢ Measurable fun b =>
    ↑↑(Measure.ofMeasurable (fun s x => compProdFun κ η b s) (_ : compProdFun κ η b ∅ = 0)
            (_ :
              ∀ (f : ℕ → Set (β × γ)),
                (∀ (i : ℕ), MeasurableSet (f i)) →
                  Pairwise (Disjoint on f) → compProdFun κ η b (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η b (f i)))
      s
[PROOFSTEP]
rw [this]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel κ ∧ IsSFiniteKernel η
this✝¹ : IsSFiniteKernel κ
this✝ : IsSFiniteKernel η
s : Set (β × γ)
hs : MeasurableSet s
this :
  (fun a =>
      ↑↑(Measure.ofMeasurable (fun s x => compProdFun κ η a s) (_ : compProdFun κ η a ∅ = 0)
              (_ :
                ∀ (f : ℕ → Set (β × γ)),
                  (∀ (i : ℕ), MeasurableSet (f i)) →
                    Pairwise (Disjoint on f) →
                      compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i)))
        s) =
    fun a => compProdFun κ η a s
⊢ Measurable fun a => compProdFun κ η a s
[PROOFSTEP]
exact measurable_compProdFun κ η hs
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ ↑↑(↑(κ ⊗ₖ η) a) s = compProdFun κ η a s
[PROOFSTEP]
rw [compProd, dif_pos]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ ↑↑(↑{
                val := fun a =>
                  Measure.ofMeasurable (fun s x => compProdFun κ η a s) (_ : compProdFun κ η a ∅ = 0)
                    (_ :
                      ∀ (f : ℕ → Set (β × γ)),
                        (∀ (i : ℕ), MeasurableSet (f i)) →
                          Pairwise (Disjoint on f) →
                            compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i)),
                property :=
                  (_ :
                    Measurable fun a =>
                      Measure.ofMeasurable (fun s x => compProdFun κ η a s) (_ : compProdFun κ η a ∅ = 0)
                        (_ :
                          ∀ (f : ℕ → Set (β × γ)),
                            (∀ (i : ℕ), MeasurableSet (f i)) →
                              Pairwise (Disjoint on f) →
                                compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i))) }
            a)
      s =
    compProdFun κ η a s
case hc
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ IsSFiniteKernel κ ∧ IsSFiniteKernel η
[PROOFSTEP]
swap
[GOAL]
case hc
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ IsSFiniteKernel κ ∧ IsSFiniteKernel η
[PROOFSTEP]
constructor
[GOAL]
case hc.left
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ IsSFiniteKernel κ
[PROOFSTEP]
infer_instance
[GOAL]
case hc.right
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ IsSFiniteKernel η
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ ↑↑(↑{
                val := fun a =>
                  Measure.ofMeasurable (fun s x => compProdFun κ η a s) (_ : compProdFun κ η a ∅ = 0)
                    (_ :
                      ∀ (f : ℕ → Set (β × γ)),
                        (∀ (i : ℕ), MeasurableSet (f i)) →
                          Pairwise (Disjoint on f) →
                            compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i)),
                property :=
                  (_ :
                    Measurable fun a =>
                      Measure.ofMeasurable (fun s x => compProdFun κ η a s) (_ : compProdFun κ η a ∅ = 0)
                        (_ :
                          ∀ (f : ℕ → Set (β × γ)),
                            (∀ (i : ℕ), MeasurableSet (f i)) →
                              Pairwise (Disjoint on f) →
                                compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i))) }
            a)
      s =
    compProdFun κ η a s
[PROOFSTEP]
change
  Measure.ofMeasurable (fun s _ => compProdFun κ η a s) (compProdFun_empty κ η a) (compProdFun_iUnion κ η a) s =
    ∫⁻ b, η (a, b) {c | (b, c) ∈ s} ∂κ a
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ ↑↑(Measure.ofMeasurable (fun s x => compProdFun κ η a s) (_ : compProdFun κ η a ∅ = 0)
            (_ :
              ∀ (f : ℕ → Set (β × γ)),
                (∀ (i : ℕ), MeasurableSet (f i)) →
                  Pairwise (Disjoint on f) → compProdFun κ η a (⋃ (i : ℕ), f i) = ∑' (i : ℕ), compProdFun κ η a (f i)))
      s =
    ∫⁻ (b : β), ↑↑(↑η (a, b)) {c | (b, c) ∈ s} ∂↑κ a
[PROOFSTEP]
rw [Measure.ofMeasurable_apply _ hs]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ compProdFun κ η a s = ∫⁻ (b : β), ↑↑(↑η (a, b)) {c | (b, c) ∈ s} ∂↑κ a
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : ¬IsSFiniteKernel κ
⊢ κ ⊗ₖ η = 0
[PROOFSTEP]
rw [compProd, dif_neg]
[GOAL]
case hnc
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : ¬IsSFiniteKernel κ
⊢ ¬(IsSFiniteKernel κ ∧ IsSFiniteKernel η)
[PROOFSTEP]
simp [h]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : ¬IsSFiniteKernel η
⊢ κ ⊗ₖ η = 0
[PROOFSTEP]
rw [compProd, dif_neg]
[GOAL]
case hnc
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : ¬IsSFiniteKernel η
⊢ ¬(IsSFiniteKernel κ ∧ IsSFiniteKernel η)
[PROOFSTEP]
simp [h]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
h2s : ↑↑(↑(κ ⊗ₖ η) a) s ≠ ⊤
⊢ ∀ᵐ (b : β) ∂↑κ a, ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) < ⊤
[PROOFSTEP]
let t := toMeasurable ((κ ⊗ₖ η) a) s
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
h2s : ↑↑(↑(κ ⊗ₖ η) a) s ≠ ⊤
t : Set (β × γ) := toMeasurable (↑(κ ⊗ₖ η) a) s
⊢ ∀ᵐ (b : β) ∂↑κ a, ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) < ⊤
[PROOFSTEP]
have : ∀ b : β, η (a, b) (Prod.mk b ⁻¹' s) ≤ η (a, b) (Prod.mk b ⁻¹' t) := fun b =>
  measure_mono (Set.preimage_mono (subset_toMeasurable _ _))
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
h2s : ↑↑(↑(κ ⊗ₖ η) a) s ≠ ⊤
t : Set (β × γ) := toMeasurable (↑(κ ⊗ₖ η) a) s
this : ∀ (b : β), ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) ≤ ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t)
⊢ ∀ᵐ (b : β) ∂↑κ a, ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) < ⊤
[PROOFSTEP]
have ht : MeasurableSet t := measurableSet_toMeasurable _ _
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
h2s : ↑↑(↑(κ ⊗ₖ η) a) s ≠ ⊤
t : Set (β × γ) := toMeasurable (↑(κ ⊗ₖ η) a) s
this : ∀ (b : β), ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) ≤ ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t)
ht : MeasurableSet t
⊢ ∀ᵐ (b : β) ∂↑κ a, ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) < ⊤
[PROOFSTEP]
have h2t : (κ ⊗ₖ η) a t ≠ ∞ := by rwa [measure_toMeasurable]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
h2s : ↑↑(↑(κ ⊗ₖ η) a) s ≠ ⊤
t : Set (β × γ) := toMeasurable (↑(κ ⊗ₖ η) a) s
this : ∀ (b : β), ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) ≤ ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t)
ht : MeasurableSet t
⊢ ↑↑(↑(κ ⊗ₖ η) a) t ≠ ⊤
[PROOFSTEP]
rwa [measure_toMeasurable]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
h2s : ↑↑(↑(κ ⊗ₖ η) a) s ≠ ⊤
t : Set (β × γ) := toMeasurable (↑(κ ⊗ₖ η) a) s
this : ∀ (b : β), ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) ≤ ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t)
ht : MeasurableSet t
h2t : ↑↑(↑(κ ⊗ₖ η) a) t ≠ ⊤
⊢ ∀ᵐ (b : β) ∂↑κ a, ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) < ⊤
[PROOFSTEP]
have ht_lt_top : ∀ᵐ b ∂κ a, η (a, b) (Prod.mk b ⁻¹' t) < ∞ :=
  by
  rw [kernel.compProd_apply _ _ _ ht] at h2t 
  exact ae_lt_top (kernel.measurable_kernel_prod_mk_left' ht a) h2t
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
h2s : ↑↑(↑(κ ⊗ₖ η) a) s ≠ ⊤
t : Set (β × γ) := toMeasurable (↑(κ ⊗ₖ η) a) s
this : ∀ (b : β), ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) ≤ ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t)
ht : MeasurableSet t
h2t : ↑↑(↑(κ ⊗ₖ η) a) t ≠ ⊤
⊢ ∀ᵐ (b : β) ∂↑κ a, ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t) < ⊤
[PROOFSTEP]
rw [kernel.compProd_apply _ _ _ ht] at h2t 
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
h2s : ↑↑(↑(κ ⊗ₖ η) a) s ≠ ⊤
t : Set (β × γ) := toMeasurable (↑(κ ⊗ₖ η) a) s
this : ∀ (b : β), ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) ≤ ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t)
ht : MeasurableSet t
h2t : ∫⁻ (b : β), ↑↑(↑η (a, b)) {c | (b, c) ∈ t} ∂↑κ a ≠ ⊤
⊢ ∀ᵐ (b : β) ∂↑κ a, ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t) < ⊤
[PROOFSTEP]
exact ae_lt_top (kernel.measurable_kernel_prod_mk_left' ht a) h2t
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
h2s : ↑↑(↑(κ ⊗ₖ η) a) s ≠ ⊤
t : Set (β × γ) := toMeasurable (↑(κ ⊗ₖ η) a) s
this : ∀ (b : β), ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) ≤ ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t)
ht : MeasurableSet t
h2t : ↑↑(↑(κ ⊗ₖ η) a) t ≠ ⊤
ht_lt_top : ∀ᵐ (b : β) ∂↑κ a, ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t) < ⊤
⊢ ∀ᵐ (b : β) ∂↑κ a, ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) < ⊤
[PROOFSTEP]
filter_upwards [ht_lt_top] with b hb
[GOAL]
case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
h2s : ↑↑(↑(κ ⊗ₖ η) a) s ≠ ⊤
t : Set (β × γ) := toMeasurable (↑(κ ⊗ₖ η) a) s
this : ∀ (b : β), ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) ≤ ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t)
ht : MeasurableSet t
h2t : ↑↑(↑(κ ⊗ₖ η) a) t ≠ ⊤
ht_lt_top : ∀ᵐ (b : β) ∂↑κ a, ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t) < ⊤
b : β
hb : ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' toMeasurable (↑(κ ⊗ₖ η) a) s) < ⊤
⊢ ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s) < ⊤
[PROOFSTEP]
exact (this b).trans_lt hb
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
hs : MeasurableSet s
⊢ ↑↑(↑(κ ⊗ₖ η) a) s = 0 ↔ (fun b => ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s)) =ᵐ[↑κ a] 0
[PROOFSTEP]
rw [kernel.compProd_apply _ _ _ hs, lintegral_eq_zero_iff]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
hs : MeasurableSet s
⊢ (fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ s}) =ᵐ[↑κ a] 0 ↔ (fun b => ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s)) =ᵐ[↑κ a] 0
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ a : α
hs : MeasurableSet s
⊢ Measurable fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ s}
[PROOFSTEP]
exact kernel.measurable_kernel_prod_mk_left' hs a
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
h : ↑↑(↑(κ ⊗ₖ η) a) s = 0
⊢ (fun b => ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s)) =ᵐ[↑κ a] 0
[PROOFSTEP]
obtain ⟨t, hst, mt, ht⟩ := exists_measurable_superset_of_null h
[GOAL]
case intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
h : ↑↑(↑(κ ⊗ₖ η) a) s = 0
t : Set (β × γ)
hst : s ⊆ t
mt : MeasurableSet t
ht : ↑↑(↑(κ ⊗ₖ η) a) t = 0
⊢ (fun b => ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s)) =ᵐ[↑κ a] 0
[PROOFSTEP]
simp_rw [compProd_null a mt] at ht 
[GOAL]
case intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
h : ↑↑(↑(κ ⊗ₖ η) a) s = 0
t : Set (β × γ)
hst : s ⊆ t
mt : MeasurableSet t
ht : (fun b => ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t)) =ᵐ[↑κ a] 0
⊢ (fun b => ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s)) =ᵐ[↑κ a] 0
[PROOFSTEP]
rw [Filter.eventuallyLE_antisymm_iff]
[GOAL]
case intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
h : ↑↑(↑(κ ⊗ₖ η) a) s = 0
t : Set (β × γ)
hst : s ⊆ t
mt : MeasurableSet t
ht : (fun b => ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' t)) =ᵐ[↑κ a] 0
⊢ (fun b => ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s)) ≤ᵐ[↑κ a] 0 ∧ 0 ≤ᵐ[↑κ a] fun b => ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s)
[PROOFSTEP]
exact
  ⟨Filter.EventuallyLE.trans_eq (Filter.eventually_of_forall fun x => (measure_mono (Set.preimage_mono hst) : _)) ht,
    Filter.eventually_of_forall fun x => zero_le _⟩
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
⊢ kernel.restrict κ hs ⊗ₖ kernel.restrict η ht = kernel.restrict (κ ⊗ₖ η) (_ : MeasurableSet (s ×ˢ t))
[PROOFSTEP]
ext a u hu
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
a : α
u : Set (β × γ)
hu : MeasurableSet u
⊢ ↑↑(↑(kernel.restrict κ hs ⊗ₖ kernel.restrict η ht) a) u =
    ↑↑(↑(kernel.restrict (κ ⊗ₖ η) (_ : MeasurableSet (s ×ˢ t))) a) u
[PROOFSTEP]
rw [compProd_apply _ _ _ hu, restrict_apply' _ _ _ hu, compProd_apply _ _ _ (hu.inter (hs.prod ht))]
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
a : α
u : Set (β × γ)
hu : MeasurableSet u
⊢ ∫⁻ (b : β), ↑↑(↑(kernel.restrict η ht) (a, b)) {c | (b, c) ∈ u} ∂↑(kernel.restrict κ hs) a =
    ∫⁻ (b : β), ↑↑(↑η (a, b)) {c | (b, c) ∈ u ∩ s ×ˢ t} ∂↑κ a
[PROOFSTEP]
simp only [kernel.restrict_apply, Measure.restrict_apply' ht, Set.mem_inter_iff, Set.prod_mk_mem_set_prod_eq]
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
a : α
u : Set (β × γ)
hu : MeasurableSet u
⊢ ∫⁻ (b : β) in s, ↑↑(↑η (a, b)) ({c | (b, c) ∈ u} ∩ t) ∂↑κ a =
    ∫⁻ (b : β), ↑↑(↑η (a, b)) {c | (b, c) ∈ u ∧ b ∈ s ∧ c ∈ t} ∂↑κ a
[PROOFSTEP]
have :
  ∀ b, η (a, b) {c : γ | (b, c) ∈ u ∧ b ∈ s ∧ c ∈ t} = s.indicator (fun b => η (a, b) ({c : γ | (b, c) ∈ u} ∩ t)) b :=
  by
  intro b
  classical
  rw [Set.indicator_apply]
  split_ifs with h
  · simp only [h, true_and_iff]
    rfl
  · simp only [h, false_and_iff, and_false_iff, Set.setOf_false, measure_empty]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
a : α
u : Set (β × γ)
hu : MeasurableSet u
⊢ ∀ (b : β),
    ↑↑(↑η (a, b)) {c | (b, c) ∈ u ∧ b ∈ s ∧ c ∈ t} = Set.indicator s (fun b => ↑↑(↑η (a, b)) ({c | (b, c) ∈ u} ∩ t)) b
[PROOFSTEP]
intro b
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
a : α
u : Set (β × γ)
hu : MeasurableSet u
b : β
⊢ ↑↑(↑η (a, b)) {c | (b, c) ∈ u ∧ b ∈ s ∧ c ∈ t} = Set.indicator s (fun b => ↑↑(↑η (a, b)) ({c | (b, c) ∈ u} ∩ t)) b
[PROOFSTEP]
classical
rw [Set.indicator_apply]
split_ifs with h
· simp only [h, true_and_iff]
  rfl
· simp only [h, false_and_iff, and_false_iff, Set.setOf_false, measure_empty]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
a : α
u : Set (β × γ)
hu : MeasurableSet u
b : β
⊢ ↑↑(↑η (a, b)) {c | (b, c) ∈ u ∧ b ∈ s ∧ c ∈ t} = Set.indicator s (fun b => ↑↑(↑η (a, b)) ({c | (b, c) ∈ u} ∩ t)) b
[PROOFSTEP]
rw [Set.indicator_apply]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
a : α
u : Set (β × γ)
hu : MeasurableSet u
b : β
⊢ ↑↑(↑η (a, b)) {c | (b, c) ∈ u ∧ b ∈ s ∧ c ∈ t} = if b ∈ s then ↑↑(↑η (a, b)) ({c | (b, c) ∈ u} ∩ t) else 0
[PROOFSTEP]
split_ifs with h
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
a : α
u : Set (β × γ)
hu : MeasurableSet u
b : β
h : b ∈ s
⊢ ↑↑(↑η (a, b)) {c | (b, c) ∈ u ∧ b ∈ s ∧ c ∈ t} = ↑↑(↑η (a, b)) ({c | (b, c) ∈ u} ∩ t)
[PROOFSTEP]
simp only [h, true_and_iff]
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
a : α
u : Set (β × γ)
hu : MeasurableSet u
b : β
h : b ∈ s
⊢ ↑↑(↑η (a, b)) {c | (b, c) ∈ u ∧ c ∈ t} = ↑↑(↑η (a, b)) ({c | (b, c) ∈ u} ∩ t)
[PROOFSTEP]
rfl
[GOAL]
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
a : α
u : Set (β × γ)
hu : MeasurableSet u
b : β
h : ¬b ∈ s
⊢ ↑↑(↑η (a, b)) {c | (b, c) ∈ u ∧ b ∈ s ∧ c ∈ t} = 0
[PROOFSTEP]
simp only [h, false_and_iff, and_false_iff, Set.setOf_false, measure_empty]
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
a : α
u : Set (β × γ)
hu : MeasurableSet u
this :
  ∀ (b : β),
    ↑↑(↑η (a, b)) {c | (b, c) ∈ u ∧ b ∈ s ∧ c ∈ t} = Set.indicator s (fun b => ↑↑(↑η (a, b)) ({c | (b, c) ∈ u} ∩ t)) b
⊢ ∫⁻ (b : β) in s, ↑↑(↑η (a, b)) ({c | (b, c) ∈ u} ∩ t) ∂↑κ a =
    ∫⁻ (b : β), ↑↑(↑η (a, b)) {c | (b, c) ∈ u ∧ b ∈ s ∧ c ∈ t} ∂↑κ a
[PROOFSTEP]
simp_rw [this]
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
a : α
u : Set (β × γ)
hu : MeasurableSet u
this :
  ∀ (b : β),
    ↑↑(↑η (a, b)) {c | (b, c) ∈ u ∧ b ∈ s ∧ c ∈ t} = Set.indicator s (fun b => ↑↑(↑η (a, b)) ({c | (b, c) ∈ u} ∩ t)) b
⊢ ∫⁻ (b : β) in s, ↑↑(↑η (a, b)) ({c | (b, c) ∈ u} ∩ t) ∂↑κ a =
    ∫⁻ (b : β), Set.indicator s (fun b => ↑↑(↑η (a, b)) ({c | (b, c) ∈ u} ∩ t)) b ∂↑κ a
[PROOFSTEP]
rw [lintegral_indicator _ hs]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
s : Set β
hs : MeasurableSet s
⊢ kernel.restrict κ hs ⊗ₖ η = kernel.restrict (κ ⊗ₖ η) (_ : MeasurableSet (s ×ˢ Set.univ))
[PROOFSTEP]
rw [← compProd_restrict]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
s : Set β
hs : MeasurableSet s
⊢ kernel.restrict κ hs ⊗ₖ η = kernel.restrict κ ?hs ⊗ₖ kernel.restrict η ?ht
case hs
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet s
case ht
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet Set.univ
[PROOFSTEP]
congr
[GOAL]
case e_η
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
s : Set β
hs : MeasurableSet s
⊢ η = kernel.restrict η ?ht
case ht
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
s : Set β
hs : MeasurableSet s
⊢ MeasurableSet Set.univ
[PROOFSTEP]
exact kernel.restrict_univ.symm
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
t : Set γ
ht : MeasurableSet t
⊢ κ ⊗ₖ kernel.restrict η ht = kernel.restrict (κ ⊗ₖ η) (_ : MeasurableSet (Set.univ ×ˢ t))
[PROOFSTEP]
rw [← compProd_restrict]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
t : Set γ
ht : MeasurableSet t
⊢ κ ⊗ₖ kernel.restrict η ht = kernel.restrict κ ?hs ⊗ₖ kernel.restrict η ?ht
case hs
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
t : Set γ
ht : MeasurableSet t
⊢ MeasurableSet Set.univ
case ht
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
t : Set γ
ht : MeasurableSet t
⊢ MeasurableSet t
[PROOFSTEP]
congr
[GOAL]
case e_κ
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
t : Set γ
ht : MeasurableSet t
⊢ κ = kernel.restrict κ ?hs
case hs
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
t : Set γ
ht : MeasurableSet t
⊢ MeasurableSet Set.univ
[PROOFSTEP]
exact kernel.restrict_univ.symm
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
⊢ ∫⁻ (bc : β × γ), f bc.fst bc.snd ∂↑(κ ⊗ₖ η) a = ∫⁻ (b : β), ∫⁻ (c : γ), f b c ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
let F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
⊢ ∫⁻ (bc : β × γ), f bc.fst bc.snd ∂↑(κ ⊗ₖ η) a = ∫⁻ (b : β), ∫⁻ (c : γ), f b c ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
have h : ∀ a, ⨆ n, F n a = Function.uncurry f a := SimpleFunc.iSup_eapprox_apply (Function.uncurry f) hf
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β × γ), ⨆ (n : ℕ), ↑(F n) a = Function.uncurry f a
⊢ ∫⁻ (bc : β × γ), f bc.fst bc.snd ∂↑(κ ⊗ₖ η) a = ∫⁻ (b : β), ∫⁻ (c : γ), f b c ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
simp only [Prod.forall, Function.uncurry_apply_pair] at h 
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
⊢ ∫⁻ (bc : β × γ), f bc.fst bc.snd ∂↑(κ ⊗ₖ η) a = ∫⁻ (b : β), ∫⁻ (c : γ), f b c ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
simp_rw [← h, Prod.mk.eta]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
⊢ ∫⁻ (bc : β × γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) bc ∂↑(κ ⊗ₖ η) a =
    ∫⁻ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (b, c) ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
have h_mono : Monotone F := fun i j hij b => SimpleFunc.monotone_eapprox (Function.uncurry f) hij _
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
⊢ ∫⁻ (bc : β × γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) bc ∂↑(κ ⊗ₖ η) a =
    ∫⁻ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (b, c) ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
rw [lintegral_iSup (fun n => (F n).measurable) h_mono]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
⊢ ⨆ (n : ℕ), ∫⁻ (a : β × γ), ↑(F n) a ∂↑(κ ⊗ₖ η) a =
    ∫⁻ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (b, c) ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
have : ∀ b, ∫⁻ c, ⨆ n, F n (b, c) ∂η (a, b) = ⨆ n, ∫⁻ c, F n (b, c) ∂η (a, b) :=
  by
  intro a
  rw [lintegral_iSup]
  · exact fun n => (F n).measurable.comp measurable_prod_mk_left
  · exact fun i j hij b => h_mono hij _
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
⊢ ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
[PROOFSTEP]
intro a
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
a : β
⊢ ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (a, c) ∂↑η (a✝, a) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (a, c) ∂↑η (a✝, a)
[PROOFSTEP]
rw [lintegral_iSup]
[GOAL]
case hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
a : β
⊢ ∀ (n : ℕ), Measurable fun c => ↑(F n) (a, c)
[PROOFSTEP]
exact fun n => (F n).measurable.comp measurable_prod_mk_left
[GOAL]
case h_mono
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a✝ : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
a : β
⊢ Monotone fun n c => ↑(F n) (a, c)
[PROOFSTEP]
exact fun i j hij b => h_mono hij _
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
⊢ ⨆ (n : ℕ), ∫⁻ (a : β × γ), ↑(F n) a ∂↑(κ ⊗ₖ η) a =
    ∫⁻ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (b, c) ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
simp_rw [this]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
⊢ ⨆ (n : ℕ), ∫⁻ (a : β × γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) a ∂↑(κ ⊗ₖ η) a =
    ∫⁻ (b : β), ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (b, c) ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
have h_some_meas_integral : ∀ f' : SimpleFunc (β × γ) ℝ≥0∞, Measurable fun b => ∫⁻ c, f' (b, c) ∂η (a, b) :=
  by
  intro f'
  have : (fun b => ∫⁻ c, f' (b, c) ∂η (a, b)) = (fun ab => ∫⁻ c, f' (ab.2, c) ∂η ab) ∘ fun b => (a, b) := by ext1 ab;
    rfl
  rw [this]
  refine' Measurable.comp _ measurable_prod_mk_left
  exact
    Measurable.lintegral_kernel_prod_right ((SimpleFunc.measurable _).comp (measurable_fst.snd.prod_mk measurable_snd))
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
⊢ ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
[PROOFSTEP]
intro f'
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
f' : SimpleFunc (β × γ) ℝ≥0∞
⊢ Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
[PROOFSTEP]
have : (fun b => ∫⁻ c, f' (b, c) ∂η (a, b)) = (fun ab => ∫⁻ c, f' (ab.2, c) ∂η ab) ∘ fun b => (a, b) := by ext1 ab; rfl
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
f' : SimpleFunc (β × γ) ℝ≥0∞
⊢ (fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)) = (fun ab => ∫⁻ (c : γ), ↑f' (ab.snd, c) ∂↑η ab) ∘ fun b => (a, b)
[PROOFSTEP]
ext1 ab
[GOAL]
case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
f' : SimpleFunc (β × γ) ℝ≥0∞
ab : β
⊢ ∫⁻ (c : γ), ↑f' (ab, c) ∂↑η (a, ab) = ((fun ab => ∫⁻ (c : γ), ↑f' (ab.snd, c) ∂↑η ab) ∘ fun b => (a, b)) ab
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this✝ : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
f' : SimpleFunc (β × γ) ℝ≥0∞
this : (fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)) = (fun ab => ∫⁻ (c : γ), ↑f' (ab.snd, c) ∂↑η ab) ∘ fun b => (a, b)
⊢ Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
[PROOFSTEP]
rw [this]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this✝ : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
f' : SimpleFunc (β × γ) ℝ≥0∞
this : (fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)) = (fun ab => ∫⁻ (c : γ), ↑f' (ab.snd, c) ∂↑η ab) ∘ fun b => (a, b)
⊢ Measurable ((fun ab => ∫⁻ (c : γ), ↑f' (ab.snd, c) ∂↑η ab) ∘ fun b => (a, b))
[PROOFSTEP]
refine' Measurable.comp _ measurable_prod_mk_left
[GOAL]
case refine'_1
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this✝ : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
f' : SimpleFunc (β × γ) ℝ≥0∞
this : (fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)) = (fun ab => ∫⁻ (c : γ), ↑f' (ab.snd, c) ∂↑η ab) ∘ fun b => (a, b)
⊢ Measurable fun ab => ∫⁻ (c : γ), ↑f' (ab.snd, c) ∂↑η ab
case refine'_2
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this✝ : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
f' : SimpleFunc (β × γ) ℝ≥0∞
this : (fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)) = (fun ab => ∫⁻ (c : γ), ↑f' (ab.snd, c) ∂↑η ab) ∘ fun b => (a, b)
⊢ MeasurableSpace α
[PROOFSTEP]
exact
  Measurable.lintegral_kernel_prod_right ((SimpleFunc.measurable _).comp (measurable_fst.snd.prod_mk measurable_snd))
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
⊢ ⨆ (n : ℕ), ∫⁻ (a : β × γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) a ∂↑(κ ⊗ₖ η) a =
    ∫⁻ (b : β), ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (b, c) ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
rw [lintegral_iSup]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
⊢ ⨆ (n : ℕ), ∫⁻ (a : β × γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) a ∂↑(κ ⊗ₖ η) a =
    ⨆ (n : ℕ), ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a_1, c) ∂↑η (a, a_1) ∂↑κ a
case hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
⊢ ∀ (n : ℕ), Measurable fun b => ∫⁻ (c : γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (b, c) ∂↑η (a, b)
case h_mono
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
⊢ Monotone fun n b => ∫⁻ (c : γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (b, c) ∂↑η (a, b)
[PROOFSTEP]
rotate_left
[GOAL]
case hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
⊢ ∀ (n : ℕ), Measurable fun b => ∫⁻ (c : γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (b, c) ∂↑η (a, b)
[PROOFSTEP]
exact fun n => h_some_meas_integral (F n)
[GOAL]
case h_mono
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
⊢ Monotone fun n b => ∫⁻ (c : γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (b, c) ∂↑η (a, b)
[PROOFSTEP]
exact fun i j hij b => lintegral_mono fun c => h_mono hij _
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
⊢ ⨆ (n : ℕ), ∫⁻ (a : β × γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) a ∂↑(κ ⊗ₖ η) a =
    ⨆ (n : ℕ), ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a_1, c) ∂↑η (a, a_1) ∂↑κ a
[PROOFSTEP]
congr
[GOAL]
case e_s
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
⊢ (fun n => ∫⁻ (a : β × γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) a ∂↑(κ ⊗ₖ η) a) = fun n =>
    ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a_1, c) ∂↑η (a, a_1) ∂↑κ a
[PROOFSTEP]
ext1 n
[GOAL]
case e_s.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
⊢ ∫⁻ (a : β × γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) a ∂↑(κ ⊗ₖ η) a =
    ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a_1, c) ∂↑η (a, a_1) ∂↑κ a
[PROOFSTEP]
refine'
  SimpleFunc.induction (P := fun f =>
    (∫⁻ (a : β × γ), f a ∂(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), f (a_1, c) ∂η (a, a_1) ∂κ a)) _ _ (F n)
[GOAL]
case e_s.h.refine'_1
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
⊢ ∀ (c : ℝ≥0∞) {s : Set (β × γ)} (hs : MeasurableSet s),
    (fun f => ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a)
      (SimpleFunc.piecewise s hs (SimpleFunc.const (β × γ) c) (SimpleFunc.const (β × γ) 0))
[PROOFSTEP]
intro c s hs
[GOAL]
case e_s.h.refine'_1
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
c : ℝ≥0∞
s : Set (β × γ)
hs : MeasurableSet s
⊢ ∫⁻ (a : β × γ),
      ↑(SimpleFunc.piecewise s hs (SimpleFunc.const (β × γ) c) (SimpleFunc.const (β × γ) 0)) a ∂↑(κ ⊗ₖ η) a =
    ∫⁻ (a_1 : β),
      ∫⁻ (c_1 : γ),
        ↑(SimpleFunc.piecewise s hs (SimpleFunc.const (β × γ) c) (SimpleFunc.const (β × γ) 0))
          (a_1, c_1) ∂↑η (a, a_1) ∂↑κ a
[PROOFSTEP]
classical
  -- Porting note: Added `classical` for `Set.piecewise_eq_indicator`
simp only [SimpleFunc.const_zero, SimpleFunc.coe_piecewise, SimpleFunc.coe_const, SimpleFunc.coe_zero,
  Set.piecewise_eq_indicator, Function.const, lintegral_indicator_const hs]
rw [compProd_apply κ η _ hs, ← lintegral_const_mul c _]
swap
· exact (measurable_kernel_prod_mk_left ((measurable_fst.snd.prod_mk measurable_snd) hs)).comp measurable_prod_mk_left
congr
ext1 b
rw [lintegral_indicator_const_comp measurable_prod_mk_left hs]
rfl
[GOAL]
case e_s.h.refine'_1
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
c : ℝ≥0∞
s : Set (β × γ)
hs : MeasurableSet s
⊢ ∫⁻ (a : β × γ),
      ↑(SimpleFunc.piecewise s hs (SimpleFunc.const (β × γ) c) (SimpleFunc.const (β × γ) 0)) a ∂↑(κ ⊗ₖ η) a =
    ∫⁻ (a_1 : β),
      ∫⁻ (c_1 : γ),
        ↑(SimpleFunc.piecewise s hs (SimpleFunc.const (β × γ) c) (SimpleFunc.const (β × γ) 0))
          (a_1, c_1) ∂↑η (a, a_1) ∂↑κ a
[PROOFSTEP]
simp only [SimpleFunc.const_zero, SimpleFunc.coe_piecewise, SimpleFunc.coe_const, SimpleFunc.coe_zero,
  Set.piecewise_eq_indicator, Function.const, lintegral_indicator_const hs]
[GOAL]
case e_s.h.refine'_1
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
c : ℝ≥0∞
s : Set (β × γ)
hs : MeasurableSet s
⊢ c * ↑↑(↑(κ ⊗ₖ η) a) s = ∫⁻ (a_1 : β), ∫⁻ (c_1 : γ), Set.indicator s (fun x => c) (a_1, c_1) ∂↑η (a, a_1) ∂↑κ a
[PROOFSTEP]
rw [compProd_apply κ η _ hs, ← lintegral_const_mul c _]
[GOAL]
case e_s.h.refine'_1
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
c : ℝ≥0∞
s : Set (β × γ)
hs : MeasurableSet s
⊢ ∫⁻ (a_1 : β), c * ↑↑(↑η (a, a_1)) {c | (a_1, c) ∈ s} ∂↑κ a =
    ∫⁻ (a_1 : β), ∫⁻ (c_1 : γ), Set.indicator s (fun x => c) (a_1, c_1) ∂↑η (a, a_1) ∂↑κ a
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
c : ℝ≥0∞
s : Set (β × γ)
hs : MeasurableSet s
⊢ Measurable fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ s}
[PROOFSTEP]
swap
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
c : ℝ≥0∞
s : Set (β × γ)
hs : MeasurableSet s
⊢ Measurable fun b => ↑↑(↑η (a, b)) {c | (b, c) ∈ s}
[PROOFSTEP]
exact (measurable_kernel_prod_mk_left ((measurable_fst.snd.prod_mk measurable_snd) hs)).comp measurable_prod_mk_left
[GOAL]
case e_s.h.refine'_1
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
c : ℝ≥0∞
s : Set (β × γ)
hs : MeasurableSet s
⊢ ∫⁻ (a_1 : β), c * ↑↑(↑η (a, a_1)) {c | (a_1, c) ∈ s} ∂↑κ a =
    ∫⁻ (a_1 : β), ∫⁻ (c_1 : γ), Set.indicator s (fun x => c) (a_1, c_1) ∂↑η (a, a_1) ∂↑κ a
[PROOFSTEP]
congr
[GOAL]
case e_s.h.refine'_1.e_f
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
c : ℝ≥0∞
s : Set (β × γ)
hs : MeasurableSet s
⊢ (fun a_1 => c * ↑↑(↑η (a, a_1)) {c | (a_1, c) ∈ s}) = fun a_1 =>
    ∫⁻ (c_1 : γ), Set.indicator s (fun x => c) (a_1, c_1) ∂↑η (a, a_1)
[PROOFSTEP]
ext1 b
[GOAL]
case e_s.h.refine'_1.e_f.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
c : ℝ≥0∞
s : Set (β × γ)
hs : MeasurableSet s
b : β
⊢ c * ↑↑(↑η (a, b)) {c | (b, c) ∈ s} = ∫⁻ (c_1 : γ), Set.indicator s (fun x => c) (b, c_1) ∂↑η (a, b)
[PROOFSTEP]
rw [lintegral_indicator_const_comp measurable_prod_mk_left hs]
[GOAL]
case e_s.h.refine'_1.e_f.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
c : ℝ≥0∞
s : Set (β × γ)
hs : MeasurableSet s
b : β
⊢ c * ↑↑(↑η (a, b)) {c | (b, c) ∈ s} = c * ↑↑(↑η (a, b)) (Prod.mk b ⁻¹' s)
[PROOFSTEP]
rfl
[GOAL]
case e_s.h.refine'_2
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f) n) (a, b) = f a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
⊢ ∀ ⦃f g : SimpleFunc (β × γ) ℝ≥0∞⦄,
    Disjoint (Function.support ↑f) (Function.support ↑g) →
      (fun f => ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a) f →
        (fun f => ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a) g →
          (fun f => ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a)
            (f + g)
[PROOFSTEP]
intro f f' _ hf_eq hf'_eq
[GOAL]
case e_s.h.refine'_2
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f✝ : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f✝)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f✝)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f✝) n) (a, b) = f✝ a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
f f' : SimpleFunc (β × γ) ℝ≥0∞
a✝ : Disjoint (Function.support ↑f) (Function.support ↑f')
hf_eq : ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a
hf'_eq : ∫⁻ (a : β × γ), ↑f' a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f' (a_1, c) ∂↑η (a, a_1) ∂↑κ a
⊢ ∫⁻ (a : β × γ), ↑(f + f') a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑(f + f') (a_1, c) ∂↑η (a, a_1) ∂↑κ a
[PROOFSTEP]
simp_rw [SimpleFunc.coe_add, Pi.add_apply]
[GOAL]
case e_s.h.refine'_2
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f✝ : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f✝)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f✝)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f✝) n) (a, b) = f✝ a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
f f' : SimpleFunc (β × γ) ℝ≥0∞
a✝ : Disjoint (Function.support ↑f) (Function.support ↑f')
hf_eq : ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a
hf'_eq : ∫⁻ (a : β × γ), ↑f' a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f' (a_1, c) ∂↑η (a, a_1) ∂↑κ a
⊢ ∫⁻ (a : β × γ), ↑f a + ↑f' a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) + ↑f' (a_1, c) ∂↑η (a, a_1) ∂↑κ a
[PROOFSTEP]
change ∫⁻ x, (f : β × γ → ℝ≥0∞) x + f' x ∂(κ ⊗ₖ η) a = ∫⁻ b, ∫⁻ c : γ, f (b, c) + f' (b, c) ∂η (a, b) ∂κ a
[GOAL]
case e_s.h.refine'_2
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f✝ : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f✝)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f✝)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f✝) n) (a, b) = f✝ a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
f f' : SimpleFunc (β × γ) ℝ≥0∞
a✝ : Disjoint (Function.support ↑f) (Function.support ↑f')
hf_eq : ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a
hf'_eq : ∫⁻ (a : β × γ), ↑f' a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f' (a_1, c) ∂↑η (a, a_1) ∂↑κ a
⊢ ∫⁻ (x : β × γ), ↑f x + ↑f' x ∂↑(κ ⊗ₖ η) a = ∫⁻ (b : β), ∫⁻ (c : γ), ↑f (b, c) + ↑f' (b, c) ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
rw [lintegral_add_left (SimpleFunc.measurable _), hf_eq, hf'_eq, ← lintegral_add_left]
[GOAL]
case e_s.h.refine'_2
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f✝ : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f✝)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f✝)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f✝) n) (a, b) = f✝ a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
f f' : SimpleFunc (β × γ) ℝ≥0∞
a✝ : Disjoint (Function.support ↑f) (Function.support ↑f')
hf_eq : ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a
hf'_eq : ∫⁻ (a : β × γ), ↑f' a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f' (a_1, c) ∂↑η (a, a_1) ∂↑κ a
⊢ ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) + ∫⁻ (c : γ), ↑f' (a_1, c) ∂↑η (a, a_1) ∂↑κ a =
    ∫⁻ (b : β), ∫⁻ (c : γ), ↑f (b, c) + ↑f' (b, c) ∂↑η (a, b) ∂↑κ a
case e_s.h.refine'_2.hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f✝ : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f✝)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f✝)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f✝) n) (a, b) = f✝ a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
f f' : SimpleFunc (β × γ) ℝ≥0∞
a✝ : Disjoint (Function.support ↑f) (Function.support ↑f')
hf_eq : ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a
hf'_eq : ∫⁻ (a : β × γ), ↑f' a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f' (a_1, c) ∂↑η (a, a_1) ∂↑κ a
⊢ Measurable fun a_1 => ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1)
[PROOFSTEP]
swap
[GOAL]
case e_s.h.refine'_2.hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f✝ : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f✝)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f✝)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f✝) n) (a, b) = f✝ a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
f f' : SimpleFunc (β × γ) ℝ≥0∞
a✝ : Disjoint (Function.support ↑f) (Function.support ↑f')
hf_eq : ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a
hf'_eq : ∫⁻ (a : β × γ), ↑f' a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f' (a_1, c) ∂↑η (a, a_1) ∂↑κ a
⊢ Measurable fun a_1 => ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1)
[PROOFSTEP]
exact h_some_meas_integral f
[GOAL]
case e_s.h.refine'_2
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f✝ : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f✝)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f✝)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f✝) n) (a, b) = f✝ a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
f f' : SimpleFunc (β × γ) ℝ≥0∞
a✝ : Disjoint (Function.support ↑f) (Function.support ↑f')
hf_eq : ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a
hf'_eq : ∫⁻ (a : β × γ), ↑f' a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f' (a_1, c) ∂↑η (a, a_1) ∂↑κ a
⊢ ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) + ∫⁻ (c : γ), ↑f' (a_1, c) ∂↑η (a, a_1) ∂↑κ a =
    ∫⁻ (b : β), ∫⁻ (c : γ), ↑f (b, c) + ↑f' (b, c) ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
congr with b
[GOAL]
case e_s.h.refine'_2.e_f.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f✝ : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f✝)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f✝)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f✝) n) (a, b) = f✝ a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
f f' : SimpleFunc (β × γ) ℝ≥0∞
a✝ : Disjoint (Function.support ↑f) (Function.support ↑f')
hf_eq : ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a
hf'_eq : ∫⁻ (a : β × γ), ↑f' a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f' (a_1, c) ∂↑η (a, a_1) ∂↑κ a
b : β
⊢ ∫⁻ (c : γ), ↑f (b, c) ∂↑η (a, b) + ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b) = ∫⁻ (c : γ), ↑f (b, c) + ↑f' (b, c) ∂↑η (a, b)
[PROOFSTEP]
rw [lintegral_add_left]
[GOAL]
case e_s.h.refine'_2.e_f.h.hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f✝ : β → γ → ℝ≥0∞
hf : Measurable (Function.uncurry f✝)
F : ℕ → SimpleFunc (β × γ) ℝ≥0∞ := SimpleFunc.eapprox (Function.uncurry f✝)
h : ∀ (a : β) (b : γ), ⨆ (n : ℕ), ↑(SimpleFunc.eapprox (Function.uncurry f✝) n) (a, b) = f✝ a b
h_mono : Monotone F
this : ∀ (b : β), ∫⁻ (c : γ), ⨆ (n : ℕ), ↑(F n) (b, c) ∂↑η (a, b) = ⨆ (n : ℕ), ∫⁻ (c : γ), ↑(F n) (b, c) ∂↑η (a, b)
h_some_meas_integral : ∀ (f' : SimpleFunc (β × γ) ℝ≥0∞), Measurable fun b => ∫⁻ (c : γ), ↑f' (b, c) ∂↑η (a, b)
n : ℕ
f f' : SimpleFunc (β × γ) ℝ≥0∞
a✝ : Disjoint (Function.support ↑f) (Function.support ↑f')
hf_eq : ∫⁻ (a : β × γ), ↑f a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f (a_1, c) ∂↑η (a, a_1) ∂↑κ a
hf'_eq : ∫⁻ (a : β × γ), ↑f' a ∂↑(κ ⊗ₖ η) a = ∫⁻ (a_1 : β), ∫⁻ (c : γ), ↑f' (a_1, c) ∂↑η (a, a_1) ∂↑κ a
b : β
⊢ Measurable fun c => ↑f (b, c)
[PROOFSTEP]
exact (SimpleFunc.measurable _).comp measurable_prod_mk_left
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (bc : β × γ), f bc ∂↑(κ ⊗ₖ η) a = ∫⁻ (b : β), ∫⁻ (c : γ), f (b, c) ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
let g := Function.curry f
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
g : β → γ → ℝ≥0∞ := Function.curry f
⊢ ∫⁻ (bc : β × γ), f bc ∂↑(κ ⊗ₖ η) a = ∫⁻ (b : β), ∫⁻ (c : γ), f (b, c) ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
change ∫⁻ bc, f bc ∂(κ ⊗ₖ η) a = ∫⁻ b, ∫⁻ c, g b c ∂η (a, b) ∂κ a
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
g : β → γ → ℝ≥0∞ := Function.curry f
⊢ ∫⁻ (bc : β × γ), f bc ∂↑(κ ⊗ₖ η) a = ∫⁻ (b : β), ∫⁻ (c : γ), g b c ∂↑η (a, b) ∂↑κ a
[PROOFSTEP]
rw [← lintegral_compProd']
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
g : β → γ → ℝ≥0∞ := Function.curry f
⊢ ∫⁻ (bc : β × γ), f bc ∂↑(κ ⊗ₖ η) a = ∫⁻ (bc : β × γ), g bc.fst bc.snd ∂↑(κ ⊗ₖ η) a
[PROOFSTEP]
simp_rw [Function.curry_apply]
[GOAL]
case hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
g : β → γ → ℝ≥0∞ := Function.curry f
⊢ Measurable (Function.uncurry fun b c => g b c)
[PROOFSTEP]
simp_rw [Function.uncurry_curry]
[GOAL]
case hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
g : β → γ → ℝ≥0∞ := Function.curry f
⊢ Measurable f
[PROOFSTEP]
exact hf
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : AEMeasurable f
⊢ ∫⁻ (z : β × γ), f z ∂↑(κ ⊗ₖ η) a = ∫⁻ (x : β), ∫⁻ (y : γ), f (x, y) ∂↑η (a, x) ∂↑κ a
[PROOFSTEP]
have A : ∫⁻ z, f z ∂(κ ⊗ₖ η) a = ∫⁻ z, hf.mk f z ∂(κ ⊗ₖ η) a := lintegral_congr_ae hf.ae_eq_mk
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : AEMeasurable f
A : ∫⁻ (z : β × γ), f z ∂↑(κ ⊗ₖ η) a = ∫⁻ (z : β × γ), AEMeasurable.mk f hf z ∂↑(κ ⊗ₖ η) a
⊢ ∫⁻ (z : β × γ), f z ∂↑(κ ⊗ₖ η) a = ∫⁻ (x : β), ∫⁻ (y : γ), f (x, y) ∂↑η (a, x) ∂↑κ a
[PROOFSTEP]
have B : ∫⁻ x, ∫⁻ y, f (x, y) ∂η (a, x) ∂κ a = ∫⁻ x, ∫⁻ y, hf.mk f (x, y) ∂η (a, x) ∂κ a :=
  by
  apply lintegral_congr_ae
  filter_upwards [ae_ae_of_ae_compProd hf.ae_eq_mk] with _ ha using lintegral_congr_ae ha
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : AEMeasurable f
A : ∫⁻ (z : β × γ), f z ∂↑(κ ⊗ₖ η) a = ∫⁻ (z : β × γ), AEMeasurable.mk f hf z ∂↑(κ ⊗ₖ η) a
⊢ ∫⁻ (x : β), ∫⁻ (y : γ), f (x, y) ∂↑η (a, x) ∂↑κ a =
    ∫⁻ (x : β), ∫⁻ (y : γ), AEMeasurable.mk f hf (x, y) ∂↑η (a, x) ∂↑κ a
[PROOFSTEP]
apply lintegral_congr_ae
[GOAL]
case h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : AEMeasurable f
A : ∫⁻ (z : β × γ), f z ∂↑(κ ⊗ₖ η) a = ∫⁻ (z : β × γ), AEMeasurable.mk f hf z ∂↑(κ ⊗ₖ η) a
⊢ (fun a_1 => ∫⁻ (y : γ), f (a_1, y) ∂↑η (a, a_1)) =ᵐ[↑κ a] fun a_1 =>
    ∫⁻ (y : γ), AEMeasurable.mk f hf (a_1, y) ∂↑η (a, a_1)
[PROOFSTEP]
filter_upwards [ae_ae_of_ae_compProd hf.ae_eq_mk] with _ ha using lintegral_congr_ae ha
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : AEMeasurable f
A : ∫⁻ (z : β × γ), f z ∂↑(κ ⊗ₖ η) a = ∫⁻ (z : β × γ), AEMeasurable.mk f hf z ∂↑(κ ⊗ₖ η) a
B :
  ∫⁻ (x : β), ∫⁻ (y : γ), f (x, y) ∂↑η (a, x) ∂↑κ a =
    ∫⁻ (x : β), ∫⁻ (y : γ), AEMeasurable.mk f hf (x, y) ∂↑η (a, x) ∂↑κ a
⊢ ∫⁻ (z : β × γ), f z ∂↑(κ ⊗ₖ η) a = ∫⁻ (x : β), ∫⁻ (y : γ), f (x, y) ∂↑η (a, x) ∂↑κ a
[PROOFSTEP]
rw [A, B, lintegral_compProd]
[GOAL]
case hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : AEMeasurable f
A : ∫⁻ (z : β × γ), f z ∂↑(κ ⊗ₖ η) a = ∫⁻ (z : β × γ), AEMeasurable.mk f hf z ∂↑(κ ⊗ₖ η) a
B :
  ∫⁻ (x : β), ∫⁻ (y : γ), f (x, y) ∂↑η (a, x) ∂↑κ a =
    ∫⁻ (x : β), ∫⁻ (y : γ), AEMeasurable.mk f hf (x, y) ∂↑η (a, x) ∂↑κ a
⊢ Measurable fun z => AEMeasurable.mk f hf z
[PROOFSTEP]
exact hf.measurable_mk
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
s : Set β
t : Set γ
hs : MeasurableSet s
ht : MeasurableSet t
⊢ ∫⁻ (z : β × γ) in s ×ˢ t, f z ∂↑(κ ⊗ₖ η) a = ∫⁻ (x : β) in s, ∫⁻ (y : γ) in t, f (x, y) ∂↑η (a, x) ∂↑κ a
[PROOFSTEP]
simp_rw [← kernel.restrict_apply (κ ⊗ₖ η) (hs.prod ht), ← compProd_restrict hs ht, lintegral_compProd _ _ _ hf,
  kernel.restrict_apply]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ ∫⁻ (z : β × γ) in s ×ˢ Set.univ, f z ∂↑(κ ⊗ₖ η) a = ∫⁻ (x : β) in s, ∫⁻ (y : γ), f (x, y) ∂↑η (a, x) ∂↑κ a
[PROOFSTEP]
simp_rw [set_lintegral_compProd κ η a hf hs MeasurableSet.univ, Measure.restrict_univ]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
t : Set γ
ht : MeasurableSet t
⊢ ∫⁻ (z : β × γ) in Set.univ ×ˢ t, f z ∂↑(κ ⊗ₖ η) a = ∫⁻ (x : β), ∫⁻ (y : γ) in t, f (x, y) ∂↑η (a, x) ∂↑κ a
[PROOFSTEP]
simp_rw [set_lintegral_compProd κ η a hf MeasurableSet.univ ht, Measure.restrict_univ]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ ↑↑(↑(κ ⊗ₖ η) a) s = ∑' (n : ℕ) (m : ℕ), ↑↑(↑(seq κ n ⊗ₖ seq η m) a) s
[PROOFSTEP]
simp_rw [compProd_apply_eq_compProdFun _ _ _ hs]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ compProdFun κ η a s = ∑' (n : ℕ) (m : ℕ), compProdFun (seq κ n) (seq η m) a s
[PROOFSTEP]
exact compProdFun_eq_tsum κ η a hs
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
⊢ κ ⊗ₖ η = kernel.sum fun n => kernel.sum fun m => seq κ n ⊗ₖ seq η m
[PROOFSTEP]
ext a s hs
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
s : Set (β × γ)
hs : MeasurableSet s
⊢ ↑↑(↑(κ ⊗ₖ η) a) s = ↑↑(↑(kernel.sum fun n => kernel.sum fun m => seq κ n ⊗ₖ seq η m) a) s
[PROOFSTEP]
simp_rw [kernel.sum_apply' _ a hs]
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
a : α
s : Set (β × γ)
hs : MeasurableSet s
⊢ ↑↑(↑(κ ⊗ₖ η) a) s = ∑' (n : ℕ) (n_1 : ℕ), ↑↑(↑(seq κ n ⊗ₖ seq η n_1) a) s
[PROOFSTEP]
rw [compProd_eq_tsum_compProd κ η a hs]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
⊢ κ ⊗ₖ η = kernel.sum fun n => seq κ n ⊗ₖ η
[PROOFSTEP]
by_cases h : IsSFiniteKernel η
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel η
⊢ κ ⊗ₖ η = kernel.sum fun n => seq κ n ⊗ₖ η
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
h : ¬IsSFiniteKernel η
⊢ κ ⊗ₖ η = kernel.sum fun n => seq κ n ⊗ₖ η
[PROOFSTEP]
swap
[GOAL]
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
h : ¬IsSFiniteKernel η
⊢ κ ⊗ₖ η = kernel.sum fun n => seq κ n ⊗ₖ η
[PROOFSTEP]
simp_rw [compProd_of_not_isSFiniteKernel_right _ _ h]
[GOAL]
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
h : ¬IsSFiniteKernel η
⊢ 0 = kernel.sum fun n => 0
[PROOFSTEP]
simp
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel η
⊢ κ ⊗ₖ η = kernel.sum fun n => seq κ n ⊗ₖ η
[PROOFSTEP]
rw [compProd_eq_sum_compProd]
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel η
⊢ (kernel.sum fun n => kernel.sum fun m => seq κ n ⊗ₖ seq η m) = kernel.sum fun n => seq κ n ⊗ₖ η
[PROOFSTEP]
congr with n a s hs
[GOAL]
case pos.e_κ.h.h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s✝ : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel η
n : ℕ
a : α
s : Set (β × γ)
hs : MeasurableSet s
⊢ ↑↑(↑(kernel.sum fun m => seq κ n ⊗ₖ seq η m) a) s = ↑↑(↑(seq κ n ⊗ₖ η) a) s
[PROOFSTEP]
simp_rw [kernel.sum_apply' _ _ hs, compProd_apply_eq_compProdFun _ _ _ hs, compProdFun_tsum_right _ η a hs]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
⊢ κ ⊗ₖ η = kernel.sum fun n => κ ⊗ₖ seq η n
[PROOFSTEP]
by_cases hκ : IsSFiniteKernel κ
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hκ : IsSFiniteKernel κ
⊢ κ ⊗ₖ η = kernel.sum fun n => κ ⊗ₖ seq η n
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hκ : ¬IsSFiniteKernel κ
⊢ κ ⊗ₖ η = kernel.sum fun n => κ ⊗ₖ seq η n
[PROOFSTEP]
swap
[GOAL]
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hκ : ¬IsSFiniteKernel κ
⊢ κ ⊗ₖ η = kernel.sum fun n => κ ⊗ₖ seq η n
[PROOFSTEP]
simp_rw [compProd_of_not_isSFiniteKernel_left _ _ hκ]
[GOAL]
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hκ : ¬IsSFiniteKernel κ
⊢ 0 = kernel.sum fun n => 0
[PROOFSTEP]
simp
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hκ : IsSFiniteKernel κ
⊢ κ ⊗ₖ η = kernel.sum fun n => κ ⊗ₖ seq η n
[PROOFSTEP]
rw [compProd_eq_sum_compProd]
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hκ : IsSFiniteKernel κ
⊢ (kernel.sum fun n => kernel.sum fun m => seq κ n ⊗ₖ seq η m) = kernel.sum fun n => κ ⊗ₖ seq η n
[PROOFSTEP]
simp_rw [compProd_eq_sum_compProd_left κ _]
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel η
hκ : IsSFiniteKernel κ
⊢ (kernel.sum fun n => kernel.sum fun m => seq κ n ⊗ₖ seq η m) =
    kernel.sum fun n => kernel.sum fun n_1 => seq κ n_1 ⊗ₖ seq η n
[PROOFSTEP]
rw [kernel.sum_comm]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsMarkovKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsMarkovKernel η
a : α
⊢ ↑↑(↑(κ ⊗ₖ η) a) Set.univ = 1
[PROOFSTEP]
rw [compProd_apply κ η a MeasurableSet.univ]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
inst✝¹ : IsMarkovKernel κ
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsMarkovKernel η
a : α
⊢ ∫⁻ (b : β), ↑↑(↑η (a, b)) {c | (b, c) ∈ Set.univ} ∂↑κ a = 1
[PROOFSTEP]
simp only [Set.mem_univ, Set.setOf_true, measure_univ, lintegral_one]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
a : α
⊢ ↑↑(↑(κ ⊗ₖ η) a) Set.univ ≤ ↑↑(↑κ a) Set.univ * IsFiniteKernel.bound η
[PROOFSTEP]
by_cases hκ : IsSFiniteKernel κ
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
a : α
hκ : IsSFiniteKernel κ
⊢ ↑↑(↑(κ ⊗ₖ η) a) Set.univ ≤ ↑↑(↑κ a) Set.univ * IsFiniteKernel.bound η
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
a : α
hκ : ¬IsSFiniteKernel κ
⊢ ↑↑(↑(κ ⊗ₖ η) a) Set.univ ≤ ↑↑(↑κ a) Set.univ * IsFiniteKernel.bound η
[PROOFSTEP]
swap
[GOAL]
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
a : α
hκ : ¬IsSFiniteKernel κ
⊢ ↑↑(↑(κ ⊗ₖ η) a) Set.univ ≤ ↑↑(↑κ a) Set.univ * IsFiniteKernel.bound η
[PROOFSTEP]
rw [compProd_of_not_isSFiniteKernel_left _ _ hκ]
[GOAL]
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
a : α
hκ : ¬IsSFiniteKernel κ
⊢ ↑↑(↑0 a) Set.univ ≤ ↑↑(↑κ a) Set.univ * IsFiniteKernel.bound η
[PROOFSTEP]
simp
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
a : α
hκ : IsSFiniteKernel κ
⊢ ↑↑(↑(κ ⊗ₖ η) a) Set.univ ≤ ↑↑(↑κ a) Set.univ * IsFiniteKernel.bound η
[PROOFSTEP]
rw [compProd_apply κ η a MeasurableSet.univ]
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
a : α
hκ : IsSFiniteKernel κ
⊢ ∫⁻ (b : β), ↑↑(↑η (a, b)) {c | (b, c) ∈ Set.univ} ∂↑κ a ≤ ↑↑(↑κ a) Set.univ * IsFiniteKernel.bound η
[PROOFSTEP]
simp only [Set.mem_univ, Set.setOf_true]
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
a : α
hκ : IsSFiniteKernel κ
⊢ ∫⁻ (b : β), ↑↑(↑η (a, b)) Set.univ ∂↑κ a ≤ ↑↑(↑κ a) Set.univ * IsFiniteKernel.bound η
[PROOFSTEP]
let Cη := IsFiniteKernel.bound η
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel η
a : α
hκ : IsSFiniteKernel κ
Cη : ℝ≥0∞ := IsFiniteKernel.bound η
⊢ ∫⁻ (b : β), ↑↑(↑η (a, b)) Set.univ ∂↑κ a ≤ ↑↑(↑κ a) Set.univ * IsFiniteKernel.bound η
[PROOFSTEP]
calc
  ∫⁻ b, η (a, b) Set.univ ∂κ a ≤ ∫⁻ _, Cη ∂κ a := lintegral_mono fun b => measure_le_bound η (a, b) Set.univ
  _ = Cη * κ a Set.univ := (MeasureTheory.lintegral_const Cη)
  _ = κ a Set.univ * Cη := mul_comm _ _
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
⊢ IsSFiniteKernel (κ ⊗ₖ η)
[PROOFSTEP]
by_cases h : IsSFiniteKernel κ
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel κ
⊢ IsSFiniteKernel (κ ⊗ₖ η)
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : ¬IsSFiniteKernel κ
⊢ IsSFiniteKernel (κ ⊗ₖ η)
[PROOFSTEP]
swap
[GOAL]
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : ¬IsSFiniteKernel κ
⊢ IsSFiniteKernel (κ ⊗ₖ η)
[PROOFSTEP]
rw [compProd_of_not_isSFiniteKernel_left _ _ h]
[GOAL]
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : ¬IsSFiniteKernel κ
⊢ IsSFiniteKernel 0
[PROOFSTEP]
infer_instance
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h : IsSFiniteKernel κ
⊢ IsSFiniteKernel (κ ⊗ₖ η)
[PROOFSTEP]
by_cases h : IsSFiniteKernel η
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h✝ : IsSFiniteKernel κ
h : IsSFiniteKernel η
⊢ IsSFiniteKernel (κ ⊗ₖ η)
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h✝ : IsSFiniteKernel κ
h : ¬IsSFiniteKernel η
⊢ IsSFiniteKernel (κ ⊗ₖ η)
[PROOFSTEP]
swap
[GOAL]
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h✝ : IsSFiniteKernel κ
h : ¬IsSFiniteKernel η
⊢ IsSFiniteKernel (κ ⊗ₖ η)
[PROOFSTEP]
rw [compProd_of_not_isSFiniteKernel_right _ _ h]
[GOAL]
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h✝ : IsSFiniteKernel κ
h : ¬IsSFiniteKernel η
⊢ IsSFiniteKernel 0
[PROOFSTEP]
infer_instance
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h✝ : IsSFiniteKernel κ
h : IsSFiniteKernel η
⊢ IsSFiniteKernel (κ ⊗ₖ η)
[PROOFSTEP]
rw [compProd_eq_sum_compProd]
[GOAL]
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel (α × β) γ }
h✝ : IsSFiniteKernel κ
h : IsSFiniteKernel η
⊢ IsSFiniteKernel (kernel.sum fun n => kernel.sum fun m => seq κ n ⊗ₖ seq η m)
[PROOFSTEP]
exact kernel.isSFiniteKernel_sum fun n => kernel.isSFiniteKernel_sum inferInstance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
hf : Measurable f
a : α
s : Set γ
hs : MeasurableSet s
⊢ ↑↑(↑(map κ f hf) a) s = ↑↑(↑κ a) (f ⁻¹' s)
[PROOFSTEP]
rw [map_apply, Measure.map_apply hf hs]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
hf : Measurable f
a : α
g' : γ → ℝ≥0∞
hg : Measurable g'
⊢ ∫⁻ (b : γ), g' b ∂↑(map κ f hf) a = ∫⁻ (a : β), g' (f a) ∂↑κ a
[PROOFSTEP]
rw [map_apply _ hf, lintegral_map hg hf]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
hf : Measurable f
⊢ (kernel.sum fun n => map (seq κ n) f hf) = map κ f hf
[PROOFSTEP]
ext a s hs
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
hf : Measurable f
a : α
s : Set γ
hs : MeasurableSet s
⊢ ↑↑(↑(kernel.sum fun n => map (seq κ n) f hf) a) s = ↑↑(↑(map κ f hf) a) s
[PROOFSTEP]
rw [kernel.sum_apply, map_apply' κ hf a hs, Measure.sum_apply _ hs, ← measure_sum_seq κ, Measure.sum_apply _ (hf hs)]
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
hf : Measurable f
a : α
s : Set γ
hs : MeasurableSet s
⊢ ∑' (i : ℕ), ↑↑(↑(map (seq κ i) f hf) a) s = ∑' (i : ℕ), ↑↑(↑(seq κ i) a) (f ⁻¹' s)
[PROOFSTEP]
simp_rw [map_apply' _ hf _ hs]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsMarkovKernel κ
hf : Measurable f
a : α
⊢ ↑↑(↑(kernel.map κ f hf) a) Set.univ = 1
[PROOFSTEP]
rw [map_apply' κ hf a MeasurableSet.univ, Set.preimage_univ, measure_univ]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsFiniteKernel κ
hf : Measurable f
⊢ IsFiniteKernel (kernel.map κ f hf)
[PROOFSTEP]
refine' ⟨⟨IsFiniteKernel.bound κ, IsFiniteKernel.bound_lt_top κ, fun a => _⟩⟩
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsFiniteKernel κ
hf : Measurable f
a : α
⊢ ↑↑(↑(kernel.map κ f hf) a) Set.univ ≤ IsFiniteKernel.bound κ
[PROOFSTEP]
rw [map_apply' κ hf a MeasurableSet.univ]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsFiniteKernel κ
hf : Measurable f
a : α
⊢ ↑↑(↑κ a) (f ⁻¹' Set.univ) ≤ IsFiniteKernel.bound κ
[PROOFSTEP]
exact measure_le_bound κ a _
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
hg : Measurable g
⊢ (kernel.sum fun n => comap (seq κ n) g hg) = comap κ g hg
[PROOFSTEP]
ext a s hs
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
hg : Measurable g
a : γ
s : Set β
hs : MeasurableSet s
⊢ ↑↑(↑(kernel.sum fun n => comap (seq κ n) g hg) a) s = ↑↑(↑(comap κ g hg) a) s
[PROOFSTEP]
rw [kernel.sum_apply, comap_apply' κ hg a s, Measure.sum_apply _ hs, ← measure_sum_seq κ, Measure.sum_apply _ hs]
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
hg : Measurable g
a : γ
s : Set β
hs : MeasurableSet s
⊢ ∑' (i : ℕ), ↑↑(↑(comap (seq κ i) g hg) a) s = ∑' (i : ℕ), ↑↑(↑(seq κ i) (g a)) s
[PROOFSTEP]
simp_rw [comap_apply' _ hg _ s]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsMarkovKernel κ
hg : Measurable g
a : γ
⊢ ↑↑(↑(kernel.comap κ g hg) a) Set.univ = 1
[PROOFSTEP]
rw [comap_apply' κ hg a Set.univ, measure_univ]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsFiniteKernel κ
hg : Measurable g
⊢ IsFiniteKernel (kernel.comap κ g hg)
[PROOFSTEP]
refine' ⟨⟨IsFiniteKernel.bound κ, IsFiniteKernel.bound_lt_top κ, fun a => _⟩⟩
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsFiniteKernel κ
hg : Measurable g
a : γ
⊢ ↑↑(↑(kernel.comap κ g hg) a) Set.univ ≤ IsFiniteKernel.bound κ
[PROOFSTEP]
rw [comap_apply' κ hg a Set.univ]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsFiniteKernel κ
hg : Measurable g
a : γ
⊢ ↑↑(↑κ (g a)) Set.univ ≤ IsFiniteKernel.bound κ
[PROOFSTEP]
exact measure_le_bound κ _ _
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsMarkovKernel κ
⊢ IsMarkovKernel (kernel.prodMkLeft γ κ)
[PROOFSTEP]
rw [prodMkLeft]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsMarkovKernel κ
⊢ IsMarkovKernel (kernel.comap κ Prod.snd (_ : Measurable Prod.snd))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsFiniteKernel κ
⊢ IsFiniteKernel (kernel.prodMkLeft γ κ)
[PROOFSTEP]
rw [prodMkLeft]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsFiniteKernel κ
⊢ IsFiniteKernel (kernel.comap κ Prod.snd (_ : Measurable Prod.snd))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
⊢ IsSFiniteKernel (kernel.prodMkLeft γ κ)
[PROOFSTEP]
rw [prodMkLeft]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
⊢ IsSFiniteKernel (kernel.comap κ Prod.snd (_ : Measurable Prod.snd))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g✝ : γ → α
κ : { x // x ∈ kernel (α × β) γ }
a : β × α
g : γ → ℝ≥0∞
⊢ ∫⁻ (c : γ), g c ∂↑(swapLeft κ) a = ∫⁻ (c : γ), g c ∂↑κ (Prod.swap a)
[PROOFSTEP]
rw [swapLeft, lintegral_comap _ measurable_swap a]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel (α × β) γ }
inst✝ : IsMarkovKernel κ
⊢ IsMarkovKernel (kernel.swapLeft κ)
[PROOFSTEP]
rw [swapLeft]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel (α × β) γ }
inst✝ : IsMarkovKernel κ
⊢ IsMarkovKernel (kernel.comap κ Prod.swap (_ : Measurable Prod.swap))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel κ
⊢ IsFiniteKernel (kernel.swapLeft κ)
[PROOFSTEP]
rw [swapLeft]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel (α × β) γ }
inst✝ : IsFiniteKernel κ
⊢ IsFiniteKernel (kernel.comap κ Prod.swap (_ : Measurable Prod.swap))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel κ
⊢ IsSFiniteKernel (kernel.swapLeft κ)
[PROOFSTEP]
rw [swapLeft]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel (α × β) γ }
inst✝ : IsSFiniteKernel κ
⊢ IsSFiniteKernel (kernel.comap κ Prod.swap (_ : Measurable Prod.swap))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
a : α
s : Set (γ × β)
hs : MeasurableSet s
⊢ ↑↑(↑(swapRight κ) a) s = ↑↑(↑κ a) {p | Prod.swap p ∈ s}
[PROOFSTEP]
rw [swapRight_apply, Measure.map_apply measurable_swap hs]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
a : α
s : Set (γ × β)
hs : MeasurableSet s
⊢ ↑↑(↑κ a) (Prod.swap ⁻¹' s) = ↑↑(↑κ a) {p | Prod.swap p ∈ s}
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g✝ : γ → α
κ : { x // x ∈ kernel α (β × γ) }
a : α
g : γ × β → ℝ≥0∞
hg : Measurable g
⊢ ∫⁻ (c : γ × β), g c ∂↑(swapRight κ) a = ∫⁻ (bc : β × γ), g (Prod.swap bc) ∂↑κ a
[PROOFSTEP]
rw [swapRight, lintegral_map _ measurable_swap a hg]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsMarkovKernel κ
⊢ IsMarkovKernel (kernel.swapRight κ)
[PROOFSTEP]
rw [swapRight]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsMarkovKernel κ
⊢ IsMarkovKernel (kernel.map κ Prod.swap (_ : Measurable Prod.swap))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsFiniteKernel κ
⊢ IsFiniteKernel (kernel.swapRight κ)
[PROOFSTEP]
rw [swapRight]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsFiniteKernel κ
⊢ IsFiniteKernel (kernel.map κ Prod.swap (_ : Measurable Prod.swap))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsSFiniteKernel κ
⊢ IsSFiniteKernel (kernel.swapRight κ)
[PROOFSTEP]
rw [swapRight]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsSFiniteKernel κ
⊢ IsSFiniteKernel (kernel.map κ Prod.swap (_ : Measurable Prod.swap))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
a : α
s : Set β
hs : MeasurableSet s
⊢ ↑↑(↑(fst κ) a) s = ↑↑(↑κ a) {p | p.fst ∈ s}
[PROOFSTEP]
rw [fst_apply, Measure.map_apply measurable_fst hs]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
a : α
s : Set β
hs : MeasurableSet s
⊢ ↑↑(↑κ a) (Prod.fst ⁻¹' s) = ↑↑(↑κ a) {p | p.fst ∈ s}
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g✝ : γ → α
κ : { x // x ∈ kernel α (β × γ) }
a : α
g : β → ℝ≥0∞
hg : Measurable g
⊢ ∫⁻ (c : β), g c ∂↑(fst κ) a = ∫⁻ (bc : β × γ), g bc.fst ∂↑κ a
[PROOFSTEP]
rw [fst, lintegral_map _ measurable_fst a hg]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsMarkovKernel κ
⊢ IsMarkovKernel (kernel.fst κ)
[PROOFSTEP]
rw [fst]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsMarkovKernel κ
⊢ IsMarkovKernel (kernel.map κ Prod.fst (_ : Measurable Prod.fst))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsFiniteKernel κ
⊢ IsFiniteKernel (kernel.fst κ)
[PROOFSTEP]
rw [fst]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsFiniteKernel κ
⊢ IsFiniteKernel (kernel.map κ Prod.fst (_ : Measurable Prod.fst))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsSFiniteKernel κ
⊢ IsSFiniteKernel (kernel.fst κ)
[PROOFSTEP]
rw [fst]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsSFiniteKernel κ
⊢ IsSFiniteKernel (kernel.map κ Prod.fst (_ : Measurable Prod.fst))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
a : α
s : Set γ
hs : MeasurableSet s
⊢ ↑↑(↑(snd κ) a) s = ↑↑(↑κ a) {p | p.snd ∈ s}
[PROOFSTEP]
rw [snd_apply, Measure.map_apply measurable_snd hs]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
a : α
s : Set γ
hs : MeasurableSet s
⊢ ↑↑(↑κ a) (Prod.snd ⁻¹' s) = ↑↑(↑κ a) {p | p.snd ∈ s}
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g✝ : γ → α
κ : { x // x ∈ kernel α (β × γ) }
a : α
g : γ → ℝ≥0∞
hg : Measurable g
⊢ ∫⁻ (c : γ), g c ∂↑(snd κ) a = ∫⁻ (bc : β × γ), g bc.snd ∂↑κ a
[PROOFSTEP]
rw [snd, lintegral_map _ measurable_snd a hg]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsMarkovKernel κ
⊢ IsMarkovKernel (kernel.snd κ)
[PROOFSTEP]
rw [snd]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsMarkovKernel κ
⊢ IsMarkovKernel (kernel.map κ Prod.snd (_ : Measurable Prod.snd))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsFiniteKernel κ
⊢ IsFiniteKernel (kernel.snd κ)
[PROOFSTEP]
rw [snd]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsFiniteKernel κ
⊢ IsFiniteKernel (kernel.map κ Prod.snd (_ : Measurable Prod.snd))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsSFiniteKernel κ
⊢ IsSFiniteKernel (kernel.snd κ)
[PROOFSTEP]
rw [snd]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α (β × γ) }
inst✝ : IsSFiniteKernel κ
⊢ IsSFiniteKernel (kernel.map κ Prod.snd (_ : Measurable Prod.snd))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
κ : { x // x ∈ kernel α β }
a : α
s : Set γ
hs : MeasurableSet s
⊢ ↑↑(↑(η ∘ₖ κ) a) s = ∫⁻ (b : β), ↑↑(↑η b) s ∂↑κ a
[PROOFSTEP]
rw [comp_apply, Measure.bind_apply hs (kernel.measurable _)]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
inst✝¹ : IsSFiniteKernel η
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
⊢ η ∘ₖ κ = snd (κ ⊗ₖ prodMkLeft α η)
[PROOFSTEP]
ext a s hs
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
inst✝¹ : IsSFiniteKernel η
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
a : α
s : Set γ
hs : MeasurableSet s
⊢ ↑↑(↑(η ∘ₖ κ) a) s = ↑↑(↑(snd (κ ⊗ₖ prodMkLeft α η)) a) s
[PROOFSTEP]
rw [comp_apply' _ _ _ hs, snd_apply' _ _ hs, compProd_apply]
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
inst✝¹ : IsSFiniteKernel η
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
a : α
s : Set γ
hs : MeasurableSet s
⊢ ∫⁻ (b : β), ↑↑(↑η b) s ∂↑κ a = ∫⁻ (b : β), ↑↑(↑(prodMkLeft α η) (a, b)) {c | (b, c) ∈ {p | p.snd ∈ s}} ∂↑κ a
case h.h.hs
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
inst✝¹ : IsSFiniteKernel η
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
a : α
s : Set γ
hs : MeasurableSet s
⊢ MeasurableSet {p | p.snd ∈ s}
[PROOFSTEP]
swap
[GOAL]
case h.h.hs
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
inst✝¹ : IsSFiniteKernel η
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
a : α
s : Set γ
hs : MeasurableSet s
⊢ MeasurableSet {p | p.snd ∈ s}
[PROOFSTEP]
exact measurable_snd hs
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
inst✝¹ : IsSFiniteKernel η
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
a : α
s : Set γ
hs : MeasurableSet s
⊢ ∫⁻ (b : β), ↑↑(↑η b) s ∂↑κ a = ∫⁻ (b : β), ↑↑(↑(prodMkLeft α η) (a, b)) {c | (b, c) ∈ {p | p.snd ∈ s}} ∂↑κ a
[PROOFSTEP]
simp only [Set.mem_setOf_eq, Set.setOf_mem_eq, prodMkLeft_apply' _ _ s]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g✝ : γ → α
η : { x // x ∈ kernel β γ }
κ : { x // x ∈ kernel α β }
a : α
g : γ → ℝ≥0∞
hg : Measurable g
⊢ ∫⁻ (c : γ), g c ∂↑(η ∘ₖ κ) a = ∫⁻ (b : β), ∫⁻ (c : γ), g c ∂↑η b ∂↑κ a
[PROOFSTEP]
rw [comp_apply, Measure.lintegral_bind (kernel.measurable _) hg]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
inst✝¹ : IsMarkovKernel η
κ : { x // x ∈ kernel α β }
inst✝ : IsMarkovKernel κ
⊢ IsMarkovKernel (η ∘ₖ κ)
[PROOFSTEP]
rw [comp_eq_snd_compProd]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
inst✝¹ : IsMarkovKernel η
κ : { x // x ∈ kernel α β }
inst✝ : IsMarkovKernel κ
⊢ IsMarkovKernel (kernel.snd (κ ⊗ₖ kernel.prodMkLeft α η))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
inst✝¹ : IsFiniteKernel η
κ : { x // x ∈ kernel α β }
inst✝ : IsFiniteKernel κ
⊢ IsFiniteKernel (η ∘ₖ κ)
[PROOFSTEP]
rw [comp_eq_snd_compProd]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
inst✝¹ : IsFiniteKernel η
κ : { x // x ∈ kernel α β }
inst✝ : IsFiniteKernel κ
⊢ IsFiniteKernel (kernel.snd (κ ⊗ₖ kernel.prodMkLeft α η))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
inst✝¹ : IsSFiniteKernel η
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
⊢ IsSFiniteKernel (η ∘ₖ κ)
[PROOFSTEP]
rw [comp_eq_snd_compProd]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
η : { x // x ∈ kernel β γ }
inst✝¹ : IsSFiniteKernel η
κ : { x // x ∈ kernel α β }
inst✝ : IsSFiniteKernel κ
⊢ IsSFiniteKernel (kernel.snd (κ ⊗ₖ kernel.prodMkLeft α η))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
δ : Type u_5
mδ : MeasurableSpace δ
ξ : { x // x ∈ kernel γ δ }
inst✝ : IsSFiniteKernel ξ
η : { x // x ∈ kernel β γ }
κ : { x // x ∈ kernel α β }
⊢ ξ ∘ₖ η ∘ₖ κ = ξ ∘ₖ (η ∘ₖ κ)
[PROOFSTEP]
refine' ext_fun fun a f hf => _
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f✝ : β → γ
g : γ → α
δ : Type u_5
mδ : MeasurableSpace δ
ξ : { x // x ∈ kernel γ δ }
inst✝ : IsSFiniteKernel ξ
η : { x // x ∈ kernel β γ }
κ : { x // x ∈ kernel α β }
a : α
f : δ → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (b : δ), f b ∂↑(ξ ∘ₖ η ∘ₖ κ) a = ∫⁻ (b : δ), f b ∂↑(ξ ∘ₖ (η ∘ₖ κ)) a
[PROOFSTEP]
simp_rw [lintegral_comp _ _ _ hf, lintegral_comp _ _ _ hf.lintegral_kernel]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
hf : Measurable f
κ : { x // x ∈ kernel α β }
⊢ deterministic f hf ∘ₖ κ = map κ f hf
[PROOFSTEP]
ext a s hs
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
hf : Measurable f
κ : { x // x ∈ kernel α β }
a : α
s : Set γ
hs : MeasurableSet s
⊢ ↑↑(↑(deterministic f hf ∘ₖ κ) a) s = ↑↑(↑(map κ f hf) a) s
[PROOFSTEP]
simp_rw [map_apply' _ _ _ hs, comp_apply' _ _ _ hs, deterministic_apply' hf _ hs, lintegral_indicator_const_comp hf hs,
  one_mul]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
hg : Measurable g
⊢ κ ∘ₖ deterministic g hg = comap κ g hg
[PROOFSTEP]
ext a s hs
[GOAL]
case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g : γ → α
κ : { x // x ∈ kernel α β }
hg : Measurable g
a : γ
s : Set β
hs : MeasurableSet s
⊢ ↑↑(↑(κ ∘ₖ deterministic g hg) a) s = ↑↑(↑(comap κ g hg) a) s
[PROOFSTEP]
simp_rw [comap_apply' _ _ _ s, comp_apply' _ _ _ hs, deterministic_apply hg a,
  lintegral_dirac' _ (kernel.measurable_coe κ hs)]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel α γ }
inst✝ : IsSFiniteKernel η
a : α
s : Set (β × γ)
hs : MeasurableSet s
⊢ ↑↑(↑(κ ×ₖ η) a) s = ∫⁻ (b : β), ↑↑(↑η a) {c | (b, c) ∈ s} ∂↑κ a
[PROOFSTEP]
simp_rw [prod, compProd_apply _ _ _ hs, swapLeft_apply _ _, prodMkLeft_apply, Prod.swap_prod_mk]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : { x // x ∈ kernel α β }
inst✝¹ : IsSFiniteKernel κ
η : { x // x ∈ kernel α γ }
inst✝ : IsSFiniteKernel η
a : α
g : β × γ → ℝ≥0∞
hg : Measurable g
⊢ ∫⁻ (c : β × γ), g c ∂↑(κ ×ₖ η) a = ∫⁻ (b : β), ∫⁻ (c : γ), g (b, c) ∂↑η a ∂↑κ a
[PROOFSTEP]
simp_rw [prod, lintegral_compProd _ _ _ hg, swapLeft_apply, prodMkLeft_apply, Prod.swap_prod_mk]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : { x // x ∈ kernel α β }
inst✝¹ : IsMarkovKernel κ
η : { x // x ∈ kernel α γ }
inst✝ : IsMarkovKernel η
⊢ IsMarkovKernel (κ ×ₖ η)
[PROOFSTEP]
rw [prod]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : { x // x ∈ kernel α β }
inst✝¹ : IsMarkovKernel κ
η : { x // x ∈ kernel α γ }
inst✝ : IsMarkovKernel η
⊢ IsMarkovKernel (κ ⊗ₖ kernel.swapLeft (kernel.prodMkLeft β η))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : { x // x ∈ kernel α β }
inst✝¹ : IsFiniteKernel κ
η : { x // x ∈ kernel α γ }
inst✝ : IsFiniteKernel η
⊢ IsFiniteKernel (κ ×ₖ η)
[PROOFSTEP]
rw [prod]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : { x // x ∈ kernel α β }
inst✝¹ : IsFiniteKernel κ
η : { x // x ∈ kernel α γ }
inst✝ : IsFiniteKernel η
⊢ IsFiniteKernel (κ ⊗ₖ kernel.swapLeft (kernel.prodMkLeft β η))
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel α γ }
⊢ IsSFiniteKernel (κ ×ₖ η)
[PROOFSTEP]
rw [prod]
[GOAL]
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : { x // x ∈ kernel α β }
η : { x // x ∈ kernel α γ }
⊢ IsSFiniteKernel (κ ⊗ₖ kernel.swapLeft (kernel.prodMkLeft β η))
[PROOFSTEP]
infer_instance
