ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Prime.dvd_prod_iff
theorem Prime.dvd_prod_iff {p : M} {L : List M} (pp : Prime p) : p ∣ L.prod ↔ ∃ a ∈ L, p ∣ a 
Arguments: {M : Type u_1} [CommMonoidWithZero M] {p : M} {L : List M} (pp : Prime p)
Goal: p ∣ L.prod ↔ ∃ a ∈ L, p ∣ a
-- Prime.not_dvd_prod
theorem Prime.not_dvd_prod {p : M} {L : List M} (pp : Prime p) (hL : ∀ a ∈ L, ¬p ∣ a) :
    ¬p ∣ L.prod 
Arguments: {M : Type u_1} [CommMonoidWithZero M] {p : M} {L : List M} (pp : Prime p) (hL : ∀ a ∈ L, ¬p ∣ a)
Goal: ¬p ∣ L.prod
-- mem_list_primes_of_dvd_prod
theorem mem_list_primes_of_dvd_prod {p : M} (hp : Prime p) {L : List M} (hL : ∀ q ∈ L, Prime q)
    (hpL : p ∣ L.prod) : p ∈ L 
Arguments: {M : Type u_1} [CancelCommMonoidWithZero M] [Unique Mˣ] {p : M} (hp : Prime p) {L : List M} (hL : ∀ q ∈ L, Prime q) (hpL : p ∣ L.prod)
Goal: p ∈ L
-- perm_of_prod_eq_prod
theorem perm_of_prod_eq_prod :
    ∀ {l₁ l₂ : List M}, l₁.prod = l₂.prod → (∀ p ∈ l₁, Prime p) → (∀ p ∈ l₂, Prime p) → Perm l₁ l₂
  
Arguments: {M : Type u_1} [CancelCommMonoidWithZero M] [Unique Mˣ] {l₁ l₂ : List M}
Goal: l₁.prod = l₂.prod → (∀ p ∈ l₁, Prime p) → (∀ p ∈ l₂, Prime p) → l₁ ~ l₂
-- List.join_singleton
theorem join_singleton (l : List α) : [l].join = l 
Arguments: {α : Type u_1} (l : List α)
Goal: [l].join = l
-- List.join_eq_nil
@[simp]
theorem join_eq_nil : ∀ {L : List (List α)}, join L = [] ↔ ∀ l ∈ L, l = []
  
Arguments: {α : Type u_1} {L : List (List α)}
Goal: L.join = [] ↔ ∀ (l : List α), l ∈ L → l = []
-- List.join_append
@[simp]
theorem join_append (L₁ L₂ : List (List α)) : join (L₁ ++ L₂) = join L₁ ++ join L₂ 
Arguments: {α : Type u_1} (L₁ L₂ : List (List α))
Goal: (L₁ ++ L₂).join = L₁.join ++ L₂.join
-- List.join_concat
theorem join_concat (L : List (List α)) (l : List α) : join (L.concat l) = join L ++ l 
Arguments: {α : Type u_1} (L : List (List α)) (l : List α)
Goal: (L.concat l).join = L.join ++ l
-- List.join_filter_not_isEmpty
@[simp]
theorem join_filter_not_isEmpty  :
    ∀ {L : List (List α)}, join (L.filter fun l => !l.isEmpty) = L.join
  
Arguments: {α : Type u_1} {L : List (List α)}
Goal: (List.filter (fun l => !l.isEmpty) L).join = L.join
-- List.join_filter_ne_nil
@[simp]
theorem join_filter_ne_nil [DecidablePred fun l : List α => l ≠ []] {L : List (List α)} :
    join (L.filter fun l => l ≠ []) = L.join 
Arguments: {α : Type u_1} [DecidablePred fun l => l ≠ []] {L : List (List α)}
Goal: (List.filter (fun l => decide (l ≠ [])) L).join = L.join
-- List.join_join
theorem join_join (l : List (List (List α))) : l.join.join = (l.map join).join 
Arguments: {α : Type u_1} (l : List (List (List α)))
Goal: l.join.join = (List.map List.join l).join
-- List.length_join'
lemma length_join' (L : List (List α)) : length (join L) = Nat.sum (map length L) 
Arguments: {α : Type u_1} (L : List (List α))
Goal: L.join.length = Nat.sum (List.map List.length L)
-- List.countP_join'
lemma countP_join' (p : α → Bool) :
    ∀ L : List (List α), countP p L.join = Nat.sum (L.map (countP p))
  
Arguments: {α : Type u_1} (p : α → Bool) (L : List (List α))
Goal: List.countP p L.join = Nat.sum (List.map (List.countP p) L)
-- List.count_join'
lemma count_join' [BEq α] (L : List (List α)) (a : α) :
    L.join.count a = Nat.sum (L.map (count a)) 
Arguments: {α : Type u_1} [BEq α] (L : List (List α)) (a : α)
Goal: List.count a L.join = Nat.sum (List.map (List.count a) L)
-- List.length_bind'
lemma length_bind' (l : List α) (f : α → List β) :
    length (l.bind f) = Nat.sum (map (length ∘ f) l) 
Arguments: {α : Type u_1} {β : Type u_2} (l : List α) (f : α → List β)
Goal: (l.bind f).length = Nat.sum (List.map (List.length ∘ f) l)
-- List.countP_bind'
lemma countP_bind' (p : β → Bool) (l : List α) (f : α → List β) :
    countP p (l.bind f) = Nat.sum (map (countP p ∘ f) l) 
Arguments: {α : Type u_1} {β : Type u_2} (p : β → Bool) (l : List α) (f : α → List β)
Goal: List.countP p (l.bind f) = Nat.sum (List.map (List.countP p ∘ f) l)
-- List.count_bind'
lemma count_bind' [BEq β] (l : List α) (f : α → List β) (x : β) :
    count x (l.bind f) = Nat.sum (map (count x ∘ f) l) 
Arguments: {α : Type u_1} {β : Type u_2} [BEq β] (l : List α) (f : α → List β) (x : β)
Goal: List.count x (l.bind f) = Nat.sum (List.map (List.count x ∘ f) l)
-- List.bind_eq_nil
@[simp]
theorem bind_eq_nil {l : List α} {f : α → List β} : List.bind l f = [] ↔ ∀ x ∈ l, f x = [] 
Arguments: {α : Type u_1} {β : Type u_2} {l : List α} {f : α → List β}
Goal: l.bind f = [] ↔ ∀ (x : α), x ∈ l → f x = []
-- List.take_sum_join'
theorem take_sum_join' (L : List (List α)) (i : ℕ) :
    L.join.take (Nat.sum ((L.map length).take i)) = (L.take i).join 
Arguments: {α : Type u_1} (L : List (List α)) (i : ℕ)
Goal: List.take (Nat.sum (List.take i (List.map List.length L))) L.join = (List.take i L).join
-- List.drop_sum_join'
theorem drop_sum_join' (L : List (List α)) (i : ℕ) :
    L.join.drop (Nat.sum ((L.map length).take i)) = (L.drop i).join 
Arguments: {α : Type u_1} (L : List (List α)) (i : ℕ)
Goal: List.drop (Nat.sum (List.take i (List.map List.length L))) L.join = (List.drop i L).join
-- List.drop_take_succ_eq_cons_getElem
theorem drop_take_succ_eq_cons_getElem (L : List α) (i : Nat) (h : i < L.length) :
    (L.take (i + 1)).drop i = [L[i]] 
Arguments: {α : Type u_1} (L : List α) (i : ℕ) (h : i < L.length)
Goal: List.drop i (List.take (i + 1) L) = [L[i]]
-- List.drop_take_succ_eq_cons_get
@[deprecated drop_take_succ_eq_cons_getElem (since := "2024-06-11")]
theorem drop_take_succ_eq_cons_get (L : List α) (i : Fin L.length) :
    (L.take (i + 1)).drop i = [get L i] 
Arguments: {α : Type u_1} (L : List α) (i : Fin L.length)
Goal: List.drop (↑i) (List.take (↑i + 1) L) = [L.get i]
-- List.drop_take_succ_eq_cons_nthLe
@[deprecated drop_take_succ_eq_cons_get (since := "2023-01-10")]
theorem drop_take_succ_eq_cons_nthLe (L : List α) {i : ℕ} (hi : i < L.length) :
    (L.take (i + 1)).drop i = [nthLe L i hi] 
Arguments: {α : Type u_1} (L : List α) {i : ℕ} (hi : i < L.length)
Goal: List.drop i (List.take (i + 1) L) = [L.nthLe i hi]
-- List.drop_take_succ_join_eq_getElem'
theorem drop_take_succ_join_eq_getElem' (L : List (List α)) (i : Nat) (h : i <  L.length) :
    (L.join.take (Nat.sum ((L.map length).take (i + 1)))).drop (Nat.sum ((L.map length).take i)) =
      L[i] 
Arguments: {α : Type u_1} (L : List (List α)) (i : ℕ) (h : i < L.length)
Goal: List.drop (Nat.sum (List.take i (List.map List.length L)))
    (List.take (Nat.sum (List.take (i + 1) (List.map List.length L))) L.join) =
  L[i]
-- List.drop_take_succ_join_eq_get'
@[deprecated drop_take_succ_join_eq_getElem' (since := "2024-06-11")]
theorem drop_take_succ_join_eq_get' (L : List (List α)) (i : Fin L.length) :
    (L.join.take (Nat.sum ((L.map length).take (i + 1)))).drop (Nat.sum ((L.map length).take i)) =
      get L i 
Arguments: {α : Type u_1} (L : List (List α)) (i : Fin L.length)
Goal: List.drop (Nat.sum (List.take (↑i) (List.map List.length L)))
    (List.take (Nat.sum (List.take (↑i + 1) (List.map List.length L))) L.join) =
  L.get i
-- List.eq_iff_join_eq
theorem eq_iff_join_eq (L L' : List (List α)) :
    L = L' ↔ L.join = L'.join ∧ map length L = map length L' 
Arguments: {α : Type u_1} (L L' : List (List α))
Goal: L = L' ↔ L.join = L'.join ∧ List.map List.length L = List.map List.length L'
-- List.join_drop_length_sub_one
theorem join_drop_length_sub_one {L : List (List α)} (h : L ≠ []) :
    (L.drop (L.length - 1)).join = L.getLast h 
Arguments: {α : Type u_1} {L : List (List α)} (h : L ≠ [])
Goal: (List.drop (L.length - 1) L).join = L.getLast h
-- List.append_join_map_append
theorem append_join_map_append (L : List (List α)) (x : List α) :
    x ++ (L.map (· ++ x)).join = (L.map (x ++ ·)).join ++ x 
Arguments: {α : Type u_1} (L : List (List α)) (x : List α)
Goal: x ++ (List.map (fun x_1 => x_1 ++ x) L).join = (List.map (fun x_1 => x ++ x_1) L).join ++ x
-- List.reverse_join
theorem reverse_join (L : List (List α)) :
    L.join.reverse = (L.map reverse).reverse.join 
Arguments: {α : Type u_1} (L : List (List α))
Goal: L.join.reverse = (List.map List.reverse L).reverse.join
-- List.join_reverse
theorem join_reverse (L : List (List α)) :
    L.reverse.join = (L.map reverse).join.reverse 
Arguments: {α : Type u_1} (L : List (List α))
Goal: L.reverse.join = (List.map List.reverse L).join.reverse
-- List.sublist_join
lemma sublist_join (L : List (List α)) {s : List α} (hs : s ∈ L) :
    s.Sublist L.join 
Arguments: {α : Type u_1} (L : List (List α)) {s : List α} (hs : s ∈ L)
Goal: s.Sublist L.join
-- List.dedup_nil
@[simp]
theorem dedup_nil : dedup [] = ([] : List α) 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: [].dedup = []
-- List.dedup_cons_of_mem'
theorem dedup_cons_of_mem' {a : α} {l : List α} (h : a ∈ dedup l) : dedup (a :: l) = dedup l 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l : List α} (h : a ∈ l.dedup)
Goal: (a :: l).dedup = l.dedup
-- List.dedup_cons_of_not_mem'
theorem dedup_cons_of_not_mem' {a : α} {l : List α} (h : a ∉ dedup l) :
    dedup (a :: l) = a :: dedup l 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l : List α} (h : a ∉ l.dedup)
Goal: (a :: l).dedup = a :: l.dedup
-- List.mem_dedup
@[simp]
theorem mem_dedup {a : α} {l : List α} : a ∈ dedup l ↔ a ∈ l 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l : List α}
Goal: a ∈ l.dedup ↔ a ∈ l
-- List.dedup_cons_of_mem
@[simp]
theorem dedup_cons_of_mem {a : α} {l : List α} (h : a ∈ l) : dedup (a :: l) = dedup l 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l : List α} (h : a ∈ l)
Goal: (a :: l).dedup = l.dedup
-- List.dedup_cons_of_not_mem
@[simp]
theorem dedup_cons_of_not_mem {a : α} {l : List α} (h : a ∉ l) : dedup (a :: l) = a :: dedup l 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l : List α} (h : a ∉ l)
Goal: (a :: l).dedup = a :: l.dedup
-- List.dedup_sublist
theorem dedup_sublist : ∀ l : List α, dedup l <+ l 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: l.dedup.Sublist l
-- List.dedup_subset
theorem dedup_subset : ∀ l : List α, dedup l ⊆ l 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: l.dedup ⊆ l
-- List.subset_dedup
theorem subset_dedup (l : List α) : l ⊆ dedup l 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: l ⊆ l.dedup
-- List.nodup_dedup
theorem nodup_dedup : ∀ l : List α, Nodup (dedup l) 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: l.dedup.Nodup
-- List.headI_dedup
theorem headI_dedup [Inhabited α] (l : List α) :
    l.dedup.headI = if l.headI ∈ l.tail then l.tail.dedup.headI else l.headI 
Arguments: {α : Type u_1} [DecidableEq α] [Inhabited α] (l : List α)
Goal: l.dedup.headI = if l.headI ∈ l.tail then l.tail.dedup.headI else l.headI
-- List.tail_dedup
theorem tail_dedup [Inhabited α] (l : List α) :
    l.dedup.tail = if l.headI ∈ l.tail then l.tail.dedup.tail else l.tail.dedup 
Arguments: {α : Type u_1} [DecidableEq α] [Inhabited α] (l : List α)
Goal: l.dedup.tail = if l.headI ∈ l.tail then l.tail.dedup.tail else l.tail.dedup
-- List.dedup_eq_self
theorem dedup_eq_self {l : List α} : dedup l = l ↔ Nodup l 
Arguments: {α : Type u_1} [DecidableEq α] {l : List α}
Goal: l.dedup = l ↔ l.Nodup
-- List.dedup_eq_cons
theorem dedup_eq_cons (l : List α) (a : α) (l' : List α) :
    l.dedup = a :: l' ↔ a ∈ l ∧ a ∉ l' ∧ l.dedup.tail = l' 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (a : α) (l' : List α)
Goal: l.dedup = a :: l' ↔ a ∈ l ∧ a ∉ l' ∧ l.dedup.tail = l'
-- List.dedup_eq_nil
@[simp]
theorem dedup_eq_nil (l : List α) : l.dedup = [] ↔ l = [] 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: l.dedup = [] ↔ l = []
-- List.Nodup.dedup
protected theorem Nodup.dedup {l : List α} (h : l.Nodup) : l.dedup = l 
Arguments: {α : Type u_1} [DecidableEq α] {l : List α} (h : l.Nodup)
Goal: l.dedup = l
-- List.dedup_idem
@[simp]
theorem dedup_idem {l : List α} : dedup (dedup l) = dedup l 
Arguments: {α : Type u_1} [DecidableEq α] {l : List α}
Goal: l.dedup.dedup = l.dedup
-- List.dedup_append
theorem dedup_append (l₁ l₂ : List α) : dedup (l₁ ++ l₂) = l₁ ∪ dedup l₂ 
Arguments: {α : Type u_1} [DecidableEq α] (l₁ l₂ : List α)
Goal: (l₁ ++ l₂).dedup = l₁ ∪ l₂.dedup
-- List.dedup_map_of_injective
theorem dedup_map_of_injective [DecidableEq β] {f : α → β} (hf : Function.Injective f)
    (xs : List α) :
    (xs.map f).dedup = xs.dedup.map f 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq α] [DecidableEq β] {f : α → β} (hf : Function.Injective f) (xs : List α)
Goal: (List.map f xs).dedup = List.map f xs.dedup
-- List.Subset.dedup_append_right
theorem Subset.dedup_append_right {xs ys : List α} (h : xs ⊆ ys) :
    dedup (xs ++ ys) = dedup ys 
Arguments: {α : Type u_1} [DecidableEq α] {xs ys : List α} (h : xs ⊆ ys)
Goal: (xs ++ ys).dedup = ys.dedup
-- List.Disjoint.union_eq
theorem Disjoint.union_eq {xs ys : List α} (h : Disjoint xs ys) :
    xs ∪ ys = xs.dedup ++ ys 
Arguments: {α : Type u_1} [DecidableEq α] {xs ys : List α} (h : xs.Disjoint ys)
Goal: xs ∪ ys = xs.dedup ++ ys
-- List.Disjoint.dedup_append
theorem Disjoint.dedup_append {xs ys : List α} (h : Disjoint xs ys) :
    dedup (xs ++ ys) = dedup xs ++ dedup ys 
Arguments: {α : Type u_1} [DecidableEq α] {xs ys : List α} (h : xs.Disjoint ys)
Goal: (xs ++ ys).dedup = xs.dedup ++ ys.dedup
-- List.replicate_dedup
theorem replicate_dedup {x : α} : ∀ {k}, k ≠ 0 → (replicate k x).dedup = [x]
  
Arguments: {α : Type u_1} [DecidableEq α] {x : α} {k : ℕ}
Goal: k ≠ 0 → (List.replicate k x).dedup = [x]
-- List.count_dedup
theorem count_dedup (l : List α) (a : α) : l.dedup.count a = if a ∈ l then 1 else 0 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (a : α)
Goal: List.count a l.dedup = if a ∈ l then 1 else 0
-- List.Lex.cons_iff
theorem cons_iff {r : α → α → Prop} [IsIrrefl α r] {a l₁ l₂} :
    Lex r (a :: l₁) (a :: l₂) ↔ Lex r l₁ l₂ 
Arguments: {α : Type u} {r : α → α → Prop} [IsIrrefl α r] {a : α} {l₁ l₂ : List α}
Goal: List.Lex r (a :: l₁) (a :: l₂) ↔ List.Lex r l₁ l₂
-- List.Lex.not_nil_right
@[simp]
theorem not_nil_right (r : α → α → Prop) (l : List α) : ¬Lex r l [] 
Arguments: {α : Type u} (r : α → α → Prop) (l : List α)
Goal: ¬List.Lex r l []
-- List.Lex.nil_left_or_eq_nil
theorem nil_left_or_eq_nil {r : α → α → Prop} (l : List α) : List.Lex r [] l ∨ l = [] 
Arguments: {α : Type u} {r : α → α → Prop} (l : List α)
Goal: List.Lex r [] l ∨ l = []
-- List.Lex.singleton_iff
@[simp]
theorem singleton_iff {r : α → α → Prop} (a b : α) : List.Lex r [a] [b] ↔ r a b 
Arguments: {α : Type u} {r : α → α → Prop} (a b : α)
Goal: List.Lex r [a] [b] ↔ r a b
-- List.Lex.isOrderConnected.aux
instance isOrderConnected (r : α → α → Prop) [IsOrderConnected α r] [IsTrichotomous α r] :
    IsOrderConnected (List α) (Lex r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsOrderConnected α r] [IsTrichotomous α r]
Goal: ∀ (x x_1 x_2 : List α), List.Lex r x x_2 → List.Lex r x x_1 ∨ List.Lex r x_1 x_2
-- List.Lex.isTrichotomous.aux
instance isTrichotomous (r : α → α → Prop) [IsTrichotomous α r] :
    IsTrichotomous (List α) (Lex r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsTrichotomous α r]
Goal: ∀ (x x_1 : List α), List.Lex r x x_1 ∨ x = x_1 ∨ List.Lex r x_1 x
-- List.Lex.isAsymm.aux
instance isAsymm (r : α → α → Prop) [IsAsymm α r] : IsAsymm (List α) (Lex r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsAsymm α r]
Goal: ∀ (x x_1 : List α), List.Lex r x x_1 → List.Lex r x_1 x → False
-- List.Lex.append_right
theorem append_right (r : α → α → Prop) : ∀ {s₁ s₂} (t), Lex r s₁ s₂ → Lex r s₁ (s₂ ++ t)
  
Arguments: {α : Type u} (r : α → α → Prop) {s₁ s₂ : List α} (t : List α)
Goal: List.Lex r s₁ s₂ → List.Lex r s₁ (s₂ ++ t)
-- List.Lex.append_left
theorem append_left (R : α → α → Prop) {t₁ t₂} (h : Lex R t₁ t₂) : ∀ s, Lex R (s ++ t₁) (s ++ t₂)
  
Arguments: {α : Type u} (R : α → α → Prop) {t₁ t₂ : List α} (h : List.Lex R t₁ t₂) (s : List α)
Goal: List.Lex R (s ++ t₁) (s ++ t₂)
-- List.Lex.imp
theorem imp {r s : α → α → Prop} (H : ∀ a b, r a b → s a b) : ∀ l₁ l₂, Lex r l₁ l₂ → Lex s l₁ l₂
  
Arguments: {α : Type u} {r s : α → α → Prop} (H : ∀ (a b : α), r a b → s a b) (l₁ l₂ : List α)
Goal: List.Lex r l₁ l₂ → List.Lex s l₁ l₂
-- List.Lex.to_ne
theorem to_ne : ∀ {l₁ l₂ : List α}, Lex (· ≠ ·) l₁ l₂ → l₁ ≠ l₂
  
Arguments: {α : Type u} {l₁ l₂ : List α}
Goal: List.Lex (fun x x_1 => x ≠ x_1) l₁ l₂ → l₁ ≠ l₂
-- Decidable.List.Lex.ne_iff
theorem _root_.Decidable.List.Lex.ne_iff [DecidableEq α] {l₁ l₂ : List α}
    (H : length l₁ ≤ length l₂) : Lex (· ≠ ·) l₁ l₂ ↔ l₁ ≠ l₂ 
Arguments: {α : Type u} [DecidableEq α] {l₁ l₂ : List α} (H : l₁.length ≤ l₂.length)
Goal: List.Lex (fun x x_1 => x ≠ x_1) l₁ l₂ ↔ l₁ ≠ l₂
-- List.Lex.ne_iff
theorem ne_iff {l₁ l₂ : List α} (H : length l₁ ≤ length l₂) : Lex (· ≠ ·) l₁ l₂ ↔ l₁ ≠ l₂ 
Arguments: {α : Type u} {l₁ l₂ : List α} (H : l₁.length ≤ l₂.length)
Goal: List.Lex (fun x x_1 => x ≠ x_1) l₁ l₂ ↔ l₁ ≠ l₂
-- List.nil_lt_cons
theorem nil_lt_cons [LT α] (a : α) (l : List α) : [] < a :: l 
Arguments: {α : Type u} [LT α] (a : α) (l : List α)
Goal: [] < a :: l
-- List.lt_iff_lex_lt
theorem lt_iff_lex_lt [LinearOrder α] (l l' : List α) : lt l l' ↔ Lex (· < ·) l l' 
Arguments: {α : Type u} [LinearOrder α] (l l' : List α)
Goal: l.lt l' ↔ List.Lex (fun x x_1 => x < x_1) l l'
-- List.nil_le
@[simp]
theorem nil_le {α} [LinearOrder α] {l : List α} : [] ≤ l 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α}
Goal: [] ≤ l
-- List.head_le_of_lt
theorem head_le_of_lt [Preorder α] {a a' : α} {l l' : List α} (h : (a' :: l') < (a :: l)) :
    a' ≤ a 
Arguments: {α : Type u} [Preorder α] {a a' : α} {l l' : List α} (h : a' :: l' < a :: l)
Goal: a' ≤ a
-- List.head!_le_of_lt
theorem head!_le_of_lt [Preorder α] [Inhabited α] (l l' : List α) (h : l' < l) (hl' : l' ≠ []) :
    l'.head! ≤ l.head! 
Arguments: {α : Type u} [Preorder α] [Inhabited α] (l l' : List α) (h : l' < l) (hl' : l' ≠ [])
Goal: l'.head! ≤ l.head!
-- List.cons_le_cons
theorem cons_le_cons [LinearOrder α] (a : α) {l l' : List α} (h : l' ≤ l) :
    a :: l' ≤ a :: l 
Arguments: {α : Type u} [LinearOrder α] (a : α) {l l' : List α} (h : l' ≤ l)
Goal: a :: l' ≤ a :: l
-- List.length_ofFn_go
@[simp]
theorem length_ofFn_go {n} (f : Fin n → α) (i j h) : length (ofFn.go f i j h) = i 
Arguments: {α : Type u} {n : ℕ} (f : Fin n → α) (i j : ℕ) (h : i + j = n)
Goal: (List.ofFn.go f i j h).length = i
-- List.length_ofFn
@[simp]
theorem length_ofFn {n} (f : Fin n → α) : length (ofFn f) = n 
Arguments: {α : Type u} {n : ℕ} (f : Fin n → α)
Goal: (List.ofFn f).length = n
-- List.getElem_ofFn_go
theorem getElem_ofFn_go {n} (f : Fin n → α) (i j h) (k) (hk : k < (ofFn.go f i j h).length) :
    (ofFn.go f i j h)[k] = f ⟨j + k, by simp at hk; omega⟩ 
Arguments: {α : Type u} {n : ℕ} (f : Fin n → α) (i j : ℕ) (h : i + j = n) (k : ℕ) (hk : k < (List.ofFn.go f i j h).length)
Goal: (List.ofFn.go f i j h)[k] = f ⟨j + k, ⋯⟩
-- List.get_ofFn_go
theorem get_ofFn_go {n} (f : Fin n → α) (i j h) (k) (hk) :
    get (ofFn.go f i j h) ⟨k, hk⟩ = f ⟨j + k, by simp at hk; omega⟩ 
Arguments: {α : Type u} {n : ℕ} (f : Fin n → α) (i j : ℕ) (h : i + j = n) (k : ℕ) (hk : k < (List.ofFn.go f i j h).length)
Goal: (List.ofFn.go f i j h).get ⟨k, hk⟩ = f ⟨j + k, ⋯⟩
-- List.getElem_ofFn
@[simp]
theorem getElem_ofFn {n} (f : Fin n → α) (i : Nat) (h : i < (ofFn f).length) :
    (ofFn f)[i] = f ⟨i, by simp_all⟩ 
Arguments: {α : Type u} {n : ℕ} (f : Fin n → α) (i : ℕ) (h : i < (List.ofFn f).length)
Goal: (List.ofFn f)[i] = f ⟨i, ⋯⟩
-- List.get_ofFn
theorem get_ofFn {n} (f : Fin n → α) (i) : get (ofFn f) i = f (Fin.cast (by simp) i) 
Arguments: {α : Type u} {n : ℕ} (f : Fin n → α) (i : Fin (List.ofFn f).length)
Goal: (List.ofFn f).get i = f (Fin.cast ⋯ i)
-- List.getElem?_ofFn
@[simp]
theorem getElem?_ofFn {n} (f : Fin n → α) (i) : (ofFn f)[i]? = ofFnNthVal f i 
Arguments: {α : Type u} {n : ℕ} (f : Fin n → α) (i : ℕ)
Goal: (List.ofFn f)[i]? = List.ofFnNthVal f i
-- List.get?_ofFn
theorem get?_ofFn {n} (f : Fin n → α) (i) : get? (ofFn f) i = ofFnNthVal f i 
Arguments: {α : Type u} {n : ℕ} (f : Fin n → α) (i : ℕ)
Goal: (List.ofFn f).get? i = List.ofFnNthVal f i
-- List.nthLe_ofFn
@[deprecated get_ofFn (since := "2023-01-17")]
theorem nthLe_ofFn {n} (f : Fin n → α) (i : Fin n) :
    nthLe (ofFn f) i ((length_ofFn f).symm ▸ i.2) = f i 
Arguments: {α : Type u} {n : ℕ} (f : Fin n → α) (i : Fin n)
Goal: (List.ofFn f).nthLe ↑i ⋯ = f i
-- List.nthLe_ofFn'
@[simp, deprecated get_ofFn (since := "2023-01-17")]
theorem nthLe_ofFn' {n} (f : Fin n → α) {i : ℕ} (h : i < (ofFn f).length) :
    nthLe (ofFn f) i h = f ⟨i, length_ofFn f ▸ h⟩ 
Arguments: {α : Type u} {n : ℕ} (f : Fin n → α) {i : ℕ} (h : i < (List.ofFn f).length)
Goal: (List.ofFn f).nthLe i h = f ⟨i, ⋯⟩
-- List.map_ofFn
@[simp]
theorem map_ofFn {β : Type*} {n : ℕ} (f : Fin n → α) (g : α → β) :
    map g (ofFn f) = ofFn (g ∘ f) 
Arguments: {α : Type u} {β : Type u_1} {n : ℕ} (f : Fin n → α) (g : α → β)
Goal: List.map g (List.ofFn f) = List.ofFn (g ∘ f)
-- List.ofFn_congr
@[congr]
theorem ofFn_congr {m n : ℕ} (h : m = n) (f : Fin m → α) :
    ofFn f = ofFn fun i : Fin n => f (Fin.cast h.symm i) 
Arguments: {α : Type u} {m n : ℕ} (h : m = n) (f : Fin m → α)
Goal: List.ofFn f = List.ofFn fun i => f (Fin.cast ⋯ i)
-- List.ofFn_zero
@[simp]
theorem ofFn_zero (f : Fin 0 → α) : ofFn f = [] 
Arguments: {α : Type u} (f : Fin 0 → α)
Goal: List.ofFn f = []
-- List.ofFn_succ
@[simp]
theorem ofFn_succ {n} (f : Fin (succ n) → α) : ofFn f = f 0 :: ofFn fun i => f i.succ 
Arguments: {α : Type u} {n : ℕ} (f : Fin n.succ → α)
Goal: List.ofFn f = f 0 :: List.ofFn fun i => f i.succ
-- List.ofFn_succ'
theorem ofFn_succ' {n} (f : Fin (succ n) → α) :
    ofFn f = (ofFn fun i => f (Fin.castSucc i)).concat (f (Fin.last _)) 
Arguments: {α : Type u} {n : ℕ} (f : Fin n.succ → α)
Goal: List.ofFn f = (List.ofFn fun i => f i.castSucc).concat (f (Fin.last n))
-- List.ofFn_eq_nil_iff
@[simp]
theorem ofFn_eq_nil_iff {n : ℕ} {f : Fin n → α} : ofFn f = [] ↔ n = 0 
Arguments: {α : Type u} {n : ℕ} {f : Fin n → α}
Goal: List.ofFn f = [] ↔ n = 0
-- List.last_ofFn
theorem last_ofFn {n : ℕ} (f : Fin n → α) (h : ofFn f ≠ [])
    (hn : n - 1 < n := Nat.pred_lt <| ofFn_eq_nil_iff.not.mp h) :
    getLast (ofFn f) h = f ⟨n - 1, hn⟩ 
Arguments: {α : Type u} {n : ℕ} (f : Fin n → α) (h : List.ofFn f ≠ []) (hn : n - 1 < n := ⋯)
Goal: (List.ofFn f).getLast h = f ⟨n - 1, hn⟩
-- List.last_ofFn_succ
theorem last_ofFn_succ {n : ℕ} (f : Fin n.succ → α)
    (h : ofFn f ≠ [] := mt ofFn_eq_nil_iff.mp (Nat.succ_ne_zero _)) :
    getLast (ofFn f) h = f (Fin.last _) 
Arguments: {α : Type u} {n : ℕ} (f : Fin n.succ → α) (h : List.ofFn f ≠ [] := ⋯)
Goal: (List.ofFn f).getLast h = f (Fin.last n)
-- List.ofFn_add
theorem ofFn_add {m n} (f : Fin (m + n) → α) :
    List.ofFn f =
      (List.ofFn fun i => f (Fin.castAdd n i)) ++ List.ofFn fun j => f (Fin.natAdd m j) 
Arguments: {α : Type u} {m n : ℕ} (f : Fin (m + n) → α)
Goal: List.ofFn f = (List.ofFn fun i => f (Fin.castAdd n i)) ++ List.ofFn fun j => f (Fin.natAdd m j)
-- List.ofFn_fin_append
@[simp]
theorem ofFn_fin_append {m n} (a : Fin m → α) (b : Fin n → α) :
    List.ofFn (Fin.append a b) = List.ofFn a ++ List.ofFn b 
Arguments: {α : Type u} {m n : ℕ} (a : Fin m → α) (b : Fin n → α)
Goal: List.ofFn (Fin.append a b) = List.ofFn a ++ List.ofFn b
-- List.ofFn_mul
theorem ofFn_mul {m n} (f : Fin (m * n) → α) :
    List.ofFn f = List.join (List.ofFn fun i : Fin m => List.ofFn fun j : Fin n => f ⟨i * n + j,
    calc
      ↑i * n + j < (i + 1) * n :=
        (Nat.add_lt_add_left j.prop _).trans_eq (by rw [Nat.add_mul, Nat.one_mul])
      _ ≤ _ := Nat.mul_le_mul_right _ i.prop⟩) 
Arguments: {α : Type u} {m n : ℕ} (f : Fin (m * n) → α)
Goal: List.ofFn f = (List.ofFn fun i => List.ofFn fun j => f ⟨↑i * n + ↑j, ⋯⟩).join
-- List.ofFn_mul'
theorem ofFn_mul' {m n} (f : Fin (m * n) → α) :
    List.ofFn f = List.join (List.ofFn fun i : Fin n => List.ofFn fun j : Fin m => f ⟨m * i + j,
    calc
      m * i + j < m * (i + 1) :=
        (Nat.add_lt_add_left j.prop _).trans_eq (by rw [Nat.mul_add, Nat.mul_one])
      _ ≤ _ := Nat.mul_le_mul_left _ i.prop⟩) 
Arguments: {α : Type u} {m n : ℕ} (f : Fin (m * n) → α)
Goal: List.ofFn f = (List.ofFn fun i => List.ofFn fun j => f ⟨m * ↑i + ↑j, ⋯⟩).join
-- List.ofFn_get
@[simp]
theorem ofFn_get : ∀ l : List α, (ofFn (get l)) = l
  
Arguments: {α : Type u} (l : List α)
Goal: List.ofFn l.get = l
-- List.ofFn_getElem
@[simp]
theorem ofFn_getElem : ∀ l : List α, (ofFn (fun i : Fin l.length => l[(i : Nat)])) = l
  
Arguments: {α : Type u} (l : List α)
Goal: (List.ofFn fun i => l[↑i]) = l