l3lab/ntp-mathlib huggingface dataset:
@[simp, norm_cast]
theorem disjoint_coe (s t : Interval α) : Disjoint (s : Set α) t ↔ Disjoint s t := by
  classical
    

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝ : Lattice α
s t : Interval α
⊢ Disjoint ↑s ↑t ↔ Disjoint s t

Next tactic:
rw [disjoint_iff_inf_le, disjoint_iff_inf_le, ← coe_subset_coe, coe_inf]
@[simp, norm_cast]
theorem disjoint_coe (s t : Interval α) : Disjoint (s : Set α) t ↔ Disjoint s t := by
  classical
    rw [disjoint_iff_inf_le, disjoint_iff_inf_le, ← coe_subset_coe, coe_inf]
    

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝ : Lattice α
s t : Interval α
⊢ ↑s ⊓ ↑t ≤ ⊥ ↔ ↑s ∩ ↑t ⊆ ↑⊥

Next tactic:
rfl
@[simp, norm_cast]
theorem coe_eq_pure : (s : Interval α) = Interval.pure a ↔ s = pure a := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝ : Preorder α
s : NonemptyInterval α
a : α
⊢ ↑s = Interval.pure a ↔ s = pure a

Next tactic:
rw [← Interval.coe_inj, coe_pure_interval]
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
S : Set (Interval α)
h : ¬S ⊆ {⊥}
⊢ (⨅ s, ⨅ (_ : ↑s ∈ S), s.toProd.1, ⨆ s, ⨆ (_ : ↑s ∈ S), s.toProd.2).1 ≤
    (⨅ s, ⨅ (_ : ↑s ∈ S), s.toProd.1, ⨆ s, ⨆ (_ : ↑s ∈ S), s.toProd.2).2

Next tactic:
obtain ⟨s, hs, ha⟩ := not_subset.1 h
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                

Proof state:
case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
S : Set (Interval α)
h : ¬S ⊆ {⊥}
s : Interval α
hs : s ∈ S
ha : s ∉ {⊥}
⊢ (⨅ s, ⨅ (_ : ↑s ∈ S), s.toProd.1, ⨆ s, ⨆ (_ : ↑s ∈ S), s.toProd.2).1 ≤
    (⨅ s, ⨅ (_ : ↑s ∈ S), s.toProd.1, ⨆ s, ⨆ (_ : ↑s ∈ S), s.toProd.2).2

Next tactic:
lift s to NonemptyInterval α using ha
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                

Proof state:
case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
S : Set (Interval α)
h : ¬S ⊆ {⊥}
s : NonemptyInterval α
hs : ↑s ∈ S
⊢ (⨅ s, ⨅ (_ : ↑s ∈ S), s.toProd.1, ⨆ s, ⨆ (_ : ↑s ∈ S), s.toProd.2).1 ≤
    (⨅ s, ⨅ (_ : ↑s ∈ S), s.toProd.1, ⨆ s, ⨆ (_ : ↑s ∈ S), s.toProd.2).2

Next tactic:
exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s✝ : Set (Interval α)
s : Interval α
ha : s ∈ s✝
⊢ s ≤ sSup s✝

Next tactic:
dsimp only
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          dsimp only -- Porting note: added
          

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s✝ : Set (Interval α)
s : Interval α
ha : s ∈ s✝
⊢ s ≤
    if h : s✝ ⊆ {⊥} then ⊥
    else
      some
        { toProd := (⨅ s, ⨅ (_ : ↑s ∈ s✝), s.toProd.1, ⨆ s, ⨆ (_ : ↑s ∈ s✝), s.toProd.2),
          fst_le_snd := (_ : ⨅ s, ⨅ (_ : ↑s ∈ s✝), s.toProd.1 ≤ ⨆ s, ⨆ (_ : ↑s ∈ s✝), s.toProd.2) }

Next tactic:
split_ifs with h
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          dsimp only -- Porting note: added
          split_ifs with h
          · 

Proof state:
case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s✝ : Set (Interval α)
s : Interval α
ha : s ∈ s✝
h : s✝ ⊆ {⊥}
⊢ s ≤ ⊥

Next tactic:
exact (h ha).le
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          dsimp only -- Porting note: added
          split_ifs with h
          · exact (h ha).le
          

Proof state:
case neg
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s✝ : Set (Interval α)
s : Interval α
ha : s ∈ s✝
h : ¬s✝ ⊆ {⊥}
⊢ s ≤
    some
      { toProd := (⨅ s, ⨅ (_ : ↑s ∈ s✝), s.toProd.1, ⨆ s, ⨆ (_ : ↑s ∈ s✝), s.toProd.2),
        fst_le_snd := (_ : ⨅ s, ⨅ (_ : ↑s ∈ s✝), s.toProd.1 ≤ ⨆ s, ⨆ (_ : ↑s ∈ s✝), s.toProd.2) }

Next tactic:
cases s
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          dsimp only -- Porting note: added
          split_ifs with h
          · exact (h ha).le
          cases s
          · 

Proof state:
case neg.none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s : Set (Interval α)
h : ¬s ⊆ {⊥}
ha : none ∈ s
⊢ none ≤
    some
      { toProd := (⨅ s_1, ⨅ (_ : ↑s_1 ∈ s), s_1.toProd.1, ⨆ s_1, ⨆ (_ : ↑s_1 ∈ s), s_1.toProd.2),
        fst_le_snd := (_ : ⨅ s_1, ⨅ (_ : ↑s_1 ∈ s), s_1.toProd.1 ≤ ⨆ s_1, ⨆ (_ : ↑s_1 ∈ s), s_1.toProd.2) }

Next tactic:
exact bot_le
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          dsimp only -- Porting note: added
          split_ifs with h
          · exact (h ha).le
          cases s
          · exact bot_le
          · -- Porting note: This case was
            -- `exact WithBot.some_le_some.2 ⟨iInf₂_le _ ha, le_iSup₂_of_le _ ha le_rfl⟩`
            -- but there seems to be a defEq-problem at `iInf₂_le` that lean cannot resolve yet.
            

Proof state:
case neg.some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s : Set (Interval α)
h : ¬s ⊆ {⊥}
val✝ : NonemptyInterval α
ha : some val✝ ∈ s
⊢ some val✝ ≤
    some
      { toProd := (⨅ s_1, ⨅ (_ : ↑s_1 ∈ s), s_1.toProd.1, ⨆ s_1, ⨆ (_ : ↑s_1 ∈ s), s_1.toProd.2),
        fst_le_snd := (_ : ⨅ s_1, ⨅ (_ : ↑s_1 ∈ s), s_1.toProd.1 ≤ ⨆ s_1, ⨆ (_ : ↑s_1 ∈ s), s_1.toProd.2) }

Next tactic:
apply WithBot.some_le_some.2
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          dsimp only -- Porting note: added
          split_ifs with h
          · exact (h ha).le
          cases s
          · exact bot_le
          · -- Porting note: This case was
            -- `exact WithBot.some_le_some.2 ⟨iInf₂_le _ ha, le_iSup₂_of_le _ ha le_rfl⟩`
            -- but there seems to be a defEq-problem at `iInf₂_le` that lean cannot resolve yet.
            apply WithBot.some_le_some.2
            

Proof state:
case neg.some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s : Set (Interval α)
h : ¬s ⊆ {⊥}
val✝ : NonemptyInterval α
ha : some val✝ ∈ s
⊢ val✝ ≤
    { toProd := (⨅ s_1, ⨅ (_ : ↑s_1 ∈ s), s_1.toProd.1, ⨆ s_1, ⨆ (_ : ↑s_1 ∈ s), s_1.toProd.2),
      fst_le_snd := (_ : ⨅ s_1, ⨅ (_ : ↑s_1 ∈ s), s_1.toProd.1 ≤ ⨆ s_1, ⨆ (_ : ↑s_1 ∈ s), s_1.toProd.2) }

Next tactic:
constructor
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          dsimp only -- Porting note: added
          split_ifs with h
          · exact (h ha).le
          cases s
          · exact bot_le
          · -- Porting note: This case was
            -- `exact WithBot.some_le_some.2 ⟨iInf₂_le _ ha, le_iSup₂_of_le _ ha le_rfl⟩`
            -- but there seems to be a defEq-problem at `iInf₂_le` that lean cannot resolve yet.
            apply WithBot.some_le_some.2
            constructor
            · 

Proof state:
case neg.some.left
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s : Set (Interval α)
h : ¬s ⊆ {⊥}
val✝ : NonemptyInterval α
ha : some val✝ ∈ s
⊢ (NonemptyInterval.toDualProd val✝).1 ≤
    (NonemptyInterval.toDualProd
        { toProd := (⨅ s_1, ⨅ (_ : ↑s_1 ∈ s), s_1.toProd.1, ⨆ s_1, ⨆ (_ : ↑s_1 ∈ s), s_1.toProd.2),
          fst_le_snd := (_ : ⨅ s_1, ⨅ (_ : ↑s_1 ∈ s), s_1.toProd.1 ≤ ⨆ s_1, ⨆ (_ : ↑s_1 ∈ s), s_1.toProd.2) }).1

Next tactic:
apply iInf₂_le
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          dsimp only -- Porting note: added
          split_ifs with h
          · exact (h ha).le
          cases s
          · exact bot_le
          · -- Porting note: This case was
            -- `exact WithBot.some_le_some.2 ⟨iInf₂_le _ ha, le_iSup₂_of_le _ ha le_rfl⟩`
            -- but there seems to be a defEq-problem at `iInf₂_le` that lean cannot resolve yet.
            apply WithBot.some_le_some.2
            constructor
            · apply iInf₂_le
              

Proof state:
case neg.some.left.j
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s : Set (Interval α)
h : ¬s ⊆ {⊥}
val✝ : NonemptyInterval α
ha : some val✝ ∈ s
⊢ ↑val✝ ∈ s

Next tactic:
exact ha
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          dsimp only -- Porting note: added
          split_ifs with h
          · exact (h ha).le
          cases s
          · exact bot_le
          · -- Porting note: This case was
            -- `exact WithBot.some_le_some.2 ⟨iInf₂_le _ ha, le_iSup₂_of_le _ ha le_rfl⟩`
            -- but there seems to be a defEq-problem at `iInf₂_le` that lean cannot resolve yet.
            apply WithBot.some_le_some.2
            constructor
            · apply iInf₂_le
              exact ha
            · 

Proof state:
case neg.some.right
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s : Set (Interval α)
h : ¬s ⊆ {⊥}
val✝ : NonemptyInterval α
ha : some val✝ ∈ s
⊢ (NonemptyInterval.toDualProd val✝).2 ≤
    (NonemptyInterval.toDualProd
        { toProd := (⨅ s_1, ⨅ (_ : ↑s_1 ∈ s), s_1.toProd.1, ⨆ s_1, ⨆ (_ : ↑s_1 ∈ s), s_1.toProd.2),
          fst_le_snd := (_ : ⨅ s_1, ⨅ (_ : ↑s_1 ∈ s), s_1.toProd.1 ≤ ⨆ s_1, ⨆ (_ : ↑s_1 ∈ s), s_1.toProd.2) }).2

Next tactic:
exact le_iSup₂_of_le _ ha le_rfl
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          dsimp only -- Porting note: added
          split_ifs with h
          · exact (h ha).le
          cases s
          · exact bot_le
          · -- Porting note: This case was
            -- `exact WithBot.some_le_some.2 ⟨iInf₂_le _ ha, le_iSup₂_of_le _ ha le_rfl⟩`
            -- but there seems to be a defEq-problem at `iInf₂_le` that lean cannot resolve yet.
            apply WithBot.some_le_some.2
            constructor
            · apply iInf₂_le
              exact ha
            · exact le_iSup₂_of_le _ ha le_rfl
        sSup_le := fun s s ha => by
          

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s✝ : Set (Interval α)
s : Interval α
ha : ∀ b ∈ s✝, b ≤ s
⊢ sSup s✝ ≤ s

Next tactic:
dsimp only
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          dsimp only -- Porting note: added
          split_ifs with h
          · exact (h ha).le
          cases s
          · exact bot_le
          · -- Porting note: This case was
            -- `exact WithBot.some_le_some.2 ⟨iInf₂_le _ ha, le_iSup₂_of_le _ ha le_rfl⟩`
            -- but there seems to be a defEq-problem at `iInf₂_le` that lean cannot resolve yet.
            apply WithBot.some_le_some.2
            constructor
            · apply iInf₂_le
              exact ha
            · exact le_iSup₂_of_le _ ha le_rfl
        sSup_le := fun s s ha => by
          dsimp only -- Porting note: added
          

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s✝ : Set (Interval α)
s : Interval α
ha : ∀ b ∈ s✝, b ≤ s
⊢ (if h : s✝ ⊆ {⊥} then ⊥
    else
      some
        { toProd := (⨅ s, ⨅ (_ : ↑s ∈ s✝), s.toProd.1, ⨆ s, ⨆ (_ : ↑s ∈ s✝), s.toProd.2),
          fst_le_snd := (_ : ⨅ s, ⨅ (_ : ↑s ∈ s✝), s.toProd.1 ≤ ⨆ s, ⨆ (_ : ↑s ∈ s✝), s.toProd.2) }) ≤
    s

Next tactic:
split_ifs with h
noncomputable instance completeLattice [@DecidableRel α (· ≤ ·)] :
    CompleteLattice (Interval α) := by
  classical
  exact
      { Interval.lattice, Interval.boundedOrder with
        sSup := fun S =>
          if h : S ⊆ {⊥} then ⊥
          else
            some
              ⟨⟨⨅ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.fst,
                  ⨆ (s : NonemptyInterval α) (_ : ↑s ∈ S), s.snd⟩, by
                obtain ⟨s, hs, ha⟩ := not_subset.1 h
                lift s to NonemptyInterval α using ha
                exact iInf₂_le_of_le s hs (le_iSup₂_of_le s hs s.fst_le_snd)⟩
        le_sSup := fun s s ha => by
          dsimp only -- Porting note: added
          split_ifs with h
          · exact (h ha).le
          cases s
          · exact bot_le
          · -- Porting note: This case was
            -- `exact WithBot.some_le_some.2 ⟨iInf₂_le _ ha, le_iSup₂_of_le _ ha le_rfl⟩`
            -- but there seems to be a defEq-problem at `iInf₂_le` that lean cannot resolve yet.
            apply WithBot.some_le_some.2
            constructor
            · apply iInf₂_le
              exact ha
            · exact le_iSup₂_of_le _ ha le_rfl
        sSup_le := fun s s ha => by
          dsimp only -- Porting note: added
          split_ifs with h
          · 

Proof state:
case pos
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
κ : ι → Sort u_6
inst✝¹ : CompleteLattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
src✝¹ : Lattice (Interval α) := lattice
src✝ : BoundedOrder (Interval α) := boundedOrder
s✝ : Set (Interval α)
s : Interval α
ha : ∀ b ∈ s✝, b ≤ s
h : s✝ ⊆ {⊥}
⊢ ⊥ ≤ s

Next tactic:
exact bot_le