ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Bitwise.Lemmas.0.Nat.eq_0_of_lt
private theorem eq_0_of_lt (x : Nat) : x < 2^ 0 ↔ x = 0 
Arguments: (x : Nat)
Goal: x < 2 ^ 0 ↔ x = 0
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Bitwise.Lemmas.0.Nat.zero_lt_pow
@[local simp]
private theorem zero_lt_pow (n : Nat) : 0 < 2^n 
Arguments: (n : Nat)
Goal: 0 < 2 ^ n
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Bitwise.Lemmas.0.Nat.div_two_le_of_lt_two
private theorem div_two_le_of_lt_two {m n : Nat} (p : m < 2 ^ succ n) : m / 2 < 2^n 
Arguments: {m n : Nat} (p : m < 2 ^ n.succ)
Goal: m / 2 < 2 ^ n
-- Nat.bitwise_lt_two_pow
theorem bitwise_lt_two_pow (left : x < 2^n) (right : y < 2^n) : (Nat.bitwise f x y) < 2^n 
Arguments: {x n y : Nat} {f : Bool → Bool → Bool} (left : x < 2 ^ n) (right : y < 2 ^ n)
Goal: Nat.bitwise f x y < 2 ^ n
-- Nat.testBit_and
@[simp] theorem testBit_and (x y i : Nat) : (x &&& y).testBit i = (x.testBit i && y.testBit i) 
Arguments: (x y i : Nat)
Goal: (x &&& y).testBit i = (x.testBit i && y.testBit i)
-- Nat.and_lt_two_pow
theorem and_lt_two_pow (x : Nat) {y n : Nat} (right : y < 2^n) : (x &&& y) < 2^n 
Arguments: (x : Nat) {y n : Nat} (right : y < 2 ^ n)
Goal: x &&& y < 2 ^ n
-- Nat.and_pow_two_is_mod
@[simp] theorem and_pow_two_is_mod (x n : Nat) : x &&& (2^n-1) = x % 2^n 
Arguments: (x n : Nat)
Goal: x &&& 2 ^ n - 1 = x % 2 ^ n
-- Nat.and_pow_two_identity
theorem and_pow_two_identity {x : Nat} (lt : x < 2^n) : x &&& 2^n-1 = x 
Arguments: {n x : Nat} (lt : x < 2 ^ n)
Goal: x &&& 2 ^ n - 1 = x
-- Nat.zero_or
@[simp] theorem zero_or (x : Nat) : 0 ||| x = x 
Arguments: (x : Nat)
Goal: 0 ||| x = x
-- Nat.or_zero
@[simp] theorem or_zero (x : Nat) : x ||| 0 = x 
Arguments: (x : Nat)
Goal: x ||| 0 = x
-- Nat.testBit_or
@[simp] theorem testBit_or (x y i : Nat) : (x ||| y).testBit i = (x.testBit i || y.testBit i) 
Arguments: (x y i : Nat)
Goal: (x ||| y).testBit i = (x.testBit i || y.testBit i)
-- Nat.or_lt_two_pow
theorem or_lt_two_pow {x y n : Nat} (left : x < 2^n) (right : y < 2^n) : x ||| y < 2^n 
Arguments: {x y n : Nat} (left : x < 2 ^ n) (right : y < 2 ^ n)
Goal: x ||| y < 2 ^ n
-- Nat.testBit_xor
@[simp] theorem testBit_xor (x y i : Nat) :
    (x ^^^ y).testBit i = Bool.xor (x.testBit i) (y.testBit i) 
Arguments: (x y i : Nat)
Goal: (x ^^^ y).testBit i = (x.testBit i).xor (y.testBit i)
-- Nat.xor_lt_two_pow
theorem xor_lt_two_pow {x y n : Nat} (left : x < 2^n) (right : y < 2^n) : x ^^^ y < 2^n 
Arguments: {x y n : Nat} (left : x < 2 ^ n) (right : y < 2 ^ n)
Goal: x ^^^ y < 2 ^ n
-- Nat.testBit_mul_pow_two_add
theorem testBit_mul_pow_two_add (a : Nat) {b i : Nat} (b_lt : b < 2^i) (j : Nat) :
    testBit (2 ^ i * a + b) j =
      if j < i then
        testBit b j
      else
        testBit a (j - i) 
Arguments: (a : Nat) {b i : Nat} (b_lt : b < 2 ^ i) (j : Nat)
Goal: (2 ^ i * a + b).testBit j = if j < i then b.testBit j else a.testBit (j - i)
-- Nat.testBit_mul_pow_two
theorem testBit_mul_pow_two :
    testBit (2 ^ i * a) j = (decide (j ≥ i) && testBit a (j-i)) 
Arguments: {i a j : Nat}
Goal: (2 ^ i * a).testBit j = (decide (j ≥ i) && a.testBit (j - i))
-- Nat.mul_add_lt_is_or
theorem mul_add_lt_is_or {b : Nat} (b_lt : b < 2^i) (a : Nat) : 2^i * a + b = 2^i * a ||| b 
Arguments: {i b : Nat} (b_lt : b < 2 ^ i) (a : Nat)
Goal: 2 ^ i * a + b = 2 ^ i * a ||| b
-- Nat.testBit_shiftLeft
@[simp] theorem testBit_shiftLeft (x : Nat) : testBit (x <<< i) j =
    (decide (j ≥ i) && testBit x (j-i)) 
Arguments: {i j : Nat} (x : Nat)
Goal: (x <<< i).testBit j = (decide (j ≥ i) && x.testBit (j - i))
-- Nat.testBit_shiftRight
@[simp] theorem testBit_shiftRight (x : Nat) : testBit (x >>> i) j = testBit x (i+j) 
Arguments: {i j : Nat} (x : Nat)
Goal: (x >>> i).testBit j = x.testBit (i + j)
-- Nat.add_add_add_comm
protected theorem add_add_add_comm (a b c d : Nat) : (a + b) + (c + d) = (a + c) + (b + d) 
Arguments: (a b c d : Nat)
Goal: a + b + (c + d) = a + c + (b + d)
-- Nat.one_add
theorem one_add (n) : 1 + n = succ n 
Arguments: (n : Nat)
Goal: 1 + n = n.succ
-- Nat.succ_eq_one_add
theorem succ_eq_one_add (n) : succ n = 1 + n 
Arguments: (n : Nat)
Goal: n.succ = 1 + n
-- Nat.succ_add_eq_add_succ
theorem succ_add_eq_add_succ (a b) : succ a + b = a + succ b 
Arguments: (a b : Nat)
Goal: a.succ + b = a + b.succ
-- Nat.eq_zero_of_add_eq_zero_right
protected theorem eq_zero_of_add_eq_zero_right (h : n + m = 0) : n = 0 
Arguments: {n m : Nat} (h : n + m = 0)
Goal: n = 0
-- Nat.add_eq_zero_iff
protected theorem add_eq_zero_iff : n + m = 0 ↔ n = 0 ∧ m = 0 
Arguments: {n m : Nat}
Goal: n + m = 0 ↔ n = 0 ∧ m = 0
-- Nat.add_left_cancel_iff
protected theorem add_left_cancel_iff {n : Nat} : n + m = n + k ↔ m = k 
Arguments: {m k n : Nat}
Goal: n + m = n + k ↔ m = k
-- Nat.add_right_cancel_iff
protected theorem add_right_cancel_iff {n : Nat} : m + n = k + n ↔ m = k 
Arguments: {m k n : Nat}
Goal: m + n = k + n ↔ m = k
-- Nat.add_le_add_iff_left
protected theorem add_le_add_iff_left {n : Nat} : n + m ≤ n + k ↔ m ≤ k 
Arguments: {m k n : Nat}
Goal: n + m ≤ n + k ↔ m ≤ k
-- Nat.lt_of_add_lt_add_right
protected theorem lt_of_add_lt_add_right : ∀ {n : Nat}, k + n < m + n → k < m
  
Arguments: {k m n : Nat}
Goal: k + n < m + n → k < m
-- Nat.lt_of_add_lt_add_left
protected theorem lt_of_add_lt_add_left {n : Nat} : n + k < n + m → k < m 
Arguments: {k m n : Nat}
Goal: n + k < n + m → k < m
-- Nat.add_lt_add_iff_left
protected theorem add_lt_add_iff_left {k n m : Nat} : k + n < k + m ↔ n < m 
Arguments: {k n m : Nat}
Goal: k + n < k + m ↔ n < m
-- Nat.add_lt_add_iff_right
protected theorem add_lt_add_iff_right {k n m : Nat} : n + k < m + k ↔ n < m 
Arguments: {k n m : Nat}
Goal: n + k < m + k ↔ n < m
-- Nat.add_lt_add_of_le_of_lt
protected theorem add_lt_add_of_le_of_lt {a b c d : Nat} (hle : a ≤ b) (hlt : c < d) :
    a + c < b + d 
Arguments: {a b c d : Nat} (hle : a ≤ b) (hlt : c < d)
Goal: a + c < b + d
-- Nat.add_lt_add_of_lt_of_le
protected theorem add_lt_add_of_lt_of_le {a b c d : Nat} (hlt : a < b) (hle : c ≤ d) :
    a + c < b + d 
Arguments: {a b c d : Nat} (hlt : a < b) (hle : c ≤ d)
Goal: a + c < b + d
-- Nat.lt_add_of_pos_left
protected theorem lt_add_of_pos_left : 0 < k → n < k + n 
Arguments: {k n : Nat}
Goal: 0 < k → n < k + n
-- Nat.pos_of_lt_add_right
protected theorem pos_of_lt_add_right (h : n < n + k) : 0 < k 
Arguments: {n k : Nat} (h : n < n + k)
Goal: 0 < k
-- Nat.pos_of_lt_add_left
protected theorem pos_of_lt_add_left : n < k + n → 0 < k 
Arguments: {n k : Nat}
Goal: n < k + n → 0 < k
-- Nat.lt_add_right_iff_pos
protected theorem lt_add_right_iff_pos : n < n + k ↔ 0 < k 
Arguments: {n k : Nat}
Goal: n < n + k ↔ 0 < k
-- Nat.lt_add_left_iff_pos
protected theorem lt_add_left_iff_pos : n < k + n ↔ 0 < k 
Arguments: {n k : Nat}
Goal: n < k + n ↔ 0 < k
-- Nat.add_pos_left
protected theorem add_pos_left (h : 0 < m) (n) : 0 < m + n 
Arguments: {m : Nat} (h : 0 < m) (n : Nat)
Goal: 0 < m + n
-- Nat.add_pos_right
protected theorem add_pos_right (m) (h : 0 < n) : 0 < m + n 
Arguments: {n : Nat} (m : Nat) (h : 0 < n)
Goal: 0 < m + n
-- Nat.add_self_ne_one
protected theorem add_self_ne_one : ∀ n, n + n ≠ 1
  
Arguments: (n : Nat)
Goal: n + n ≠ 1
-- Nat.sub_one
protected theorem sub_one (n) : n - 1 = pred n 
Arguments: (n : Nat)
Goal: n - 1 = n.pred
-- Nat.one_sub
protected theorem one_sub : ∀ n, 1 - n = if n = 0 then 1 else 0
  
Arguments: (n : Nat)
Goal: 1 - n = if n = 0 then 1 else 0
-- Nat.succ_sub_sub_succ
theorem succ_sub_sub_succ (n m k) : succ n - m - succ k = n - m - k 
Arguments: (n m k : Nat)
Goal: n.succ - m - k.succ = n - m - k
-- Nat.add_sub_sub_add_right
theorem add_sub_sub_add_right (n m k l : Nat) :
    (n + l) - m - (k + l) = n - m - k 
Arguments: (n m k l : Nat)
Goal: n + l - m - (k + l) = n - m - k
-- Nat.sub_right_comm
protected theorem sub_right_comm (m n k : Nat) : m - n - k = m - k - n 
Arguments: (m n k : Nat)
Goal: m - n - k = m - k - n
-- Nat.add_sub_cancel_right
protected theorem add_sub_cancel_right (n m : Nat) : (n + m) - m = n 
Arguments: (n m : Nat)
Goal: n + m - m = n
-- Nat.add_sub_cancel'
@[simp] protected theorem add_sub_cancel' {n m : Nat} (h : m ≤ n) : m + (n - m) = n 
Arguments: {n m : Nat} (h : m ≤ n)
Goal: m + (n - m) = n
-- Nat.succ_sub_one
theorem succ_sub_one (n) : succ n - 1 = n 
Arguments: (n : Nat)
Goal: n.succ - 1 = n
-- Nat.add_one_sub_one
protected theorem add_one_sub_one (n : Nat) : (n + 1) - 1 = n 
Arguments: (n : Nat)
Goal: n + 1 - 1 = n
-- Nat.one_add_sub_one
protected theorem one_add_sub_one (n : Nat) : (1 + n) - 1 = n 
Arguments: (n : Nat)
Goal: 1 + n - 1 = n
-- Nat.sub_sub_self
protected theorem sub_sub_self {n m : Nat} (h : m ≤ n) : n - (n - m) = m 
Arguments: {n m : Nat} (h : m ≤ n)
Goal: n - (n - m) = m
-- Nat.sub_add_comm
protected theorem sub_add_comm {n m k : Nat} (h : k ≤ n) : n + m - k = n - k + m 
Arguments: {n m k : Nat} (h : k ≤ n)
Goal: n + m - k = n - k + m
-- Nat.sub_eq_zero_iff_le
protected theorem sub_eq_zero_iff_le : n - m = 0 ↔ n ≤ m 
Arguments: {n m : Nat}
Goal: n - m = 0 ↔ n ≤ m
-- Nat.sub_pos_iff_lt
protected theorem sub_pos_iff_lt : 0 < n - m ↔ m < n 
Arguments: {n m : Nat}
Goal: 0 < n - m ↔ m < n
-- Nat.sub_le_iff_le_add
protected theorem sub_le_iff_le_add {a b c : Nat} : a - b ≤ c ↔ a ≤ c + b 
Arguments: {a b c : Nat}
Goal: a - b ≤ c ↔ a ≤ c + b
-- Nat.sub_le_iff_le_add'
protected theorem sub_le_iff_le_add' {a b c : Nat} : a - b ≤ c ↔ a ≤ b + c 
Arguments: {a b c : Nat}
Goal: a - b ≤ c ↔ a ≤ b + c
-- Nat.le_sub_iff_add_le
protected theorem le_sub_iff_add_le {n : Nat} (h : k ≤ m) : n ≤ m - k ↔ n + k ≤ m 
Arguments: {k m n : Nat} (h : k ≤ m)
Goal: n ≤ m - k ↔ n + k ≤ m
-- Nat.add_le_to_le_sub
@[deprecated Nat.le_sub_iff_add_le (since := "2024-02-19")]
protected theorem add_le_to_le_sub (n : Nat) (h : m ≤ k) : n + m ≤ k ↔ n ≤ k - m 
Arguments: {m k : Nat} (n : Nat) (h : m ≤ k)
Goal: n + m ≤ k ↔ n ≤ k - m
-- Nat.add_le_of_le_sub'
protected theorem add_le_of_le_sub' {n k m : Nat} (h : m ≤ k) : n ≤ k - m → m + n ≤ k 
Arguments: {n k m : Nat} (h : m ≤ k)
Goal: n ≤ k - m → m + n ≤ k
-- Nat.add_le_of_le_sub_left
@[deprecated Nat.add_le_of_le_sub' (since := "2024-02-19")]
protected theorem add_le_of_le_sub_left {n k m : Nat} (h : m ≤ k) : n ≤ k - m → m + n ≤ k 
Arguments: {n k m : Nat} (h : m ≤ k)
Goal: n ≤ k - m → m + n ≤ k
-- Nat.le_sub_of_add_le'
protected theorem le_sub_of_add_le' {n k m : Nat} : m + n ≤ k → n ≤ k - m 
Arguments: {n k m : Nat}
Goal: m + n ≤ k → n ≤ k - m
-- Nat.le_sub_iff_add_le'
protected theorem le_sub_iff_add_le' {n : Nat} (h : k ≤ m) : n ≤ m - k ↔ k + n ≤ m 
Arguments: {k m n : Nat} (h : k ≤ m)
Goal: n ≤ m - k ↔ k + n ≤ m
-- Nat.le_of_sub_le_sub_left
protected theorem le_of_sub_le_sub_left : ∀ {n k m : Nat}, n ≤ k → k - m ≤ k - n → n ≤ m
  
Arguments: {n k m : Nat}
Goal: n ≤ k → k - m ≤ k - n → n ≤ m
-- Nat.sub_le_sub_iff_left
protected theorem sub_le_sub_iff_left {n m k : Nat} (h : n ≤ k) : k - m ≤ k - n ↔ n ≤ m 
Arguments: {n m k : Nat} (h : n ≤ k)
Goal: k - m ≤ k - n ↔ n ≤ m
-- Nat.sub_lt_of_pos_le
protected theorem sub_lt_of_pos_le (h₀ : 0 < a) (h₁ : a ≤ b) : b - a < b 
Arguments: {a b : Nat} (h₀ : 0 < a) (h₁ : a ≤ b)
Goal: b - a < b
-- Nat.add_lt_of_lt_sub'
theorem add_lt_of_lt_sub' {a b c : Nat} : b < c - a → a + b < c 
Arguments: {a b c : Nat}
Goal: b < c - a → a + b < c
-- Nat.sub_add_lt_sub
protected theorem sub_add_lt_sub (h₁ : m + k ≤ n) (h₂ : 0 < k) : n - (m + k) < n - m 
Arguments: {m k n : Nat} (h₁ : m + k ≤ n) (h₂ : 0 < k)
Goal: n - (m + k) < n - m
-- Nat.sub_one_lt_of_le
theorem sub_one_lt_of_le (h₀ : 0 < a) (h₁ : a ≤ b) : a - 1 < b 
Arguments: {a b : Nat} (h₀ : 0 < a) (h₁ : a ≤ b)
Goal: a - 1 < b
-- Nat.sub_lt_succ
theorem sub_lt_succ (a b) : a - b < succ a 
Arguments: (a b : Nat)
Goal: a - b < a.succ
-- Nat.sub_lt_add_one
theorem sub_lt_add_one (a b) : a - b < a + 1 
Arguments: (a b : Nat)
Goal: a - b < a + 1
-- Nat.sub_one_sub_lt
theorem sub_one_sub_lt (h : i < n) : n - 1 - i < n 
Arguments: {i n : Nat} (h : i < n)
Goal: n - 1 - i < n
-- Nat.exists_eq_add_of_le
protected theorem exists_eq_add_of_le (h : m ≤ n) : ∃ k : Nat, n = m + k 
Arguments: {m n : Nat} (h : m ≤ n)
Goal: ∃ k, n = m + k
-- Nat.exists_eq_add_of_le'
protected theorem exists_eq_add_of_le' (h : m ≤ n) : ∃ k : Nat, n = k + m 
Arguments: {m n : Nat} (h : m ≤ n)
Goal: ∃ k, n = k + m
-- Nat.exists_eq_add_of_lt
protected theorem exists_eq_add_of_lt (h : m < n) : ∃ k : Nat, n = m + k + 1 
Arguments: {m n : Nat} (h : m < n)
Goal: ∃ k, n = m + k + 1
-- Nat.succ_min_succ
theorem succ_min_succ (x y) : min (succ x) (succ y) = succ (min x y) 
Arguments: (x y : Nat)
Goal: min x.succ y.succ = (min x y).succ
-- Nat.min_self
@[simp] protected theorem min_self (a : Nat) : min a a = a 
Arguments: (a : Nat)
Goal: min a a = a
-- Nat.zero_min
@[simp] protected theorem zero_min (a) : min 0 a = 0 
Arguments: (a : Nat)
Goal: min 0 a = 0
-- Nat.min_zero
@[simp] protected theorem min_zero (a) : min a 0 = 0 
Arguments: (a : Nat)
Goal: min a 0 = 0
-- Nat.min_assoc
@[simp] protected theorem min_assoc : ∀ (a b c : Nat), min (min a b) c = min a (min b c)
  
Arguments: (a b c : Nat)
Goal: min (min a b) c = min a (min b c)
-- Nat.min_self_assoc
@[simp] protected theorem min_self_assoc {m n : Nat} : min m (min m n) = min m n 
Arguments: {m n : Nat}
Goal: min m (min m n) = min m n
-- Nat.min_self_assoc'
@[simp] protected theorem min_self_assoc' {m n : Nat} : min n (min m n) = min n m 
Arguments: {m n : Nat}
Goal: min n (min m n) = min n m
-- Nat.sub_sub_eq_min
protected theorem sub_sub_eq_min : ∀ (a b : Nat), a - (a - b) = min a b
  
Arguments: (a b : Nat)
Goal: a - (a - b) = min a b
-- Nat.sub_eq_sub_min
protected theorem sub_eq_sub_min (n m : Nat) : n - m = n - min n m 
Arguments: (n m : Nat)
Goal: n - m = n - min n m
-- Nat.sub_add_min_cancel
@[simp] protected theorem sub_add_min_cancel (n m : Nat) : n - m + min n m = n 
Arguments: (n m : Nat)
Goal: n - m + min n m = n
-- Nat.max_eq_right
protected theorem max_eq_right {a b : Nat} (h : a ≤ b) : max a b = b 
Arguments: {a b : Nat} (h : a ≤ b)
Goal: max a b = b
-- Nat.max_eq_left
protected theorem max_eq_left {a b : Nat} (h : b ≤ a) : max a b = a 
Arguments: {a b : Nat} (h : b ≤ a)
Goal: max a b = a
-- Nat.succ_max_succ
protected theorem succ_max_succ (x y) : max (succ x) (succ y) = succ (max x y) 
Arguments: (x y : Nat)
Goal: max x.succ y.succ = (max x y).succ
-- Nat.max_le_of_le_of_le
protected theorem max_le_of_le_of_le {a b c : Nat} : a ≤ c → b ≤ c → max a b ≤ c 
Arguments: {a b c : Nat}
Goal: a ≤ c → b ≤ c → max a b ≤ c
-- Nat.max_le
protected theorem max_le {a b c : Nat} : max a b ≤ c ↔ a ≤ c ∧ b ≤ c 
Arguments: {a b c : Nat}
Goal: max a b ≤ c ↔ a ≤ c ∧ b ≤ c
-- Nat.max_lt
protected theorem max_lt {a b c : Nat} : max a b < c ↔ a < c ∧ b < c 
Arguments: {a b c : Nat}
Goal: max a b < c ↔ a < c ∧ b < c
-- Nat.max_self
@[simp] protected theorem max_self (a : Nat) : max a a = a 
Arguments: (a : Nat)
Goal: max a a = a
-- Nat.zero_max
@[simp] protected theorem zero_max (a) : max 0 a = a 
Arguments: (a : Nat)
Goal: max 0 a = a
-- Nat.max_zero
@[simp] protected theorem max_zero (a) : max a 0 = a 
Arguments: (a : Nat)
Goal: max a 0 = a
-- Nat.max_assoc
protected theorem max_assoc : ∀ (a b c : Nat), max (max a b) c = max a (max b c)
  
Arguments: (a b c : Nat)
Goal: max (max a b) c = max a (max b c)
-- Nat.sub_add_eq_max
protected theorem sub_add_eq_max (a b : Nat) : a - b + b = max a b 
Arguments: (a b : Nat)
Goal: a - b + b = max a b
-- Nat.sub_eq_max_sub
protected theorem sub_eq_max_sub (n m : Nat) : n - m = max n m - m 
Arguments: (n m : Nat)
Goal: n - m = max n m - m
-- Nat.max_min_distrib_left
protected theorem max_min_distrib_left : ∀ (a b c : Nat), max a (min b c) = min (max a b) (max a c)
  
Arguments: (a b c : Nat)
Goal: max a (min b c) = min (max a b) (max a c)
-- Nat.min_max_distrib_left
protected theorem min_max_distrib_left : ∀ (a b c : Nat), min a (max b c) = max (min a b) (min a c)
  
Arguments: (a b c : Nat)
Goal: min a (max b c) = max (min a b) (min a c)
-- Nat.max_min_distrib_right
protected theorem max_min_distrib_right (a b c : Nat) :
    max (min a b) c = min (max a c) (max b c) 
Arguments: (a b c : Nat)
Goal: max (min a b) c = min (max a c) (max b c)
-- Nat.min_max_distrib_right
protected theorem min_max_distrib_right (a b c : Nat) :
    min (max a b) c = max (min a c) (min b c) 
Arguments: (a b c : Nat)
Goal: min (max a b) c = max (min a c) (min b c)
-- Nat.add_max_add_right
protected theorem add_max_add_right : ∀ (a b c : Nat), max (a + c) (b + c) = max a b + c
  
Arguments: (a b c : Nat)
Goal: max (a + c) (b + c) = max a b + c
-- Nat.add_min_add_right
protected theorem add_min_add_right : ∀ (a b c : Nat), min (a + c) (b + c) = min a b + c
  
Arguments: (a b c : Nat)
Goal: min (a + c) (b + c) = min a b + c
-- Nat.add_max_add_left
protected theorem add_max_add_left (a b c : Nat) : max (a + b) (a + c) = a + max b c 
Arguments: (a b c : Nat)
Goal: max (a + b) (a + c) = a + max b c
-- Nat.add_min_add_left
protected theorem add_min_add_left (a b c : Nat) : min (a + b) (a + c) = a + min b c 
Arguments: (a b c : Nat)
Goal: min (a + b) (a + c) = a + min b c
-- Nat.pred_min_pred
protected theorem pred_min_pred : ∀ (x y), min (pred x) (pred y) = pred (min x y)
  
Arguments: (x y : Nat)
Goal: min x.pred y.pred = (min x y).pred
-- Nat.pred_max_pred
protected theorem pred_max_pred : ∀ (x y), max (pred x) (pred y) = pred (max x y)
  
Arguments: (x y : Nat)
Goal: max x.pred y.pred = (max x y).pred
-- Nat.sub_min_sub_right
protected theorem sub_min_sub_right : ∀ (a b c : Nat), min (a - c) (b - c) = min a b - c
  
Arguments: (a b c : Nat)
Goal: min (a - c) (b - c) = min a b - c
-- Nat.sub_max_sub_right
protected theorem sub_max_sub_right : ∀ (a b c : Nat), max (a - c) (b - c) = max a b - c
  
Arguments: (a b c : Nat)
Goal: max (a - c) (b - c) = max a b - c
-- Nat.sub_min_sub_left
protected theorem sub_min_sub_left (a b c : Nat) : min (a - b) (a - c) = a - max b c 
Arguments: (a b c : Nat)
Goal: min (a - b) (a - c) = a - max b c
-- Nat.sub_max_sub_left
protected theorem sub_max_sub_left (a b c : Nat) : max (a - b) (a - c) = a - min b c 
Arguments: (a b c : Nat)
Goal: max (a - b) (a - c) = a - min b c
-- Nat.mul_max_mul_right
protected theorem mul_max_mul_right (a b c : Nat) : max (a * c) (b * c) = max a b * c 
Arguments: (a b c : Nat)
Goal: max (a * c) (b * c) = max a b * c
-- Nat.mul_min_mul_right
protected theorem mul_min_mul_right (a b c : Nat) : min (a * c) (b * c) = min a b * c 
Arguments: (a b c : Nat)
Goal: min (a * c) (b * c) = min a b * c
-- Nat.mul_max_mul_left
protected theorem mul_max_mul_left (a b c : Nat) : max (a * b) (a * c) = a * max b c 
Arguments: (a b c : Nat)
Goal: max (a * b) (a * c) = a * max b c
-- Nat.mul_min_mul_left
protected theorem mul_min_mul_left (a b c : Nat) : min (a * b) (a * c) = a * min b c 
Arguments: (a b c : Nat)
Goal: min (a * b) (a * c) = a * min b c
-- Nat.mul_le_mul_of_nonneg_left
@[deprecated Nat.mul_le_mul_left (since := "2024-02-19")]
protected theorem mul_le_mul_of_nonneg_left {a b c : Nat} : a ≤ b → c * a ≤ c * b 
Arguments: {a b c : Nat}
Goal: a ≤ b → c * a ≤ c * b
-- Nat.mul_le_mul_of_nonneg_right
@[deprecated Nat.mul_le_mul_right (since := "2024-02-19")]
protected theorem mul_le_mul_of_nonneg_right {a b c : Nat} : a ≤ b → a * c ≤ b * c 
Arguments: {a b c : Nat}
Goal: a ≤ b → a * c ≤ b * c
-- Nat.mul_right_comm
protected theorem mul_right_comm (n m k : Nat) : n * m * k = n * k * m 
Arguments: (n m k : Nat)
Goal: n * m * k = n * k * m
-- Nat.mul_mul_mul_comm
protected theorem mul_mul_mul_comm (a b c d : Nat) : (a * b) * (c * d) = (a * c) * (b * d) 
Arguments: (a b c d : Nat)
Goal: a * b * (c * d) = a * c * (b * d)
-- Nat.mul_eq_zero
theorem mul_eq_zero : ∀ {m n}, n * m = 0 ↔ n = 0 ∨ m = 0
  
Arguments: {m n : Nat}
Goal: n * m = 0 ↔ n = 0 ∨ m = 0
-- Nat.mul_ne_zero_iff
protected theorem mul_ne_zero_iff : n * m ≠ 0 ↔ n ≠ 0 ∧ m ≠ 0 
Arguments: {n m : Nat}
Goal: n * m ≠ 0 ↔ n ≠ 0 ∧ m ≠ 0
-- Nat.mul_ne_zero
protected theorem mul_ne_zero : n ≠ 0 → m ≠ 0 → n * m ≠ 0 
Arguments: {n m : Nat}
Goal: n ≠ 0 → m ≠ 0 → n * m ≠ 0
-- Nat.ne_zero_of_mul_ne_zero_left
protected theorem ne_zero_of_mul_ne_zero_left (h : n * m ≠ 0) : n ≠ 0 
Arguments: {n m : Nat} (h : n * m ≠ 0)
Goal: n ≠ 0
-- Nat.mul_left_cancel
protected theorem mul_left_cancel {n m k : Nat} (np : 0 < n) (h : n * m = n * k) : m = k 
Arguments: {n m k : Nat} (np : 0 < n) (h : n * m = n * k)
Goal: m = k
-- Nat.mul_right_cancel
protected theorem mul_right_cancel {n m k : Nat} (mp : 0 < m) (h : n * m = k * m) : n = k 
Arguments: {n m k : Nat} (mp : 0 < m) (h : n * m = k * m)
Goal: n = k
-- Nat.mul_left_cancel_iff
protected theorem mul_left_cancel_iff {n: Nat} (p : 0 < n) (m k : Nat) : n * m = n * k ↔ m = k 
Arguments: {n : Nat} (p : 0 < n) (m k : Nat)
Goal: n * m = n * k ↔ m = k
-- Nat.mul_right_cancel_iff
protected theorem mul_right_cancel_iff {m : Nat} (p : 0 < m) (n k : Nat) : n * m = k * m ↔ n = k 
Arguments: {m : Nat} (p : 0 < m) (n k : Nat)
Goal: n * m = k * m ↔ n = k
-- Nat.ne_zero_of_mul_ne_zero_right
protected theorem ne_zero_of_mul_ne_zero_right (h : n * m ≠ 0) : m ≠ 0 
Arguments: {n m : Nat} (h : n * m ≠ 0)
Goal: m ≠ 0
-- Nat.le_mul_of_pos_left
protected theorem le_mul_of_pos_left (m) (h : 0 < n) : m ≤ n * m 
Arguments: {n : Nat} (m : Nat) (h : 0 < n)
Goal: m ≤ n * m
-- Nat.le_mul_of_pos_right
protected theorem le_mul_of_pos_right (n) (h : 0 < m) : n ≤ n * m 
Arguments: {m : Nat} (n : Nat) (h : 0 < m)
Goal: n ≤ n * m
-- Nat.mul_lt_mul_of_lt_of_le
protected theorem mul_lt_mul_of_lt_of_le (hac : a < c) (hbd : b ≤ d) (hd : 0 < d) :
    a * b < c * d 
Arguments: {a c b d : Nat} (hac : a < c) (hbd : b ≤ d) (hd : 0 < d)
Goal: a * b < c * d
-- Nat.mul_lt_mul_of_lt_of_le'
protected theorem mul_lt_mul_of_lt_of_le' (hac : a < c) (hbd : b ≤ d) (hb : 0 < b) :
    a * b < c * d 
Arguments: {a c b d : Nat} (hac : a < c) (hbd : b ≤ d) (hb : 0 < b)
Goal: a * b < c * d
-- Nat.mul_lt_mul_of_le_of_lt
protected theorem mul_lt_mul_of_le_of_lt (hac : a ≤ c) (hbd : b < d) (hc : 0 < c) :
    a * b < c * d 
Arguments: {a c b d : Nat} (hac : a ≤ c) (hbd : b < d) (hc : 0 < c)
Goal: a * b < c * d
-- Nat.mul_lt_mul_of_le_of_lt'
protected theorem mul_lt_mul_of_le_of_lt' (hac : a ≤ c) (hbd : b < d) (ha : 0 < a) :
    a * b < c * d 
Arguments: {a c b d : Nat} (hac : a ≤ c) (hbd : b < d) (ha : 0 < a)
Goal: a * b < c * d
-- Nat.mul_lt_mul_of_lt_of_lt
protected theorem mul_lt_mul_of_lt_of_lt {a b c d : Nat} (hac : a < c) (hbd : b < d) :
    a * b < c * d 
Arguments: {a b c d : Nat} (hac : a < c) (hbd : b < d)
Goal: a * b < c * d
-- Nat.succ_mul_succ
theorem succ_mul_succ (a b) : succ a * succ b = a * b + a + b + 1 
Arguments: (a b : Nat)
Goal: a.succ * b.succ = a * b + a + b + 1
-- Nat.add_one_mul_add_one
theorem add_one_mul_add_one (a b : Nat) : (a + 1) * (b + 1) = a * b + a + b + 1 
Arguments: (a b : Nat)
Goal: (a + 1) * (b + 1) = a * b + a + b + 1
-- Nat.mul_le_add_right
theorem mul_le_add_right (m k n : Nat) : k * m ≤ m + n ↔ (k-1) * m ≤ n 
Arguments: (m k n : Nat)
Goal: k * m ≤ m + n ↔ (k - 1) * m ≤ n
-- Nat.succ_mul_succ_eq
theorem succ_mul_succ_eq (a b : Nat) : succ a * succ b = a * b + a + b + 1 
Arguments: (a b : Nat)
Goal: a.succ * b.succ = a * b + a + b + 1
-- Nat.mul_self_sub_mul_self_eq
protected theorem mul_self_sub_mul_self_eq (a b : Nat) : a * a - b * b = (a + b) * (a - b) 
Arguments: (a b : Nat)
Goal: a * a - b * b = (a + b) * (a - b)
-- Nat.pos_of_mul_pos_left
protected theorem pos_of_mul_pos_left {a b : Nat} (h : 0 < a * b) : 0 < b 
Arguments: {a b : Nat} (h : 0 < a * b)
Goal: 0 < b
-- Nat.pos_of_mul_pos_right
protected theorem pos_of_mul_pos_right {a b : Nat} (h : 0 < a * b) : 0 < a 
Arguments: {a b : Nat} (h : 0 < a * b)
Goal: 0 < a
-- Nat.mul_pos_iff_of_pos_left
@[simp] protected theorem mul_pos_iff_of_pos_left {a b : Nat} (h : 0 < a) :
    0 < a * b ↔ 0 < b 
Arguments: {a b : Nat} (h : 0 < a)
Goal: 0 < a * b ↔ 0 < b
-- Nat.mul_pos_iff_of_pos_right
@[simp] protected theorem mul_pos_iff_of_pos_right {a b : Nat} (h : 0 < b) :
    0 < a * b ↔ 0 < a 
Arguments: {a b : Nat} (h : 0 < b)
Goal: 0 < a * b ↔ 0 < a
-- Nat.mod_two_eq_zero_or_one
theorem mod_two_eq_zero_or_one (n : Nat) : n % 2 = 0 ∨ n % 2 = 1 
Arguments: (n : Nat)
Goal: n % 2 = 0 ∨ n % 2 = 1
-- Nat.le_of_mod_lt
theorem le_of_mod_lt {a b : Nat} (h : a % b < a) : b ≤ a 
Arguments: {a b : Nat} (h : a % b < a)
Goal: b ≤ a