ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Set.div_zero_subset
theorem div_zero_subset (s : Set α) : s / 0 ⊆ 0 
Arguments: {α : Type u_2} [GroupWithZero α] (s : Set α)
Goal: s / 0 ⊆ 0
-- Set.zero_div_subset
theorem zero_div_subset (s : Set α) : 0 / s ⊆ 0 
Arguments: {α : Type u_2} [GroupWithZero α] (s : Set α)
Goal: 0 / s ⊆ 0
-- Set.Nonempty.div_zero
theorem Nonempty.div_zero (hs : s.Nonempty) : s / 0 = 0 
Arguments: {α : Type u_2} [GroupWithZero α] {s : Set α} (hs : s.Nonempty)
Goal: s / 0 = 0
-- Set.Nonempty.zero_div
theorem Nonempty.zero_div (hs : s.Nonempty) : 0 / s = 0 
Arguments: {α : Type u_2} [GroupWithZero α] {s : Set α} (hs : s.Nonempty)
Goal: 0 / s = 0
-- Set.image_mul
@[to_additive]
theorem image_mul : m '' (s * t) = m '' s * m '' t 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] [FunLike F α β] [MulHomClass F α β] (m : F) {s t : Set α}
Goal: ⇑m '' (s * t) = ⇑m '' s * ⇑m '' t
-- Set.image_add
@[to_additive]
theorem image_mul : m '' (s * t) = m '' s * m '' t 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Add α] [Add β] [FunLike F α β] [AddHomClass F α β] (m : F) {s t : Set α}
Goal: ⇑m '' (s + t) = ⇑m '' s + ⇑m '' t
-- Set.mul_subset_range
@[to_additive]
lemma mul_subset_range {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) : s * t ⊆ range m 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] [FunLike F α β] [MulHomClass F α β] (m : F) {s t : Set β} (hs : s ⊆ Set.range ⇑m) (ht : t ⊆ Set.range ⇑m)
Goal: s * t ⊆ Set.range ⇑m
-- Set.add_subset_range
@[to_additive]
lemma mul_subset_range {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) : s * t ⊆ range m 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Add α] [Add β] [FunLike F α β] [AddHomClass F α β] (m : F) {s t : Set β} (hs : s ⊆ Set.range ⇑m) (ht : t ⊆ Set.range ⇑m)
Goal: s + t ⊆ Set.range ⇑m
-- Set.preimage_mul_preimage_subset
@[to_additive]
theorem preimage_mul_preimage_subset {s t : Set β} : m ⁻¹' s * m ⁻¹' t ⊆ m ⁻¹' (s * t) 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] [FunLike F α β] [MulHomClass F α β] (m : F) {s t : Set β}
Goal: ⇑m ⁻¹' s * ⇑m ⁻¹' t ⊆ ⇑m ⁻¹' (s * t)
-- Set.preimage_add_preimage_subset
@[to_additive]
theorem preimage_mul_preimage_subset {s t : Set β} : m ⁻¹' s * m ⁻¹' t ⊆ m ⁻¹' (s * t) 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Add α] [Add β] [FunLike F α β] [AddHomClass F α β] (m : F) {s t : Set β}
Goal: ⇑m ⁻¹' s + ⇑m ⁻¹' t ⊆ ⇑m ⁻¹' (s + t)
-- Set.preimage_mul
@[to_additive]
lemma preimage_mul (hm : Injective m) {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) :
    m ⁻¹' (s * t) = m ⁻¹' s * m ⁻¹' t 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Mul α] [Mul β] [FunLike F α β] [MulHomClass F α β] (m : F) (hm : Function.Injective ⇑m) {s t : Set β} (hs : s ⊆ Set.range ⇑m) (ht : t ⊆ Set.range ⇑m)
Goal: ⇑m ⁻¹' (s * t) = ⇑m ⁻¹' s * ⇑m ⁻¹' t
-- Set.preimage_add
@[to_additive]
lemma preimage_mul (hm : Injective m) {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) :
    m ⁻¹' (s * t) = m ⁻¹' s * m ⁻¹' t 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Add α] [Add β] [FunLike F α β] [AddHomClass F α β] (m : F) (hm : Function.Injective ⇑m) {s t : Set β} (hs : s ⊆ Set.range ⇑m) (ht : t ⊆ Set.range ⇑m)
Goal: ⇑m ⁻¹' (s + t) = ⇑m ⁻¹' s + ⇑m ⁻¹' t
-- Set.image_sub
@[to_additive]
theorem image_div : m '' (s / t) = m '' s / m '' t 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddGroup α] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] (m : F) {s t : Set α}
Goal: ⇑m '' (s - t) = ⇑m '' s - ⇑m '' t
-- Set.image_div
@[to_additive]
theorem image_div : m '' (s / t) = m '' s / m '' t 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass F α β] (m : F) {s t : Set α}
Goal: ⇑m '' (s / t) = ⇑m '' s / ⇑m '' t
-- Set.sub_subset_range
@[to_additive]
lemma div_subset_range {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) : s / t ⊆ range m 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddGroup α] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] (m : F) {s t : Set β} (hs : s ⊆ Set.range ⇑m) (ht : t ⊆ Set.range ⇑m)
Goal: s - t ⊆ Set.range ⇑m
-- Set.div_subset_range
@[to_additive]
lemma div_subset_range {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) : s / t ⊆ range m 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass F α β] (m : F) {s t : Set β} (hs : s ⊆ Set.range ⇑m) (ht : t ⊆ Set.range ⇑m)
Goal: s / t ⊆ Set.range ⇑m
-- Set.preimage_div_preimage_subset
@[to_additive]
theorem preimage_div_preimage_subset {s t : Set β} : m ⁻¹' s / m ⁻¹' t ⊆ m ⁻¹' (s / t) 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass F α β] (m : F) {s t : Set β}
Goal: ⇑m ⁻¹' s / ⇑m ⁻¹' t ⊆ ⇑m ⁻¹' (s / t)
-- Set.preimage_sub_preimage_subset
@[to_additive]
theorem preimage_div_preimage_subset {s t : Set β} : m ⁻¹' s / m ⁻¹' t ⊆ m ⁻¹' (s / t) 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddGroup α] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] (m : F) {s t : Set β}
Goal: ⇑m ⁻¹' s - ⇑m ⁻¹' t ⊆ ⇑m ⁻¹' (s - t)
-- Set.preimage_div
@[to_additive]
lemma preimage_div (hm : Injective m) {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) :
    m ⁻¹' (s / t) = m ⁻¹' s / m ⁻¹' t 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [Group α] [DivisionMonoid β] [FunLike F α β] [MonoidHomClass F α β] (m : F) (hm : Function.Injective ⇑m) {s t : Set β} (hs : s ⊆ Set.range ⇑m) (ht : t ⊆ Set.range ⇑m)
Goal: ⇑m ⁻¹' (s / t) = ⇑m ⁻¹' s / ⇑m ⁻¹' t
-- Set.preimage_sub
@[to_additive]
lemma preimage_div (hm : Injective m) {s t : Set β} (hs : s ⊆ range m) (ht : t ⊆ range m) :
    m ⁻¹' (s / t) = m ⁻¹' s / m ⁻¹' t 
Arguments: {F : Type u_1} {α : Type u_2} {β : Type u_3} [AddGroup α] [SubtractionMonoid β] [FunLike F α β] [AddMonoidHomClass F α β] (m : F) (hm : Function.Injective ⇑m) {s t : Set β} (hs : s ⊆ Set.range ⇑m) (ht : t ⊆ Set.range ⇑m)
Goal: ⇑m ⁻¹' (s - t) = ⇑m ⁻¹' s - ⇑m ⁻¹' t
-- AddGroup.card_nsmul_eq_card_nsmul_card_univ_aux
@[to_additive]
theorem card_pow_eq_card_pow_card_univ_aux {f : ℕ → ℕ} (h1 : Monotone f) {B : ℕ} (h2 : ∀ n, f n ≤ B)
    (h3 : ∀ n, f n = f (n + 1) → f (n + 1) = f (n + 2)) : ∀ k, B ≤ k → f k = f B 
Arguments: {f : ℕ → ℕ} (h1 : Monotone f) {B : ℕ} (h2 : ∀ (n : ℕ), f n ≤ B) (h3 : ∀ (n : ℕ), f n = f (n + 1) → f (n + 1) = f (n + 2)) (k : ℕ)
Goal: B ≤ k → f k = f B
-- Group.card_pow_eq_card_pow_card_univ_aux
@[to_additive]
theorem card_pow_eq_card_pow_card_univ_aux {f : ℕ → ℕ} (h1 : Monotone f) {B : ℕ} (h2 : ∀ n, f n ≤ B)
    (h3 : ∀ n, f n = f (n + 1) → f (n + 1) = f (n + 2)) : ∀ k, B ≤ k → f k = f B 
Arguments: {f : ℕ → ℕ} (h1 : Monotone f) {B : ℕ} (h2 : ∀ (n : ℕ), f n ≤ B) (h3 : ∀ (n : ℕ), f n = f (n + 1) → f (n + 1) = f (n + 2)) (k : ℕ)
Goal: B ≤ k → f k = f B
-- List.nextOr_nil
@[simp]
theorem nextOr_nil (x d : α) : nextOr [] x d = d 
Arguments: {α : Type u_1} [DecidableEq α] (x d : α)
Goal: [].nextOr x d = d
-- List.nextOr_singleton
@[simp]
theorem nextOr_singleton (x y d : α) : nextOr [y] x d = d 
Arguments: {α : Type u_1} [DecidableEq α] (x y d : α)
Goal: [y].nextOr x d = d
-- List.nextOr_self_cons_cons
@[simp]
theorem nextOr_self_cons_cons (xs : List α) (x y d : α) : nextOr (x :: y :: xs) x d = y 
Arguments: {α : Type u_1} [DecidableEq α] (xs : List α) (x y d : α)
Goal: (x :: y :: xs).nextOr x d = y
-- List.nextOr_cons_of_ne
theorem nextOr_cons_of_ne (xs : List α) (y x d : α) (h : x ≠ y) :
    nextOr (y :: xs) x d = nextOr xs x d 
Arguments: {α : Type u_1} [DecidableEq α] (xs : List α) (y x d : α) (h : x ≠ y)
Goal: (y :: xs).nextOr x d = xs.nextOr x d
-- List.nextOr_eq_nextOr_of_mem_of_ne
theorem nextOr_eq_nextOr_of_mem_of_ne (xs : List α) (x d d' : α) (x_mem : x ∈ xs)
    (x_ne : x ≠ xs.getLast (ne_nil_of_mem x_mem)) : nextOr xs x d = nextOr xs x d' 
Arguments: {α : Type u_1} [DecidableEq α] (xs : List α) (x d d' : α) (x_mem : x ∈ xs) (x_ne : x ≠ xs.getLast ⋯)
Goal: xs.nextOr x d = xs.nextOr x d'
-- List.mem_of_nextOr_ne
theorem mem_of_nextOr_ne {xs : List α} {x d : α} (h : nextOr xs x d ≠ d) : x ∈ xs 
Arguments: {α : Type u_1} [DecidableEq α] {xs : List α} {x d : α} (h : xs.nextOr x d ≠ d)
Goal: x ∈ xs
-- List.nextOr_concat
theorem nextOr_concat {xs : List α} {x : α} (d : α) (h : x ∉ xs) : nextOr (xs ++ [x]) x d = d 
Arguments: {α : Type u_1} [DecidableEq α] {xs : List α} {x : α} (d : α) (h : x ∉ xs)
Goal: (xs ++ [x]).nextOr x d = d
-- List.nextOr_mem
theorem nextOr_mem {xs : List α} {x d : α} (hd : d ∈ xs) : nextOr xs x d ∈ xs 
Arguments: {α : Type u_1} [DecidableEq α] {xs : List α} {x d : α} (hd : d ∈ xs)
Goal: xs.nextOr x d ∈ xs
-- List.next_singleton
@[simp]
theorem next_singleton (x y : α) (h : x ∈ [y]) : next [y] x h = y 
Arguments: {α : Type u_1} [DecidableEq α] (x y : α) (h : x ∈ [y])
Goal: [y].next x h = y
-- List.prev_singleton
@[simp]
theorem prev_singleton (x y : α) (h : x ∈ [y]) : prev [y] x h = y 
Arguments: {α : Type u_1} [DecidableEq α] (x y : α) (h : x ∈ [y])
Goal: [y].prev x h = y
-- List.next_cons_cons_eq'
theorem next_cons_cons_eq' (y z : α) (h : x ∈ y :: z :: l) (hx : x = y) :
    next (y :: z :: l) x h = z 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x y z : α) (h : x ∈ y :: z :: l) (hx : x = y)
Goal: (y :: z :: l).next x h = z
-- List.next_cons_cons_eq
@[simp]
theorem next_cons_cons_eq (z : α) (h : x ∈ x :: z :: l) : next (x :: z :: l) x h = z 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x z : α) (h : x ∈ x :: z :: l)
Goal: (x :: z :: l).next x h = z
-- List.next_ne_head_ne_getLast
theorem next_ne_head_ne_getLast (h : x ∈ l) (y : α) (h : x ∈ y :: l) (hy : x ≠ y)
    (hx : x ≠ getLast (y :: l) (cons_ne_nil _ _)) :
    next (y :: l) x h = next l x (by simpa [hy] using h) 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x : α) (h : x ∈ l) (y : α)
Goal: ∀ (h : x ∈ y :: l) (hy : x ≠ y), x ≠ (y :: l).getLast ⋯ → (y :: l).next x h = l.next x ⋯
-- List.next_cons_concat
theorem next_cons_concat (y : α) (hy : x ≠ y) (hx : x ∉ l)
    (h : x ∈ y :: l ++ [x] := mem_append_right _ (mem_singleton_self x)) :
    next (y :: l ++ [x]) x h = y 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x y : α) (hy : x ≠ y) (hx : x ∉ l) (h : x ∈ y :: l ++ [x] := ⋯)
Goal: (y :: l ++ [x]).next x h = y
-- List.next_getLast_cons
theorem next_getLast_cons (h : x ∈ l) (y : α) (h : x ∈ y :: l) (hy : x ≠ y)
    (hx : x = getLast (y :: l) (cons_ne_nil _ _)) (hl : Nodup l) : next (y :: l) x h = y 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x : α) (h : x ∈ l) (y : α)
Goal: ∀ (h : x ∈ y :: l), x ≠ y → x = (y :: l).getLast ⋯ → l.Nodup → (y :: l).next x h = y
-- List.prev_getLast_cons'
theorem prev_getLast_cons' (y : α) (hxy : x ∈ y :: l) (hx : x = y) :
    prev (y :: l) x hxy = getLast (y :: l) (cons_ne_nil _ _) 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x y : α) (hxy : x ∈ y :: l) (hx : x = y)
Goal: (y :: l).prev x hxy = (y :: l).getLast ⋯
-- List.prev_getLast_cons
@[simp]
theorem prev_getLast_cons (h : x ∈ x :: l) :
    prev (x :: l) x h = getLast (x :: l) (cons_ne_nil _ _) 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x : α) (h : x ∈ x :: l)
Goal: (x :: l).prev x h = (x :: l).getLast ⋯
-- List.prev_cons_cons_eq'
theorem prev_cons_cons_eq' (y z : α) (h : x ∈ y :: z :: l) (hx : x = y) :
    prev (y :: z :: l) x h = getLast (z :: l) (cons_ne_nil _ _) 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x y z : α) (h : x ∈ y :: z :: l) (hx : x = y)
Goal: (y :: z :: l).prev x h = (z :: l).getLast ⋯
-- List.prev_cons_cons_eq
theorem prev_cons_cons_eq (z : α) (h : x ∈ x :: z :: l) :
    prev (x :: z :: l) x h = getLast (z :: l) (cons_ne_nil _ _) 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x z : α) (h : x ∈ x :: z :: l)
Goal: (x :: z :: l).prev x h = (z :: l).getLast ⋯
-- List.prev_cons_cons_of_ne'
theorem prev_cons_cons_of_ne' (y z : α) (h : x ∈ y :: z :: l) (hy : x ≠ y) (hz : x = z) :
    prev (y :: z :: l) x h = y 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x y z : α) (h : x ∈ y :: z :: l) (hy : x ≠ y) (hz : x = z)
Goal: (y :: z :: l).prev x h = y
-- List.prev_cons_cons_of_ne
theorem prev_cons_cons_of_ne (y : α) (h : x ∈ y :: x :: l) (hy : x ≠ y) :
    prev (y :: x :: l) x h = y 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x y : α) (h : x ∈ y :: x :: l) (hy : x ≠ y)
Goal: (y :: x :: l).prev x h = y
-- List.prev_ne_cons_cons
theorem prev_ne_cons_cons (y z : α) (h : x ∈ y :: z :: l) (hy : x ≠ y) (hz : x ≠ z) :
    prev (y :: z :: l) x h = prev (z :: l) x (by simpa [hy] using h) 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x y z : α) (h : x ∈ y :: z :: l) (hy : x ≠ y) (hz : x ≠ z)
Goal: (y :: z :: l).prev x h = (z :: l).prev x ⋯
-- List.next_mem
theorem next_mem (h : x ∈ l) : l.next x h ∈ l 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x : α) (h : x ∈ l)
Goal: l.next x h ∈ l
-- List.prev_mem
theorem prev_mem (h : x ∈ l) : l.prev x h ∈ l 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (x : α) (h : x ∈ l)
Goal: l.prev x h ∈ l
-- List.next_get
theorem next_get : ∀ (l : List α) (_h : Nodup l) (i : Fin l.length),
    next l (l.get i) (get_mem _ _ _) = l.get ⟨(i + 1) % l.length,
      Nat.mod_lt _ (i.1.zero_le.trans_lt i.2)⟩
  
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (_h : l.Nodup) (i : Fin l.length)
Goal: l.next (l.get i) ⋯ = l.get ⟨(↑i + 1) % l.length, ⋯⟩
-- List.next_nthLe
@[deprecated next_get (since := "2023-01-27")]
theorem next_nthLe (l : List α) (h : Nodup l) (n : ℕ) (hn : n < l.length) :
    next l (l.nthLe n hn) (nthLe_mem _ _ _) =
      l.nthLe ((n + 1) % l.length) (Nat.mod_lt _ (n.zero_le.trans_lt hn)) 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (h : l.Nodup) (n : ℕ) (hn : n < l.length)
Goal: l.next (l.nthLe n hn) ⋯ = l.nthLe ((n + 1) % l.length) ⋯
-- List.prev_nthLe
theorem prev_nthLe (l : List α) (h : Nodup l) (n : ℕ) (hn : n < l.length) :
    prev l (l.nthLe n hn) (nthLe_mem _ _ _) =
      l.nthLe ((n + (l.length - 1)) % l.length) (Nat.mod_lt _ (n.zero_le.trans_lt hn)) 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (h : l.Nodup) (n : ℕ) (hn : n < l.length)
Goal: l.prev (l.nthLe n hn) ⋯ = l.nthLe ((n + (l.length - 1)) % l.length) ⋯
-- List.pmap_next_eq_rotate_one
theorem pmap_next_eq_rotate_one (h : Nodup l) : (l.pmap l.next fun _ h => h) = l.rotate 1 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (h : l.Nodup)
Goal: List.pmap l.next l ⋯ = l.rotate 1
-- List.pmap_prev_eq_rotate_length_sub_one
theorem pmap_prev_eq_rotate_length_sub_one (h : Nodup l) :
    (l.pmap l.prev fun _ h => h) = l.rotate (l.length - 1) 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (h : l.Nodup)
Goal: List.pmap l.prev l ⋯ = l.rotate (l.length - 1)
-- List.prev_next
theorem prev_next (l : List α) (h : Nodup l) (x : α) (hx : x ∈ l) :
    prev l (next l x hx) (next_mem _ _ _) = x 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (h : l.Nodup) (x : α) (hx : x ∈ l)
Goal: l.prev (l.next x hx) ⋯ = x
-- List.next_prev
theorem next_prev (l : List α) (h : Nodup l) (x : α) (hx : x ∈ l) :
    next l (prev l x hx) (prev_mem _ _ _) = x 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (h : l.Nodup) (x : α) (hx : x ∈ l)
Goal: l.next (l.prev x hx) ⋯ = x
-- List.prev_reverse_eq_next
theorem prev_reverse_eq_next (l : List α) (h : Nodup l) (x : α) (hx : x ∈ l) :
    prev l.reverse x (mem_reverse.mpr hx) = next l x hx 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (h : l.Nodup) (x : α) (hx : x ∈ l)
Goal: l.reverse.prev x ⋯ = l.next x hx
-- List.next_reverse_eq_prev
theorem next_reverse_eq_prev (l : List α) (h : Nodup l) (x : α) (hx : x ∈ l) :
    next l.reverse x (mem_reverse.mpr hx) = prev l x hx 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (h : l.Nodup) (x : α) (hx : x ∈ l)
Goal: l.reverse.next x ⋯ = l.prev x hx
-- List.isRotated_next_eq
theorem isRotated_next_eq {l l' : List α} (h : l ~r l') (hn : Nodup l) {x : α} (hx : x ∈ l) :
    l.next x hx = l'.next x (h.mem_iff.mp hx) 
Arguments: {α : Type u_1} [DecidableEq α] {l l' : List α} (h : l ~r l') (hn : l.Nodup) {x : α} (hx : x ∈ l)
Goal: l.next x hx = l'.next x ⋯
-- List.isRotated_prev_eq
theorem isRotated_prev_eq {l l' : List α} (h : l ~r l') (hn : Nodup l) {x : α} (hx : x ∈ l) :
    l.prev x hx = l'.prev x (h.mem_iff.mp hx) 
Arguments: {α : Type u_1} [DecidableEq α] {l l' : List α} (h : l ~r l') (hn : l.Nodup) {x : α} (hx : x ∈ l)
Goal: l.prev x hx = l'.prev x ⋯
-- Cycle.coe_eq_coe
@[simp]
theorem coe_eq_coe {l₁ l₂ : List α} : (l₁ : Cycle α) = (l₂ : Cycle α) ↔ l₁ ~r l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: ↑l₁ = ↑l₂ ↔ l₁ ~r l₂
-- Cycle.mk_eq_coe
@[simp]
theorem mk_eq_coe (l : List α) : Quot.mk _ l = (l : Cycle α) 
Arguments: {α : Type u_1} (l : List α)
Goal: Quot.mk Setoid.r l = ↑l
-- Cycle.mk''_eq_coe
@[simp]
theorem mk''_eq_coe (l : List α) : Quotient.mk'' l = (l : Cycle α) 
Arguments: {α : Type u_1} (l : List α)
Goal: Quotient.mk'' l = ↑l
-- Cycle.coe_cons_eq_coe_append
theorem coe_cons_eq_coe_append (l : List α) (a : α) :
    (↑(a :: l) : Cycle α) = (↑(l ++ [a]) : Cycle α) 
Arguments: {α : Type u_1} (l : List α) (a : α)
Goal: ↑(a :: l) = ↑(l ++ [a])
-- Cycle.coe_nil
@[simp]
theorem coe_nil : ↑([] : List α) = @nil α 
Arguments: {α : Type u_1}
Goal: ↑[] = Cycle.nil
-- Cycle.coe_eq_nil
@[simp]
theorem coe_eq_nil (l : List α) : (l : Cycle α) = nil ↔ l = [] 
Arguments: {α : Type u_1} (l : List α)
Goal: ↑l = Cycle.nil ↔ l = []
-- Cycle.empty_eq
@[simp]
theorem empty_eq : ∅ = @nil α 
Arguments: {α : Type u_1}
Goal: ∅ = Cycle.nil
-- Cycle.induction_on
@[elab_as_elim, induction_eliminator]
theorem induction_on {C : Cycle α → Prop} (s : Cycle α) (H0 : C nil)
    (HI : ∀ (a) (l : List α), C ↑l → C ↑(a :: l)) : C s 
Arguments: {α : Type u_1} {C : Cycle α → Prop} (s : Cycle α) (H0 : C Cycle.nil) (HI : ∀ (a : α) (l : List α), C ↑l → C ↑(a :: l))
Goal: C s
-- Cycle.mem_coe_iff
@[simp]
theorem mem_coe_iff {a : α} {l : List α} : a ∈ (↑l : Cycle α) ↔ a ∈ l 
Arguments: {α : Type u_1} {a : α} {l : List α}
Goal: a ∈ ↑l ↔ a ∈ l
-- Cycle.not_mem_nil
@[simp]
theorem not_mem_nil : ∀ a, a ∉ @nil α 
Arguments: {α : Type u_1} (a : α)
Goal: a ∉ Cycle.nil
-- Cycle.reverse_coe
@[simp]
theorem reverse_coe (l : List α) : (l : Cycle α).reverse = l.reverse 
Arguments: {α : Type u_1} (l : List α)
Goal: (↑l).reverse = ↑l.reverse
-- Cycle.mem_reverse_iff
@[simp]
theorem mem_reverse_iff {a : α} {s : Cycle α} : a ∈ s.reverse ↔ a ∈ s 
Arguments: {α : Type u_1} {a : α} {s : Cycle α}
Goal: a ∈ s.reverse ↔ a ∈ s
-- Cycle.reverse_reverse
@[simp]
theorem reverse_reverse (s : Cycle α) : s.reverse.reverse = s 
Arguments: {α : Type u_1} (s : Cycle α)
Goal: s.reverse.reverse = s
-- Cycle.reverse_nil
@[simp]
theorem reverse_nil : nil.reverse = @nil α 
Arguments: {α : Type u_1}
Goal: Cycle.nil.reverse = Cycle.nil
-- Cycle.length_coe
@[simp]
theorem length_coe (l : List α) : length (l : Cycle α) = l.length 
Arguments: {α : Type u_1} (l : List α)
Goal: (↑l).length = l.length
-- Cycle.length_nil
@[simp]
theorem length_nil : length (@nil α) = 0 
Arguments: {α : Type u_1}
Goal: Cycle.nil.length = 0
-- Cycle.length_reverse
@[simp]
theorem length_reverse (s : Cycle α) : s.reverse.length = s.length 
Arguments: {α : Type u_1} (s : Cycle α)
Goal: s.reverse.length = s.length
-- Cycle.subsingleton_nil
theorem subsingleton_nil : Subsingleton (@nil α) 
Arguments: {α : Type u_1}
Goal: Cycle.nil.Subsingleton
-- Cycle.length_subsingleton_iff
theorem length_subsingleton_iff {s : Cycle α} : Subsingleton s ↔ length s ≤ 1 
Arguments: {α : Type u_1} {s : Cycle α}
Goal: s.Subsingleton ↔ s.length ≤ 1
-- Cycle.subsingleton_reverse_iff
@[simp]
theorem subsingleton_reverse_iff {s : Cycle α} : s.reverse.Subsingleton ↔ s.Subsingleton 
Arguments: {α : Type u_1} {s : Cycle α}
Goal: s.reverse.Subsingleton ↔ s.Subsingleton
-- Cycle.Subsingleton.congr
theorem Subsingleton.congr {s : Cycle α} (h : Subsingleton s) :
    ∀ ⦃x⦄ (_hx : x ∈ s) ⦃y⦄ (_hy : y ∈ s), x = y 
Arguments: {α : Type u_1} {s : Cycle α} (h : s.Subsingleton) ⦃x : α⦄ (_hx : x ∈ s) ⦃y : α⦄ (_hy : y ∈ s)
Goal: x = y
-- Cycle.nontrivial_coe_nodup_iff
@[simp]
theorem nontrivial_coe_nodup_iff {l : List α} (hl : l.Nodup) :
    Nontrivial (l : Cycle α) ↔ 2 ≤ l.length 
Arguments: {α : Type u_1} {l : List α} (hl : l.Nodup)
Goal: (↑l).Nontrivial ↔ 2 ≤ l.length
-- Cycle.nontrivial_reverse_iff
@[simp]
theorem nontrivial_reverse_iff {s : Cycle α} : s.reverse.Nontrivial ↔ s.Nontrivial 
Arguments: {α : Type u_1} {s : Cycle α}
Goal: s.reverse.Nontrivial ↔ s.Nontrivial
-- Cycle.length_nontrivial
theorem length_nontrivial {s : Cycle α} (h : Nontrivial s) : 2 ≤ length s 
Arguments: {α : Type u_1} {s : Cycle α} (h : s.Nontrivial)
Goal: 2 ≤ s.length
-- Cycle.nodup_nil
@[simp]
nonrec theorem nodup_nil : Nodup (@nil α) 
Arguments: {α : Type u_1}
Goal: Cycle.nil.Nodup
-- Cycle.nodup_coe_iff
@[simp]
theorem nodup_coe_iff {l : List α} : Nodup (l : Cycle α) ↔ l.Nodup 
Arguments: {α : Type u_1} {l : List α}
Goal: (↑l).Nodup ↔ l.Nodup
-- Cycle.nodup_reverse_iff
@[simp]
theorem nodup_reverse_iff {s : Cycle α} : s.reverse.Nodup ↔ s.Nodup 
Arguments: {α : Type u_1} {s : Cycle α}
Goal: s.reverse.Nodup ↔ s.Nodup
-- Cycle.Subsingleton.nodup
theorem Subsingleton.nodup {s : Cycle α} (h : Subsingleton s) : Nodup s 
Arguments: {α : Type u_1} {s : Cycle α} (h : s.Subsingleton)
Goal: s.Nodup
-- Cycle.Nodup.nontrivial_iff
theorem Nodup.nontrivial_iff {s : Cycle α} (h : Nodup s) : Nontrivial s ↔ ¬Subsingleton s 
Arguments: {α : Type u_1} {s : Cycle α} (h : s.Nodup)
Goal: s.Nontrivial ↔ ¬s.Subsingleton
-- Cycle.coe_toMultiset
@[simp]
theorem coe_toMultiset (l : List α) : (l : Cycle α).toMultiset = l 
Arguments: {α : Type u_1} (l : List α)
Goal: (↑l).toMultiset = ↑l
-- Cycle.nil_toMultiset
@[simp]
theorem nil_toMultiset : nil.toMultiset = (0 : Multiset α) 
Arguments: {α : Type u_1}
Goal: Cycle.nil.toMultiset = 0
-- Cycle.card_toMultiset
@[simp]
theorem card_toMultiset (s : Cycle α) : Multiset.card s.toMultiset = s.length 
Arguments: {α : Type u_1} (s : Cycle α)
Goal: Multiset.card s.toMultiset = s.length
-- Cycle.toMultiset_eq_nil
@[simp]
theorem toMultiset_eq_nil {s : Cycle α} : s.toMultiset = 0 ↔ s = Cycle.nil 
Arguments: {α : Type u_1} {s : Cycle α}
Goal: s.toMultiset = 0 ↔ s = Cycle.nil
-- Cycle.map_nil
@[simp]
theorem map_nil {β : Type*} (f : α → β) : map f nil = nil 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β)
Goal: Cycle.map f Cycle.nil = Cycle.nil
-- Cycle.map_coe
@[simp]
theorem map_coe {β : Type*} (f : α → β) (l : List α) : map f ↑l = List.map f l 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α)
Goal: Cycle.map f ↑l = ↑(List.map f l)
-- Cycle.map_eq_nil
@[simp]
theorem map_eq_nil {β : Type*} (f : α → β) (s : Cycle α) : map f s = nil ↔ s = nil 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (s : Cycle α)
Goal: Cycle.map f s = Cycle.nil ↔ s = Cycle.nil
-- Cycle.mem_map
@[simp]
theorem mem_map {β : Type*} {f : α → β} {b : β} {s : Cycle α} :
    b ∈ s.map f ↔ ∃ a, a ∈ s ∧ f a = b 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → β} {b : β} {s : Cycle α}
Goal: b ∈ Cycle.map f s ↔ ∃ a ∈ s, f a = b
-- Cycle.lists_coe
@[simp]
theorem lists_coe (l : List α) : lists (l : Cycle α) = ↑l.cyclicPermutations 
Arguments: {α : Type u_1} (l : List α)
Goal: (↑l).lists = ↑l.cyclicPermutations
-- Cycle.mem_lists_iff_coe_eq
@[simp]
theorem mem_lists_iff_coe_eq {s : Cycle α} {l : List α} : l ∈ s.lists ↔ (l : Cycle α) = s 
Arguments: {α : Type u_1} {s : Cycle α} {l : List α}
Goal: l ∈ s.lists ↔ ↑l = s
-- Cycle.lists_nil
@[simp]
theorem lists_nil : lists (@nil α) = [([] : List α)] 
Arguments: {α : Type u_1}
Goal: Cycle.nil.lists = ↑[[]]
-- Cycle.toFinset_toMultiset
@[simp]
theorem toFinset_toMultiset (s : Cycle α) : s.toMultiset.toFinset = s.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (s : Cycle α)
Goal: s.toMultiset.toFinset = s.toFinset
-- Cycle.coe_toFinset
@[simp]
theorem coe_toFinset (l : List α) : (l : Cycle α).toFinset = l.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α)
Goal: (↑l).toFinset = l.toFinset
-- Cycle.nil_toFinset
@[simp]
theorem nil_toFinset : (@nil α).toFinset = ∅ 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Cycle.nil.toFinset = ∅
-- Cycle.toFinset_eq_nil
@[simp]
theorem toFinset_eq_nil {s : Cycle α} : s.toFinset = ∅ ↔ s = Cycle.nil 
Arguments: {α : Type u_1} [DecidableEq α] {s : Cycle α}
Goal: s.toFinset = ∅ ↔ s = Cycle.nil