l3lab/ntp-mathlib huggingface dataset:
theorem coe_le_iff : ∀ {x : WithBot α}, (a : WithBot α) ≤ x ↔ ∃ b : α, x = b ∧ a ≤ b
  | Option.some x => by simp [some_eq_coe]
  | none => iff_of_false (not_coe_le_bot _) <| by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
⊢ ¬∃ b, none = ↑b ∧ a ≤ b

Next tactic:
simp [none_eq_bot]
theorem le_coe_iff : ∀ {x : WithBot α}, x ≤ b ↔ ∀ a : α, x = ↑a → a ≤ b
  | Option.some b => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : LE α
b : α
⊢ Option.some b ≤ ↑b✝ ↔ ∀ (a : α), Option.some b = ↑a → a ≤ b✝

Next tactic:
simp [some_eq_coe, coe_eq_coe]
theorem le_coe_iff : ∀ {x : WithBot α}, x ≤ b ↔ ∀ a : α, x = ↑a → a ≤ b
  | Option.some b => by simp [some_eq_coe, coe_eq_coe]
  | none => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
⊢ none ≤ ↑b ↔ ∀ (a : α), none = ↑a → a ≤ b

Next tactic:
simp [none_eq_bot]
theorem le_unbot_iff {a : α} {b : WithBot α} (h : b ≠ ⊥) :
    a ≤ unbot b h ↔ (a : WithBot α) ≤ b := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : LE α
a : α
b : WithBot α
h : b ≠ ⊥
⊢ a ≤ unbot b h ↔ ↑a ≤ b

Next tactic:
match b, h with
  | some _, _ => simp only [unbot_coe, coe_le_coe]
theorem le_unbot_iff {a : α} {b : WithBot α} (h : b ≠ ⊥) :
    a ≤ unbot b h ↔ (a : WithBot α) ≤ b := by
  match b, h with
  | some _, _ => 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : LE α
a : α
b : WithBot α
h : b ≠ ⊥
val✝ : α
x✝ : ↑val✝ ≠ ⊥
⊢ a ≤ unbot (↑val✝) x✝ ↔ ↑a ≤ ↑val✝

Next tactic:
simp only [unbot_coe, coe_le_coe]
theorem unbot_le_iff {a : WithBot α} (h : a ≠ ⊥) {b : α} :
    unbot a h ≤ b ↔ a ≤ (b : WithBot α) := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : LE α
a : WithBot α
h : a ≠ ⊥
b : α
⊢ unbot a h ≤ b ↔ a ≤ ↑b

Next tactic:
match a, h with
  | some _, _ => simp only [unbot_coe, coe_le_coe]
theorem unbot_le_iff {a : WithBot α} (h : a ≠ ⊥) {b : α} :
    unbot a h ≤ b ↔ a ≤ (b : WithBot α) := by
  match a, h with
  | some _, _ => 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : LE α
a : WithBot α
h : a ≠ ⊥
b val✝ : α
x✝ : ↑val✝ ≠ ⊥
⊢ unbot (↑val✝) x✝ ≤ b ↔ ↑val✝ ≤ ↑b

Next tactic:
simp only [unbot_coe, coe_le_coe]
@[simp]
theorem some_lt_some : @LT.lt (WithBot α) _ (Option.some a) (Option.some b) ↔ a < b := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LT α
⊢ Option.some a < Option.some b ↔ a < b

Next tactic:
simp [LT.lt]
theorem lt_iff_exists_coe : ∀ {a b : WithBot α}, a < b ↔ ∃ p : α, b = p ∧ a < p
  | a, Option.some b => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : LT α
a : WithBot α
b : α
⊢ a < Option.some b ↔ ∃ p, Option.some b = ↑p ∧ a < ↑p

Next tactic:
simp [some_eq_coe, coe_eq_coe]
theorem lt_iff_exists_coe : ∀ {a b : WithBot α}, a < b ↔ ∃ p : α, b = p ∧ a < p
  | a, Option.some b => by simp [some_eq_coe, coe_eq_coe]
  | a, none => iff_of_false (not_lt_none _) <| by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : LT α
a : WithBot α
⊢ ¬∃ p, none = ↑p ∧ a < ↑p

Next tactic:
simp [none_eq_bot]
theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a, x = ↑a → a < b
  | Option.some b => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : LT α
b : α
⊢ Option.some b < ↑b✝ ↔ ∀ (a : WithBot α), Option.some b = a → a < ↑b✝

Next tactic:
simp [some_eq_coe, coe_eq_coe, coe_lt_coe]
theorem lt_coe_iff : ∀ {x : WithBot α}, x < b ↔ ∀ a, x = ↑a → a < b
  | Option.some b => by simp [some_eq_coe, coe_eq_coe, coe_lt_coe]
  | none => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LT α
⊢ none < ↑b ↔ ∀ (a : WithBot α), none = a → a < ↑b

Next tactic:
simp [none_eq_bot, bot_lt_coe]
/-- A version of `bot_lt_iff_ne_bot` for `WithBot` that only requires `LT α`, not
`PartialOrder α`. -/
protected theorem bot_lt_iff_ne_bot : ∀ {x : WithBot α}, ⊥ < x ↔ x ≠ ⊥
  | ⊥ => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LT α
⊢ ⊥ < ⊥ ↔ ⊥ ≠ ⊥

Next tactic:
simpa using not_lt_none ⊥
/-- A version of `bot_lt_iff_ne_bot` for `WithBot` that only requires `LT α`, not
`PartialOrder α`. -/
protected theorem bot_lt_iff_ne_bot : ∀ {x : WithBot α}, ⊥ < x ↔ x ≠ ⊥
  | ⊥ => by simpa using not_lt_none ⊥
  | (x : α) => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LT α
x : α
⊢ ⊥ < ↑x ↔ ↑x ≠ ⊥

Next tactic:
simp [bot_lt_coe]
instance preorder [Preorder α] : Preorder (WithBot α) where
  le := (· ≤ ·)
  lt := (· < ·)
  lt_iff_le_not_le := by
    

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : Preorder α
⊢ ∀ (a b : WithBot α), a < b ↔ a ≤ b ∧ ¬b ≤ a

Next tactic:
intros a b
instance preorder [Preorder α] : Preorder (WithBot α) where
  le := (· ≤ ·)
  lt := (· < ·)
  lt_iff_le_not_le := by
    intros a b
    

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : Preorder α
a b : WithBot α
⊢ a < b ↔ a ≤ b ∧ ¬b ≤ a

Next tactic:
cases a
instance preorder [Preorder α] : Preorder (WithBot α) where
  le := (· ≤ ·)
  lt := (· < ·)
  lt_iff_le_not_le := by
    intros a b
    cases a <;> 

Proof state:
case none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : Preorder α
b : WithBot α
⊢ none < b ↔ none ≤ b ∧ ¬b ≤ none

Next tactic:
cases b
instance preorder [Preorder α] : Preorder (WithBot α) where
  le := (· ≤ ·)
  lt := (· < ·)
  lt_iff_le_not_le := by
    intros a b
    cases a <;> 

Proof state:
case some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : Preorder α
b : WithBot α
val✝ : α
⊢ Option.some val✝ < b ↔ Option.some val✝ ≤ b ∧ ¬b ≤ Option.some val✝

Next tactic:
cases b
instance preorder [Preorder α] : Preorder (WithBot α) where
  le := (· ≤ ·)
  lt := (· < ·)
  lt_iff_le_not_le := by
    intros a b
    cases a <;> cases b <;> 

Proof state:
case none.none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : Preorder α
⊢ none < none ↔ none ≤ none ∧ ¬none ≤ none

Next tactic:
simp [lt_iff_le_not_le]
instance preorder [Preorder α] : Preorder (WithBot α) where
  le := (· ≤ ·)
  lt := (· < ·)
  lt_iff_le_not_le := by
    intros a b
    cases a <;> cases b <;> 

Proof state:
case none.some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : Preorder α
val✝ : α
⊢ none < Option.some val✝ ↔ none ≤ Option.some val✝ ∧ ¬Option.some val✝ ≤ none

Next tactic:
simp [lt_iff_le_not_le]
instance preorder [Preorder α] : Preorder (WithBot α) where
  le := (· ≤ ·)
  lt := (· < ·)
  lt_iff_le_not_le := by
    intros a b
    cases a <;> cases b <;> 

Proof state:
case some.none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : Preorder α
val✝ : α
⊢ Option.some val✝ < none ↔ Option.some val✝ ≤ none ∧ ¬none ≤ Option.some val✝

Next tactic:
simp [lt_iff_le_not_le]
instance preorder [Preorder α] : Preorder (WithBot α) where
  le := (· ≤ ·)
  lt := (· < ·)
  lt_iff_le_not_le := by
    intros a b
    cases a <;> cases b <;> 

Proof state:
case some.some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : Preorder α
val✝¹ val✝ : α
⊢ Option.some val✝¹ < Option.some val✝ ↔ Option.some val✝¹ ≤ Option.some val✝ ∧ ¬Option.some val✝ ≤ Option.some val✝¹

Next tactic:
simp [lt_iff_le_not_le]
instance preorder [Preorder α] : Preorder (WithBot α) where
  le := (· ≤ ·)
  lt := (· < ·)
  lt_iff_le_not_le := by
    intros a b
    cases a <;> cases b <;> simp [lt_iff_le_not_le]; 

Proof state:
case none.some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : Preorder α
val✝ : α
⊢ none < Option.some val✝ ↔ ¬Option.some val✝ ≤ none

Next tactic:
simp [LE.le, LT.lt]
instance partialOrder [PartialOrder α] : PartialOrder (WithBot α) :=
  { WithBot.preorder with
    le_antisymm := fun o₁ o₂ h₁ h₂ => by
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : PartialOrder α
src✝ : Preorder (WithBot α) := preorder
o₁ o₂ : WithBot α
h₁ : o₁ ≤ o₂
h₂ : o₂ ≤ o₁
⊢ o₁ = o₂

Next tactic:
cases' o₁ with a
instance partialOrder [PartialOrder α] : PartialOrder (WithBot α) :=
  { WithBot.preorder with
    le_antisymm := fun o₁ o₂ h₁ h₂ => by
      cases' o₁ with a
      · 

Proof state:
case none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : PartialOrder α
src✝ : Preorder (WithBot α) := preorder
o₂ : WithBot α
h₁ : none ≤ o₂
h₂ : o₂ ≤ none
⊢ none = o₂

Next tactic:
cases' o₂ with b
instance partialOrder [PartialOrder α] : PartialOrder (WithBot α) :=
  { WithBot.preorder with
    le_antisymm := fun o₁ o₂ h₁ h₂ => by
      cases' o₁ with a
      · cases' o₂ with b
        · 

Proof state:
case none.none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : PartialOrder α
src✝ : Preorder (WithBot α) := preorder
h₁ h₂ : none ≤ none
⊢ none = none

Next tactic:
rfl
instance partialOrder [PartialOrder α] : PartialOrder (WithBot α) :=
  { WithBot.preorder with
    le_antisymm := fun o₁ o₂ h₁ h₂ => by
      cases' o₁ with a
      · cases' o₂ with b
        · rfl

        

Proof state:
case none.some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : PartialOrder α
src✝ : Preorder (WithBot α) := preorder
b : α
h₁ : none ≤ Option.some b
h₂ : Option.some b ≤ none
⊢ none = Option.some b

Next tactic:
rcases h₂ b rfl with ⟨_, ⟨⟩, _⟩
instance partialOrder [PartialOrder α] : PartialOrder (WithBot α) :=
  { WithBot.preorder with
    le_antisymm := fun o₁ o₂ h₁ h₂ => by
      cases' o₁ with a
      · cases' o₂ with b
        · rfl

        rcases h₂ b rfl with ⟨_, ⟨⟩, _⟩

      · 

Proof state:
case some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : PartialOrder α
src✝ : Preorder (WithBot α) := preorder
o₂ : WithBot α
a : α
h₁ : Option.some a ≤ o₂
h₂ : o₂ ≤ Option.some a
⊢ Option.some a = o₂

Next tactic:
rcases h₁ a rfl with ⟨b, ⟨⟩, h₁'⟩
instance partialOrder [PartialOrder α] : PartialOrder (WithBot α) :=
  { WithBot.preorder with
    le_antisymm := fun o₁ o₂ h₁ h₂ => by
      cases' o₁ with a
      · cases' o₂ with b
        · rfl

        rcases h₂ b rfl with ⟨_, ⟨⟩, _⟩

      · rcases h₁ a rfl with ⟨b, ⟨⟩, h₁'⟩
        

Proof state:
case some.intro.intro.refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : PartialOrder α
src✝ : Preorder (WithBot α) := preorder
a b : α
h₁' : a ≤ b
h₁ : Option.some a ≤ Option.some b
h₂ : Option.some b ≤ Option.some a
⊢ Option.some a = Option.some b

Next tactic:
rcases h₂ b rfl with ⟨_, ⟨⟩, h₂'⟩
instance partialOrder [PartialOrder α] : PartialOrder (WithBot α) :=
  { WithBot.preorder with
    le_antisymm := fun o₁ o₂ h₁ h₂ => by
      cases' o₁ with a
      · cases' o₂ with b
        · rfl

        rcases h₂ b rfl with ⟨_, ⟨⟩, _⟩

      · rcases h₁ a rfl with ⟨b, ⟨⟩, h₁'⟩
        rcases h₂ b rfl with ⟨_, ⟨⟩, h₂'⟩
        

Proof state:
case some.intro.intro.refl.intro.intro.refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : PartialOrder α
src✝ : Preorder (WithBot α) := preorder
a b : α
h₁' : a ≤ b
h₁ : Option.some a ≤ Option.some b
h₂ : Option.some b ≤ Option.some a
h₂' : b ≤ a
⊢ Option.some a = Option.some b

Next tactic:
rw [le_antisymm h₁' h₂']
@[simp]
theorem monotone_map_iff [Preorder α] [Preorder β] {f : α → β} :
    Monotone (WithBot.map f) ↔ Monotone f :=
  monotone_iff.trans <| by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
⊢ ((Monotone fun a => map f ↑a) ∧ ∀ (x : α), map f ⊥ ≤ map f ↑x) ↔ Monotone f

Next tactic:
simp [Monotone]
@[simp]
theorem strictMono_map_iff [Preorder α] [Preorder β] {f : α → β} :
    StrictMono (WithBot.map f) ↔ StrictMono f :=
  strictMono_iff.trans <| by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
⊢ ((StrictMono fun a => map f ↑a) ∧ ∀ (x : α), map f ⊥ < map f ↑x) ↔ StrictMono f

Next tactic:
simp [StrictMono, bot_lt_coe]
theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) :
    ∀ a b : WithBot α, a.map f ≤ b.map f ↔ a ≤ b
  | ⊥, _ => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
x✝ : WithBot α
⊢ map f ⊥ ≤ map f x✝ ↔ ⊥ ≤ x✝

Next tactic:
simp only [map_bot, bot_le]
theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) :
    ∀ a b : WithBot α, a.map f ≤ b.map f ↔ a ≤ b
  | ⊥, _ => by simp only [map_bot, bot_le]
  | (a : α), ⊥ => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
a : α
⊢ map f ↑a ≤ map f ⊥ ↔ ↑a ≤ ⊥

Next tactic:
simp only [map_coe, map_bot, coe_ne_bot, not_coe_le_bot _]
theorem map_le_iff [Preorder α] [Preorder β] (f : α → β) (mono_iff : ∀ {a b}, f a ≤ f b ↔ a ≤ b) :
    ∀ a b : WithBot α, a.map f ≤ b.map f ↔ a ≤ b
  | ⊥, _ => by simp only [map_bot, bot_le]
  | (a : α), ⊥ => by simp only [map_coe, map_bot, coe_ne_bot, not_coe_le_bot _]
  | (a : α), (b : α) => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
mono_iff : ∀ {a b : α}, f a ≤ f b ↔ a ≤ b
a b : α
⊢ map f ↑a ≤ map f ↑b ↔ ↑a ≤ ↑b

Next tactic:
simpa only [map_coe, coe_le_coe] using mono_iff
theorem unbot'_le_iff [LE α] {a : WithBot α} {b c : α} (h : a = ⊥ → b ≤ c) :
    a.unbot' b ≤ c ↔ a ≤ c := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : LE α
a : WithBot α
b c : α
h : a = ⊥ → b ≤ c
⊢ unbot' b a ≤ c ↔ a ≤ ↑c

Next tactic:
cases a
theorem unbot'_le_iff [LE α] {a : WithBot α} {b c : α} (h : a = ⊥ → b ≤ c) :
    a.unbot' b ≤ c ↔ a ≤ c := by
  cases a
  · 

Proof state:
case none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : LE α
b c : α
h : none = ⊥ → b ≤ c
⊢ unbot' b none ≤ c ↔ none ≤ ↑c

Next tactic:
simpa using h rfl
theorem unbot'_le_iff [LE α] {a : WithBot α} {b c : α} (h : a = ⊥ → b ≤ c) :
    a.unbot' b ≤ c ↔ a ≤ c := by
  cases a
  · simpa using h rfl
  · 

Proof state:
case some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : LE α
b c val✝ : α
h : Option.some val✝ = ⊥ → b ≤ c
⊢ unbot' b (Option.some val✝) ≤ c ↔ Option.some val✝ ≤ ↑c

Next tactic:
simp [some_eq_coe]
theorem unbot'_lt_iff [LT α] {a : WithBot α} {b c : α} (h : a = ⊥ → b < c) :
    a.unbot' b < c ↔ a < c := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : LT α
a : WithBot α
b c : α
h : a = ⊥ → b < c
⊢ unbot' b a < c ↔ a < ↑c

Next tactic:
cases a
theorem unbot'_lt_iff [LT α] {a : WithBot α} {b c : α} (h : a = ⊥ → b < c) :
    a.unbot' b < c ↔ a < c := by
  cases a
  · 

Proof state:
case none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : LT α
b c : α
h : none = ⊥ → b < c
⊢ unbot' b none < c ↔ none < ↑c

Next tactic:
simpa [bot_lt_coe] using h rfl
theorem unbot'_lt_iff [LT α] {a : WithBot α} {b c : α} (h : a = ⊥ → b < c) :
    a.unbot' b < c ↔ a < c := by
  cases a
  · simpa [bot_lt_coe] using h rfl
  · 

Proof state:
case some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : LT α
b c val✝ : α
h : Option.some val✝ = ⊥ → b < c
⊢ unbot' b (Option.some val✝) < c ↔ Option.some val✝ < ↑c

Next tactic:
simp [some_eq_coe]
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
o₁ o₂ : WithBot α
a : α
ha : a ∈ o₁
⊢ ∃ b, b ∈ o₁ ⊔ o₂ ∧ a ≤ b

Next tactic:
cases ha
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by cases ha; 

Proof state:
case refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
o₂ : WithBot α
a : α
⊢ ∃ b, b ∈ Option.some a ⊔ o₂ ∧ a ≤ b

Next tactic:
cases o₂
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> 

Proof state:
case refl.none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
a : α
⊢ ∃ b, b ∈ Option.some a ⊔ none ∧ a ≤ b

Next tactic:
simp [Option.liftOrGet]
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> 

Proof state:
case refl.some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
a val✝ : α
⊢ ∃ b, b ∈ Option.some a ⊔ Option.some val✝ ∧ a ≤ b

Next tactic:
simp [Option.liftOrGet]
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> simp [Option.liftOrGet],
    le_sup_right := fun o₁ o₂ a ha => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
o₁ o₂ : WithBot α
a : α
ha : a ∈ o₂
⊢ ∃ b, b ∈ o₁ ⊔ o₂ ∧ a ≤ b

Next tactic:
cases ha
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> simp [Option.liftOrGet],
    le_sup_right := fun o₁ o₂ a ha => by cases ha; 

Proof state:
case refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
o₁ : WithBot α
a : α
⊢ ∃ b, b ∈ o₁ ⊔ Option.some a ∧ a ≤ b

Next tactic:
cases o₁
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> simp [Option.liftOrGet],
    le_sup_right := fun o₁ o₂ a ha => by cases ha; cases o₁ <;> 

Proof state:
case refl.none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
a : α
⊢ ∃ b, b ∈ none ⊔ Option.some a ∧ a ≤ b

Next tactic:
simp [Option.liftOrGet]
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> simp [Option.liftOrGet],
    le_sup_right := fun o₁ o₂ a ha => by cases ha; cases o₁ <;> 

Proof state:
case refl.some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
a val✝ : α
⊢ ∃ b, b ∈ Option.some val✝ ⊔ Option.some a ∧ a ≤ b

Next tactic:
simp [Option.liftOrGet]
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> simp [Option.liftOrGet],
    le_sup_right := fun o₁ o₂ a ha => by cases ha; cases o₁ <;> simp [Option.liftOrGet],
    sup_le := fun o₁ o₂ o₃ h₁ h₂ a ha => by
      

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
o₁ o₂ o₃ : WithBot α
h₁ : o₁ ≤ o₃
h₂ : o₂ ≤ o₃
a : α
ha : a ∈ o₁ ⊔ o₂
⊢ ∃ b, b ∈ o₃ ∧ a ≤ b

Next tactic:
cases' o₁ with b
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> simp [Option.liftOrGet],
    le_sup_right := fun o₁ o₂ a ha => by cases ha; cases o₁ <;> simp [Option.liftOrGet],
    sup_le := fun o₁ o₂ o₃ h₁ h₂ a ha => by
      cases' o₁ with b <;> 

Proof state:
case none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
o₂ o₃ : WithBot α
h₂ : o₂ ≤ o₃
a : α
h₁ : none ≤ o₃
ha : a ∈ none ⊔ o₂
⊢ ∃ b, b ∈ o₃ ∧ a ≤ b

Next tactic:
cases' o₂ with c
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> simp [Option.liftOrGet],
    le_sup_right := fun o₁ o₂ a ha => by cases ha; cases o₁ <;> simp [Option.liftOrGet],
    sup_le := fun o₁ o₂ o₃ h₁ h₂ a ha => by
      cases' o₁ with b <;> 

Proof state:
case some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
o₂ o₃ : WithBot α
h₂ : o₂ ≤ o₃
a b : α
h₁ : Option.some b ≤ o₃
ha : a ∈ Option.some b ⊔ o₂
⊢ ∃ b, b ∈ o₃ ∧ a ≤ b

Next tactic:
cases' o₂ with c
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> simp [Option.liftOrGet],
    le_sup_right := fun o₁ o₂ a ha => by cases ha; cases o₁ <;> simp [Option.liftOrGet],
    sup_le := fun o₁ o₂ o₃ h₁ h₂ a ha => by
      cases' o₁ with b <;> cases' o₂ with c <;> 

Proof state:
case none.none
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
o₃ : WithBot α
a : α
h₁ h₂ : none ≤ o₃
ha : a ∈ none ⊔ none
⊢ ∃ b, b ∈ o₃ ∧ a ≤ b

Next tactic:
cases ha
instance semilatticeSup [SemilatticeSup α] : SemilatticeSup (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    sup := Option.liftOrGet (· ⊔ ·),
    le_sup_left := fun o₁ o₂ a ha => by cases ha; cases o₂ <;> simp [Option.liftOrGet],
    le_sup_right := fun o₁ o₂ a ha => by cases ha; cases o₁ <;> simp [Option.liftOrGet],
    sup_le := fun o₁ o₂ o₃ h₁ h₂ a ha => by
      cases' o₁ with b <;> cases' o₂ with c <;> 

Proof state:
case none.some
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : SemilatticeSup α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
o₃ : WithBot α
a : α
h₁ : none ≤ o₃
c : α
h₂ : Option.some c ≤ o₃
ha : a ∈ none ⊔ Option.some c
⊢ ∃ b, b ∈ o₃ ∧ a ≤ b

Next tactic:
cases ha