l3lab/ntp-mathlib huggingface dataset:
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          

Proof state:
case pos
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
ha : ∀ b ∈ S, b ≤ a
h : S = ∅
h₁ : ⊤ ∈ ∅
⊢ ⊤ ≤ a

Next tactic:
cases h₁
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · 

Proof state:
case pos
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
ha : ∀ b ∈ S, b ≤ a
h : S = ∅
h₁ : ⊤ ∉ S
h₂ : BddAbove ((fun a => ↑a) ⁻¹' S)
⊢ ↑(sSup ((fun a => ↑a) ⁻¹' S)) ≤ a

Next tactic:
convert bot_le (a := a)
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          

Proof state:
case h.e'_3
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
ha : ∀ b ∈ S, b ≤ a
h : S = ∅
h₁ : ⊤ ∉ S
h₂ : BddAbove ((fun a => ↑a) ⁻¹' S)
⊢ ↑(sSup ((fun a => ↑a) ⁻¹' S)) = ⊥

Next tactic:
apply congr_arg
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          

Proof state:
case h.e'_3.h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
ha : ∀ b ∈ S, b ≤ a
h : S = ∅
h₁ : ⊤ ∉ S
h₂ : BddAbove ((fun a => ↑a) ⁻¹' S)
⊢ sSup ((fun a => ↑a) ⁻¹' S) = ⊥

Next tactic:
simp only [h, preimage_empty, WithBot.csSup_empty]
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · 

Proof state:
case neg
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
ha : ∀ b ∈ S, b ≤ a
h : S = ∅
h₁ : ⊤ ∉ S
h₂ : ¬BddAbove ((fun a => ↑a) ⁻¹' S)
⊢ ⊤ ≤ a

Next tactic:
exfalso
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          

Proof state:
case neg.h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
ha : ∀ b ∈ S, b ≤ a
h : S = ∅
h₁ : ⊤ ∉ S
h₂ : ¬BddAbove ((fun a => ↑a) ⁻¹' S)
⊢ False

Next tactic:
apply h₂
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          apply h₂
          

Proof state:
case neg.h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
ha : ∀ b ∈ S, b ≤ a
h : S = ∅
h₁ : ⊤ ∉ S
h₂ : ¬BddAbove ((fun a => ↑a) ⁻¹' S)
⊢ BddAbove ((fun a => ↑a) ⁻¹' S)

Next tactic:
use ⊥
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          apply h₂
          use ⊥
          

Proof state:
case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
ha : ∀ b ∈ S, b ≤ a
h : S = ∅
h₁ : ⊤ ∉ S
h₂ : ¬BddAbove ((fun a => ↑a) ⁻¹' S)
⊢ ⊥ ∈ upperBounds ((fun a => ↑a) ⁻¹' S)

Next tactic:
rw [h]
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          apply h₂
          use ⊥
          rw [h]
          

Proof state:
case h
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
ha : ∀ b ∈ S, b ≤ a
h : S = ∅
h₁ : ⊤ ∉ S
h₂ : ¬BddAbove ((fun a => ↑a) ⁻¹' S)
⊢ ⊥ ∈ upperBounds ((fun a => ↑a) ⁻¹' ∅)

Next tactic:
rintro b ⟨⟩
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          apply h₂
          use ⊥
          rw [h]
          rintro b ⟨⟩
      · 

Proof state:
case inr
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
ha : ∀ b ∈ S, b ≤ a
h : Set.Nonempty S
⊢ sSup S ≤ a

Next tactic:
refine' (WithTop.isLUB_sSup' h).2 ha
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          apply h₂
          use ⊥
          rw [h]
          rintro b ⟨⟩
      · refine' (WithTop.isLUB_sSup' h).2 ha
    sInf_le := fun S a haS =>
      show ite _ _ _ ≤ a by
        

Proof state:
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
haS : a ∈ S
⊢ (if S ⊆ {⊤} then ⊤ else ↑(sInf ((fun a => ↑a) ⁻¹' S))) ≤ a

Next tactic:
split_ifs with h₁
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          apply h₂
          use ⊥
          rw [h]
          rintro b ⟨⟩
      · refine' (WithTop.isLUB_sSup' h).2 ha
    sInf_le := fun S a haS =>
      show ite _ _ _ ≤ a by
        split_ifs with h₁
        · 

Proof state:
case pos
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
haS : a ∈ S
h₁ : S ⊆ {⊤}
⊢ ⊤ ≤ a

Next tactic:
cases' a with a
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          apply h₂
          use ⊥
          rw [h]
          rintro b ⟨⟩
      · refine' (WithTop.isLUB_sSup' h).2 ha
    sInf_le := fun S a haS =>
      show ite _ _ _ ≤ a by
        split_ifs with h₁
        · cases' a with a
          

Proof state:
case pos.none
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
h₁ : S ⊆ {⊤}
haS : none ∈ S
⊢ ⊤ ≤ none
case pos.some
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
h₁ : S ⊆ {⊤}
a : WithBot α
haS : Option.some a ∈ S
⊢ ⊤ ≤ Option.some a

Next tactic:
exact le_rfl
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          apply h₂
          use ⊥
          rw [h]
          rintro b ⟨⟩
      · refine' (WithTop.isLUB_sSup' h).2 ha
    sInf_le := fun S a haS =>
      show ite _ _ _ ≤ a by
        split_ifs with h₁
        · cases' a with a
          exact le_rfl
          

Proof state:
case pos.some
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
h₁ : S ⊆ {⊤}
a : WithBot α
haS : Option.some a ∈ S
⊢ ⊤ ≤ Option.some a

Next tactic:
cases h₁ haS
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          apply h₂
          use ⊥
          rw [h]
          rintro b ⟨⟩
      · refine' (WithTop.isLUB_sSup' h).2 ha
    sInf_le := fun S a haS =>
      show ite _ _ _ ≤ a by
        split_ifs with h₁
        · cases' a with a
          exact le_rfl
          cases h₁ haS
        · 

Proof state:
case neg
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
a : WithTop (WithBot α)
haS : a ∈ S
h₁ : ¬S ⊆ {⊤}
⊢ ↑(sInf ((fun a => ↑a) ⁻¹' S)) ≤ a

Next tactic:
cases a
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          apply h₂
          use ⊥
          rw [h]
          rintro b ⟨⟩
      · refine' (WithTop.isLUB_sSup' h).2 ha
    sInf_le := fun S a haS =>
      show ite _ _ _ ≤ a by
        split_ifs with h₁
        · cases' a with a
          exact le_rfl
          cases h₁ haS
        · cases a
          · 

Proof state:
case neg.none
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
h₁ : ¬S ⊆ {⊤}
haS : none ∈ S
⊢ ↑(sInf ((fun a => ↑a) ⁻¹' S)) ≤ none

Next tactic:
exact le_top
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          apply h₂
          use ⊥
          rw [h]
          rintro b ⟨⟩
      · refine' (WithTop.isLUB_sSup' h).2 ha
    sInf_le := fun S a haS =>
      show ite _ _ _ ≤ a by
        split_ifs with h₁
        · cases' a with a
          exact le_rfl
          cases h₁ haS
        · cases a
          · exact le_top
          · 

Proof state:
case neg.some
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
h₁ : ¬S ⊆ {⊤}
val✝ : WithBot α
haS : Option.some val✝ ∈ S
⊢ ↑(sInf ((fun a => ↑a) ⁻¹' S)) ≤ Option.some val✝

Next tactic:
apply WithTop.some_le_some.2
noncomputable instance WithTop.WithBot.completeLattice {α : Type*}
    [ConditionallyCompleteLattice α] : CompleteLattice (WithTop (WithBot α)) :=
  { instInfSet, instSupSet, boundedOrder, lattice with
    le_sSup := fun S a haS => (WithTop.isLUB_sSup' ⟨a, haS⟩).1 haS
    sSup_le := fun S a ha => by
      rcases S.eq_empty_or_nonempty with h | h
      · show ite _ _ _ ≤ a
        split_ifs with h₁ h₂
        · rw [h] at h₁
          cases h₁
        · convert bot_le (a := a)
          -- porting note: previous proof relied on convert unfolding
          -- the definition of ⊥
          apply congr_arg
          simp only [h, preimage_empty, WithBot.csSup_empty]
        · exfalso
          apply h₂
          use ⊥
          rw [h]
          rintro b ⟨⟩
      · refine' (WithTop.isLUB_sSup' h).2 ha
    sInf_le := fun S a haS =>
      show ite _ _ _ ≤ a by
        split_ifs with h₁
        · cases' a with a
          exact le_rfl
          cases h₁ haS
        · cases a
          · exact le_top
          · apply WithTop.some_le_some.2
            

Proof state:
case neg.some
α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
α : Type u_5
inst✝ : ConditionallyCompleteLattice α
src✝³ : InfSet (WithTop (WithBot α)) := instInfSet
src✝² : SupSet (WithTop (WithBot α)) := instSupSet
src✝¹ : BoundedOrder (WithTop (WithBot α)) := boundedOrder
src✝ : Lattice (WithTop (WithBot α)) := lattice
S : Set (WithTop (WithBot α))
h₁ : ¬S ⊆ {⊤}
val✝ : WithBot α
haS : Option.some val✝ ∈ S
⊢ sInf ((fun a => ↑a) ⁻¹' S) ≤ val✝

Next tactic:
refine' csInf_le _ haS