ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.maximum_eq_none
@[simp, deprecated maximum_eq_bot "Don't mix Option and WithBot" (since := "2024-05-27")]
theorem maximum_eq_none {l : List α} : l.maximum = none ↔ l = [] 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] {l : List α}
Goal: l.maximum = none ↔ l = []
-- List.minimum_eq_top
@[simp]
theorem minimum_eq_top {l : List α} : l.minimum = ⊤ ↔ l = [] 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] {l : List α}
Goal: l.minimum = ⊤ ↔ l = []
-- List.minimum_eq_none
@[simp, deprecated minimum_eq_top "Don't mix Option and WithTop" (since := "2024-05-27")]
theorem minimum_eq_none {l : List α} : l.minimum = none ↔ l = [] 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] {l : List α}
Goal: l.minimum = none ↔ l = []
-- List.not_lt_maximum_of_mem
theorem not_lt_maximum_of_mem : a ∈ l → (maximum l : WithBot α) = m → ¬m < a 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] {l : List α} {a m : α}
Goal: a ∈ l → l.maximum = ↑m → ¬m < a
-- List.minimum_not_lt_of_mem
theorem minimum_not_lt_of_mem : a ∈ l → (minimum l : WithTop α) = m → ¬a < m 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] {l : List α} {a m : α}
Goal: a ∈ l → l.minimum = ↑m → ¬a < m
-- List.not_lt_maximum_of_mem'
theorem not_lt_maximum_of_mem' (ha : a ∈ l) : ¬maximum l < (a : WithBot α) 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] {l : List α} {a : α} (ha : a ∈ l)
Goal: ¬l.maximum < ↑a
-- List.not_lt_minimum_of_mem'
theorem not_lt_minimum_of_mem' (ha : a ∈ l) : ¬(a : WithTop α) < minimum l 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] {l : List α} {a : α} (ha : a ∈ l)
Goal: ¬↑a < l.minimum
-- List.maximum_concat
theorem maximum_concat (a : α) (l : List α) : maximum (l ++ [a]) = max (maximum l) a 
Arguments: {α : Type u_1} [LinearOrder α] (a : α) (l : List α)
Goal: (l ++ [a]).maximum = max l.maximum ↑a
-- List.le_maximum_of_mem
theorem le_maximum_of_mem : a ∈ l → (maximum l : WithBot α) = m → a ≤ m 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {a m : α}
Goal: a ∈ l → l.maximum = ↑m → a ≤ m
-- List.minimum_le_of_mem
theorem minimum_le_of_mem : a ∈ l → (minimum l : WithTop α) = m → m ≤ a 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {a m : α}
Goal: a ∈ l → l.minimum = ↑m → m ≤ a
-- List.le_maximum_of_mem'
theorem le_maximum_of_mem' (ha : a ∈ l) : (a : WithBot α) ≤ maximum l 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {a : α} (ha : a ∈ l)
Goal: ↑a ≤ l.maximum
-- List.minimum_le_of_mem'
theorem minimum_le_of_mem' (ha : a ∈ l) : minimum l ≤ (a : WithTop α) 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {a : α} (ha : a ∈ l)
Goal: l.minimum ≤ ↑a
-- List.minimum_concat
theorem minimum_concat (a : α) (l : List α) : minimum (l ++ [a]) = min (minimum l) a 
Arguments: {α : Type u_1} [LinearOrder α] (a : α) (l : List α)
Goal: (l ++ [a]).minimum = min l.minimum ↑a
-- List.maximum_cons
theorem maximum_cons (a : α) (l : List α) : maximum (a :: l) = max ↑a (maximum l) 
Arguments: {α : Type u_1} [LinearOrder α] (a : α) (l : List α)
Goal: (a :: l).maximum = max (↑a) l.maximum
-- List.minimum_cons
theorem minimum_cons (a : α) (l : List α) : minimum (a :: l) = min ↑a (minimum l) 
Arguments: {α : Type u_1} [LinearOrder α] (a : α) (l : List α)
Goal: (a :: l).minimum = min (↑a) l.minimum
-- List.maximum_le_of_forall_le
theorem maximum_le_of_forall_le {b : WithBot α} (h : ∀ a ∈ l, a ≤ b) : l.maximum ≤ b 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {b : WithBot α} (h : ∀ (a : α), a ∈ l → ↑a ≤ b)
Goal: l.maximum ≤ b
-- List.le_minimum_of_forall_le
theorem le_minimum_of_forall_le {b : WithTop α} (h : ∀ a ∈ l, b ≤ a) : b ≤ l.minimum 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {b : WithTop α} (h : ∀ (a : α), a ∈ l → b ≤ ↑a)
Goal: b ≤ l.minimum
-- List.maximum_eq_coe_iff
theorem maximum_eq_coe_iff : maximum l = m ↔ m ∈ l ∧ ∀ a ∈ l, a ≤ m 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {m : α}
Goal: l.maximum = ↑m ↔ m ∈ l ∧ ∀ (a : α), a ∈ l → a ≤ m
-- List.minimum_eq_coe_iff
theorem minimum_eq_coe_iff : minimum l = m ↔ m ∈ l ∧ ∀ a ∈ l, m ≤ a 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {m : α}
Goal: l.minimum = ↑m ↔ m ∈ l ∧ ∀ (a : α), a ∈ l → m ≤ a
-- List.coe_le_maximum_iff
theorem coe_le_maximum_iff : a ≤ l.maximum ↔ ∃ b, b ∈ l ∧ a ≤ b 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {a : α}
Goal: ↑a ≤ l.maximum ↔ ∃ b, b ∈ l ∧ a ≤ b
-- List.minimum_le_coe_iff
theorem minimum_le_coe_iff : l.minimum ≤ a ↔ ∃ b, b ∈ l ∧ b ≤ a 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {a : α}
Goal: l.minimum ≤ ↑a ↔ ∃ b, b ∈ l ∧ b ≤ a
-- List.maximum_ne_bot_of_ne_nil
theorem maximum_ne_bot_of_ne_nil (h : l ≠ []) : l.maximum ≠ ⊥ 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} (h : l ≠ [])
Goal: l.maximum ≠ ⊥
-- List.minimum_ne_top_of_ne_nil
theorem minimum_ne_top_of_ne_nil (h : l ≠ []) : l.minimum ≠ ⊤ 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} (h : l ≠ [])
Goal: l.minimum ≠ ⊤
-- List.maximum_ne_bot_of_length_pos
theorem maximum_ne_bot_of_length_pos (h : 0 < l.length) : l.maximum ≠ ⊥ 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} (h : 0 < l.length)
Goal: l.maximum ≠ ⊥
-- List.minimum_ne_top_of_length_pos
theorem minimum_ne_top_of_length_pos (h : 0 < l.length) : l.minimum ≠ ⊤ 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} (h : 0 < l.length)
Goal: l.minimum ≠ ⊤
-- List.coe_maximum_of_length_pos
@[simp]
lemma coe_maximum_of_length_pos (h : 0 < l.length) :
    (l.maximum_of_length_pos h : α) = l.maximum 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} (h : 0 < l.length)
Goal: ↑(List.maximum_of_length_pos h) = l.maximum
-- List.coe_minimum_of_length_pos
@[simp]
lemma coe_minimum_of_length_pos (h : 0 < l.length) :
    (l.minimum_of_length_pos h : α) = l.minimum 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} (h : 0 < l.length)
Goal: ↑(List.minimum_of_length_pos h) = l.minimum
-- List.le_maximum_of_length_pos_iff
@[simp]
theorem le_maximum_of_length_pos_iff {b : α} (h : 0 < l.length) :
    b ≤ maximum_of_length_pos h ↔ b ≤ l.maximum 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {b : α} (h : 0 < l.length)
Goal: b ≤ List.maximum_of_length_pos h ↔ ↑b ≤ l.maximum
-- List.minimum_of_length_pos_le_iff
@[simp]
theorem minimum_of_length_pos_le_iff {b : α} (h : 0 < l.length) :
    minimum_of_length_pos h ≤ b ↔ l.minimum ≤ b 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {b : α} (h : 0 < l.length)
Goal: List.minimum_of_length_pos h ≤ b ↔ l.minimum ≤ ↑b
-- List.maximum_of_length_pos_mem
theorem maximum_of_length_pos_mem (h : 0 < l.length) :
    maximum_of_length_pos h ∈ l 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} (h : 0 < l.length)
Goal: List.maximum_of_length_pos h ∈ l
-- List.minimum_of_length_pos_mem
theorem minimum_of_length_pos_mem (h : 0 < l.length) :
    minimum_of_length_pos h ∈ l 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} (h : 0 < l.length)
Goal: List.minimum_of_length_pos h ∈ l
-- List.le_maximum_of_length_pos_of_mem
theorem le_maximum_of_length_pos_of_mem (h : a ∈ l) (w : 0 < l.length) :
    a ≤ l.maximum_of_length_pos w 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {a : α} (h : a ∈ l) (w : 0 < l.length)
Goal: a ≤ List.maximum_of_length_pos w
-- List.minimum_of_length_pos_le_of_mem
theorem minimum_of_length_pos_le_of_mem (h : a ∈ l) (w : 0 < l.length) :
    l.minimum_of_length_pos w ≤ a 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {a : α} (h : a ∈ l) (w : 0 < l.length)
Goal: List.minimum_of_length_pos w ≤ a
-- List.getElem_le_maximum_of_length_pos
theorem getElem_le_maximum_of_length_pos {i : ℕ} (w : i < l.length) (h := (Nat.zero_lt_of_lt w)) :
    l[i] ≤ l.maximum_of_length_pos h 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {i : ℕ} (w : i < l.length) (h : 0 < l.length := ⋯)
Goal: l[i] ≤ List.maximum_of_length_pos h
-- List.minimum_of_length_pos_le_getElem
theorem minimum_of_length_pos_le_getElem {i : ℕ} (w : i < l.length) (h := (Nat.zero_lt_of_lt w)) :
    l.minimum_of_length_pos h ≤ l[i] 
Arguments: {α : Type u_1} [LinearOrder α] {l : List α} {i : ℕ} (w : i < l.length) (h : 0 < l.length := ⋯)
Goal: List.minimum_of_length_pos h ≤ l[i]
-- List.getD_maximum?_eq_unbot'_maximum
lemma getD_maximum?_eq_unbot'_maximum (l : List α) (d : α) :
    l.maximum?.getD d = l.maximum.unbot' d 
Arguments: {α : Type u_1} [LinearOrder α] (l : List α) (d : α)
Goal: l.maximum?.getD d = WithBot.unbot' d l.maximum
-- List.getD_minimum?_eq_untop'_minimum
lemma getD_minimum?_eq_untop'_minimum (l : List α) (d : α) :
    l.minimum?.getD d = l.minimum.untop' d 
Arguments: {α : Type u_1} [LinearOrder α] (l : List α) (d : α)
Goal: l.minimum?.getD d = WithTop.untop' d l.minimum
-- List.foldr_max_of_ne_nil
@[simp]
theorem foldr_max_of_ne_nil (h : l ≠ []) : ↑(l.foldr max ⊥) = l.maximum 
Arguments: {α : Type u_1} [LinearOrder α] [OrderBot α] {l : List α} (h : l ≠ [])
Goal: ↑(List.foldr max ⊥ l) = l.maximum
-- List.max_le_of_forall_le
theorem max_le_of_forall_le (l : List α) (a : α) (h : ∀ x ∈ l, x ≤ a) : l.foldr max ⊥ ≤ a 
Arguments: {α : Type u_1} [LinearOrder α] [OrderBot α] (l : List α) (a : α) (h : ∀ (x : α), x ∈ l → x ≤ a)
Goal: List.foldr max ⊥ l ≤ a
-- List.le_max_of_le
theorem le_max_of_le {l : List α} {a x : α} (hx : x ∈ l) (h : a ≤ x) : a ≤ l.foldr max ⊥ 
Arguments: {α : Type u_1} [LinearOrder α] [OrderBot α] {l : List α} {a x : α} (hx : x ∈ l) (h : a ≤ x)
Goal: a ≤ List.foldr max ⊥ l
-- List.foldr_min_of_ne_nil
@[simp]
theorem foldr_min_of_ne_nil (h : l ≠ []) : ↑(l.foldr min ⊤) = l.minimum 
Arguments: {α : Type u_1} [LinearOrder α] [OrderTop α] {l : List α} (h : l ≠ [])
Goal: ↑(List.foldr min ⊤ l) = l.minimum
-- List.le_min_of_forall_le
theorem le_min_of_forall_le (l : List α) (a : α) (h : ∀ x ∈ l, a ≤ x) : a ≤ l.foldr min ⊤ 
Arguments: {α : Type u_1} [LinearOrder α] [OrderTop α] (l : List α) (a : α) (h : ∀ (x : α), x ∈ l → a ≤ x)
Goal: a ≤ List.foldr min ⊤ l
-- List.min_le_of_le
theorem min_le_of_le (l : List α) (a : α) {x : α} (hx : x ∈ l) (h : x ≤ a) : l.foldr min ⊤ ≤ a 
Arguments: {α : Type u_1} [LinearOrder α] [OrderTop α] (l : List α) (a : α) {x : α} (hx : x ∈ l) (h : x ≤ a)
Goal: List.foldr min ⊤ l ≤ a
-- LevenshteinEstimator'.bound_eq
structure LevenshteinEstimator' : Type where
    pre_rev : List β
    suff : List β
    split : pre_rev.reverse ++ suff = ys
    distances : {r : List δ // 0 < r.length}
    distances_eq : distances = suffixLevenshtein C xs suff
    bound : δ × ℕ
    bound_eq : bound = match pre_rev with
    | [] => (distances.1[0]'(distances.2), ys.length)
    | _ => (List.minimum_of_length_pos distances.2, suff.length)
Arguments: {α : Type u_1} {β δ : Type} [CanonicallyLinearOrderedAddCommMonoid δ] {C : Levenshtein.Cost α β δ} {xs : List α} {ys : List β} (self : LevenshteinEstimator' C xs ys)
Goal: self.bound =
  match self.pre_rev, ⋯ with
  | [], split => ((↑self.distances)[0], ys.length)
  | x, split => (List.minimum_of_length_pos ⋯, self.suff.length)
-- LevenshteinEstimator'.split
structure LevenshteinEstimator' : Type where
    pre_rev : List β
    suff : List β
    split : pre_rev.reverse ++ suff = ys
    distances : {r : List δ // 0 < r.length}
    distances_eq : distances = suffixLevenshtein C xs suff
    bound : δ × ℕ
    bound_eq : bound = match pre_rev with
    | [] => (distances.1[0]'(distances.2), ys.length)
    | _ => (List.minimum_of_length_pos distances.2, suff.length)
Arguments: {α : Type u_1} {β δ : Type} [CanonicallyLinearOrderedAddCommMonoid δ] {C : Levenshtein.Cost α β δ} {xs : List α} {ys : List β} (self : LevenshteinEstimator' C xs ys)
Goal: self.pre_rev.reverse ++ self.suff = ys
-- LevenshteinEstimator'.distances_eq
structure LevenshteinEstimator' : Type where
    pre_rev : List β
    suff : List β
    split : pre_rev.reverse ++ suff = ys
    distances : {r : List δ // 0 < r.length}
    distances_eq : distances = suffixLevenshtein C xs suff
    bound : δ × ℕ
    bound_eq : bound = match pre_rev with
    | [] => (distances.1[0]'(distances.2), ys.length)
    | _ => (List.minimum_of_length_pos distances.2, suff.length)
Arguments: {α : Type u_1} {β δ : Type} [CanonicallyLinearOrderedAddCommMonoid δ] {C : Levenshtein.Cost α β δ} {xs : List α} {ys : List β} (self : LevenshteinEstimator' C xs ys)
Goal: self.distances = suffixLevenshtein C xs self.suff
-- List.rotate_mod
theorem rotate_mod (l : List α) (n : ℕ) : l.rotate (n % l.length) = l.rotate n 
Arguments: {α : Type u} (l : List α) (n : ℕ)
Goal: l.rotate (n % l.length) = l.rotate n
-- List.rotate_nil
@[simp]
theorem rotate_nil (n : ℕ) : ([] : List α).rotate n = [] 
Arguments: {α : Type u} (n : ℕ)
Goal: [].rotate n = []
-- List.rotate_zero
@[simp]
theorem rotate_zero (l : List α) : l.rotate 0 = l 
Arguments: {α : Type u} (l : List α)
Goal: l.rotate 0 = l
-- List.rotate'_nil
theorem rotate'_nil (n : ℕ) : ([] : List α).rotate' n = [] 
Arguments: {α : Type u} (n : ℕ)
Goal: [].rotate' n = []
-- List.rotate'_zero
@[simp]
theorem rotate'_zero (l : List α) : l.rotate' 0 = l 
Arguments: {α : Type u} (l : List α)
Goal: l.rotate' 0 = l
-- List.rotate'_cons_succ
theorem rotate'_cons_succ (l : List α) (a : α) (n : ℕ) :
    (a :: l : List α).rotate' n.succ = (l ++ [a]).rotate' n 
Arguments: {α : Type u} (l : List α) (a : α) (n : ℕ)
Goal: (a :: l).rotate' n.succ = (l ++ [a]).rotate' n
-- List.length_rotate'
@[simp]
theorem length_rotate' : ∀ (l : List α) (n : ℕ), (l.rotate' n).length = l.length
  
Arguments: {α : Type u} (l : List α) (n : ℕ)
Goal: (l.rotate' n).length = l.length
-- List.rotate'_eq_drop_append_take
theorem rotate'_eq_drop_append_take :
    ∀ {l : List α} {n : ℕ}, n ≤ l.length → l.rotate' n = l.drop n ++ l.take n
  
Arguments: {α : Type u} {l : List α} {n : ℕ}
Goal: n ≤ l.length → l.rotate' n = List.drop n l ++ List.take n l
-- List.rotate'_rotate'
theorem rotate'_rotate' : ∀ (l : List α) (n m : ℕ), (l.rotate' n).rotate' m = l.rotate' (n + m)
  
Arguments: {α : Type u} (l : List α) (n m : ℕ)
Goal: (l.rotate' n).rotate' m = l.rotate' (n + m)
-- List.rotate'_length
@[simp]
theorem rotate'_length (l : List α) : rotate' l l.length = l 
Arguments: {α : Type u} (l : List α)
Goal: l.rotate' l.length = l
-- List.rotate'_length_mul
@[simp]
theorem rotate'_length_mul (l : List α) : ∀ n : ℕ, l.rotate' (l.length * n) = l
  
Arguments: {α : Type u} (l : List α) (n : ℕ)
Goal: l.rotate' (l.length * n) = l
-- List.rotate'_mod
theorem rotate'_mod (l : List α) (n : ℕ) : l.rotate' (n % l.length) = l.rotate' n 
Arguments: {α : Type u} (l : List α) (n : ℕ)
Goal: l.rotate' (n % l.length) = l.rotate' n
-- List.rotate_eq_rotate'
theorem rotate_eq_rotate' (l : List α) (n : ℕ) : l.rotate n = l.rotate' n 
Arguments: {α : Type u} (l : List α) (n : ℕ)
Goal: l.rotate n = l.rotate' n
-- List.rotate_cons_succ
theorem rotate_cons_succ (l : List α) (a : α) (n : ℕ) :
    (a :: l : List α).rotate (n + 1) = (l ++ [a]).rotate n 
Arguments: {α : Type u} (l : List α) (a : α) (n : ℕ)
Goal: (a :: l).rotate (n + 1) = (l ++ [a]).rotate n
-- List.mem_rotate
@[simp]
theorem mem_rotate : ∀ {l : List α} {a : α} {n : ℕ}, a ∈ l.rotate n ↔ a ∈ l
  
Arguments: {α : Type u} {l : List α} {a : α} {n : ℕ}
Goal: a ∈ l.rotate n ↔ a ∈ l
-- List.length_rotate
@[simp]
theorem length_rotate (l : List α) (n : ℕ) : (l.rotate n).length = l.length 
Arguments: {α : Type u} (l : List α) (n : ℕ)
Goal: (l.rotate n).length = l.length
-- List.rotate_replicate
@[simp]
theorem rotate_replicate (a : α) (n : ℕ) (k : ℕ) : (replicate n a).rotate k = replicate n a 
Arguments: {α : Type u} (a : α) (n k : ℕ)
Goal: (List.replicate n a).rotate k = List.replicate n a
-- List.rotate_eq_drop_append_take
theorem rotate_eq_drop_append_take {l : List α} {n : ℕ} :
    n ≤ l.length → l.rotate n = l.drop n ++ l.take n 
Arguments: {α : Type u} {l : List α} {n : ℕ}
Goal: n ≤ l.length → l.rotate n = List.drop n l ++ List.take n l
-- List.rotate_eq_drop_append_take_mod
theorem rotate_eq_drop_append_take_mod {l : List α} {n : ℕ} :
    l.rotate n = l.drop (n % l.length) ++ l.take (n % l.length) 
Arguments: {α : Type u} {l : List α} {n : ℕ}
Goal: l.rotate n = List.drop (n % l.length) l ++ List.take (n % l.length) l
-- List.rotate_append_length_eq
@[simp]
theorem rotate_append_length_eq (l l' : List α) : (l ++ l').rotate l.length = l' ++ l 
Arguments: {α : Type u} (l l' : List α)
Goal: (l ++ l').rotate l.length = l' ++ l
-- List.rotate_rotate
theorem rotate_rotate (l : List α) (n m : ℕ) : (l.rotate n).rotate m = l.rotate (n + m) 
Arguments: {α : Type u} (l : List α) (n m : ℕ)
Goal: (l.rotate n).rotate m = l.rotate (n + m)
-- List.rotate_length
@[simp]
theorem rotate_length (l : List α) : rotate l l.length = l 
Arguments: {α : Type u} (l : List α)
Goal: l.rotate l.length = l
-- List.rotate_length_mul
@[simp]
theorem rotate_length_mul (l : List α) (n : ℕ) : l.rotate (l.length * n) = l 
Arguments: {α : Type u} (l : List α) (n : ℕ)
Goal: l.rotate (l.length * n) = l
-- List.rotate_perm
theorem rotate_perm (l : List α) (n : ℕ) : l.rotate n ~ l 
Arguments: {α : Type u} (l : List α) (n : ℕ)
Goal: (l.rotate n).Perm l
-- List.nodup_rotate
@[simp]
theorem nodup_rotate {l : List α} {n : ℕ} : Nodup (l.rotate n) ↔ Nodup l 
Arguments: {α : Type u} {l : List α} {n : ℕ}
Goal: (l.rotate n).Nodup ↔ l.Nodup
-- List.rotate_eq_nil_iff
@[simp]
theorem rotate_eq_nil_iff {l : List α} {n : ℕ} : l.rotate n = [] ↔ l = [] 
Arguments: {α : Type u} {l : List α} {n : ℕ}
Goal: l.rotate n = [] ↔ l = []
-- List.nil_eq_rotate_iff
@[simp]
theorem nil_eq_rotate_iff {l : List α} {n : ℕ} : [] = l.rotate n ↔ [] = l 
Arguments: {α : Type u} {l : List α} {n : ℕ}
Goal: [] = l.rotate n ↔ [] = l
-- List.rotate_singleton
@[simp]
theorem rotate_singleton (x : α) (n : ℕ) : [x].rotate n = [x] 
Arguments: {α : Type u} (x : α) (n : ℕ)
Goal: [x].rotate n = [x]
-- List.zipWith_rotate_distrib
theorem zipWith_rotate_distrib {β γ : Type*} (f : α → β → γ) (l : List α) (l' : List β) (n : ℕ)
    (h : l.length = l'.length) :
    (zipWith f l l').rotate n = zipWith f (l.rotate n) (l'.rotate n) 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (l : List α) (l' : List β) (n : ℕ) (h : l.length = l'.length)
Goal: (List.zipWith f l l').rotate n = List.zipWith f (l.rotate n) (l'.rotate n)
-- List.zipWith_rotate_one
theorem zipWith_rotate_one {β : Type*} (f : α → α → β) (x y : α) (l : List α) :
    zipWith f (x :: y :: l) ((x :: y :: l).rotate 1) = f x y :: zipWith f (y :: l) (l ++ [x]) 
Arguments: {α : Type u} {β : Type u_1} (f : α → α → β) (x y : α) (l : List α)
Goal: List.zipWith f (x :: y :: l) ((x :: y :: l).rotate 1) = f x y :: List.zipWith f (y :: l) (l ++ [x])
-- List.getElem?_rotate
theorem getElem?_rotate {l : List α} {n m : ℕ} (hml : m < l.length) :
    (l.rotate n)[m]? = l[(m + n) % l.length]? 
Arguments: {α : Type u} {l : List α} {n m : ℕ} (hml : m < l.length)
Goal: (l.rotate n)[m]? = l[(m + n) % l.length]?
-- List.getElem_rotate
theorem getElem_rotate (l : List α) (n : ℕ) (k : Nat) (h : k < (l.rotate n).length) :
    (l.rotate n)[k] =
      l[(k + n) % l.length]'(mod_lt _ (length_rotate l n ▸ k.zero_le.trans_lt h)) 
Arguments: {α : Type u} (l : List α) (n k : ℕ) (h : k < (l.rotate n).length)
Goal: (l.rotate n)[k] = l[(k + n) % l.length]
-- List.get?_rotate
theorem get?_rotate {l : List α} {n m : ℕ} (hml : m < l.length) :
    (l.rotate n).get? m = l.get? ((m + n) % l.length) 
Arguments: {α : Type u} {l : List α} {n m : ℕ} (hml : m < l.length)
Goal: (l.rotate n).get? m = l.get? ((m + n) % l.length)
-- List.get_rotate
theorem get_rotate (l : List α) (n : ℕ) (k : Fin (l.rotate n).length) :
    (l.rotate n).get k =
      l.get ⟨(k + n) % l.length, mod_lt _ (length_rotate l n ▸ k.1.zero_le.trans_lt k.2)⟩ 
Arguments: {α : Type u} (l : List α) (n : ℕ) (k : Fin (l.rotate n).length)
Goal: (l.rotate n).get k = l.get ⟨(↑k + n) % l.length, ⋯⟩
-- List.head?_rotate
theorem head?_rotate {l : List α} {n : ℕ} (h : n < l.length) : head? (l.rotate n) = l[n]? 
Arguments: {α : Type u} {l : List α} {n : ℕ} (h : n < l.length)
Goal: (l.rotate n).head? = l[n]?
-- List.nthLe_rotate
@[deprecated get_rotate (since := "2023-01-13")]
theorem nthLe_rotate (l : List α) (n k : ℕ) (hk : k < (l.rotate n).length) :
    (l.rotate n).nthLe k hk =
      l.nthLe ((k + n) % l.length) (mod_lt _ (length_rotate l n ▸ k.zero_le.trans_lt hk)) 
Arguments: {α : Type u} (l : List α) (n k : ℕ) (hk : k < (l.rotate n).length)
Goal: (l.rotate n).nthLe k hk = l.nthLe ((k + n) % l.length) ⋯
-- List.nthLe_rotate_one
theorem nthLe_rotate_one (l : List α) (k : ℕ) (hk : k < (l.rotate 1).length) :
    (l.rotate 1).nthLe k hk =
      l.nthLe ((k + 1) % l.length) (mod_lt _ (length_rotate l 1 ▸ k.zero_le.trans_lt hk)) 
Arguments: {α : Type u} (l : List α) (k : ℕ) (hk : k < (l.rotate 1).length)
Goal: (l.rotate 1).nthLe k hk = l.nthLe ((k + 1) % l.length) ⋯
-- List.get_eq_get_rotate
theorem get_eq_get_rotate (l : List α) (n : ℕ) (k : Fin l.length) :
    l.get k = (l.rotate n).get ⟨(l.length - n % l.length + k) % l.length,
      (Nat.mod_lt _ (k.1.zero_le.trans_lt k.2)).trans_eq (length_rotate _ _).symm⟩ 
Arguments: {α : Type u} (l : List α) (n : ℕ) (k : Fin l.length)
Goal: l.get k = (l.rotate n).get ⟨(l.length - n % l.length + ↑k) % l.length, ⋯⟩
-- List.nthLe_rotate'
@[deprecated get_eq_get_rotate (since := "2023-03-26")]
theorem nthLe_rotate' (l : List α) (n k : ℕ) (hk : k < l.length) :
    (l.rotate n).nthLe ((l.length - n % l.length + k) % l.length)
        ((Nat.mod_lt _ (k.zero_le.trans_lt hk)).trans_le (length_rotate _ _).ge) =
      l.nthLe k hk 
Arguments: {α : Type u} (l : List α) (n k : ℕ) (hk : k < l.length)
Goal: (l.rotate n).nthLe ((l.length - n % l.length + k) % l.length) ⋯ = l.nthLe k hk
-- List.rotate_eq_self_iff_eq_replicate
theorem rotate_eq_self_iff_eq_replicate [hα : Nonempty α] :
    ∀ {l : List α}, (∀ n, l.rotate n = l) ↔ ∃ a, l = replicate l.length a
  
Arguments: {α : Type u} [hα : Nonempty α] {l : List α}
Goal: (∀ (n : ℕ), l.rotate n = l) ↔ ∃ a, l = List.replicate l.length a
-- List.rotate_one_eq_self_iff_eq_replicate
theorem rotate_one_eq_self_iff_eq_replicate [Nonempty α] {l : List α} :
    l.rotate 1 = l ↔ ∃ a : α, l = List.replicate l.length a 
Arguments: {α : Type u} [Nonempty α] {l : List α}
Goal: l.rotate 1 = l ↔ ∃ a, l = List.replicate l.length a
-- List.rotate_injective
theorem rotate_injective (n : ℕ) : Function.Injective fun l : List α => l.rotate n 
Arguments: {α : Type u} (n : ℕ)
Goal: Function.Injective fun l => l.rotate n
-- List.rotate_eq_rotate
@[simp]
theorem rotate_eq_rotate {l l' : List α} {n : ℕ} : l.rotate n = l'.rotate n ↔ l = l' 
Arguments: {α : Type u} {l l' : List α} {n : ℕ}
Goal: l.rotate n = l'.rotate n ↔ l = l'
-- List.rotate_eq_iff
theorem rotate_eq_iff {l l' : List α} {n : ℕ} :
    l.rotate n = l' ↔ l = l'.rotate (l'.length - n % l'.length) 
Arguments: {α : Type u} {l l' : List α} {n : ℕ}
Goal: l.rotate n = l' ↔ l = l'.rotate (l'.length - n % l'.length)
-- List.rotate_eq_singleton_iff
@[simp]
theorem rotate_eq_singleton_iff {l : List α} {n : ℕ} {x : α} : l.rotate n = [x] ↔ l = [x] 
Arguments: {α : Type u} {l : List α} {n : ℕ} {x : α}
Goal: l.rotate n = [x] ↔ l = [x]
-- List.singleton_eq_rotate_iff
@[simp]
theorem singleton_eq_rotate_iff {l : List α} {n : ℕ} {x : α} : [x] = l.rotate n ↔ [x] = l 
Arguments: {α : Type u} {l : List α} {n : ℕ} {x : α}
Goal: [x] = l.rotate n ↔ [x] = l
-- List.reverse_rotate
theorem reverse_rotate (l : List α) (n : ℕ) :
    (l.rotate n).reverse = l.reverse.rotate (l.length - n % l.length) 
Arguments: {α : Type u} (l : List α) (n : ℕ)
Goal: (l.rotate n).reverse = l.reverse.rotate (l.length - n % l.length)
-- List.rotate_reverse
theorem rotate_reverse (l : List α) (n : ℕ) :
    l.reverse.rotate n = (l.rotate (l.length - n % l.length)).reverse 
Arguments: {α : Type u} (l : List α) (n : ℕ)
Goal: l.reverse.rotate n = (l.rotate (l.length - n % l.length)).reverse
-- List.map_rotate
theorem map_rotate {β : Type*} (f : α → β) (l : List α) (n : ℕ) :
    map f (l.rotate n) = (map f l).rotate n 
Arguments: {α : Type u} {β : Type u_1} (f : α → β) (l : List α) (n : ℕ)
Goal: List.map f (l.rotate n) = (List.map f l).rotate n