File: .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean

full_name: _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Basic.0.Nat.recCompiled
code: /-- Compiled version of `Nat.rec` so that we can define `Nat.recAux` to be defeq to `Nat.rec`.
This is working around the fact that the compiler does not currently support recursors. -/
private def recCompiled {motive : Nat → Sort u} (zero : motive zero) (succ : (n : Nat) → motive n → motive (Nat.succ n)) : (t : Nat) → motive t
  
goal: motive t

full_name: _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Basic.0.Nat.rec_eq_recCompiled
code: @[csimp]
private theorem rec_eq_recCompiled : @Nat.rec = @Nat.recCompiled 
goal: @Nat.rec = @Nat.recCompiled

full_name: Nat.recAux
code: /-- Recursor identical to `Nat.rec` but uses notations `0` for `Nat.zero` and `· + 1` for `Nat.succ`.
Used as the default `Nat` eliminator by the `induction` tactic. -/
@[elab_as_elim, induction_eliminator]
protected abbrev recAux {motive : Nat → Sort u} (zero : motive 0) (succ : (n : Nat) → motive n → motive (n + 1)) (t : Nat) : motive t 
goal: motive t

full_name: Nat.casesAuxOn
code: /-- Recursor identical to `Nat.casesOn` but uses notations `0` for `Nat.zero` and `· + 1` for `Nat.succ`.
Used as the default `Nat` eliminator by the `cases` tactic. -/
@[elab_as_elim, cases_eliminator]
protected abbrev casesAuxOn {motive : Nat → Sort u} (t : Nat) (zero : motive 0) (succ : (n : Nat) → motive (n + 1)) : motive t 
goal: motive t

full_name: Nat.fold
code: /--
`Nat.fold` evaluates `f` on the numbers up to `n` exclusive, in increasing order:
* `Nat.fold f 3 init = init |> f 0 |> f 1 |> f 2`
-/
@[specialize] def fold {α : Type u} (f : Nat → α → α) : (n : Nat) → (init : α) → α
  
goal: α

full_name: Nat.foldTR.loop
code: /-- Tail-recursive version of `Nat.fold`. -/
@[inline] def foldTR {α : Type u} (f : Nat → α → α) (n : Nat) (init : α) : α 
goal: Nat → α → α

full_name: Nat.foldTR
code: /-- Tail-recursive version of `Nat.fold`. -/
@[inline] def foldTR {α : Type u} (f : Nat → α → α) (n : Nat) (init : α) : α 
goal: α

full_name: Nat.foldRev
code: /--
`Nat.foldRev` evaluates `f` on the numbers up to `n` exclusive, in decreasing order:
* `Nat.foldRev f 3 init = f 0 <| f 1 <| f 2 <| init`
-/
@[specialize] def foldRev {α : Type u} (f : Nat → α → α) : (n : Nat) → (init : α) → α
  
goal: α

full_name: Nat.any
code: /-- `any f n = true` iff there is `i in [0, n-1]` s.t. `f i = true` -/
@[specialize] def any (f : Nat → Bool) : Nat → Bool
  
goal: Nat → Bool

full_name: Nat.anyTR.loop
code: /-- Tail-recursive version of `Nat.any`. -/
@[inline] def anyTR (f : Nat → Bool) (n : Nat) : Bool 
goal: Nat → Bool

full_name: Nat.anyTR
code: /-- Tail-recursive version of `Nat.any`. -/
@[inline] def anyTR (f : Nat → Bool) (n : Nat) : Bool 
goal: Bool

full_name: Nat.all
code: /-- `all f n = true` iff every `i in [0, n-1]` satisfies `f i = true` -/
@[specialize] def all (f : Nat → Bool) : Nat → Bool
  
goal: Nat → Bool

full_name: Nat.allTR.loop
code: /-- Tail-recursive version of `Nat.all`. -/
@[inline] def allTR (f : Nat → Bool) (n : Nat) : Bool 
goal: Nat → Bool

full_name: Nat.allTR
code: /-- Tail-recursive version of `Nat.all`. -/
@[inline] def allTR (f : Nat → Bool) (n : Nat) : Bool 
goal: Bool

full_name: Nat.repeat
code: /--
`Nat.repeat f n a` is `f^(n) a`; that is, it iterates `f` `n` times on `a`.
* `Nat.repeat f 3 a = f <| f <| f <| a`
-/
@[specialize] def repeat {α : Type u} (f : α → α) : (n : Nat) → (a : α) → α
  
goal: α

full_name: Nat.repeatTR.loop
code: /-- Tail-recursive version of `Nat.repeat`. -/
@[inline] def repeatTR {α : Type u} (f : α → α) (n : Nat) (a : α) : α 
goal: Nat → α → α

full_name: Nat.repeatTR
code: /-- Tail-recursive version of `Nat.repeat`. -/
@[inline] def repeatTR {α : Type u} (f : α → α) (n : Nat) (a : α) : α 
goal: α

full_name: Nat.blt
code: /-- Boolean less-than of natural numbers. -/
def blt (a b : Nat) : Bool 
goal: Bool

full_name: Nat.zero_eq
code: @[simp] theorem zero_eq : Nat.zero = 0 
goal: Nat.zero = 0

full_name: Nat.add_eq
code: @[simp] theorem add_eq : Nat.add x y = x + y 
goal: x.add y = x + y

full_name: Nat.mul_eq
code: @[simp] theorem mul_eq : Nat.mul x y = x * y 
goal: x.mul y = x * y

full_name: Nat.sub_eq
code: @[simp] theorem sub_eq : Nat.sub x y = x - y 
goal: x.sub y = x - y

full_name: Nat.lt_eq
code: @[simp] theorem lt_eq : Nat.lt x y = (x < y) 
goal: x.lt y = (x < y)

full_name: Nat.le_eq
code: @[simp] theorem le_eq : Nat.le x y = (x ≤ y) 
goal: x.le y = (x ≤ y)

full_name: Nat.beq_refl
code: @[simp] theorem beq_refl (a : Nat) : Nat.beq a a = true 
goal: a.beq a = true

full_name: Nat.beq_eq
code: @[simp] theorem beq_eq : (Nat.beq x y = true) = (x = y) 
goal: (x.beq y = true) = (x = y)

full_name: Nat.ble_eq
code: @[simp] theorem ble_eq : (Nat.ble x y = true) = (x ≤ y) 
goal: (x.ble y = true) = (x ≤ y)

full_name: Nat.blt_eq
code: @[simp] theorem blt_eq : (Nat.blt x y = true) = (x < y) 
goal: (x.blt y = true) = (x < y)

full_name: Nat.«instLawfulBEq_.lake»
code: instance : LawfulBEq Nat 
goal: LawfulBEq Nat

full_name: Nat.beq_eq_true_eq
code: @[simp] theorem beq_eq_true_eq (a b : Nat) : ((a == b) = true) = (a = b) 
goal: ((a == b) = true) = (a = b)

full_name: Nat.not_beq_eq_true_eq
code: @[simp] theorem not_beq_eq_true_eq (a b : Nat) : ((!(a == b)) = true) = ¬(a = b) 
goal: ((!a == b) = true) = ¬a = b

full_name: Nat.zero_add
code: @[simp] protected theorem zero_add : ∀ (n : Nat), 0 + n = n
  
goal: 0 + n = n

full_name: Nat.«instLawfulIdentityHAddOfNat_.lake»
code: instance : Std.LawfulIdentity (α := Nat) (· + ·) 0 
goal: Std.LawfulIdentity (fun x x_1 => x + x_1) 0

full_name: Nat.succ_add
code: theorem succ_add : ∀ (n m : Nat), (succ n) + m = succ (n + m)
  
goal: n.succ + m = (n + m).succ

full_name: Nat.add_succ
code: theorem add_succ (n m : Nat) : n + succ m = succ (n + m) 
goal: n + m.succ = (n + m).succ

full_name: Nat.add_one
code: theorem add_one (n : Nat) : n + 1 = succ n 
goal: n + 1 = n.succ

full_name: Nat.succ_eq_add_one
code: @[simp] theorem succ_eq_add_one (n : Nat) : succ n = n + 1 
goal: n.succ = n + 1

full_name: Nat.add_one_ne_zero
code: @[simp] theorem add_one_ne_zero (n : Nat) : n + 1 ≠ 0 
goal: n + 1 ≠ 0

full_name: Nat.zero_ne_add_one
code: @[simp] theorem zero_ne_add_one (n : Nat) : 0 ≠ n + 1 
goal: 0 ≠ n + 1

full_name: Nat.add_comm
code: protected theorem add_comm : ∀ (n m : Nat), n + m = m + n
  
goal: n + m = m + n

full_name: Nat.«instCommutativeHAdd_.lake»
code: instance : Std.Commutative (α := Nat) (· + ·) 
goal: Std.Commutative fun x x_1 => x + x_1

full_name: Nat.add_assoc
code: protected theorem add_assoc : ∀ (n m k : Nat), (n + m) + k = n + (m + k)
  
goal: n + m + k = n + (m + k)

full_name: Nat.«instAssociativeHAdd_.lake»
code: instance : Std.Associative (α := Nat) (· + ·) 
goal: Std.Associative fun x x_1 => x + x_1

full_name: Nat.add_left_comm
code: protected theorem add_left_comm (n m k : Nat) : n + (m + k) = m + (n + k) 
goal: n + (m + k) = m + (n + k)

full_name: Nat.add_right_comm
code: protected theorem add_right_comm (n m k : Nat) : (n + m) + k = (n + k) + m 
goal: n + m + k = n + k + m

full_name: Nat.add_left_cancel
code: protected theorem add_left_cancel {n m k : Nat} : n + m = n + k → m = k 
goal: n + m = n + k → m = k

full_name: Nat.add_right_cancel
code: protected theorem add_right_cancel {n m k : Nat} (h : n + m = k + m) : n = k 
goal: n = k

full_name: Nat.eq_zero_of_add_eq_zero
code: theorem eq_zero_of_add_eq_zero : ∀ {n m}, n + m = 0 → n = 0 ∧ m = 0
  
goal: n + m = 0 → n = 0 ∧ m = 0

full_name: Nat.eq_zero_of_add_eq_zero_left
code: protected theorem eq_zero_of_add_eq_zero_left (h : n + m = 0) : m = 0 
goal: m = 0

full_name: Nat.mul_zero
code: @[simp] protected theorem mul_zero (n : Nat) : n * 0 = 0 
goal: n * 0 = 0

full_name: Nat.mul_succ
code: theorem mul_succ (n m : Nat) : n * succ m = n * m + n 
goal: n * m.succ = n * m + n

full_name: Nat.mul_add_one
code: theorem mul_add_one (n m : Nat) : n * (m + 1) = n * m + n 
goal: n * (m + 1) = n * m + n

full_name: Nat.zero_mul
code: @[simp] protected theorem zero_mul : ∀ (n : Nat), 0 * n = 0
  
goal: 0 * n = 0

full_name: Nat.succ_mul
code: theorem succ_mul (n m : Nat) : (succ n) * m = (n * m) + m 
goal: n.succ * m = n * m + m

full_name: Nat.add_one_mul
code: theorem add_one_mul (n m : Nat) : (n + 1) * m = (n * m) + m 
goal: (n + 1) * m = n * m + m

full_name: Nat.mul_comm
code: protected theorem mul_comm : ∀ (n m : Nat), n * m = m * n
  
goal: n * m = m * n

full_name: Nat.«instCommutativeHMul_.lake»
code: instance : Std.Commutative (α := Nat) (· * ·) 
goal: Std.Commutative fun x x_1 => x * x_1

full_name: Nat.mul_one
code: @[simp] protected theorem mul_one : ∀ (n : Nat), n * 1 = n 
goal: n * 1 = n

full_name: Nat.one_mul
code: @[simp] protected theorem one_mul (n : Nat) : 1 * n = n 
goal: 1 * n = n

full_name: Nat.«instLawfulIdentityHMulOfNat_.lake»
code: instance : Std.LawfulIdentity (α := Nat) (· * ·) 1 
goal: Std.LawfulIdentity (fun x x_1 => x * x_1) 1

full_name: Nat.left_distrib
code: protected theorem left_distrib (n m k : Nat) : n * (m + k) = n * m + n * k 
goal: n * (m + k) = n * m + n * k

full_name: Nat.right_distrib
code: protected theorem right_distrib (n m k : Nat) : (n + m) * k = n * k + m * k 
goal: (n + m) * k = n * k + m * k

full_name: Nat.mul_add
code: protected theorem mul_add (n m k : Nat) : n * (m + k) = n * m + n * k 
goal: n * (m + k) = n * m + n * k

full_name: Nat.add_mul
code: protected theorem add_mul (n m k : Nat) : (n + m) * k = n * k + m * k 
goal: (n + m) * k = n * k + m * k

full_name: Nat.mul_assoc
code: protected theorem mul_assoc : ∀ (n m k : Nat), (n * m) * k = n * (m * k)
  
goal: n * m * k = n * (m * k)

full_name: Nat.«instAssociativeHMul_.lake»
code: instance : Std.Associative (α := Nat) (· * ·) 
goal: Std.Associative fun x x_1 => x * x_1

full_name: Nat.mul_left_comm
code: protected theorem mul_left_comm (n m k : Nat) : n * (m * k) = m * (n * k) 
goal: n * (m * k) = m * (n * k)

full_name: Nat.mul_two
code: protected theorem mul_two (n) : n * 2 = n + n 
goal: n * 2 = n + n

full_name: Nat.two_mul
code: protected theorem two_mul (n) : 2 * n = n + n 
goal: 2 * n = n + n

full_name: Nat.succ_lt_succ
code: theorem succ_lt_succ {n m : Nat} : n < m → succ n < succ m 
goal: n < m → n.succ < m.succ

full_name: Nat.lt_succ_of_le
code: theorem lt_succ_of_le {n m : Nat} : n ≤ m → n < succ m 
goal: n ≤ m → n < m.succ

full_name: Nat.le_of_lt_add_one
code: theorem le_of_lt_add_one {n m : Nat} : n < m + 1 → n ≤ m 
goal: n < m + 1 → n ≤ m

full_name: Nat.lt_add_one_of_le
code: theorem lt_add_one_of_le {n m : Nat} : n ≤ m → n < m + 1 
goal: n ≤ m → n < m + 1

full_name: Nat.sub_zero
code: @[simp] protected theorem sub_zero (n : Nat) : n - 0 = n 
goal: n - 0 = n

full_name: Nat.not_add_one_le_zero
code: theorem not_add_one_le_zero (n : Nat) : ¬ n + 1 ≤ 0 
goal: ¬n + 1 ≤ 0

full_name: Nat.not_add_one_le_self
code: theorem not_add_one_le_self : (n : Nat) → ¬ n + 1 ≤ n 
goal: ¬n + 1 ≤ n

full_name: Nat.add_one_pos
code: theorem add_one_pos (n : Nat) : 0 < n + 1 
goal: 0 < n + 1

full_name: Nat.succ_sub_succ_eq_sub
code: theorem succ_sub_succ_eq_sub (n m : Nat) : succ n - succ m = n - m 
goal: n.succ - m.succ = n - m

full_name: Nat.pred_le
code: theorem pred_le : ∀ (n : Nat), pred n ≤ n
  
goal: n.pred ≤ n

full_name: Nat.pred_lt
code: theorem pred_lt : ∀ {n : Nat}, n ≠ 0 → pred n < n
  
goal: n ≠ 0 → n.pred < n

full_name: Nat.sub_one_lt
code: theorem sub_one_lt : ∀ {n : Nat}, n ≠ 0 → n - 1 < n 
goal: n ≠ 0 → n - 1 < n

full_name: Nat.sub_le
code: @[simp] theorem sub_le (n m : Nat) : n - m ≤ n 
goal: n - m ≤ n

full_name: Nat.sub_lt
code: theorem sub_lt : ∀ {n m : Nat}, 0 < n → 0 < m → n - m < n
  
goal: 0 < n → 0 < m → n - m < n

full_name: Nat.sub_succ
code: theorem sub_succ (n m : Nat) : n - succ m = pred (n - m) 
goal: n - m.succ = (n - m).pred

full_name: Nat.succ_sub_succ
code: theorem succ_sub_succ (n m : Nat) : succ n - succ m = n - m 
goal: n.succ - m.succ = n - m

full_name: Nat.sub_self
code: @[simp] protected theorem sub_self : ∀ (n : Nat), n - n = 0
  
goal: n - n = 0

full_name: Nat.sub_add_eq
code: theorem sub_add_eq (a b c : Nat) : a - (b + c) = a - b - c 
goal: a - (b + c) = a - b - c

full_name: Nat.lt_of_lt_of_le
code: protected theorem lt_of_lt_of_le {n m k : Nat} : n < m → m ≤ k → n < k 
goal: n < m → m ≤ k → n < k

full_name: Nat.lt_of_lt_of_eq
code: protected theorem lt_of_lt_of_eq {n m k : Nat} : n < m → m = k → n < k 
goal: n < m → m = k → n < k

full_name: Nat.«instTransLt_.lake»
code: instance : Trans (. < . : Nat → Nat → Prop) (. < . : Nat → Nat → Prop) (. < . : Nat → Nat → Prop) 
goal: Trans (fun x x_1 => x < x_1) (fun x x_1 => x < x_1) fun x x_1 => x < x_1

full_name: Nat.«instTransLe_.lake»
code: instance : Trans (. ≤ . : Nat → Nat → Prop) (. ≤ . : Nat → Nat → Prop) (. ≤ . : Nat → Nat → Prop) 
goal: Trans (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≤ x_1) fun x x_1 => x ≤ x_1

full_name: Nat.«instTransLtLe_.lake»
code: instance : Trans (. < . : Nat → Nat → Prop) (. ≤ . : Nat → Nat → Prop) (. < . : Nat → Nat → Prop) 
goal: Trans (fun x x_1 => x < x_1) (fun x x_1 => x ≤ x_1) fun x x_1 => x < x_1

full_name: Nat.«instTransLeLt_.lake»
code: instance : Trans (. ≤ . : Nat → Nat → Prop) (. < . : Nat → Nat → Prop) (. < . : Nat → Nat → Prop) 
goal: Trans (fun x x_1 => x ≤ x_1) (fun x x_1 => x < x_1) fun x x_1 => x < x_1

full_name: Nat.le_of_eq
code: protected theorem le_of_eq {n m : Nat} (p : n = m) : n ≤ m 
goal: n ≤ m

full_name: Nat.lt.step
code: theorem lt.step {n m : Nat} : n < m → n < succ m 
goal: n < m → n < m.succ

full_name: Nat.le_of_succ_le
code: theorem le_of_succ_le {n m : Nat} (h : succ n ≤ m) : n ≤ m 
goal: n ≤ m

full_name: Nat.lt_of_succ_lt
code: theorem lt_of_succ_lt      {n m : Nat} : succ n < m → n < m 
goal: n.succ < m → n < m

full_name: Nat.le_of_lt
code: protected theorem le_of_lt {n m : Nat} : n < m → n ≤ m 
goal: n < m → n ≤ m

full_name: Nat.lt_of_succ_lt_succ
code: theorem lt_of_succ_lt_succ {n m : Nat} : succ n < succ m → n < m 
goal: n.succ < m.succ → n < m

full_name: Nat.lt_of_succ_le
code: theorem lt_of_succ_le {n m : Nat} (h : succ n ≤ m) : n < m 
goal: n < m

full_name: Nat.succ_le_of_lt
code: theorem succ_le_of_lt {n m : Nat} (h : n < m) : succ n ≤ m 
goal: n.succ ≤ m

full_name: Nat.eq_zero_or_pos
code: theorem eq_zero_or_pos : ∀ (n : Nat), n = 0 ∨ n > 0
  
goal: n = 0 ∨ n > 0

full_name: Nat.pos_of_ne_zero
code: protected theorem pos_of_ne_zero {n : Nat} : n ≠ 0 → 0 < n 
goal: n ≠ 0 → 0 < n

full_name: Nat.lt.base
code: theorem lt.base (n : Nat) : n < succ n 
goal: n < n.succ

full_name: Nat.lt_succ_self
code: @[simp] theorem lt_succ_self (n : Nat) : n < succ n 
goal: n < n.succ

full_name: Nat.lt_add_one
code: @[simp] protected theorem lt_add_one (n : Nat) : n < n + 1 
goal: n < n + 1

full_name: Nat.le_total
code: protected theorem le_total (m n : Nat) : m ≤ n ∨ n ≤ m 
goal: m ≤ n ∨ n ≤ m

full_name: Nat.eq_zero_of_le_zero
code: theorem eq_zero_of_le_zero {n : Nat} (h : n ≤ 0) : n = 0 
goal: n = 0

full_name: Nat.zero_lt_of_lt
code: theorem zero_lt_of_lt : {a b : Nat} → a < b → 0 < b
  
goal: a < b → 0 < b

full_name: Nat.zero_lt_of_ne_zero
code: theorem zero_lt_of_ne_zero {a : Nat} (h : a ≠ 0) : 0 < a 
goal: 0 < a

full_name: Nat.ne_of_lt
code: theorem ne_of_lt {a b : Nat} (h : a < b) : a ≠ b 
goal: a ≠ b

full_name: Nat.le_or_eq_of_le_succ
code: theorem le_or_eq_of_le_succ {m n : Nat} (h : m ≤ succ n) : m ≤ n ∨ m = succ n 
goal: m ≤ n ∨ m = n.succ

full_name: Nat.le_or_eq_of_le_add_one
code: theorem le_or_eq_of_le_add_one {m n : Nat} (h : m ≤ n + 1) : m ≤ n ∨ m = n + 1 
goal: m ≤ n ∨ m = n + 1

full_name: Nat.le_add_right
code: theorem le_add_right : ∀ (n k : Nat), n ≤ n + k
  
goal: n ≤ n + k

full_name: Nat.le_add_left
code: theorem le_add_left (n m : Nat): n ≤ m + n 
goal: n ≤ m + n

full_name: Nat.le_of_add_right_le
code: theorem le_of_add_right_le {n m k : Nat} (h : n + k ≤ m) : n ≤ m 
goal: n ≤ m

full_name: Nat.le_add_right_of_le
code: theorem le_add_right_of_le {n m k : Nat} (h : n ≤ m) : n ≤ m + k 
goal: n ≤ m + k

full_name: Nat.lt_of_add_one_le
code: theorem lt_of_add_one_le {n m : Nat} (h : n + 1 ≤ m) : n < m 
goal: n < m

full_name: Nat.add_one_le_of_lt
code: theorem add_one_le_of_lt {n m : Nat} (h : n < m) : n + 1 ≤ m 
goal: n + 1 ≤ m

full_name: Nat.lt_add_left
code: protected theorem lt_add_left (c : Nat) (h : a < b) : a < c + b 
goal: a < c + b

full_name: Nat.lt_add_right
code: protected theorem lt_add_right (c : Nat) (h : a < b) : a < b + c 
goal: a < b + c

full_name: Nat.lt_of_add_right_lt
code: theorem lt_of_add_right_lt {n m k : Nat} (h : n + k < m) : n < m 
goal: n < m

full_name: Nat.le.dest
code: theorem le.dest : ∀ {n m : Nat}, n ≤ m → Exists (fun k => n + k = m)
  
goal: n ≤ m → Exists fun k => n + k = m

full_name: Nat.le.intro
code: theorem le.intro {n m k : Nat} (h : n + k = m) : n ≤ m 
goal: n ≤ m

full_name: Nat.not_le_of_gt
code: protected theorem not_le_of_gt {n m : Nat} (h : n > m) : ¬ n ≤ m 
goal: ¬n ≤ m

full_name: Nat.not_le_of_lt
code: protected theorem not_le_of_lt : ∀{a b : Nat}, a < b → ¬(b ≤ a) 
goal: a < b → ¬b ≤ a

full_name: Nat.not_lt_of_ge
code: protected theorem not_lt_of_ge : ∀{a b : Nat}, b ≥ a → ¬(b < a) 
goal: b ≥ a → ¬b < a

full_name: Nat.not_lt_of_le
code: protected theorem not_lt_of_le : ∀{a b : Nat}, a ≤ b → ¬(b < a) 
goal: a ≤ b → ¬b < a

full_name: Nat.lt_le_asymm
code: protected theorem lt_le_asymm : ∀{a b : Nat}, a < b → ¬(b ≤ a) 
goal: a < b → ¬b ≤ a

full_name: Nat.le_lt_asymm
code: protected theorem le_lt_asymm : ∀{a b : Nat}, a ≤ b → ¬(b < a) 
goal: a ≤ b → ¬b < a

full_name: Nat.gt_of_not_le
code: theorem gt_of_not_le {n m : Nat} (h : ¬ n ≤ m) : n > m 
goal: n > m

full_name: Nat.lt_of_not_ge
code: protected theorem lt_of_not_ge : ∀{a b : Nat}, ¬(b ≥ a) → b < a 
goal: ¬b ≥ a → b < a

full_name: Nat.lt_of_not_le
code: protected theorem lt_of_not_le : ∀{a b : Nat}, ¬(a ≤ b) → b < a 
goal: ¬a ≤ b → b < a

full_name: Nat.ge_of_not_lt
code: theorem ge_of_not_lt {n m : Nat} (h : ¬ n < m) : n ≥ m 
goal: n ≥ m

full_name: Nat.le_of_not_gt
code: protected theorem le_of_not_gt : ∀{a b : Nat}, ¬(b > a) → b ≤ a 
goal: ¬b > a → b ≤ a

full_name: Nat.le_of_not_lt
code: protected theorem le_of_not_lt : ∀{a b : Nat}, ¬(a < b) → b ≤ a 
goal: ¬a < b → b ≤ a

full_name: Nat.ne_of_gt
code: theorem ne_of_gt {a b : Nat} (h : b < a) : a ≠ b 
goal: a ≠ b

full_name: Nat.ne_of_lt'
code: protected theorem ne_of_lt' : ∀{a b : Nat}, a < b → b ≠ a 
goal: a < b → b ≠ a

full_name: Nat.not_le
code: @[simp] protected theorem not_le {a b : Nat} : ¬ a ≤ b ↔ b < a 
goal: ¬a ≤ b ↔ b < a

full_name: Nat.not_lt
code: @[simp] protected theorem not_lt {a b : Nat} : ¬ a < b ↔ b ≤ a 
goal: ¬a < b ↔ b ≤ a

full_name: Nat.le_of_not_le
code: protected theorem le_of_not_le {a b : Nat} (h : ¬ b ≤ a) : a ≤ b 
goal: a ≤ b

full_name: Nat.le_of_not_ge
code: protected theorem le_of_not_ge : ∀{a b : Nat}, ¬(a ≥ b) → a ≤ b
goal: ¬a ≥ b → a ≤ b

full_name: Nat.lt_trichotomy
code: protected theorem lt_trichotomy (a b : Nat) : a < b ∨ a = b ∨ b < a 
goal: a < b ∨ a = b ∨ b < a

full_name: Nat.lt_or_gt_of_ne
code: protected theorem lt_or_gt_of_ne {a b : Nat} (ne : a ≠ b) : a < b ∨ a > b 
goal: a < b ∨ a > b

full_name: Nat.lt_or_lt_of_ne
code: protected theorem lt_or_lt_of_ne : ∀{a b : Nat}, a ≠ b → a < b ∨ b < a 
goal: a ≠ b → a < b ∨ b < a

full_name: Nat.le_antisymm_iff
code: protected theorem le_antisymm_iff {a b : Nat} : a = b ↔ a ≤ b ∧ b ≤ a 
goal: a = b ↔ a ≤ b ∧ b ≤ a

full_name: Nat.eq_iff_le_and_ge
code: protected theorem eq_iff_le_and_ge : ∀{a b : Nat}, a = b ↔ a ≤ b ∧ b ≤ a 
goal: a = b ↔ a ≤ b ∧ b ≤ a

full_name: Nat.«instAntisymmLe_.lake»
code: instance : Antisymm ( . ≤ . : Nat → Nat → Prop) 
goal: Antisymm fun x x_1 => x ≤ x_1

full_name: Nat.«instAntisymmNotLt_.lake»
code: instance : Antisymm (¬ . < . : Nat → Nat → Prop) 
goal: Antisymm fun x x_1 => ¬x < x_1

full_name: Nat.add_le_add_left
code: protected theorem add_le_add_left {n m : Nat} (h : n ≤ m) (k : Nat) : k + n ≤ k + m 
goal: k + n ≤ k + m

full_name: Nat.add_le_add_right
code: protected theorem add_le_add_right {n m : Nat} (h : n ≤ m) (k : Nat) : n + k ≤ m + k 
goal: n + k ≤ m + k

full_name: Nat.add_lt_add_left
code: protected theorem add_lt_add_left {n m : Nat} (h : n < m) (k : Nat) : k + n < k + m 
goal: k + n < k + m

full_name: Nat.add_lt_add_right
code: protected theorem add_lt_add_right {n m : Nat} (h : n < m) (k : Nat) : n + k < m + k 
goal: n + k < m + k

full_name: Nat.lt_add_of_pos_right
code: protected theorem lt_add_of_pos_right (h : 0 < k) : n < n + k 
goal: n < n + k

full_name: Nat.zero_lt_one
code: protected theorem zero_lt_one : 0 < (1:Nat) 
goal: 0 < 1

full_name: Nat.pos_iff_ne_zero
code: protected theorem pos_iff_ne_zero : 0 < n ↔ n ≠ 0 
goal: 0 < n ↔ n ≠ 0

full_name: Nat.add_le_add
code: theorem add_le_add {a b c d : Nat} (h₁ : a ≤ b) (h₂ : c ≤ d) : a + c ≤ b + d 
goal: a + c ≤ b + d

full_name: Nat.add_lt_add
code: theorem add_lt_add {a b c d : Nat} (h₁ : a < b) (h₂ : c < d) : a + c < b + d 
goal: a + c < b + d

full_name: Nat.le_of_add_le_add_left
code: protected theorem le_of_add_le_add_left {a b c : Nat} (h : a + b ≤ a + c) : b ≤ c 
goal: b ≤ c

full_name: Nat.le_of_add_le_add_right
code: protected theorem le_of_add_le_add_right {a b c : Nat} : a + b ≤ c + b → a ≤ c 
goal: a + b ≤ c + b → a ≤ c

full_name: Nat.add_le_add_iff_right
code: protected theorem add_le_add_iff_right {n : Nat} : m + n ≤ k + n ↔ m ≤ k 
goal: m + n ≤ k + n ↔ m ≤ k

full_name: Nat.lt_asymm
code: protected theorem lt_asymm {a b : Nat} (h : a < b) : ¬ b < a 
goal: ¬b < a

full_name: Nat.not_lt_of_gt
code: /-- Alias for `Nat.lt_asymm`. -/
protected abbrev not_lt_of_gt 
goal: ¬b < a

full_name: Nat.not_lt_of_lt
code: /-- Alias for `Nat.lt_asymm`. -/
protected abbrev not_lt_of_lt 
goal: ¬b < a

full_name: Nat.lt_iff_le_not_le
code: protected theorem lt_iff_le_not_le {m n : Nat} : m < n ↔ m ≤ n ∧ ¬ n ≤ m 
goal: m < n ↔ m ≤ n ∧ ¬n ≤ m

full_name: Nat.lt_iff_le_and_not_ge
code: /-- Alias for `Nat.lt_iff_le_not_le`. -/
protected abbrev lt_iff_le_and_not_ge 
goal: m < n ↔ m ≤ n ∧ ¬n ≤ m

full_name: Nat.lt_iff_le_and_ne
code: protected theorem lt_iff_le_and_ne {m n : Nat} : m < n ↔ m ≤ n ∧ m ≠ n 
goal: m < n ↔ m ≤ n ∧ m ≠ n

full_name: Nat.ne_iff_lt_or_gt
code: protected theorem ne_iff_lt_or_gt {a b : Nat} : a ≠ b ↔ a < b ∨ b < a 
goal: a ≠ b ↔ a < b ∨ b < a

full_name: Nat.lt_or_gt
code: /-- Alias for `Nat.ne_iff_lt_or_gt`. -/
protected abbrev lt_or_gt 
goal: a ≠ b ↔ a < b ∨ b < a

full_name: Nat.le_or_ge
code: /-- Alias for `Nat.le_total`. -/
protected abbrev le_or_ge 
goal: m ≤ n ∨ n ≤ m

full_name: Nat.le_or_le
code: /-- Alias for `Nat.le_total`. -/
protected abbrev le_or_le 
goal: m ≤ n ∨ n ≤ m

full_name: Nat.eq_or_lt_of_not_lt
code: protected theorem eq_or_lt_of_not_lt {a b : Nat} (hnlt : ¬ a < b) : a = b ∨ b < a 
goal: a = b ∨ b < a

full_name: Nat.lt_or_eq_of_le
code: protected theorem lt_or_eq_of_le {n m : Nat} (h : n ≤ m) : n < m ∨ n = m 
goal: n < m ∨ n = m

full_name: Nat.le_iff_lt_or_eq
code: protected theorem le_iff_lt_or_eq {n m : Nat} : n ≤ m ↔ n < m ∨ n = m 
goal: n ≤ m ↔ n < m ∨ n = m

full_name: Nat.lt_succ_iff
code: protected theorem lt_succ_iff : m < succ n ↔ m ≤ n 
goal: m < n.succ ↔ m ≤ n

full_name: Nat.lt_add_one_iff
code: protected theorem lt_add_one_iff : m < n + 1 ↔ m ≤ n 
goal: m < n + 1 ↔ m ≤ n

full_name: Nat.lt_succ_iff_lt_or_eq
code: protected theorem lt_succ_iff_lt_or_eq : m < succ n ↔ m < n ∨ m = n 
goal: m < n.succ ↔ m < n ∨ m = n

full_name: Nat.lt_add_one_iff_lt_or_eq
code: protected theorem lt_add_one_iff_lt_or_eq : m < n + 1 ↔ m < n ∨ m = n 
goal: m < n + 1 ↔ m < n ∨ m = n

full_name: Nat.eq_of_lt_succ_of_not_lt
code: protected theorem eq_of_lt_succ_of_not_lt (hmn : m < n + 1) (h : ¬ m < n) : m = n 
goal: m = n

full_name: Nat.eq_of_le_of_lt_succ
code: protected theorem eq_of_le_of_lt_succ (h₁ : n ≤ m) (h₂ : m < n + 1) : m = n 
goal: m = n

full_name: Nat.le_zero
code: theorem le_zero : i ≤ 0 ↔ i = 0 
goal: i ≤ 0 ↔ i = 0

full_name: Nat.one_pos
code: /-- Alias for `Nat.zero_lt_one`. -/
protected abbrev one_pos 
goal: 0 < 1

full_name: Nat.two_pos
code: protected theorem two_pos : 0 < 2 
goal: 0 < 2

full_name: Nat.ne_zero_iff_zero_lt
code: protected theorem ne_zero_iff_zero_lt : n ≠ 0 ↔ 0 < n 
goal: n ≠ 0 ↔ 0 < n

full_name: Nat.zero_lt_two
code: protected theorem zero_lt_two : 0 < 2 
goal: 0 < 2

full_name: Nat.one_lt_two
code: protected theorem one_lt_two : 1 < 2 
goal: 1 < 2

full_name: Nat.eq_zero_of_not_pos
code: protected theorem eq_zero_of_not_pos (h : ¬0 < n) : n = 0 
goal: n = 0

full_name: Nat.succ_ne_self
code: theorem succ_ne_self (n) : succ n ≠ n 
goal: n.succ ≠ n

full_name: Nat.add_one_ne_self
code: theorem add_one_ne_self (n) : n + 1 ≠ n 
goal: n + 1 ≠ n

full_name: Nat.succ_le
code: theorem succ_le : succ n ≤ m ↔ n < m 
goal: n.succ ≤ m ↔ n < m

full_name: Nat.add_one_le_iff
code: theorem add_one_le_iff : n + 1 ≤ m ↔ n < m 
goal: n + 1 ≤ m ↔ n < m

full_name: Nat.lt_succ
code: theorem lt_succ : m < succ n ↔ m ≤ n 
goal: m < n.succ ↔ m ≤ n

full_name: Nat.lt_succ_of_lt
code: theorem lt_succ_of_lt (h : a < b) : a < succ b 
goal: a < b.succ

full_name: Nat.lt_add_one_of_lt
code: theorem lt_add_one_of_lt (h : a < b) : a < b + 1 
goal: a < b + 1

full_name: Nat.succ_pred_eq_of_ne_zero
code: theorem succ_pred_eq_of_ne_zero : ∀ {n}, n ≠ 0 → succ (pred n) = n
  
goal: n ≠ 0 → n.pred.succ = n

full_name: Nat.eq_zero_or_eq_succ_pred
code: theorem eq_zero_or_eq_succ_pred : ∀ n, n = 0 ∨ n = succ (pred n)
  
goal: n = 0 ∨ n = n.pred.succ

full_name: Nat.succ_inj'
code: theorem succ_inj' : succ a = succ b ↔ a = b 
goal: a.succ = b.succ ↔ a = b

full_name: Nat.succ_le_succ_iff
code: theorem succ_le_succ_iff : succ a ≤ succ b ↔ a ≤ b 
goal: a.succ ≤ b.succ ↔ a ≤ b

full_name: Nat.succ_lt_succ_iff
code: theorem succ_lt_succ_iff : succ a < succ b ↔ a < b 
goal: a.succ < b.succ ↔ a < b

full_name: Nat.add_one_inj
code: theorem add_one_inj : a + 1 = b + 1 ↔ a = b 
goal: a + 1 = b + 1 ↔ a = b

full_name: Nat.add_one_le_add_one_iff
code: theorem add_one_le_add_one_iff : a + 1 ≤ b + 1 ↔ a ≤ b 
goal: a + 1 ≤ b + 1 ↔ a ≤ b

full_name: Nat.add_one_lt_add_one_iff
code: theorem add_one_lt_add_one_iff : a + 1 < b + 1 ↔ a < b 
goal: a + 1 < b + 1 ↔ a < b

full_name: Nat.pred_inj
code: theorem pred_inj : ∀ {a b}, 0 < a → 0 < b → pred a = pred b → a = b
  
goal: 0 < a → 0 < b → a.pred = b.pred → a = b

full_name: Nat.pred_ne_self
code: theorem pred_ne_self : ∀ {a}, a ≠ 0 → pred a ≠ a
  
goal: a ≠ 0 → a.pred ≠ a

full_name: Nat.sub_one_ne_self
code: theorem sub_one_ne_self : ∀ {a}, a ≠ 0 → a - 1 ≠ a
  
goal: a ≠ 0 → a - 1 ≠ a

full_name: Nat.pred_lt_self
code: theorem pred_lt_self : ∀ {a}, 0 < a → pred a < a
  
goal: 0 < a → a.pred < a

full_name: Nat.pred_lt_pred
code: theorem pred_lt_pred : ∀ {n m}, n ≠ 0 → n < m → pred n < pred m
  
goal: n ≠ 0 → n < m → n.pred < m.pred

full_name: Nat.pred_le_iff_le_succ
code: theorem pred_le_iff_le_succ : ∀ {n m}, pred n ≤ m ↔ n ≤ succ m
  
goal: n.pred ≤ m ↔ n ≤ m.succ

full_name: Nat.le_succ_of_pred_le
code: theorem le_succ_of_pred_le : pred n ≤ m → n ≤ succ m 
goal: n.pred ≤ m → n ≤ m.succ

full_name: Nat.pred_le_of_le_succ
code: theorem pred_le_of_le_succ : n ≤ succ m → pred n ≤ m 
goal: n ≤ m.succ → n.pred ≤ m

full_name: Nat.lt_pred_iff_succ_lt
code: theorem lt_pred_iff_succ_lt : ∀ {n m}, n < pred m ↔ succ n < m
  
goal: n < m.pred ↔ n.succ < m

full_name: Nat.succ_lt_of_lt_pred
code: theorem succ_lt_of_lt_pred : n < pred m → succ n < m 
goal: n < m.pred → n.succ < m

full_name: Nat.lt_pred_of_succ_lt
code: theorem lt_pred_of_succ_lt : succ n < m → n < pred m 
goal: n.succ < m → n < m.pred

full_name: Nat.le_pred_iff_lt
code: theorem le_pred_iff_lt : ∀ {n m}, 0 < m → (n ≤ pred m ↔ n < m)
  
goal: 0 < m → (n ≤ m.pred ↔ n < m)

full_name: Nat.le_pred_of_lt
code: theorem le_pred_of_lt (h : n < m) : n ≤ pred m 
goal: n ≤ m.pred

full_name: Nat.le_sub_one_of_lt
code: theorem le_sub_one_of_lt : a < b → a ≤ b - 1 
goal: a < b → a ≤ b - 1

full_name: Nat.lt_of_le_pred
code: theorem lt_of_le_pred (h : 0 < m) : n ≤ pred m → n < m 
goal: n ≤ m.pred → n < m

full_name: Nat.lt_of_le_sub_one
code: theorem lt_of_le_sub_one (h : 0 < m) : n ≤ m - 1 → n < m 
goal: n ≤ m - 1 → n < m

full_name: Nat.le_sub_one_iff_lt
code: protected theorem le_sub_one_iff_lt (h : 0 < m) : n ≤ m - 1 ↔ n < m 
goal: n ≤ m - 1 ↔ n < m

full_name: Nat.exists_eq_succ_of_ne_zero
code: theorem exists_eq_succ_of_ne_zero : ∀ {n}, n ≠ 0 → Exists fun k => n = succ k
  
goal: n ≠ 0 → Exists fun k => n = k.succ

full_name: Nat.exists_eq_add_one_of_ne_zero
code: theorem exists_eq_add_one_of_ne_zero : ∀ {n}, n ≠ 0 → Exists fun k => n = k + 1
  
goal: n ≠ 0 → Exists fun k => n = k + 1

full_name: Nat.ctor_eq_zero
code: theorem ctor_eq_zero : Nat.zero = 0 
goal: Nat.zero = 0

full_name: Nat.one_ne_zero
code: protected theorem one_ne_zero : 1 ≠ (0 : Nat) 
goal: 1 ≠ 0

full_name: Nat.zero_ne_one
code: protected theorem zero_ne_one : 0 ≠ (1 : Nat) 
goal: 0 ≠ 1

full_name: Nat.succ_ne_zero
code: @[simp] theorem succ_ne_zero (n : Nat) : succ n ≠ 0 
goal: n.succ ≠ 0

full_name: Nat.mul_le_mul_left
code: theorem mul_le_mul_left {n m : Nat} (k : Nat) (h : n ≤ m) : k * n ≤ k * m 
goal: k * n ≤ k * m

full_name: Nat.mul_le_mul_right
code: theorem mul_le_mul_right {n m : Nat} (k : Nat) (h : n ≤ m) : n * k ≤ m * k 
goal: n * k ≤ m * k

full_name: Nat.mul_le_mul
code: protected theorem mul_le_mul {n₁ m₁ n₂ m₂ : Nat} (h₁ : n₁ ≤ n₂) (h₂ : m₁ ≤ m₂) : n₁ * m₁ ≤ n₂ * m₂ 
goal: n₁ * m₁ ≤ n₂ * m₂

full_name: Nat.mul_lt_mul_of_pos_left
code: protected theorem mul_lt_mul_of_pos_left {n m k : Nat} (h : n < m) (hk : k > 0) : k * n < k * m 
goal: k * n < k * m

full_name: Nat.mul_lt_mul_of_pos_right
code: protected theorem mul_lt_mul_of_pos_right {n m k : Nat} (h : n < m) (hk : k > 0) : n * k < m * k 
goal: n * k < m * k

full_name: Nat.mul_pos
code: protected theorem mul_pos {n m : Nat} (ha : n > 0) (hb : m > 0) : n * m > 0 
goal: n * m > 0

full_name: Nat.le_of_mul_le_mul_left
code: protected theorem le_of_mul_le_mul_left {a b c : Nat} (h : c * a ≤ c * b) (hc : 0 < c) : a ≤ b 
goal: a ≤ b

full_name: Nat.eq_of_mul_eq_mul_left
code: protected theorem eq_of_mul_eq_mul_left {m k n : Nat} (hn : 0 < n) (h : n * m = n * k) : m = k 
goal: m = k

full_name: Nat.eq_of_mul_eq_mul_right
code: theorem eq_of_mul_eq_mul_right {n m k : Nat} (hm : 0 < m) (h : n * m = k * m) : n = k 
goal: n = k

full_name: Nat.pow_succ
code: protected theorem pow_succ (n m : Nat) : n^(succ m) = n^m * n 
goal: n ^ m.succ = n ^ m * n

full_name: Nat.pow_add_one
code: protected theorem pow_add_one (n m : Nat) : n^(m + 1) = n^m * n 
goal: n ^ (m + 1) = n ^ m * n

full_name: Nat.pow_zero
code: protected theorem pow_zero (n : Nat) : n^0 = 1 
goal: n ^ 0 = 1

full_name: Nat.pow_le_pow_of_le_left
code: theorem pow_le_pow_of_le_left {n m : Nat} (h : n ≤ m) : ∀ (i : Nat), n^i ≤ m^i
  
goal: n ^ i ≤ m ^ i

full_name: Nat.pow_le_pow_of_le_right
code: theorem pow_le_pow_of_le_right {n : Nat} (hx : n > 0) {i : Nat} : ∀ {j}, i ≤ j → n^i ≤ n^j
  
goal: i ≤ j → n ^ i ≤ n ^ j

full_name: Nat.pos_pow_of_pos
code: theorem pos_pow_of_pos {n : Nat} (m : Nat) (h : 0 < n) : 0 < n^m 
goal: 0 < n ^ m

full_name: Nat.min
code: /--
`Nat.min a b` is the minimum of `a` and `b`:
* if `a ≤ b` then `Nat.min a b = a`
* if `b ≤ a` then `Nat.min a b = b`
-/
protected abbrev min (n m : Nat) 
goal: Nat

full_name: Nat.min_def
code: protected theorem min_def {n m : Nat} : min n m = if n ≤ m then n else m 
goal: min n m = ite (n ≤ m) n m

full_name: Nat.«instMax_.lake»
code: instance : Max Nat 
goal: Max Nat

full_name: Nat.max
code: /--
`Nat.max a b` is the maximum of `a` and `b`:
* if `a ≤ b` then `Nat.max a b = b`
* if `b ≤ a` then `Nat.max a b = a`
-/
protected abbrev max (n m : Nat) 
goal: Nat

full_name: Nat.max_def
code: protected theorem max_def {n m : Nat} : max n m = if n ≤ m then m else n 
goal: max n m = ite (n ≤ m) m n

full_name: Nat.not_eq_zero_of_lt
code: theorem not_eq_zero_of_lt (h : b < a) : a ≠ 0 
goal: a ≠ 0

full_name: Nat.pred_lt_of_lt
code: theorem pred_lt_of_lt {n m : Nat} (h : m < n) : pred n < n 
goal: n.pred < n

full_name: Nat.pred_lt'
code: @[deprecated (since := "2024-06-01")] abbrev pred_lt' 
goal: n.pred < n

full_name: Nat.sub_one_lt_of_lt
code: theorem sub_one_lt_of_lt {n m : Nat} (h : m < n) : n - 1 < n 
goal: n - 1 < n

full_name: Nat.pred_zero
code: @[simp] protected theorem pred_zero : pred 0 = 0 
goal: Nat.pred 0 = 0

full_name: Nat.pred_succ
code: @[simp] protected theorem pred_succ (n : Nat) : pred n.succ = n 
goal: n.succ.pred = n

full_name: Nat.succ_pred
code: theorem succ_pred {a : Nat} (h : a ≠ 0) : a.pred.succ = a 
goal: a.pred.succ = a

full_name: Nat.sub_one_add_one
code: theorem sub_one_add_one {a : Nat} (h : a ≠ 0) : a - 1 + 1 = a 
goal: a - 1 + 1 = a

full_name: Nat.succ_pred_eq_of_pos
code: theorem succ_pred_eq_of_pos : ∀ {n}, 0 < n → succ (pred n) = n
  
goal: 0 < n → n.pred.succ = n

full_name: Nat.sub_one_add_one_eq_of_pos
code: theorem sub_one_add_one_eq_of_pos : ∀ {n}, 0 < n → (n - 1) + 1 = n
  
goal: 0 < n → n - 1 + 1 = n

full_name: Nat.eq_zero_or_eq_sub_one_add_one
code: theorem eq_zero_or_eq_sub_one_add_one : ∀ {n}, n = 0 ∨ n = n - 1 + 1
  
goal: n = 0 ∨ n = n - 1 + 1

full_name: Nat.pred_eq_sub_one
code: @[simp] theorem pred_eq_sub_one : pred n = n - 1 
goal: n.pred = n - 1

full_name: Nat.add_sub_self_left
code: theorem add_sub_self_left (a b : Nat) : (a + b) - a = b 
goal: a + b - a = b

full_name: Nat.add_sub_self_right
code: theorem add_sub_self_right (a b : Nat) : (a + b) - b = a 
goal: a + b - b = a

full_name: Nat.sub_le_succ_sub
code: theorem sub_le_succ_sub (a i : Nat) : a - i ≤ a.succ - i 
goal: a - i ≤ a.succ - i

full_name: Nat.zero_lt_sub_of_lt
code: theorem zero_lt_sub_of_lt (h : i < a) : 0 < a - i 
goal: 0 < a - i

full_name: Nat.sub_succ_lt_self
code: theorem sub_succ_lt_self (a i : Nat) (h : i < a) : a - (i + 1) < a - i 
goal: a - (i + 1) < a - i

full_name: Nat.sub_ne_zero_of_lt
code: theorem sub_ne_zero_of_lt : {a b : Nat} → a < b → b - a ≠ 0
  
goal: a < b → b - a ≠ 0

full_name: Nat.add_sub_of_le
code: theorem add_sub_of_le {a b : Nat} (h : a ≤ b) : a + (b - a) = b 
goal: a + (b - a) = b

full_name: Nat.sub_one_cancel
code: theorem sub_one_cancel : ∀ {a b : Nat}, 0 < a → 0 < b → a - 1 = b - 1 → a = b
  
goal: 0 < a → 0 < b → a - 1 = b - 1 → a = b

full_name: Nat.sub_add_cancel
code: @[simp] protected theorem sub_add_cancel {n m : Nat} (h : m ≤ n) : n - m + m = n 
goal: n - m + m = n

full_name: Nat.add_sub_add_right
code: protected theorem add_sub_add_right (n k m : Nat) : (n + k) - (m + k) = n - m 
goal: n + k - (m + k) = n - m

full_name: Nat.add_sub_add_left
code: protected theorem add_sub_add_left (k n m : Nat) : (k + n) - (k + m) = n - m 
goal: k + n - (k + m) = n - m

full_name: Nat.add_sub_cancel
code: @[simp] protected theorem add_sub_cancel (n m : Nat) : n + m - m = n 
goal: n + m - m = n

full_name: Nat.add_sub_cancel_left
code: protected theorem add_sub_cancel_left (n m : Nat) : n + m - n = m 
goal: n + m - n = m

full_name: Nat.add_sub_assoc
code: protected theorem add_sub_assoc {m k : Nat} (h : k ≤ m) (n : Nat) : n + m - k = n + (m - k) 
goal: n + m - k = n + (m - k)

full_name: Nat.eq_add_of_sub_eq
code: protected theorem eq_add_of_sub_eq {a b c : Nat} (hle : b ≤ a) (h : a - b = c) : a = c + b 
goal: a = c + b

full_name: Nat.sub_eq_of_eq_add
code: protected theorem sub_eq_of_eq_add {a b c : Nat} (h : a = c + b) : a - b = c 
goal: a - b = c

full_name: Nat.le_add_of_sub_le
code: theorem le_add_of_sub_le {a b c : Nat} (h : a - b ≤ c) : a ≤ c + b 
goal: a ≤ c + b

full_name: Nat.sub_lt_sub_left
code: protected theorem sub_lt_sub_left : ∀ {k m n : Nat}, k < m → k < n → m - n < m - k
  
goal: k < m → k < n → m - n < m - k

full_name: Nat.zero_sub
code: @[simp] protected theorem zero_sub (n : Nat) : 0 - n = 0 
goal: 0 - n = 0

full_name: Nat.sub_lt_sub_right
code: protected theorem sub_lt_sub_right : ∀ {a b c : Nat}, c ≤ a → a < b → a - c < b - c
  
goal: c ≤ a → a < b → a - c < b - c

full_name: Nat.sub_self_add
code: protected theorem sub_self_add (n m : Nat) : n - (n + m) = 0 
goal: n - (n + m) = 0

full_name: Nat.sub_eq_zero_of_le
code: protected theorem sub_eq_zero_of_le {n m : Nat} (h : n ≤ m) : n - m = 0 
goal: n - m = 0

full_name: Nat.sub_le_of_le_add
code: theorem sub_le_of_le_add {a b c : Nat} (h : a ≤ c + b) : a - b ≤ c 
goal: a - b ≤ c

full_name: Nat.add_le_of_le_sub
code: theorem add_le_of_le_sub {a b c : Nat} (hle : b ≤ c) (h : a ≤ c - b) : a + b ≤ c 
goal: a + b ≤ c

full_name: Nat.le_sub_of_add_le
code: theorem le_sub_of_add_le {a b c : Nat} (h : a + b ≤ c) : a ≤ c - b 
goal: a ≤ c - b

full_name: Nat.add_lt_of_lt_sub
code: theorem add_lt_of_lt_sub {a b c : Nat} (h : a < c - b) : a + b < c 
goal: a + b < c

full_name: Nat.lt_sub_of_add_lt
code: theorem lt_sub_of_add_lt {a b c : Nat} (h : a + b < c) : a < c - b 
goal: a < c - b

full_name: Nat.sub.elim
code: theorem sub.elim {motive : Nat → Prop}
    (x y : Nat)
    (h₁ : y ≤ x → (k : Nat) → x = y + k → motive k)
    (h₂ : x < y → motive 0)
    : motive (x - y) 
goal: motive (x - y)

full_name: Nat.succ_sub
code: theorem succ_sub {m n : Nat} (h : n ≤ m) : succ m - n = succ (m - n) 
goal: m.succ - n = (m - n).succ

full_name: Nat.sub_pos_of_lt
code: protected theorem sub_pos_of_lt (h : m < n) : 0 < n - m 
goal: 0 < n - m

full_name: Nat.sub_sub
code: protected theorem sub_sub (n m k : Nat) : n - m - k = n - (m + k) 
goal: n - m - k = n - (m + k)

full_name: Nat.sub_le_sub_left
code: protected theorem sub_le_sub_left (h : n ≤ m) (k : Nat) : k - m ≤ k - n 
goal: k - m ≤ k - n

full_name: Nat.sub_le_sub_right
code: protected theorem sub_le_sub_right {n m : Nat} (h : n ≤ m) : ∀ k, n - k ≤ m - k
  
goal: n - k ≤ m - k

full_name: Nat.sub_le_add_right_sub
code: protected theorem sub_le_add_right_sub (a i j : Nat) : a - i ≤ a + j - i 
goal: a - i ≤ a + j - i

full_name: Nat.lt_of_sub_ne_zero
code: protected theorem lt_of_sub_ne_zero (h : n - m ≠ 0) : m < n 
goal: m < n

full_name: Nat.sub_ne_zero_iff_lt
code: protected theorem sub_ne_zero_iff_lt : n - m ≠ 0 ↔ m < n 
goal: n - m ≠ 0 ↔ m < n

full_name: Nat.lt_of_sub_pos
code: protected theorem lt_of_sub_pos (h : 0 < n - m) : m < n 
goal: m < n

full_name: Nat.lt_of_sub_eq_succ
code: protected theorem lt_of_sub_eq_succ (h : m - n = succ l) : n < m 
goal: n < m

full_name: Nat.lt_of_sub_eq_sub_one
code: protected theorem lt_of_sub_eq_sub_one (h : m - n = l + 1) : n < m 
goal: n < m

full_name: Nat.sub_lt_left_of_lt_add
code: protected theorem sub_lt_left_of_lt_add {n k m : Nat} (H : n ≤ k) (h : k < n + m) : k - n < m 
goal: k - n < m

full_name: Nat.sub_lt_right_of_lt_add
code: protected theorem sub_lt_right_of_lt_add {n k m : Nat} (H : n ≤ k) (h : k < m + n) : k - n < m 
goal: k - n < m

full_name: Nat.le_of_sub_eq_zero
code: protected theorem le_of_sub_eq_zero : ∀ {n m}, n - m = 0 → n ≤ m
  
goal: n - m = 0 → n ≤ m

full_name: Nat.le_of_sub_le_sub_right
code: protected theorem le_of_sub_le_sub_right : ∀ {n m k : Nat}, k ≤ m → n - k ≤ m - k → n ≤ m
  
goal: k ≤ m → n - k ≤ m - k → n ≤ m

full_name: Nat.sub_le_sub_iff_right
code: protected theorem sub_le_sub_iff_right {n : Nat} (h : k ≤ m) : n - k ≤ m - k ↔ n ≤ m 
goal: n - k ≤ m - k ↔ n ≤ m

full_name: Nat.sub_eq_iff_eq_add
code: protected theorem sub_eq_iff_eq_add {c : Nat} (h : b ≤ a) : a - b = c ↔ a = c + b 
goal: a - b = c ↔ a = c + b

full_name: Nat.sub_eq_iff_eq_add'
code: protected theorem sub_eq_iff_eq_add' {c : Nat} (h : b ≤ a) : a - b = c ↔ a = b + c 
goal: a - b = c ↔ a = b + c

full_name: Nat.pred_mul
code: theorem pred_mul (n m : Nat) : pred n * m = n * m - m 
goal: n.pred * m = n * m - m

full_name: Nat.mul_pred_left
code: @[deprecated (since := "2024-06-01")] abbrev mul_pred_left 
goal: n.pred * m = n * m - m

full_name: Nat.sub_one_mul
code: protected theorem sub_one_mul  (n m : Nat) : (n - 1) * m = n * m - m 
goal: (n - 1) * m = n * m - m

full_name: Nat.mul_pred
code: theorem mul_pred (n m : Nat) : n * pred m = n * m - n 
goal: n * m.pred = n * m - n

full_name: Nat.mul_pred_right
code: @[deprecated (since := "2024-06-01")] abbrev mul_pred_right 
goal: n * m.pred = n * m - n

full_name: Nat.mul_sub_one
code: theorem mul_sub_one (n m : Nat) : n * (m - 1) = n * m - n 
goal: n * (m - 1) = n * m - n

full_name: Nat.mul_sub_right_distrib
code: protected theorem mul_sub_right_distrib (n m k : Nat) : (n - m) * k = n * k - m * k 
goal: (n - m) * k = n * k - m * k

full_name: Nat.mul_sub_left_distrib
code: protected theorem mul_sub_left_distrib (n m k : Nat) : n * (m - k) = n * m - n * k 
goal: n * (m - k) = n * m - n * k

full_name: Nat.not_le_eq
code: theorem not_le_eq (a b : Nat) : (¬ (a ≤ b)) = (b + 1 ≤ a) 
goal: (¬a ≤ b) = (b + 1 ≤ a)

full_name: Nat.not_ge_eq
code: theorem not_ge_eq (a b : Nat) : (¬ (a ≥ b)) = (a + 1 ≤ b) 
goal: (¬a ≥ b) = (a + 1 ≤ b)

full_name: Nat.not_lt_eq
code: theorem not_lt_eq (a b : Nat) : (¬ (a < b)) = (b ≤ a) 
goal: (¬a < b) = (b ≤ a)

full_name: Nat.not_gt_eq
code: theorem not_gt_eq (a b : Nat) : (¬ (a > b)) = (a ≤ b) 
goal: (¬a > b) = (a ≤ b)

full_name: Nat.fold_eq_foldTR
code: @[csimp] theorem fold_eq_foldTR : @fold = @foldTR 
goal: @Nat.fold = @Nat.foldTR

full_name: Nat.fold_eq_foldTR.go
code: @[csimp] theorem fold_eq_foldTR : @fold = @foldTR 
goal: Nat.foldTR.loop f (m + n) m (Nat.fold f n init) = Nat.fold f (m + n) init

full_name: Nat.any_eq_anyTR.go
code: @[csimp] theorem any_eq_anyTR : @any = @anyTR 
goal: (Nat.any f n || Nat.anyTR.loop f (m + n) m) = Nat.any f (m + n)

full_name: Nat.any_eq_anyTR
code: @[csimp] theorem any_eq_anyTR : @any = @anyTR 
goal: Nat.any = Nat.anyTR

full_name: Nat.all_eq_allTR.go
code: @[csimp] theorem all_eq_allTR : @all = @allTR 
goal: (Nat.all f n && Nat.allTR.loop f (m + n) m) = Nat.all f (m + n)

full_name: Nat.all_eq_allTR
code: @[csimp] theorem all_eq_allTR : @all = @allTR 
goal: Nat.all = Nat.allTR

full_name: Nat.repeat_eq_repeatTR.go
code: @[csimp] theorem repeat_eq_repeatTR : @repeat = @repeatTR 
goal: Nat.repeatTR.loop f m (Nat.repeat f n init) = Nat.repeat f (m + n) init

full_name: Nat.repeat_eq_repeatTR
code: @[csimp] theorem repeat_eq_repeatTR : @repeat = @repeatTR 
goal: @Nat.repeat = @Nat.repeatTR

full_name: Prod.foldI
code: /--
`(start, stop).foldI f a` evaluates `f` on all the numbers
from `start` (inclusive) to `stop` (exclusive) in increasing order:
* `(5, 8).foldI f init = init |> f 5 |> f 6 |> f 7`
-/
@[inline] def foldI {α : Type u} (f : Nat → α → α) (i : Nat × Nat) (a : α) : α 
goal: α

full_name: Prod.anyI
code: /--
`(start, stop).anyI f a` returns true if `f` is true for some natural number
from `start` (inclusive) to `stop` (exclusive):
* `(5, 8).anyI f = f 5 || f 6 || f 7`
-/
@[inline] def anyI (f : Nat → Bool) (i : Nat × Nat) : Bool 
goal: Bool

full_name: Prod.allI
code: /--
`(start, stop).allI f a` returns true if `f` is true for all natural numbers
from `start` (inclusive) to `stop` (exclusive):
* `(5, 8).anyI f = f 5 && f 6 && f 7`
-/
@[inline] def allI (f : Nat → Bool) (i : Nat × Nat) : Bool 
goal: Bool