l3lab/ntp-mathlib huggingface dataset:
instance : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => ite (a = ⊥) ⊥ (some (pred a))
  pred_le a := by
    cases' a with a a
    · exact bot_le
    change ite _ _ _ ≤ _
    split_ifs
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases' a with a a
    · exact isMin_bot
    dsimp only at ha
    split_ifs at ha with ha'
    · exact (not_coe_le_bot _ ha).elim
    · rw [some_eq_coe, coe_le_coe, le_pred_iff_eq_bot] at ha
      exact (ha' ha).elim
  le_pred_of_lt {a b} h := by
    cases a
    · exact bot_le
    cases b
    · exact (not_lt_bot h).elim
    rw [some_lt_some] at h
    change _ ≤ ite _ _ _
    split_ifs with hb
    · rw [hb] at h
      

Proof state:
case pos
α : Type u_1
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : PartialOrder α
inst✝¹ : OrderBot α
inst✝ : PredOrder α
val✝¹ val✝ : α
h : val✝¹ < ⊥
hb : val✝ = ⊥
⊢ Option.some val✝¹ ≤ ⊥

Next tactic:
exact (not_lt_bot h).elim
instance : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => ite (a = ⊥) ⊥ (some (pred a))
  pred_le a := by
    cases' a with a a
    · exact bot_le
    change ite _ _ _ ≤ _
    split_ifs
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases' a with a a
    · exact isMin_bot
    dsimp only at ha
    split_ifs at ha with ha'
    · exact (not_coe_le_bot _ ha).elim
    · rw [some_eq_coe, coe_le_coe, le_pred_iff_eq_bot] at ha
      exact (ha' ha).elim
  le_pred_of_lt {a b} h := by
    cases a
    · exact bot_le
    cases b
    · exact (not_lt_bot h).elim
    rw [some_lt_some] at h
    change _ ≤ ite _ _ _
    split_ifs with hb
    · rw [hb] at h
      exact (not_lt_bot h).elim
    · 

Proof state:
case neg
α : Type u_1
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : PartialOrder α
inst✝¹ : OrderBot α
inst✝ : PredOrder α
val✝¹ val✝ : α
h : val✝¹ < val✝
hb : ¬val✝ = ⊥
⊢ Option.some val✝¹ ≤ ↑(pred val✝)

Next tactic:
exact some_le_some.2 (le_pred_of_lt h)
instance : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => ite (a = ⊥) ⊥ (some (pred a))
  pred_le a := by
    cases' a with a a
    · exact bot_le
    change ite _ _ _ ≤ _
    split_ifs
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases' a with a a
    · exact isMin_bot
    dsimp only at ha
    split_ifs at ha with ha'
    · exact (not_coe_le_bot _ ha).elim
    · rw [some_eq_coe, coe_le_coe, le_pred_iff_eq_bot] at ha
      exact (ha' ha).elim
  le_pred_of_lt {a b} h := by
    cases a
    · exact bot_le
    cases b
    · exact (not_lt_bot h).elim
    rw [some_lt_some] at h
    change _ ≤ ite _ _ _
    split_ifs with hb
    · rw [hb] at h
      exact (not_lt_bot h).elim
    · exact some_le_some.2 (le_pred_of_lt h)
  le_of_pred_lt {a b} h := by
    

Proof state:
α : Type u_1
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : PartialOrder α
inst✝¹ : OrderBot α
inst✝ : PredOrder α
a b : WithBot α
h :
  (fun a =>
        match a with
        | none => ⊥
        | Option.some a => if a = ⊥ then ⊥ else ↑(pred a))
      a <
    b
⊢ a ≤ b

Next tactic:
cases b
instance : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => ite (a = ⊥) ⊥ (some (pred a))
  pred_le a := by
    cases' a with a a
    · exact bot_le
    change ite _ _ _ ≤ _
    split_ifs
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases' a with a a
    · exact isMin_bot
    dsimp only at ha
    split_ifs at ha with ha'
    · exact (not_coe_le_bot _ ha).elim
    · rw [some_eq_coe, coe_le_coe, le_pred_iff_eq_bot] at ha
      exact (ha' ha).elim
  le_pred_of_lt {a b} h := by
    cases a
    · exact bot_le
    cases b
    · exact (not_lt_bot h).elim
    rw [some_lt_some] at h
    change _ ≤ ite _ _ _
    split_ifs with hb
    · rw [hb] at h
      exact (not_lt_bot h).elim
    · exact some_le_some.2 (le_pred_of_lt h)
  le_of_pred_lt {a b} h := by
    cases b
    · 

Proof state:
case none
α : Type u_1
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : PartialOrder α
inst✝¹ : OrderBot α
inst✝ : PredOrder α
a : WithBot α
h :
  (fun a =>
        match a with
        | none => ⊥
        | Option.some a => if a = ⊥ then ⊥ else ↑(pred a))
      a <
    none
⊢ a ≤ none

Next tactic:
exact (not_lt_bot h).elim
instance : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => ite (a = ⊥) ⊥ (some (pred a))
  pred_le a := by
    cases' a with a a
    · exact bot_le
    change ite _ _ _ ≤ _
    split_ifs
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases' a with a a
    · exact isMin_bot
    dsimp only at ha
    split_ifs at ha with ha'
    · exact (not_coe_le_bot _ ha).elim
    · rw [some_eq_coe, coe_le_coe, le_pred_iff_eq_bot] at ha
      exact (ha' ha).elim
  le_pred_of_lt {a b} h := by
    cases a
    · exact bot_le
    cases b
    · exact (not_lt_bot h).elim
    rw [some_lt_some] at h
    change _ ≤ ite _ _ _
    split_ifs with hb
    · rw [hb] at h
      exact (not_lt_bot h).elim
    · exact some_le_some.2 (le_pred_of_lt h)
  le_of_pred_lt {a b} h := by
    cases b
    · exact (not_lt_bot h).elim
    

Proof state:
case some
α : Type u_1
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : PartialOrder α
inst✝¹ : OrderBot α
inst✝ : PredOrder α
a : WithBot α
val✝ : α
h :
  (fun a =>
        match a with
        | none => ⊥
        | Option.some a => if a = ⊥ then ⊥ else ↑(pred a))
      a <
    Option.some val✝
⊢ a ≤ Option.some val✝

Next tactic:
cases a
instance : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => ite (a = ⊥) ⊥ (some (pred a))
  pred_le a := by
    cases' a with a a
    · exact bot_le
    change ite _ _ _ ≤ _
    split_ifs
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases' a with a a
    · exact isMin_bot
    dsimp only at ha
    split_ifs at ha with ha'
    · exact (not_coe_le_bot _ ha).elim
    · rw [some_eq_coe, coe_le_coe, le_pred_iff_eq_bot] at ha
      exact (ha' ha).elim
  le_pred_of_lt {a b} h := by
    cases a
    · exact bot_le
    cases b
    · exact (not_lt_bot h).elim
    rw [some_lt_some] at h
    change _ ≤ ite _ _ _
    split_ifs with hb
    · rw [hb] at h
      exact (not_lt_bot h).elim
    · exact some_le_some.2 (le_pred_of_lt h)
  le_of_pred_lt {a b} h := by
    cases b
    · exact (not_lt_bot h).elim
    cases a
    · 

Proof state:
case some.none
α : Type u_1
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : PartialOrder α
inst✝¹ : OrderBot α
inst✝ : PredOrder α
val✝ : α
h :
  (fun a =>
        match a with
        | none => ⊥
        | Option.some a => if a = ⊥ then ⊥ else ↑(pred a))
      none <
    Option.some val✝
⊢ none ≤ Option.some val✝

Next tactic:
exact bot_le
instance : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => ite (a = ⊥) ⊥ (some (pred a))
  pred_le a := by
    cases' a with a a
    · exact bot_le
    change ite _ _ _ ≤ _
    split_ifs
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases' a with a a
    · exact isMin_bot
    dsimp only at ha
    split_ifs at ha with ha'
    · exact (not_coe_le_bot _ ha).elim
    · rw [some_eq_coe, coe_le_coe, le_pred_iff_eq_bot] at ha
      exact (ha' ha).elim
  le_pred_of_lt {a b} h := by
    cases a
    · exact bot_le
    cases b
    · exact (not_lt_bot h).elim
    rw [some_lt_some] at h
    change _ ≤ ite _ _ _
    split_ifs with hb
    · rw [hb] at h
      exact (not_lt_bot h).elim
    · exact some_le_some.2 (le_pred_of_lt h)
  le_of_pred_lt {a b} h := by
    cases b
    · exact (not_lt_bot h).elim
    cases a
    · exact bot_le
    

Proof state:
case some.some
α : Type u_1
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : PartialOrder α
inst✝¹ : OrderBot α
inst✝ : PredOrder α
val✝¹ val✝ : α
h :
  (fun a =>
        match a with
        | none => ⊥
        | Option.some a => if a = ⊥ then ⊥ else ↑(pred a))
      (Option.some val✝) <
    Option.some val✝¹
⊢ Option.some val✝ ≤ Option.some val✝¹

Next tactic:
dsimp only at h
instance : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => ite (a = ⊥) ⊥ (some (pred a))
  pred_le a := by
    cases' a with a a
    · exact bot_le
    change ite _ _ _ ≤ _
    split_ifs
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases' a with a a
    · exact isMin_bot
    dsimp only at ha
    split_ifs at ha with ha'
    · exact (not_coe_le_bot _ ha).elim
    · rw [some_eq_coe, coe_le_coe, le_pred_iff_eq_bot] at ha
      exact (ha' ha).elim
  le_pred_of_lt {a b} h := by
    cases a
    · exact bot_le
    cases b
    · exact (not_lt_bot h).elim
    rw [some_lt_some] at h
    change _ ≤ ite _ _ _
    split_ifs with hb
    · rw [hb] at h
      exact (not_lt_bot h).elim
    · exact some_le_some.2 (le_pred_of_lt h)
  le_of_pred_lt {a b} h := by
    cases b
    · exact (not_lt_bot h).elim
    cases a
    · exact bot_le
    dsimp only at h
    

Proof state:
case some.some
α : Type u_1
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : PartialOrder α
inst✝¹ : OrderBot α
inst✝ : PredOrder α
val✝¹ val✝ : α
h : (if val✝ = ⊥ then ⊥ else ↑(pred val✝)) < Option.some val✝¹
⊢ Option.some val✝ ≤ Option.some val✝¹

Next tactic:
rw [some_le_some]
instance : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => ite (a = ⊥) ⊥ (some (pred a))
  pred_le a := by
    cases' a with a a
    · exact bot_le
    change ite _ _ _ ≤ _
    split_ifs
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases' a with a a
    · exact isMin_bot
    dsimp only at ha
    split_ifs at ha with ha'
    · exact (not_coe_le_bot _ ha).elim
    · rw [some_eq_coe, coe_le_coe, le_pred_iff_eq_bot] at ha
      exact (ha' ha).elim
  le_pred_of_lt {a b} h := by
    cases a
    · exact bot_le
    cases b
    · exact (not_lt_bot h).elim
    rw [some_lt_some] at h
    change _ ≤ ite _ _ _
    split_ifs with hb
    · rw [hb] at h
      exact (not_lt_bot h).elim
    · exact some_le_some.2 (le_pred_of_lt h)
  le_of_pred_lt {a b} h := by
    cases b
    · exact (not_lt_bot h).elim
    cases a
    · exact bot_le
    dsimp only at h
    rw [some_le_some]
    

Proof state:
case some.some
α : Type u_1
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : PartialOrder α
inst✝¹ : OrderBot α
inst✝ : PredOrder α
val✝¹ val✝ : α
h : (if val✝ = ⊥ then ⊥ else ↑(pred val✝)) < Option.some val✝¹
⊢ val✝ ≤ val✝¹

Next tactic:
split_ifs at h with ha
instance : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => ite (a = ⊥) ⊥ (some (pred a))
  pred_le a := by
    cases' a with a a
    · exact bot_le
    change ite _ _ _ ≤ _
    split_ifs
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases' a with a a
    · exact isMin_bot
    dsimp only at ha
    split_ifs at ha with ha'
    · exact (not_coe_le_bot _ ha).elim
    · rw [some_eq_coe, coe_le_coe, le_pred_iff_eq_bot] at ha
      exact (ha' ha).elim
  le_pred_of_lt {a b} h := by
    cases a
    · exact bot_le
    cases b
    · exact (not_lt_bot h).elim
    rw [some_lt_some] at h
    change _ ≤ ite _ _ _
    split_ifs with hb
    · rw [hb] at h
      exact (not_lt_bot h).elim
    · exact some_le_some.2 (le_pred_of_lt h)
  le_of_pred_lt {a b} h := by
    cases b
    · exact (not_lt_bot h).elim
    cases a
    · exact bot_le
    dsimp only at h
    rw [some_le_some]
    split_ifs at h with ha
    · 

Proof state:
case pos
α : Type u_1
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : PartialOrder α
inst✝¹ : OrderBot α
inst✝ : PredOrder α
val✝¹ val✝ : α
ha : val✝ = ⊥
h : ⊥ < Option.some val✝¹
⊢ val✝ ≤ val✝¹

Next tactic:
rw [ha]
instance : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => ite (a = ⊥) ⊥ (some (pred a))
  pred_le a := by
    cases' a with a a
    · exact bot_le
    change ite _ _ _ ≤ _
    split_ifs
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases' a with a a
    · exact isMin_bot
    dsimp only at ha
    split_ifs at ha with ha'
    · exact (not_coe_le_bot _ ha).elim
    · rw [some_eq_coe, coe_le_coe, le_pred_iff_eq_bot] at ha
      exact (ha' ha).elim
  le_pred_of_lt {a b} h := by
    cases a
    · exact bot_le
    cases b
    · exact (not_lt_bot h).elim
    rw [some_lt_some] at h
    change _ ≤ ite _ _ _
    split_ifs with hb
    · rw [hb] at h
      exact (not_lt_bot h).elim
    · exact some_le_some.2 (le_pred_of_lt h)
  le_of_pred_lt {a b} h := by
    cases b
    · exact (not_lt_bot h).elim
    cases a
    · exact bot_le
    dsimp only at h
    rw [some_le_some]
    split_ifs at h with ha
    · rw [ha]
      

Proof state:
case pos
α : Type u_1
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : PartialOrder α
inst✝¹ : OrderBot α
inst✝ : PredOrder α
val✝¹ val✝ : α
ha : val✝ = ⊥
h : ⊥ < Option.some val✝¹
⊢ ⊥ ≤ val✝¹

Next tactic:
exact bot_le
instance : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => ite (a = ⊥) ⊥ (some (pred a))
  pred_le a := by
    cases' a with a a
    · exact bot_le
    change ite _ _ _ ≤ _
    split_ifs
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases' a with a a
    · exact isMin_bot
    dsimp only at ha
    split_ifs at ha with ha'
    · exact (not_coe_le_bot _ ha).elim
    · rw [some_eq_coe, coe_le_coe, le_pred_iff_eq_bot] at ha
      exact (ha' ha).elim
  le_pred_of_lt {a b} h := by
    cases a
    · exact bot_le
    cases b
    · exact (not_lt_bot h).elim
    rw [some_lt_some] at h
    change _ ≤ ite _ _ _
    split_ifs with hb
    · rw [hb] at h
      exact (not_lt_bot h).elim
    · exact some_le_some.2 (le_pred_of_lt h)
  le_of_pred_lt {a b} h := by
    cases b
    · exact (not_lt_bot h).elim
    cases a
    · exact bot_le
    dsimp only at h
    rw [some_le_some]
    split_ifs at h with ha
    · rw [ha]
      exact bot_le
    · 

Proof state:
case neg
α : Type u_1
β : Type u_2
inst✝³ : DecidableEq α
inst✝² : PartialOrder α
inst✝¹ : OrderBot α
inst✝ : PredOrder α
val✝¹ val✝ : α
ha : ¬val✝ = ⊥
h : ↑(pred val✝) < Option.some val✝¹
⊢ val✝ ≤ val✝¹

Next tactic:
exact le_of_pred_lt (some_lt_some.1 h)
instance [hα : Nonempty α] : IsEmpty (SuccOrder (WithBot α)) :=
  ⟨by
    

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : NoMinOrder α
hα : Nonempty α
⊢ SuccOrder (WithBot α) → False

Next tactic:
intro
instance [hα : Nonempty α] : IsEmpty (SuccOrder (WithBot α)) :=
  ⟨by
    intro
    

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : NoMinOrder α
hα : Nonempty α
a✝ : SuccOrder (WithBot α)
⊢ False

Next tactic:
cases' h : succ (⊥ : WithBot α) with a ha
instance [hα : Nonempty α] : IsEmpty (SuccOrder (WithBot α)) :=
  ⟨by
    intro
    cases' h : succ (⊥ : WithBot α) with a ha
    · 

Proof state:
case none
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : NoMinOrder α
hα : Nonempty α
a✝ : SuccOrder (WithBot α)
h : succ ⊥ = none
⊢ False

Next tactic:
exact hα.elim fun a => (max_of_succ_le h.le).not_lt <| bot_lt_coe a
instance [hα : Nonempty α] : IsEmpty (SuccOrder (WithBot α)) :=
  ⟨by
    intro
    cases' h : succ (⊥ : WithBot α) with a ha
    · exact hα.elim fun a => (max_of_succ_le h.le).not_lt <| bot_lt_coe a
    · 

Proof state:
case some
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : NoMinOrder α
hα : Nonempty α
a✝ : SuccOrder (WithBot α)
a : α
h : succ ⊥ = Option.some a
⊢ False

Next tactic:
obtain ⟨c, hc⟩ := exists_lt a
instance [hα : Nonempty α] : IsEmpty (SuccOrder (WithBot α)) :=
  ⟨by
    intro
    cases' h : succ (⊥ : WithBot α) with a ha
    · exact hα.elim fun a => (max_of_succ_le h.le).not_lt <| bot_lt_coe a
    · obtain ⟨c, hc⟩ := exists_lt a
      

Proof state:
case some.intro
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : NoMinOrder α
hα : Nonempty α
a✝ : SuccOrder (WithBot α)
a : α
h : succ ⊥ = Option.some a
c : α
hc : c < a
⊢ False

Next tactic:
rw [← some_lt_some, ← h] at hc
instance [hα : Nonempty α] : IsEmpty (SuccOrder (WithBot α)) :=
  ⟨by
    intro
    cases' h : succ (⊥ : WithBot α) with a ha
    · exact hα.elim fun a => (max_of_succ_le h.le).not_lt <| bot_lt_coe a
    · obtain ⟨c, hc⟩ := exists_lt a
      rw [← some_lt_some, ← h] at hc
      

Proof state:
case some.intro
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : NoMinOrder α
hα : Nonempty α
a✝ : SuccOrder (WithBot α)
a : α
h : succ ⊥ = Option.some a
c : α
hc : Option.some c < succ ⊥
⊢ False

Next tactic:
exact (le_of_lt_succ hc).not_lt (none_lt_some _)
instance predOrderOfNoMinOrder : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => some (pred a)
  pred_le a := by
    

Proof state:
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : NoMinOrder α
inst✝ : PredOrder α
a : WithBot α
⊢ (fun a =>
        match a with
        | none => ⊥
        | Option.some a => ↑(pred a))
      a ≤
    a

Next tactic:
cases' a with a a
instance predOrderOfNoMinOrder : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => some (pred a)
  pred_le a := by
    cases' a with a a
    · 

Proof state:
case none
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : NoMinOrder α
inst✝ : PredOrder α
⊢ (fun a =>
        match a with
        | none => ⊥
        | Option.some a => ↑(pred a))
      none ≤
    none

Next tactic:
exact bot_le
instance predOrderOfNoMinOrder : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => some (pred a)
  pred_le a := by
    cases' a with a a
    · exact bot_le
    · 

Proof state:
case some
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : NoMinOrder α
inst✝ : PredOrder α
a : α
⊢ (fun a =>
        match a with
        | none => ⊥
        | Option.some a => ↑(pred a))
      (Option.some a) ≤
    Option.some a

Next tactic:
exact some_le_some.2 (pred_le a)
instance predOrderOfNoMinOrder : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => some (pred a)
  pred_le a := by
    cases' a with a a
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    

Proof state:
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : NoMinOrder α
inst✝ : PredOrder α
a : WithBot α
ha :
  a ≤
    (fun a =>
        match a with
        | none => ⊥
        | Option.some a => ↑(pred a))
      a
⊢ IsMin a

Next tactic:
cases a
instance predOrderOfNoMinOrder : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => some (pred a)
  pred_le a := by
    cases' a with a a
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases a
    · 

Proof state:
case none
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : NoMinOrder α
inst✝ : PredOrder α
ha :
  none ≤
    (fun a =>
        match a with
        | none => ⊥
        | Option.some a => ↑(pred a))
      none
⊢ IsMin none

Next tactic:
exact isMin_bot
instance predOrderOfNoMinOrder : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => some (pred a)
  pred_le a := by
    cases' a with a a
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases a
    · exact isMin_bot
    · 

Proof state:
case some
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : NoMinOrder α
inst✝ : PredOrder α
val✝ : α
ha :
  Option.some val✝ ≤
    (fun a =>
        match a with
        | none => ⊥
        | Option.some a => ↑(pred a))
      (Option.some val✝)
⊢ IsMin (Option.some val✝)

Next tactic:
exact (not_isMin _ <| min_of_le_pred <| some_le_some.1 ha).elim
instance predOrderOfNoMinOrder : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => some (pred a)
  pred_le a := by
    cases' a with a a
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases a
    · exact isMin_bot
    · exact (not_isMin _ <| min_of_le_pred <| some_le_some.1 ha).elim
  le_pred_of_lt {a b} h := by
    

Proof state:
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : NoMinOrder α
inst✝ : PredOrder α
a b : WithBot α
h : a < b
⊢ a ≤
    (fun a =>
        match a with
        | none => ⊥
        | Option.some a => ↑(pred a))
      b

Next tactic:
cases b
instance predOrderOfNoMinOrder : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => some (pred a)
  pred_le a := by
    cases' a with a a
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases a
    · exact isMin_bot
    · exact (not_isMin _ <| min_of_le_pred <| some_le_some.1 ha).elim
  le_pred_of_lt {a b} h := by
    cases b
    · 

Proof state:
case none
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : NoMinOrder α
inst✝ : PredOrder α
a : WithBot α
h : a < none
⊢ a ≤
    (fun a =>
        match a with
        | none => ⊥
        | Option.some a => ↑(pred a))
      none

Next tactic:
exact (not_lt_bot h).elim
instance predOrderOfNoMinOrder : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => some (pred a)
  pred_le a := by
    cases' a with a a
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases a
    · exact isMin_bot
    · exact (not_isMin _ <| min_of_le_pred <| some_le_some.1 ha).elim
  le_pred_of_lt {a b} h := by
    cases b
    · exact (not_lt_bot h).elim
    

Proof state:
case some
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : NoMinOrder α
inst✝ : PredOrder α
a : WithBot α
val✝ : α
h : a < Option.some val✝
⊢ a ≤
    (fun a =>
        match a with
        | none => ⊥
        | Option.some a => ↑(pred a))
      (Option.some val✝)

Next tactic:
cases a
instance predOrderOfNoMinOrder : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => some (pred a)
  pred_le a := by
    cases' a with a a
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases a
    · exact isMin_bot
    · exact (not_isMin _ <| min_of_le_pred <| some_le_some.1 ha).elim
  le_pred_of_lt {a b} h := by
    cases b
    · exact (not_lt_bot h).elim
    cases a
    · 

Proof state:
case some.none
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : NoMinOrder α
inst✝ : PredOrder α
val✝ : α
h : none < Option.some val✝
⊢ none ≤
    (fun a =>
        match a with
        | none => ⊥
        | Option.some a => ↑(pred a))
      (Option.some val✝)

Next tactic:
exact bot_le
instance predOrderOfNoMinOrder : PredOrder (WithBot α) where
  pred a :=
    match a with
    | ⊥ => ⊥
    | Option.some a => some (pred a)
  pred_le a := by
    cases' a with a a
    · exact bot_le
    · exact some_le_some.2 (pred_le a)
  min_of_le_pred {a} ha := by
    cases a
    · exact isMin_bot
    · exact (not_isMin _ <| min_of_le_pred <| some_le_some.1 ha).elim
  le_pred_of_lt {a b} h := by
    cases b
    · exact (not_lt_bot h).elim
    cases a
    · exact bot_le
    · 

Proof state:
case some.some
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : NoMinOrder α
inst✝ : PredOrder α
val✝¹ val✝ : α
h : Option.some val✝ < Option.some val✝¹
⊢ Option.some val✝ ≤
    (fun a =>
        match a with
        | none => ⊥
        | Option.some a => ↑(pred a))
      (Option.some val✝¹)

Next tactic:
exact some_le_some.2 (le_pred_of_lt <| some_lt_some.1 h)