ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.le_sub_one_iff_lt
protected theorem le_sub_one_iff_lt (h : 0 < m) : n ≤ m - 1 ↔ n < m 
Arguments: {m n : Nat} (h : 0 < m)
Goal: n ≤ m - 1 ↔ n < m
-- Nat.exists_eq_succ_of_ne_zero
theorem exists_eq_succ_of_ne_zero : ∀ {n}, n ≠ 0 → Exists fun k => n = succ k
  
Arguments: {n : Nat}
Goal: n ≠ 0 → Exists fun k => n = k.succ
-- Nat.exists_eq_add_one_of_ne_zero
theorem exists_eq_add_one_of_ne_zero : ∀ {n}, n ≠ 0 → Exists fun k => n = k + 1
  
Arguments: {n : Nat}
Goal: n ≠ 0 → Exists fun k => n = k + 1
-- Nat.ctor_eq_zero
theorem ctor_eq_zero : Nat.zero = 0 
Goal: Nat.zero = 0
-- Nat.one_ne_zero
protected theorem one_ne_zero : 1 ≠ (0 : Nat) 
Goal: 1 ≠ 0
-- Nat.zero_ne_one
protected theorem zero_ne_one : 0 ≠ (1 : Nat) 
Goal: 0 ≠ 1
-- Nat.succ_ne_zero
@[simp] theorem succ_ne_zero (n : Nat) : succ n ≠ 0 
Arguments: (n : Nat)
Goal: n.succ ≠ 0
-- Nat.mul_le_mul_left
theorem mul_le_mul_left {n m : Nat} (k : Nat) (h : n ≤ m) : k * n ≤ k * m 
Arguments: {n m : Nat} (k : Nat) (h : n ≤ m)
Goal: k * n ≤ k * m
-- Nat.mul_le_mul_right
theorem mul_le_mul_right {n m : Nat} (k : Nat) (h : n ≤ m) : n * k ≤ m * k 
Arguments: {n m : Nat} (k : Nat) (h : n ≤ m)
Goal: n * k ≤ m * k
-- Nat.mul_le_mul
protected theorem mul_le_mul {n₁ m₁ n₂ m₂ : Nat} (h₁ : n₁ ≤ n₂) (h₂ : m₁ ≤ m₂) : n₁ * m₁ ≤ n₂ * m₂ 
Arguments: {n₁ m₁ n₂ m₂ : Nat} (h₁ : n₁ ≤ n₂) (h₂ : m₁ ≤ m₂)
Goal: n₁ * m₁ ≤ n₂ * m₂
-- Nat.mul_lt_mul_of_pos_left
protected theorem mul_lt_mul_of_pos_left {n m k : Nat} (h : n < m) (hk : k > 0) : k * n < k * m 
Arguments: {n m k : Nat} (h : n < m) (hk : k > 0)
Goal: k * n < k * m
-- Nat.mul_lt_mul_of_pos_right
protected theorem mul_lt_mul_of_pos_right {n m k : Nat} (h : n < m) (hk : k > 0) : n * k < m * k 
Arguments: {n m k : Nat} (h : n < m) (hk : k > 0)
Goal: n * k < m * k
-- Nat.mul_pos
protected theorem mul_pos {n m : Nat} (ha : n > 0) (hb : m > 0) : n * m > 0 
Arguments: {n m : Nat} (ha : n > 0) (hb : m > 0)
Goal: n * m > 0
-- Nat.le_of_mul_le_mul_left
protected theorem le_of_mul_le_mul_left {a b c : Nat} (h : c * a ≤ c * b) (hc : 0 < c) : a ≤ b 
Arguments: {a b c : Nat} (h : c * a ≤ c * b) (hc : 0 < c)
Goal: a ≤ b
-- Nat.eq_of_mul_eq_mul_left
protected theorem eq_of_mul_eq_mul_left {m k n : Nat} (hn : 0 < n) (h : n * m = n * k) : m = k 
Arguments: {m k n : Nat} (hn : 0 < n) (h : n * m = n * k)
Goal: m = k
-- Nat.eq_of_mul_eq_mul_right
theorem eq_of_mul_eq_mul_right {n m k : Nat} (hm : 0 < m) (h : n * m = k * m) : n = k 
Arguments: {n m k : Nat} (hm : 0 < m) (h : n * m = k * m)
Goal: n = k
-- Nat.pow_succ
protected theorem pow_succ (n m : Nat) : n^(succ m) = n^m * n 
Arguments: (n m : Nat)
Goal: n ^ m.succ = n ^ m * n
-- Nat.pow_add_one
protected theorem pow_add_one (n m : Nat) : n^(m + 1) = n^m * n 
Arguments: (n m : Nat)
Goal: n ^ (m + 1) = n ^ m * n
-- Nat.pow_zero
protected theorem pow_zero (n : Nat) : n^0 = 1 
Arguments: (n : Nat)
Goal: n ^ 0 = 1
-- Nat.pow_le_pow_of_le_left
theorem pow_le_pow_of_le_left {n m : Nat} (h : n ≤ m) : ∀ (i : Nat), n^i ≤ m^i
  
Arguments: {n m : Nat} (h : n ≤ m) (i : Nat)
Goal: n ^ i ≤ m ^ i
-- Nat.pow_le_pow_of_le_right
theorem pow_le_pow_of_le_right {n : Nat} (hx : n > 0) {i : Nat} : ∀ {j}, i ≤ j → n^i ≤ n^j
  
Arguments: {n : Nat} (hx : n > 0) {i j : Nat}
Goal: i ≤ j → n ^ i ≤ n ^ j
-- Nat.pos_pow_of_pos
theorem pos_pow_of_pos {n : Nat} (m : Nat) (h : 0 < n) : 0 < n^m 
Arguments: {n : Nat} (m : Nat) (h : 0 < n)
Goal: 0 < n ^ m
-- Nat.min_def
protected theorem min_def {n m : Nat} : min n m = if n ≤ m then n else m 
Arguments: {n m : Nat}
Goal: min n m = ite (n ≤ m) n m
-- Nat.max_def
protected theorem max_def {n m : Nat} : max n m = if n ≤ m then m else n 
Arguments: {n m : Nat}
Goal: max n m = ite (n ≤ m) m n
-- Nat.not_eq_zero_of_lt
theorem not_eq_zero_of_lt (h : b < a) : a ≠ 0 
Arguments: {b a : Nat} (h : b < a)
Goal: a ≠ 0
-- Nat.pred_lt_of_lt
theorem pred_lt_of_lt {n m : Nat} (h : m < n) : pred n < n 
Arguments: {n m : Nat} (h : m < n)
Goal: n.pred < n
-- Nat.sub_one_lt_of_lt
theorem sub_one_lt_of_lt {n m : Nat} (h : m < n) : n - 1 < n 
Arguments: {n m : Nat} (h : m < n)
Goal: n - 1 < n
-- Nat.pred_zero
@[simp] protected theorem pred_zero : pred 0 = 0 
Goal: Nat.pred 0 = 0
-- Nat.pred_succ
@[simp] protected theorem pred_succ (n : Nat) : pred n.succ = n 
Arguments: (n : Nat)
Goal: n.succ.pred = n
-- Nat.succ_pred
theorem succ_pred {a : Nat} (h : a ≠ 0) : a.pred.succ = a 
Arguments: {a : Nat} (h : a ≠ 0)
Goal: a.pred.succ = a
-- Nat.sub_one_add_one
theorem sub_one_add_one {a : Nat} (h : a ≠ 0) : a - 1 + 1 = a 
Arguments: {a : Nat} (h : a ≠ 0)
Goal: a - 1 + 1 = a
-- Nat.succ_pred_eq_of_pos
theorem succ_pred_eq_of_pos : ∀ {n}, 0 < n → succ (pred n) = n
  
Arguments: {n : Nat}
Goal: 0 < n → n.pred.succ = n
-- Nat.sub_one_add_one_eq_of_pos
theorem sub_one_add_one_eq_of_pos : ∀ {n}, 0 < n → (n - 1) + 1 = n
  
Arguments: {n : Nat}
Goal: 0 < n → n - 1 + 1 = n
-- Nat.eq_zero_or_eq_sub_one_add_one
theorem eq_zero_or_eq_sub_one_add_one : ∀ {n}, n = 0 ∨ n = n - 1 + 1
  
Arguments: {n : Nat}
Goal: n = 0 ∨ n = n - 1 + 1
-- Nat.pred_eq_sub_one
@[simp] theorem pred_eq_sub_one : pred n = n - 1 
Arguments: {n : Nat}
Goal: n.pred = n - 1
-- Nat.add_sub_self_left
theorem add_sub_self_left (a b : Nat) : (a + b) - a = b 
Arguments: (a b : Nat)
Goal: a + b - a = b
-- Nat.add_sub_self_right
theorem add_sub_self_right (a b : Nat) : (a + b) - b = a 
Arguments: (a b : Nat)
Goal: a + b - b = a
-- Nat.sub_le_succ_sub
theorem sub_le_succ_sub (a i : Nat) : a - i ≤ a.succ - i 
Arguments: (a i : Nat)
Goal: a - i ≤ a.succ - i
-- Nat.zero_lt_sub_of_lt
theorem zero_lt_sub_of_lt (h : i < a) : 0 < a - i 
Arguments: {i a : Nat} (h : i < a)
Goal: 0 < a - i
-- Nat.sub_succ_lt_self
theorem sub_succ_lt_self (a i : Nat) (h : i < a) : a - (i + 1) < a - i 
Arguments: (a i : Nat) (h : i < a)
Goal: a - (i + 1) < a - i
-- Nat.sub_ne_zero_of_lt
theorem sub_ne_zero_of_lt : {a b : Nat} → a < b → b - a ≠ 0
  
Arguments: {a b : Nat}
Goal: a < b → b - a ≠ 0
-- Nat.add_sub_of_le
theorem add_sub_of_le {a b : Nat} (h : a ≤ b) : a + (b - a) = b 
Arguments: {a b : Nat} (h : a ≤ b)
Goal: a + (b - a) = b
-- Nat.sub_one_cancel
theorem sub_one_cancel : ∀ {a b : Nat}, 0 < a → 0 < b → a - 1 = b - 1 → a = b
  
Arguments: {a b : Nat}
Goal: 0 < a → 0 < b → a - 1 = b - 1 → a = b
-- Nat.sub_add_cancel
@[simp] protected theorem sub_add_cancel {n m : Nat} (h : m ≤ n) : n - m + m = n 
Arguments: {n m : Nat} (h : m ≤ n)
Goal: n - m + m = n
-- Nat.add_sub_add_right
protected theorem add_sub_add_right (n k m : Nat) : (n + k) - (m + k) = n - m 
Arguments: (n k m : Nat)
Goal: n + k - (m + k) = n - m
-- Nat.add_sub_add_left
protected theorem add_sub_add_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_sub_cancel
@[simp] protected theorem add_sub_cancel (n m : Nat) : n + m - m = n 
Arguments: (n m : Nat)
Goal: n + m - m = n
-- Nat.add_sub_cancel_left
protected theorem add_sub_cancel_left (n m : Nat) : n + m - n = m 
Arguments: (n m : Nat)
Goal: n + m - n = m
-- Nat.add_sub_assoc
protected theorem add_sub_assoc {m k : Nat} (h : k ≤ m) (n : Nat) : n + m - k = n + (m - k) 
Arguments: {m k : Nat} (h : k ≤ m) (n : Nat)
Goal: n + m - k = n + (m - k)
-- Nat.eq_add_of_sub_eq
protected theorem eq_add_of_sub_eq {a b c : Nat} (hle : b ≤ a) (h : a - b = c) : a = c + b 
Arguments: {a b c : Nat} (hle : b ≤ a) (h : a - b = c)
Goal: a = c + b
-- Nat.sub_eq_of_eq_add
protected theorem sub_eq_of_eq_add {a b c : Nat} (h : a = c + b) : a - b = c 
Arguments: {a b c : Nat} (h : a = c + b)
Goal: a - b = c
-- Nat.le_add_of_sub_le
theorem le_add_of_sub_le {a b c : Nat} (h : a - b ≤ c) : a ≤ c + b 
Arguments: {a b c : Nat} (h : a - b ≤ c)
Goal: a ≤ c + b
-- Nat.sub_lt_sub_left
protected theorem sub_lt_sub_left : ∀ {k m n : Nat}, k < m → k < n → m - n < m - k
  
Arguments: {k m n : Nat}
Goal: k < m → k < n → m - n < m - k
-- Nat.zero_sub
@[simp] protected theorem zero_sub (n : Nat) : 0 - n = 0 
Arguments: (n : Nat)
Goal: 0 - n = 0
-- Nat.sub_lt_sub_right
protected theorem sub_lt_sub_right : ∀ {a b c : Nat}, c ≤ a → a < b → a - c < b - c
  
Arguments: {a b c : Nat}
Goal: c ≤ a → a < b → a - c < b - c
-- Nat.sub_self_add
protected theorem sub_self_add (n m : Nat) : n - (n + m) = 0 
Arguments: (n m : Nat)
Goal: n - (n + m) = 0
-- Nat.sub_eq_zero_of_le
protected theorem sub_eq_zero_of_le {n m : Nat} (h : n ≤ m) : n - m = 0 
Arguments: {n m : Nat} (h : n ≤ m)
Goal: n - m = 0
-- Nat.sub_le_of_le_add
theorem sub_le_of_le_add {a b c : Nat} (h : a ≤ c + b) : a - b ≤ c 
Arguments: {a b c : Nat} (h : a ≤ c + b)
Goal: a - b ≤ c
-- Nat.add_le_of_le_sub
theorem add_le_of_le_sub {a b c : Nat} (hle : b ≤ c) (h : a ≤ c - b) : a + b ≤ c 
Arguments: {a b c : Nat} (hle : b ≤ c) (h : a ≤ c - b)
Goal: a + b ≤ c
-- Nat.le_sub_of_add_le
theorem le_sub_of_add_le {a b c : Nat} (h : a + b ≤ c) : a ≤ c - b 
Arguments: {a b c : Nat} (h : a + b ≤ c)
Goal: a ≤ c - b
-- Nat.add_lt_of_lt_sub
theorem add_lt_of_lt_sub {a b c : Nat} (h : a < c - b) : a + b < c 
Arguments: {a b c : Nat} (h : a < c - b)
Goal: a + b < c
-- Nat.lt_sub_of_add_lt
theorem lt_sub_of_add_lt {a b c : Nat} (h : a + b < c) : a < c - b 
Arguments: {a b c : Nat} (h : a + b < c)
Goal: a < c - b
-- Nat.sub.elim
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) 
Arguments: {motive : Nat → Prop} (x y : Nat) (h₁ : y ≤ x → ∀ (k : Nat), x = y + k → motive k) (h₂ : x < y → motive 0)
Goal: motive (x - y)
-- Nat.succ_sub
theorem succ_sub {m n : Nat} (h : n ≤ m) : succ m - n = succ (m - n) 
Arguments: {m n : Nat} (h : n ≤ m)
Goal: m.succ - n = (m - n).succ
-- Nat.sub_pos_of_lt
protected theorem sub_pos_of_lt (h : m < n) : 0 < n - m 
Arguments: {m n : Nat} (h : m < n)
Goal: 0 < n - m
-- Nat.sub_sub
protected theorem sub_sub (n m k : Nat) : n - m - k = n - (m + k) 
Arguments: (n m k : Nat)
Goal: n - m - k = n - (m + k)
-- Nat.sub_le_sub_left
protected theorem sub_le_sub_left (h : n ≤ m) (k : Nat) : k - m ≤ k - n 
Arguments: {n m : Nat} (h : n ≤ m) (k : Nat)
Goal: k - m ≤ k - n
-- Nat.sub_le_sub_right
protected theorem sub_le_sub_right {n m : Nat} (h : n ≤ m) : ∀ k, n - k ≤ m - k
  
Arguments: {n m : Nat} (h : n ≤ m) (k : Nat)
Goal: n - k ≤ m - k
-- Nat.sub_le_add_right_sub
protected theorem sub_le_add_right_sub (a i j : Nat) : a - i ≤ a + j - i 
Arguments: (a i j : Nat)
Goal: a - i ≤ a + j - i
-- Nat.lt_of_sub_ne_zero
protected theorem lt_of_sub_ne_zero (h : n - m ≠ 0) : m < n 
Arguments: {n m : Nat} (h : n - m ≠ 0)
Goal: m < n
-- Nat.sub_ne_zero_iff_lt
protected theorem sub_ne_zero_iff_lt : n - m ≠ 0 ↔ m < n 
Arguments: {n m : Nat}
Goal: n - m ≠ 0 ↔ m < n
-- Nat.lt_of_sub_pos
protected theorem lt_of_sub_pos (h : 0 < n - m) : m < n 
Arguments: {n m : Nat} (h : 0 < n - m)
Goal: m < n
-- Nat.lt_of_sub_eq_succ
protected theorem lt_of_sub_eq_succ (h : m - n = succ l) : n < m 
Arguments: {m n l : Nat} (h : m - n = l.succ)
Goal: n < m
-- Nat.lt_of_sub_eq_sub_one
protected theorem lt_of_sub_eq_sub_one (h : m - n = l + 1) : n < m 
Arguments: {m n l : Nat} (h : m - n = l + 1)
Goal: n < m
-- Nat.sub_lt_left_of_lt_add
protected theorem sub_lt_left_of_lt_add {n k m : Nat} (H : n ≤ k) (h : k < n + m) : k - n < m 
Arguments: {n k m : Nat} (H : n ≤ k) (h : k < n + m)
Goal: k - n < m
-- Nat.sub_lt_right_of_lt_add
protected theorem sub_lt_right_of_lt_add {n k m : Nat} (H : n ≤ k) (h : k < m + n) : k - n < m 
Arguments: {n k m : Nat} (H : n ≤ k) (h : k < m + n)
Goal: k - n < m
-- Nat.le_of_sub_eq_zero
protected theorem le_of_sub_eq_zero : ∀ {n m}, n - m = 0 → n ≤ m
  
Arguments: {n m : Nat}
Goal: n - m = 0 → n ≤ m
-- Nat.le_of_sub_le_sub_right
protected theorem le_of_sub_le_sub_right : ∀ {n m k : Nat}, k ≤ m → n - k ≤ m - k → n ≤ m
  
Arguments: {n m k : Nat}
Goal: k ≤ m → n - k ≤ m - k → n ≤ m
-- Nat.sub_le_sub_iff_right
protected theorem sub_le_sub_iff_right {n : Nat} (h : k ≤ m) : n - k ≤ m - k ↔ n ≤ m 
Arguments: {k m n : Nat} (h : k ≤ m)
Goal: n - k ≤ m - k ↔ n ≤ m
-- Nat.sub_eq_iff_eq_add
protected theorem sub_eq_iff_eq_add {c : Nat} (h : b ≤ a) : a - b = c ↔ a = c + b 
Arguments: {b a c : Nat} (h : b ≤ a)
Goal: a - b = c ↔ a = c + b
-- Nat.sub_eq_iff_eq_add'
protected theorem sub_eq_iff_eq_add' {c : Nat} (h : b ≤ a) : a - b = c ↔ a = b + c 
Arguments: {b a c : Nat} (h : b ≤ a)
Goal: a - b = c ↔ a = b + c
-- Nat.pred_mul
theorem pred_mul (n m : Nat) : pred n * m = n * m - m 
Arguments: (n m : Nat)
Goal: n.pred * m = n * m - m
-- Nat.sub_one_mul
protected theorem sub_one_mul  (n m : Nat) : (n - 1) * m = n * m - m 
Arguments: (n m : Nat)
Goal: (n - 1) * m = n * m - m
-- Nat.mul_pred
theorem mul_pred (n m : Nat) : n * pred m = n * m - n 
Arguments: (n m : Nat)
Goal: n * m.pred = n * m - n
-- Nat.mul_sub_one
theorem mul_sub_one (n m : Nat) : n * (m - 1) = n * m - n 
Arguments: (n m : Nat)
Goal: n * (m - 1) = n * m - n
-- Nat.mul_sub_right_distrib
protected theorem mul_sub_right_distrib (n m k : Nat) : (n - m) * k = n * k - m * k 
Arguments: (n m k : Nat)
Goal: (n - m) * k = n * k - m * k
-- Nat.mul_sub_left_distrib
protected theorem mul_sub_left_distrib (n m k : Nat) : n * (m - k) = n * m - n * k 
Arguments: (n m k : Nat)
Goal: n * (m - k) = n * m - n * k
-- Nat.not_le_eq
theorem not_le_eq (a b : Nat) : (¬ (a ≤ b)) = (b + 1 ≤ a) 
Arguments: (a b : Nat)
Goal: (¬a ≤ b) = (b + 1 ≤ a)
-- Nat.not_ge_eq
theorem not_ge_eq (a b : Nat) : (¬ (a ≥ b)) = (a + 1 ≤ b) 
Arguments: (a b : Nat)
Goal: (¬a ≥ b) = (a + 1 ≤ b)
-- Nat.not_lt_eq
theorem not_lt_eq (a b : Nat) : (¬ (a < b)) = (b ≤ a) 
Arguments: (a b : Nat)
Goal: (¬a < b) = (b ≤ a)
-- Nat.not_gt_eq
theorem not_gt_eq (a b : Nat) : (¬ (a > b)) = (a ≤ b) 
Arguments: (a b : Nat)
Goal: (¬a > b) = (a ≤ b)
-- Nat.fold_eq_foldTR
@[csimp] theorem fold_eq_foldTR : @fold = @foldTR 
Goal: @Nat.fold = @Nat.foldTR
-- Nat.fold_eq_foldTR.go
@[csimp] theorem fold_eq_foldTR : @fold = @foldTR 
Arguments: (α : Type u_1) (f : Nat → α → α) (init : α) (m n : Nat)
Goal: Nat.foldTR.loop f (m + n) m (Nat.fold f n init) = Nat.fold f (m + n) init
-- Nat.any_eq_anyTR.go
@[csimp] theorem any_eq_anyTR : @any = @anyTR 
Arguments: (f : Nat → Bool) (m n : Nat)
Goal: (Nat.any f n || Nat.anyTR.loop f (m + n) m) = Nat.any f (m + n)
-- Nat.any_eq_anyTR
@[csimp] theorem any_eq_anyTR : @any = @anyTR 
Goal: Nat.any = Nat.anyTR
-- Nat.all_eq_allTR.go
@[csimp] theorem all_eq_allTR : @all = @allTR 
Arguments: (f : Nat → Bool) (m n : Nat)
Goal: (Nat.all f n && Nat.allTR.loop f (m + n) m) = Nat.all f (m + n)
-- Nat.all_eq_allTR
@[csimp] theorem all_eq_allTR : @all = @allTR 
Goal: Nat.all = Nat.allTR
-- Nat.repeat_eq_repeatTR.go
@[csimp] theorem repeat_eq_repeatTR : @repeat = @repeatTR 
Arguments: (α : Type u_1) (f : α → α) (init : α) (m n : Nat)
Goal: Nat.repeatTR.loop f m (Nat.repeat f n init) = Nat.repeat f (m + n) init
-- Nat.repeat_eq_repeatTR
@[csimp] theorem repeat_eq_repeatTR : @repeat = @repeatTR 
Goal: @Nat.repeat = @Nat.repeatTR
-- Nat.SOM.Mon.append_denote
theorem Mon.append_denote (ctx : Context) (m₁ m₂ : Mon) : (m₁ ++ m₂).denote ctx = m₁.denote ctx * m₂.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (m₁ m₂ : Nat.SOM.Mon)
Goal: Nat.SOM.Mon.denote ctx (m₁ ++ m₂) = Nat.SOM.Mon.denote ctx m₁ * Nat.SOM.Mon.denote ctx m₂
-- Nat.SOM.Mon.mul_denote.go
theorem Mon.mul_denote (ctx : Context) (m₁ m₂ : Mon) : (m₁.mul m₂).denote ctx = m₁.denote ctx * m₂.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (fuel : Nat) (m₁ m₂ : Nat.SOM.Mon)
Goal: Nat.SOM.Mon.denote ctx (Nat.SOM.Mon.mul.go fuel m₁ m₂) = Nat.SOM.Mon.denote ctx m₁ * Nat.SOM.Mon.denote ctx m₂
-- Nat.SOM.Mon.mul_denote
theorem Mon.mul_denote (ctx : Context) (m₁ m₂ : Mon) : (m₁.mul m₂).denote ctx = m₁.denote ctx * m₂.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (m₁ m₂ : Nat.SOM.Mon)
Goal: Nat.SOM.Mon.denote ctx (m₁.mul m₂) = Nat.SOM.Mon.denote ctx m₁ * Nat.SOM.Mon.denote ctx m₂
-- Nat.SOM.Poly.append_denote
theorem Poly.append_denote (ctx : Context) (p₁ p₂ : Poly) : (p₁ ++ p₂).denote ctx = p₁.denote ctx + p₂.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (p₁ p₂ : Nat.SOM.Poly)
Goal: Nat.SOM.Poly.denote ctx (p₁ ++ p₂) = Nat.SOM.Poly.denote ctx p₁ + Nat.SOM.Poly.denote ctx p₂
-- Nat.SOM.Poly.add_denote.go
theorem Poly.add_denote (ctx : Context) (p₁ p₂ : Poly) : (p₁.add p₂).denote ctx = p₁.denote ctx + p₂.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (fuel : Nat) (p₁ p₂ : Nat.SOM.Poly)
Goal: Nat.SOM.Poly.denote ctx (Nat.SOM.Poly.add.go fuel p₁ p₂) = Nat.SOM.Poly.denote ctx p₁ + Nat.SOM.Poly.denote ctx p₂
-- Nat.SOM.Poly.add_denote
theorem Poly.add_denote (ctx : Context) (p₁ p₂ : Poly) : (p₁.add p₂).denote ctx = p₁.denote ctx + p₂.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (p₁ p₂ : Nat.SOM.Poly)
Goal: Nat.SOM.Poly.denote ctx (p₁.add p₂) = Nat.SOM.Poly.denote ctx p₁ + Nat.SOM.Poly.denote ctx p₂
-- Nat.SOM.Poly.denote_insertSorted
theorem Poly.denote_insertSorted (ctx : Context) (k : Nat) (m : Mon) (p : Poly) : (p.insertSorted k m).denote ctx = p.denote ctx + k * m.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (k : Nat) (m : Nat.SOM.Mon) (p : Nat.SOM.Poly)
Goal: Nat.SOM.Poly.denote ctx (Nat.SOM.Poly.insertSorted k m p) = Nat.SOM.Poly.denote ctx p + k * Nat.SOM.Mon.denote ctx m
-- Nat.SOM.Poly.mulMon_denote.go
theorem Poly.mulMon_denote (ctx : Context) (p : Poly) (k : Nat) (m : Mon) : (p.mulMon k m).denote ctx = p.denote ctx * k * m.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (k : Nat) (m : Nat.SOM.Mon) (p acc : Nat.SOM.Poly)
Goal: Nat.SOM.Poly.denote ctx (Nat.SOM.Poly.mulMon.go k m p acc) =
  Nat.SOM.Poly.denote ctx acc + Nat.SOM.Poly.denote ctx p * k * Nat.SOM.Mon.denote ctx m
-- Nat.SOM.Poly.mulMon_denote
theorem Poly.mulMon_denote (ctx : Context) (p : Poly) (k : Nat) (m : Mon) : (p.mulMon k m).denote ctx = p.denote ctx * k * m.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (p : Nat.SOM.Poly) (k : Nat) (m : Nat.SOM.Mon)
Goal: Nat.SOM.Poly.denote ctx (p.mulMon k m) = Nat.SOM.Poly.denote ctx p * k * Nat.SOM.Mon.denote ctx m
-- Nat.SOM.Poly.mul_denote.go
theorem Poly.mul_denote (ctx : Context) (p₁ p₂ : Poly) : (p₁.mul p₂).denote ctx = p₁.denote ctx * p₂.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (p₂ p₁ acc : Nat.SOM.Poly)
Goal: Nat.SOM.Poly.denote ctx (Nat.SOM.Poly.mul.go p₂ p₁ acc) =
  Nat.SOM.Poly.denote ctx acc + Nat.SOM.Poly.denote ctx p₁ * Nat.SOM.Poly.denote ctx p₂
-- Nat.SOM.Poly.mul_denote
theorem Poly.mul_denote (ctx : Context) (p₁ p₂ : Poly) : (p₁.mul p₂).denote ctx = p₁.denote ctx * p₂.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (p₁ p₂ : Nat.SOM.Poly)
Goal: Nat.SOM.Poly.denote ctx (p₁.mul p₂) = Nat.SOM.Poly.denote ctx p₁ * Nat.SOM.Poly.denote ctx p₂
-- Nat.SOM.Expr.toPoly_denote
theorem Expr.toPoly_denote (ctx : Context) (e : Expr) : e.toPoly.denote ctx = e.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (e : Nat.SOM.Expr)
Goal: Nat.SOM.Poly.denote ctx e.toPoly = Nat.SOM.Expr.denote ctx e
-- Nat.SOM.Expr.eq_of_toPoly_eq
theorem Expr.eq_of_toPoly_eq (ctx : Context) (a b : Expr) (h : a.toPoly == b.toPoly) : a.denote ctx = b.denote ctx 
Arguments: (ctx : Nat.Linear.Context) (a b : Nat.SOM.Expr) (h : (a.toPoly == b.toPoly) = true)
Goal: Nat.SOM.Expr.denote ctx a = Nat.SOM.Expr.denote ctx b
-- Subarray.stop_le_array_size
structure Subarray (α : Type u)  where
  array : Array α
  start : Nat
  stop : Nat
  start_le_stop : start ≤ stop
  stop_le_array_size : stop ≤ array.size
Arguments: {α : Type u} (self : Subarray α)
Goal: self.stop ≤ self.array.size
-- Subarray.start_le_stop
structure Subarray (α : Type u)  where
  array : Array α
  start : Nat
  stop : Nat
  start_le_stop : start ≤ stop
  stop_le_array_size : stop ≤ array.size
Arguments: {α : Type u} (self : Subarray α)
Goal: self.start ≤ self.stop
-- Subarray.h₁
@[deprecated Subarray.start_le_stop (since := "2024-04-13")]
theorem Subarray.h₁ (s : Subarray α) : s.start ≤ s.stop 
Arguments: {α : Type u_1} (s : Subarray α)
Goal: s.start ≤ s.stop
-- Subarray.h₂
@[deprecated Subarray.stop_le_array_size (since := "2024-04-13")]
theorem Subarray.h₂ (s : Subarray α) : s.stop ≤ s.array.size 
Arguments: {α : Type u_1} (s : Subarray α)
Goal: s.stop ≤ s.array.size
-- Subarray.size_le_array_size
theorem size_le_array_size {s : Subarray α} : s.size ≤ s.array.size 
Arguments: {α : Type u_1} {s : Subarray α}
Goal: s.size ≤ s.array.size
-- Char.isValidUInt32
theorem isValidUInt32 (n : Nat) (h : isValidCharNat n) : n < UInt32.size 
Arguments: (n : Nat) (h : Char.isValidCharNat n)
Goal: n < UInt32.size
-- Char.isValidChar_of_isValidCharNat
theorem isValidChar_of_isValidCharNat (n : Nat) (h : isValidCharNat n) : isValidChar (UInt32.ofNat' n (isValidUInt32 n h)) 
Arguments: (n : Nat) (h : Char.isValidCharNat n)
Goal: isValidChar (UInt32.ofNat' n ⋯)
-- Char.isValidChar_zero
theorem isValidChar_zero : isValidChar 0 
Goal: isValidChar 0
-- Array.Mem.val
-- NB: This is defined as a structure rather than a plain def so that a lemma
-- like `sizeOf_lt_of_mem` will not apply with no actual arrays around.
structure Mem (a : α) (as : Array α) : Prop where
  val : a ∈ as.data
Arguments: {α : Type u_1} {a : α} {as : Array α} (self : Array.Mem a as)
Goal: a ∈ as.data
-- Array.sizeOf_lt_of_mem
theorem sizeOf_lt_of_mem [SizeOf α] {as : Array α} (h : a ∈ as) : sizeOf a < sizeOf as 
Arguments: {α : Type u_1} {a : α} [SizeOf α] {as : Array α} (h : a ∈ as)
Goal: sizeOf a < sizeOf as
-- Array.sizeOf_get
@[simp] theorem sizeOf_get [SizeOf α] (as : Array α) (i : Fin as.size) : sizeOf (as.get i) < sizeOf as 
Arguments: {α : Type u_1} [SizeOf α] (as : Array α) (i : Fin as.size)
Goal: sizeOf (as.get i) < sizeOf as
-- Array.sizeOf_getElem
@[simp] theorem sizeOf_getElem [SizeOf α] (as : Array α) (i : Nat) (h : i < as.size) :
  sizeOf (as[i]'h) < sizeOf as 
Arguments: {α : Type u_1} [SizeOf α] (as : Array α) (i : Nat) (h : i < as.size)
Goal: sizeOf as[i] < sizeOf as
-- Fin.size_pos
theorem size_pos (i : Fin n) : 0 < n 
Arguments: {n : Nat} (i : Fin n)
Goal: 0 < n
-- Fin.mod_def
theorem mod_def (a m : Fin n) : a % m = Fin.mk (a % m) (Nat.lt_of_le_of_lt (Nat.mod_le _ _) a.2) 
Arguments: {n : Nat} (a m : Fin n)
Goal: a % m = ⟨↑a % ↑m, ⋯⟩
-- Fin.mul_def
theorem mul_def (a b : Fin n) : a * b = Fin.mk ((a * b) % n) (Nat.mod_lt _ a.size_pos) 
Arguments: {n : Nat} (a b : Fin n)
Goal: a * b = ⟨↑a * ↑b % n, ⋯⟩
-- Fin.sub_def
theorem sub_def (a b : Fin n) : a - b = Fin.mk (((n - b) + a) % n) (Nat.mod_lt _ a.size_pos) 
Arguments: {n : Nat} (a b : Fin n)
Goal: a - b = ⟨(n - ↑b + ↑a) % n, ⋯⟩
-- Fin.size_pos'
theorem size_pos' : ∀ [Nonempty (Fin n)], 0 < n 
Arguments: {n : Nat} [Nonempty (Fin n)]
Goal: 0 < n
-- Fin.is_lt
@[simp] theorem is_lt (a : Fin n) : (a : Nat) < n 
Arguments: {n : Nat} (a : Fin n)
Goal: ↑a < n
-- Fin.pos_iff_nonempty
theorem pos_iff_nonempty {n : Nat} : 0 < n ↔ Nonempty (Fin n) 
Arguments: {n : Nat}
Goal: 0 < n ↔ Nonempty (Fin n)
-- Fin.eta
@[simp] protected theorem eta (a : Fin n) (h : a < n) : (⟨a, h⟩ : Fin n) = a 
Arguments: {n : Nat} (a : Fin n) (h : ↑a < n)
Goal: ⟨↑a, h⟩ = a
-- Fin.ext
@[ext] theorem ext {a b : Fin n} (h : (a : Nat) = b) : a = b 
Arguments: {n : Nat} {a b : Fin n} (h : ↑a = ↑b)
Goal: a = b
-- Fin.ext_iff
theorem ext_iff {a b : Fin n} : a = b ↔ a.1 = b.1 
Arguments: {n : Nat} {a b : Fin n}
Goal: a = b ↔ ↑a = ↑b
-- Fin.val_ne_iff
theorem val_ne_iff {a b : Fin n} : a.1 ≠ b.1 ↔ a ≠ b 
Arguments: {n : Nat} {a b : Fin n}
Goal: ↑a ≠ ↑b ↔ a ≠ b
-- Fin.forall_iff
theorem forall_iff {p : Fin n → Prop} : (∀ i, p i) ↔ ∀ i h, p ⟨i, h⟩ 
Arguments: {n : Nat} {p : Fin n → Prop}
Goal: (∀ (i : Fin n), p i) ↔ ∀ (i : Nat) (h : i < n), p ⟨i, h⟩
-- Fin.mk.inj_iff
protected theorem mk.inj_iff {n a b : Nat} {ha : a < n} {hb : b < n} :
    (⟨a, ha⟩ : Fin n) = ⟨b, hb⟩ ↔ a = b 
Arguments: {n a b : Nat} {ha : a < n} {hb : b < n}
Goal: ⟨a, ha⟩ = ⟨b, hb⟩ ↔ a = b
-- Fin.val_mk
theorem val_mk {m n : Nat} (h : m < n) : (⟨m, h⟩ : Fin n).val = m 
Arguments: {m n : Nat} (h : m < n)
Goal: ↑⟨m, h⟩ = m
-- Fin.eq_mk_iff_val_eq
theorem eq_mk_iff_val_eq {a : Fin n} {k : Nat} {hk : k < n} :
    a = ⟨k, hk⟩ ↔ (a : Nat) = k 
Arguments: {n : Nat} {a : Fin n} {k : Nat} {hk : k < n}
Goal: a = ⟨k, hk⟩ ↔ ↑a = k
-- Fin.mk_val
theorem mk_val (i : Fin n) : (⟨i, i.isLt⟩ : Fin n) = i 
Arguments: {n : Nat} (i : Fin n)
Goal: ⟨↑i, ⋯⟩ = i
-- Fin.val_ofNat'
@[simp] theorem val_ofNat' (a : Nat) (is_pos : n > 0) :
  (Fin.ofNat' a is_pos).val = a % n 
Arguments: {n : Nat} (a : Nat) (is_pos : n > 0)
Goal: ↑(Fin.ofNat' a is_pos) = a % n