File: Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean

full_name: WithTop.one
code: @[to_additive]
instance one : One (WithTop α) 
goal: One (WithTop α)

full_name: WithTop.zero
code: @[to_additive]
instance one : One (WithTop α) 
goal: Zero (WithTop α)

full_name: WithTop.coe_zero
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_one : ((1 : α) : WithTop α) = 1 
goal: ↑0 = 0

full_name: WithTop.coe_one
code: @[to_additive (attr := simp, norm_cast)]
theorem coe_one : ((1 : α) : WithTop α) = 1 
goal: ↑1 = 1

full_name: WithTop.coe_eq_zero
code: @[to_additive (attr := simp, norm_cast)]
lemma coe_eq_one : (a : WithTop α) = 1 ↔ a = 1 
goal: ↑a = 0 ↔ a = 0

full_name: WithTop.coe_eq_one
code: @[to_additive (attr := simp, norm_cast)]
lemma coe_eq_one : (a : WithTop α) = 1 ↔ a = 1 
goal: ↑a = 1 ↔ a = 1

full_name: WithTop.one_eq_coe
code: @[to_additive (attr := simp, norm_cast)]
lemma one_eq_coe : 1 = (a : WithTop α) ↔ a = 1 
goal: 1 = ↑a ↔ a = 1

full_name: WithTop.zero_eq_coe
code: @[to_additive (attr := simp, norm_cast)]
lemma one_eq_coe : 1 = (a : WithTop α) ↔ a = 1 
goal: 0 = ↑a ↔ a = 0

full_name: WithTop.top_ne_zero
code: @[to_additive (attr := simp)] lemma top_ne_one : (⊤ : WithTop α) ≠ 1 
goal: ⊤ ≠ 0

full_name: WithTop.top_ne_one
code: @[to_additive (attr := simp)] lemma top_ne_one : (⊤ : WithTop α) ≠ 1 
goal: ⊤ ≠ 1

full_name: WithTop.one_ne_top
code: @[to_additive (attr := simp)] lemma one_ne_top : (1 : WithTop α) ≠ ⊤ 
goal: 1 ≠ ⊤

full_name: WithTop.zero_ne_top
code: @[to_additive (attr := simp)] lemma one_ne_top : (1 : WithTop α) ≠ ⊤ 
goal: 0 ≠ ⊤

full_name: WithTop.untop_one
code: @[to_additive (attr := simp)]
theorem untop_one : (1 : WithTop α).untop coe_ne_top = 1 
goal: WithTop.untop 1 ⋯ = 1

full_name: WithTop.untop_zero
code: @[to_additive (attr := simp)]
theorem untop_one : (1 : WithTop α).untop coe_ne_top = 1 
goal: WithTop.untop 0 ⋯ = 0

full_name: WithTop.untop_one'
code: @[to_additive (attr := simp)]
theorem untop_one' (d : α) : (1 : WithTop α).untop' d = 1 
goal: WithTop.untop' d 1 = 1

full_name: WithTop.untop_zero'
code: @[to_additive (attr := simp)]
theorem untop_one' (d : α) : (1 : WithTop α).untop' d = 1 
goal: WithTop.untop' d 0 = 0

full_name: WithTop.one_le_coe
code: @[to_additive (attr := simp, norm_cast) coe_nonneg]
theorem one_le_coe [LE α] {a : α} : 1 ≤ (a : WithTop α) ↔ 1 ≤ a 
goal: 1 ≤ ↑a ↔ 1 ≤ a

full_name: WithTop.coe_nonneg
code: @[to_additive (attr := simp, norm_cast) coe_nonneg]
theorem one_le_coe [LE α] {a : α} : 1 ≤ (a : WithTop α) ↔ 1 ≤ a 
goal: 0 ≤ ↑a ↔ 0 ≤ a

full_name: WithTop.coe_le_one
code: @[to_additive (attr := simp, norm_cast) coe_le_zero]
theorem coe_le_one [LE α] {a : α} : (a : WithTop α) ≤ 1 ↔ a ≤ 1 
goal: ↑a ≤ 1 ↔ a ≤ 1

full_name: WithTop.coe_le_zero
code: @[to_additive (attr := simp, norm_cast) coe_le_zero]
theorem coe_le_one [LE α] {a : α} : (a : WithTop α) ≤ 1 ↔ a ≤ 1 
goal: ↑a ≤ 0 ↔ a ≤ 0

full_name: WithTop.coe_pos
code: @[to_additive (attr := simp, norm_cast) coe_pos]
theorem one_lt_coe [LT α] {a : α} : 1 < (a : WithTop α) ↔ 1 < a 
goal: 0 < ↑a ↔ 0 < a

full_name: WithTop.one_lt_coe
code: @[to_additive (attr := simp, norm_cast) coe_pos]
theorem one_lt_coe [LT α] {a : α} : 1 < (a : WithTop α) ↔ 1 < a 
goal: 1 < ↑a ↔ 1 < a

full_name: WithTop.coe_lt_one
code: @[to_additive (attr := simp, norm_cast) coe_lt_zero]
theorem coe_lt_one [LT α] {a : α} : (a : WithTop α) < 1 ↔ a < 1 
goal: ↑a < 1 ↔ a < 1

full_name: WithTop.coe_lt_zero
code: @[to_additive (attr := simp, norm_cast) coe_lt_zero]
theorem coe_lt_one [LT α] {a : α} : (a : WithTop α) < 1 ↔ a < 1 
goal: ↑a < 0 ↔ a < 0

full_name: WithTop.map_zero
code: @[to_additive (attr := simp)]
protected theorem map_one {β} (f : α → β) : (1 : WithTop α).map f = (f 1 : WithTop β) 
goal: WithTop.map f 0 = ↑(f 0)

full_name: WithTop.map_one
code: @[to_additive (attr := simp)]
protected theorem map_one {β} (f : α → β) : (1 : WithTop α).map f = (f 1 : WithTop β) 
goal: WithTop.map f 1 = ↑(f 1)

full_name: WithTop.zeroLEOneClass
code: instance zeroLEOneClass [Zero α] [LE α] [ZeroLEOneClass α] : ZeroLEOneClass (WithTop α) 
goal: ZeroLEOneClass (WithTop α)

full_name: WithTop.add
code: instance add : Add (WithTop α) 
goal: Add (WithTop α)

full_name: WithTop.coe_add
code: @[simp, norm_cast] lemma coe_add (a b : α) : ↑(a + b) = (a + b : WithTop α) 
goal: ↑(a + b) = ↑a + ↑b

full_name: WithTop.top_add
code: @[simp]
theorem top_add (a : WithTop α) : ⊤ + a = ⊤ 
goal: ⊤ + a = ⊤

full_name: WithTop.add_top
code: @[simp]
theorem add_top (a : WithTop α) : a + ⊤ = ⊤ 
goal: a + ⊤ = ⊤

full_name: WithTop.add_eq_top
code: @[simp]
theorem add_eq_top : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ 
goal: a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤

full_name: WithTop.add_ne_top
code: theorem add_ne_top : a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤ 
goal: a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤

full_name: WithTop.add_lt_top
code: theorem add_lt_top [LT α] {a b : WithTop α} : a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤ 
goal: a + b < ⊤ ↔ a < ⊤ ∧ b < ⊤

full_name: WithTop.add_eq_coe
code: theorem add_eq_coe :
    ∀ {a b : WithTop α} {c : α}, a + b = c ↔ ∃ a' b' : α, ↑a' = a ∧ ↑b' = b ∧ a' + b' = c
  
goal: a + b = ↑c ↔ ∃ a' b', ↑a' = a ∧ ↑b' = b ∧ a' + b' = c

full_name: WithTop.add_coe_eq_top_iff
code: theorem add_coe_eq_top_iff {x : WithTop α} {y : α} : x + y = ⊤ ↔ x = ⊤ 
goal: x + ↑y = ⊤ ↔ x = ⊤

full_name: WithTop.coe_add_eq_top_iff
code: theorem coe_add_eq_top_iff {y : WithTop α} : ↑x + y = ⊤ ↔ y = ⊤ 
goal: ↑x + y = ⊤ ↔ y = ⊤

full_name: WithTop.add_right_cancel_iff
code: theorem add_right_cancel_iff [IsRightCancelAdd α] (ha : a ≠ ⊤) : b + a = c + a ↔ b = c 
goal: b + a = c + a ↔ b = c

full_name: WithTop.add_right_cancel
code: theorem add_right_cancel [IsRightCancelAdd α] (ha : a ≠ ⊤) (h : b + a = c + a) : b = c 
goal: b = c

full_name: WithTop.add_left_cancel_iff
code: theorem add_left_cancel_iff [IsLeftCancelAdd α] (ha : a ≠ ⊤) : a + b = a + c ↔ b = c 
goal: a + b = a + c ↔ b = c

full_name: WithTop.add_left_cancel
code: theorem add_left_cancel [IsLeftCancelAdd α] (ha : a ≠ ⊤) (h : a + b = a + c) : b = c 
goal: b = c

full_name: WithTop.covariantClass_add_le
code: instance covariantClass_add_le [LE α] [CovariantClass α α (· + ·) (· ≤ ·)] :
    CovariantClass (WithTop α) (WithTop α) (· + ·) (· ≤ ·) 
goal: CovariantClass (WithTop α) (WithTop α) (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: WithTop.covariantClass_swap_add_le
code: instance covariantClass_swap_add_le [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
    CovariantClass (WithTop α) (WithTop α) (swap (· + ·)) (· ≤ ·) 
goal: CovariantClass (WithTop α) (WithTop α) (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: WithTop.contravariantClass_add_lt
code: instance contravariantClass_add_lt [LT α] [ContravariantClass α α (· + ·) (· < ·)] :
    ContravariantClass (WithTop α) (WithTop α) (· + ·) (· < ·) 
goal: ContravariantClass (WithTop α) (WithTop α) (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: WithTop.contravariantClass_swap_add_lt
code: instance contravariantClass_swap_add_lt [LT α] [ContravariantClass α α (swap (· + ·)) (· < ·)] :
    ContravariantClass (WithTop α) (WithTop α) (swap (· + ·)) (· < ·) 
goal: ContravariantClass (WithTop α) (WithTop α) (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: WithTop.le_of_add_le_add_left
code: protected theorem le_of_add_le_add_left [LE α] [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤)
    (h : a + b ≤ a + c) : b ≤ c 
goal: b ≤ c

full_name: WithTop.le_of_add_le_add_right
code: protected theorem le_of_add_le_add_right [LE α] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (ha : a ≠ ⊤) (h : b + a ≤ c + a) : b ≤ c 
goal: b ≤ c

full_name: WithTop.add_lt_add_left
code: protected theorem add_lt_add_left [LT α] [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤)
    (h : b < c) : a + b < a + c 
goal: a + b < a + c

full_name: WithTop.add_lt_add_right
code: protected theorem add_lt_add_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤)
    (h : b < c) : b + a < c + a 
goal: b + a < c + a

full_name: WithTop.add_le_add_iff_left
code: protected theorem add_le_add_iff_left [LE α] [CovariantClass α α (· + ·) (· ≤ ·)]
    [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊤) : a + b ≤ a + c ↔ b ≤ c 
goal: a + b ≤ a + c ↔ b ≤ c

full_name: WithTop.add_le_add_iff_right
code: protected theorem add_le_add_iff_right [LE α] [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
    [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊤) : b + a ≤ c + a ↔ b ≤ c 
goal: b + a ≤ c + a ↔ b ≤ c

full_name: WithTop.add_lt_add_iff_left
code: protected theorem add_lt_add_iff_left [LT α] [CovariantClass α α (· + ·) (· < ·)]
    [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊤) : a + b < a + c ↔ b < c 
goal: a + b < a + c ↔ b < c

full_name: WithTop.add_lt_add_iff_right
code: protected theorem add_lt_add_iff_right [LT α] [CovariantClass α α (swap (· + ·)) (· < ·)]
    [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊤) : b + a < c + a ↔ b < c 
goal: b + a < c + a ↔ b < c

full_name: WithTop.add_lt_add_of_le_of_lt
code: protected theorem add_lt_add_of_le_of_lt [Preorder α] [CovariantClass α α (· + ·) (· < ·)]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊤) (hab : a ≤ b) (hcd : c < d) :
    a + c < b + d 
goal: a + c < b + d

full_name: WithTop.add_lt_add_of_lt_of_le
code: protected theorem add_lt_add_of_lt_of_le [Preorder α] [CovariantClass α α (· + ·) (· ≤ ·)]
    [CovariantClass α α (swap (· + ·)) (· < ·)] (hc : c ≠ ⊤) (hab : a < b) (hcd : c ≤ d) :
    a + c < b + d 
goal: a + c < b + d

full_name: WithTop.map_add
code: @[simp]
protected theorem map_add {F} [Add β] [FunLike F α β] [AddHomClass F α β]
    (f : F) (a b : WithTop α) :
    (a + b).map f = a.map f + b.map f 
goal: WithTop.map (⇑f) (a + b) = WithTop.map (⇑f) a + WithTop.map (⇑f) b

full_name: WithTop.addSemigroup
code: instance addSemigroup [AddSemigroup α] : AddSemigroup (WithTop α) 
goal: AddSemigroup (WithTop α)

full_name: WithTop.addCommSemigroup
code: instance addCommSemigroup [AddCommSemigroup α] : AddCommSemigroup (WithTop α) 
goal: AddCommSemigroup (WithTop α)

full_name: WithTop.addZeroClass
code: instance addZeroClass [AddZeroClass α] : AddZeroClass (WithTop α) 
goal: AddZeroClass (WithTop α)

full_name: WithTop.addMonoid
code: instance addMonoid : AddMonoid (WithTop α) 
goal: AddMonoid (WithTop α)

full_name: WithTop.coe_nsmul
code: @[simp, norm_cast] lemma coe_nsmul (a : α) (n : ℕ) : ↑(n • a) = n • (a : WithTop α) 
goal: ↑(n • a) = n • ↑a

full_name: WithTop.addHom
code: /-- Coercion from `α` to `WithTop α` as an `AddMonoidHom`. -/
def addHom : α →+ WithTop α 
goal: α →+ WithTop α

full_name: WithTop.coe_addHom
code: @[simp, norm_cast] lemma coe_addHom : ⇑(addHom : α →+ WithTop α) = WithTop.some 
goal: ⇑WithTop.addHom = WithTop.some

full_name: WithTop.addCommMonoid
code: instance addCommMonoid [AddCommMonoid α] : AddCommMonoid (WithTop α) 
goal: AddCommMonoid (WithTop α)

full_name: WithTop.addMonoidWithOne
code: instance addMonoidWithOne : AddMonoidWithOne (WithTop α) 
goal: AddMonoidWithOne (WithTop α)

full_name: WithTop.coe_natCast
code: @[simp, norm_cast] lemma coe_natCast (n : ℕ) : ((n : α) : WithTop α) = n 
goal: ↑↑n = ↑n

full_name: WithTop.natCast_ne_top
code: @[simp] lemma natCast_ne_top (n : ℕ) : (n : WithTop α) ≠ ⊤ 
goal: ↑n ≠ ⊤

full_name: WithTop.top_ne_natCast
code: @[simp] lemma top_ne_natCast (n : ℕ) : (⊤ : WithTop α) ≠ n 
goal: ⊤ ≠ ↑n

full_name: WithTop.coe_ofNat
code: @[simp] lemma coe_ofNat (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : α) : WithTop α) = OfNat.ofNat n 
goal: ↑(OfNat.ofNat n) = OfNat.ofNat n

full_name: WithTop.coe_eq_ofNat
code: @[simp] lemma coe_eq_ofNat (n : ℕ) [n.AtLeastTwo] (m : α) :
    (m : WithTop α) = no_index (OfNat.ofNat n) ↔ m = OfNat.ofNat n 
goal: ↑m = OfNat.ofNat n ↔ m = OfNat.ofNat n

full_name: WithTop.ofNat_eq_coe
code: @[simp] lemma ofNat_eq_coe (n : ℕ) [n.AtLeastTwo] (m : α) :
    no_index (OfNat.ofNat n) = (m : WithTop α) ↔ OfNat.ofNat n = m 
goal: OfNat.ofNat n = ↑m ↔ OfNat.ofNat n = m

full_name: WithTop.ofNat_ne_top
code: @[simp] lemma ofNat_ne_top (n : ℕ) [n.AtLeastTwo] : no_index (OfNat.ofNat n : WithTop α) ≠ ⊤ 
goal: OfNat.ofNat n ≠ ⊤

full_name: WithTop.top_ne_ofNat
code: @[simp] lemma top_ne_ofNat (n : ℕ) [n.AtLeastTwo] : (⊤ : WithTop α) ≠ no_index (OfNat.ofNat n) 
goal: ⊤ ≠ OfNat.ofNat n

full_name: WithTop.charZero
code: instance charZero [AddMonoidWithOne α] [CharZero α] : CharZero (WithTop α) 
goal: CharZero (WithTop α)

full_name: WithTop.addCommMonoidWithOne
code: instance addCommMonoidWithOne [AddCommMonoidWithOne α] : AddCommMonoidWithOne (WithTop α) 
goal: AddCommMonoidWithOne (WithTop α)

full_name: WithTop.existsAddOfLE
code: instance existsAddOfLE [LE α] [Add α] [ExistsAddOfLE α] : ExistsAddOfLE (WithTop α) 
goal: ExistsAddOfLE (WithTop α)

full_name: WithTop.zero_lt_top
code: @[simp]
theorem zero_lt_top [Zero α] [LT α] : (0 : WithTop α) < ⊤ 
goal: 0 < ⊤

full_name: WithTop.zero_lt_coe
code: @[norm_cast]
theorem zero_lt_coe [Zero α] [LT α] (a : α) : (0 : WithTop α) < a ↔ 0 < a 
goal: 0 < ↑a ↔ 0 < a

full_name: ZeroHom.withTopMap_apply
code: /-- A version of `WithTop.map` for `OneHom`s. -/
@[to_additive (attr := simps (config := .asFn))
  "A version of `WithTop.map` for `ZeroHom`s"]
protected def _root_.OneHom.withTopMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
    OneHom (WithTop M) (WithTop N) 
goal: ⇑f.withTopMap = WithTop.map ⇑f

full_name: OneHom.withTopMap_apply
code: /-- A version of `WithTop.map` for `OneHom`s. -/
@[to_additive (attr := simps (config := .asFn))
  "A version of `WithTop.map` for `ZeroHom`s"]
protected def _root_.OneHom.withTopMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
    OneHom (WithTop M) (WithTop N) 
goal: ⇑f.withTopMap = WithTop.map ⇑f

full_name: OneHom.withTopMap
code: /-- A version of `WithTop.map` for `OneHom`s. -/
@[to_additive (attr := simps (config := .asFn))
  "A version of `WithTop.map` for `ZeroHom`s"]
protected def _root_.OneHom.withTopMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
    OneHom (WithTop M) (WithTop N) 
goal: OneHom (WithTop M) (WithTop N)

full_name: ZeroHom.withTopMap
code: /-- A version of `WithTop.map` for `OneHom`s. -/
@[to_additive (attr := simps (config := .asFn))
  "A version of `WithTop.map` for `ZeroHom`s"]
protected def _root_.OneHom.withTopMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
    OneHom (WithTop M) (WithTop N) 
goal: ZeroHom (WithTop M) (WithTop N)

full_name: AddHom.withTopMap
code: /-- A version of `WithTop.map` for `AddHom`s. -/
@[simps (config := .asFn)]
protected def _root_.AddHom.withTopMap {M N : Type*} [Add M] [Add N] (f : AddHom M N) :
    AddHom (WithTop M) (WithTop N) 
goal: AddHom (WithTop M) (WithTop N)

full_name: AddHom.withTopMap_apply
code: /-- A version of `WithTop.map` for `AddHom`s. -/
@[simps (config := .asFn)]
protected def _root_.AddHom.withTopMap {M N : Type*} [Add M] [Add N] (f : AddHom M N) :
    AddHom (WithTop M) (WithTop N) 
goal: ⇑f.withTopMap = WithTop.map ⇑f

full_name: AddMonoidHom.withTopMap
code: /-- A version of `WithTop.map` for `AddMonoidHom`s. -/
@[simps (config := .asFn)]
protected def _root_.AddMonoidHom.withTopMap {M N : Type*} [AddZeroClass M] [AddZeroClass N]
    (f : M →+ N) : WithTop M →+ WithTop N 
goal: WithTop M →+ WithTop N

full_name: AddMonoidHom.withTopMap_apply
code: /-- A version of `WithTop.map` for `AddMonoidHom`s. -/
@[simps (config := .asFn)]
protected def _root_.AddMonoidHom.withTopMap {M N : Type*} [AddZeroClass M] [AddZeroClass N]
    (f : M →+ N) : WithTop M →+ WithTop N 
goal: ⇑f.withTopMap = WithTop.map ⇑f

full_name: WithBot.zero
code: @[to_additive] instance one : One (WithBot α) 
goal: Zero (WithBot α)

full_name: WithBot.one
code: @[to_additive] instance one : One (WithBot α) 
goal: One (WithBot α)

full_name: WithBot.coe_zero
code: @[to_additive (attr := simp, norm_cast)] lemma coe_one : ((1 : α) : WithBot α) = 1 
goal: ↑0 = 0

full_name: WithBot.coe_one
code: @[to_additive (attr := simp, norm_cast)] lemma coe_one : ((1 : α) : WithBot α) = 1 
goal: ↑1 = 1

full_name: WithBot.coe_eq_one
code: @[to_additive (attr := simp, norm_cast)]
lemma coe_eq_one : (a : WithBot α) = 1 ↔ a = 1 
goal: ↑a = 1 ↔ a = 1

full_name: WithBot.coe_eq_zero
code: @[to_additive (attr := simp, norm_cast)]
lemma coe_eq_one : (a : WithBot α) = 1 ↔ a = 1 
goal: ↑a = 0 ↔ a = 0

full_name: WithBot.zero_eq_coe
code: @[to_additive (attr := simp, norm_cast)]
lemma one_eq_coe : 1 = (a : WithBot α) ↔ a = 1 
goal: 0 = ↑a ↔ a = 0

full_name: WithBot.one_eq_coe
code: @[to_additive (attr := simp, norm_cast)]
lemma one_eq_coe : 1 = (a : WithBot α) ↔ a = 1 
goal: 1 = ↑a ↔ a = 1

full_name: WithBot.bot_ne_one
code: @[to_additive (attr := simp)] lemma bot_ne_one : (⊥ : WithBot α) ≠ 1 
goal: ⊥ ≠ 1

full_name: WithBot.bot_ne_zero
code: @[to_additive (attr := simp)] lemma bot_ne_one : (⊥ : WithBot α) ≠ 1 
goal: ⊥ ≠ 0

full_name: WithBot.zero_ne_bot
code: @[to_additive (attr := simp)] lemma one_ne_bot : (1 : WithBot α) ≠ ⊥ 
goal: 0 ≠ ⊥

full_name: WithBot.one_ne_bot
code: @[to_additive (attr := simp)] lemma one_ne_bot : (1 : WithBot α) ≠ ⊥ 
goal: 1 ≠ ⊥

full_name: WithBot.unbot_zero
code: @[to_additive (attr := simp)]
theorem unbot_one : (1 : WithBot α).unbot coe_ne_bot = 1 
goal: WithBot.unbot 0 ⋯ = 0

full_name: WithBot.unbot_one
code: @[to_additive (attr := simp)]
theorem unbot_one : (1 : WithBot α).unbot coe_ne_bot = 1 
goal: WithBot.unbot 1 ⋯ = 1

full_name: WithBot.unbot_one'
code: @[to_additive (attr := simp)]
theorem unbot_one' (d : α) : (1 : WithBot α).unbot' d = 1 
goal: WithBot.unbot' d 1 = 1

full_name: WithBot.unbot_zero'
code: @[to_additive (attr := simp)]
theorem unbot_one' (d : α) : (1 : WithBot α).unbot' d = 1 
goal: WithBot.unbot' d 0 = 0

full_name: WithBot.coe_nonneg
code: @[to_additive (attr := simp, norm_cast) coe_nonneg]
theorem one_le_coe [LE α] : 1 ≤ (a : WithBot α) ↔ 1 ≤ a 
goal: 0 ≤ ↑a ↔ 0 ≤ a

full_name: WithBot.one_le_coe
code: @[to_additive (attr := simp, norm_cast) coe_nonneg]
theorem one_le_coe [LE α] : 1 ≤ (a : WithBot α) ↔ 1 ≤ a 
goal: 1 ≤ ↑a ↔ 1 ≤ a

full_name: WithBot.coe_le_one
code: @[to_additive (attr := simp, norm_cast) coe_le_zero]
theorem coe_le_one [LE α] : (a : WithBot α) ≤ 1 ↔ a ≤ 1 
goal: ↑a ≤ 1 ↔ a ≤ 1

full_name: WithBot.coe_le_zero
code: @[to_additive (attr := simp, norm_cast) coe_le_zero]
theorem coe_le_one [LE α] : (a : WithBot α) ≤ 1 ↔ a ≤ 1 
goal: ↑a ≤ 0 ↔ a ≤ 0

full_name: WithBot.one_lt_coe
code: @[to_additive (attr := simp, norm_cast) coe_pos]
theorem one_lt_coe [LT α] : 1 < (a : WithBot α) ↔ 1 < a 
goal: 1 < ↑a ↔ 1 < a

full_name: WithBot.coe_pos
code: @[to_additive (attr := simp, norm_cast) coe_pos]
theorem one_lt_coe [LT α] : 1 < (a : WithBot α) ↔ 1 < a 
goal: 0 < ↑a ↔ 0 < a

full_name: WithBot.coe_lt_one
code: @[to_additive (attr := simp, norm_cast) coe_lt_zero]
theorem coe_lt_one [LT α] : (a : WithBot α) < 1 ↔ a < 1 
goal: ↑a < 1 ↔ a < 1

full_name: WithBot.coe_lt_zero
code: @[to_additive (attr := simp, norm_cast) coe_lt_zero]
theorem coe_lt_one [LT α] : (a : WithBot α) < 1 ↔ a < 1 
goal: ↑a < 0 ↔ a < 0

full_name: WithBot.map_one
code: @[to_additive (attr := simp)]
protected theorem map_one {β} (f : α → β) : (1 : WithBot α).map f = (f 1 : WithBot β) 
goal: WithBot.map f 1 = ↑(f 1)

full_name: WithBot.map_zero
code: @[to_additive (attr := simp)]
protected theorem map_one {β} (f : α → β) : (1 : WithBot α).map f = (f 1 : WithBot β) 
goal: WithBot.map f 0 = ↑(f 0)

full_name: WithBot.zeroLEOneClass
code: instance zeroLEOneClass [Zero α] [LE α] [ZeroLEOneClass α] : ZeroLEOneClass (WithBot α) 
goal: ZeroLEOneClass (WithBot α)

full_name: WithBot.add
code: instance add [Add α] : Add (WithBot α) 
goal: Add (WithBot α)

full_name: WithBot.AddSemigroup
code: instance AddSemigroup [AddSemigroup α] : AddSemigroup (WithBot α) 
goal: AddSemigroup (WithBot α)

full_name: WithBot.addCommSemigroup
code: instance addCommSemigroup [AddCommSemigroup α] : AddCommSemigroup (WithBot α) 
goal: AddCommSemigroup (WithBot α)

full_name: WithBot.addZeroClass
code: instance addZeroClass [AddZeroClass α] : AddZeroClass (WithBot α) 
goal: AddZeroClass (WithBot α)

full_name: WithBot.addMonoid
code: instance addMonoid : AddMonoid (WithBot α) 
goal: AddMonoid (WithBot α)

full_name: WithBot.addHom
code: /-- Coercion from `α` to `WithBot α` as an `AddMonoidHom`. -/
def addHom : α →+ WithBot α 
goal: α →+ WithBot α

full_name: WithBot.coe_addHom
code: @[simp, norm_cast] lemma coe_addHom : ⇑(addHom : α →+ WithBot α) = WithBot.some 
goal: ⇑WithBot.addHom = WithBot.some

full_name: WithBot.coe_nsmul
code: @[simp, norm_cast]
lemma coe_nsmul (a : α) (n : ℕ) : ↑(n • a) = n • (a : WithBot α) 
goal: ↑(n • a) = n • ↑a

full_name: WithBot.addCommMonoid
code: instance addCommMonoid [AddCommMonoid α] : AddCommMonoid (WithBot α) 
goal: AddCommMonoid (WithBot α)

full_name: WithBot.addMonoidWithOne
code: instance addMonoidWithOne : AddMonoidWithOne (WithBot α) 
goal: AddMonoidWithOne (WithBot α)

full_name: WithBot.coe_natCast
code: @[norm_cast] lemma coe_natCast (n : ℕ) : ((n : α) : WithBot α) = n 
goal: ↑↑n = ↑n

full_name: WithBot.natCast_ne_bot
code: @[simp] lemma natCast_ne_bot (n : ℕ) : (n : WithBot α) ≠ ⊥ 
goal: ↑n ≠ ⊥

full_name: WithBot.bot_ne_natCast
code: @[simp] lemma bot_ne_natCast (n : ℕ) : (⊥ : WithBot α) ≠ n 
goal: ⊥ ≠ ↑n

full_name: WithBot.coe_ofNat
code: @[simp] lemma coe_ofNat (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : α) : WithBot α) = OfNat.ofNat n 
goal: ↑(OfNat.ofNat n) = OfNat.ofNat n

full_name: WithBot.coe_eq_ofNat
code: @[simp] lemma coe_eq_ofNat (n : ℕ) [n.AtLeastTwo] (m : α) :
    (m : WithBot α) = no_index (OfNat.ofNat n) ↔ m = OfNat.ofNat n 
goal: ↑m = OfNat.ofNat n ↔ m = OfNat.ofNat n

full_name: WithBot.ofNat_eq_coe
code: @[simp] lemma ofNat_eq_coe (n : ℕ) [n.AtLeastTwo] (m : α) :
    no_index (OfNat.ofNat n) = (m : WithBot α) ↔ OfNat.ofNat n = m 
goal: OfNat.ofNat n = ↑m ↔ OfNat.ofNat n = m

full_name: WithBot.ofNat_ne_bot
code: @[simp] lemma ofNat_ne_bot (n : ℕ) [n.AtLeastTwo] : no_index (OfNat.ofNat n : WithBot α) ≠ ⊥ 
goal: OfNat.ofNat n ≠ ⊥

full_name: WithBot.bot_ne_ofNat
code: @[simp] lemma bot_ne_ofNat (n : ℕ) [n.AtLeastTwo] : (⊥ : WithBot α) ≠ no_index (OfNat.ofNat n) 
goal: ⊥ ≠ OfNat.ofNat n

full_name: WithBot.charZero
code: instance charZero [AddMonoidWithOne α] [CharZero α] : CharZero (WithBot α) 
goal: CharZero (WithBot α)

full_name: WithBot.addCommMonoidWithOne
code: instance addCommMonoidWithOne [AddCommMonoidWithOne α] : AddCommMonoidWithOne (WithBot α) 
goal: AddCommMonoidWithOne (WithBot α)

full_name: WithBot.coe_add
code: @[simp, norm_cast]
theorem coe_add (a b : α) : ((a + b : α) : WithBot α) = a + b 
goal: ↑(a + b) = ↑a + ↑b

full_name: WithBot.bot_add
code: @[simp]
theorem bot_add (a : WithBot α) : ⊥ + a = ⊥ 
goal: ⊥ + a = ⊥

full_name: WithBot.add_bot
code: @[simp]
theorem add_bot (a : WithBot α) : a + ⊥ = ⊥ 
goal: a + ⊥ = ⊥

full_name: WithBot.add_eq_bot
code: @[simp]
theorem add_eq_bot : a + b = ⊥ ↔ a = ⊥ ∨ b = ⊥ 
goal: a + b = ⊥ ↔ a = ⊥ ∨ b = ⊥

full_name: WithBot.add_ne_bot
code: theorem add_ne_bot : a + b ≠ ⊥ ↔ a ≠ ⊥ ∧ b ≠ ⊥ 
goal: a + b ≠ ⊥ ↔ a ≠ ⊥ ∧ b ≠ ⊥

full_name: WithBot.bot_lt_add
code: theorem bot_lt_add [LT α] {a b : WithBot α} : ⊥ < a + b ↔ ⊥ < a ∧ ⊥ < b 
goal: ⊥ < a + b ↔ ⊥ < a ∧ ⊥ < b

full_name: WithBot.add_eq_coe
code: theorem add_eq_coe : a + b = x ↔ ∃ a' b' : α, ↑a' = a ∧ ↑b' = b ∧ a' + b' = x 
goal: a + b = ↑x ↔ ∃ a' b', ↑a' = a ∧ ↑b' = b ∧ a' + b' = x

full_name: WithBot.add_coe_eq_bot_iff
code: theorem add_coe_eq_bot_iff : a + y = ⊥ ↔ a = ⊥ 
goal: a + ↑y = ⊥ ↔ a = ⊥

full_name: WithBot.coe_add_eq_bot_iff
code: theorem coe_add_eq_bot_iff : ↑x + b = ⊥ ↔ b = ⊥ 
goal: ↑x + b = ⊥ ↔ b = ⊥

full_name: WithBot.add_right_cancel_iff
code: theorem add_right_cancel_iff [IsRightCancelAdd α] (ha : a ≠ ⊥) : b + a = c + a ↔ b = c 
goal: b + a = c + a ↔ b = c

full_name: WithBot.add_right_cancel
code: theorem add_right_cancel [IsRightCancelAdd α] (ha : a ≠ ⊥) (h : b + a = c + a) : b = c 
goal: b = c

full_name: WithBot.add_left_cancel_iff
code: theorem add_left_cancel_iff [IsLeftCancelAdd α] (ha : a ≠ ⊥) : a + b = a + c ↔ b = c 
goal: a + b = a + c ↔ b = c

full_name: WithBot.add_left_cancel
code: theorem add_left_cancel [IsLeftCancelAdd α] (ha : a ≠ ⊥) (h : a + b = a + c) : b = c 
goal: b = c

full_name: WithBot.map_add
code: @[simp]
protected theorem map_add {F} [Add β] [FunLike F α β] [AddHomClass F α β]
    (f : F) (a b : WithBot α) :
    (a + b).map f = a.map f + b.map f 
goal: WithBot.map (⇑f) (a + b) = WithBot.map (⇑f) a + WithBot.map (⇑f) b

full_name: OneHom.withBotMap
code: /-- A version of `WithBot.map` for `OneHom`s. -/
@[to_additive (attr := simps (config := .asFn))
  "A version of `WithBot.map` for `ZeroHom`s"]
protected def _root_.OneHom.withBotMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
    OneHom (WithBot M) (WithBot N) 
goal: OneHom (WithBot M) (WithBot N)

full_name: ZeroHom.withBotMap
code: /-- A version of `WithBot.map` for `OneHom`s. -/
@[to_additive (attr := simps (config := .asFn))
  "A version of `WithBot.map` for `ZeroHom`s"]
protected def _root_.OneHom.withBotMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
    OneHom (WithBot M) (WithBot N) 
goal: ZeroHom (WithBot M) (WithBot N)

full_name: ZeroHom.withBotMap_apply
code: /-- A version of `WithBot.map` for `OneHom`s. -/
@[to_additive (attr := simps (config := .asFn))
  "A version of `WithBot.map` for `ZeroHom`s"]
protected def _root_.OneHom.withBotMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
    OneHom (WithBot M) (WithBot N) 
goal: ⇑f.withBotMap = WithBot.map ⇑f

full_name: OneHom.withBotMap_apply
code: /-- A version of `WithBot.map` for `OneHom`s. -/
@[to_additive (attr := simps (config := .asFn))
  "A version of `WithBot.map` for `ZeroHom`s"]
protected def _root_.OneHom.withBotMap {M N : Type*} [One M] [One N] (f : OneHom M N) :
    OneHom (WithBot M) (WithBot N) 
goal: ⇑f.withBotMap = WithBot.map ⇑f

full_name: AddHom.withBotMap_apply
code: /-- A version of `WithBot.map` for `AddHom`s. -/
@[simps (config := .asFn)]
protected def _root_.AddHom.withBotMap {M N : Type*} [Add M] [Add N] (f : AddHom M N) :
    AddHom (WithBot M) (WithBot N) 
goal: ⇑f.withBotMap = WithBot.map ⇑f

full_name: AddHom.withBotMap
code: /-- A version of `WithBot.map` for `AddHom`s. -/
@[simps (config := .asFn)]
protected def _root_.AddHom.withBotMap {M N : Type*} [Add M] [Add N] (f : AddHom M N) :
    AddHom (WithBot M) (WithBot N) 
goal: AddHom (WithBot M) (WithBot N)

full_name: AddMonoidHom.withBotMap_apply
code: /-- A version of `WithBot.map` for `AddMonoidHom`s. -/
@[simps (config := .asFn)]
protected def _root_.AddMonoidHom.withBotMap {M N : Type*} [AddZeroClass M] [AddZeroClass N]
    (f : M →+ N) : WithBot M →+ WithBot N 
goal: ⇑f.withBotMap = WithBot.map ⇑f

full_name: AddMonoidHom.withBotMap
code: /-- A version of `WithBot.map` for `AddMonoidHom`s. -/
@[simps (config := .asFn)]
protected def _root_.AddMonoidHom.withBotMap {M N : Type*} [AddZeroClass M] [AddZeroClass N]
    (f : M →+ N) : WithBot M →+ WithBot N 
goal: WithBot M →+ WithBot N

full_name: WithBot.covariantClass_add_le
code: instance covariantClass_add_le [CovariantClass α α (· + ·) (· ≤ ·)] :
    CovariantClass (WithBot α) (WithBot α) (· + ·) (· ≤ ·) 
goal: CovariantClass (WithBot α) (WithBot α) (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: WithBot.covariantClass_swap_add_le
code: instance covariantClass_swap_add_le [CovariantClass α α (swap (· + ·)) (· ≤ ·)] :
    CovariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· ≤ ·) 
goal: CovariantClass (WithBot α) (WithBot α) (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: WithBot.contravariantClass_add_lt
code: instance contravariantClass_add_lt [ContravariantClass α α (· + ·) (· < ·)] :
    ContravariantClass (WithBot α) (WithBot α) (· + ·) (· < ·) 
goal: ContravariantClass (WithBot α) (WithBot α) (fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: WithBot.contravariantClass_swap_add_lt
code: instance contravariantClass_swap_add_lt [ContravariantClass α α (swap (· + ·)) (· < ·)] :
    ContravariantClass (WithBot α) (WithBot α) (swap (· + ·)) (· < ·) 
goal: ContravariantClass (WithBot α) (WithBot α) (Function.swap fun x x_1 => x + x_1) fun x x_1 => x < x_1

full_name: WithBot.le_of_add_le_add_left
code: protected theorem le_of_add_le_add_left [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥)
    (h : a + b ≤ a + c) : b ≤ c 
goal: b ≤ c

full_name: WithBot.le_of_add_le_add_right
code: protected theorem le_of_add_le_add_right [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    (ha : a ≠ ⊥) (h : b + a ≤ c + a) : b ≤ c 
goal: b ≤ c

full_name: WithBot.add_lt_add_left
code: protected theorem add_lt_add_left [CovariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) (h : b < c) :
    a + b < a + c 
goal: a + b < a + c

full_name: WithBot.add_lt_add_right
code: protected theorem add_lt_add_right [CovariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥)
    (h : b < c) : b + a < c + a 
goal: b + a < c + a

full_name: WithBot.add_le_add_iff_left
code: protected theorem add_le_add_iff_left [CovariantClass α α (· + ·) (· ≤ ·)]
    [ContravariantClass α α (· + ·) (· ≤ ·)] (ha : a ≠ ⊥) : a + b ≤ a + c ↔ b ≤ c 
goal: a + b ≤ a + c ↔ b ≤ c

full_name: WithBot.add_le_add_iff_right
code: protected theorem add_le_add_iff_right [CovariantClass α α (swap (· + ·)) (· ≤ ·)]
    [ContravariantClass α α (swap (· + ·)) (· ≤ ·)] (ha : a ≠ ⊥) : b + a ≤ c + a ↔ b ≤ c 
goal: b + a ≤ c + a ↔ b ≤ c

full_name: WithBot.add_lt_add_iff_left
code: protected theorem add_lt_add_iff_left [CovariantClass α α (· + ·) (· < ·)]
    [ContravariantClass α α (· + ·) (· < ·)] (ha : a ≠ ⊥) : a + b < a + c ↔ b < c 
goal: a + b < a + c ↔ b < c

full_name: WithBot.add_lt_add_iff_right
code: protected theorem add_lt_add_iff_right [CovariantClass α α (swap (· + ·)) (· < ·)]
    [ContravariantClass α α (swap (· + ·)) (· < ·)] (ha : a ≠ ⊥) : b + a < c + a ↔ b < c 
goal: b + a < c + a ↔ b < c

full_name: WithBot.add_lt_add_of_le_of_lt
code: protected theorem add_lt_add_of_le_of_lt [CovariantClass α α (· + ·) (· < ·)]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] (hb : b ≠ ⊥) (hab : a ≤ b) (hcd : c < d) :
    a + c < b + d 
goal: a + c < b + d

full_name: WithBot.add_lt_add_of_lt_of_le
code: protected theorem add_lt_add_of_lt_of_le [CovariantClass α α (· + ·) (· ≤ ·)]
    [CovariantClass α α (swap (· + ·)) (· < ·)] (hd : d ≠ ⊥) (hab : a < b) (hcd : c ≤ d) :
    a + c < b + d 
goal: a + c < b + d