ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- UInt64.le_antisymm_iff
theorem UInt64.le_antisymm_iff {x y : UInt64} : x = y ↔ x ≤ y ∧ y ≤ x 
Arguments: {x y : UInt64}
Goal: x = y ↔ x ≤ y ∧ y ≤ x
-- UInt64.le_antisymm
theorem UInt64.le_antisymm {x y : UInt64} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
Arguments: {x y : UInt64} (h1 : x ≤ y) (h2 : y ≤ x)
Goal: x = y
-- USize.ext
@[ext] theorem USize.ext : {x y : USize} → x.toNat = y.toNat → x = y
  
Arguments: {x y : USize}
Goal: x.toNat = y.toNat → x = y
-- USize.ext_iff
theorem USize.ext_iff {x y : USize} : x = y ↔ x.toNat = y.toNat 
Arguments: {x y : USize}
Goal: x = y ↔ x.toNat = y.toNat
-- USize.val_val_eq_toNat
@[simp] theorem USize.val_val_eq_toNat (x : USize) : x.val.val = x.toNat 
Arguments: (x : USize)
Goal: ↑x.val = x.toNat
-- USize.val_ofNat
@[simp] theorem USize.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : USize).val = OfNat.ofNat n 
Arguments: (n : Nat)
Goal: (OfNat.ofNat n).val = OfNat.ofNat n
-- USize.toNat_ofNat
@[simp] theorem USize.toNat_ofNat (n) :
    (no_index (OfNat.ofNat n) : USize).toNat = n % USize.size 
Arguments: (n : Nat)
Goal: (OfNat.ofNat n).toNat = n % USize.size
-- USize.size_eq
theorem USize.size_eq : USize.size = 2 ^ System.Platform.numBits 
Goal: USize.size = 2 ^ System.Platform.numBits
-- USize.le_size
theorem USize.le_size : 2 ^ 32 ≤ USize.size 
Goal: 2 ^ 32 ≤ USize.size
-- USize.size_le
theorem USize.size_le : USize.size ≤ 2 ^ 64 
Goal: USize.size ≤ 2 ^ 64
-- USize.toNat_lt
theorem USize.toNat_lt (x : USize) : x.toNat < 2 ^ System.Platform.numBits 
Arguments: (x : USize)
Goal: x.toNat < 2 ^ System.Platform.numBits
-- USize.toUInt64_toNat
@[simp] theorem USize.toUInt64_toNat (x : USize) : x.toUInt64.toNat = x.toNat 
Arguments: (x : USize)
Goal: x.toUInt64.toNat = x.toNat
-- UInt32.toUSize_toNat
@[simp] theorem UInt32.toUSize_toNat (x : UInt32) : x.toUSize.toNat = x.toNat 
Arguments: (x : UInt32)
Goal: x.toUSize.toNat = x.toNat
-- USize.toNat_zero
theorem USize.toNat_zero : (0 : USize).toNat = 0 
Goal: USize.toNat 0 = 0
-- USize.toNat_add
theorem USize.toNat_add (x y : USize) : (x + y).toNat = (x.toNat + y.toNat) % USize.size 
Arguments: (x y : USize)
Goal: (x + y).toNat = (x.toNat + y.toNat) % USize.size
-- USize.toNat_sub
theorem USize.toNat_sub (x y : USize) :
    (x - y).toNat = (USize.size - y.toNat + x.toNat) % USize.size 
Arguments: (x y : USize)
Goal: (x - y).toNat = (USize.size - y.toNat + x.toNat) % USize.size
-- USize.toNat_mul
theorem USize.toNat_mul (x y : USize) : (x * y).toNat = (x.toNat * y.toNat) % USize.size 
Arguments: (x y : USize)
Goal: (x * y).toNat = x.toNat * y.toNat % USize.size
-- USize.toNat_div
theorem USize.toNat_div (x y : USize) : (x / y).toNat = x.toNat / y.toNat 
Arguments: (x y : USize)
Goal: (x / y).toNat = x.toNat / y.toNat
-- USize.toNat_mod
theorem USize.toNat_mod (x y : USize) : (x % y).toNat = x.toNat % y.toNat 
Arguments: (x y : USize)
Goal: (x % y).toNat = x.toNat % y.toNat
-- USize.toNat_modn
theorem USize.toNat_modn (x : USize) (n) : (x.modn n).toNat = x.toNat % n 
Arguments: (x : USize) (n : Nat)
Goal: (x.modn n).toNat = x.toNat % n
-- USize.le_antisymm_iff
theorem USize.le_antisymm_iff {x y : USize} : x = y ↔ x ≤ y ∧ y ≤ x 
Arguments: {x y : USize}
Goal: x = y ↔ x ≤ y ∧ y ≤ x
-- USize.le_antisymm
theorem USize.le_antisymm {x y : USize} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
Arguments: {x y : USize} (h1 : x ≤ y) (h2 : y ≤ x)
Goal: x = y
-- Nat.recAux_zero
@[simp] theorem recAux_zero {motive : Nat → Sort _} (zero : motive 0)
    (succ : ∀ n, motive n → motive (n+1)) :
    Nat.recAux zero succ 0 = zero 
Arguments: {motive : Nat → Sort u_1} (zero : motive 0) (succ : (n : Nat) → motive n → motive (n + 1))
Goal: Nat.recAux zero succ 0 = zero
-- Nat.recAux_succ
theorem recAux_succ {motive : Nat → Sort _} (zero : motive 0)
    (succ : ∀ n, motive n → motive (n+1)) (n) :
    Nat.recAux zero succ (n+1) = succ n (Nat.recAux zero succ n) 
Arguments: {motive : Nat → Sort u_1} (zero : motive 0) (succ : (n : Nat) → motive n → motive (n + 1)) (n : Nat)
Goal: Nat.recAux zero succ (n + 1) = succ n (Nat.recAux zero succ n)
-- Nat.recAuxOn_zero
@[simp] theorem recAuxOn_zero {motive : Nat → Sort _} (zero : motive 0)
    (succ : ∀ n, motive n → motive (n+1)) :
    Nat.recAuxOn 0 zero succ = zero 
Arguments: {motive : Nat → Sort u_1} (zero : motive 0) (succ : (n : Nat) → motive n → motive (n + 1))
Goal: Nat.recAuxOn 0 zero succ = zero
-- Nat.recAuxOn_succ
theorem recAuxOn_succ {motive : Nat → Sort _} (zero : motive 0)
    (succ : ∀ n, motive n → motive (n+1)) (n) :
    Nat.recAuxOn (n+1) zero succ = succ n (Nat.recAuxOn n zero succ) 
Arguments: {motive : Nat → Sort u_1} (zero : motive 0) (succ : (n : Nat) → motive n → motive (n + 1)) (n : Nat)
Goal: Nat.recAuxOn (n + 1) zero succ = succ n (Nat.recAuxOn n zero succ)
-- Nat.casesAuxOn_zero
@[simp] theorem casesAuxOn_zero {motive : Nat → Sort _} (zero : motive 0)
    (succ : ∀ n, motive (n+1)) :
    Nat.casesAuxOn 0 zero succ = zero 
Arguments: {motive : Nat → Sort u_1} (zero : motive 0) (succ : (n : Nat) → motive (n + 1))
Goal: Nat.casesAuxOn 0 zero succ = zero
-- Nat.casesAuxOn_succ
theorem casesAuxOn_succ {motive : Nat → Sort _} (zero : motive 0)
    (succ : ∀ n, motive (n+1)) (n) :
    Nat.casesAuxOn (n+1) zero succ = succ n 
Arguments: {motive : Nat → Sort u_1} (zero : motive 0) (succ : (n : Nat) → motive (n + 1)) (n : Nat)
Goal: Nat.casesAuxOn (n + 1) zero succ = succ n
-- Nat.strongRec_eq
theorem strongRec_eq {motive : Nat → Sort _} (ind : ∀ n, (∀ m, m < n → motive m) → motive n)
    (t : Nat) : Nat.strongRec ind t = ind t fun m _ => Nat.strongRec ind m 
Arguments: {motive : Nat → Sort u_1} (ind : (n : Nat) → ((m : Nat) → m < n → motive m) → motive n) (t : Nat)
Goal: Nat.strongRec ind t = ind t fun m x => Nat.strongRec ind m
-- Nat.strongRecOn_eq
theorem strongRecOn_eq {motive : Nat → Sort _} (ind : ∀ n, (∀ m, m < n → motive m) → motive n)
    (t : Nat) : Nat.strongRecOn t ind = ind t fun m _ => Nat.strongRecOn m ind 
Arguments: {motive : Nat → Sort u_1} (ind : (n : Nat) → ((m : Nat) → m < n → motive m) → motive n) (t : Nat)
Goal: t.strongRecOn ind = ind t fun m x => m.strongRecOn ind
-- Nat.recDiagAux_zero_left
@[simp] theorem recDiagAux_zero_left {motive : Nat → Nat → Sort _}
    (zero_left : ∀ n, motive 0 n) (zero_right : ∀ m, motive m 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (n) :
    Nat.recDiagAux zero_left zero_right succ_succ 0 n = zero_left n 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_left : (n : Nat) → motive 0 n) (zero_right : (m : Nat) → motive m 0) (succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)) (n : Nat)
Goal: Nat.recDiagAux zero_left zero_right succ_succ 0 n = zero_left n
-- Nat.recDiagAux_zero_right
@[simp] theorem recDiagAux_zero_right {motive : Nat → Nat → Sort _}
    (zero_left : ∀ n, motive 0 n) (zero_right : ∀ m, motive m 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (m)
    (h : zero_left 0 = zero_right 0 := by first | assumption | trivial) :
    Nat.recDiagAux zero_left zero_right succ_succ m 0 = zero_right m 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_left : (n : Nat) → motive 0 n) (zero_right : (m : Nat) → motive m 0) (succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)) (m : Nat) (h : zero_left 0 = zero_right 0 := by
  first
  | assumption
  | trivial)
Goal: Nat.recDiagAux zero_left zero_right succ_succ m 0 = zero_right m
-- Nat.recDiagAux_succ_succ
theorem recDiagAux_succ_succ {motive : Nat → Nat → Sort _}
    (zero_left : ∀ n, motive 0 n) (zero_right : ∀ m, motive m 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (m n) :
    Nat.recDiagAux zero_left zero_right succ_succ (m+1) (n+1)
      = succ_succ m n (Nat.recDiagAux zero_left zero_right succ_succ m n) 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_left : (n : Nat) → motive 0 n) (zero_right : (m : Nat) → motive m 0) (succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)) (m n : Nat)
Goal: Nat.recDiagAux zero_left zero_right succ_succ (m + 1) (n + 1) =
  succ_succ m n (Nat.recDiagAux zero_left zero_right succ_succ m n)
-- Nat.recDiag_zero_zero
@[simp] theorem recDiag_zero_zero {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 n → motive 0 (n+1)) (succ_zero : ∀ m, motive m 0 → motive (m+1) 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) :
    Nat.recDiag (motive:=motive) zero_zero zero_succ succ_zero succ_succ 0 0 = zero_zero 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)) (succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0) (succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1))
Goal: Nat.recDiag zero_zero zero_succ succ_zero succ_succ 0 0 = zero_zero
-- Nat.recDiag_zero_succ
theorem recDiag_zero_succ {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 n → motive 0 (n+1)) (succ_zero : ∀ m, motive m 0 → motive (m+1) 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (n) :
    Nat.recDiag zero_zero zero_succ succ_zero succ_succ 0 (n+1)
      = zero_succ n (Nat.recDiag zero_zero zero_succ succ_zero succ_succ 0 n) 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)) (succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0) (succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)) (n : Nat)
Goal: Nat.recDiag zero_zero zero_succ succ_zero succ_succ 0 (n + 1) =
  zero_succ n (Nat.recDiag zero_zero zero_succ succ_zero succ_succ 0 n)
-- Nat.recDiag_succ_zero
theorem recDiag_succ_zero {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 n → motive 0 (n+1)) (succ_zero : ∀ m, motive m 0 → motive (m+1) 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (m) :
    Nat.recDiag zero_zero zero_succ succ_zero succ_succ (m+1) 0
      = succ_zero m (Nat.recDiag zero_zero zero_succ succ_zero succ_succ m 0) 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)) (succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0) (succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)) (m : Nat)
Goal: Nat.recDiag zero_zero zero_succ succ_zero succ_succ (m + 1) 0 =
  succ_zero m (Nat.recDiag zero_zero zero_succ succ_zero succ_succ m 0)
-- Nat.recDiag_succ_succ
theorem recDiag_succ_succ {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 n → motive 0 (n+1)) (succ_zero : ∀ m, motive m 0 → motive (m+1) 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (m n) :
    Nat.recDiag zero_zero zero_succ succ_zero succ_succ (m+1) (n+1)
      = succ_succ m n (Nat.recDiag zero_zero zero_succ succ_zero succ_succ m n) 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)) (succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0) (succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)) (m n : Nat)
Goal: Nat.recDiag zero_zero zero_succ succ_zero succ_succ (m + 1) (n + 1) =
  succ_succ m n (Nat.recDiag zero_zero zero_succ succ_zero succ_succ m n)
-- Nat.recDiagOn_zero_zero
@[simp] theorem recDiagOn_zero_zero {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 n → motive 0 (n+1)) (succ_zero : ∀ m, motive m 0 → motive (m+1) 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) :
    Nat.recDiagOn (motive:=motive) 0 0 zero_zero zero_succ succ_zero succ_succ = zero_zero 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)) (succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0) (succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1))
Goal: Nat.recDiagOn 0 0 zero_zero zero_succ succ_zero succ_succ = zero_zero
-- Nat.recDiagOn_zero_succ
theorem recDiagOn_zero_succ {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 n → motive 0 (n+1)) (succ_zero : ∀ m, motive m 0 → motive (m+1) 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (n) :
    Nat.recDiagOn 0 (n+1) zero_zero zero_succ succ_zero succ_succ
      = zero_succ n (Nat.recDiagOn 0 n zero_zero zero_succ succ_zero succ_succ) 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)) (succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0) (succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)) (n : Nat)
Goal: Nat.recDiagOn 0 (n + 1) zero_zero zero_succ succ_zero succ_succ =
  zero_succ n (Nat.recDiagOn 0 n zero_zero zero_succ succ_zero succ_succ)
-- Nat.recDiagOn_succ_zero
theorem recDiagOn_succ_zero {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 n → motive 0 (n+1)) (succ_zero : ∀ m, motive m 0 → motive (m+1) 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (m) :
    Nat.recDiagOn (m+1) 0 zero_zero zero_succ succ_zero succ_succ
      = succ_zero m (Nat.recDiagOn m 0 zero_zero zero_succ succ_zero succ_succ) 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)) (succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0) (succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)) (m : Nat)
Goal: Nat.recDiagOn (m + 1) 0 zero_zero zero_succ succ_zero succ_succ =
  succ_zero m (Nat.recDiagOn m 0 zero_zero zero_succ succ_zero succ_succ)
-- Nat.recDiagOn_succ_succ
theorem recDiagOn_succ_succ {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 n → motive 0 (n+1)) (succ_zero : ∀ m, motive m 0 → motive (m+1) 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (m n) :
    Nat.recDiagOn (m+1) (n+1) zero_zero zero_succ succ_zero succ_succ
      = succ_succ m n (Nat.recDiagOn m n zero_zero zero_succ succ_zero succ_succ) 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : Nat) → motive 0 n → motive 0 (n + 1)) (succ_zero : (m : Nat) → motive m 0 → motive (m + 1) 0) (succ_succ : (m n : Nat) → motive m n → motive (m + 1) (n + 1)) (m n : Nat)
Goal: Nat.recDiagOn (m + 1) (n + 1) zero_zero zero_succ succ_zero succ_succ =
  succ_succ m n (Nat.recDiagOn m n zero_zero zero_succ succ_zero succ_succ)
-- Nat.casesDiagOn_zero_zero
@[simp] theorem casesDiagOn_zero_zero {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 (n+1)) (succ_zero : ∀ m, motive (m+1) 0)
    (succ_succ : ∀ m n, motive (m+1) (n+1)) :
    Nat.casesDiagOn 0 0 (motive:=motive) zero_zero zero_succ succ_zero succ_succ = zero_zero 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : Nat) → motive 0 (n + 1)) (succ_zero : (m : Nat) → motive (m + 1) 0) (succ_succ : (m n : Nat) → motive (m + 1) (n + 1))
Goal: Nat.casesDiagOn 0 0 zero_zero zero_succ succ_zero succ_succ = zero_zero
-- Nat.casesDiagOn_zero_succ
@[simp] theorem casesDiagOn_zero_succ {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 (n+1)) (succ_zero : ∀ m, motive (m+1) 0)
    (succ_succ : ∀ m n, motive (m+1) (n+1)) (n) :
    Nat.casesDiagOn 0 (n+1) zero_zero zero_succ succ_zero succ_succ = zero_succ n 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : Nat) → motive 0 (n + 1)) (succ_zero : (m : Nat) → motive (m + 1) 0) (succ_succ : (m n : Nat) → motive (m + 1) (n + 1)) (n : Nat)
Goal: Nat.casesDiagOn 0 (n + 1) zero_zero zero_succ succ_zero succ_succ = zero_succ n
-- Nat.casesDiagOn_succ_zero
@[simp] theorem casesDiagOn_succ_zero {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 (n+1)) (succ_zero : ∀ m, motive (m+1) 0)
    (succ_succ : ∀ m n, motive (m+1) (n+1)) (m) :
    Nat.casesDiagOn (m+1) 0 zero_zero zero_succ succ_zero succ_succ = succ_zero m 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : Nat) → motive 0 (n + 1)) (succ_zero : (m : Nat) → motive (m + 1) 0) (succ_succ : (m n : Nat) → motive (m + 1) (n + 1)) (m : Nat)
Goal: Nat.casesDiagOn (m + 1) 0 zero_zero zero_succ succ_zero succ_succ = succ_zero m
-- Nat.casesDiagOn_succ_succ
@[simp] theorem casesDiagOn_succ_succ {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 (n+1)) (succ_zero : ∀ m, motive (m+1) 0)
    (succ_succ : ∀ m n, motive (m+1) (n+1)) (m n) :
    Nat.casesDiagOn (m+1) (n+1) zero_zero zero_succ succ_zero succ_succ = succ_succ m n 
Arguments: {motive : Nat → Nat → Sort u_1} (zero_zero : motive 0 0) (zero_succ : (n : Nat) → motive 0 (n + 1)) (succ_zero : (m : Nat) → motive (m + 1) 0) (succ_succ : (m n : Nat) → motive (m + 1) (n + 1)) (m n : Nat)
Goal: Nat.casesDiagOn (m + 1) (n + 1) zero_zero zero_succ succ_zero succ_succ = succ_succ m n
-- Nat.sum_nil
@[simp] theorem sum_nil : Nat.sum [] = 0 
Goal: Nat.sum [] = 0
-- Nat.sum_cons
@[simp] theorem sum_cons : Nat.sum (a :: l) = a + Nat.sum l 
Arguments: {a : Nat} {l : List Nat}
Goal: Nat.sum (a :: l) = a + Nat.sum l
-- Nat.sum_append
@[simp] theorem sum_append : Nat.sum (l₁ ++ l₂) = Nat.sum l₁ + Nat.sum l₂ 
Arguments: {l₁ l₂ : List Nat}
Goal: Nat.sum (l₁ ++ l₂) = Nat.sum l₁ + Nat.sum l₂
-- Array.PrefixTable.valid
structure PrefixTable (α : Type _) extends Array (α × Nat) where
    valid : (h : i < toArray.size) → toArray[i].2 ≤ i
Arguments: {α : Type u_1} (self : Array.PrefixTable α) {i : Nat} (h : i < self.size)
Goal: self.toArray[i].snd ≤ i
-- List.countP_nil
@[simp] theorem countP_nil : countP p [] = 0 
Arguments: {α : Type u_1} (p : α → Bool)
Goal: List.countP p [] = 0
-- List.countP_go_eq_add
protected theorem countP_go_eq_add (l) : countP.go p l n = n + countP.go p l 0 
Arguments: {α : Type u_1} (p : α → Bool) {n : Nat} (l : List α)
Goal: List.countP.go p l n = n + List.countP.go p l 0
-- List.countP_cons_of_pos
@[simp] theorem countP_cons_of_pos (l) (pa : p a) : countP p (a :: l) = countP p l + 1 
Arguments: {α : Type u_1} (p : α → Bool) {a : α} (l : List α) (pa : p a = true)
Goal: List.countP p (a :: l) = List.countP p l + 1
-- List.countP_cons_of_neg
@[simp] theorem countP_cons_of_neg (l) (pa : ¬p a) : countP p (a :: l) = countP p l 
Arguments: {α : Type u_1} (p : α → Bool) {a : α} (l : List α) (pa : ¬p a = true)
Goal: List.countP p (a :: l) = List.countP p l
-- List.countP_cons
theorem countP_cons (a : α) (l) : countP p (a :: l) = countP p l + if p a then 1 else 0 
Arguments: {α : Type u_1} (p : α → Bool) (a : α) (l : List α)
Goal: List.countP p (a :: l) = List.countP p l + if p a = true then 1 else 0
-- List.length_eq_countP_add_countP
theorem length_eq_countP_add_countP (l) : length l = countP p l + countP (fun a => ¬p a) l 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α)
Goal: l.length = List.countP p l + List.countP (fun a => decide ¬p a = true) l
-- List.countP_eq_length_filter
theorem countP_eq_length_filter (l) : countP p l = length (filter p l) 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α)
Goal: List.countP p l = (List.filter p l).length
-- List.countP_le_length
theorem countP_le_length : countP p l ≤ l.length 
Arguments: {α : Type u_1} (p : α → Bool) {l : List α}
Goal: List.countP p l ≤ l.length
-- List.countP_append
@[simp] theorem countP_append (l₁ l₂) : countP p (l₁ ++ l₂) = countP p l₁ + countP p l₂ 
Arguments: {α : Type u_1} (p : α → Bool) (l₁ l₂ : List α)
Goal: List.countP p (l₁ ++ l₂) = List.countP p l₁ + List.countP p l₂
-- List.countP_pos
theorem countP_pos : 0 < countP p l ↔ ∃ a ∈ l, p a 
Arguments: {α : Type u_1} (p : α → Bool) {l : List α}
Goal: 0 < List.countP p l ↔ ∃ a, a ∈ l ∧ p a = true
-- List.countP_eq_zero
theorem countP_eq_zero : countP p l = 0 ↔ ∀ a ∈ l, ¬p a 
Arguments: {α : Type u_1} (p : α → Bool) {l : List α}
Goal: List.countP p l = 0 ↔ ∀ (a : α), a ∈ l → ¬p a = true
-- List.countP_eq_length
theorem countP_eq_length : countP p l = l.length ↔ ∀ a ∈ l, p a 
Arguments: {α : Type u_1} (p : α → Bool) {l : List α}
Goal: List.countP p l = l.length ↔ ∀ (a : α), a ∈ l → p a = true
-- List.Sublist.countP_le
theorem Sublist.countP_le (s : l₁ <+ l₂) : countP p l₁ ≤ countP p l₂ 
Arguments: {α : Type u_1} (p : α → Bool) {l₁ l₂ : List α} (s : l₁ <+ l₂)
Goal: List.countP p l₁ ≤ List.countP p l₂
-- List.countP_filter
theorem countP_filter (l : List α) :
    countP p (filter q l) = countP (fun a => p a ∧ q a) l 
Arguments: {α : Type u_1} (p q : α → Bool) (l : List α)
Goal: List.countP p (List.filter q l) = List.countP (fun a => decide (p a = true ∧ q a = true)) l
-- List.countP_true
@[simp] theorem countP_true {l : List α} : (l.countP fun _ => true) = l.length 
Arguments: {α : Type u_1} {l : List α}
Goal: List.countP (fun x => true) l = l.length
-- List.countP_false
@[simp] theorem countP_false {l : List α} : (l.countP fun _ => false) = 0 
Arguments: {α : Type u_1} {l : List α}
Goal: List.countP (fun x => false) l = 0
-- List.countP_map
@[simp] theorem countP_map (p : β → Bool) (f : α → β) :
    ∀ l, countP p (map f l) = countP (p ∘ f) l
  
Arguments: {α : Type u_2} {β : Type u_1} (p : β → Bool) (f : α → β) (l : List α)
Goal: List.countP p (List.map f l) = List.countP (p ∘ f) l
-- List.countP_mono_left
theorem countP_mono_left (h : ∀ x ∈ l, p x → q x) : countP p l ≤ countP q l 
Arguments: {α : Type u_1} {p q : α → Bool} {l : List α} (h : ∀ (x : α), x ∈ l → p x = true → q x = true)
Goal: List.countP p l ≤ List.countP q l
-- List.countP_congr
theorem countP_congr (h : ∀ x ∈ l, p x ↔ q x) : countP p l = countP q l 
Arguments: {α : Type u_1} {p q : α → Bool} {l : List α} (h : ∀ (x : α), x ∈ l → (p x = true ↔ q x = true))
Goal: List.countP p l = List.countP q l
-- List.count_nil
@[simp] theorem count_nil (a : α) : count a [] = 0 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: List.count a [] = 0
-- List.count_cons
theorem count_cons (a b : α) (l : List α) :
    count a (b :: l) = count a l + if a = b then 1 else 0 
Arguments: {α : Type u_1} [DecidableEq α] (a b : α) (l : List α)
Goal: List.count a (b :: l) = List.count a l + if a = b then 1 else 0
-- List.count_cons_self
@[simp] theorem count_cons_self (a : α) (l : List α) : count a (a :: l) = count a l + 1 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l : List α)
Goal: List.count a (a :: l) = List.count a l + 1
-- List.count_cons_of_ne
@[simp] theorem count_cons_of_ne (h : a ≠ b) (l : List α) : count a (b :: l) = count a l 
Arguments: {α : Type u_1} [DecidableEq α] {a b : α} (h : a ≠ b) (l : List α)
Goal: List.count a (b :: l) = List.count a l
-- List.count_tail
theorem count_tail : ∀ (l : List α) (a : α) (h : l ≠ []),
      l.tail.count a = l.count a - if a = l.head h then 1 else 0
  
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (a : α) (h : l ≠ [])
Goal: List.count a l.tail = List.count a l - if a = l.head h then 1 else 0
-- List.count_le_length
theorem count_le_length (a : α) (l : List α) : count a l ≤ l.length 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l : List α)
Goal: List.count a l ≤ l.length
-- List.Sublist.count_le
theorem Sublist.count_le (h : l₁ <+ l₂) (a : α) : count a l₁ ≤ count a l₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α} (h : l₁ <+ l₂) (a : α)
Goal: List.count a l₁ ≤ List.count a l₂
-- List.count_le_count_cons
theorem count_le_count_cons (a b : α) (l : List α) : count a l ≤ count a (b :: l) 
Arguments: {α : Type u_1} [DecidableEq α] (a b : α) (l : List α)
Goal: List.count a l ≤ List.count a (b :: l)
-- List.count_singleton
theorem count_singleton (a : α) : count a [a] = 1 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: List.count a [a] = 1
-- List.count_singleton'
theorem count_singleton' (a b : α) : count a [b] = if a = b then 1 else 0 
Arguments: {α : Type u_1} [DecidableEq α] (a b : α)
Goal: List.count a [b] = if a = b then 1 else 0
-- List.count_append
@[simp] theorem count_append (a : α) : ∀ l₁ l₂, count a (l₁ ++ l₂) = count a l₁ + count a l₂ 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l₁ l₂ : List α)
Goal: List.count a (l₁ ++ l₂) = List.count a l₁ + List.count a l₂
-- List.count_concat
theorem count_concat (a : α) (l : List α) : count a (concat l a) = succ (count a l) 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l : List α)
Goal: List.count a (l.concat a) = (List.count a l).succ
-- List.count_pos_iff_mem
@[simp]
theorem count_pos_iff_mem {a : α} {l : List α} : 0 < count a l ↔ a ∈ l 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l : List α}
Goal: 0 < List.count a l ↔ a ∈ l