l3lab/ntp-mathlib huggingface dataset:
instance prod.instIsOpenPosMeasure {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
    {m : MeasurableSpace X} {μ : Measure X} [IsOpenPosMeasure μ] {m' : MeasurableSpace Y}
    {ν : Measure Y} [IsOpenPosMeasure ν] [SFinite ν] : IsOpenPosMeasure (μ.prod ν) := by
  constructor
  rintro U U_open ⟨⟨x, y⟩, hxy⟩
  

Proof state:
case open_pos.intro.mk
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α
ν✝ ν' : Measure β
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
X : Type u_7
Y : Type u_8
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
m : MeasurableSpace X
μ : Measure X
inst✝² : IsOpenPosMeasure μ
m' : MeasurableSpace Y
ν : Measure Y
inst✝¹ : IsOpenPosMeasure ν
inst✝ : SFinite ν
U : Set (X × Y)
U_open : IsOpen U
x : X
y : Y
hxy : (x, y) ∈ U
⊢ ↑↑(Measure.prod μ ν) U ≠ 0

Next tactic:
rcases isOpen_prod_iff.1 U_open x y hxy with ⟨u, v, u_open, v_open, xu, yv, huv⟩
instance prod.instIsOpenPosMeasure {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
    {m : MeasurableSpace X} {μ : Measure X} [IsOpenPosMeasure μ] {m' : MeasurableSpace Y}
    {ν : Measure Y} [IsOpenPosMeasure ν] [SFinite ν] : IsOpenPosMeasure (μ.prod ν) := by
  constructor
  rintro U U_open ⟨⟨x, y⟩, hxy⟩
  rcases isOpen_prod_iff.1 U_open x y hxy with ⟨u, v, u_open, v_open, xu, yv, huv⟩
  

Proof state:
case open_pos.intro.mk.intro.intro.intro.intro.intro.intro
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α
ν✝ ν' : Measure β
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
X : Type u_7
Y : Type u_8
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
m : MeasurableSpace X
μ : Measure X
inst✝² : IsOpenPosMeasure μ
m' : MeasurableSpace Y
ν : Measure Y
inst✝¹ : IsOpenPosMeasure ν
inst✝ : SFinite ν
U : Set (X × Y)
U_open : IsOpen U
x : X
y : Y
hxy : (x, y) ∈ U
u : Set X
v : Set Y
u_open : IsOpen u
v_open : IsOpen v
xu : x ∈ u
yv : y ∈ v
huv : u ×ˢ v ⊆ U
⊢ ↑↑(Measure.prod μ ν) U ≠ 0

Next tactic:
refine' ne_of_gt (lt_of_lt_of_le _ (measure_mono huv))
instance prod.instIsOpenPosMeasure {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
    {m : MeasurableSpace X} {μ : Measure X} [IsOpenPosMeasure μ] {m' : MeasurableSpace Y}
    {ν : Measure Y} [IsOpenPosMeasure ν] [SFinite ν] : IsOpenPosMeasure (μ.prod ν) := by
  constructor
  rintro U U_open ⟨⟨x, y⟩, hxy⟩
  rcases isOpen_prod_iff.1 U_open x y hxy with ⟨u, v, u_open, v_open, xu, yv, huv⟩
  refine' ne_of_gt (lt_of_lt_of_le _ (measure_mono huv))
  

Proof state:
case open_pos.intro.mk.intro.intro.intro.intro.intro.intro
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α
ν✝ ν' : Measure β
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
X : Type u_7
Y : Type u_8
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
m : MeasurableSpace X
μ : Measure X
inst✝² : IsOpenPosMeasure μ
m' : MeasurableSpace Y
ν : Measure Y
inst✝¹ : IsOpenPosMeasure ν
inst✝ : SFinite ν
U : Set (X × Y)
U_open : IsOpen U
x : X
y : Y
hxy : (x, y) ∈ U
u : Set X
v : Set Y
u_open : IsOpen u
v_open : IsOpen v
xu : x ∈ u
yv : y ∈ v
huv : u ×ˢ v ⊆ U
⊢ 0 < ↑↑(Measure.prod μ ν) (u ×ˢ v)

Next tactic:
simp only [prod_prod, CanonicallyOrderedCommSemiring.mul_pos]
instance prod.instIsOpenPosMeasure {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
    {m : MeasurableSpace X} {μ : Measure X} [IsOpenPosMeasure μ] {m' : MeasurableSpace Y}
    {ν : Measure Y} [IsOpenPosMeasure ν] [SFinite ν] : IsOpenPosMeasure (μ.prod ν) := by
  constructor
  rintro U U_open ⟨⟨x, y⟩, hxy⟩
  rcases isOpen_prod_iff.1 U_open x y hxy with ⟨u, v, u_open, v_open, xu, yv, huv⟩
  refine' ne_of_gt (lt_of_lt_of_le _ (measure_mono huv))
  simp only [prod_prod, CanonicallyOrderedCommSemiring.mul_pos]
  

Proof state:
case open_pos.intro.mk.intro.intro.intro.intro.intro.intro
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α
ν✝ ν' : Measure β
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
X : Type u_7
Y : Type u_8
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
m : MeasurableSpace X
μ : Measure X
inst✝² : IsOpenPosMeasure μ
m' : MeasurableSpace Y
ν : Measure Y
inst✝¹ : IsOpenPosMeasure ν
inst✝ : SFinite ν
U : Set (X × Y)
U_open : IsOpen U
x : X
y : Y
hxy : (x, y) ∈ U
u : Set X
v : Set Y
u_open : IsOpen u
v_open : IsOpen v
xu : x ∈ u
yv : y ∈ v
huv : u ×ˢ v ⊆ U
⊢ 0 < ↑↑μ u ∧ 0 < ↑↑ν v

Next tactic:
constructor
instance prod.instIsOpenPosMeasure {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
    {m : MeasurableSpace X} {μ : Measure X} [IsOpenPosMeasure μ] {m' : MeasurableSpace Y}
    {ν : Measure Y} [IsOpenPosMeasure ν] [SFinite ν] : IsOpenPosMeasure (μ.prod ν) := by
  constructor
  rintro U U_open ⟨⟨x, y⟩, hxy⟩
  rcases isOpen_prod_iff.1 U_open x y hxy with ⟨u, v, u_open, v_open, xu, yv, huv⟩
  refine' ne_of_gt (lt_of_lt_of_le _ (measure_mono huv))
  simp only [prod_prod, CanonicallyOrderedCommSemiring.mul_pos]
  constructor
  · 

Proof state:
case open_pos.intro.mk.intro.intro.intro.intro.intro.intro.left
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α
ν✝ ν' : Measure β
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
X : Type u_7
Y : Type u_8
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
m : MeasurableSpace X
μ : Measure X
inst✝² : IsOpenPosMeasure μ
m' : MeasurableSpace Y
ν : Measure Y
inst✝¹ : IsOpenPosMeasure ν
inst✝ : SFinite ν
U : Set (X × Y)
U_open : IsOpen U
x : X
y : Y
hxy : (x, y) ∈ U
u : Set X
v : Set Y
u_open : IsOpen u
v_open : IsOpen v
xu : x ∈ u
yv : y ∈ v
huv : u ×ˢ v ⊆ U
⊢ 0 < ↑↑μ u

Next tactic:
exact u_open.measure_pos μ ⟨x, xu⟩
instance prod.instIsOpenPosMeasure {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
    {m : MeasurableSpace X} {μ : Measure X} [IsOpenPosMeasure μ] {m' : MeasurableSpace Y}
    {ν : Measure Y} [IsOpenPosMeasure ν] [SFinite ν] : IsOpenPosMeasure (μ.prod ν) := by
  constructor
  rintro U U_open ⟨⟨x, y⟩, hxy⟩
  rcases isOpen_prod_iff.1 U_open x y hxy with ⟨u, v, u_open, v_open, xu, yv, huv⟩
  refine' ne_of_gt (lt_of_lt_of_le _ (measure_mono huv))
  simp only [prod_prod, CanonicallyOrderedCommSemiring.mul_pos]
  constructor
  · exact u_open.measure_pos μ ⟨x, xu⟩
  · 

Proof state:
case open_pos.intro.mk.intro.intro.intro.intro.intro.intro.right
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α
ν✝ ν' : Measure β
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
X : Type u_7
Y : Type u_8
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
m : MeasurableSpace X
μ : Measure X
inst✝² : IsOpenPosMeasure μ
m' : MeasurableSpace Y
ν : Measure Y
inst✝¹ : IsOpenPosMeasure ν
inst✝ : SFinite ν
U : Set (X × Y)
U_open : IsOpen U
x : X
y : Y
hxy : (x, y) ∈ U
u : Set X
v : Set Y
u_open : IsOpen u
v_open : IsOpen v
xu : x ∈ u
yv : y ∈ v
huv : u ×ˢ v ⊆ U
⊢ 0 < ↑↑ν v

Next tactic:
exact v_open.measure_pos ν ⟨y, yv⟩
instance prod.instIsFiniteMeasure {α β : Type*} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
    (μ : Measure α) (ν : Measure β) [IsFiniteMeasure μ] [IsFiniteMeasure ν] :
    IsFiniteMeasure (μ.prod ν) := by
  

Proof state:
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁸ : MeasurableSpace α✝
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β✝
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝³ : NormedAddCommGroup E
inst✝² : SFinite ν✝
α : Type u_7
β : Type u_8
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
⊢ IsFiniteMeasure (Measure.prod μ ν)

Next tactic:
constructor
instance prod.instIsFiniteMeasure {α β : Type*} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
    (μ : Measure α) (ν : Measure β) [IsFiniteMeasure μ] [IsFiniteMeasure ν] :
    IsFiniteMeasure (μ.prod ν) := by
  constructor
  

Proof state:
case measure_univ_lt_top
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁸ : MeasurableSpace α✝
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β✝
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝³ : NormedAddCommGroup E
inst✝² : SFinite ν✝
α : Type u_7
β : Type u_8
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
⊢ ↑↑(Measure.prod μ ν) univ < ⊤

Next tactic:
rw [← univ_prod_univ, prod_prod]
instance prod.instIsFiniteMeasure {α β : Type*} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
    (μ : Measure α) (ν : Measure β) [IsFiniteMeasure μ] [IsFiniteMeasure ν] :
    IsFiniteMeasure (μ.prod ν) := by
  constructor
  rw [← univ_prod_univ, prod_prod]
  

Proof state:
case measure_univ_lt_top
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁸ : MeasurableSpace α✝
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β✝
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝³ : NormedAddCommGroup E
inst✝² : SFinite ν✝
α : Type u_7
β : Type u_8
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝¹ : IsFiniteMeasure μ
inst✝ : IsFiniteMeasure ν
⊢ ↑↑μ univ * ↑↑ν univ < ⊤

Next tactic:
exact mul_lt_top (measure_lt_top _ _).ne (measure_lt_top _ _).ne
instance prod.instIsProbabilityMeasure {α β : Type*} {mα : MeasurableSpace α}
    {mβ : MeasurableSpace β} (μ : Measure α) (ν : Measure β) [IsProbabilityMeasure μ]
    [IsProbabilityMeasure ν] : IsProbabilityMeasure (μ.prod ν) :=
  ⟨by 

Proof state:
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁸ : MeasurableSpace α✝
inst✝⁷ : MeasurableSpace α'
inst✝⁶ : MeasurableSpace β✝
inst✝⁵ : MeasurableSpace β'
inst✝⁴ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝³ : NormedAddCommGroup E
inst✝² : SFinite ν✝
α : Type u_7
β : Type u_8
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝¹ : IsProbabilityMeasure μ
inst✝ : IsProbabilityMeasure ν
⊢ ↑↑(Measure.prod μ ν) univ = 1

Next tactic:
rw [← univ_prod_univ, prod_prod, measure_univ, measure_univ, mul_one]
instance prod.instIsFiniteMeasureOnCompacts {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
    {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : Measure α) (ν : Measure β)
    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] [SFinite ν] :
    IsFiniteMeasureOnCompacts (μ.prod ν) := by
  

Proof state:
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α✝
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β✝
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
α : Type u_7
β : Type u_8
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝² : IsFiniteMeasureOnCompacts μ
inst✝¹ : IsFiniteMeasureOnCompacts ν
inst✝ : SFinite ν
⊢ IsFiniteMeasureOnCompacts (Measure.prod μ ν)

Next tactic:
refine' ⟨fun K hK => _⟩
instance prod.instIsFiniteMeasureOnCompacts {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
    {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : Measure α) (ν : Measure β)
    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] [SFinite ν] :
    IsFiniteMeasureOnCompacts (μ.prod ν) := by
  refine' ⟨fun K hK => _⟩
  

Proof state:
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α✝
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β✝
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
α : Type u_7
β : Type u_8
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝² : IsFiniteMeasureOnCompacts μ
inst✝¹ : IsFiniteMeasureOnCompacts ν
inst✝ : SFinite ν
K : Set (α × β)
hK : IsCompact K
⊢ ↑↑(Measure.prod μ ν) K < ⊤

Next tactic:
set L := (Prod.fst '' K) ×ˢ (Prod.snd '' K) with hL
instance prod.instIsFiniteMeasureOnCompacts {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
    {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : Measure α) (ν : Measure β)
    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] [SFinite ν] :
    IsFiniteMeasureOnCompacts (μ.prod ν) := by
  refine' ⟨fun K hK => _⟩
  set L := (Prod.fst '' K) ×ˢ (Prod.snd '' K) with hL
  

Proof state:
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α✝
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β✝
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
α : Type u_7
β : Type u_8
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝² : IsFiniteMeasureOnCompacts μ
inst✝¹ : IsFiniteMeasureOnCompacts ν
inst✝ : SFinite ν
K : Set (α × β)
hK : IsCompact K
L : Set (α × β) := (Prod.fst '' K) ×ˢ (Prod.snd '' K)
hL : L = (Prod.fst '' K) ×ˢ (Prod.snd '' K)
⊢ ↑↑(Measure.prod μ ν) K < ⊤

Next tactic:
have : K ⊆ L := by
    rintro ⟨x, y⟩ hxy
    simp only [prod_mk_mem_set_prod_eq, mem_image, Prod.exists, exists_and_right, exists_eq_right]
    exact ⟨⟨y, hxy⟩, ⟨x, hxy⟩⟩
instance prod.instIsFiniteMeasureOnCompacts {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
    {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : Measure α) (ν : Measure β)
    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] [SFinite ν] :
    IsFiniteMeasureOnCompacts (μ.prod ν) := by
  refine' ⟨fun K hK => _⟩
  set L := (Prod.fst '' K) ×ˢ (Prod.snd '' K) with hL
  have : K ⊆ L := by
    

Proof state:
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α✝
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β✝
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
α : Type u_7
β : Type u_8
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝² : IsFiniteMeasureOnCompacts μ
inst✝¹ : IsFiniteMeasureOnCompacts ν
inst✝ : SFinite ν
K : Set (α × β)
hK : IsCompact K
L : Set (α × β) := (Prod.fst '' K) ×ˢ (Prod.snd '' K)
hL : L = (Prod.fst '' K) ×ˢ (Prod.snd '' K)
⊢ K ⊆ L

Next tactic:
rintro ⟨x, y⟩ hxy
instance prod.instIsFiniteMeasureOnCompacts {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
    {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : Measure α) (ν : Measure β)
    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] [SFinite ν] :
    IsFiniteMeasureOnCompacts (μ.prod ν) := by
  refine' ⟨fun K hK => _⟩
  set L := (Prod.fst '' K) ×ˢ (Prod.snd '' K) with hL
  have : K ⊆ L := by
    rintro ⟨x, y⟩ hxy
    

Proof state:
case mk
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α✝
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β✝
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
α : Type u_7
β : Type u_8
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝² : IsFiniteMeasureOnCompacts μ
inst✝¹ : IsFiniteMeasureOnCompacts ν
inst✝ : SFinite ν
K : Set (α × β)
hK : IsCompact K
L : Set (α × β) := (Prod.fst '' K) ×ˢ (Prod.snd '' K)
hL : L = (Prod.fst '' K) ×ˢ (Prod.snd '' K)
x : α
y : β
hxy : (x, y) ∈ K
⊢ (x, y) ∈ L

Next tactic:
simp only [prod_mk_mem_set_prod_eq, mem_image, Prod.exists, exists_and_right, exists_eq_right]
instance prod.instIsFiniteMeasureOnCompacts {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
    {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : Measure α) (ν : Measure β)
    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] [SFinite ν] :
    IsFiniteMeasureOnCompacts (μ.prod ν) := by
  refine' ⟨fun K hK => _⟩
  set L := (Prod.fst '' K) ×ˢ (Prod.snd '' K) with hL
  have : K ⊆ L := by
    rintro ⟨x, y⟩ hxy
    simp only [prod_mk_mem_set_prod_eq, mem_image, Prod.exists, exists_and_right, exists_eq_right]
    

Proof state:
case mk
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α✝
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β✝
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
α : Type u_7
β : Type u_8
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝² : IsFiniteMeasureOnCompacts μ
inst✝¹ : IsFiniteMeasureOnCompacts ν
inst✝ : SFinite ν
K : Set (α × β)
hK : IsCompact K
L : Set (α × β) := (Prod.fst '' K) ×ˢ (Prod.snd '' K)
hL : L = (Prod.fst '' K) ×ˢ (Prod.snd '' K)
x : α
y : β
hxy : (x, y) ∈ K
⊢ (∃ x_1, (x, x_1) ∈ K) ∧ ∃ a, (a, y) ∈ K

Next tactic:
exact ⟨⟨y, hxy⟩, ⟨x, hxy⟩⟩
instance prod.instIsFiniteMeasureOnCompacts {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
    {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : Measure α) (ν : Measure β)
    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] [SFinite ν] :
    IsFiniteMeasureOnCompacts (μ.prod ν) := by
  refine' ⟨fun K hK => _⟩
  set L := (Prod.fst '' K) ×ˢ (Prod.snd '' K) with hL
  have : K ⊆ L := by
    rintro ⟨x, y⟩ hxy
    simp only [prod_mk_mem_set_prod_eq, mem_image, Prod.exists, exists_and_right, exists_eq_right]
    exact ⟨⟨y, hxy⟩, ⟨x, hxy⟩⟩
  

Proof state:
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α✝
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β✝
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
α : Type u_7
β : Type u_8
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝² : IsFiniteMeasureOnCompacts μ
inst✝¹ : IsFiniteMeasureOnCompacts ν
inst✝ : SFinite ν
K : Set (α × β)
hK : IsCompact K
L : Set (α × β) := (Prod.fst '' K) ×ˢ (Prod.snd '' K)
hL : L = (Prod.fst '' K) ×ˢ (Prod.snd '' K)
this : K ⊆ L
⊢ ↑↑(Measure.prod μ ν) K < ⊤

Next tactic:
apply lt_of_le_of_lt (measure_mono this)
instance prod.instIsFiniteMeasureOnCompacts {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
    {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : Measure α) (ν : Measure β)
    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] [SFinite ν] :
    IsFiniteMeasureOnCompacts (μ.prod ν) := by
  refine' ⟨fun K hK => _⟩
  set L := (Prod.fst '' K) ×ˢ (Prod.snd '' K) with hL
  have : K ⊆ L := by
    rintro ⟨x, y⟩ hxy
    simp only [prod_mk_mem_set_prod_eq, mem_image, Prod.exists, exists_and_right, exists_eq_right]
    exact ⟨⟨y, hxy⟩, ⟨x, hxy⟩⟩
  apply lt_of_le_of_lt (measure_mono this)
  

Proof state:
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α✝
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β✝
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
α : Type u_7
β : Type u_8
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝² : IsFiniteMeasureOnCompacts μ
inst✝¹ : IsFiniteMeasureOnCompacts ν
inst✝ : SFinite ν
K : Set (α × β)
hK : IsCompact K
L : Set (α × β) := (Prod.fst '' K) ×ˢ (Prod.snd '' K)
hL : L = (Prod.fst '' K) ×ˢ (Prod.snd '' K)
this : K ⊆ L
⊢ ↑↑(Measure.prod μ ν) L < ⊤

Next tactic:
rw [hL, prod_prod]
instance prod.instIsFiniteMeasureOnCompacts {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
    {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : Measure α) (ν : Measure β)
    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] [SFinite ν] :
    IsFiniteMeasureOnCompacts (μ.prod ν) := by
  refine' ⟨fun K hK => _⟩
  set L := (Prod.fst '' K) ×ˢ (Prod.snd '' K) with hL
  have : K ⊆ L := by
    rintro ⟨x, y⟩ hxy
    simp only [prod_mk_mem_set_prod_eq, mem_image, Prod.exists, exists_and_right, exists_eq_right]
    exact ⟨⟨y, hxy⟩, ⟨x, hxy⟩⟩
  apply lt_of_le_of_lt (measure_mono this)
  rw [hL, prod_prod]
  

Proof state:
α✝ : Type u_1
α' : Type u_2
β✝ : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α✝
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β✝
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ✝ μ' : Measure α✝
ν✝ ν' : Measure β✝
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν✝
α : Type u_7
β : Type u_8
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
ν : Measure β
inst✝² : IsFiniteMeasureOnCompacts μ
inst✝¹ : IsFiniteMeasureOnCompacts ν
inst✝ : SFinite ν
K : Set (α × β)
hK : IsCompact K
L : Set (α × β) := (Prod.fst '' K) ×ˢ (Prod.snd '' K)
hL : L = (Prod.fst '' K) ×ˢ (Prod.snd '' K)
this : K ⊆ L
⊢ ↑↑μ (Prod.fst '' K) * ↑↑ν (Prod.snd '' K) < ⊤

Next tactic:
exact
    mul_lt_top (IsCompact.measure_lt_top (hK.image continuous_fst)).ne
      (IsCompact.measure_lt_top (hK.image continuous_snd)).ne
instance prod.instNoAtoms_fst [NoAtoms μ] :
    NoAtoms (Measure.prod μ ν) := by
  

Proof state:
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : NoAtoms μ
⊢ NoAtoms (Measure.prod μ ν)

Next tactic:
refine NoAtoms.mk (fun x => ?_)
instance prod.instNoAtoms_fst [NoAtoms μ] :
    NoAtoms (Measure.prod μ ν) := by
  refine NoAtoms.mk (fun x => ?_)
  

Proof state:
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : NoAtoms μ
x : α × β
⊢ ↑↑(Measure.prod μ ν) {x} = 0

Next tactic:
rw [← Set.singleton_prod_singleton, Measure.prod_prod, measure_singleton, zero_mul]
instance prod.instNoAtoms_snd [NoAtoms ν] :
    NoAtoms (Measure.prod μ ν) := by
  

Proof state:
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : NoAtoms ν
⊢ NoAtoms (Measure.prod μ ν)

Next tactic:
refine NoAtoms.mk (fun x => ?_)