ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.count_eq_zero_of_not_mem
@[simp 900] theorem count_eq_zero_of_not_mem {a : α} {l : List α} (h : a ∉ l) : count a l = 0 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l : List α} (h : ¬a ∈ l)
Goal: List.count a l = 0
-- List.not_mem_of_count_eq_zero
theorem not_mem_of_count_eq_zero {a : α} {l : List α} (h : count a l = 0) : a ∉ l 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l : List α} (h : List.count a l = 0)
Goal: ¬a ∈ l
-- List.count_eq_zero
theorem count_eq_zero {l : List α} : count a l = 0 ↔ a ∉ l 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l : List α}
Goal: List.count a l = 0 ↔ ¬a ∈ l
-- List.count_eq_length
theorem count_eq_length {l : List α} : count a l = l.length ↔ ∀ b ∈ l, a = b 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l : List α}
Goal: List.count a l = l.length ↔ ∀ (b : α), b ∈ l → a = b
-- List.count_replicate_self
@[simp] theorem count_replicate_self (a : α) (n : Nat) : count a (replicate n a) = n 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (n : Nat)
Goal: List.count a (List.replicate n a) = n
-- List.count_replicate
theorem count_replicate (a b : α) (n : Nat) : count a (replicate n b) = if a = b then n else 0 
Arguments: {α : Type u_1} [DecidableEq α] (a b : α) (n : Nat)
Goal: List.count a (List.replicate n b) = if a = b then n else 0
-- List.filter_beq
theorem filter_beq (l : List α) (a : α) : l.filter (· == a) = replicate (count a l) a 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (a : α)
Goal: List.filter (fun x => x == a) l = List.replicate (List.count a l) a
-- List.filter_eq
theorem filter_eq (l : List α) (a : α) : l.filter (· = a) = replicate (count a l) a 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (a : α)
Goal: List.filter (fun x => decide (x = a)) l = List.replicate (List.count a l) a
-- List.filter_eq'
@[deprecated filter_eq (since := "2023-12-14")]
theorem filter_eq' (l : List α) (a : α) : l.filter (a = ·) = replicate (count a l) a 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (a : α)
Goal: List.filter (fun x => decide (a = x)) l = List.replicate (List.count a l) a
-- List.filter_beq'
@[deprecated filter_beq (since := "2023-12-14")]
theorem filter_beq' (l : List α) (a : α) : l.filter (a == ·) = replicate (count a l) a 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (a : α)
Goal: List.filter (fun x => a == x) l = List.replicate (List.count a l) a
-- List.le_count_iff_replicate_sublist
theorem le_count_iff_replicate_sublist {l : List α} : n ≤ count a l ↔ replicate n a <+ l 
Arguments: {α : Type u_1} [DecidableEq α] {n : Nat} {a : α} {l : List α}
Goal: n ≤ List.count a l ↔ List.replicate n a <+ l
-- List.replicate_count_eq_of_count_eq_length
theorem replicate_count_eq_of_count_eq_length {l : List α} (h : count a l = length l) :
    replicate (count a l) a = l 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l : List α} (h : List.count a l = l.length)
Goal: List.replicate (List.count a l) a = l
-- List.count_filter
@[simp] theorem count_filter {l : List α} (h : p a) : count a (filter p l) = count a l 
Arguments: {α : Type u_1} [DecidableEq α] {p : α → Bool} {a : α} {l : List α} (h : p a = true)
Goal: List.count a (List.filter p l) = List.count a l
-- List.count_le_count_map
theorem count_le_count_map [DecidableEq β] (l : List α) (f : α → β) (x : α) :
    count x l ≤ count (f x) (map f l) 
Arguments: {α : Type u_2} [DecidableEq α] {β : Type u_1} [DecidableEq β] (l : List α) (f : α → β) (x : α)
Goal: List.count x l ≤ List.count (f x) (List.map f l)
-- List.count_erase
theorem count_erase (a b : α) :
    ∀ l : List α, count a (l.erase b) = count a l - if a = b then 1 else 0
  
Arguments: {α : Type u_1} [DecidableEq α] (a b : α) (l : List α)
Goal: List.count a (l.erase b) = List.count a l - if a = b then 1 else 0
-- List.count_erase_self
@[simp] theorem count_erase_self (a : α) (l : List α) :
    count a (List.erase l a) = count a l - 1 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l : List α)
Goal: List.count a (l.erase a) = List.count a l - 1
-- List.count_erase_of_ne
@[simp] theorem count_erase_of_ne (ab : a ≠ b) (l : List α) : count a (l.erase b) = count a l 
Arguments: {α : Type u_1} [DecidableEq α] {a b : α} (ab : a ≠ b) (l : List α)
Goal: List.count a (l.erase b) = List.count a l
-- Nat.coprime_iff_gcd_eq_one
theorem coprime_iff_gcd_eq_one : Coprime m n ↔ gcd m n = 1 
Arguments: {m n : Nat}
Goal: m.Coprime n ↔ m.gcd n = 1
-- Nat.Coprime.gcd_eq_one
theorem Coprime.gcd_eq_one : Coprime m n → gcd m n = 1 
Arguments: {m n : Nat}
Goal: m.Coprime n → m.gcd n = 1
-- Nat.Coprime.symm
theorem Coprime.symm : Coprime n m → Coprime m n 
Arguments: {n m : Nat}
Goal: n.Coprime m → m.Coprime n
-- Nat.coprime_comm
theorem coprime_comm : Coprime n m ↔ Coprime m n 
Arguments: {n m : Nat}
Goal: n.Coprime m ↔ m.Coprime n
-- Nat.Coprime.dvd_of_dvd_mul_right
theorem Coprime.dvd_of_dvd_mul_right (H1 : Coprime k n) (H2 : k ∣ m * n) : k ∣ m 
Arguments: {k n m : Nat} (H1 : k.Coprime n) (H2 : k ∣ m * n)
Goal: k ∣ m
-- Nat.Coprime.dvd_of_dvd_mul_left
theorem Coprime.dvd_of_dvd_mul_left (H1 : Coprime k m) (H2 : k ∣ m * n) : k ∣ n 
Arguments: {k m n : Nat} (H1 : k.Coprime m) (H2 : k ∣ m * n)
Goal: k ∣ n
-- Nat.Coprime.gcd_mul_left_cancel
theorem Coprime.gcd_mul_left_cancel (m : Nat) (H : Coprime k n) : gcd (k * m) n = gcd m n 
Arguments: {k n : Nat} (m : Nat) (H : k.Coprime n)
Goal: (k * m).gcd n = m.gcd n
-- Nat.Coprime.gcd_mul_right_cancel
theorem Coprime.gcd_mul_right_cancel (m : Nat) (H : Coprime k n) : gcd (m * k) n = gcd m n 
Arguments: {k n : Nat} (m : Nat) (H : k.Coprime n)
Goal: (m * k).gcd n = m.gcd n
-- Nat.Coprime.gcd_mul_left_cancel_right
theorem Coprime.gcd_mul_left_cancel_right (n : Nat)
    (H : Coprime k m) : gcd m (k * n) = gcd m n 
Arguments: {k m : Nat} (n : Nat) (H : k.Coprime m)
Goal: m.gcd (k * n) = m.gcd n
-- Nat.Coprime.gcd_mul_right_cancel_right
theorem Coprime.gcd_mul_right_cancel_right (n : Nat)
    (H : Coprime k m) : gcd m (n * k) = gcd m n 
Arguments: {k m : Nat} (n : Nat) (H : k.Coprime m)
Goal: m.gcd (n * k) = m.gcd n
-- Nat.coprime_div_gcd_div_gcd
theorem coprime_div_gcd_div_gcd
    (H : 0 < gcd m n) : Coprime (m / gcd m n) (n / gcd m n) 
Arguments: {m n : Nat} (H : 0 < m.gcd n)
Goal: (m / m.gcd n).Coprime (n / m.gcd n)
-- Nat.not_coprime_of_dvd_of_dvd
theorem not_coprime_of_dvd_of_dvd (dgt1 : 1 < d) (Hm : d ∣ m) (Hn : d ∣ n) : ¬ Coprime m n 
Arguments: {d m n : Nat} (dgt1 : 1 < d) (Hm : d ∣ m) (Hn : d ∣ n)
Goal: ¬m.Coprime n
-- Nat.exists_coprime
theorem exists_coprime (m n : Nat) :
    ∃ m' n', Coprime m' n' ∧ m = m' * gcd m n ∧ n = n' * gcd m n 
Arguments: (m n : Nat)
Goal: ∃ m' n', m'.Coprime n' ∧ m = m' * m.gcd n ∧ n = n' * m.gcd n
-- Nat.exists_coprime'
theorem exists_coprime' (H : 0 < gcd m n) :
    ∃ g m' n', 0 < g ∧ Coprime m' n' ∧ m = m' * g ∧ n = n' * g 
Arguments: {m n : Nat} (H : 0 < m.gcd n)
Goal: ∃ g m' n', 0 < g ∧ m'.Coprime n' ∧ m = m' * g ∧ n = n' * g
-- Nat.Coprime.mul
theorem Coprime.mul (H1 : Coprime m k) (H2 : Coprime n k) : Coprime (m * n) k 
Arguments: {m k n : Nat} (H1 : m.Coprime k) (H2 : n.Coprime k)
Goal: (m * n).Coprime k
-- Nat.Coprime.mul_right
theorem Coprime.mul_right (H1 : Coprime k m) (H2 : Coprime k n) : Coprime k (m * n) 
Arguments: {k m n : Nat} (H1 : k.Coprime m) (H2 : k.Coprime n)
Goal: k.Coprime (m * n)
-- Nat.Coprime.coprime_dvd_left
theorem Coprime.coprime_dvd_left (H1 : m ∣ k) (H2 : Coprime k n) : Coprime m n 
Arguments: {m k n : Nat} (H1 : m ∣ k) (H2 : k.Coprime n)
Goal: m.Coprime n
-- Nat.Coprime.coprime_dvd_right
theorem Coprime.coprime_dvd_right (H1 : n ∣ m) (H2 : Coprime k m) : Coprime k n 
Arguments: {n m k : Nat} (H1 : n ∣ m) (H2 : k.Coprime m)
Goal: k.Coprime n
-- Nat.Coprime.coprime_mul_left
theorem Coprime.coprime_mul_left (H : Coprime (k * m) n) : Coprime m n 
Arguments: {k m n : Nat} (H : (k * m).Coprime n)
Goal: m.Coprime n
-- Nat.Coprime.coprime_mul_right
theorem Coprime.coprime_mul_right (H : Coprime (m * k) n) : Coprime m n 
Arguments: {m k n : Nat} (H : (m * k).Coprime n)
Goal: m.Coprime n
-- Nat.Coprime.coprime_mul_left_right
theorem Coprime.coprime_mul_left_right (H : Coprime m (k * n)) : Coprime m n 
Arguments: {m k n : Nat} (H : m.Coprime (k * n))
Goal: m.Coprime n
-- Nat.Coprime.coprime_mul_right_right
theorem Coprime.coprime_mul_right_right (H : Coprime m (n * k)) : Coprime m n 
Arguments: {m n k : Nat} (H : m.Coprime (n * k))
Goal: m.Coprime n
-- Nat.Coprime.coprime_div_left
theorem Coprime.coprime_div_left (cmn : Coprime m n) (dvd : a ∣ m) : Coprime (m / a) n 
Arguments: {m n a : Nat} (cmn : m.Coprime n) (dvd : a ∣ m)
Goal: (m / a).Coprime n
-- Nat.Coprime.coprime_div_right
theorem Coprime.coprime_div_right (cmn : Coprime m n) (dvd : a ∣ n) : Coprime m (n / a) 
Arguments: {m n a : Nat} (cmn : m.Coprime n) (dvd : a ∣ n)
Goal: m.Coprime (n / a)
-- Nat.coprime_mul_iff_left
theorem coprime_mul_iff_left : Coprime (m * n) k ↔ Coprime m k ∧ Coprime n k 
Arguments: {m n k : Nat}
Goal: (m * n).Coprime k ↔ m.Coprime k ∧ n.Coprime k
-- Nat.coprime_mul_iff_right
theorem coprime_mul_iff_right : Coprime k (m * n) ↔ Coprime k m ∧ Coprime k n 
Arguments: {k m n : Nat}
Goal: k.Coprime (m * n) ↔ k.Coprime m ∧ k.Coprime n
-- Nat.Coprime.gcd_left
theorem Coprime.gcd_left (k : Nat) (hmn : Coprime m n) : Coprime (gcd k m) n 
Arguments: {m n : Nat} (k : Nat) (hmn : m.Coprime n)
Goal: (k.gcd m).Coprime n
-- Nat.Coprime.gcd_right
theorem Coprime.gcd_right (k : Nat) (hmn : Coprime m n) : Coprime m (gcd k n) 
Arguments: {m n : Nat} (k : Nat) (hmn : m.Coprime n)
Goal: m.Coprime (k.gcd n)
-- Nat.Coprime.gcd_both
theorem Coprime.gcd_both (k l : Nat) (hmn : Coprime m n) : Coprime (gcd k m) (gcd l n) 
Arguments: {m n : Nat} (k l : Nat) (hmn : m.Coprime n)
Goal: (k.gcd m).Coprime (l.gcd n)
-- Nat.Coprime.mul_dvd_of_dvd_of_dvd
theorem Coprime.mul_dvd_of_dvd_of_dvd (hmn : Coprime m n) (hm : m ∣ a) (hn : n ∣ a) : m * n ∣ a 
Arguments: {m n a : Nat} (hmn : m.Coprime n) (hm : m ∣ a) (hn : n ∣ a)
Goal: m * n ∣ a
-- Nat.coprime_zero_left
@[simp] theorem coprime_zero_left (n : Nat) : Coprime 0 n ↔ n = 1 
Arguments: (n : Nat)
Goal: Nat.Coprime 0 n ↔ n = 1
-- Nat.coprime_zero_right
@[simp] theorem coprime_zero_right (n : Nat) : Coprime n 0 ↔ n = 1 
Arguments: (n : Nat)
Goal: n.Coprime 0 ↔ n = 1
-- Nat.coprime_one_left
theorem coprime_one_left : ∀ n, Coprime 1 n 
Arguments: (n : Nat)
Goal: Nat.Coprime 1 n
-- Nat.coprime_one_right
theorem coprime_one_right : ∀ n, Coprime n 1 
Arguments: (n : Nat)
Goal: n.Coprime 1
-- Nat.coprime_one_left_eq_true
@[simp] theorem coprime_one_left_eq_true (n) : Coprime 1 n = True 
Arguments: (n : Nat)
Goal: Nat.Coprime 1 n = True
-- Nat.coprime_one_right_eq_true
@[simp] theorem coprime_one_right_eq_true (n) : Coprime n 1 = True 
Arguments: (n : Nat)
Goal: n.Coprime 1 = True
-- Nat.coprime_self
@[simp] theorem coprime_self (n : Nat) : Coprime n n ↔ n = 1 
Arguments: (n : Nat)
Goal: n.Coprime n ↔ n = 1
-- Nat.Coprime.pow_left
theorem Coprime.pow_left (n : Nat) (H1 : Coprime m k) : Coprime (m ^ n) k 
Arguments: {m k : Nat} (n : Nat) (H1 : m.Coprime k)
Goal: (m ^ n).Coprime k
-- Nat.Coprime.pow_right
theorem Coprime.pow_right (n : Nat) (H1 : Coprime k m) : Coprime k (m ^ n) 
Arguments: {k m : Nat} (n : Nat) (H1 : k.Coprime m)
Goal: k.Coprime (m ^ n)
-- Nat.Coprime.pow
theorem Coprime.pow {k l : Nat} (m n : Nat) (H1 : Coprime k l) : Coprime (k ^ m) (l ^ n) 
Arguments: {k l : Nat} (m n : Nat) (H1 : k.Coprime l)
Goal: (k ^ m).Coprime (l ^ n)
-- Nat.Coprime.eq_one_of_dvd
theorem Coprime.eq_one_of_dvd {k m : Nat} (H : Coprime k m) (d : k ∣ m) : k = 1 
Arguments: {k m : Nat} (H : k.Coprime m) (d : k ∣ m)
Goal: k = 1
-- Nat.Coprime.gcd_mul
theorem Coprime.gcd_mul (k : Nat) (h : Coprime m n) : gcd k (m * n) = gcd k m * gcd k n 
Arguments: {m n : Nat} (k : Nat) (h : m.Coprime n)
Goal: k.gcd (m * n) = k.gcd m * k.gcd n
-- Nat.gcd_mul_gcd_of_coprime_of_mul_eq_mul
theorem gcd_mul_gcd_of_coprime_of_mul_eq_mul
    (cop : Coprime c d) (h : a * b = c * d) : a.gcd c * b.gcd c = c 
Arguments: {c d a b : Nat} (cop : c.Coprime d) (h : a * b = c * d)
Goal: a.gcd c * b.gcd c = c
-- Thunk.ext
@[ext] protected theorem ext : {a b : Thunk α} → a.get = b.get → a = b
  
Arguments: {α : Type u_1} {a b : Thunk α}
Goal: a.get = b.get → a = b
-- String.Pos.ne_zero_of_lt
protected theorem Pos.ne_zero_of_lt : {a b : Pos} → a < b → b ≠ 0
  
Arguments: {a b : String.Pos}
Goal: a < b → b ≠ 0
-- Batteries.HashMap.LawfulHashable.hash_eq
class LawfulHashable (α : Type _) [BEq α] [Hashable α] : Prop where
    hash_eq {a b : α} : a == b → hash a = hash b
Arguments: {α : Type u_1} [BEq α] [Hashable α] [self : Batteries.HashMap.LawfulHashable α] {a b : α}
Goal: (a == b) = true → hash a = hash b
-- Batteries.HashMap.Imp.Buckets.update_size
@[simp] theorem update_size (self : Buckets α β) (i d h) :
    (self.update i d h).1.size = self.1.size 
Arguments: {α : Type u_1} {β : Type u_2} (self : Batteries.HashMap.Imp.Buckets α β) (i : USize) (d : Batteries.AssocList α β) (h : i.toNat < self.val.size)
Goal: (self.update i d h).val.size = self.val.size
-- Batteries.HashMap.Imp.Buckets.WF.distinct
structure WF [BEq α] [Hashable α] (buckets : Buckets α β) : Prop where
    distinct [LawfulHashable α] [PartialEquivBEq α] : ∀ bucket ∈ buckets.1.data,
    bucket.toList.Pairwise fun a b => ¬(a.1 == b.1)
    hash_self (i : Nat) (h : i < buckets.1.size) :
    buckets.1[i].All fun k _ => ((hash k).toUSize % buckets.1.size).toNat = i
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [Hashable α] {buckets : Batteries.HashMap.Imp.Buckets α β} (self : buckets.WF) [Batteries.HashMap.LawfulHashable α] [PartialEquivBEq α] (bucket : Batteries.AssocList α β)
Goal: bucket ∈ buckets.val.data → List.Pairwise (fun a b => ¬(a.fst == b.fst) = true) bucket.toList
-- Batteries.HashMap.Imp.Buckets.WF.hash_self
structure WF [BEq α] [Hashable α] (buckets : Buckets α β) : Prop where
    distinct [LawfulHashable α] [PartialEquivBEq α] : ∀ bucket ∈ buckets.1.data,
    bucket.toList.Pairwise fun a b => ¬(a.1 == b.1)
    hash_self (i : Nat) (h : i < buckets.1.size) :
    buckets.1[i].All fun k _ => ((hash k).toUSize % buckets.1.size).toNat = i
Arguments: {α : Type u_1} {β : Type u_2} [BEq α] [Hashable α] {buckets : Batteries.HashMap.Imp.Buckets α β} (self : buckets.WF) (i : Nat) (h : i < buckets.val.size)
Goal: Batteries.AssocList.All (fun k x => ((hash k).toUSize % buckets.val.size).toNat = i) buckets.val[i]
-- Batteries.HashMap.Imp.WF.empty
theorem WF.empty [BEq α] [Hashable α] : WF (empty n : Imp α β) 
Arguments: {α : Type u_1} {β : Type u_2} {n : Nat} [BEq α] [Hashable α]
Goal: (Batteries.HashMap.Imp.empty n).WF
-- Char.ext
@[ext] theorem Char.ext : {a b : Char} → a.val = b.val → a = b
  
Arguments: {a b : Char}
Goal: a.val = b.val → a = b
-- Char.ext_iff
theorem Char.ext_iff {x y : Char} : x = y ↔ x.val = y.val 
Arguments: {x y : Char}
Goal: x = y ↔ x.val = y.val
-- Char.le_antisymm_iff
theorem Char.le_antisymm_iff {x y : Char} : x = y ↔ x ≤ y ∧ y ≤ x 
Arguments: {x y : Char}
Goal: x = y ↔ x ≤ y ∧ y ≤ x
-- Char.le_antisymm
theorem Char.le_antisymm {x y : Char} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
Arguments: {x y : Char} (h1 : x ≤ y) (h2 : y ≤ x)
Goal: x = y
-- Fin.le_antisymm_iff
protected theorem le_antisymm_iff {x y : Fin n} : x = y ↔ x ≤ y ∧ y ≤ x 
Arguments: {n : Nat} {x y : Fin n}
Goal: x = y ↔ x ≤ y ∧ y ≤ x
-- Fin.le_antisymm
protected theorem le_antisymm {x y : Fin n} (h1 : x ≤ y) (h2 : y ≤ x) : x = y 
Arguments: {n : Nat} {x y : Fin n} (h1 : x ≤ y) (h2 : y ≤ x)
Goal: x = y
-- Fin.coe_clamp
@[simp] theorem coe_clamp (n m : Nat) : (clamp n m : Nat) = min n m 
Arguments: (n m : Nat)
Goal: ↑(Fin.clamp n m) = min n m
-- Fin.size_enum
@[simp] theorem size_enum (n) : (enum n).size = n 
Arguments: (n : Nat)
Goal: (Fin.enum n).size = n
-- Fin.enum_zero
@[simp] theorem enum_zero : (enum 0) = #[] 
Goal: Fin.enum 0 = #[]
-- Fin.getElem_enum
@[simp] theorem getElem_enum (i) (h : i < (enum n).size) : (enum n)[i] = ⟨i, size_enum n ▸ h⟩ 
Arguments: {n : Nat} (i : Nat) (h : i < (Fin.enum n).size)
Goal: (Fin.enum n)[i] = ⟨i, ⋯⟩
-- Fin.length_list
@[simp] theorem length_list (n) : (list n).length = n 
Arguments: (n : Nat)
Goal: (Fin.list n).length = n
-- Fin.getElem_list
@[simp] theorem getElem_list (i : Nat) (h : i < (list n).length) :
    (list n)[i] = cast (length_list n) ⟨i, h⟩ 
Arguments: {n : Nat} (i : Nat) (h : i < (Fin.list n).length)
Goal: (Fin.list n)[i] = Fin.cast ⋯ ⟨i, h⟩
-- Fin.get_list
@[deprecated getElem_list (since := "2024-06-12")]
theorem get_list (i : Fin (list n).length) : (list n).get i = i.cast (length_list n) 
Arguments: {n : Nat} (i : Fin (Fin.list n).length)
Goal: (Fin.list n).get i = Fin.cast ⋯ i
-- Fin.list_zero
@[simp] theorem list_zero : list 0 = [] 
Goal: Fin.list 0 = []
-- Fin.list_succ
theorem list_succ (n) : list (n+1) = 0 :: (list n).map Fin.succ 
Arguments: (n : Nat)
Goal: Fin.list (n + 1) = 0 :: List.map Fin.succ (Fin.list n)
-- Fin.list_succ_last
theorem list_succ_last (n) : list (n+1) = (list n).map castSucc ++ [last n] 
Arguments: (n : Nat)
Goal: Fin.list (n + 1) = List.map Fin.castSucc (Fin.list n) ++ [Fin.last n]
-- Fin.list_reverse
theorem list_reverse (n) : (list n).reverse = (list n).map rev 
Arguments: (n : Nat)
Goal: (Fin.list n).reverse = List.map Fin.rev (Fin.list n)
-- Fin.foldl_loop_lt
theorem foldl_loop_lt (f : α → Fin n → α) (x) (h : m < n) :
    foldl.loop n f x m = foldl.loop n f (f x ⟨m, h⟩) (m+1) 
Arguments: {α : Sort u_1} {n m : Nat} (f : α → Fin n → α) (x : α) (h : m < n)
Goal: Fin.foldl.loop n f x m = Fin.foldl.loop n f (f x ⟨m, h⟩) (m + 1)
-- Fin.foldl_loop_eq
theorem foldl_loop_eq (f : α → Fin n → α) (x) : foldl.loop n f x n = x 
Arguments: {α : Sort u_1} {n : Nat} (f : α → Fin n → α) (x : α)
Goal: Fin.foldl.loop n f x n = x
-- Fin.foldl_loop
theorem foldl_loop (f : α → Fin (n+1) → α) (x) (h : m < n+1) :
    foldl.loop (n+1) f x m = foldl.loop n (fun x i => f x i.succ) (f x ⟨m, h⟩) m 
Arguments: {α : Sort u_1} {n m : Nat} (f : α → Fin (n + 1) → α) (x : α) (h : m < n + 1)
Goal: Fin.foldl.loop (n + 1) f x m = Fin.foldl.loop n (fun x i => f x i.succ) (f x ⟨m, h⟩) m
-- Fin.foldl_zero
@[simp] theorem foldl_zero (f : α → Fin 0 → α) (x) : foldl 0 f x = x 
Arguments: {α : Sort u_1} (f : α → Fin 0 → α) (x : α)
Goal: Fin.foldl 0 f x = x
-- Fin.foldl_succ
theorem foldl_succ (f : α → Fin (n+1) → α) (x) :
    foldl (n+1) f x = foldl n (fun x i => f x i.succ) (f x 0) 
Arguments: {α : Sort u_1} {n : Nat} (f : α → Fin (n + 1) → α) (x : α)
Goal: Fin.foldl (n + 1) f x = Fin.foldl n (fun x i => f x i.succ) (f x 0)
-- Fin.foldl_succ_last
theorem foldl_succ_last (f : α → Fin (n+1) → α) (x) :
    foldl (n+1) f x = f (foldl n (f · ·.castSucc) x) (last n) 
Arguments: {α : Sort u_1} {n : Nat} (f : α → Fin (n + 1) → α) (x : α)
Goal: Fin.foldl (n + 1) f x = f (Fin.foldl n (fun x x_1 => f x x_1.castSucc) x) (Fin.last n)
-- Fin.foldl_eq_foldl_list
theorem foldl_eq_foldl_list (f : α → Fin n → α) (x) : foldl n f x = (list n).foldl f x 
Arguments: {α : Type u_1} {n : Nat} (f : α → Fin n → α) (x : α)
Goal: Fin.foldl n f x = List.foldl f x (Fin.list n)
-- Fin.foldr_loop_zero
theorem foldr_loop_zero (f : Fin n → α → α) (x) : foldr.loop n f ⟨0, Nat.zero_le _⟩ x = x 
Arguments: {n : Nat} {α : Sort u_1} (f : Fin n → α → α) (x : α)
Goal: Fin.foldr.loop n f ⟨0, ⋯⟩ x = x
-- Fin.foldr_loop_succ
theorem foldr_loop_succ (f : Fin n → α → α) (x) (h : m < n) :
    foldr.loop n f ⟨m+1, h⟩ x = foldr.loop n f ⟨m, Nat.le_of_lt h⟩ (f ⟨m, h⟩ x) 
Arguments: {n : Nat} {α : Sort u_1} {m : Nat} (f : Fin n → α → α) (x : α) (h : m < n)
Goal: Fin.foldr.loop n f ⟨m + 1, h⟩ x = Fin.foldr.loop n f ⟨m, ⋯⟩ (f ⟨m, h⟩ x)
-- Fin.foldr_loop
theorem foldr_loop (f : Fin (n+1) → α → α) (x) (h : m+1 ≤ n+1) :
    foldr.loop (n+1) f ⟨m+1, h⟩ x =
      f 0 (foldr.loop n (fun i => f i.succ) ⟨m, Nat.le_of_succ_le_succ h⟩ x) 
Arguments: {n : Nat} {α : Sort u_1} {m : Nat} (f : Fin (n + 1) → α → α) (x : α) (h : m + 1 ≤ n + 1)
Goal: Fin.foldr.loop (n + 1) f ⟨m + 1, h⟩ x = f 0 (Fin.foldr.loop n (fun i => f i.succ) ⟨m, ⋯⟩ x)
-- Fin.foldr_zero
@[simp] theorem foldr_zero (f : Fin 0 → α → α) (x) :
    foldr 0 f x = x 
Arguments: {α : Sort u_1} (f : Fin 0 → α → α) (x : α)
Goal: Fin.foldr 0 f x = x
-- Fin.foldr_succ
theorem foldr_succ (f : Fin (n+1) → α → α) (x) :
    foldr (n+1) f x = f 0 (foldr n (fun i => f i.succ) x) 
Arguments: {n : Nat} {α : Sort u_1} (f : Fin (n + 1) → α → α) (x : α)
Goal: Fin.foldr (n + 1) f x = f 0 (Fin.foldr n (fun i => f i.succ) x)
-- Fin.foldr_succ_last
theorem foldr_succ_last (f : Fin (n+1) → α → α) (x) :
    foldr (n+1) f x = foldr n (f ·.castSucc) (f (last n) x) 
Arguments: {n : Nat} {α : Sort u_1} (f : Fin (n + 1) → α → α) (x : α)
Goal: Fin.foldr (n + 1) f x = Fin.foldr n (fun x => f x.castSucc) (f (Fin.last n) x)
-- Fin.foldr_eq_foldr_list
theorem foldr_eq_foldr_list (f : Fin n → α → α) (x) : foldr n f x = (list n).foldr f x 
Arguments: {n : Nat} {α : Type u_1} (f : Fin n → α → α) (x : α)
Goal: Fin.foldr n f x = List.foldr f x (Fin.list n)
-- Fin.foldl_rev
theorem foldl_rev (f : Fin n → α → α) (x) :
    foldl n (fun x i => f i.rev x) x = foldr n f x 
Arguments: {n : Nat} {α : Sort u_1} (f : Fin n → α → α) (x : α)
Goal: Fin.foldl n (fun x i => f i.rev x) x = Fin.foldr n f x
-- Fin.foldr_rev
theorem foldr_rev (f : α → Fin n → α) (x) :
     foldr n (fun i x => f x i.rev) x = foldl n f x 
Arguments: {α : Sort u_1} {n : Nat} (f : α → Fin n → α) (x : α)
Goal: Fin.foldr n (fun i x => f x i.rev) x = Fin.foldl n f x
-- Batteries.RBNode.All.imp
theorem All.imp (H : ∀ {x : α}, p x → q x) : ∀ {t : RBNode α}, t.All p → t.All q
  
Arguments: {α : Type u_1} {p q : α → Prop} (H : ∀ {x : α}, p x → q x) {t : Batteries.RBNode α}
Goal: Batteries.RBNode.All p t → Batteries.RBNode.All q t
-- Batteries.RBNode.all_iff
theorem all_iff {t : RBNode α} : t.all p ↔ t.All (p ·) 
Arguments: {α : Type u_1} {p : α → Bool} {t : Batteries.RBNode α}
Goal: Batteries.RBNode.all p t = true ↔ Batteries.RBNode.All (fun x => p x = true) t
-- Batteries.RBNode.any_iff
theorem any_iff {t : RBNode α} : t.any p ↔ t.Any (p ·) 
Arguments: {α : Type u_1} {p : α → Bool} {t : Batteries.RBNode α}
Goal: Batteries.RBNode.any p t = true ↔ Batteries.RBNode.Any (fun x => p x = true) t
-- Batteries.RBNode.cmpLT_iff
theorem cmpLT_iff [TransCmp cmp] : cmpLT cmp x y ↔ cmp x y = .lt 
Goal: ∀ {α : Sort u_1} {cmp : α → α → Ordering} {x y : α} [inst : Batteries.TransCmp cmp],
  Batteries.RBNode.cmpLT cmp x y ↔ cmp x y = Ordering.lt
-- Batteries.RBNode.cmpEq_iff
theorem cmpEq_iff [TransCmp cmp] : cmpEq cmp x y ↔ cmp x y = .eq 
Goal: ∀ {α : Sort u_1} {cmp : α → α → Ordering} {x y : α} [inst : Batteries.TransCmp cmp],
  Batteries.RBNode.cmpEq cmp x y ↔ cmp x y = Ordering.eq
-- Batteries.RBSet.ModifyWF.wf
class ModifyWF (t : RBSet α cmp) (cut : α → Ordering) (f : α → α) : Prop where
    wf : (t.1.modify cut f).WF cmp
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {t : Batteries.RBSet α cmp} {cut : α → Ordering} {f : α → α} [self : t.ModifyWF cut f]
Goal: Batteries.RBNode.WF cmp (Batteries.RBNode.modify cut f t.val)
-- Batteries.RBSet.AlterWF.wf
class AlterWF (t : RBSet α cmp) (cut : α → Ordering) (f : Option α → Option α) : Prop where
    wf : (t.1.alter cut f).WF cmp
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {t : Batteries.RBSet α cmp} {cut : α → Ordering} {f : Option α → Option α} [self : t.AlterWF cut f]
Goal: Batteries.RBNode.WF cmp (Batteries.RBNode.alter cut f t.val)
-- Batteries.RBNode.Path.zoom_fill'
theorem zoom_fill' (cut : α → Ordering) (t : RBNode α) (path : Path α) :
    fill' (zoom cut t path) = path.fill t 
Arguments: {α : Type u_1} (cut : α → Ordering) (t : Batteries.RBNode α) (path : Batteries.RBNode.Path α)
Goal: Batteries.RBNode.Path.fill' (Batteries.RBNode.zoom cut t path) = path.fill t
-- Batteries.RBNode.Path.zoom_fill
theorem zoom_fill (H : zoom cut t path = (t', path')) : path.fill t = path'.fill t' 
Goal: ∀ {α : Type u_1} {cut : α → Ordering} {t : Batteries.RBNode α} {path : Batteries.RBNode.Path α}
  {t' : Batteries.RBNode α} {path' : Batteries.RBNode.Path α},
  Batteries.RBNode.zoom cut t path = (t', path') → path.fill t = path'.fill t'