ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.join_eq_joinTR
@[csimp] theorem join_eq_joinTR : @join = @joinTR 
Goal: @List.join = @List.joinTR
-- List.replicateTR_loop_replicate_eq
theorem replicateTR_loop_replicate_eq (a : α) (m n : Nat) :
  replicateTR.loop a n (replicate m a) = replicate (n + m) a 
Arguments: {α : Type u_1} (a : α) (m n : Nat)
Goal: List.replicateTR.loop a n (List.replicate m a) = List.replicate (n + m) a
-- List.replicateTR_loop_eq
theorem replicateTR_loop_eq : ∀ n, replicateTR.loop a n acc = replicate n a ++ acc
  
Goal: ∀ {α : Type u_1} {a : α} {acc : List α} (n : Nat), List.replicateTR.loop a n acc = List.replicate n a ++ acc
-- List.replicate_eq_replicateTR
@[csimp] theorem replicate_eq_replicateTR : @List.replicate = @List.replicateTR 
Goal: @List.replicate = @List.replicateTR
-- List.take_eq_takeTR
@[csimp] theorem take_eq_takeTR : @take = @takeTR 
Goal: @List.take = @List.takeTR
-- List.takeWhile_eq_takeWhileTR
@[csimp] theorem takeWhile_eq_takeWhileTR : @takeWhile = @takeWhileTR 
Goal: @List.takeWhile = @List.takeWhileTR
-- List.dropLast_eq_dropLastTR
@[csimp] theorem dropLast_eq_dropLastTR : @dropLast = @dropLastTR 
Goal: @List.dropLast = @List.dropLastTR
-- List.replace_eq_replaceTR
@[csimp] theorem replace_eq_replaceTR : @List.replace = @replaceTR 
Goal: @List.replace = @List.replaceTR
-- List.erase_eq_eraseTR
@[csimp] theorem erase_eq_eraseTR : @List.erase = @eraseTR 
Goal: @List.erase = @List.eraseTR
-- List.eraseIdx_eq_eraseIdxTR
@[csimp] theorem eraseIdx_eq_eraseIdxTR : @eraseIdx = @eraseIdxTR 
Goal: @List.eraseIdx = @List.eraseIdxTR
-- List.zipWith_eq_zipWithTR.go
@[csimp] theorem zipWith_eq_zipWithTR : @zipWith = @zipWithTR 
Arguments: (α : Type u_3) (β : Type u_2) (γ : Type u_1) (f : α → β → γ) (as : List α) (bs : List β) (acc : Array γ)
Goal: List.zipWithTR.go f as bs acc = acc.data ++ List.zipWith f as bs
-- List.zipWith_eq_zipWithTR
@[csimp] theorem zipWith_eq_zipWithTR : @zipWith = @zipWithTR 
Goal: @List.zipWith = @List.zipWithTR
-- List.unzip_eq_unzipTR
@[csimp] theorem unzip_eq_unzipTR : @unzip = @unzipTR 
Goal: @List.unzip = @List.unzipTR
-- List.iota_eq_iotaTR
@[csimp]
theorem iota_eq_iotaTR : @iota = @iotaTR 
Goal: List.iota = List.iotaTR
-- List.enumFrom_eq_enumFromTR.go
@[csimp] theorem enumFrom_eq_enumFromTR : @enumFrom = @enumFromTR 
Arguments: (α : Type u_1) (l : List α) (n : Nat)
Goal: let f := fun a x =>
  match x with
  | (n, acc) => (n - 1, (n - 1, a) :: acc);
List.foldr f (n + l.length, []) l = (n, List.enumFrom n l)
-- List.enumFrom_eq_enumFromTR
@[csimp] theorem enumFrom_eq_enumFromTR : @enumFrom = @enumFromTR 
Goal: @List.enumFrom = @List.enumFromTR
-- List.intersperse_eq_intersperseTR
@[csimp] theorem intersperse_eq_intersperseTR : @intersperse = @intersperseTR 
Goal: @List.intersperse = @List.intersperseTR
-- List.intercalate_eq_intercalateTR.go
@[csimp] theorem intercalate_eq_intercalateTR : @intercalate = @intercalateTR 
Arguments: (α : Type u_1) (sep : List α) {acc : Array α} {x : List α} (xs : List (List α))
Goal: List.intercalateTR.go (List.toArray sep) x xs acc = acc.data ++ (List.intersperse sep (x :: xs)).join
-- List.intercalate_eq_intercalateTR
@[csimp] theorem intercalate_eq_intercalateTR : @intercalate = @intercalateTR 
Goal: @List.intercalate = @List.intercalateTR
-- UInt8.mod_def
declare_uint_theorems UInt8
Arguments: (a b : UInt8)
Goal: a % b = { val := a.val % b.val }
-- UInt8.not_le
declare_uint_theorems UInt8
Arguments: {a b : UInt8}
Goal: ¬a ≤ b ↔ b < a
-- UInt8.lt_trans
declare_uint_theorems UInt8
Arguments: {a b c : UInt8}
Goal: a < b → b < c → a < c
-- UInt8.one_def
declare_uint_theorems UInt8
Goal: 1 = { val := 1 }
-- UInt8.modn_lt
declare_uint_theorems UInt8
Arguments: {m : Nat} (u : UInt8)
Goal: m > 0 → (u % m).toNat < m
-- UInt8.mul_def
declare_uint_theorems UInt8
Arguments: (a b : UInt8)
Goal: a * b = { val := a.val * b.val }
-- UInt8.sub_def
declare_uint_theorems UInt8
Arguments: (a b : UInt8)
Goal: a - b = { val := a.val - b.val }
-- UInt8.val_eq_of_lt
declare_uint_theorems UInt8
Arguments: {a : Nat}
Goal: a < UInt8.size → ↑(UInt8.ofNat a).val = a
-- UInt8.zero_toNat
declare_uint_theorems UInt8
Goal: UInt8.toNat 0 = 0
-- UInt8.modn_toNat
declare_uint_theorems UInt8
Arguments: (a : UInt8) (b : Nat)
Goal: (a.modn b).toNat = a.toNat % b
-- UInt8.le_trans
declare_uint_theorems UInt8
Arguments: {a b c : UInt8}
Goal: a ≤ b → b ≤ c → a ≤ c
-- UInt8.lt_asymm
declare_uint_theorems UInt8
Arguments: {a b : UInt8} (h : a < b)
Goal: ¬b < a
-- UInt8.lt_irrefl
declare_uint_theorems UInt8
Arguments: (a : UInt8)
Goal: ¬a < a
-- UInt8.le_refl
declare_uint_theorems UInt8
Arguments: (a : UInt8)
Goal: a ≤ a
-- UInt8.not_lt
declare_uint_theorems UInt8
Arguments: {a b : UInt8}
Goal: ¬a < b ↔ b ≤ a
-- UInt8.ne_of_lt
declare_uint_theorems UInt8
Arguments: {a b : UInt8} (h : a < b)
Goal: a ≠ b
-- UInt8.val_eq_of_eq
declare_uint_theorems UInt8
Arguments: {a b : UInt8} (h : a = b)
Goal: a.val = b.val
-- UInt8.eq_of_val_eq
declare_uint_theorems UInt8
Arguments: {a b : UInt8} (h : a.val = b.val)
Goal: a = b
-- UInt8.add_def
declare_uint_theorems UInt8
Arguments: (a b : UInt8)
Goal: a + b = { val := a.val + b.val }
-- UInt8.mk_val_eq
declare_uint_theorems UInt8
Arguments: (a : UInt8)
Goal: { val := a.val } = a
-- UInt8.lt_def
declare_uint_theorems UInt8
Arguments: {a b : UInt8}
Goal: a < b ↔ a.val < b.val
-- UInt8.div_toNat
declare_uint_theorems UInt8
Arguments: (a b : UInt8)
Goal: (a / b).toNat = a.toNat / b.toNat
-- UInt8.ne_of_val_ne
declare_uint_theorems UInt8
Arguments: {a b : UInt8} (h : a.val ≠ b.val)
Goal: a ≠ b
-- UInt8.lt_iff_val_lt_val
declare_uint_theorems UInt8
Arguments: {a b : UInt8}
Goal: a < b ↔ a.val < b.val
-- UInt8.mod_lt
declare_uint_theorems UInt8
Arguments: (a b : UInt8) (h : 0 < b)
Goal: a % b < b
-- UInt8.mod_toNat
declare_uint_theorems UInt8
Arguments: (a b : UInt8)
Goal: (a % b).toNat = a.toNat % b.toNat
-- UInt8.le_def
declare_uint_theorems UInt8
Arguments: {a b : UInt8}
Goal: a ≤ b ↔ a.val ≤ b.val
-- UInt8.toNat.inj
declare_uint_theorems UInt8
Arguments: {a b : UInt8}
Goal: a.toNat = b.toNat → a = b
-- UInt8.le_total
declare_uint_theorems UInt8
Arguments: (a b : UInt8)
Goal: a ≤ b ∨ b ≤ a
-- UInt8.zero_def
declare_uint_theorems UInt8
Goal: 0 = { val := 0 }
-- UInt16.sub_def
declare_uint_theorems UInt16
Arguments: (a b : UInt16)
Goal: a - b = { val := a.val - b.val }
-- UInt16.le_trans
declare_uint_theorems UInt16
Arguments: {a b c : UInt16}
Goal: a ≤ b → b ≤ c → a ≤ c
-- UInt16.mk_val_eq
declare_uint_theorems UInt16
Arguments: (a : UInt16)
Goal: { val := a.val } = a
-- UInt16.mod_toNat
declare_uint_theorems UInt16
Arguments: (a b : UInt16)
Goal: (a % b).toNat = a.toNat % b.toNat
-- UInt16.mod_def
declare_uint_theorems UInt16
Arguments: (a b : UInt16)
Goal: a % b = { val := a.val % b.val }
-- UInt16.modn_toNat
declare_uint_theorems UInt16
Arguments: (a : UInt16) (b : Nat)
Goal: (a.modn b).toNat = a.toNat % b
-- UInt16.lt_trans
declare_uint_theorems UInt16
Arguments: {a b c : UInt16}
Goal: a < b → b < c → a < c
-- UInt16.le_refl
declare_uint_theorems UInt16
Arguments: (a : UInt16)
Goal: a ≤ a
-- UInt16.mul_def
declare_uint_theorems UInt16
Arguments: (a b : UInt16)
Goal: a * b = { val := a.val * b.val }
-- UInt16.not_lt
declare_uint_theorems UInt16
Arguments: {a b : UInt16}
Goal: ¬a < b ↔ b ≤ a
-- UInt16.le_def
declare_uint_theorems UInt16
Arguments: {a b : UInt16}
Goal: a ≤ b ↔ a.val ≤ b.val
-- UInt16.not_le
declare_uint_theorems UInt16
Arguments: {a b : UInt16}
Goal: ¬a ≤ b ↔ b < a
-- UInt16.zero_toNat
declare_uint_theorems UInt16
Goal: UInt16.toNat 0 = 0
-- UInt16.lt_def
declare_uint_theorems UInt16
Arguments: {a b : UInt16}
Goal: a < b ↔ a.val < b.val
-- UInt16.toNat.inj
declare_uint_theorems UInt16
Arguments: {a b : UInt16}
Goal: a.toNat = b.toNat → a = b
-- UInt16.div_toNat
declare_uint_theorems UInt16
Arguments: (a b : UInt16)
Goal: (a / b).toNat = a.toNat / b.toNat
-- UInt16.val_eq_of_lt
declare_uint_theorems UInt16
Arguments: {a : Nat}
Goal: a < UInt16.size → ↑(UInt16.ofNat a).val = a
-- UInt16.lt_iff_val_lt_val
declare_uint_theorems UInt16
Arguments: {a b : UInt16}
Goal: a < b ↔ a.val < b.val
-- UInt16.mod_lt
declare_uint_theorems UInt16
Arguments: (a b : UInt16) (h : 0 < b)
Goal: a % b < b
-- UInt16.one_def
declare_uint_theorems UInt16
Goal: 1 = { val := 1 }
-- UInt16.le_total
declare_uint_theorems UInt16
Arguments: (a b : UInt16)
Goal: a ≤ b ∨ b ≤ a
-- UInt16.ne_of_lt
declare_uint_theorems UInt16
Arguments: {a b : UInt16} (h : a < b)
Goal: a ≠ b
-- UInt16.lt_asymm
declare_uint_theorems UInt16
Arguments: {a b : UInt16} (h : a < b)
Goal: ¬b < a
-- UInt16.add_def
declare_uint_theorems UInt16
Arguments: (a b : UInt16)
Goal: a + b = { val := a.val + b.val }
-- UInt16.modn_lt
declare_uint_theorems UInt16
Arguments: {m : Nat} (u : UInt16)
Goal: m > 0 → (u % m).toNat < m
-- UInt16.ne_of_val_ne
declare_uint_theorems UInt16
Arguments: {a b : UInt16} (h : a.val ≠ b.val)
Goal: a ≠ b
-- UInt16.eq_of_val_eq
declare_uint_theorems UInt16
Arguments: {a b : UInt16} (h : a.val = b.val)
Goal: a = b
-- UInt16.lt_irrefl
declare_uint_theorems UInt16
Arguments: (a : UInt16)
Goal: ¬a < a
-- UInt16.val_eq_of_eq
declare_uint_theorems UInt16
Arguments: {a b : UInt16} (h : a = b)
Goal: a.val = b.val
-- UInt16.zero_def
declare_uint_theorems UInt16
Goal: 0 = { val := 0 }
-- UInt32.mk_val_eq
declare_uint_theorems UInt32
Arguments: (a : UInt32)
Goal: { val := a.val } = a
-- UInt32.ne_of_lt
declare_uint_theorems UInt32
Arguments: {a b : UInt32} (h : a < b)
Goal: a ≠ b
-- UInt32.add_def
declare_uint_theorems UInt32
Arguments: (a b : UInt32)
Goal: a + b = { val := a.val + b.val }
-- UInt32.lt_asymm
declare_uint_theorems UInt32
Arguments: {a b : UInt32} (h : a < b)
Goal: ¬b < a
-- UInt32.lt_def
declare_uint_theorems UInt32
Arguments: {a b : UInt32}
Goal: a < b ↔ a.val < b.val
-- UInt32.modn_toNat
declare_uint_theorems UInt32
Arguments: (a : UInt32) (b : Nat)
Goal: (a.modn b).toNat = a.toNat % b
-- UInt32.zero_toNat
declare_uint_theorems UInt32
Goal: UInt32.toNat 0 = 0
-- UInt32.le_trans
declare_uint_theorems UInt32
Arguments: {a b c : UInt32}
Goal: a ≤ b → b ≤ c → a ≤ c
-- UInt32.not_le
declare_uint_theorems UInt32
Arguments: {a b : UInt32}
Goal: ¬a ≤ b ↔ b < a
-- UInt32.le_refl
declare_uint_theorems UInt32
Arguments: (a : UInt32)
Goal: a ≤ a
-- UInt32.lt_trans
declare_uint_theorems UInt32
Arguments: {a b c : UInt32}
Goal: a < b → b < c → a < c
-- UInt32.mod_toNat
declare_uint_theorems UInt32
Arguments: (a b : UInt32)
Goal: (a % b).toNat = a.toNat % b.toNat
-- UInt32.modn_lt
declare_uint_theorems UInt32
Arguments: {m : Nat} (u : UInt32)
Goal: m > 0 → (u % m).toNat < m
-- UInt32.div_toNat
declare_uint_theorems UInt32
Arguments: (a b : UInt32)
Goal: (a / b).toNat = a.toNat / b.toNat
-- UInt32.zero_def
declare_uint_theorems UInt32
Goal: 0 = { val := 0 }
-- UInt32.lt_iff_val_lt_val
declare_uint_theorems UInt32
Arguments: {a b : UInt32}
Goal: a < b ↔ a.val < b.val
-- UInt32.lt_irrefl
declare_uint_theorems UInt32
Arguments: (a : UInt32)
Goal: ¬a < a
-- UInt32.one_def
declare_uint_theorems UInt32
Goal: 1 = { val := 1 }
-- UInt32.mod_lt
declare_uint_theorems UInt32
Arguments: (a b : UInt32) (h : 0 < b)
Goal: a % b < b
-- UInt32.toNat.inj
declare_uint_theorems UInt32
Arguments: {a b : UInt32}
Goal: a.toNat = b.toNat → a = b
-- UInt32.val_eq_of_lt
declare_uint_theorems UInt32
Arguments: {a : Nat}
Goal: a < UInt32.size → ↑(UInt32.ofNat a).val = a
-- UInt32.ne_of_val_ne
declare_uint_theorems UInt32
Arguments: {a b : UInt32} (h : a.val ≠ b.val)
Goal: a ≠ b
-- UInt32.le_def
declare_uint_theorems UInt32
Arguments: {a b : UInt32}
Goal: a ≤ b ↔ a.val ≤ b.val
-- UInt32.eq_of_val_eq
declare_uint_theorems UInt32
Arguments: {a b : UInt32} (h : a.val = b.val)
Goal: a = b
-- UInt32.mod_def
declare_uint_theorems UInt32
Arguments: (a b : UInt32)
Goal: a % b = { val := a.val % b.val }
-- UInt32.sub_def
declare_uint_theorems UInt32
Arguments: (a b : UInt32)
Goal: a - b = { val := a.val - b.val }
-- UInt32.mul_def
declare_uint_theorems UInt32
Arguments: (a b : UInt32)
Goal: a * b = { val := a.val * b.val }
-- UInt32.val_eq_of_eq
declare_uint_theorems UInt32
Arguments: {a b : UInt32} (h : a = b)
Goal: a.val = b.val
-- UInt32.not_lt
declare_uint_theorems UInt32
Arguments: {a b : UInt32}
Goal: ¬a < b ↔ b ≤ a
-- UInt32.le_total
declare_uint_theorems UInt32
Arguments: (a b : UInt32)
Goal: a ≤ b ∨ b ≤ a
-- UInt64.toNat.inj
declare_uint_theorems UInt64
Arguments: {a b : UInt64}
Goal: a.toNat = b.toNat → a = b
-- UInt64.sub_def
declare_uint_theorems UInt64
Arguments: (a b : UInt64)
Goal: a - b = { val := a.val - b.val }
-- UInt64.ne_of_lt
declare_uint_theorems UInt64
Arguments: {a b : UInt64} (h : a < b)
Goal: a ≠ b
-- UInt64.eq_of_val_eq
declare_uint_theorems UInt64
Arguments: {a b : UInt64} (h : a.val = b.val)
Goal: a = b
-- UInt64.mod_toNat
declare_uint_theorems UInt64
Arguments: (a b : UInt64)
Goal: (a % b).toNat = a.toNat % b.toNat
-- UInt64.le_total
declare_uint_theorems UInt64
Arguments: (a b : UInt64)
Goal: a ≤ b ∨ b ≤ a
-- UInt64.mk_val_eq
declare_uint_theorems UInt64
Arguments: (a : UInt64)
Goal: { val := a.val } = a
-- UInt64.lt_trans
declare_uint_theorems UInt64
Arguments: {a b c : UInt64}
Goal: a < b → b < c → a < c
-- UInt64.le_def
declare_uint_theorems UInt64
Arguments: {a b : UInt64}
Goal: a ≤ b ↔ a.val ≤ b.val
-- UInt64.zero_def
declare_uint_theorems UInt64
Goal: 0 = { val := 0 }
-- UInt64.val_eq_of_eq
declare_uint_theorems UInt64
Arguments: {a b : UInt64} (h : a = b)
Goal: a.val = b.val
-- UInt64.add_def
declare_uint_theorems UInt64
Arguments: (a b : UInt64)
Goal: a + b = { val := a.val + b.val }
-- UInt64.one_def
declare_uint_theorems UInt64
Goal: 1 = { val := 1 }
-- UInt64.val_eq_of_lt
declare_uint_theorems UInt64
Arguments: {a : Nat}
Goal: a < UInt64.size → ↑(UInt64.ofNat a).val = a
-- UInt64.modn_lt
declare_uint_theorems UInt64
Arguments: {m : Nat} (u : UInt64)
Goal: m > 0 → (u % m).toNat < m
-- UInt64.div_toNat
declare_uint_theorems UInt64
Arguments: (a b : UInt64)
Goal: (a / b).toNat = a.toNat / b.toNat
-- UInt64.not_le
declare_uint_theorems UInt64
Arguments: {a b : UInt64}
Goal: ¬a ≤ b ↔ b < a
-- UInt64.not_lt
declare_uint_theorems UInt64
Arguments: {a b : UInt64}
Goal: ¬a < b ↔ b ≤ a
-- UInt64.lt_def
declare_uint_theorems UInt64
Arguments: {a b : UInt64}
Goal: a < b ↔ a.val < b.val
-- UInt64.lt_iff_val_lt_val
declare_uint_theorems UInt64
Arguments: {a b : UInt64}
Goal: a < b ↔ a.val < b.val
-- UInt64.lt_irrefl
declare_uint_theorems UInt64
Arguments: (a : UInt64)
Goal: ¬a < a
-- UInt64.lt_asymm
declare_uint_theorems UInt64
Arguments: {a b : UInt64} (h : a < b)
Goal: ¬b < a
-- UInt64.mul_def
declare_uint_theorems UInt64
Arguments: (a b : UInt64)
Goal: a * b = { val := a.val * b.val }
-- UInt64.modn_toNat
declare_uint_theorems UInt64
Arguments: (a : UInt64) (b : Nat)
Goal: (a.modn b).toNat = a.toNat % b
-- UInt64.mod_lt
declare_uint_theorems UInt64
Arguments: (a b : UInt64) (h : 0 < b)
Goal: a % b < b
-- UInt64.le_refl
declare_uint_theorems UInt64
Arguments: (a : UInt64)
Goal: a ≤ a
-- UInt64.mod_def
declare_uint_theorems UInt64
Arguments: (a b : UInt64)
Goal: a % b = { val := a.val % b.val }
-- UInt64.ne_of_val_ne
declare_uint_theorems UInt64
Arguments: {a b : UInt64} (h : a.val ≠ b.val)
Goal: a ≠ b
-- UInt64.le_trans
declare_uint_theorems UInt64
Arguments: {a b c : UInt64}
Goal: a ≤ b → b ≤ c → a ≤ c
-- UInt64.zero_toNat
declare_uint_theorems UInt64
Goal: UInt64.toNat 0 = 0
-- USize.one_def
declare_uint_theorems USize
Goal: 1 = { val := 1 }
-- USize.le_def
declare_uint_theorems USize
Arguments: {a b : USize}
Goal: a ≤ b ↔ a.val ≤ b.val
-- USize.modn_lt
declare_uint_theorems USize
Arguments: {m : Nat} (u : USize)
Goal: m > 0 → (u % m).toNat < m
-- USize.mul_def
declare_uint_theorems USize
Arguments: (a b : USize)
Goal: a * b = { val := a.val * b.val }
-- USize.lt_trans
declare_uint_theorems USize
Arguments: {a b c : USize}
Goal: a < b → b < c → a < c
-- USize.eq_of_val_eq
declare_uint_theorems USize
Arguments: {a b : USize} (h : a.val = b.val)
Goal: a = b
-- USize.zero_def
declare_uint_theorems USize
Goal: 0 = { val := 0 }
-- USize.lt_asymm
declare_uint_theorems USize
Arguments: {a b : USize} (h : a < b)
Goal: ¬b < a
-- USize.mk_val_eq
declare_uint_theorems USize
Arguments: (a : USize)
Goal: { val := a.val } = a
-- USize.lt_iff_val_lt_val
declare_uint_theorems USize
Arguments: {a b : USize}
Goal: a < b ↔ a.val < b.val
-- USize.mod_toNat
declare_uint_theorems USize
Arguments: (a b : USize)
Goal: (a % b).toNat = a.toNat % b.toNat
-- USize.mod_lt
declare_uint_theorems USize
Arguments: (a b : USize) (h : 0 < b)
Goal: a % b < b
-- USize.lt_irrefl
declare_uint_theorems USize
Arguments: (a : USize)
Goal: ¬a < a
-- USize.val_eq_of_eq
declare_uint_theorems USize
Arguments: {a b : USize} (h : a = b)
Goal: a.val = b.val
-- USize.le_trans
declare_uint_theorems USize
Arguments: {a b c : USize}
Goal: a ≤ b → b ≤ c → a ≤ c
-- USize.toNat.inj
declare_uint_theorems USize
Arguments: {a b : USize}
Goal: a.toNat = b.toNat → a = b
-- USize.lt_def
declare_uint_theorems USize
Arguments: {a b : USize}
Goal: a < b ↔ a.val < b.val
-- USize.le_total
declare_uint_theorems USize
Arguments: (a b : USize)
Goal: a ≤ b ∨ b ≤ a
-- USize.not_le
declare_uint_theorems USize
Arguments: {a b : USize}
Goal: ¬a ≤ b ↔ b < a
-- USize.div_toNat
declare_uint_theorems USize
Arguments: (a b : USize)
Goal: (a / b).toNat = a.toNat / b.toNat
-- USize.le_refl
declare_uint_theorems USize
Arguments: (a : USize)
Goal: a ≤ a
-- USize.val_eq_of_lt
declare_uint_theorems USize
Arguments: {a : Nat}
Goal: a < USize.size → ↑(USize.ofNat a).val = a
-- USize.add_def
declare_uint_theorems USize
Arguments: (a b : USize)
Goal: a + b = { val := a.val + b.val }
-- USize.modn_toNat
declare_uint_theorems USize
Arguments: (a : USize) (b : Nat)
Goal: (a.modn b).toNat = a.toNat % b
-- USize.zero_toNat
declare_uint_theorems USize
Goal: USize.toNat 0 = 0
-- USize.mod_def
declare_uint_theorems USize
Arguments: (a b : USize)
Goal: a % b = { val := a.val % b.val }
-- USize.not_lt
declare_uint_theorems USize
Arguments: {a b : USize}
Goal: ¬a < b ↔ b ≤ a
-- USize.ne_of_lt
declare_uint_theorems USize
Arguments: {a b : USize} (h : a < b)
Goal: a ≠ b
-- USize.ne_of_val_ne
declare_uint_theorems USize
Arguments: {a b : USize} (h : a.val ≠ b.val)
Goal: a ≠ b
-- USize.sub_def
declare_uint_theorems USize
Arguments: (a b : USize)
Goal: a - b = { val := a.val - b.val }
-- List.length_take
@[simp] theorem length_take : ∀ (i : Nat) (l : List α), length (take i l) = min i (length l)
  
Arguments: {α : Type u_1} (i : Nat) (l : List α)
Goal: (List.take i l).length = min i l.length
-- List.length_take_le
theorem length_take_le (n) (l : List α) : length (take n l) ≤ n 
Arguments: {α : Type u_1} (n : Nat) (l : List α)
Goal: (List.take n l).length ≤ n
-- List.length_take_le'
theorem length_take_le' (n) (l : List α) : length (take n l) ≤ l.length 
Arguments: {α : Type u_1} (n : Nat) (l : List α)
Goal: (List.take n l).length ≤ l.length
-- List.length_take_of_le
theorem length_take_of_le (h : n ≤ length l) : length (take n l) = n 
Arguments: {n : Nat}
Goal: ∀ {α : Type u_1} {l : List α}, n ≤ l.length → (List.take n l).length = n
-- List.take_take
theorem take_take : ∀ (n m) (l : List α), take n (take m l) = take (min n m) l
  
Arguments: {α : Type u_1} (n m : Nat) (l : List α)
Goal: List.take n (List.take m l) = List.take (min n m) l
-- List.take_replicate
@[simp] theorem take_replicate (a : α) : ∀ n m : Nat, take n (replicate m a) = replicate (min n m) a
  
Arguments: {α : Type u_1} (a : α) (n m : Nat)
Goal: List.take n (List.replicate m a) = List.replicate (min n m) a
-- List.drop_replicate
@[simp] theorem drop_replicate (a : α) : ∀ n m : Nat, drop n (replicate m a) = replicate (m - n) a
  
Arguments: {α : Type u_1} (a : α) (n m : Nat)
Goal: List.drop n (List.replicate m a) = List.replicate (m - n) a
-- List.take_append_eq_append_take
theorem take_append_eq_append_take {l₁ l₂ : List α} {n : Nat} :
    take n (l₁ ++ l₂) = take n l₁ ++ take (n - l₁.length) l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat}
Goal: List.take n (l₁ ++ l₂) = List.take n l₁ ++ List.take (n - l₁.length) l₂
-- List.take_append_of_le_length
theorem take_append_of_le_length {l₁ l₂ : List α} {n : Nat} (h : n ≤ l₁.length) :
    (l₁ ++ l₂).take n = l₁.take n 
Arguments: {α : Type u_1} {l₁ l₂ : List α} {n : Nat} (h : n ≤ l₁.length)
Goal: List.take n (l₁ ++ l₂) = List.take n l₁
-- List.take_append
theorem take_append {l₁ l₂ : List α} (i : Nat) :
    take (l₁.length + i) (l₁ ++ l₂) = l₁ ++ take i l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (i : Nat)
Goal: List.take (l₁.length + i) (l₁ ++ l₂) = l₁ ++ List.take i l₂
-- List.getElem_take
theorem getElem_take (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j) :
    L[i] = (L.take j)[i]'(length_take .. ▸ Nat.lt_min.mpr ⟨hj, hi⟩) 
Arguments: {α : Type u_1} (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j)
Goal: L[i] = (List.take j L)[i]
-- List.getElem_take'
theorem getElem_take' (L : List α) {j i : Nat} {h : i < (L.take j).length} :
    (L.take j)[i] =
    L[i]'(Nat.lt_of_lt_of_le h (length_take_le' _ _)) 
Arguments: {α : Type u_1} (L : List α) {j i : Nat} {h : i < (List.take j L).length}
Goal: (List.take j L)[i] = L[i]
-- List.get_take
@[deprecated getElem_take (since := "2024-06-12")]
theorem get_take (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j) :
    get L ⟨i, hi⟩ = get (L.take j) ⟨i, length_take .. ▸ Nat.lt_min.mpr ⟨hj, hi⟩⟩ 
Arguments: {α : Type u_1} (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j)
Goal: L.get ⟨i, hi⟩ = (List.take j L).get ⟨i, ⋯⟩
-- List.get_take'
@[deprecated getElem_take (since := "2024-06-12")]
theorem get_take' (L : List α) {j i} :
    get (L.take j) i =
    get L ⟨i.1, Nat.lt_of_lt_of_le i.2 (length_take_le' _ _)⟩ 
Arguments: {α : Type u_1} (L : List α) {j : Nat} {i : Fin (List.take j L).length}
Goal: (List.take j L).get i = L.get ⟨↑i, ⋯⟩
-- List.getElem?_take_eq_none
theorem getElem?_take_eq_none {l : List α} {n m : Nat} (h : n ≤ m) :
    (l.take n)[m]? = none 
Arguments: {α : Type u_1} {l : List α} {n m : Nat} (h : n ≤ m)
Goal: (List.take n l)[m]? = none
-- List.get?_take_eq_none
@[deprecated getElem?_take_eq_none (since := "2024-06-12")]
theorem get?_take_eq_none {l : List α} {n m : Nat} (h : n ≤ m) :
    (l.take n).get? m = none 
Arguments: {α : Type u_1} {l : List α} {n m : Nat} (h : n ≤ m)
Goal: (List.take n l).get? m = none
-- List.getElem?_take_eq_if
theorem getElem?_take_eq_if {l : List α} {n m : Nat} :
    (l.take n)[m]? = if m < n then l[m]? else none 
Arguments: {α : Type u_1} {l : List α} {n m : Nat}
Goal: (List.take n l)[m]? = if m < n then l[m]? else none
-- List.get?_take_eq_if
@[deprecated getElem?_take_eq_if (since := "2024-06-12")]
theorem get?_take_eq_if {l : List α} {n m : Nat} :
    (l.take n).get? m = if m < n then l.get? m else none 
Arguments: {α : Type u_1} {l : List α} {n m : Nat}
Goal: (List.take n l).get? m = if m < n then l.get? m else none
-- List.take_eq_take
@[simp]
theorem take_eq_take :
    ∀ {l : List α} {m n : Nat}, l.take m = l.take n ↔ min m l.length = min n l.length
  
Arguments: {α : Type u_1} {l : List α} {m n : Nat}
Goal: List.take m l = List.take n l ↔ min m l.length = min n l.length
-- List.take_add
theorem take_add (l : List α) (m n : Nat) : l.take (m + n) = l.take m ++ (l.drop m).take n 
Arguments: {α : Type u_1} (l : List α) (m n : Nat)
Goal: List.take (m + n) l = List.take m l ++ List.take n (List.drop m l)
-- List.dropLast_take
theorem dropLast_take {n : Nat} {l : List α} (h : n < l.length) :
    (l.take n).dropLast = l.take n.pred 
Arguments: {α : Type u_1} {n : Nat} {l : List α} (h : n < l.length)
Goal: (List.take n l).dropLast = List.take n.pred l
-- List.map_eq_append_split
theorem map_eq_append_split {f : α → β} {l : List α} {s₁ s₂ : List β}
    (h : map f l = s₁ ++ s₂) : ∃ l₁ l₂, l = l₁ ++ l₂ ∧ map f l₁ = s₁ ∧ map f l₂ = s₂ 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α} {s₁ s₂ : List β} (h : List.map f l = s₁ ++ s₂)
Goal: ∃ l₁ l₂, l = l₁ ++ l₂ ∧ List.map f l₁ = s₁ ∧ List.map f l₂ = s₂
-- List.drop_length_cons
theorem drop_length_cons {l : List α} (h : l ≠ []) (a : α) :
    (a :: l).drop l.length = [l.getLast h] 
Arguments: {α : Type u_1} {l : List α} (h : l ≠ []) (a : α)
Goal: List.drop l.length (a :: l) = [l.getLast h]