l3lab/ntp-mathlib huggingface dataset:
theorem atBot_le_nhds_bot {α : Type*} [TopologicalSpace α] [LinearOrder α] [OrderBot α]
    [OrderTopology α] : (atBot : Filter α) ≤ 𝓝 ⊥ := by
  cases subsingleton_or_nontrivial α
  · simp only [nhds_discrete, le_pure_iff, mem_atBot_sets, mem_singleton_iff,
      eq_iff_true_of_subsingleton, imp_true_iff, exists_const]
  have h : atBot.HasBasis (fun _ : α => True) Iic := @atBot_basis α _ _
  have h_nhds : (𝓝 ⊥).HasBasis (fun a : α => ⊥ < a) fun a => Iio a := @nhds_bot_basis α _ _ _ _ _
  intro s
  

Proof state:
case inr
α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderBot α
inst✝ : OrderTopology α
h✝ : Nontrivial α
h : HasBasis atBot (fun x => True) Iic
h_nhds : HasBasis (𝓝 ⊥) (fun a => ⊥ < a) fun a => Iio a
s : Set α
⊢ s ∈ 𝓝 ⊥ → s ∈ atBot

Next tactic:
rw [h.mem_iff, h_nhds.mem_iff]
theorem atBot_le_nhds_bot {α : Type*} [TopologicalSpace α] [LinearOrder α] [OrderBot α]
    [OrderTopology α] : (atBot : Filter α) ≤ 𝓝 ⊥ := by
  cases subsingleton_or_nontrivial α
  · simp only [nhds_discrete, le_pure_iff, mem_atBot_sets, mem_singleton_iff,
      eq_iff_true_of_subsingleton, imp_true_iff, exists_const]
  have h : atBot.HasBasis (fun _ : α => True) Iic := @atBot_basis α _ _
  have h_nhds : (𝓝 ⊥).HasBasis (fun a : α => ⊥ < a) fun a => Iio a := @nhds_bot_basis α _ _ _ _ _
  intro s
  rw [h.mem_iff, h_nhds.mem_iff]
  

Proof state:
case inr
α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderBot α
inst✝ : OrderTopology α
h✝ : Nontrivial α
h : HasBasis atBot (fun x => True) Iic
h_nhds : HasBasis (𝓝 ⊥) (fun a => ⊥ < a) fun a => Iio a
s : Set α
⊢ (∃ i, ⊥ < i ∧ Iio i ⊆ s) → ∃ i, True ∧ Iic i ⊆ s

Next tactic:
rintro ⟨a, ha_bot_lt, h_Iio_a_subset_s⟩
theorem atBot_le_nhds_bot {α : Type*} [TopologicalSpace α] [LinearOrder α] [OrderBot α]
    [OrderTopology α] : (atBot : Filter α) ≤ 𝓝 ⊥ := by
  cases subsingleton_or_nontrivial α
  · simp only [nhds_discrete, le_pure_iff, mem_atBot_sets, mem_singleton_iff,
      eq_iff_true_of_subsingleton, imp_true_iff, exists_const]
  have h : atBot.HasBasis (fun _ : α => True) Iic := @atBot_basis α _ _
  have h_nhds : (𝓝 ⊥).HasBasis (fun a : α => ⊥ < a) fun a => Iio a := @nhds_bot_basis α _ _ _ _ _
  intro s
  rw [h.mem_iff, h_nhds.mem_iff]
  rintro ⟨a, ha_bot_lt, h_Iio_a_subset_s⟩
  

Proof state:
case inr.intro.intro
α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderBot α
inst✝ : OrderTopology α
h✝ : Nontrivial α
h : HasBasis atBot (fun x => True) Iic
h_nhds : HasBasis (𝓝 ⊥) (fun a => ⊥ < a) fun a => Iio a
s : Set α
a : α
ha_bot_lt : ⊥ < a
h_Iio_a_subset_s : Iio a ⊆ s
⊢ ∃ i, True ∧ Iic i ⊆ s

Next tactic:
refine' ⟨⊥, trivial, _root_.trans _ h_Iio_a_subset_s⟩
theorem atBot_le_nhds_bot {α : Type*} [TopologicalSpace α] [LinearOrder α] [OrderBot α]
    [OrderTopology α] : (atBot : Filter α) ≤ 𝓝 ⊥ := by
  cases subsingleton_or_nontrivial α
  · simp only [nhds_discrete, le_pure_iff, mem_atBot_sets, mem_singleton_iff,
      eq_iff_true_of_subsingleton, imp_true_iff, exists_const]
  have h : atBot.HasBasis (fun _ : α => True) Iic := @atBot_basis α _ _
  have h_nhds : (𝓝 ⊥).HasBasis (fun a : α => ⊥ < a) fun a => Iio a := @nhds_bot_basis α _ _ _ _ _
  intro s
  rw [h.mem_iff, h_nhds.mem_iff]
  rintro ⟨a, ha_bot_lt, h_Iio_a_subset_s⟩
  refine' ⟨⊥, trivial, _root_.trans _ h_Iio_a_subset_s⟩
  

Proof state:
case inr.intro.intro
α✝ : Type u_1
β : Type u_2
ι : Type u_3
α : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderBot α
inst✝ : OrderTopology α
h✝ : Nontrivial α
h : HasBasis atBot (fun x => True) Iic
h_nhds : HasBasis (𝓝 ⊥) (fun a => ⊥ < a) fun a => Iio a
s : Set α
a : α
ha_bot_lt : ⊥ < a
h_Iio_a_subset_s : Iio a ⊆ s
⊢ Iic ⊥ ⊆ Iio a

Next tactic:
simpa only [Iic_bot, singleton_subset_iff, mem_Iio]
theorem ENNReal.ofReal_cinfi (f : α → ℝ) [Nonempty α] :
    ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i) := by
  

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
f : α → ℝ
inst✝ : Nonempty α
⊢ ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i)

Next tactic:
by_cases hf : BddBelow (range f)
theorem ENNReal.ofReal_cinfi (f : α → ℝ) [Nonempty α] :
    ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i) := by
  by_cases hf : BddBelow (range f)
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
ι : Type u_3
f : α → ℝ
inst✝ : Nonempty α
hf : BddBelow (range f)
⊢ ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i)

Next tactic:
exact
      Monotone.map_ciInf_of_continuousAt ENNReal.continuous_ofReal.continuousAt
        (fun i j hij => ENNReal.ofReal_le_ofReal hij) hf
theorem ENNReal.ofReal_cinfi (f : α → ℝ) [Nonempty α] :
    ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i) := by
  by_cases hf : BddBelow (range f)
  · exact
      Monotone.map_ciInf_of_continuousAt ENNReal.continuous_ofReal.continuousAt
        (fun i j hij => ENNReal.ofReal_le_ofReal hij) hf
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
f : α → ℝ
inst✝ : Nonempty α
hf : ¬BddBelow (range f)
⊢ ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i)

Next tactic:
symm
theorem ENNReal.ofReal_cinfi (f : α → ℝ) [Nonempty α] :
    ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i) := by
  by_cases hf : BddBelow (range f)
  · exact
      Monotone.map_ciInf_of_continuousAt ENNReal.continuous_ofReal.continuousAt
        (fun i j hij => ENNReal.ofReal_le_ofReal hij) hf
  · symm
    

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
f : α → ℝ
inst✝ : Nonempty α
hf : ¬BddBelow (range f)
⊢ ⨅ i, ENNReal.ofReal (f i) = ENNReal.ofReal (⨅ i, f i)

Next tactic:
rw [Real.iInf_of_not_bddBelow hf, ENNReal.ofReal_zero, ← ENNReal.bot_eq_zero, iInf_eq_bot]
theorem ENNReal.ofReal_cinfi (f : α → ℝ) [Nonempty α] :
    ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i) := by
  by_cases hf : BddBelow (range f)
  · exact
      Monotone.map_ciInf_of_continuousAt ENNReal.continuous_ofReal.continuousAt
        (fun i j hij => ENNReal.ofReal_le_ofReal hij) hf
  · symm
    rw [Real.iInf_of_not_bddBelow hf, ENNReal.ofReal_zero, ← ENNReal.bot_eq_zero, iInf_eq_bot]
    

Proof state:
case neg
α : Type u_1
β : Type u_2
ι : Type u_3
f : α → ℝ
inst✝ : Nonempty α
hf : ¬BddBelow (range f)
⊢ ∀ b > ⊥, ∃ i, ENNReal.ofReal (f i) < b

Next tactic:
obtain ⟨y, hy_mem, hy_neg⟩ := not_bddBelow_iff.mp hf 0
theorem ENNReal.ofReal_cinfi (f : α → ℝ) [Nonempty α] :
    ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i) := by
  by_cases hf : BddBelow (range f)
  · exact
      Monotone.map_ciInf_of_continuousAt ENNReal.continuous_ofReal.continuousAt
        (fun i j hij => ENNReal.ofReal_le_ofReal hij) hf
  · symm
    rw [Real.iInf_of_not_bddBelow hf, ENNReal.ofReal_zero, ← ENNReal.bot_eq_zero, iInf_eq_bot]
    obtain ⟨y, hy_mem, hy_neg⟩ := not_bddBelow_iff.mp hf 0
    

Proof state:
case neg.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
f : α → ℝ
inst✝ : Nonempty α
hf : ¬BddBelow (range f)
y : ℝ
hy_mem : y ∈ range f
hy_neg : y < 0
⊢ ∀ b > ⊥, ∃ i, ENNReal.ofReal (f i) < b

Next tactic:
obtain ⟨i, rfl⟩ := mem_range.mpr hy_mem
theorem ENNReal.ofReal_cinfi (f : α → ℝ) [Nonempty α] :
    ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i) := by
  by_cases hf : BddBelow (range f)
  · exact
      Monotone.map_ciInf_of_continuousAt ENNReal.continuous_ofReal.continuousAt
        (fun i j hij => ENNReal.ofReal_le_ofReal hij) hf
  · symm
    rw [Real.iInf_of_not_bddBelow hf, ENNReal.ofReal_zero, ← ENNReal.bot_eq_zero, iInf_eq_bot]
    obtain ⟨y, hy_mem, hy_neg⟩ := not_bddBelow_iff.mp hf 0
    obtain ⟨i, rfl⟩ := mem_range.mpr hy_mem
    

Proof state:
case neg.intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
f : α → ℝ
inst✝ : Nonempty α
hf : ¬BddBelow (range f)
i : α
hy_mem : (fun y => f y) i ∈ range f
hy_neg : (fun y => f y) i < 0
⊢ ∀ b > ⊥, ∃ i, ENNReal.ofReal (f i) < b

Next tactic:
refine' fun x hx => ⟨i, _⟩
theorem ENNReal.ofReal_cinfi (f : α → ℝ) [Nonempty α] :
    ENNReal.ofReal (⨅ i, f i) = ⨅ i, ENNReal.ofReal (f i) := by
  by_cases hf : BddBelow (range f)
  · exact
      Monotone.map_ciInf_of_continuousAt ENNReal.continuous_ofReal.continuousAt
        (fun i j hij => ENNReal.ofReal_le_ofReal hij) hf
  · symm
    rw [Real.iInf_of_not_bddBelow hf, ENNReal.ofReal_zero, ← ENNReal.bot_eq_zero, iInf_eq_bot]
    obtain ⟨y, hy_mem, hy_neg⟩ := not_bddBelow_iff.mp hf 0
    obtain ⟨i, rfl⟩ := mem_range.mpr hy_mem
    refine' fun x hx => ⟨i, _⟩
    

Proof state:
case neg.intro.intro.intro
α : Type u_1
β : Type u_2
ι : Type u_3
f : α → ℝ
inst✝ : Nonempty α
hf : ¬BddBelow (range f)
i : α
hy_mem : (fun y => f y) i ∈ range f
hy_neg : (fun y => f y) i < 0
x : ℝ≥0∞
hx : x > ⊥
⊢ ENNReal.ofReal (f i) < x

Next tactic:
rwa [ENNReal.ofReal_of_nonpos hy_neg.le]
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
⊢ ∫⁻ (a : α), ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ (a : α), f b a ∂μ

Next tactic:
cases nonempty_encodable β
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  

Proof state:
case intro
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
⊢ ∫⁻ (a : α), ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ (a : α), f b a ∂μ

Next tactic:
cases isEmpty_or_nonempty β
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    

Proof state:
case intro.inl
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
⊢ ∫⁻ (a : α), ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ (a : α), f b a ∂μ

Next tactic:
conv =>
      lhs
      congr
      · skip
      · ext x
        rw [WithTop.iInf_empty]
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    conv =>
      

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
| ∫⁻ (a : α), ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ (a : α), f b a ∂μ

Next tactic:
lhs
      congr
      · skip
      · ext x
        rw [WithTop.iInf_empty]
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    conv =>
      

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
| ∫⁻ (a : α), ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ (a : α), f b a ∂μ

Next tactic:
lhs
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    conv =>
      lhs
      

Proof state:
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
| ∫⁻ (a : α), ⨅ b, f b a ∂μ

Next tactic:
congr
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    conv =>
      lhs
      congr
      

Proof state:
case μ
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
| μ
case f
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
| fun a => ⨅ b, f b a

Next tactic:
· skip
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    conv =>
      lhs
      congr
      · 

Proof state:
case μ
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
| μ

Next tactic:
skip
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    conv =>
      lhs
      congr
      · skip
      

Proof state:
case f
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
| fun a => ⨅ b, f b a

Next tactic:
· ext x
        rw [WithTop.iInf_empty]
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    conv =>
      lhs
      congr
      · skip
      · 

Proof state:
case f
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
| fun a => ⨅ b, f b a

Next tactic:
ext x
        rw [WithTop.iInf_empty]
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    conv =>
      lhs
      congr
      · skip
      · 

Proof state:
case f
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
| fun a => ⨅ b, f b a

Next tactic:
ext x
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    conv =>
      lhs
      congr
      · skip
      · ext x
        

Proof state:
case f.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
x : α
| ⨅ b, f b x

Next tactic:
rw [WithTop.iInf_empty]
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    conv =>
      lhs
      congr
      · skip
      · ext x
        rw [WithTop.iInf_empty]
    

Proof state:
case intro.inl
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
⊢ ∫⁻ (x : α), ⊤ ∂μ = ⨅ b, ∫⁻ (a : α), f b a ∂μ

Next tactic:
rw [WithTop.iInf_empty, lintegral_const]
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    conv =>
      lhs
      congr
      · skip
      · ext x
        rw [WithTop.iInf_empty]
    rw [WithTop.iInf_empty, lintegral_const]
    

Proof state:
case intro.inl
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
⊢ ⊤ * ↑↑μ univ = ⊤

Next tactic:
rw [ENNReal.top_mul', if_neg]
/-- Monotone convergence for an infimum over a directed family and indexed by a countable type -/
theorem lintegral_iInf_directed_of_measurable {mα : MeasurableSpace α} [Countable β]
    {f : β → α → ℝ≥0∞} {μ : Measure α} (hμ : μ ≠ 0) (hf : ∀ b, Measurable (f b))
    (hf_int : ∀ b, ∫⁻ a, f b a ∂μ ≠ ∞) (h_directed : Directed (· ≥ ·) f) :
    ∫⁻ a, ⨅ b, f b a ∂μ = ⨅ b, ∫⁻ a, f b a ∂μ := by
  cases nonempty_encodable β
  cases isEmpty_or_nonempty β
  · -- Porting note: the next `simp only` doesn't do anything, so added a workaround below.
    -- simp only [WithTop.iInf_empty, lintegral_const]
    conv =>
      lhs
      congr
      · skip
      · ext x
        rw [WithTop.iInf_empty]
    rw [WithTop.iInf_empty, lintegral_const]
    rw [ENNReal.top_mul', if_neg]
    

Proof state:
case intro.inl.hnc
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
inst✝ : Countable β
f : β → α → ℝ≥0∞
μ : Measure α
hμ : μ ≠ 0
hf : ∀ (b : β), Measurable (f b)
hf_int : ∀ (b : β), ∫⁻ (a : α), f b a ∂μ ≠ ⊤
h_directed : Directed (fun x x_1 => x ≥ x_1) f
val✝ : Encodable β
h✝ : IsEmpty β
⊢ ¬↑↑μ univ = 0

Next tactic:
simp only [Measure.measure_univ_eq_zero, hμ, not_false_iff]