ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.drop_append_eq_append_drop
theorem drop_append_eq_append_drop {l₁ l₂ : List α} {n : Nat} :
    drop n (l₁ ++ l₂) = drop n l₁ ++ drop (n - l₁.length) l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat}
Goal: List.drop n (l₁ ++ l₂) = List.drop n l₁ ++ List.drop (n - l₁.length) l₂
-- List.drop_append_of_le_length
theorem drop_append_of_le_length {l₁ l₂ : List α} {n : Nat} (h : n ≤ l₁.length) :
    (l₁ ++ l₂).drop n = l₁.drop n ++ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat} (h : n ≤ l₁.length)
Goal: List.drop n (l₁ ++ l₂) = List.drop n l₁ ++ l₂
-- List.drop_append
@[simp]
theorem drop_append {l₁ l₂ : List α} (i : Nat) : drop (l₁.length + i) (l₁ ++ l₂) = drop i l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (i : Nat)
Goal: List.drop (l₁.length + i) (l₁ ++ l₂) = List.drop i l₂
-- List.lt_length_drop
theorem lt_length_drop (L : List α) {i j : Nat} (h : i + j < L.length) : j < (L.drop i).length 
Arguments: {α : Type u_1} (L : List α) {i j : Nat} (h : i + j < L.length)
Goal: j < (List.drop i L).length
-- List.getElem_drop
theorem getElem_drop (L : List α) {i j : Nat} (h : i + j < L.length) :
    L[i + j] = (L.drop i)[j]'(lt_length_drop L h) 
Arguments: {α : Type u_1} (L : List α) {i j : Nat} (h : i + j < L.length)
Goal: L[i + j] = (List.drop i L)[j]
-- List.get_drop
@[deprecated getElem_drop (since := "2024-06-12")]
theorem get_drop (L : List α) {i j : Nat} (h : i + j < L.length) :
    get L ⟨i + j, h⟩ = get (L.drop i) ⟨j, lt_length_drop L h⟩ 
Arguments: {α : Type u_1} (L : List α) {i j : Nat} (h : i + j < L.length)
Goal: L.get ⟨i + j, h⟩ = (List.drop i L).get ⟨j, ⋯⟩
-- List.getElem_drop'
theorem getElem_drop' (L : List α) {i : Nat} {j : Nat} {h : j < (L.drop i).length} :
    (L.drop i)[j] = L[i + j]'(by
      rw [Nat.add_comm]
      exact Nat.add_lt_of_lt_sub (length_drop i L ▸ h)) 
Arguments: {α : Type u_1} (L : List α) {i j : Nat} {h : j < (List.drop i L).length}
Goal: (List.drop i L)[j] = L[i + j]
-- List.get_drop'
@[deprecated getElem_drop' (since := "2024-06-12")]
theorem get_drop' (L : List α) {i j} :
    get (L.drop i) j = get L ⟨i + j, by
      rw [Nat.add_comm]
      exact Nat.add_lt_of_lt_sub (length_drop i L ▸ j.2)⟩ 
Arguments: {α : Type u_1} (L : List α) {i : Nat} {j : Fin (List.drop i L).length}
Goal: (List.drop i L).get j = L.get ⟨i + ↑j, ⋯⟩
-- List.getElem?_drop
@[simp]
theorem getElem?_drop (L : List α) (i j : Nat) : (L.drop i)[j]? = L[i + j]? 
Arguments: {α : Type u_1} (L : List α) (i j : Nat)
Goal: (List.drop i L)[j]? = L[i + j]?
-- List.get?_drop
@[deprecated getElem?_drop (since := "2024-06-12")]
theorem get?_drop (L : List α) (i j : Nat) : get? (L.drop i) j = get? L (i + j) 
Arguments: {α : Type u_1} (L : List α) (i j : Nat)
Goal: (List.drop i L).get? j = L.get? (i + j)
-- List.set_eq_take_append_cons_drop
theorem set_eq_take_append_cons_drop {l : List α} {n : Nat} {a : α} :
    l.set n a = if n < l.length then l.take n ++ a :: l.drop (n + 1) else l 
Arguments: {α : Type u_1} {l : List α} {n : Nat} {a : α}
Goal: l.set n a = if n < l.length then List.take n l ++ a :: List.drop (n + 1) l else l
-- List.drop_take
theorem drop_take : ∀ (m n : Nat) (l : List α), drop n (take m l) = take (m - n) (drop n l)
  
Arguments: {α : Type u_1} (m n : Nat) (l : List α)
Goal: List.drop n (List.take m l) = List.take (m - n) (List.drop n l)
-- List.take_reverse
theorem take_reverse {α} {xs : List α} (n : Nat) (h : n ≤ xs.length) :
    xs.reverse.take n = (xs.drop (xs.length - n)).reverse 
Arguments: {α : Type u_1} {xs : List α} (n : Nat) (h : n ≤ xs.length)
Goal: List.take n xs.reverse = (List.drop (xs.length - n) xs).reverse
-- List.rotateLeft_replicate
@[simp] theorem rotateLeft_replicate (n) (a : α) : rotateLeft (replicate m a) n = replicate m a 
Arguments: {α : Type u_1} {m : Nat} (n : Nat) (a : α)
Goal: (List.replicate m a).rotateLeft n = List.replicate m a
-- List.rotateRight_replicate
@[simp] theorem rotateRight_replicate (n) (a : α) : rotateRight (replicate m a) n = replicate m a 
Arguments: {α : Type u_1} {m : Nat} (n : Nat) (a : α)
Goal: (List.replicate m a).rotateRight n = List.replicate m a
-- List.length_zipWith
@[simp] theorem length_zipWith (f : α → β → γ) (l₁ l₂) :
    length (zipWith f l₁ l₂) = min (length l₁) (length l₂) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β → γ) (l₁ : List α) (l₂ : List β)
Goal: (List.zipWith f l₁ l₂).length = min l₁.length l₂.length
-- List.zipWith_eq_zipWith_take_min
theorem zipWith_eq_zipWith_take_min : ∀ (l₁ : List α) (l₂ : List β),
    zipWith f l₁ l₂ = zipWith f (l₁.take (min l₁.length l₂.length)) (l₂.take (min l₁.length l₂.length))
  
Arguments: {α : Type u_1} {β : Type u_2}
Goal: ∀ {α_1 : Type u_3} {f : α → β → α_1} (l₁ : List α) (l₂ : List β),
  List.zipWith f l₁ l₂ =
    List.zipWith f (List.take (min l₁.length l₂.length) l₁) (List.take (min l₁.length l₂.length) l₂)
-- List.zipWith_replicate
@[simp] theorem zipWith_replicate {a : α} {b : β} {m n : Nat} :
    zipWith f (replicate m a) (replicate n b) = replicate (min m n) (f a b) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: ∀ {α_1 : Type u_3} {f : α → β → α_1} {a : α} {b : β} {m n : Nat},
  List.zipWith f (List.replicate m a) (List.replicate n b) = List.replicate (min m n) (f a b)
-- List.length_zip
@[simp] theorem length_zip (l₁ : List α) (l₂ : List β) :
    length (zip l₁ l₂) = min (length l₁) (length l₂) 
Arguments: {α : Type u_1} {β : Type u_2} (l₁ : List α) (l₂ : List β)
Goal: (l₁.zip l₂).length = min l₁.length l₂.length
-- List.zip_eq_zip_take_min
theorem zip_eq_zip_take_min : ∀ (l₁ : List α) (l₂ : List β),
    zip l₁ l₂ = zip (l₁.take (min l₁.length l₂.length)) (l₂.take (min l₁.length l₂.length))
  
Arguments: {α : Type u_1} {β : Type u_2} (l₁ : List α) (l₂ : List β)
Goal: l₁.zip l₂ = (List.take (min l₁.length l₂.length) l₁).zip (List.take (min l₁.length l₂.length) l₂)
-- List.zip_replicate
@[simp] theorem zip_replicate {a : α} {b : β} {m n : Nat} :
    zip (replicate m a) (replicate n b) = replicate (min m n) (a, b) 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {b : β} {m n : Nat}
Goal: (List.replicate m a).zip (List.replicate n b) = List.replicate (min m n) (a, b)
-- List.minimum?_eq_some_iff'
theorem minimum?_eq_some_iff' {xs : List Nat} :
    xs.minimum? = some a ↔ (a ∈ xs ∧ ∀ b ∈ xs, a ≤ b) 
Arguments: {a : Nat} {xs : List Nat}
Goal: xs.minimum? = some a ↔ a ∈ xs ∧ ∀ (b : Nat), b ∈ xs → a ≤ b
-- List.maximum?_eq_some_iff'
theorem maximum?_eq_some_iff' {xs : List Nat} :
    xs.maximum? = some a ↔ (a ∈ xs ∧ ∀ b ∈ xs, b ≤ a) 
Arguments: {a : Nat} {xs : List Nat}
Goal: xs.maximum? = some a ↔ a ∈ xs ∧ ∀ (b : Nat), b ∈ xs → b ≤ a
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Fin.Basic.0.Fin.mlt
private theorem mlt {b : Nat} : {a : Nat} → a < n → b % n < n
  
Arguments: {n b a : Nat}
Goal: a < n → b % n < n
-- Fin.zero_eta
@[simp] theorem zero_eta : (⟨0, Nat.zero_lt_succ _⟩ : Fin (n + 1)) = 0 
Arguments: {n : Nat}
Goal: ⟨0, ⋯⟩ = 0
-- Fin.val_ne_of_ne
theorem val_ne_of_ne {i j : Fin n} (h : i ≠ j) : val i ≠ val j 
Arguments: {n : Nat} {i j : Fin n} (h : i ≠ j)
Goal: ↑i ≠ ↑j
-- Fin.modn_lt
theorem modn_lt : ∀ {m : Nat} (i : Fin n), m > 0 → (modn i m).val < m
  
Arguments: {n m : Nat} (i : Fin n)
Goal: m > 0 → ↑(i.modn m) < m
-- Fin.val_lt_of_le
theorem val_lt_of_le (i : Fin b) (h : b ≤ n) : i.val < n 
Arguments: {n b : Nat} (i : Fin b) (h : b ≤ n)
Goal: ↑i < n
-- Fin.pos
protected theorem pos (i : Fin n) : 0 < n 
Arguments: {n : Nat} (i : Fin n)
Goal: 0 < n
-- Fin.val_inj
theorem val_inj {a b : Fin n} : a.1 = b.1 ↔ a = b 
Arguments: {n : Nat} {a b : Fin n}
Goal: ↑a = ↑b ↔ a = b
-- Fin.val_congr
theorem val_congr {n : Nat} {a b : Fin n} (h : a = b) : (a : Nat) = (b : Nat) 
Arguments: {n : Nat} {a b : Fin n} (h : a = b)
Goal: ↑a = ↑b
-- Fin.val_le_of_le
theorem val_le_of_le {n : Nat} {a b : Fin n} (h : a ≤ b) : (a : Nat) ≤ (b : Nat) 
Arguments: {n : Nat} {a b : Fin n} (h : a ≤ b)
Goal: ↑a ≤ ↑b
-- Fin.val_le_of_ge
theorem val_le_of_ge {n : Nat} {a b : Fin n} (h : a ≥ b) : (b : Nat) ≤ (a : Nat) 
Arguments: {n : Nat} {a b : Fin n} (h : a ≥ b)
Goal: ↑b ≤ ↑a
-- Fin.val_add_one_le_of_lt
theorem val_add_one_le_of_lt {n : Nat} {a b : Fin n} (h : a < b) : (a : Nat) + 1 ≤ (b : Nat) 
Arguments: {n : Nat} {a b : Fin n} (h : a < b)
Goal: ↑a + 1 ≤ ↑b
-- Fin.val_add_one_le_of_gt
theorem val_add_one_le_of_gt {n : Nat} {a b : Fin n} (h : a > b) : (b : Nat) + 1 ≤ (a : Nat) 
Arguments: {n : Nat} {a b : Fin n} (h : a > b)
Goal: ↑b + 1 ≤ ↑a
-- Fin.exists_iff
theorem exists_iff {p : Fin n → Prop} : (Exists fun i => p i) ↔ Exists fun i => Exists fun h => p ⟨i, h⟩ 
Arguments: {n : Nat} {p : Fin n → Prop}
Goal: (Exists fun i => p i) ↔ Exists fun i => Exists fun h => p ⟨i, h⟩
-- Option.eq_of_eq_some
theorem eq_of_eq_some {α : Type u} : ∀ {x y : Option α}, (∀z, x = some z ↔ y = some z) → x = y
  
Arguments: {α : Type u} {x y : Option α}
Goal: (∀ (z : α), x = some z ↔ y = some z) → x = y
-- Option.eq_none_of_isNone
theorem eq_none_of_isNone {α : Type u} : ∀ {o : Option α}, o.isNone → o = none
  
Arguments: {α : Type u} {o : Option α}
Goal: o.isNone = true → o = none
-- Option.mem_def
@[simp] theorem mem_def {a : α} {b : Option α} : a ∈ b ↔ b = some a 
Arguments: {α : Type u_1} {a : α} {b : Option α}
Goal: a ∈ b ↔ b = some a
-- Option.isNone_iff_eq_none
@[simp] theorem isNone_iff_eq_none {o : Option α} : o.isNone ↔ o = none 
Arguments: {α : Type u_1} {o : Option α}
Goal: o.isNone = true ↔ o = none
-- Option.some_inj
theorem some_inj {a b : α} : some a = some b ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: some a = some b ↔ a = b
-- Option.map_id
theorem map_id : (Option.map id : Option α → Option α) = id 
Arguments: {α : Type u_1}
Goal: Option.map id = id
-- Option.getD_none
@[simp] theorem getD_none : getD none a = a 
Goal: ∀ {α : Type u_1} {a : α}, none.getD a = a
-- Option.getD_some
@[simp] theorem getD_some : getD (some a) b = a 
Goal: ∀ {α : Type u_1} {a b : α}, (some a).getD b = a
-- Option.map_none'
@[simp] theorem map_none' (f : α → β) : none.map f = none 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: Option.map f none = none
-- Option.map_some'
@[simp] theorem map_some' (a) (f : α → β) : (some a).map f = some (f a) 
Arguments: {α : Type u_1} {β : Type u_2} (a : α) (f : α → β)
Goal: Option.map f (some a) = some (f a)
-- Option.none_bind
@[simp] theorem none_bind (f : α → Option β) : none.bind f = none 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β)
Goal: none.bind f = none
-- Option.some_bind
@[simp] theorem some_bind (a) (f : α → Option β) : (some a).bind f = f a 
Arguments: {α : Type u_1} {β : Type u_2} (a : α) (f : α → Option β)
Goal: (some a).bind f = f a
-- Option.all_none
@[simp] theorem all_none : Option.all p none = true 
Goal: ∀ {α : Type u_1} {p : α → Bool}, Option.all p none = true
-- Option.all_some
@[simp] theorem all_some : Option.all p (some x) = p x 
Goal: ∀ {α : Type u_1} {p : α → Bool} {x : α}, Option.all p (some x) = p x
-- Option.min_some_some
@[simp] theorem min_some_some [Min α] {a b : α} : min (some a) (some b) = some (min a b) 
Arguments: {α : Type u_1} [Min α] {a b : α}
Goal: min (some a) (some b) = some (min a b)
-- Option.min_some_none
@[simp] theorem min_some_none [Min α] {a : α} : min (some a) none = some a 
Arguments: {α : Type u_1} [Min α] {a : α}
Goal: min (some a) none = some a
-- Option.min_none_some
@[simp] theorem min_none_some [Min α] {b : α} : min none (some b) = some b 
Arguments: {α : Type u_1} [Min α] {b : α}
Goal: min none (some b) = some b
-- Option.min_none_none
@[simp] theorem min_none_none [Min α] : min (none : Option α) none = none 
Arguments: {α : Type u_1} [Min α]
Goal: min none none = none
-- Option.max_some_some
@[simp] theorem max_some_some [Max α] {a b : α} : max (some a) (some b) = some (max a b) 
Arguments: {α : Type u_1} [Max α] {a b : α}
Goal: max (some a) (some b) = some (max a b)
-- Option.max_some_none
@[simp] theorem max_some_none [Max α] {a : α} : max (some a) none = some a 
Arguments: {α : Type u_1} [Max α] {a : α}
Goal: max (some a) none = some a
-- Option.max_none_some
@[simp] theorem max_none_some [Max α] {b : α} : max none (some b) = some b 
Arguments: {α : Type u_1} [Max α] {b : α}
Goal: max none (some b) = some b
-- Option.max_none_none
@[simp] theorem max_none_none [Max α] : max (none : Option α) none = none 
Arguments: {α : Type u_1} [Max α]
Goal: max none none = none
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Fin.Iterate.0.Fin.hIterateFrom_elim
private theorem hIterateFrom_elim {P : Nat → Sort _}(Q : ∀(i : Nat), P i → Prop)
    {n  : Nat}
    (f : ∀(i : Fin n), P i.val → P (i.val+1))
    {i : Nat} (ubnd : i ≤ n)
    (s : P i)
    (init : Q i s)
    (step : ∀(k : Fin n) (s : P k.val), Q k.val s → Q (k.val+1) (f k s)) :
    Q n (hIterateFrom P f i ubnd s) 
Arguments: {P : Nat → Sort u_1} (Q : (i : Nat) → P i → Prop) {n : Nat} (f : (i : Fin n) → P ↑i → P (↑i + 1)) {i : Nat} (ubnd : i ≤ n) (s : P i) (init : Q i s) (step : ∀ (k : Fin n) (s : P ↑k), Q (↑k) s → Q (↑k + 1) (f k s))
Goal: Q n (Fin.hIterateFrom P f i ubnd s)
-- Fin.hIterate_elim
theorem hIterate_elim {P : Nat → Sort _} (Q : ∀(i : Nat), P i → Prop)
    {n : Nat} (f : ∀(i : Fin n), P i.val → P (i.val+1)) (s : P 0) (init : Q 0 s)
    (step : ∀(k : Fin n) (s : P k.val), Q k.val s → Q (k.val+1) (f k s)) :
    Q n (hIterate P s f) 
Arguments: {P : Nat → Sort u_1} (Q : (i : Nat) → P i → Prop) {n : Nat} (f : (i : Fin n) → P ↑i → P (↑i + 1)) (s : P 0) (init : Q 0 s) (step : ∀ (k : Fin n) (s : P ↑k), Q (↑k) s → Q (↑k + 1) (f k s))
Goal: Q n (Fin.hIterate P s f)
-- Fin.hIterate_eq
theorem hIterate_eq {P : Nat → Sort _} (state : ∀(i : Nat), P i)
    {n : Nat} (f : ∀(i : Fin n), P i.val → P (i.val+1)) (s : P 0)
    (init : s = state 0)
    (step : ∀(i : Fin n), f i (state i) = state (i+1)) :
    hIterate P s f = state n 
Arguments: {P : Nat → Sort u_1} (state : (i : Nat) → P i) {n : Nat} (f : (i : Fin n) → P ↑i → P (↑i + 1)) (s : P 0) (init : s = state 0) (step : ∀ (i : Fin n), f i (state ↑i) = state (↑i + 1))
Goal: Fin.hIterate P s f = state n
-- Int.nonneg_def
theorem nonneg_def {a : Int} : NonNeg a ↔ ∃ n : Nat, a = n 
Arguments: {a : Int}
Goal: a.NonNeg ↔ ∃ n, a = ↑n
-- Int.NonNeg.elim
theorem NonNeg.elim {a : Int} : NonNeg a → ∃ n : Nat, a = n 
Arguments: {a : Int}
Goal: a.NonNeg → ∃ n, a = ↑n
-- Int.nonneg_or_nonneg_neg
theorem nonneg_or_nonneg_neg : ∀ (a : Int), NonNeg a ∨ NonNeg (-a)
  
Arguments: (a : Int)
Goal: a.NonNeg ∨ (-a).NonNeg
-- Int.le_def
theorem le_def (a b : Int) : a ≤ b ↔ NonNeg (b - a) 
Arguments: (a b : Int)
Goal: a ≤ b ↔ (b - a).NonNeg
-- Int.lt_iff_add_one_le
theorem lt_iff_add_one_le (a b : Int) : a < b ↔ a + 1 ≤ b 
Arguments: (a b : Int)
Goal: a < b ↔ a + 1 ≤ b
-- Int.le.intro_sub
theorem le.intro_sub {a b : Int} (n : Nat) (h : b - a = n) : a ≤ b 
Arguments: {a b : Int} (n : Nat) (h : b - a = ↑n)
Goal: a ≤ b
-- Int.le.intro
theorem le.intro {a b : Int} (n : Nat) (h : a + n = b) : a ≤ b 
Arguments: {a b : Int} (n : Nat) (h : a + ↑n = b)
Goal: a ≤ b
-- Int.le.dest_sub
theorem le.dest_sub {a b : Int} (h : a ≤ b) : ∃ n : Nat, b - a = n 
Arguments: {a b : Int} (h : a ≤ b)
Goal: ∃ n, b - a = ↑n
-- Int.le.dest
theorem le.dest {a b : Int} (h : a ≤ b) : ∃ n : Nat, a + n = b 
Arguments: {a b : Int} (h : a ≤ b)
Goal: ∃ n, a + ↑n = b
-- Int.le_total
protected theorem le_total (a b : Int) : a ≤ b ∨ b ≤ a 
Arguments: (a b : Int)
Goal: a ≤ b ∨ b ≤ a
-- Int.ofNat_le
@[simp, norm_cast] theorem ofNat_le {m n : Nat} : (↑m : Int) ≤ ↑n ↔ m ≤ n 
Arguments: {m n : Nat}
Goal: ↑m ≤ ↑n ↔ m ≤ n
-- Int.ofNat_zero_le
theorem ofNat_zero_le (n : Nat) : 0 ≤ (↑n : Int) 
Arguments: (n : Nat)
Goal: 0 ≤ ↑n
-- Int.eq_ofNat_of_zero_le
theorem eq_ofNat_of_zero_le {a : Int} (h : 0 ≤ a) : ∃ n : Nat, a = n 
Arguments: {a : Int} (h : 0 ≤ a)
Goal: ∃ n, a = ↑n
-- Int.eq_succ_of_zero_lt
theorem eq_succ_of_zero_lt {a : Int} (h : 0 < a) : ∃ n : Nat, a = n.succ 
Arguments: {a : Int} (h : 0 < a)
Goal: ∃ n, a = ↑n.succ
-- Int.lt_add_succ
theorem lt_add_succ (a : Int) (n : Nat) : a < a + Nat.succ n 
Arguments: (a : Int) (n : Nat)
Goal: a < a + ↑n.succ
-- Int.lt.intro
theorem lt.intro {a b : Int} {n : Nat} (h : a + Nat.succ n = b) : a < b 
Arguments: {a b : Int} {n : Nat} (h : a + ↑n.succ = b)
Goal: a < b
-- Int.lt.dest
theorem lt.dest {a b : Int} (h : a < b) : ∃ n : Nat, a + Nat.succ n = b 
Arguments: {a b : Int} (h : a < b)
Goal: ∃ n, a + ↑n.succ = b
-- Int.ofNat_lt
@[simp, norm_cast] theorem ofNat_lt {n m : Nat} : (↑n : Int) < ↑m ↔ n < m 
Arguments: {n m : Nat}
Goal: ↑n < ↑m ↔ n < m
-- Int.ofNat_pos
@[simp, norm_cast] theorem ofNat_pos {n : Nat} : 0 < (↑n : Int) ↔ 0 < n 
Arguments: {n : Nat}
Goal: 0 < ↑n ↔ 0 < n
-- Int.ofNat_nonneg
theorem ofNat_nonneg (n : Nat) : 0 ≤ (n : Int) 
Arguments: (n : Nat)
Goal: 0 ≤ ↑n
-- Int.ofNat_succ_pos
theorem ofNat_succ_pos (n : Nat) : 0 < (succ n : Int) 
Arguments: (n : Nat)
Goal: 0 < ↑n.succ
-- Int.le_refl
@[simp] protected theorem le_refl (a : Int) : a ≤ a 
Arguments: (a : Int)
Goal: a ≤ a
-- Int.le_trans
protected theorem le_trans {a b c : Int} (h₁ : a ≤ b) (h₂ : b ≤ c) : a ≤ c 
Arguments: {a b c : Int} (h₁ : a ≤ b) (h₂ : b ≤ c)
Goal: a ≤ c
-- Int.le_antisymm
protected theorem le_antisymm {a b : Int} (h₁ : a ≤ b) (h₂ : b ≤ a) : a = b 
Arguments: {a b : Int} (h₁ : a ≤ b) (h₂ : b ≤ a)
Goal: a = b
-- Int.lt_irrefl
@[simp] protected theorem lt_irrefl (a : Int) : ¬a < a 
Arguments: (a : Int)
Goal: ¬a < a
-- Int.ne_of_lt
protected theorem ne_of_lt {a b : Int} (h : a < b) : a ≠ b 
Arguments: {a b : Int} (h : a < b)
Goal: a ≠ b
-- Int.ne_of_gt
protected theorem ne_of_gt {a b : Int} (h : b < a) : a ≠ b 
Arguments: {a b : Int} (h : b < a)
Goal: a ≠ b
-- Int.le_of_lt
protected theorem le_of_lt {a b : Int} (h : a < b) : a ≤ b 
Arguments: {a b : Int} (h : a < b)
Goal: a ≤ b
-- Int.lt_iff_le_and_ne
protected theorem lt_iff_le_and_ne {a b : Int} : a < b ↔ a ≤ b ∧ a ≠ b 
Arguments: {a b : Int}
Goal: a < b ↔ a ≤ b ∧ a ≠ b
-- Int.lt_succ
theorem lt_succ (a : Int) : a < a + 1 
Arguments: (a : Int)
Goal: a < a + 1
-- Int.zero_lt_one
protected theorem zero_lt_one : (0 : Int) < 1 
Goal: 0 < 1
-- Int.lt_iff_le_not_le
protected theorem lt_iff_le_not_le {a b : Int} : a < b ↔ a ≤ b ∧ ¬b ≤ a 
Arguments: {a b : Int}
Goal: a < b ↔ a ≤ b ∧ ¬b ≤ a
-- Int.lt_of_not_ge
protected theorem lt_of_not_ge {a b : Int} (h : ¬a ≤ b) : b < a 
Arguments: {a b : Int} (h : ¬a ≤ b)
Goal: b < a
-- Int.not_le_of_gt
protected theorem not_le_of_gt {a b : Int} (h : b < a) : ¬a ≤ b 
Arguments: {a b : Int} (h : b < a)
Goal: ¬a ≤ b
-- Int.not_le
protected theorem not_le {a b : Int} : ¬a ≤ b ↔ b < a 
Arguments: {a b : Int}
Goal: ¬a ≤ b ↔ b < a
-- Int.not_lt
protected theorem not_lt {a b : Int} : ¬a < b ↔ b ≤ a 
Arguments: {a b : Int}
Goal: ¬a < b ↔ b ≤ a
-- Int.lt_trichotomy
protected theorem lt_trichotomy (a b : Int) : a < b ∨ a = b ∨ b < a 
Arguments: (a b : Int)
Goal: a < b ∨ a = b ∨ b < a
-- Int.ne_iff_lt_or_gt
protected theorem ne_iff_lt_or_gt {a b : Int} : a ≠ b ↔ a < b ∨ b < a 
Arguments: {a b : Int}
Goal: a ≠ b ↔ a < b ∨ b < a
-- Int.lt_or_gt_of_ne
protected theorem lt_or_gt_of_ne {a b : Int} : a ≠ b →  a < b ∨ b < a
Arguments: {a b : Int}
Goal: a ≠ b → a < b ∨ b < a
-- Int.eq_iff_le_and_ge
protected theorem eq_iff_le_and_ge {x y : Int} : x = y ↔ x ≤ y ∧ y ≤ x 
Arguments: {x y : Int}
Goal: x = y ↔ x ≤ y ∧ y ≤ x
-- Int.lt_of_le_of_lt
protected theorem lt_of_le_of_lt {a b c : Int} (h₁ : a ≤ b) (h₂ : b < c) : a < c 
Arguments: {a b c : Int} (h₁ : a ≤ b) (h₂ : b < c)
Goal: a < c
-- Int.lt_of_lt_of_le
protected theorem lt_of_lt_of_le {a b c : Int} (h₁ : a < b) (h₂ : b ≤ c) : a < c 
Arguments: {a b c : Int} (h₁ : a < b) (h₂ : b ≤ c)
Goal: a < c
-- Int.lt_trans
protected theorem lt_trans {a b c : Int} (h₁ : a < b) (h₂ : b < c) : a < c 
Arguments: {a b c : Int} (h₁ : a < b) (h₂ : b < c)
Goal: a < c
-- Int.min_def
protected theorem min_def (n m : Int) : min n m = if n ≤ m then n else m 
Arguments: (n m : Int)
Goal: min n m = if n ≤ m then n else m
-- Int.max_def
protected theorem max_def (n m : Int) : max n m = if n ≤ m then m else n 
Arguments: (n m : Int)
Goal: max n m = if n ≤ m then m else n
-- Int.min_comm
protected theorem min_comm (a b : Int) : min a b = min b a 
Arguments: (a b : Int)
Goal: min a b = min b a
-- Int.min_le_right
protected theorem min_le_right (a b : Int) : min a b ≤ b 
Arguments: (a b : Int)
Goal: min a b ≤ b
-- Int.min_le_left
protected theorem min_le_left (a b : Int) : min a b ≤ a 
Arguments: (a b : Int)
Goal: min a b ≤ a
-- Int.min_eq_left
protected theorem min_eq_left {a b : Int} (h : a ≤ b) : min a b = a 
Arguments: {a b : Int} (h : a ≤ b)
Goal: min a b = a
-- Int.min_eq_right
protected theorem min_eq_right {a b : Int} (h : b ≤ a) : min a b = b 
Arguments: {a b : Int} (h : b ≤ a)
Goal: min a b = b
-- Int.le_min
protected theorem le_min {a b c : Int} : a ≤ min b c ↔ a ≤ b ∧ a ≤ c 
Arguments: {a b c : Int}
Goal: a ≤ min b c ↔ a ≤ b ∧ a ≤ c
-- Int.max_comm
protected theorem max_comm (a b : Int) : max a b = max b a 
Arguments: (a b : Int)
Goal: max a b = max b a
-- Int.le_max_left
protected theorem le_max_left (a b : Int) : a ≤ max a b 
Arguments: (a b : Int)
Goal: a ≤ max a b
-- Int.le_max_right
protected theorem le_max_right (a b : Int) : b ≤ max a b 
Arguments: (a b : Int)
Goal: b ≤ max a b
-- Int.max_le
protected theorem max_le {a b c : Int} : max a b ≤ c ↔ a ≤ c ∧ b ≤ c 
Arguments: {a b c : Int}
Goal: max a b ≤ c ↔ a ≤ c ∧ b ≤ c
-- Int.max_eq_right
protected theorem max_eq_right {a b : Int} (h : a ≤ b) : max a b = b 
Arguments: {a b : Int} (h : a ≤ b)
Goal: max a b = b
-- Int.max_eq_left
protected theorem max_eq_left {a b : Int} (h : b ≤ a) : max a b = a 
Arguments: {a b : Int} (h : b ≤ a)
Goal: max a b = a
-- Int.eq_natAbs_of_zero_le
theorem eq_natAbs_of_zero_le {a : Int} (h : 0 ≤ a) : a = natAbs a 
Arguments: {a : Int} (h : 0 ≤ a)
Goal: a = ↑a.natAbs
-- Int.le_natAbs
theorem le_natAbs {a : Int} : a ≤ natAbs a 
Arguments: {a : Int}
Goal: a ≤ ↑a.natAbs
-- Int.negSucc_lt_zero
theorem negSucc_lt_zero (n : Nat) : -[n+1] < 0 
Arguments: (n : Nat)
Goal: Int.negSucc n < 0
-- Int.negSucc_not_nonneg
@[simp] theorem negSucc_not_nonneg (n : Nat) : 0 ≤ -[n+1] ↔ False 
Arguments: (n : Nat)
Goal: 0 ≤ Int.negSucc n ↔ False
-- Int.add_le_add_left
protected theorem add_le_add_left {a b : Int} (h : a ≤ b) (c : Int) : c + a ≤ c + b 
Arguments: {a b : Int} (h : a ≤ b) (c : Int)
Goal: c + a ≤ c + b
-- Int.add_lt_add_left
protected theorem add_lt_add_left {a b : Int} (h : a < b) (c : Int) : c + a < c + b 
Arguments: {a b : Int} (h : a < b) (c : Int)
Goal: c + a < c + b
-- Int.add_le_add_right
protected theorem add_le_add_right {a b : Int} (h : a ≤ b) (c : Int) : a + c ≤ b + c 
Arguments: {a b : Int} (h : a ≤ b) (c : Int)
Goal: a + c ≤ b + c
-- Int.add_lt_add_right
protected theorem add_lt_add_right {a b : Int} (h : a < b) (c : Int) : a + c < b + c 
Arguments: {a b : Int} (h : a < b) (c : Int)
Goal: a + c < b + c
-- Int.le_of_add_le_add_left
protected theorem le_of_add_le_add_left {a b c : Int} (h : a + b ≤ a + c) : b ≤ c 
Arguments: {a b c : Int} (h : a + b ≤ a + c)
Goal: b ≤ c
-- Int.le_of_add_le_add_right
protected theorem le_of_add_le_add_right {a b c : Int} (h : a + b ≤ c + b) : a ≤ c 
Arguments: {a b c : Int} (h : a + b ≤ c + b)
Goal: a ≤ c
-- Int.add_le_add_iff_left
protected theorem add_le_add_iff_left (a : Int) : a + b ≤ a + c ↔ b ≤ c 
Arguments: {b c : Int} (a : Int)
Goal: a + b ≤ a + c ↔ b ≤ c
-- Int.add_le_add_iff_right
protected theorem add_le_add_iff_right (c : Int) : a + c ≤ b + c ↔ a ≤ b 
Arguments: {a b : Int} (c : Int)
Goal: a + c ≤ b + c ↔ a ≤ b
-- Int.add_le_add
protected theorem add_le_add {a b c d : Int} (h₁ : a ≤ b) (h₂ : c ≤ d) : a + c ≤ b + d 
Arguments: {a b c d : Int} (h₁ : a ≤ b) (h₂ : c ≤ d)
Goal: a + c ≤ b + d
-- Int.le_add_of_nonneg_right
protected theorem le_add_of_nonneg_right {a b : Int} (h : 0 ≤ b) : a ≤ a + b 
Arguments: {a b : Int} (h : 0 ≤ b)
Goal: a ≤ a + b
-- Int.le_add_of_nonneg_left
protected theorem le_add_of_nonneg_left {a b : Int} (h : 0 ≤ b) : a ≤ b + a 
Arguments: {a b : Int} (h : 0 ≤ b)
Goal: a ≤ b + a
-- Int.neg_le_neg
protected theorem neg_le_neg {a b : Int} (h : a ≤ b) : -b ≤ -a 
Arguments: {a b : Int} (h : a ≤ b)
Goal: -b ≤ -a
-- Int.le_of_neg_le_neg
protected theorem le_of_neg_le_neg {a b : Int} (h : -b ≤ -a) : a ≤ b 
Arguments: {a b : Int} (h : -b ≤ -a)
Goal: a ≤ b
-- Int.neg_nonpos_of_nonneg
protected theorem neg_nonpos_of_nonneg {a : Int} (h : 0 ≤ a) : -a ≤ 0 
Arguments: {a : Int} (h : 0 ≤ a)
Goal: -a ≤ 0