Theorem: ProbabilityTheory.kernel.measurable_kernel_prod_mk_left_of_finite
File: Mathlib/Probability/Kernel/MeasurableIntegral.lean

tactic: refine MeasurableSpace.induction_on_inter
  (C := fun t => Measurable fun a => κ a (Prod.mk a ⁻¹' t))
  generateFrom_prod.symm isPiSystem_prod ?_ ?_ ?_ ?_ ht
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) ∅

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ ∀ t ∈ image2 (fun x x_1 => x ×ˢ x_1) {s | MeasurableSet s} {t | MeasurableSet t},
    (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) t

case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ ∀ (t : Set (α × β)),
    MeasurableSet t →
      (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) t →
        (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) tᶜ

case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ ∀ (f : ℕ → Set (α × β)),
    Pairwise (Disjoint on f) →
      (∀ (i : ℕ), MeasurableSet (f i)) →
        (∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)) →
          (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (⋃ i, f i)

tactic: simp only [preimage_empty, measure_empty, measurable_const]
state_before: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) ∅
state_after: no goals

tactic: intro t' ht'
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ ∀ t ∈ image2 (fun x x_1 => x ×ˢ x_1) {s | MeasurableSet s} {t | MeasurableSet t},
    (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) t
state_after: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : t' ∈ image2 (fun x x_1 => x ×ˢ x_1) {s | MeasurableSet s} {t | MeasurableSet t}
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')

tactic: simp only [Set.mem_image2, Set.mem_setOf_eq, exists_and_left] at ht'
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : t' ∈ image2 (fun x x_1 => x ×ˢ x_1) {s | MeasurableSet s} {t | MeasurableSet t}
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
state_after: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : ∃ a, MeasurableSet a ∧ ∃ b, MeasurableSet b ∧ a ×ˢ b = t'
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')

tactic: obtain ⟨t₁, ht₁, t₂, ht₂, rfl⟩ := ht'
state_before: case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : ∃ a, MeasurableSet a ∧ ∃ b, MeasurableSet b ∧ a ×ˢ b = t'
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
state_after: case refine_2.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t₁ ×ˢ t₂)

tactic: classical
simp_rw [mk_preimage_prod_right_eq_if]
have h_eq_ite : (fun a => κ a (ite (a ∈ t₁) t₂ ∅)) = fun a => ite (a ∈ t₁) (κ a t₂) 0 := by
  ext1 a
  split_ifs
  exacts [rfl, measure_empty]
rw [h_eq_ite]
exact Measurable.ite ht₁ (kernel.measurable_coe κ ht₂) measurable_const
state_before: case refine_2.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t₁ ×ˢ t₂)
state_after: no goals

tactic: simp_rw [mk_preimage_prod_right_eq_if]
state_before: case refine_2.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t₁ ×ˢ t₂)
state_after: case refine_2.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
⊢ Measurable fun a => (κ a) (if a ∈ t₁ then t₂ else ∅)

tactic: have h_eq_ite : (fun a => κ a (ite (a ∈ t₁) t₂ ∅)) = fun a => ite (a ∈ t₁) (κ a t₂) 0 := by
  ext1 a
  split_ifs
  exacts [rfl, measure_empty]
state_before: case refine_2.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
⊢ Measurable fun a => (κ a) (if a ∈ t₁ then t₂ else ∅)
state_after: case refine_2.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
h_eq_ite : (fun a => (κ a) (if a ∈ t₁ then t₂ else ∅)) = fun a => if a ∈ t₁ then (κ a) t₂ else 0
⊢ Measurable fun a => (κ a) (if a ∈ t₁ then t₂ else ∅)

tactic: rw [h_eq_ite]
state_before: case refine_2.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
h_eq_ite : (fun a => (κ a) (if a ∈ t₁ then t₂ else ∅)) = fun a => if a ∈ t₁ then (κ a) t₂ else 0
⊢ Measurable fun a => (κ a) (if a ∈ t₁ then t₂ else ∅)
state_after: case refine_2.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
h_eq_ite : (fun a => (κ a) (if a ∈ t₁ then t₂ else ∅)) = fun a => if a ∈ t₁ then (κ a) t₂ else 0
⊢ Measurable fun a => if a ∈ t₁ then (κ a) t₂ else 0

tactic: exact Measurable.ite ht₁ (kernel.measurable_coe κ ht₂) measurable_const
state_before: case refine_2.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
h_eq_ite : (fun a => (κ a) (if a ∈ t₁ then t₂ else ∅)) = fun a => if a ∈ t₁ then (κ a) t₂ else 0
⊢ Measurable fun a => if a ∈ t₁ then (κ a) t₂ else 0
state_after: no goals

tactic: ext1 a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
⊢ (fun a => (κ a) (if a ∈ t₁ then t₂ else ∅)) = fun a => if a ∈ t₁ then (κ a) t₂ else 0
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
a : α
⊢ (κ a) (if a ∈ t₁ then t₂ else ∅) = if a ∈ t₁ then (κ a) t₂ else 0

tactic: split_ifs
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
a : α
⊢ (κ a) (if a ∈ t₁ then t₂ else ∅) = if a ∈ t₁ then (κ a) t₂ else 0
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
a : α
h✝ : a ∈ t₁
⊢ (κ a) t₂ = (κ a) t₂

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
a : α
h✝ : a ∉ t₁
⊢ (κ a) ∅ = 0

tactic: exacts [rfl, measure_empty]
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
a : α
h✝ : a ∈ t₁
⊢ (κ a) t₂ = (κ a) t₂

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t₁ : Set α
ht₁ : MeasurableSet t₁
t₂ : Set β
ht₂ : MeasurableSet t₂
a : α
h✝ : a ∉ t₁
⊢ (κ a) ∅ = 0
state_after: no goals

tactic: intro t' ht' h_meas
state_before: case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ ∀ (t : Set (α × β)),
    MeasurableSet t →
      (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) t →
        (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) tᶜ
state_after: case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t'ᶜ)

tactic: have h_eq_sdiff : ∀ a, Prod.mk a ⁻¹' t'ᶜ = Set.univ \ Prod.mk a ⁻¹' t' := by
  intro a
  ext1 b
  simp only [mem_compl_iff, mem_preimage, mem_diff, mem_univ, true_and_iff]
state_before: case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t'ᶜ)
state_after: case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t'ᶜ)

tactic: simp_rw [h_eq_sdiff]
state_before: case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t'ᶜ)
state_after: case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
⊢ Measurable fun a => (κ a) (univ \ Prod.mk a ⁻¹' t')

tactic: rw [this]
state_before: case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
this : (fun a => (κ a) (univ \ Prod.mk a ⁻¹' t')) = fun a => (κ a) univ - (κ a) (Prod.mk a ⁻¹' t')
⊢ Measurable fun a => (κ a) (univ \ Prod.mk a ⁻¹' t')
state_after: case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
this : (fun a => (κ a) (univ \ Prod.mk a ⁻¹' t')) = fun a => (κ a) univ - (κ a) (Prod.mk a ⁻¹' t')
⊢ Measurable fun a => (κ a) univ - (κ a) (Prod.mk a ⁻¹' t')

tactic: exact Measurable.sub (kernel.measurable_coe κ MeasurableSet.univ) h_meas
state_before: case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
this : (fun a => (κ a) (univ \ Prod.mk a ⁻¹' t')) = fun a => (κ a) univ - (κ a) (Prod.mk a ⁻¹' t')
⊢ Measurable fun a => (κ a) univ - (κ a) (Prod.mk a ⁻¹' t')
state_after: no goals

tactic: intro a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
⊢ ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
a : α
⊢ Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'

tactic: ext1 b
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
a : α
⊢ Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
a : α
b : β
⊢ b ∈ Prod.mk a ⁻¹' t'ᶜ ↔ b ∈ univ \ Prod.mk a ⁻¹' t'

tactic: simp only [mem_compl_iff, mem_preimage, mem_diff, mem_univ, true_and_iff]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
a : α
b : β
⊢ b ∈ Prod.mk a ⁻¹' t'ᶜ ↔ b ∈ univ \ Prod.mk a ⁻¹' t'
state_after: no goals

tactic: ext1 a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
⊢ (fun a => (κ a) (univ \ Prod.mk a ⁻¹' t')) = fun a => (κ a) univ - (κ a) (Prod.mk a ⁻¹' t')
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
a : α
⊢ (κ a) (univ \ Prod.mk a ⁻¹' t') = (κ a) univ - (κ a) (Prod.mk a ⁻¹' t')

tactic: rw [← Set.diff_inter_self_eq_diff, Set.inter_univ, measure_diff (Set.subset_univ _)]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
a : α
⊢ (κ a) (univ \ Prod.mk a ⁻¹' t') = (κ a) univ - (κ a) (Prod.mk a ⁻¹' t')
state_after: case h.h₂
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
a : α
⊢ MeasurableSet (Prod.mk a ⁻¹' t')

case h.h_fin
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
a : α
⊢ (κ a) (Prod.mk a ⁻¹' t') ≠ ⊤

tactic: exact (@measurable_prod_mk_left α β _ _ a) ht'
state_before: case h.h₂
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
a : α
⊢ MeasurableSet (Prod.mk a ⁻¹' t')
state_after: no goals

tactic: exact measure_ne_top _ _
state_before: case h.h_fin
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
t' : Set (α × β)
ht' : MeasurableSet t'
h_meas : Measurable fun a => (κ a) (Prod.mk a ⁻¹' t')
h_eq_sdiff : ∀ (a : α), Prod.mk a ⁻¹' t'ᶜ = univ \ Prod.mk a ⁻¹' t'
a : α
⊢ (κ a) (Prod.mk a ⁻¹' t') ≠ ⊤
state_after: no goals

tactic: intro f h_disj hf_meas hf
state_before: case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ ∀ (f : ℕ → Set (α × β)),
    Pairwise (Disjoint on f) →
      (∀ (i : ℕ), MeasurableSet (f i)) →
        (∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)) →
          (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (⋃ i, f i)
state_after: case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)

tactic: have h_Union :
  (fun a => κ a (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => κ a (⋃ i, Prod.mk a ⁻¹' f i) := by
  ext1 a
  congr with b
  simp only [mem_iUnion, mem_preimage]
state_before: case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)
state_after: case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)

tactic: rw [h_Union]
state_before: case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)
state_after: case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
⊢ Measurable fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)

tactic: rw [h_tsum]
state_before: case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
h_tsum : (fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)) = fun a => ∑' (i : ℕ), (κ a) (Prod.mk a ⁻¹' f i)
⊢ Measurable fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
state_after: case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
h_tsum : (fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)) = fun a => ∑' (i : ℕ), (κ a) (Prod.mk a ⁻¹' f i)
⊢ Measurable fun a => ∑' (i : ℕ), (κ a) (Prod.mk a ⁻¹' f i)

tactic: exact Measurable.ennreal_tsum hf
state_before: case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
h_tsum : (fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)) = fun a => ∑' (i : ℕ), (κ a) (Prod.mk a ⁻¹' f i)
⊢ Measurable fun a => ∑' (i : ℕ), (κ a) (Prod.mk a ⁻¹' f i)
state_after: no goals

tactic: ext1 a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
⊢ (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
a : α
⊢ (κ a) (Prod.mk a ⁻¹' ⋃ i, f i) = (κ a) (⋃ i, Prod.mk a ⁻¹' f i)

tactic: congr with b
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
a : α
⊢ (κ a) (Prod.mk a ⁻¹' ⋃ i, f i) = (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
state_after: case h.h.e_6.h.h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
a : α
b : β
⊢ b ∈ Prod.mk a ⁻¹' ⋃ i, f i ↔ b ∈ ⋃ i, Prod.mk a ⁻¹' f i

tactic: simp only [mem_iUnion, mem_preimage]
state_before: case h.h.e_6.h.h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
a : α
b : β
⊢ b ∈ Prod.mk a ⁻¹' ⋃ i, f i ↔ b ∈ ⋃ i, Prod.mk a ⁻¹' f i
state_after: no goals

tactic: ext1 a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
⊢ (fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)) = fun a => ∑' (i : ℕ), (κ a) (Prod.mk a ⁻¹' f i)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
⊢ (κ a) (⋃ i, Prod.mk a ⁻¹' f i) = ∑' (i : ℕ), (κ a) (Prod.mk a ⁻¹' f i)

tactic: rw [measure_iUnion]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
⊢ (κ a) (⋃ i, Prod.mk a ⁻¹' f i) = ∑' (i : ℕ), (κ a) (Prod.mk a ⁻¹' f i)
state_after: case h.hn
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
⊢ Pairwise (Disjoint on fun i => Prod.mk a ⁻¹' f i)

case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
⊢ ∀ (i : ℕ), MeasurableSet (Prod.mk a ⁻¹' f i)

tactic: intro i j hij s hsi hsj b hbs
state_before: case h.hn
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
⊢ Pairwise (Disjoint on fun i => Prod.mk a ⁻¹' f i)
state_after: case h.hn
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
i j : ℕ
hij : i ≠ j
s : Set β
hsi : s ≤ (fun i => Prod.mk a ⁻¹' f i) i
hsj : s ≤ (fun i => Prod.mk a ⁻¹' f i) j
b : β
hbs : b ∈ s
⊢ b ∈ ⊥

tactic: have habi : {(a, b)} ⊆ f i := by rw [Set.singleton_subset_iff]; exact hsi hbs
state_before: case h.hn
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
i j : ℕ
hij : i ≠ j
s : Set β
hsi : s ≤ (fun i => Prod.mk a ⁻¹' f i) i
hsj : s ≤ (fun i => Prod.mk a ⁻¹' f i) j
b : β
hbs : b ∈ s
⊢ b ∈ ⊥
state_after: case h.hn
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
i j : ℕ
hij : i ≠ j
s : Set β
hsi : s ≤ (fun i => Prod.mk a ⁻¹' f i) i
hsj : s ≤ (fun i => Prod.mk a ⁻¹' f i) j
b : β
hbs : b ∈ s
habi : {(a, b)} ⊆ f i
⊢ b ∈ ⊥

tactic: have habj : {(a, b)} ⊆ f j := by rw [Set.singleton_subset_iff]; exact hsj hbs
state_before: case h.hn
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
i j : ℕ
hij : i ≠ j
s : Set β
hsi : s ≤ (fun i => Prod.mk a ⁻¹' f i) i
hsj : s ≤ (fun i => Prod.mk a ⁻¹' f i) j
b : β
hbs : b ∈ s
habi : {(a, b)} ⊆ f i
⊢ b ∈ ⊥
state_after: case h.hn
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
i j : ℕ
hij : i ≠ j
s : Set β
hsi : s ≤ (fun i => Prod.mk a ⁻¹' f i) i
hsj : s ≤ (fun i => Prod.mk a ⁻¹' f i) j
b : β
hbs : b ∈ s
habi : {(a, b)} ⊆ f i
habj : {(a, b)} ⊆ f j
⊢ b ∈ ⊥

tactic: simpa only [Set.bot_eq_empty, Set.le_eq_subset, Set.singleton_subset_iff,
  Set.mem_empty_iff_false] using h_disj hij habi habj
state_before: case h.hn
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
i j : ℕ
hij : i ≠ j
s : Set β
hsi : s ≤ (fun i => Prod.mk a ⁻¹' f i) i
hsj : s ≤ (fun i => Prod.mk a ⁻¹' f i) j
b : β
hbs : b ∈ s
habi : {(a, b)} ⊆ f i
habj : {(a, b)} ⊆ f j
⊢ b ∈ ⊥
state_after: no goals

tactic: rw [Set.singleton_subset_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
i j : ℕ
hij : i ≠ j
s : Set β
hsi : s ≤ (fun i => Prod.mk a ⁻¹' f i) i
hsj : s ≤ (fun i => Prod.mk a ⁻¹' f i) j
b : β
hbs : b ∈ s
⊢ {(a, b)} ⊆ f i
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
i j : ℕ
hij : i ≠ j
s : Set β
hsi : s ≤ (fun i => Prod.mk a ⁻¹' f i) i
hsj : s ≤ (fun i => Prod.mk a ⁻¹' f i) j
b : β
hbs : b ∈ s
⊢ (a, b) ∈ f i

tactic: exact hsi hbs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
i j : ℕ
hij : i ≠ j
s : Set β
hsi : s ≤ (fun i => Prod.mk a ⁻¹' f i) i
hsj : s ≤ (fun i => Prod.mk a ⁻¹' f i) j
b : β
hbs : b ∈ s
⊢ (a, b) ∈ f i
state_after: no goals

tactic: rw [Set.singleton_subset_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
i j : ℕ
hij : i ≠ j
s : Set β
hsi : s ≤ (fun i => Prod.mk a ⁻¹' f i) i
hsj : s ≤ (fun i => Prod.mk a ⁻¹' f i) j
b : β
hbs : b ∈ s
habi : {(a, b)} ⊆ f i
⊢ {(a, b)} ⊆ f j
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
i j : ℕ
hij : i ≠ j
s : Set β
hsi : s ≤ (fun i => Prod.mk a ⁻¹' f i) i
hsj : s ≤ (fun i => Prod.mk a ⁻¹' f i) j
b : β
hbs : b ∈ s
habi : {(a, b)} ⊆ f i
⊢ (a, b) ∈ f j

tactic: exact hsj hbs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
i j : ℕ
hij : i ≠ j
s : Set β
hsi : s ≤ (fun i => Prod.mk a ⁻¹' f i) i
hsj : s ≤ (fun i => Prod.mk a ⁻¹' f i) j
b : β
hbs : b ∈ s
habi : {(a, b)} ⊆ f i
⊢ (a, b) ∈ f j
state_after: no goals

tactic: exact fun i => (@measurable_prod_mk_left α β _ _ a) (hf_meas i)
state_before: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : ↥(kernel α β)
η : ↥(kernel (α × β) γ)
a✝ : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
f : ℕ → Set (α × β)
h_disj : Pairwise (Disjoint on f)
hf_meas : ∀ (i : ℕ), MeasurableSet (f i)
hf : ∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)
h_Union : (fun a => (κ a) (Prod.mk a ⁻¹' ⋃ i, f i)) = fun a => (κ a) (⋃ i, Prod.mk a ⁻¹' f i)
a : α
⊢ ∀ (i : ℕ), MeasurableSet (Prod.mk a ⁻¹' f i)
state_after: no goals