ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.xor_right_injective
theorem xor_right_injective {n : ℕ} : Function.Injective (HXor.hXor n : ℕ → ℕ) 
Arguments: {n : ℕ}
Goal: Function.Injective (HXor.hXor n)
-- Nat.xor_left_injective
theorem xor_left_injective {n : ℕ} : Function.Injective fun m => m ^^^ n 
Arguments: {n : ℕ}
Goal: Function.Injective fun m => m ^^^ n
-- Nat.xor_right_inj
@[simp]
theorem xor_right_inj {n m m' : ℕ} : n ^^^ m = n ^^^ m' ↔ m = m' 
Arguments: {n m m' : ℕ}
Goal: n ^^^ m = n ^^^ m' ↔ m = m'
-- Nat.xor_left_inj
@[simp]
theorem xor_left_inj {n m m' : ℕ} : m ^^^ n = m' ^^^ n ↔ m = m' 
Arguments: {n m m' : ℕ}
Goal: m ^^^ n = m' ^^^ n ↔ m = m'
-- Nat.xor_eq_zero
@[simp]
theorem xor_eq_zero {n m : ℕ} : n ^^^ m = 0 ↔ n = m 
Arguments: {n m : ℕ}
Goal: n ^^^ m = 0 ↔ n = m
-- Nat.xor_ne_zero
theorem xor_ne_zero {n m : ℕ} : n ^^^ m ≠ 0 ↔ n ≠ m 
Arguments: {n m : ℕ}
Goal: n ^^^ m ≠ 0 ↔ n ≠ m
-- Nat.xor_trichotomy
theorem xor_trichotomy {a b c : ℕ} (h : a ≠ b ^^^ c) :
    b ^^^ c < a ∨ a ^^^ c < b ∨ a ^^^ b < c 
Arguments: {a b c : ℕ} (h : a ≠ b ^^^ c)
Goal: b ^^^ c < a ∨ a ^^^ c < b ∨ a ^^^ b < c
-- Nat.lt_xor_cases
theorem lt_xor_cases {a b c : ℕ} (h : a < b ^^^ c) : a ^^^ c < b ∨ a ^^^ b < c 
Arguments: {a b c : ℕ} (h : a < b ^^^ c)
Goal: a ^^^ c < b ∨ a ^^^ b < c
-- Nat.bit_lt_two_pow_succ_iff
@[simp] theorem bit_lt_two_pow_succ_iff {b x n} : bit b x < 2 ^ (n + 1) ↔ x < 2 ^ n 
Arguments: {b : Bool} {x n : ℕ}
Goal: Nat.bit b x < 2 ^ (n + 1) ↔ x < 2 ^ n
-- Nat.bitwise_lt
theorem bitwise_lt {f x y n} (hx : x < 2 ^ n) (hy : y < 2 ^ n) :
    bitwise f x y < 2 ^ n 
Arguments: {f : Bool → Bool → Bool} {x y n : ℕ} (hx : x < 2 ^ n) (hy : y < 2 ^ n)
Goal: Nat.bitwise f x y < 2 ^ n
-- Nat.shiftLeft_lt
lemma shiftLeft_lt {x n m : ℕ} (h : x < 2 ^ n) : x <<< m < 2 ^ (n + m) 
Arguments: {x n m : ℕ} (h : x < 2 ^ n)
Goal: x <<< m < 2 ^ (n + m)
-- Nat.append_lt
lemma append_lt {x y n m} (hx : x < 2 ^ n) (hy : y < 2 ^ m) : y <<< n ||| x < 2 ^ (n + m) 
Arguments: {x y n m : ℕ} (hx : x < 2 ^ n) (hy : y < 2 ^ m)
Goal: y <<< n ||| x < 2 ^ (n + m)
-- ENat.map_coe_nnreal
@[simp]
theorem map_coe_nnreal : WithTop.map ((↑) : ℕ → ℝ≥0) = ((↑) : ℕ∞ → ℝ≥0∞) 
Goal: WithTop.map Nat.cast = ENat.toENNReal
-- ENat.toENNRealOrderEmbedding_apply
@[simps! (config := .asFn)]
def toENNRealOrderEmbedding : ℕ∞ ↪o ℝ≥0∞ 
Goal: ⇑ENat.toENNRealOrderEmbedding = ENat.toENNReal
-- ENat.toENNRealRingHom_apply
@[simps! (config := .asFn)]
def toENNRealRingHom : ℕ∞ →+* ℝ≥0∞ 
Goal: ⇑ENat.toENNRealRingHom = ENat.toENNReal
-- ENat.toENNReal_top
@[simp, norm_cast]
theorem toENNReal_top : ((⊤ : ℕ∞) : ℝ≥0∞) = ⊤ 
Goal: ↑⊤ = ⊤
-- ENat.toENNReal_coe
@[simp, norm_cast]
theorem toENNReal_coe (n : ℕ) : ((n : ℕ∞) : ℝ≥0∞) = n 
Arguments: (n : ℕ)
Goal: ↑↑n = ↑n
-- ENat.toENNReal_ofNat
@[simp, norm_cast]
theorem toENNReal_ofNat (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n : ℕ∞)) : ℝ≥0∞) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- ENat.toENNReal_coe_eq_iff
@[simp, norm_cast]
theorem toENNReal_coe_eq_iff : (m : ℝ≥0∞) = (n : ℝ≥0∞) ↔ m = n 
Arguments: {m n : ℕ∞}
Goal: ↑m = ↑n ↔ m = n
-- ENat.toENNReal_le
@[simp, norm_cast]
theorem toENNReal_le : (m : ℝ≥0∞) ≤ n ↔ m ≤ n 
Arguments: {m n : ℕ∞}
Goal: ↑m ≤ ↑n ↔ m ≤ n
-- ENat.toENNReal_lt
@[simp, norm_cast]
theorem toENNReal_lt : (m : ℝ≥0∞) < n ↔ m < n 
Arguments: {m n : ℕ∞}
Goal: ↑m < ↑n ↔ m < n
-- ENat.toENNReal_mono
@[mono]
theorem toENNReal_mono : Monotone ((↑) : ℕ∞ → ℝ≥0∞) 
Goal: Monotone ENat.toENNReal
-- ENat.toENNReal_strictMono
@[mono]
theorem toENNReal_strictMono : StrictMono ((↑) : ℕ∞ → ℝ≥0∞) 
Goal: StrictMono ENat.toENNReal
-- ENat.toENNReal_zero
@[simp, norm_cast]
theorem toENNReal_zero : ((0 : ℕ∞) : ℝ≥0∞) = 0 
Goal: ↑0 = 0
-- ENat.toENNReal_add
@[simp, norm_cast]
theorem toENNReal_add (m n : ℕ∞) : ↑(m + n) = (m + n : ℝ≥0∞) 
Arguments: (m n : ℕ∞)
Goal: ↑(m + n) = ↑m + ↑n
-- ENat.toENNReal_one
@[simp, norm_cast]
theorem toENNReal_one : ((1 : ℕ∞) : ℝ≥0∞) = 1 
Goal: ↑1 = 1
-- ENat.toENNReal_mul
@[simp, norm_cast]
theorem toENNReal_mul (m n : ℕ∞) : ↑(m * n) = (m * n : ℝ≥0∞) 
Arguments: (m n : ℕ∞)
Goal: ↑(m * n) = ↑m * ↑n
-- ENat.toENNReal_pow
@[simp, norm_cast]
theorem toENNReal_pow (x : ℕ∞) (n : ℕ) : (x ^ n : ℕ∞) = (x : ℝ≥0∞) ^ n 
Arguments: (x : ℕ∞) (n : ℕ)
Goal: ↑(x ^ n) = ↑x ^ n
-- ENat.toENNReal_min
@[simp, norm_cast]
theorem toENNReal_min (m n : ℕ∞) : ↑(min m n) = (min m n : ℝ≥0∞) 
Arguments: (m n : ℕ∞)
Goal: ↑(min m n) = min ↑m ↑n
-- ENat.toENNReal_max
@[simp, norm_cast]
theorem toENNReal_max (m n : ℕ∞) : ↑(max m n) = (max m n : ℝ≥0∞) 
Arguments: (m n : ℕ∞)
Goal: ↑(max m n) = max ↑m ↑n
-- ENat.toENNReal_sub
@[simp, norm_cast]
theorem toENNReal_sub (m n : ℕ∞) : ↑(m - n) = (m - n : ℝ≥0∞) 
Arguments: (m n : ℕ∞)
Goal: ↑(m - n) = ↑m - ↑n
-- PartENat.dom_some
@[simp]
theorem dom_some (x : ℕ) : (some x).Dom 
Arguments: (x : ℕ)
Goal: (↑x).Dom
-- PartENat.some_eq_natCast
theorem some_eq_natCast (n : ℕ) : some n = n 
Arguments: (n : ℕ)
Goal: ↑n = ↑n
-- PartENat.natCast_inj
theorem natCast_inj {x y : ℕ} : (x : PartENat) = y ↔ x = y 
Arguments: {x y : ℕ}
Goal: ↑x = ↑y ↔ x = y
-- PartENat.dom_natCast
@[simp]
theorem dom_natCast (x : ℕ) : (x : PartENat).Dom 
Arguments: (x : ℕ)
Goal: (↑x).Dom
-- PartENat.dom_ofNat
@[simp]
theorem dom_ofNat (x : ℕ) [x.AtLeastTwo] : (no_index (OfNat.ofNat x : PartENat)).Dom 
Arguments: (x : ℕ) [x.AtLeastTwo]
Goal: (OfNat.ofNat x).Dom
-- PartENat.dom_zero
@[simp]
theorem dom_zero : (0 : PartENat).Dom 
Goal: Part.Dom 0
-- PartENat.dom_one
@[simp]
theorem dom_one : (1 : PartENat).Dom 
Goal: Part.Dom 1
-- PartENat.le_def
theorem le_def (x y : PartENat) :
    x ≤ y ↔ ∃ h : y.Dom → x.Dom, ∀ hy : y.Dom, x.get (h hy) ≤ y.get hy 
Arguments: (x y : PartENat)
Goal: x ≤ y ↔ ∃ (h : y.Dom → x.Dom), ∀ (hy : y.Dom), x.get ⋯ ≤ y.get hy
-- PartENat.casesOn'
@[elab_as_elim]
protected theorem casesOn' {P : PartENat → Prop} :
    ∀ a : PartENat, P ⊤ → (∀ n : ℕ, P (some n)) → P a 
Arguments: {P : PartENat → Prop} (a : PartENat)
Goal: P ⊤ → (∀ (n : ℕ), P ↑n) → P a
-- PartENat.casesOn
@[elab_as_elim]
protected theorem casesOn {P : PartENat → Prop} : ∀ a : PartENat, P ⊤ → (∀ n : ℕ, P n) → P a 
Arguments: {P : PartENat → Prop} (a : PartENat)
Goal: P ⊤ → (∀ (n : ℕ), P ↑n) → P a
-- PartENat.top_add
theorem top_add (x : PartENat) : ⊤ + x = ⊤ 
Arguments: (x : PartENat)
Goal: ⊤ + x = ⊤
-- PartENat.add_top
theorem add_top (x : PartENat) : x + ⊤ = ⊤ 
Arguments: (x : PartENat)
Goal: x + ⊤ = ⊤
-- PartENat.natCast_get
@[simp]
theorem natCast_get {x : PartENat} (h : x.Dom) : (x.get h : PartENat) = x 
Arguments: {x : PartENat} (h : x.Dom)
Goal: ↑(x.get h) = x
-- PartENat.get_natCast'
@[simp, norm_cast]
theorem get_natCast' (x : ℕ) (h : (x : PartENat).Dom) : get (x : PartENat) h = x 
Arguments: (x : ℕ) (h : (↑x).Dom)
Goal: (↑x).get h = x
-- PartENat.get_natCast
theorem get_natCast {x : ℕ} : get (x : PartENat) (dom_natCast x) = x 
Arguments: {x : ℕ}
Goal: (↑x).get ⋯ = x
-- PartENat.coe_add_get
theorem coe_add_get {x : ℕ} {y : PartENat} (h : ((x : PartENat) + y).Dom) :
    get ((x : PartENat) + y) h = x + get y h.2 
Arguments: {x : ℕ} {y : PartENat} (h : (↑x + y).Dom)
Goal: (↑x + y).get h = x + y.get ⋯
-- PartENat.get_add
@[simp]
theorem get_add {x y : PartENat} (h : (x + y).Dom) : get (x + y) h = x.get h.1 + y.get h.2 
Arguments: {x y : PartENat} (h : (x + y).Dom)
Goal: (x + y).get h = x.get ⋯ + y.get ⋯
-- PartENat.get_zero
@[simp]
theorem get_zero (h : (0 : PartENat).Dom) : (0 : PartENat).get h = 0 
Arguments: (h : Part.Dom 0)
Goal: Part.get 0 h = 0
-- PartENat.get_one
@[simp]
theorem get_one (h : (1 : PartENat).Dom) : (1 : PartENat).get h = 1 
Arguments: (h : Part.Dom 1)
Goal: Part.get 1 h = 1
-- PartENat.get_ofNat'
@[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)) 
Arguments: (x : ℕ) [x.AtLeastTwo] (h : (OfNat.ofNat x).Dom)
Goal: (OfNat.ofNat x).get h = OfNat.ofNat x
-- PartENat.get_eq_iff_eq_some
nonrec theorem get_eq_iff_eq_some {a : PartENat} {ha : a.Dom} {b : ℕ} : a.get ha = b ↔ a = some b 
Arguments: {a : PartENat} {ha : a.Dom} {b : ℕ}
Goal: a.get ha = b ↔ a = ↑b
-- PartENat.get_eq_iff_eq_coe
theorem get_eq_iff_eq_coe {a : PartENat} {ha : a.Dom} {b : ℕ} : a.get ha = b ↔ a = b 
Arguments: {a : PartENat} {ha : a.Dom} {b : ℕ}
Goal: a.get ha = b ↔ a = ↑b
-- PartENat.dom_of_le_of_dom
theorem dom_of_le_of_dom {x y : PartENat} : x ≤ y → y.Dom → x.Dom 
Arguments: {x y : PartENat}
Goal: x ≤ y → y.Dom → x.Dom
-- PartENat.dom_of_le_some
theorem dom_of_le_some {x : PartENat} {y : ℕ} (h : x ≤ some y) : x.Dom 
Arguments: {x : PartENat} {y : ℕ} (h : x ≤ ↑y)
Goal: x.Dom
-- PartENat.dom_of_le_natCast
theorem dom_of_le_natCast {x : PartENat} {y : ℕ} (h : x ≤ y) : x.Dom 
Arguments: {x : PartENat} {y : ℕ} (h : x ≤ ↑y)
Goal: x.Dom
-- PartENat.lt_def
theorem lt_def (x y : PartENat) : x < y ↔ ∃ hx : x.Dom, ∀ hy : y.Dom, x.get hx < y.get hy 
Arguments: (x y : PartENat)
Goal: x < y ↔ ∃ (hx : x.Dom), ∀ (hy : y.Dom), x.get hx < y.get hy
-- PartENat.coe_le_coe
theorem coe_le_coe {x y : ℕ} : (x : PartENat) ≤ y ↔ x ≤ y 
Arguments: {x y : ℕ}
Goal: ↑x ≤ ↑y ↔ x ≤ y
-- PartENat.coe_lt_coe
theorem coe_lt_coe {x y : ℕ} : (x : PartENat) < y ↔ x < y 
Arguments: {x y : ℕ}
Goal: ↑x < ↑y ↔ x < y
-- PartENat.get_le_get
@[simp]
theorem get_le_get {x y : PartENat} {hx : x.Dom} {hy : y.Dom} : x.get hx ≤ y.get hy ↔ x ≤ y 
Arguments: {x y : PartENat} {hx : x.Dom} {hy : y.Dom}
Goal: x.get hx ≤ y.get hy ↔ x ≤ y
-- PartENat.le_coe_iff
theorem le_coe_iff (x : PartENat) (n : ℕ) : x ≤ n ↔ ∃ h : x.Dom, x.get h ≤ n 
Arguments: (x : PartENat) (n : ℕ)
Goal: x ≤ ↑n ↔ ∃ (h : x.Dom), x.get h ≤ n
-- PartENat.lt_coe_iff
theorem lt_coe_iff (x : PartENat) (n : ℕ) : x < n ↔ ∃ h : x.Dom, x.get h < n 
Arguments: (x : PartENat) (n : ℕ)
Goal: x < ↑n ↔ ∃ (h : x.Dom), x.get h < n
-- PartENat.coe_le_iff
theorem coe_le_iff (n : ℕ) (x : PartENat) : (n : PartENat) ≤ x ↔ ∀ h : x.Dom, n ≤ x.get h 
Arguments: (n : ℕ) (x : PartENat)
Goal: ↑n ≤ x ↔ ∀ (h : x.Dom), n ≤ x.get h
-- PartENat.coe_lt_iff
theorem coe_lt_iff (n : ℕ) (x : PartENat) : (n : PartENat) < x ↔ ∀ h : x.Dom, n < x.get h 
Arguments: (n : ℕ) (x : PartENat)
Goal: ↑n < x ↔ ∀ (h : x.Dom), n < x.get h
-- PartENat.eq_zero_iff
nonrec theorem eq_zero_iff {x : PartENat} : x = 0 ↔ x ≤ 0 
Arguments: {x : PartENat}
Goal: x = 0 ↔ x ≤ 0
-- PartENat.ne_zero_iff
theorem ne_zero_iff {x : PartENat} : x ≠ 0 ↔ ⊥ < x 
Arguments: {x : PartENat}
Goal: x ≠ 0 ↔ ⊥ < x
-- PartENat.dom_of_lt
theorem dom_of_lt {x y : PartENat} : x < y → x.Dom 
Arguments: {x y : PartENat}
Goal: x < y → x.Dom
-- PartENat.top_eq_none
theorem top_eq_none : (⊤ : PartENat) = Part.none 
Goal: ⊤ = Part.none
-- PartENat.natCast_lt_top
@[simp]
theorem natCast_lt_top (x : ℕ) : (x : PartENat) < ⊤ 
Arguments: (x : ℕ)
Goal: ↑x < ⊤
-- PartENat.zero_lt_top
@[simp]
theorem zero_lt_top : (0 : PartENat) < ⊤ 
Goal: 0 < ⊤
-- PartENat.one_lt_top
@[simp]
theorem one_lt_top : (1 : PartENat) < ⊤ 
Goal: 1 < ⊤
-- PartENat.ofNat_lt_top
@[simp]
theorem ofNat_lt_top (x : ℕ) [x.AtLeastTwo] : (no_index (OfNat.ofNat x : PartENat)) < ⊤ 
Arguments: (x : ℕ) [x.AtLeastTwo]
Goal: OfNat.ofNat x < ⊤
-- PartENat.natCast_ne_top
@[simp]
theorem natCast_ne_top (x : ℕ) : (x : PartENat) ≠ ⊤ 
Arguments: (x : ℕ)
Goal: ↑x ≠ ⊤
-- PartENat.zero_ne_top
@[simp]
theorem zero_ne_top : (0 : PartENat) ≠ ⊤ 
Goal: 0 ≠ ⊤
-- PartENat.one_ne_top
@[simp]
theorem one_ne_top : (1 : PartENat) ≠ ⊤ 
Goal: 1 ≠ ⊤
-- PartENat.ofNat_ne_top
@[simp]
theorem ofNat_ne_top (x : ℕ) [x.AtLeastTwo] : (no_index (OfNat.ofNat x : PartENat)) ≠ ⊤ 
Arguments: (x : ℕ) [x.AtLeastTwo]
Goal: OfNat.ofNat x ≠ ⊤
-- PartENat.not_isMax_natCast
theorem not_isMax_natCast (x : ℕ) : ¬IsMax (x : PartENat) 
Arguments: (x : ℕ)
Goal: ¬IsMax ↑x
-- PartENat.ne_top_iff
theorem ne_top_iff {x : PartENat} : x ≠ ⊤ ↔ ∃ n : ℕ, x = n 
Arguments: {x : PartENat}
Goal: x ≠ ⊤ ↔ ∃ n, x = ↑n
-- PartENat.ne_top_iff_dom
theorem ne_top_iff_dom {x : PartENat} : x ≠ ⊤ ↔ x.Dom 
Arguments: {x : PartENat}
Goal: x ≠ ⊤ ↔ x.Dom
-- PartENat.not_dom_iff_eq_top
theorem not_dom_iff_eq_top {x : PartENat} : ¬x.Dom ↔ x = ⊤ 
Arguments: {x : PartENat}
Goal: ¬x.Dom ↔ x = ⊤
-- PartENat.ne_top_of_lt
theorem ne_top_of_lt {x y : PartENat} (h : x < y) : x ≠ ⊤ 
Arguments: {x y : PartENat} (h : x < y)
Goal: x ≠ ⊤
-- PartENat.eq_top_iff_forall_lt
theorem eq_top_iff_forall_lt (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : PartENat) < x 
Arguments: (x : PartENat)
Goal: x = ⊤ ↔ ∀ (n : ℕ), ↑n < x
-- PartENat.eq_top_iff_forall_le
theorem eq_top_iff_forall_le (x : PartENat) : x = ⊤ ↔ ∀ n : ℕ, (n : PartENat) ≤ x 
Arguments: (x : PartENat)
Goal: x = ⊤ ↔ ∀ (n : ℕ), ↑n ≤ x
-- PartENat.pos_iff_one_le
theorem pos_iff_one_le {x : PartENat} : 0 < x ↔ 1 ≤ x 
Arguments: {x : PartENat}
Goal: 0 < x ↔ 1 ≤ x
-- PartENat.eq_natCast_sub_of_add_eq_natCast
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))) 
Arguments: {x y : PartENat} {n : ℕ} (h : x + y = ↑n)
Goal: x = ↑(n - y.get ⋯)
-- PartENat.add_lt_add_right
protected theorem add_lt_add_right {x y z : PartENat} (h : x < y) (hz : z ≠ ⊤) : x + z < y + z 
Arguments: {x y z : PartENat} (h : x < y) (hz : z ≠ ⊤)
Goal: x + z < y + z
-- PartENat.add_lt_add_iff_right
protected theorem add_lt_add_iff_right {x y z : PartENat} (hz : z ≠ ⊤) : x + z < y + z ↔ x < y 
Arguments: {x y z : PartENat} (hz : z ≠ ⊤)
Goal: x + z < y + z ↔ x < y
-- PartENat.add_lt_add_iff_left
protected theorem add_lt_add_iff_left {x y z : PartENat} (hz : z ≠ ⊤) : z + x < z + y ↔ x < y 
Arguments: {x y z : PartENat} (hz : z ≠ ⊤)
Goal: z + x < z + y ↔ x < y
-- PartENat.lt_add_iff_pos_right
protected theorem lt_add_iff_pos_right {x y : PartENat} (hx : x ≠ ⊤) : x < x + y ↔ 0 < y 
Arguments: {x y : PartENat} (hx : x ≠ ⊤)
Goal: x < x + y ↔ 0 < y
-- PartENat.lt_add_one
theorem lt_add_one {x : PartENat} (hx : x ≠ ⊤) : x < x + 1 
Arguments: {x : PartENat} (hx : x ≠ ⊤)
Goal: x < x + 1
-- PartENat.le_of_lt_add_one
theorem le_of_lt_add_one {x y : PartENat} (h : x < y + 1) : x ≤ y 
Arguments: {x y : PartENat} (h : x < y + 1)
Goal: x ≤ y
-- PartENat.add_one_le_of_lt
theorem add_one_le_of_lt {x y : PartENat} (h : x < y) : x + 1 ≤ y 
Arguments: {x y : PartENat} (h : x < y)
Goal: x + 1 ≤ y
-- PartENat.add_one_le_iff_lt
theorem add_one_le_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x + 1 ≤ y ↔ x < y 
Arguments: {x y : PartENat} (hx : x ≠ ⊤)
Goal: x + 1 ≤ y ↔ x < y
-- PartENat.coe_succ_le_iff
theorem coe_succ_le_iff {n : ℕ} {e : PartENat} : ↑n.succ ≤ e ↔ ↑n < e 
Arguments: {n : ℕ} {e : PartENat}
Goal: ↑n.succ ≤ e ↔ ↑n < e
-- PartENat.lt_add_one_iff_lt
theorem lt_add_one_iff_lt {x y : PartENat} (hx : x ≠ ⊤) : x < y + 1 ↔ x ≤ y 
Arguments: {x y : PartENat} (hx : x ≠ ⊤)
Goal: x < y + 1 ↔ x ≤ y
-- PartENat.lt_coe_succ_iff_le
lemma lt_coe_succ_iff_le {x : PartENat} {n : ℕ} (hx : x ≠ ⊤) : x < n.succ ↔ x ≤ n 
Arguments: {x : PartENat} {n : ℕ} (hx : x ≠ ⊤)
Goal: x < ↑n.succ ↔ x ≤ ↑n
-- PartENat.add_eq_top_iff
theorem add_eq_top_iff {a b : PartENat} : a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤ 
Arguments: {a b : PartENat}
Goal: a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤
-- PartENat.add_right_cancel_iff
protected theorem add_right_cancel_iff {a b c : PartENat} (hc : c ≠ ⊤) : a + c = b + c ↔ a = b 
Arguments: {a b c : PartENat} (hc : c ≠ ⊤)
Goal: a + c = b + c ↔ a = b
-- PartENat.add_left_cancel_iff
protected theorem add_left_cancel_iff {a b c : PartENat} (ha : a ≠ ⊤) : a + b = a + c ↔ b = c 
Arguments: {a b c : PartENat} (ha : a ≠ ⊤)
Goal: a + b = a + c ↔ b = c
-- PartENat.toWithTop_top
theorem toWithTop_top :
    have : Decidable (⊤ : PartENat).Dom := Part.noneDecidable
    toWithTop ⊤ = ⊤ 
Goal: let_fun this := Part.noneDecidable;
⊤.toWithTop = ⊤
-- PartENat.toWithTop_top'
@[simp]
theorem toWithTop_top' {h : Decidable (⊤ : PartENat).Dom} : toWithTop ⊤ = ⊤ 
Arguments: {h : Decidable ⊤.Dom}
Goal: ⊤.toWithTop = ⊤
-- PartENat.toWithTop_zero
theorem toWithTop_zero :
    have : Decidable (0 : PartENat).Dom := someDecidable 0
    toWithTop 0 = 0 
Goal: let_fun this := Part.someDecidable 0;
PartENat.toWithTop 0 = 0
-- PartENat.toWithTop_zero'
@[simp]
theorem toWithTop_zero' {h : Decidable (0 : PartENat).Dom} : toWithTop 0 = 0 
Arguments: {h : Decidable (Part.Dom 0)}
Goal: PartENat.toWithTop 0 = 0
-- PartENat.toWithTop_one
theorem toWithTop_one :
    have : Decidable (1 : PartENat).Dom := someDecidable 1
    toWithTop 1 = 1 
Goal: let_fun this := Part.someDecidable 1;
PartENat.toWithTop 1 = 1
-- PartENat.toWithTop_one'
@[simp]
theorem toWithTop_one' {h : Decidable (1 : PartENat).Dom} : toWithTop 1 = 1 
Arguments: {h : Decidable (Part.Dom 1)}
Goal: PartENat.toWithTop 1 = 1
-- PartENat.toWithTop_some
theorem toWithTop_some (n : ℕ) : toWithTop (some n) = n 
Arguments: (n : ℕ)
Goal: (↑n).toWithTop = ↑n
-- PartENat.toWithTop_natCast
theorem toWithTop_natCast (n : ℕ) {_ : Decidable (n : PartENat).Dom} : toWithTop n = n 
Arguments: (n : ℕ)
Goal: ∀ {x : Decidable (↑n).Dom}, (↑n).toWithTop = ↑n
-- PartENat.toWithTop_natCast'
@[simp]
theorem toWithTop_natCast' (n : ℕ) {_ : Decidable (n : PartENat).Dom} :
    toWithTop (n : PartENat) = n 
Arguments: (n : ℕ)
Goal: ∀ {x : Decidable (↑n).Dom}, (↑n).toWithTop = ↑n
-- PartENat.toWithTop_ofNat
@[simp]
theorem toWithTop_ofNat (n : ℕ) [n.AtLeastTwo] {_ : Decidable (OfNat.ofNat n : PartENat).Dom} :
    toWithTop (no_index (OfNat.ofNat n : PartENat)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: ∀ {x : Decidable (Part.Dom (OfNat.ofNat n))}, (OfNat.ofNat n).toWithTop = OfNat.ofNat n
-- PartENat.toWithTop_le
@[simp]
theorem toWithTop_le {x y : PartENat} [hx : Decidable x.Dom] [hy : Decidable y.Dom] :
    toWithTop x ≤ toWithTop y ↔ x ≤ y 
Arguments: {x y : PartENat} [hx : Decidable x.Dom] [hy : Decidable y.Dom]
Goal: x.toWithTop ≤ y.toWithTop ↔ x ≤ y
-- PartENat.toWithTop_lt
@[simp]
theorem toWithTop_lt {x y : PartENat} [Decidable x.Dom] [Decidable y.Dom] :
    toWithTop x < toWithTop y ↔ x < y 
Arguments: {x y : PartENat} [Decidable x.Dom] [Decidable y.Dom]
Goal: x.toWithTop < y.toWithTop ↔ x < y
-- PartENat.ofENat_top
@[simp, norm_cast]
lemma ofENat_top : ofENat ⊤ = ⊤ 
Goal: ↑⊤ = ⊤
-- PartENat.ofENat_coe
@[simp, norm_cast]
lemma ofENat_coe (n : ℕ) : ofENat n = n 
Arguments: (n : ℕ)
Goal: ↑↑n = ↑n
-- PartENat.ofENat_zero
@[simp, norm_cast]
theorem ofENat_zero : ofENat 0 = 0 
Goal: ↑0 = 0
-- PartENat.ofENat_one
@[simp, norm_cast]
theorem ofENat_one : ofENat 1 = 1 
Goal: ↑1 = 1
-- PartENat.ofENat_ofNat
@[simp, norm_cast]
theorem ofENat_ofNat (n : Nat) [n.AtLeastTwo] : ofENat (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: ↑(OfNat.ofNat n) = OfNat.ofNat n
-- PartENat.toWithTop_ofENat
@[simp, norm_cast]
theorem toWithTop_ofENat (n : ℕ∞) {_ : Decidable (n : PartENat).Dom} : toWithTop (↑n) = n 
Arguments: (n : ℕ∞)
Goal: ∀ {x : Decidable (↑n).Dom}, (↑n).toWithTop = n
-- PartENat.ofENat_toWithTop
@[simp, norm_cast]
theorem ofENat_toWithTop (x : PartENat) {_ : Decidable (x : PartENat).Dom} : toWithTop x = x 
Arguments: (x : PartENat)
Goal: ∀ {x_1 : Decidable x.Dom}, ↑x.toWithTop = x
-- PartENat.ofENat_le
@[simp, norm_cast]
theorem ofENat_le {x y : ℕ∞} : ofENat x ≤ ofENat y ↔ x ≤ y 
Arguments: {x y : ℕ∞}
Goal: ↑x ≤ ↑y ↔ x ≤ y
-- PartENat.ofENat_lt
@[simp, norm_cast]
theorem ofENat_lt {x y : ℕ∞} : ofENat x < ofENat y ↔ x < y 
Arguments: {x y : ℕ∞}
Goal: ↑x < ↑y ↔ x < y
-- PartENat.toWithTop_add
@[simp]
theorem toWithTop_add {x y : PartENat} : toWithTop (x + y) = toWithTop x + toWithTop y 
Arguments: {x y : PartENat}
Goal: (x + y).toWithTop = x.toWithTop + y.toWithTop
-- PartENat.withTopEquiv_symm_apply
@[simps]
noncomputable def withTopEquiv : PartENat ≃ ℕ∞ 
Arguments: (x : ℕ∞)
Goal: PartENat.withTopEquiv.symm x = ↑x
-- PartENat.withTopEquiv_apply
@[simps]
noncomputable def withTopEquiv : PartENat ≃ ℕ∞ 
Arguments: (x : PartENat)
Goal: PartENat.withTopEquiv x = x.toWithTop
-- PartENat.withTopEquiv_top
theorem withTopEquiv_top : withTopEquiv ⊤ = ⊤ 
Goal: PartENat.withTopEquiv ⊤ = ⊤
-- PartENat.withTopEquiv_natCast
theorem withTopEquiv_natCast (n : Nat) : withTopEquiv n = n 
Arguments: (n : ℕ)
Goal: PartENat.withTopEquiv ↑n = ↑n
-- PartENat.withTopEquiv_zero
theorem withTopEquiv_zero : withTopEquiv 0 = 0 
Goal: PartENat.withTopEquiv 0 = 0
-- PartENat.withTopEquiv_one
theorem withTopEquiv_one : withTopEquiv 1 = 1 
Goal: PartENat.withTopEquiv 1 = 1
-- PartENat.withTopEquiv_ofNat
theorem withTopEquiv_ofNat (n : Nat) [n.AtLeastTwo] :
    withTopEquiv (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: PartENat.withTopEquiv (OfNat.ofNat n) = OfNat.ofNat n
-- PartENat.withTopEquiv_le
theorem withTopEquiv_le {x y : PartENat} : withTopEquiv x ≤ withTopEquiv y ↔ x ≤ y 
Arguments: {x y : PartENat}
Goal: PartENat.withTopEquiv x ≤ PartENat.withTopEquiv y ↔ x ≤ y
-- PartENat.withTopEquiv_lt
theorem withTopEquiv_lt {x y : PartENat} : withTopEquiv x < withTopEquiv y ↔ x < y 
Arguments: {x y : PartENat}
Goal: PartENat.withTopEquiv x < PartENat.withTopEquiv y ↔ x < y
-- PartENat.withTopEquiv_symm_top
theorem withTopEquiv_symm_top : withTopEquiv.symm ⊤ = ⊤ 
Goal: PartENat.withTopEquiv.symm ⊤ = ⊤
-- PartENat.withTopEquiv_symm_coe
theorem withTopEquiv_symm_coe (n : Nat) : withTopEquiv.symm n = n 
Arguments: (n : ℕ)
Goal: PartENat.withTopEquiv.symm ↑n = ↑n
-- PartENat.withTopEquiv_symm_zero
theorem withTopEquiv_symm_zero : withTopEquiv.symm 0 = 0 
Goal: PartENat.withTopEquiv.symm 0 = 0
-- PartENat.withTopEquiv_symm_one
theorem withTopEquiv_symm_one : withTopEquiv.symm 1 = 1 
Goal: PartENat.withTopEquiv.symm 1 = 1
-- PartENat.withTopEquiv_symm_ofNat
theorem withTopEquiv_symm_ofNat (n : Nat) [n.AtLeastTwo] :
    withTopEquiv.symm (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: PartENat.withTopEquiv.symm (OfNat.ofNat n) = OfNat.ofNat n
-- PartENat.withTopEquiv_symm_le
theorem withTopEquiv_symm_le {x y : ℕ∞} : withTopEquiv.symm x ≤ withTopEquiv.symm y ↔ x ≤ y 
Arguments: {x y : ℕ∞}
Goal: PartENat.withTopEquiv.symm x ≤ PartENat.withTopEquiv.symm y ↔ x ≤ y
-- PartENat.withTopEquiv_symm_lt
theorem withTopEquiv_symm_lt {x y : ℕ∞} : withTopEquiv.symm x < withTopEquiv.symm y ↔ x < y 
Arguments: {x y : ℕ∞}
Goal: PartENat.withTopEquiv.symm x < PartENat.withTopEquiv.symm y ↔ x < y
-- PartENat.lt_wf
theorem lt_wf : @WellFounded PartENat (· < ·) 
Goal: WellFounded fun x x_1 => x < x_1
-- PartENat.find_get
@[simp]
theorem find_get (h : (find P).Dom) : (find P).get h = Nat.find h 
Arguments: (P : ℕ → Prop) [DecidablePred P] (h : (PartENat.find P).Dom)
Goal: (PartENat.find P).get h = Nat.find h
-- PartENat.find_dom
theorem find_dom (h : ∃ n, P n) : (find P).Dom 
Arguments: (P : ℕ → Prop) [DecidablePred P] (h : ∃ n, P n)
Goal: (PartENat.find P).Dom
-- PartENat.lt_find
theorem lt_find (n : ℕ) (h : ∀ m ≤ n, ¬P m) : (n : PartENat) < find P 
Arguments: (P : ℕ → Prop) [DecidablePred P] (n : ℕ) (h : ∀ m ≤ n, ¬P m)
Goal: ↑n < PartENat.find P
-- PartENat.lt_find_iff
theorem lt_find_iff (n : ℕ) : (n : PartENat) < find P ↔ ∀ m ≤ n, ¬P m 
Arguments: (P : ℕ → Prop) [DecidablePred P] (n : ℕ)
Goal: ↑n < PartENat.find P ↔ ∀ m ≤ n, ¬P m
-- PartENat.find_le
theorem find_le (n : ℕ) (h : P n) : find P ≤ n 
Arguments: (P : ℕ → Prop) [DecidablePred P] (n : ℕ) (h : P n)
Goal: PartENat.find P ≤ ↑n
-- PartENat.find_eq_top_iff
theorem find_eq_top_iff : find P = ⊤ ↔ ∀ n, ¬P n 
Arguments: (P : ℕ → Prop) [DecidablePred P]
Goal: PartENat.find P = ⊤ ↔ ∀ (n : ℕ), ¬P n
-- Real.sign_of_neg
theorem sign_of_neg {r : ℝ} (hr : r < 0) : sign r = -1 
Arguments: {r : ℝ} (hr : r < 0)
Goal: r.sign = -1
-- Real.sign_of_pos
theorem sign_of_pos {r : ℝ} (hr : 0 < r) : sign r = 1 
Arguments: {r : ℝ} (hr : 0 < r)
Goal: r.sign = 1
-- Real.sign_zero
@[simp]
theorem sign_zero : sign 0 = 0 
Goal: Real.sign 0 = 0
-- Real.sign_one
@[simp]
theorem sign_one : sign 1 = 1 
Goal: Real.sign 1 = 1
-- Real.sign_apply_eq
theorem sign_apply_eq (r : ℝ) : sign r = -1 ∨ sign r = 0 ∨ sign r = 1 
Arguments: (r : ℝ)
Goal: r.sign = -1 ∨ r.sign = 0 ∨ r.sign = 1
-- Real.sign_apply_eq_of_ne_zero
theorem sign_apply_eq_of_ne_zero (r : ℝ) (h : r ≠ 0) : sign r = -1 ∨ sign r = 1 
Arguments: (r : ℝ) (h : r ≠ 0)
Goal: r.sign = -1 ∨ r.sign = 1
-- Real.sign_eq_zero_iff
@[simp]
theorem sign_eq_zero_iff {r : ℝ} : sign r = 0 ↔ r = 0 
Arguments: {r : ℝ}
Goal: r.sign = 0 ↔ r = 0
-- Real.sign_intCast
theorem sign_intCast (z : ℤ) : sign (z : ℝ) = ↑(Int.sign z) 
Arguments: (z : ℤ)
Goal: (↑z).sign = ↑z.sign