l3lab/ntp-mathlib huggingface dataset:
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 some.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 b : α
h₁ : Option.some b ≤ o₃
h₂ : none ≤ o₃
ha : a ∈ Option.some b ⊔ 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 some.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 b : α
h₁ : Option.some b ≤ o₃
c : α
h₂ : Option.some c ≤ o₃
ha : a ∈ Option.some b ⊔ Option.some c
⊢ ∃ 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 <;> cases ha
      · 

Proof state:
case none.some.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 : α
h₁ : none ≤ o₃
h₂ : Option.some a ≤ o₃
⊢ ∃ b, b ∈ o₃ ∧ a ≤ b

Next tactic:
exact h₂ a rfl
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 <;> cases ha
      · exact h₂ a rfl

      · 

Proof state:
case some.none.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 : α
h₂ : none ≤ o₃
h₁ : Option.some a ≤ o₃
⊢ ∃ b, b ∈ o₃ ∧ a ≤ b

Next tactic:
exact h₁ a rfl
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 <;> cases ha
      · exact h₂ a rfl

      · exact h₁ a rfl

      · 

Proof state:
case some.some.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 α
b : α
h₁ : Option.some b ≤ o₃
c : α
h₂ : Option.some c ≤ o₃
⊢ ∃ b_1, b_1 ∈ o₃ ∧ (fun x x_1 => x ⊔ x_1) b c ≤ b_1

Next tactic:
rcases h₁ b rfl with ⟨d, ⟨⟩, h₁'⟩
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 <;> cases ha
      · exact h₂ a rfl

      · exact h₁ a rfl

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

Proof state:
case some.some.refl.intro.intro.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
b c d : α
h₁' : b ≤ d
h₁ : Option.some b ≤ Option.some d
h₂ : Option.some c ≤ Option.some d
⊢ ∃ b_1, b_1 ∈ Option.some d ∧ (fun x x_1 => x ⊔ x_1) b c ≤ b_1

Next tactic:
simp at h₂
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 <;> cases ha
      · exact h₂ a rfl

      · exact h₁ a rfl

      · rcases h₁ b rfl with ⟨d, ⟨⟩, h₁'⟩
        simp at h₂
        

Proof state:
case some.some.refl.intro.intro.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
b c d : α
h₁' : b ≤ d
h₁ : Option.some b ≤ Option.some d
h₂ : c ≤ d
⊢ ∃ b_1, b_1 ∈ Option.some d ∧ (fun x x_1 => x ⊔ x_1) b c ≤ b_1

Next tactic:
exact ⟨d, rfl, sup_le h₁' h₂⟩
instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    inf := Option.map₂ (· ⊓ ·),
    inf_le_left := fun o₁ o₂ a ha => by
      

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

Next tactic:
rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    inf := Option.map₂ (· ⊓ ·),
    inf_le_left := fun o₁ o₂ a ha => by
      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
      

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

Next tactic:
exact ⟨_, rfl, inf_le_left⟩
instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    inf := Option.map₂ (· ⊓ ·),
    inf_le_left := fun o₁ o₂ a ha => by
      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
      exact ⟨_, rfl, inf_le_left⟩,
    inf_le_right := fun o₁ o₂ a ha => by
      

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

Next tactic:
rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    inf := Option.map₂ (· ⊓ ·),
    inf_le_left := fun o₁ o₂ a ha => by
      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
      exact ⟨_, rfl, inf_le_left⟩,
    inf_le_right := fun o₁ o₂ a ha => by
      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
      

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

Next tactic:
exact ⟨_, rfl, inf_le_right⟩
instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    inf := Option.map₂ (· ⊓ ·),
    inf_le_left := fun o₁ o₂ a ha => by
      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
      exact ⟨_, rfl, inf_le_left⟩,
    inf_le_right := fun o₁ o₂ a ha => by
      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
      exact ⟨_, rfl, inf_le_right⟩,
    le_inf := 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✝ : SemilatticeInf α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
o₁ o₂ o₃ : WithBot α
h₁ : o₁ ≤ o₂
h₂ : o₁ ≤ o₃
a : α
ha : a ∈ o₁
⊢ ∃ b, b ∈ o₂ ⊓ o₃ ∧ a ≤ b

Next tactic:
cases ha
instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    inf := Option.map₂ (· ⊓ ·),
    inf_le_left := fun o₁ o₂ a ha => by
      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
      exact ⟨_, rfl, inf_le_left⟩,
    inf_le_right := fun o₁ o₂ a ha => by
      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
      exact ⟨_, rfl, inf_le_right⟩,
    le_inf := fun o₁ o₂ o₃ h₁ h₂ a ha => by
      cases ha
      

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

Next tactic:
rcases h₁ a rfl with ⟨b, ⟨⟩, ab⟩
instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    inf := Option.map₂ (· ⊓ ·),
    inf_le_left := fun o₁ o₂ a ha => by
      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
      exact ⟨_, rfl, inf_le_left⟩,
    inf_le_right := fun o₁ o₂ a ha => by
      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
      exact ⟨_, rfl, inf_le_right⟩,
    le_inf := fun o₁ o₂ o₃ h₁ h₂ a ha => by
      cases ha
      rcases h₁ a rfl with ⟨b, ⟨⟩, ab⟩
      

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

Next tactic:
rcases h₂ a rfl with ⟨c, ⟨⟩, ac⟩
instance semilatticeInf [SemilatticeInf α] : SemilatticeInf (WithBot α) :=
  { WithBot.partialOrder, @WithBot.orderBot α _ with
    inf := Option.map₂ (· ⊓ ·),
    inf_le_left := fun o₁ o₂ a ha => by
      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
      exact ⟨_, rfl, inf_le_left⟩,
    inf_le_right := fun o₁ o₂ a ha => by
      rcases Option.mem_map₂_iff.1 ha with ⟨a, b, (rfl : _ = _), (rfl : _ = _), rfl⟩
      exact ⟨_, rfl, inf_le_right⟩,
    le_inf := fun o₁ o₂ o₃ h₁ h₂ a ha => by
      cases ha
      rcases h₁ a rfl with ⟨b, ⟨⟩, ab⟩
      rcases h₂ a rfl with ⟨c, ⟨⟩, ac⟩
      

Proof state:
case refl.intro.intro.refl.intro.intro.refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝ : SemilatticeInf α
src✝¹ : PartialOrder (WithBot α) := partialOrder
src✝ : OrderBot (WithBot α) := orderBot
a b : α
ab : a ≤ b
h₁ : Option.some a ≤ Option.some b
c : α
ac : a ≤ c
h₂ : Option.some a ≤ Option.some c
⊢ ∃ b_1, b_1 ∈ Option.some b ⊓ Option.some c ∧ a ≤ b_1

Next tactic:
exact ⟨_, rfl, le_inf ab ac⟩
instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithBot α) (· ≤ ·)
  | none, x => isTrue fun a h => Option.noConfusion h
  | Option.some x, Option.some y =>
      if h : x ≤ y then isTrue (some_le_some.2 h) else isFalse <| by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝¹ : LE α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x y : α
h : ¬x ≤ y
⊢ ¬(fun x x_1 => x ≤ x_1) (Option.some x) (Option.some y)

Next tactic:
simp [*]
instance decidableLE [LE α] [@DecidableRel α (· ≤ ·)] : @DecidableRel (WithBot α) (· ≤ ·)
  | none, x => isTrue fun a h => Option.noConfusion h
  | Option.some x, Option.some y =>
      if h : x ≤ y then isTrue (some_le_some.2 h) else isFalse <| by simp [*]
  | Option.some x, none => isFalse fun h => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝¹ : LE α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
h : (fun x x_1 => x ≤ x_1) (Option.some x) none
⊢ False

Next tactic:
rcases h x rfl with ⟨y, ⟨_⟩, _⟩
instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
  | none, Option.some x => isTrue <| by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝¹ : LT α
inst✝ : DecidableRel fun x x_1 => x < x_1
x : α
⊢ (fun x x_1 => x < x_1) none (Option.some x)

Next tactic:
exists x, rfl
instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
  | none, Option.some x => isTrue <| by exists x, rfl; 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝¹ : LT α
inst✝ : DecidableRel fun x x_1 => x < x_1
x : α
⊢ ∀ (a : α), a ∈ none → a < x

Next tactic:
rintro _ ⟨⟩
instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
  | none, Option.some x => isTrue <| by exists x, rfl; rintro _ ⟨⟩
  | Option.some x, Option.some y =>
      if h : x < y then isTrue <| by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝¹ : LT α
inst✝ : DecidableRel fun x x_1 => x < x_1
x y : α
h : x < y
⊢ (fun x x_1 => x < x_1) (Option.some x) (Option.some y)

Next tactic:
simp [*]
instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
  | none, Option.some x => isTrue <| by exists x, rfl; rintro _ ⟨⟩
  | Option.some x, Option.some y =>
      if h : x < y then isTrue <| by simp [*] else isFalse <| by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝¹ : LT α
inst✝ : DecidableRel fun x x_1 => x < x_1
x y : α
h : ¬x < y
⊢ ¬(fun x x_1 => x < x_1) (Option.some x) (Option.some y)

Next tactic:
simp [*]
instance decidableLT [LT α] [@DecidableRel α (· < ·)] : @DecidableRel (WithBot α) (· < ·)
  | none, Option.some x => isTrue <| by exists x, rfl; rintro _ ⟨⟩
  | Option.some x, Option.some y =>
      if h : x < y then isTrue <| by simp [*] else isFalse <| by simp [*]
  | x, none => isFalse <| by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝¹ : LT α
inst✝ : DecidableRel fun x x_1 => x < x_1
x : WithBot α
⊢ ¬(fun x x_1 => x < x_1) x none

Next tactic:
rintro ⟨a, ⟨⟨⟩⟩⟩
instance instWellFoundedLT [LT α] [WellFoundedLT α] : WellFoundedLT (WithBot α) where
  wf :=
  have not_lt_bot : ∀ a : WithBot α, ¬ a < ⊥ := (fun.)
  have acc_bot := ⟨_, by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝¹ : LT α
inst✝ : WellFoundedLT α
not_lt_bot : ∀ (a : WithBot α), ¬a < ⊥
⊢ ∀ (y : WithBot α), y < ⊥ → Acc (fun x x_1 => x < x_1) y

Next tactic:
simp [not_lt_bot]
instance noTopOrder [LE α] [NoTopOrder α] [Nonempty α] : NoTopOrder (WithBot α) :=
  ⟨by
    

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝² : LE α
inst✝¹ : NoTopOrder α
inst✝ : Nonempty α
⊢ ∀ (a : WithBot α), ∃ b, ¬b ≤ a

Next tactic:
apply recBotCoe
instance noTopOrder [LE α] [NoTopOrder α] [Nonempty α] : NoTopOrder (WithBot α) :=
  ⟨by
    apply recBotCoe
    · 

Proof state:
case bot
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝² : LE α
inst✝¹ : NoTopOrder α
inst✝ : Nonempty α
⊢ ∃ b, ¬b ≤ ⊥

Next tactic:
exact ‹Nonempty α›.elim fun a => ⟨a, not_coe_le_bot a⟩
instance noTopOrder [LE α] [NoTopOrder α] [Nonempty α] : NoTopOrder (WithBot α) :=
  ⟨by
    apply recBotCoe
    · exact ‹Nonempty α›.elim fun a => ⟨a, not_coe_le_bot a⟩

    · 

Proof state:
case coe
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝² : LE α
inst✝¹ : NoTopOrder α
inst✝ : Nonempty α
⊢ ∀ (a : α), ∃ b, ¬b ≤ ↑a

Next tactic:
intro a
instance noTopOrder [LE α] [NoTopOrder α] [Nonempty α] : NoTopOrder (WithBot α) :=
  ⟨by
    apply recBotCoe
    · exact ‹Nonempty α›.elim fun a => ⟨a, not_coe_le_bot a⟩

    · intro a
      

Proof state:
case coe
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝² : LE α
inst✝¹ : NoTopOrder α
inst✝ : Nonempty α
a : α
⊢ ∃ b, ¬b ≤ ↑a

Next tactic:
obtain ⟨b, h⟩ := exists_not_le a
instance noTopOrder [LE α] [NoTopOrder α] [Nonempty α] : NoTopOrder (WithBot α) :=
  ⟨by
    apply recBotCoe
    · exact ‹Nonempty α›.elim fun a => ⟨a, not_coe_le_bot a⟩

    · intro a
      obtain ⟨b, h⟩ := exists_not_le a
      

Proof state:
case coe.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝² : LE α
inst✝¹ : NoTopOrder α
inst✝ : Nonempty α
a b : α
h : ¬b ≤ a
⊢ ∃ b, ¬b ≤ ↑a

Next tactic:
exact ⟨b, by rwa [coe_le_coe]⟩
instance noTopOrder [LE α] [NoTopOrder α] [Nonempty α] : NoTopOrder (WithBot α) :=
  ⟨by
    apply recBotCoe
    · exact ‹Nonempty α›.elim fun a => ⟨a, not_coe_le_bot a⟩

    · intro a
      obtain ⟨b, h⟩ := exists_not_le a
      exact ⟨b, by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝² : LE α
inst✝¹ : NoTopOrder α
inst✝ : Nonempty α
a b : α
h : ¬b ≤ a
⊢ ¬↑b ≤ ↑a

Next tactic:
rwa [coe_le_coe]
instance noMaxOrder [LT α] [NoMaxOrder α] [Nonempty α] : NoMaxOrder (WithBot α) :=
  ⟨by
    

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝² : LT α
inst✝¹ : NoMaxOrder α
inst✝ : Nonempty α
⊢ ∀ (a : WithBot α), ∃ b, a < b

Next tactic:
apply WithBot.recBotCoe
instance noMaxOrder [LT α] [NoMaxOrder α] [Nonempty α] : NoMaxOrder (WithBot α) :=
  ⟨by
    apply WithBot.recBotCoe
    · 

Proof state:
case bot
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝² : LT α
inst✝¹ : NoMaxOrder α
inst✝ : Nonempty α
⊢ ∃ b, ⊥ < b

Next tactic:
apply ‹Nonempty α›.elim
instance noMaxOrder [LT α] [NoMaxOrder α] [Nonempty α] : NoMaxOrder (WithBot α) :=
  ⟨by
    apply WithBot.recBotCoe
    · apply ‹Nonempty α›.elim
      

Proof state:
case bot
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝² : LT α
inst✝¹ : NoMaxOrder α
inst✝ : Nonempty α
⊢ α → ∃ b, ⊥ < b

Next tactic:
exact fun a => ⟨a, WithBot.bot_lt_coe a⟩
instance noMaxOrder [LT α] [NoMaxOrder α] [Nonempty α] : NoMaxOrder (WithBot α) :=
  ⟨by
    apply WithBot.recBotCoe
    · apply ‹Nonempty α›.elim
      exact fun a => ⟨a, WithBot.bot_lt_coe a⟩

    · 

Proof state:
case coe
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝² : LT α
inst✝¹ : NoMaxOrder α
inst✝ : Nonempty α
⊢ ∀ (a : α), ∃ b, ↑a < b

Next tactic:
intro a
instance noMaxOrder [LT α] [NoMaxOrder α] [Nonempty α] : NoMaxOrder (WithBot α) :=
  ⟨by
    apply WithBot.recBotCoe
    · apply ‹Nonempty α›.elim
      exact fun a => ⟨a, WithBot.bot_lt_coe a⟩

    · intro a
      

Proof state:
case coe
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝² : LT α
inst✝¹ : NoMaxOrder α
inst✝ : Nonempty α
a : α
⊢ ∃ b, ↑a < b

Next tactic:
obtain ⟨b, ha⟩ := exists_gt a
instance noMaxOrder [LT α] [NoMaxOrder α] [Nonempty α] : NoMaxOrder (WithBot α) :=
  ⟨by
    apply WithBot.recBotCoe
    · apply ‹Nonempty α›.elim
      exact fun a => ⟨a, WithBot.bot_lt_coe a⟩

    · intro a
      obtain ⟨b, ha⟩ := exists_gt a
      

Proof state:
case coe.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b✝ : α
inst✝² : LT α
inst✝¹ : NoMaxOrder α
inst✝ : Nonempty α
a b : α
ha : a < b
⊢ ∃ b, ↑a < b

Next tactic:
exact ⟨b, coe_lt_coe.mpr ha⟩
@[simp, norm_cast]
theorem coe_le_coe : (a : WithTop α) ≤ b ↔ a ≤ b := by
  

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

Next tactic:
simp only [← toDual_le_toDual_iff, toDual_apply_coe, WithBot.coe_le_coe, toDual_le_toDual]
instance orderBot [OrderBot α] : OrderBot (WithTop α) where
  bot := some ⊥
  bot_le o a ha := by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝¹ : LE α
inst✝ : OrderBot α
o : WithTop α
a : α
ha : a ∈ o
⊢ ∃ b, b ∈ ⊥ ∧ b ≤ a

Next tactic:
cases ha
instance orderBot [OrderBot α] : OrderBot (WithTop α) where
  bot := some ⊥
  bot_le 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✝¹ : LE α
inst✝ : OrderBot α
a : α
⊢ ∃ b, b ∈ ⊥ ∧ b ≤ a

Next tactic:
exact ⟨_, rfl, bot_le⟩
/-- There is a general version `top_le_iff`, but this lemma does not require a `PartialOrder`. -/
@[simp]
protected theorem top_le_iff : ∀ {a : WithTop α}, ⊤ ≤ a ↔ a = ⊤
  | (a : α) => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : LE α
a : α
⊢ ⊤ ≤ ↑a ↔ ↑a = ⊤

Next tactic:
simp [not_top_le_coe _]
/-- There is a general version `top_le_iff`, but this lemma does not require a `PartialOrder`. -/
@[simp]
protected theorem top_le_iff : ∀ {a : WithTop α}, ⊤ ≤ a ↔ a = ⊤
  | (a : α) => by simp [not_top_le_coe _]
  | ⊤ => by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
⊢ ⊤ ≤ ⊤ ↔ ⊤ = ⊤

Next tactic:
simp
protected theorem _root_.IsMin.withTop (h : IsMin a) : IsMin (a : WithTop α) := by
  -- defeq to is_max_to_dual_iff.mp (is_max.with_bot _), but that breaks API boundary
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
h : IsMin a
⊢ IsMin ↑a

Next tactic:
intro _ hb
protected theorem _root_.IsMin.withTop (h : IsMin a) : IsMin (a : WithTop α) := by
  -- defeq to is_max_to_dual_iff.mp (is_max.with_bot _), but that breaks API boundary
  intro _ hb
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
h : IsMin a
b✝ : WithTop α
hb : b✝ ≤ ↑a
⊢ ↑a ≤ b✝

Next tactic:
rw [← toDual_le_toDual_iff] at hb
protected theorem _root_.IsMin.withTop (h : IsMin a) : IsMin (a : WithTop α) := by
  -- defeq to is_max_to_dual_iff.mp (is_max.with_bot _), but that breaks API boundary
  intro _ hb
  rw [← toDual_le_toDual_iff] at hb
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
h : IsMin a
b✝ : WithTop α
hb : WithTop.toDual ↑a ≤ WithTop.toDual b✝
⊢ ↑a ≤ b✝

Next tactic:
simpa [toDual_le_iff] using h.toDual.withBot hb
@[simp, norm_cast]
theorem coe_lt_coe : (a : WithTop α) < b ↔ a < b := by
  

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

Next tactic:
simp only [← toDual_lt_toDual_iff, toDual_apply_coe, WithBot.coe_lt_coe, toDual_lt_toDual]
theorem coe_lt_top (a : α) : (a : WithTop α) < ⊤ := by
  

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

Next tactic:
simp [← toDual_lt_toDual_iff, WithBot.bot_lt_coe]
@[simp]
theorem not_none_lt (a : WithTop α) : ¬@LT.lt (WithTop α) _ none a := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : LT α
a✝ b : α
a : WithTop α
⊢ ¬none < a

Next tactic:
rw [← toDual_lt_toDual_iff]
@[simp]
theorem not_none_lt (a : WithTop α) : ¬@LT.lt (WithTop α) _ none a := by
  rw [← toDual_lt_toDual_iff]
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : LT α
a✝ b : α
a : WithTop α
⊢ ¬WithTop.toDual a < WithTop.toDual none

Next tactic:
exact WithBot.not_lt_none _