File: Mathlib/Data/Nat/PartENat.lean

full_name: PartENat
code: /-- Type of natural numbers with infinity (`⊤`) -/
def PartENat : Type 
goal: Type

full_name: PartENat.some
code: /-- The computable embedding `ℕ → PartENat`.

This coincides with the coercion `coe : ℕ → PartENat`, see `PartENat.some_eq_natCast`. -/
@[coe]
def some : ℕ → PartENat 
goal: ℕ → PartENat

full_name: PartENat.instZero
code: instance : Zero PartENat 
goal: Zero PartENat

full_name: PartENat.instInhabited
code: instance : Inhabited PartENat 
goal: Inhabited PartENat

full_name: PartENat.instOne
code: instance : One PartENat 
goal: One PartENat

full_name: PartENat.instAdd
code: instance : Add PartENat 
goal: Add PartENat

full_name: PartENat.instDecidableDomNatSome
code: instance (n : ℕ) : Decidable (some n).Dom 
goal: Decidable (↑n).Dom

full_name: PartENat.dom_some
code: @[simp]
theorem dom_some (x : ℕ) : (some x).Dom 
goal: (↑x).Dom

full_name: PartENat.addCommMonoid
code: instance addCommMonoid : AddCommMonoid PartENat 
goal: AddCommMonoid PartENat

full_name: PartENat.instAddCommMonoidWithOne
code: instance : AddCommMonoidWithOne PartENat 
goal: AddCommMonoidWithOne PartENat

full_name: PartENat.some_eq_natCast
code: theorem some_eq_natCast (n : ℕ) : some n = n 
goal: ↑n = ↑n

full_name: PartENat.instCharZero
code: instance : CharZero PartENat 
goal: CharZero PartENat

full_name: PartENat.natCast_inj
code: /-- Alias of `Nat.cast_inj` specialized to `PartENat` --/
theorem natCast_inj {x y : ℕ} : (x : PartENat) = y ↔ x = y 
goal: ↑x = ↑y ↔ x = y

full_name: PartENat.dom_natCast
code: @[simp]
theorem dom_natCast (x : ℕ) : (x : PartENat).Dom 
goal: (↑x).Dom

full_name: PartENat.dom_ofNat
code: @[simp]
theorem dom_ofNat (x : ℕ) [x.AtLeastTwo] : (no_index (OfNat.ofNat x : PartENat)).Dom 
goal: (OfNat.ofNat x).Dom

full_name: PartENat.dom_zero
code: @[simp]
theorem dom_zero : (0 : PartENat).Dom 
goal: Part.Dom 0

full_name: PartENat.dom_one
code: @[simp]
theorem dom_one : (1 : PartENat).Dom 
goal: Part.Dom 1

full_name: PartENat.instCanLiftNatCastDom
code: instance : CanLift PartENat ℕ (↑) Dom 
goal: CanLift PartENat ℕ Nat.cast Part.Dom

full_name: PartENat.instLE
code: instance : LE PartENat 
goal: LE PartENat

full_name: PartENat.instTop
code: instance : Top PartENat 
goal: Top PartENat

full_name: PartENat.instBot
code: instance : Bot PartENat 
goal: Bot PartENat

full_name: PartENat.instSup
code: instance : Sup PartENat 
goal: Sup PartENat

full_name: PartENat.le_def
code: theorem le_def (x y : PartENat) :
    x ≤ y ↔ ∃ h : y.Dom → x.Dom, ∀ hy : y.Dom, x.get (h hy) ≤ y.get hy 
goal: x ≤ y ↔ ∃ (h : y.Dom → x.Dom), ∀ (hy : y.Dom), x.get ⋯ ≤ y.get hy

full_name: PartENat.casesOn'
code: @[elab_as_elim]
protected theorem casesOn' {P : PartENat → Prop} :
    ∀ a : PartENat, P ⊤ → (∀ n : ℕ, P (some n)) → P a 
goal: P ⊤ → (∀ (n : ℕ), P ↑n) → P a

full_name: PartENat.casesOn
code: @[elab_as_elim]
protected theorem casesOn {P : PartENat → Prop} : ∀ a : PartENat, P ⊤ → (∀ n : ℕ, P n) → P a 
goal: P ⊤ → (∀ (n : ℕ), P ↑n) → P a

full_name: PartENat.top_add
code: theorem top_add (x : PartENat) : ⊤ + x = ⊤ 
goal: ⊤ + x = ⊤

full_name: PartENat.add_top
code: theorem add_top (x : PartENat) : x + ⊤ = ⊤ 
goal: x + ⊤ = ⊤

full_name: PartENat.natCast_get
code: @[simp]
theorem natCast_get {x : PartENat} (h : x.Dom) : (x.get h : PartENat) = x 
goal: ↑(x.get h) = x

full_name: PartENat.get_natCast'
code: @[simp, norm_cast]
theorem get_natCast' (x : ℕ) (h : (x : PartENat).Dom) : get (x : PartENat) h = x 
goal: (↑x).get h = x

full_name: PartENat.get_natCast
code: theorem get_natCast {x : ℕ} : get (x : PartENat) (dom_natCast x) = x 
goal: (↑x).get ⋯ = x

full_name: PartENat.coe_add_get
code: theorem coe_add_get {x : ℕ} {y : PartENat} (h : ((x : PartENat) + y).Dom) :
    get ((x : PartENat) + y) h = x + get y h.2 
goal: (↑x + y).get h = x + y.get ⋯

full_name: PartENat.get_add
code: @[simp]
theorem get_add {x y : PartENat} (h : (x + y).Dom) : get (x + y) h = x.get h.1 + y.get h.2 
goal: (x + y).get h = x.get ⋯ + y.get ⋯

full_name: PartENat.get_zero
code: @[simp]
theorem get_zero (h : (0 : PartENat).Dom) : (0 : PartENat).get h = 0 
goal: Part.get 0 h = 0

full_name: PartENat.get_one
code: @[simp]
theorem get_one (h : (1 : PartENat).Dom) : (1 : PartENat).get h = 1 
goal: Part.get 1 h = 1

full_name: PartENat.get_ofNat'
code: @[simp]
theorem get_ofNat' (x : ℕ) [x.AtLeastTwo] (h : (no_index (OfNat.ofNat x : PartENat)).Dom) :
    Part.get (no_index (OfNat.ofNat x : PartENat)) h = (no_index (OfNat.ofNat x)) 
goal: (OfNat.ofNat x).get h = OfNat.ofNat x

full_name: PartENat.get_eq_iff_eq_some
code: nonrec theorem get_eq_iff_eq_some {a : PartENat} {ha : a.Dom} {b : ℕ} : a.get ha = b ↔ a = some b 
goal: a.get ha = b ↔ a = ↑b

full_name: PartENat.get_eq_iff_eq_coe
code: theorem get_eq_iff_eq_coe {a : PartENat} {ha : a.Dom} {b : ℕ} : a.get ha = b ↔ a = b 
goal: a.get ha = b ↔ a = ↑b

full_name: PartENat.dom_of_le_of_dom
code: theorem dom_of_le_of_dom {x y : PartENat} : x ≤ y → y.Dom → x.Dom 
goal: x ≤ y → y.Dom → x.Dom

full_name: PartENat.dom_of_le_some
code: theorem dom_of_le_some {x : PartENat} {y : ℕ} (h : x ≤ some y) : x.Dom 
goal: x.Dom

full_name: PartENat.dom_of_le_natCast
code: theorem dom_of_le_natCast {x : PartENat} {y : ℕ} (h : x ≤ y) : x.Dom 
goal: x.Dom

full_name: PartENat.decidableLe
code: instance decidableLe (x y : PartENat) [Decidable x.Dom] [Decidable y.Dom] : Decidable (x ≤ y) 
goal: Decidable (x ≤ y)

full_name: PartENat.partialOrder
code: instance partialOrder : PartialOrder PartENat 
goal: PartialOrder PartENat

full_name: PartENat.lt_def
code: theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.get hx < y.get hy 
goal: x < y ↔ ∃ (hx : x.Dom), ∀ (hy : y.Dom), x.get hx < y.get hy

full_name: PartENat.orderedAddCommMonoid
code: noncomputable instance orderedAddCommMonoid : OrderedAddCommMonoid PartENat 
goal: OrderedAddCommMonoid PartENat

full_name: PartENat.semilatticeSup
code: instance semilatticeSup : SemilatticeSup PartENat 
goal: SemilatticeSup PartENat

full_name: PartENat.orderBot
code: instance orderBot : OrderBot PartENat 
goal: OrderBot PartENat

full_name: PartENat.orderTop
code: instance orderTop : OrderTop PartENat 
goal: OrderTop PartENat

full_name: PartENat.instZeroLEOneClass
code: instance : ZeroLEOneClass PartENat 
goal: ZeroLEOneClass PartENat

full_name: PartENat.coe_le_coe
code: /-- Alias of `Nat.cast_le` specialized to `PartENat` --/
theorem coe_le_coe {x y : ℕ} : (x : PartENat) ≤ y ↔ x ≤ y 
goal: ↑x ≤ ↑y ↔ x ≤ y

full_name: PartENat.coe_lt_coe
code: /-- Alias of `Nat.cast_lt` specialized to `PartENat` --/
theorem coe_lt_coe {x y : ℕ} : (x : PartENat) < y ↔ x < y 
goal: ↑x < ↑y ↔ x < y

full_name: PartENat.get_le_get
code: @[simp]
theorem get_le_get {x y : PartENat} {hx : x.Dom} {hy : y.Dom} : x.get hx ≤ y.get hy ↔ x ≤ y 
goal: x.get hx ≤ y.get hy ↔ x ≤ y

full_name: PartENat.le_coe_iff
code: theorem le_coe_iff (x : PartENat) (n : ℕ) : x ≤ n ↔ ∃ h : x.Dom, x.get h ≤ n 
goal: x ≤ ↑n ↔ ∃ (h : x.Dom), x.get h ≤ n

full_name: PartENat.lt_coe_iff
code: theorem lt_coe_iff (x : PartENat) (n : ℕ) : x < n ↔ ∃ h : x.Dom, x.get h < n 
goal: x < ↑n ↔ ∃ (h : x.Dom), x.get h < n

full_name: PartENat.coe_le_iff
code: theorem coe_le_iff (n : ℕ) (x : PartENat) : (n : PartENat) ≤ x ↔ ∀ h : x.Dom, n ≤ x.get h 
goal: ↑n ≤ x ↔ ∀ (h : x.Dom), n ≤ x.get h

full_name: PartENat.coe_lt_iff
code: theorem coe_lt_iff (n : ℕ) (x : PartENat) : (n : PartENat) < x ↔ ∀ h : x.Dom, n < x.get h 
goal: ↑n < x ↔ ∀ (h : x.Dom), n < x.get h

full_name: PartENat.eq_zero_iff
code: nonrec theorem eq_zero_iff {x : PartENat} : x = 0 ↔ x ≤ 0 
goal: x = 0 ↔ x ≤ 0

full_name: PartENat.ne_zero_iff
code: theorem ne_zero_iff {x : PartENat} : x ≠ 0 ↔ ⊥ < x 
goal: x ≠ 0 ↔ ⊥ < x

full_name: PartENat.dom_of_lt
code: theorem dom_of_lt {x y : PartENat} : x < y → x.Dom 
goal: x < y → x.Dom

full_name: PartENat.top_eq_none
code: theorem top_eq_none : (⊤ : PartENat) = Part.none 
goal: ⊤ = Part.none

full_name: PartENat.natCast_lt_top
code: @[simp]
theorem natCast_lt_top (x : ℕ) : (x : PartENat) < ⊤ 
goal: ↑x < ⊤

full_name: PartENat.zero_lt_top
code: @[simp]
theorem zero_lt_top : (0 : PartENat) < ⊤ 
goal: 0 < ⊤

full_name: PartENat.one_lt_top
code: @[simp]
theorem one_lt_top : (1 : PartENat) < ⊤ 
goal: 1 < ⊤

full_name: PartENat.ofNat_lt_top
code: @[simp]
theorem ofNat_lt_top (x : ℕ) [x.AtLeastTwo] : (no_index (OfNat.ofNat x : PartENat)) < ⊤ 
goal: OfNat.ofNat x < ⊤

full_name: PartENat.natCast_ne_top
code: @[simp]
theorem natCast_ne_top (x : ℕ) : (x : PartENat) ≠ ⊤ 
goal: ↑x ≠ ⊤

full_name: PartENat.zero_ne_top
code: @[simp]
theorem zero_ne_top : (0 : PartENat) ≠ ⊤ 
goal: 0 ≠ ⊤

full_name: PartENat.one_ne_top
code: @[simp]
theorem one_ne_top : (1 : PartENat) ≠ ⊤ 
goal: 1 ≠ ⊤

full_name: PartENat.ofNat_ne_top
code: @[simp]
theorem ofNat_ne_top (x : ℕ) [x.AtLeastTwo] : (no_index (OfNat.ofNat x : PartENat)) ≠ ⊤ 
goal: OfNat.ofNat x ≠ ⊤

full_name: PartENat.not_isMax_natCast
code: theorem not_isMax_natCast (x : ℕ) : ¬IsMax (x : PartENat) 
goal: ¬IsMax ↑x

full_name: PartENat.ne_top_iff
code: theorem ne_top_iff {x : PartENat} : x ≠ ⊤ ↔ ∃ n : ℕ, x = n 
goal: x ≠ ⊤ ↔ ∃ n, x = ↑n

full_name: PartENat.ne_top_iff_dom
code: theorem ne_top_iff_dom {x : PartENat} : x ≠ ⊤ ↔ x.Dom 
goal: x ≠ ⊤ ↔ x.Dom

full_name: PartENat.not_dom_iff_eq_top
code: theorem not_dom_iff_eq_top {x : PartENat} : ¬x.Dom ↔ x = ⊤ 
goal: ¬x.Dom ↔ x = ⊤

full_name: PartENat.ne_top_of_lt
code: theorem ne_top_of_lt {x y : PartENat} (h : x < y) : x ≠ ⊤ 
goal: x ≠ ⊤

full_name: PartENat.eq_top_iff_forall_lt
code: theorem eq_top_iff_forall_lt (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : PartENat) < x 
goal: x = ⊤ ↔ ∀ (n : ℕ), ↑n < x

full_name: PartENat.eq_top_iff_forall_le
code: theorem eq_top_iff_forall_le (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : PartENat) ≤ x 
goal: x = ⊤ ↔ ∀ (n : ℕ), ↑n ≤ x

full_name: PartENat.pos_iff_one_le
code: theorem pos_iff_one_le {x : PartENat} : 0 < x ↔ 1 ≤ x 
goal: 0 < x ↔ 1 ≤ x

full_name: PartENat.isTotal
code: instance isTotal : IsTotal PartENat (· ≤ ·) 
goal: IsTotal PartENat fun x x_1 => x ≤ x_1

full_name: PartENat.linearOrder
code: noncomputable instance linearOrder : LinearOrder PartENat 
goal: LinearOrder PartENat

full_name: PartENat.boundedOrder
code: instance boundedOrder : BoundedOrder PartENat 
goal: BoundedOrder PartENat

full_name: PartENat.lattice
code: noncomputable instance lattice : Lattice PartENat 
goal: Lattice PartENat

full_name: PartENat.instCanonicallyOrderedAddCommMonoid
code: noncomputable instance : CanonicallyOrderedAddCommMonoid PartENat 
goal: CanonicallyOrderedAddCommMonoid PartENat

full_name: PartENat.eq_natCast_sub_of_add_eq_natCast
code: theorem eq_natCast_sub_of_add_eq_natCast {x y : PartENat} {n : ℕ} (h : x + y = n) :
    x = ↑(n - y.get (dom_of_le_natCast ((le_add_left le_rfl).trans_eq h))) 
goal: x = ↑(n - y.get ⋯)

full_name: PartENat.add_lt_add_right
code: protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ ⊤) : x + z < y + z 
goal: x + z < y + z

full_name: PartENat.add_lt_add_iff_right
code: protected theorem add_lt_add_iff_right {x y z : PartENat} (hz : z ≠ ⊤) : x + z < y + z ↔ x < y 
goal: x + z < y + z ↔ x < y

full_name: PartENat.add_lt_add_iff_left
code: protected theorem add_lt_add_iff_left {x y z : PartENat} (hz : z ≠ ⊤) : z + x < z + y ↔ x < y 
goal: z + x < z + y ↔ x < y

full_name: PartENat.lt_add_iff_pos_right
code: protected theorem lt_add_iff_pos_right {x y : PartENat} (hx : x ≠ ⊤) : x < x + y ↔ 0 < y 
goal: x < x + y ↔ 0 < y

full_name: PartENat.lt_add_one
code: theorem lt_add_one {x : PartENat} (hx : x ≠ ⊤) : x < x + 1 
goal: x < x + 1

full_name: PartENat.le_of_lt_add_one
code: theorem le_of_lt_add_one {x y : PartENat} (h : x < y + 1) : x ≤ y 
goal: x ≤ y

full_name: PartENat.add_one_le_of_lt
code: theorem add_one_le_of_lt {x y : PartENat} (h : x < y) : x + 1 ≤ y 
goal: x + 1 ≤ y

full_name: PartENat.add_one_le_iff_lt
code: theorem add_one_le_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x + 1 ≤ y ↔ x < y 
goal: x + 1 ≤ y ↔ x < y

full_name: PartENat.coe_succ_le_iff
code: theorem coe_succ_le_iff {n : ℕ} {e : PartENat} : ↑n.succ ≤ e ↔ ↑n < e 
goal: ↑n.succ ≤ e ↔ ↑n < e

full_name: PartENat.lt_add_one_iff_lt
code: theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x ≤ y 
goal: x < y + 1 ↔ x ≤ y

full_name: PartENat.lt_coe_succ_iff_le
code: lemma lt_coe_succ_iff_le {x : PartENat} {n : ℕ} (hx : x ≠ ⊤) : x < n.succ ↔ x ≤ n 
goal: x < ↑n.succ ↔ x ≤ ↑n

full_name: PartENat.add_eq_top_iff
code: theorem add_eq_top_iff {a b : PartENat} : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ 
goal: a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤

full_name: PartENat.add_right_cancel_iff
code: protected theorem add_right_cancel_iff {a b c : PartENat} (hc : c ≠ ⊤) : a + c = b + c ↔ a = b 
goal: a + c = b + c ↔ a = b

full_name: PartENat.add_left_cancel_iff
code: protected theorem add_left_cancel_iff {a b c : PartENat} (ha : a ≠ ⊤) : a + b = a + c ↔ b = c 
goal: a + b = a + c ↔ b = c

full_name: PartENat.toWithTop
code: /-- Computably converts a `PartENat` to a `ℕ∞`. -/
def toWithTop (x : PartENat) [Decidable x.Dom] : ℕ∞ 
goal: ℕ∞

full_name: PartENat.toWithTop_top
code: theorem toWithTop_top :
    have : Decidable (⊤ : PartENat).Dom := Part.noneDecidable
    toWithTop ⊤ = ⊤ 
goal: let_fun this := Part.noneDecidable;
⊤.toWithTop = ⊤

full_name: PartENat.toWithTop_top'
code: @[simp]
theorem toWithTop_top' {h : Decidable (⊤ : PartENat).Dom} : toWithTop ⊤ = ⊤ 
goal: ⊤.toWithTop = ⊤

full_name: PartENat.toWithTop_zero
code: theorem toWithTop_zero :
    have : Decidable (0 : PartENat).Dom := someDecidable 0
    toWithTop 0 = 0 
goal: let_fun this := Part.someDecidable 0;
PartENat.toWithTop 0 = 0

full_name: PartENat.toWithTop_zero'
code: @[simp]
theorem toWithTop_zero' {h : Decidable (0 : PartENat).Dom} : toWithTop 0 = 0 
goal: PartENat.toWithTop 0 = 0

full_name: PartENat.toWithTop_one
code: theorem toWithTop_one :
    have : Decidable (1 : PartENat).Dom := someDecidable 1
    toWithTop 1 = 1 
goal: let_fun this := Part.someDecidable 1;
PartENat.toWithTop 1 = 1

full_name: PartENat.toWithTop_one'
code: @[simp]
theorem toWithTop_one' {h : Decidable (1 : PartENat).Dom} : toWithTop 1 = 1 
goal: PartENat.toWithTop 1 = 1

full_name: PartENat.toWithTop_some
code: theorem toWithTop_some (n : ℕ) : toWithTop (some n) = n 
goal: (↑n).toWithTop = ↑n

full_name: PartENat.toWithTop_natCast
code: theorem toWithTop_natCast (n : ℕ) {_ : Decidable (n : PartENat).Dom} : toWithTop n = n 
goal: ∀ {x : Decidable (↑n).Dom}, (↑n).toWithTop = ↑n

full_name: PartENat.toWithTop_natCast'
code: @[simp]
theorem toWithTop_natCast' (n : ℕ) {_ : Decidable (n : PartENat).Dom} :
    toWithTop (n : PartENat) = n 
goal: ∀ {x : Decidable (↑n).Dom}, (↑n).toWithTop = ↑n

full_name: PartENat.toWithTop_ofNat
code: @[simp]
theorem toWithTop_ofNat (n : ℕ) [n.AtLeastTwo] {_ : Decidable (OfNat.ofNat n : PartENat).Dom} :
    toWithTop (no_index (OfNat.ofNat n : PartENat)) = OfNat.ofNat n 
goal: ∀ {x : Decidable (Part.Dom (OfNat.ofNat n))}, (OfNat.ofNat n).toWithTop = OfNat.ofNat n

full_name: PartENat.toWithTop_le
code: @[simp]
theorem toWithTop_le {x y : PartENat} [hx : Decidable x.Dom] [hy : Decidable y.Dom] :
    toWithTop x ≤ toWithTop y ↔ x ≤ y 
goal: x.toWithTop ≤ y.toWithTop ↔ x ≤ y

full_name: PartENat.toWithTop_lt
code: @[simp]
theorem toWithTop_lt {x y : PartENat} [Decidable x.Dom] [Decidable y.Dom] :
    toWithTop x < toWithTop y ↔ x < y 
goal: x.toWithTop < y.toWithTop ↔ x < y

full_name: PartENat.ofENat
code: /-- Coercion from `ℕ∞` to `PartENat`. -/
@[coe]
def ofENat : ℕ∞ → PartENat 
goal: ℕ∞ → PartENat

full_name: PartENat.instCoeENat
code: instance : Coe ℕ∞ PartENat 
goal: Coe ℕ∞ PartENat

full_name: PartENat.ofENat_top
code: @[simp, norm_cast]
lemma ofENat_top : ofENat ⊤ = ⊤ 
goal: ↑⊤ = ⊤

full_name: PartENat.ofENat_coe
code: @[simp, norm_cast]
lemma ofENat_coe (n : ℕ) : ofENat n = n 
goal: ↑↑n = ↑n

full_name: PartENat.ofENat_zero
code: @[simp, norm_cast]
theorem ofENat_zero : ofENat 0 = 0 
goal: ↑0 = 0

full_name: PartENat.ofENat_one
code: @[simp, norm_cast]
theorem ofENat_one : ofENat 1 = 1 
goal: ↑1 = 1

full_name: PartENat.ofENat_ofNat
code: @[simp, norm_cast]
theorem ofENat_ofNat (n : Nat) [n.AtLeastTwo] : ofENat (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
goal: ↑(OfNat.ofNat n) = OfNat.ofNat n

full_name: PartENat.toWithTop_ofENat
code: @[simp, norm_cast]
theorem toWithTop_ofENat (n : ℕ∞) {_ : Decidable (n : PartENat).Dom} : toWithTop (↑n) = n 
goal: ∀ {x : Decidable (↑n).Dom}, (↑n).toWithTop = n

full_name: PartENat.ofENat_toWithTop
code: @[simp, norm_cast]
theorem ofENat_toWithTop (x : PartENat) {_ : Decidable (x : PartENat).Dom} : toWithTop x = x 
goal: ∀ {x_1 : Decidable x.Dom}, ↑x.toWithTop = x

full_name: PartENat.ofENat_le
code: @[simp, norm_cast]
theorem ofENat_le {x y : ℕ∞} : ofENat x ≤ ofENat y ↔ x ≤ y 
goal: ↑x ≤ ↑y ↔ x ≤ y

full_name: PartENat.ofENat_lt
code: @[simp, norm_cast]
theorem ofENat_lt {x y : ℕ∞} : ofENat x < ofENat y ↔ x < y 
goal: ↑x < ↑y ↔ x < y

full_name: PartENat.toWithTop_add
code: @[simp]
theorem toWithTop_add {x y : PartENat} : toWithTop (x + y) = toWithTop x + toWithTop y 
goal: (x + y).toWithTop = x.toWithTop + y.toWithTop

full_name: PartENat.withTopEquiv
code: /-- `Equiv` between `PartENat` and `ℕ∞` (for the order isomorphism see
`withTopOrderIso`). -/
@[simps]
noncomputable def withTopEquiv : PartENat ≃ ℕ∞ 
goal: PartENat ≃ ℕ∞

full_name: PartENat.withTopEquiv_symm_apply
code: /-- `Equiv` between `PartENat` and `ℕ∞` (for the order isomorphism see
`withTopOrderIso`). -/
@[simps]
noncomputable def withTopEquiv : PartENat ≃ ℕ∞ 
goal: PartENat.withTopEquiv.symm x = ↑x

full_name: PartENat.withTopEquiv_apply
code: /-- `Equiv` between `PartENat` and `ℕ∞` (for the order isomorphism see
`withTopOrderIso`). -/
@[simps]
noncomputable def withTopEquiv : PartENat ≃ ℕ∞ 
goal: PartENat.withTopEquiv x = x.toWithTop

full_name: PartENat.withTopEquiv_top
code: theorem withTopEquiv_top : withTopEquiv ⊤ = ⊤ 
goal: PartENat.withTopEquiv ⊤ = ⊤

full_name: PartENat.withTopEquiv_natCast
code: theorem withTopEquiv_natCast (n : Nat) : withTopEquiv n = n 
goal: PartENat.withTopEquiv ↑n = ↑n

full_name: PartENat.withTopEquiv_zero
code: theorem withTopEquiv_zero : withTopEquiv 0 = 0 
goal: PartENat.withTopEquiv 0 = 0

full_name: PartENat.withTopEquiv_one
code: theorem withTopEquiv_one : withTopEquiv 1 = 1 
goal: PartENat.withTopEquiv 1 = 1

full_name: PartENat.withTopEquiv_ofNat
code: theorem withTopEquiv_ofNat (n : Nat) [n.AtLeastTwo] :
    withTopEquiv (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
goal: PartENat.withTopEquiv (OfNat.ofNat n) = OfNat.ofNat n

full_name: PartENat.withTopEquiv_le
code: theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔ x ≤ y 
goal: PartENat.withTopEquiv x ≤ PartENat.withTopEquiv y ↔ x ≤ y

full_name: PartENat.withTopEquiv_lt
code: theorem withTopEquiv_lt {x y : PartENat} : withTopEquiv x < withTopEquiv y ↔ x < y 
goal: PartENat.withTopEquiv x < PartENat.withTopEquiv y ↔ x < y

full_name: PartENat.withTopEquiv_symm_top
code: theorem withTopEquiv_symm_top : withTopEquiv.symm ⊤ = ⊤ 
goal: PartENat.withTopEquiv.symm ⊤ = ⊤

full_name: PartENat.withTopEquiv_symm_coe
code: theorem withTopEquiv_symm_coe (n : Nat) : withTopEquiv.symm n = n 
goal: PartENat.withTopEquiv.symm ↑n = ↑n

full_name: PartENat.withTopEquiv_symm_zero
code: theorem withTopEquiv_symm_zero : withTopEquiv.symm 0 = 0 
goal: PartENat.withTopEquiv.symm 0 = 0

full_name: PartENat.withTopEquiv_symm_one
code: theorem withTopEquiv_symm_one : withTopEquiv.symm 1 = 1 
goal: PartENat.withTopEquiv.symm 1 = 1

full_name: PartENat.withTopEquiv_symm_ofNat
code: theorem withTopEquiv_symm_ofNat (n : Nat) [n.AtLeastTwo] :
    withTopEquiv.symm (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
goal: PartENat.withTopEquiv.symm (OfNat.ofNat n) = OfNat.ofNat n

full_name: PartENat.withTopEquiv_symm_le
code: theorem withTopEquiv_symm_le {x y : ℕ∞} : withTopEquiv.symm x ≤ withTopEquiv.symm y ↔ x ≤ y 
goal: PartENat.withTopEquiv.symm x ≤ PartENat.withTopEquiv.symm y ↔ x ≤ y

full_name: PartENat.withTopEquiv_symm_lt
code: theorem withTopEquiv_symm_lt {x y : ℕ∞} : withTopEquiv.symm x < withTopEquiv.symm y ↔ x < y 
goal: PartENat.withTopEquiv.symm x < PartENat.withTopEquiv.symm y ↔ x < y

full_name: PartENat.withTopOrderIso
code: /-- `toWithTop` induces an order isomorphism between `PartENat` and `ℕ∞`. -/
noncomputable def withTopOrderIso : PartENat ≃o ℕ∞ 
goal: PartENat ≃o ℕ∞

full_name: PartENat.withTopAddEquiv
code: /-- `toWithTop` induces an additive monoid isomorphism between `PartENat` and `ℕ∞`. -/
noncomputable def withTopAddEquiv : PartENat ≃+ ℕ∞ 
goal: PartENat ≃+ ℕ∞

full_name: PartENat.lt_wf
code: theorem lt_wf : @WellFounded PartENat (· < ·) 
goal: WellFounded fun x x_1 => x < x_1

full_name: PartENat.instWellFoundedLT
code: instance : WellFoundedLT PartENat 
goal: WellFoundedLT PartENat

full_name: PartENat.isWellOrder
code: instance isWellOrder : IsWellOrder PartENat (· < ·) 
goal: IsWellOrder PartENat fun x x_1 => x < x_1

full_name: PartENat.wellFoundedRelation
code: instance wellFoundedRelation : WellFoundedRelation PartENat 
goal: WellFoundedRelation PartENat

full_name: PartENat.find
code: /-- The smallest `PartENat` satisfying a (decidable) predicate `P : ℕ → Prop` -/
def find : PartENat 
goal: PartENat

full_name: PartENat.find_get
code: @[simp]
theorem find_get (h : (find P).Dom) : (find P).get h = Nat.find h 
goal: (PartENat.find P).get h = Nat.find h

full_name: PartENat.find_dom
code: theorem find_dom (h : ∃ n, P n) : (find P).Dom 
goal: (PartENat.find P).Dom

full_name: PartENat.lt_find
code: theorem lt_find (n : ℕ) (h : ∀ m ≤ n, ¬P m) : (n : PartENat) < find P 
goal: ↑n < PartENat.find P

full_name: PartENat.lt_find_iff
code: theorem lt_find_iff (n : ℕ) : (n : PartENat) < find P ↔ ∀ m ≤ n, ¬P m 
goal: ↑n < PartENat.find P ↔ ∀ m ≤ n, ¬P m

full_name: PartENat.find_le
code: theorem find_le (n : ℕ) (h : P n) : find P ≤ n 
goal: PartENat.find P ≤ ↑n

full_name: PartENat.find_eq_top_iff
code: theorem find_eq_top_iff : find P = ⊤ ↔ ∀ n, ¬P n 
goal: PartENat.find P = ⊤ ↔ ∀ (n : ℕ), ¬P n

full_name: PartENat.instLinearOrderedAddCommMonoidWithTop
code: noncomputable instance : LinearOrderedAddCommMonoidWithTop PartENat 
goal: LinearOrderedAddCommMonoidWithTop PartENat

full_name: PartENat.instCompleteLinearOrder
code: noncomputable instance : CompleteLinearOrder PartENat 
goal: CompleteLinearOrder PartENat