ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Batteries.DList.toList_append
theorem toList_append (l₁ l₂ : DList α) : toList (l₁ ++ l₂) = toList l₁ ++ toList l₂ 
Arguments: {α : Type u} (l₁ l₂ : Batteries.DList α)
Goal: (l₁ ++ l₂).toList = l₁.toList ++ l₂.toList
-- Batteries.DList.toList_cons
theorem toList_cons (x : α) (l : DList α) : toList (cons x l) = x :: toList l 
Arguments: {α : Type u} (x : α) (l : Batteries.DList α)
Goal: (Batteries.DList.cons x l).toList = x :: l.toList
-- Batteries.DList.toList_push
theorem toList_push (x : α) (l : DList α) : toList (push l x) = toList l ++ [x] 
Arguments: {α : Type u} (x : α) (l : Batteries.DList α)
Goal: (l.push x).toList = l.toList ++ [x]
-- List.mapIdx_nil
@[simp]
theorem mapIdx_nil {α β} (f : ℕ → α → β) : mapIdx f [] = [] 
Arguments: {α : Type u_1} {β : Type u_2} (f : ℕ → α → β)
Goal: List.mapIdx f [] = []
-- List.oldMapIdxCore_eq
protected theorem oldMapIdxCore_eq (l : List α) (f : ℕ → α → β) (n : ℕ) :
    l.oldMapIdxCore f n = l.oldMapIdx fun i a ↦ f (i + n) a 
Arguments: {α : Type u} {β : Type v} (l : List α) (f : ℕ → α → β) (n : ℕ)
Goal: List.oldMapIdxCore f n l = List.oldMapIdx (fun i a => f (i + n) a) l
-- List.list_reverse_induction
theorem list_reverse_induction (p : List α → Prop) (base : p [])
    (ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])) : (∀ (l : List α), p l) 
Arguments: {α : Type u} (p : List α → Prop) (base : p []) (ind : ∀ (l : List α) (e : α), p l → p (l ++ [e])) (l : List α)
Goal: p l
-- List.oldMapIdxCore_append
protected theorem oldMapIdxCore_append : ∀ (f : ℕ → α → β) (n : ℕ) (l₁ l₂ : List α),
    List.oldMapIdxCore f n (l₁ ++ l₂) =
    List.oldMapIdxCore f n l₁ ++ List.oldMapIdxCore f (n + l₁.length) l₂ 
Arguments: {α : Type u} {β : Type v} (f : ℕ → α → β) (n : ℕ) (l₁ l₂ : List α)
Goal: List.oldMapIdxCore f n (l₁ ++ l₂) = List.oldMapIdxCore f n l₁ ++ List.oldMapIdxCore f (n + l₁.length) l₂
-- List.oldMapIdx_append
protected theorem oldMapIdx_append : ∀ (f : ℕ → α → β) (l : List α) (e : α),
    List.oldMapIdx f (l ++ [e]) = List.oldMapIdx f l ++ [f l.length e] 
Arguments: {α : Type u} {β : Type v} (f : ℕ → α → β) (l : List α) (e : α)
Goal: List.oldMapIdx f (l ++ [e]) = List.oldMapIdx f l ++ [f l.length e]
-- List.mapIdxGo_append
theorem mapIdxGo_append : ∀ (f : ℕ → α → β) (l₁ l₂ : List α) (arr : Array β),
    mapIdx.go f (l₁ ++ l₂) arr = mapIdx.go f l₂ (List.toArray (mapIdx.go f l₁ arr)) 
Arguments: {α : Type u} {β : Type v} (f : ℕ → α → β) (l₁ l₂ : List α) (arr : Array β)
Goal: List.mapIdx.go f (l₁ ++ l₂) arr = List.mapIdx.go f l₂ (List.toArray (List.mapIdx.go f l₁ arr))
-- List.mapIdxGo_length
theorem mapIdxGo_length : ∀ (f : ℕ → α → β) (l : List α) (arr : Array β),
    length (mapIdx.go f l arr) = length l + arr.size 
Arguments: {α : Type u} {β : Type v} (f : ℕ → α → β) (l : List α) (arr : Array β)
Goal: (List.mapIdx.go f l arr).length = l.length + arr.size
-- List.mapIdx_append_one
theorem mapIdx_append_one : ∀ (f : ℕ → α → β) (l : List α) (e : α),
    mapIdx f (l ++ [e]) = mapIdx f l ++ [f l.length e] 
Arguments: {α : Type u} {β : Type v} (f : ℕ → α → β) (l : List α) (e : α)
Goal: List.mapIdx f (l ++ [e]) = List.mapIdx f l ++ [f l.length e]
-- List.new_def_eq_old_def
protected theorem new_def_eq_old_def :
    ∀ (f : ℕ → α → β) (l : List α), l.mapIdx f = List.oldMapIdx f l 
Arguments: {α : Type u} {β : Type v} (f : ℕ → α → β) (l : List α)
Goal: List.mapIdx f l = List.oldMapIdx f l
-- List.map_enumFrom_eq_zipWith
@[local simp]
theorem map_enumFrom_eq_zipWith : ∀ (l : List α) (n : ℕ) (f : ℕ → α → β),
    map (uncurry f) (enumFrom n l) = zipWith (fun i ↦ f (i + n)) (range (length l)) l 
Arguments: {α : Type u} {β : Type v} (l : List α) (n : ℕ) (f : ℕ → α → β)
Goal: List.map (Function.uncurry f) (List.enumFrom n l) = List.zipWith (fun i => f (i + n)) (List.range l.length) l
-- List.mapIdx_eq_enum_map
theorem mapIdx_eq_enum_map (l : List α) (f : ℕ → α → β) :
    l.mapIdx f = l.enum.map (Function.uncurry f) 
Arguments: {α : Type u} {β : Type v} (l : List α) (f : ℕ → α → β)
Goal: List.mapIdx f l = List.map (Function.uncurry f) l.enum
-- List.mapIdx_cons
@[simp]
theorem mapIdx_cons (l : List α) (f : ℕ → α → β) (a : α) :
    mapIdx f (a :: l) = f 0 a :: mapIdx (fun i ↦ f (i + 1)) l 
Arguments: {α : Type u} {β : Type v} (l : List α) (f : ℕ → α → β) (a : α)
Goal: List.mapIdx f (a :: l) = f 0 a :: List.mapIdx (fun i => f (i + 1)) l
-- List.mapIdx_append
theorem mapIdx_append (K L : List α) (f : ℕ → α → β) :
    (K ++ L).mapIdx f = K.mapIdx f ++ L.mapIdx fun i a ↦ f (i + K.length) a 
Arguments: {α : Type u} {β : Type v} (K L : List α) (f : ℕ → α → β)
Goal: List.mapIdx f (K ++ L) = List.mapIdx f K ++ List.mapIdx (fun i a => f (i + K.length) a) L
-- List.length_mapIdx
@[simp]
theorem length_mapIdx (l : List α) (f : ℕ → α → β) : (l.mapIdx f).length = l.length 
Arguments: {α : Type u} {β : Type v} (l : List α) (f : ℕ → α → β)
Goal: (List.mapIdx f l).length = l.length
-- List.mapIdx_eq_nil
@[simp]
theorem mapIdx_eq_nil {f : ℕ → α → β} {l : List α} : List.mapIdx f l = [] ↔ l = [] 
Arguments: {α : Type u} {β : Type v} {f : ℕ → α → β} {l : List α}
Goal: List.mapIdx f l = [] ↔ l = []
-- List.nthLe_mapIdx
@[simp, deprecated (since := "2023-02-11")]
theorem nthLe_mapIdx (l : List α) (f : ℕ → α → β) (i : ℕ) (h : i < l.length)
    (h' : i < (l.mapIdx f).length := h.trans_le (l.length_mapIdx f).ge) :
    (l.mapIdx f).nthLe i h' = f i (l.nthLe i h) 
Arguments: {α : Type u} {β : Type v} (l : List α) (f : ℕ → α → β) (i : ℕ) (h : i < l.length) (h' : i < (List.mapIdx f l).length := ⋯)
Goal: (List.mapIdx f l).nthLe i h' = f i (l.nthLe i h)
-- List.mapIdx_eq_ofFn
theorem mapIdx_eq_ofFn (l : List α) (f : ℕ → α → β) :
    l.mapIdx f = ofFn fun i : Fin l.length ↦ f (i : ℕ) (l.get i) 
Arguments: {α : Type u} {β : Type v} (l : List α) (f : ℕ → α → β)
Goal: List.mapIdx f l = List.ofFn fun i => f (↑i) (l.get i)
-- List.foldrIdxSpec_cons
theorem foldrIdxSpec_cons (f : ℕ → α → β → β) (b a as start) :
    foldrIdxSpec f b (a :: as) start = f start a (foldrIdxSpec f b as (start + 1)) 
Arguments: {α : Type u} {β : Type v} (f : ℕ → α → β → β) (b : β) (a : α) (as : List α) (start : ℕ)
Goal: List.foldrIdxSpec f b (a :: as) start = f start a (List.foldrIdxSpec f b as (start + 1))
-- List.foldrIdx_eq_foldrIdxSpec
theorem foldrIdx_eq_foldrIdxSpec (f : ℕ → α → β → β) (b as start) :
    foldrIdx f b as start = foldrIdxSpec f b as start 
Arguments: {α : Type u} {β : Type v} (f : ℕ → α → β → β) (b : β) (as : List α) (start : ℕ)
Goal: List.foldrIdx f b as start = List.foldrIdxSpec f b as start
-- List.foldrIdx_eq_foldr_enum
theorem foldrIdx_eq_foldr_enum (f : ℕ → α → β → β) (b : β) (as : List α) :
    foldrIdx f b as = foldr (uncurry f) b (enum as) 
Arguments: {α : Type u} {β : Type v} (f : ℕ → α → β → β) (b : β) (as : List α)
Goal: List.foldrIdx f b as = List.foldr (Function.uncurry f) b as.enum
-- List.indexesValues_eq_filter_enum
theorem indexesValues_eq_filter_enum (p : α → Prop) [DecidablePred p] (as : List α) :
    indexesValues p as = filter (p ∘ Prod.snd) (enum as) 
Arguments: {α : Type u} (p : α → Prop) [DecidablePred p] (as : List α)
Goal: List.indexesValues (fun b => decide (p b)) as = List.filter ((fun b => decide (p b)) ∘ Prod.snd) as.enum
-- List.findIdxs_eq_map_indexesValues
theorem findIdxs_eq_map_indexesValues (p : α → Prop) [DecidablePred p] (as : List α) :
    findIdxs p as = map Prod.fst (indexesValues p as) 
Arguments: {α : Type u} (p : α → Prop) [DecidablePred p] (as : List α)
Goal: List.findIdxs (fun b => decide (p b)) as = List.map Prod.fst (List.indexesValues (fun b => decide (p b)) as)
-- List.findIdx_eq_length
theorem findIdx_eq_length {p : α → Bool} {xs : List α} :
    xs.findIdx p = xs.length ↔ ∀ x ∈ xs, ¬p x 
Arguments: {α : Type u} {p : α → Bool} {xs : List α}
Goal: List.findIdx p xs = xs.length ↔ ∀ x ∈ xs, ¬p x = true
-- List.findIdx_le_length
theorem findIdx_le_length (p : α → Bool) {xs : List α} : xs.findIdx p ≤ xs.length 
Arguments: {α : Type u} (p : α → Bool) {xs : List α}
Goal: List.findIdx p xs ≤ xs.length
-- List.findIdx_lt_length
theorem findIdx_lt_length {p : α → Bool} {xs : List α} :
    xs.findIdx p < xs.length ↔ ∃ x ∈ xs, p x 
Arguments: {α : Type u} {p : α → Bool} {xs : List α}
Goal: List.findIdx p xs < xs.length ↔ ∃ x ∈ xs, p x = true
-- List.not_of_lt_findIdx
theorem not_of_lt_findIdx {p : α → Bool} {xs : List α} {i : ℕ} (h : i < xs.findIdx p) :
    ¬p (xs.get ⟨i, h.trans_le (findIdx_le_length p)⟩) 
Arguments: {α : Type u} {p : α → Bool} {xs : List α} {i : ℕ} (h : i < List.findIdx p xs)
Goal: ¬p (xs.get ⟨i, ⋯⟩) = true
-- List.le_findIdx_of_not
theorem le_findIdx_of_not {p : α → Bool} {xs : List α} {i : ℕ} (h : i < xs.length)
    (h2 : ∀ j (hji : j < i), ¬p (xs.get ⟨j, hji.trans h⟩)) : i ≤ xs.findIdx p 
Arguments: {α : Type u} {p : α → Bool} {xs : List α} {i : ℕ} (h : i < xs.length) (h2 : ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true)
Goal: i ≤ List.findIdx p xs
-- List.lt_findIdx_of_not
theorem lt_findIdx_of_not {p : α → Bool} {xs : List α} {i : ℕ} (h : i < xs.length)
    (h2 : ∀ j (hji : j ≤ i), ¬p (xs.get ⟨j, hji.trans_lt h⟩)) : i < xs.findIdx p 
Arguments: {α : Type u} {p : α → Bool} {xs : List α} {i : ℕ} (h : i < xs.length) (h2 : ∀ (j : ℕ) (hji : j ≤ i), ¬p (xs.get ⟨j, ⋯⟩) = true)
Goal: i < List.findIdx p xs
-- List.findIdx_eq
theorem findIdx_eq {p : α → Bool} {xs : List α} {i : ℕ} (h : i < xs.length) :
    xs.findIdx p = i ↔ p (xs.get ⟨i, h⟩) ∧ ∀ j (hji : j < i), ¬p (xs.get ⟨j, hji.trans h⟩) 
Arguments: {α : Type u} {p : α → Bool} {xs : List α} {i : ℕ} (h : i < xs.length)
Goal: List.findIdx p xs = i ↔ p (xs.get ⟨i, h⟩) = true ∧ ∀ (j : ℕ) (hji : j < i), ¬p (xs.get ⟨j, ⋯⟩) = true
-- List.foldlIdxSpec_cons
theorem foldlIdxSpec_cons (f : ℕ → α → β → α) (a b bs start) :
    foldlIdxSpec f a (b :: bs) start = foldlIdxSpec f (f start a b) bs (start + 1) 
Arguments: {α : Type u} {β : Type v} (f : ℕ → α → β → α) (a : α) (b : β) (bs : List β) (start : ℕ)
Goal: List.foldlIdxSpec f a (b :: bs) start = List.foldlIdxSpec f (f start a b) bs (start + 1)
-- List.foldlIdx_eq_foldlIdxSpec
theorem foldlIdx_eq_foldlIdxSpec (f : ℕ → α → β → α) (a bs start) :
    foldlIdx f a bs start = foldlIdxSpec f a bs start 
Arguments: {α : Type u} {β : Type v} (f : ℕ → α → β → α) (a : α) (bs : List β) (start : ℕ)
Goal: List.foldlIdx f a bs start = List.foldlIdxSpec f a bs start
-- List.foldlIdx_eq_foldl_enum
theorem foldlIdx_eq_foldl_enum (f : ℕ → α → β → α) (a : α) (bs : List β) :
    foldlIdx f a bs = foldl (fun a p ↦ f p.fst a p.snd) a (enum bs) 
Arguments: {α : Type u} {β : Type v} (f : ℕ → α → β → α) (a : α) (bs : List β)
Goal: List.foldlIdx f a bs = List.foldl (fun a p => f p.1 a p.2) a bs.enum
-- List.foldrIdxM_eq_foldrM_enum
theorem foldrIdxM_eq_foldrM_enum {β} (f : ℕ → α → β → m β) (b : β) (as : List α) [LawfulMonad m] :
    foldrIdxM f b as = foldrM (uncurry f) b (enum as) 
Arguments: {α : Type u} {m : Type u → Type v} [Monad m] {β : Type u} (f : ℕ → α → β → m β) (b : β) (as : List α) [LawfulMonad m]
Goal: List.foldrIdxM f b as = List.foldrM (Function.uncurry f) b as.enum
-- List.foldlIdxM_eq_foldlM_enum
theorem foldlIdxM_eq_foldlM_enum [LawfulMonad m] {β} (f : ℕ → β → α → m β) (b : β) (as : List α) :
    foldlIdxM f b as = List.foldlM (fun b p ↦ f p.fst b p.snd) b (enum as) 
Arguments: {α : Type u} {m : Type u → Type v} [Monad m] [LawfulMonad m] {β : Type u} (f : ℕ → β → α → m β) (b : β) (as : List α)
Goal: List.foldlIdxM f b as = List.foldlM (fun b p => f p.1 b p.2) b as.enum
-- List.mapIdxMAuxSpec_cons
theorem mapIdxMAuxSpec_cons {β} (f : ℕ → α → m β) (start : ℕ) (a : α) (as : List α) :
    mapIdxMAuxSpec f start (a :: as) = cons <$> f start a <*> mapIdxMAuxSpec f (start + 1) as 
Arguments: {α : Type u} {m : Type u → Type v} [Monad m] {β : Type u} (f : ℕ → α → m β) (start : ℕ) (a : α) (as : List α)
Goal: List.mapIdxMAuxSpec f start (a :: as) = Seq.seq (List.cons <$> f start a) fun x => List.mapIdxMAuxSpec f (start + 1) as
-- List.mapIdxMGo_eq_mapIdxMAuxSpec
theorem mapIdxMGo_eq_mapIdxMAuxSpec
    [LawfulMonad m] {β} (f : ℕ → α → m β) (arr : Array β) (as : List α) :
    mapIdxM.go f as arr = (arr.toList ++ ·) <$> mapIdxMAuxSpec f arr.size as 
Arguments: {α : Type u} {m : Type u → Type v} [Monad m] [LawfulMonad m] {β : Type u} (f : ℕ → α → m β) (arr : Array β) (as : List α)
Goal: List.mapIdxM.go f as arr = (fun x => arr.toList ++ x) <$> List.mapIdxMAuxSpec f arr.size as
-- List.mapIdxM_eq_mmap_enum
theorem mapIdxM_eq_mmap_enum [LawfulMonad m] {β} (f : ℕ → α → m β) (as : List α) :
    as.mapIdxM f = List.traverse (uncurry f) (enum as) 
Arguments: {α : Type u} {m : Type u → Type v} [Monad m] [LawfulMonad m] {β : Type u} (f : ℕ → α → m β) (as : List α)
Goal: as.mapIdxM f = List.traverse (Function.uncurry f) as.enum
-- List.mapIdxMAux'_eq_mapIdxMGo
theorem mapIdxMAux'_eq_mapIdxMGo {α} (f : ℕ → α → m PUnit) (as : List α) (arr : Array PUnit) :
    mapIdxMAux' f arr.size as = mapIdxM.go f as arr *> pure PUnit.unit 
Arguments: {m : Type u → Type v} [Monad m] [LawfulMonad m] {α : Type u_1} (f : ℕ → α → m PUnit.{u + 1}) (as : List α) (arr : Array PUnit.{u + 1})
Goal: List.mapIdxMAux' f arr.size as = SeqRight.seqRight (List.mapIdxM.go f as arr) fun x => pure PUnit.unit
-- List.mapIdxM'_eq_mapIdxM
theorem mapIdxM'_eq_mapIdxM {α} (f : ℕ → α → m PUnit) (as : List α) :
    mapIdxM' f as = mapIdxM as f *> pure PUnit.unit 
Arguments: {m : Type u → Type v} [Monad m] [LawfulMonad m] {α : Type u_1} (f : ℕ → α → m PUnit.{u + 1}) (as : List α)
Goal: List.mapIdxM' f as = SeqRight.seqRight (as.mapIdxM f) fun x => pure PUnit.unit
-- List.Pairwise.forall_of_forall
theorem Pairwise.forall_of_forall (H : Symmetric R) (H₁ : ∀ x ∈ l, R x x) (H₂ : l.Pairwise R) :
    ∀ ⦃x⦄, x ∈ l → ∀ ⦃y⦄, y ∈ l → R x y 
Arguments: {α : Type u_1} {R : α → α → Prop} {l : List α} (H : Symmetric R) (H₁ : ∀ (x : α), x ∈ l → R x x) (H₂ : List.Pairwise R l) ⦃x : α⦄
Goal: x ∈ l → ∀ ⦃y : α⦄, y ∈ l → R x y
-- List.Pairwise.forall
theorem Pairwise.forall (hR : Symmetric R) (hl : l.Pairwise R) :
    ∀ ⦃a⦄, a ∈ l → ∀ ⦃b⦄, b ∈ l → a ≠ b → R a b 
Arguments: {α : Type u_1} {R : α → α → Prop} {l : List α} (hR : Symmetric R) (hl : List.Pairwise R l) ⦃a : α⦄
Goal: a ∈ l → ∀ ⦃b : α⦄, b ∈ l → a ≠ b → R a b
-- List.Pairwise.set_pairwise
theorem Pairwise.set_pairwise (hl : Pairwise R l) (hr : Symmetric R) : { x | x ∈ l }.Pairwise R 
Arguments: {α : Type u_1} {R : α → α → Prop} {l : List α} (hl : List.Pairwise R l) (hr : Symmetric R)
Goal: {x | x ∈ l}.Pairwise R
-- List.pairwise_map'
@[deprecated (since := "2024-02-25")] theorem pairwise_map' (f : β → α) :
    ∀ {l : List β}, Pairwise R (map f l) ↔ Pairwise (fun a b : β => R (f a) (f b)) l
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → α → Prop} (f : β → α) {l : List β}
Goal: List.Pairwise R (List.map f l) ↔ List.Pairwise (fun a b => R (f a) (f b)) l
-- List.pairwise_pmap
theorem pairwise_pmap {p : β → Prop} {f : ∀ b, p b → α} {l : List β} (h : ∀ x ∈ l, p x) :
    Pairwise R (l.pmap f h) ↔
      Pairwise (fun b₁ b₂ => ∀ (h₁ : p b₁) (h₂ : p b₂), R (f b₁ h₁) (f b₂ h₂)) l 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → α → Prop} {p : β → Prop} {f : (b : β) → p b → α} {l : List β} (h : ∀ (x : β), x ∈ l → p x)
Goal: List.Pairwise R (List.pmap f l h) ↔ List.Pairwise (fun b₁ b₂ => ∀ (h₁ : p b₁) (h₂ : p b₂), R (f b₁ h₁) (f b₂ h₂)) l
-- List.Pairwise.pmap
theorem Pairwise.pmap {l : List α} (hl : Pairwise R l) {p : α → Prop} {f : ∀ a, p a → β}
    (h : ∀ x ∈ l, p x) {S : β → β → Prop}
    (hS : ∀ ⦃x⦄ (hx : p x) ⦃y⦄ (hy : p y), R x y → S (f x hx) (f y hy)) :
    Pairwise S (l.pmap f h) 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → α → Prop} {l : List α} (hl : List.Pairwise R l) {p : α → Prop} {f : (a : α) → p a → β} (h : ∀ (x : α), x ∈ l → p x) {S : β → β → Prop} (hS : ∀ ⦃x : α⦄ (hx : p x) ⦃y : α⦄ (hy : p y), R x y → S (f x hx) (f y hy))
Goal: List.Pairwise S (List.pmap f l h)
-- List.pairwise_of_forall_mem_list
theorem pairwise_of_forall_mem_list {l : List α} {r : α → α → Prop} (h : ∀ a ∈ l, ∀ b ∈ l, r a b) :
    l.Pairwise r 
Arguments: {α : Type u_1} {l : List α} {r : α → α → Prop} (h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b)
Goal: List.Pairwise r l
-- List.pairwise_of_reflexive_of_forall_ne
theorem pairwise_of_reflexive_of_forall_ne {l : List α} {r : α → α → Prop} (hr : Reflexive r)
    (h : ∀ a ∈ l, ∀ b ∈ l, a ≠ b → r a b) : l.Pairwise r 
Arguments: {α : Type u_1} {l : List α} {r : α → α → Prop} (hr : Reflexive r) (h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b)
Goal: List.Pairwise r l
-- List.pairwise_iff_nthLe
@[deprecated pairwise_iff_get (since := "2023-01-10")]
theorem pairwise_iff_nthLe {R} {l : List α} : Pairwise R l ↔
    ∀ (i j) (h₁ : j < length l) (h₂ : i < j), R (nthLe l i (lt_trans h₂ h₁)) (nthLe l j h₁) 
Arguments: {α : Type u_1} {R : α → α → Prop} {l : List α}
Goal: List.Pairwise R l ↔ ∀ (i j : ℕ) (h₁ : j < l.length) (h₂ : i < j), R (l.nthLe i ⋯) (l.nthLe j h₁)
-- countable_iff_nonempty_embedding
theorem countable_iff_nonempty_embedding : Countable α ↔ Nonempty (α ↪ ℕ) 
Arguments: {α : Sort u}
Goal: Countable α ↔ Nonempty (α ↪ ℕ)
-- uncountable_iff_isEmpty_embedding
theorem uncountable_iff_isEmpty_embedding : Uncountable α ↔ IsEmpty (α ↪ ℕ) 
Arguments: {α : Sort u}
Goal: Uncountable α ↔ IsEmpty (α ↪ ℕ)
-- nonempty_embedding_nat
theorem nonempty_embedding_nat (α) [Countable α] : Nonempty (α ↪ ℕ) 
Arguments: (α : Sort u_1) [Countable α]
Goal: Nonempty (α ↪ ℕ)
-- Function.Embedding.countable
protected theorem Function.Embedding.countable [Countable β] (f : α ↪ β) : Countable α 
Arguments: {α : Sort u} {β : Sort v} [Countable β] (f : α ↪ β)
Goal: Countable α
-- Function.Embedding.uncountable
protected lemma Function.Embedding.uncountable [Uncountable α] (f : α ↪ β) : Uncountable β 
Arguments: {α : Sort u} {β : Sort v} [Uncountable α] (f : α ↪ β)
Goal: Uncountable β
-- Sigma.uncountable
lemma Sigma.uncountable (a : α) [Uncountable (π a)] : Uncountable (Sigma π) 
Arguments: {α : Type u} {π : α → Type w} (a : α) [Uncountable (π a)]
Goal: Uncountable (Sigma π)
-- List.sublists'_nil
@[simp]
theorem sublists'_nil : sublists' (@nil α) = [[]] 
Arguments: {α : Type u}
Goal: [].sublists' = [[]]
-- List.sublists'_singleton
@[simp]
theorem sublists'_singleton (a : α) : sublists' [a] = [[], [a]] 
Arguments: {α : Type u} (a : α)
Goal: [a].sublists' = [[], [a]]
-- List.sublists'Aux_eq_array_foldl
theorem sublists'Aux_eq_array_foldl (a : α) : ∀ (r₁ r₂ : List (List α)),
    sublists'Aux a r₁ r₂ = ((r₁.toArray).foldl (init := r₂.toArray)
      (fun r l => r.push (a :: l))).toList 
Arguments: {α : Type u} (a : α) (r₁ r₂ : List (List α))
Goal: List.sublists'Aux a r₁ r₂ = (Array.foldl (fun r l => r.push (a :: l)) (List.toArray r₂) (List.toArray r₁) 0).toList
-- List.sublists'_eq_sublists'Aux
theorem sublists'_eq_sublists'Aux (l : List α) :
    sublists' l = l.foldr (fun a r => sublists'Aux a r r) [[]] 
Arguments: {α : Type u} (l : List α)
Goal: l.sublists' = List.foldr (fun a r => List.sublists'Aux a r r) [[]] l
-- List.sublists'Aux_eq_map
theorem sublists'Aux_eq_map (a : α) (r₁ : List (List α)) : ∀ (r₂ : List (List α)),
    sublists'Aux a r₁ r₂ = r₂ ++ map (cons a) r₁ 
Arguments: {α : Type u} (a : α) (r₁ r₂ : List (List α))
Goal: List.sublists'Aux a r₁ r₂ = r₂ ++ List.map (List.cons a) r₁
-- List.sublists'_cons
@[simp 900]
theorem sublists'_cons (a : α) (l : List α) :
    sublists' (a :: l) = sublists' l ++ map (cons a) (sublists' l) 
Arguments: {α : Type u} (a : α) (l : List α)
Goal: (a :: l).sublists' = l.sublists' ++ List.map (List.cons a) l.sublists'
-- List.mem_sublists'
@[simp]
theorem mem_sublists' {s t : List α} : s ∈ sublists' t ↔ s <+ t 
Arguments: {α : Type u} {s t : List α}
Goal: s ∈ t.sublists' ↔ s.Sublist t
-- List.length_sublists'
@[simp]
theorem length_sublists' : ∀ l : List α, length (sublists' l) = 2 ^ length l
  
Arguments: {α : Type u} (l : List α)
Goal: l.sublists'.length = 2 ^ l.length
-- List.sublists_nil
@[simp]
theorem sublists_nil : sublists (@nil α) = [[]] 
Arguments: {α : Type u}
Goal: [].sublists = [[]]
-- List.sublists_singleton
@[simp]
theorem sublists_singleton (a : α) : sublists [a] = [[], [a]] 
Arguments: {α : Type u} (a : α)
Goal: [a].sublists = [[], [a]]
-- List.sublistsAux_eq_array_foldl
theorem sublistsAux_eq_array_foldl :
    sublistsAux = fun (a : α) (r : List (List α)) =>
      (r.toArray.foldl (init := #[])
        fun r l => (r.push l).push (a :: l)).toList 
Arguments: {α : Type u}
Goal: List.sublistsAux = fun a r => (Array.foldl (fun r l => (r.push l).push (a :: l)) #[] (List.toArray r) 0).toList
-- List.sublistsAux_eq_bind
theorem sublistsAux_eq_bind :
    sublistsAux = fun (a : α) (r : List (List α)) => r.bind fun l => [l, a :: l] 
Arguments: {α : Type u}
Goal: List.sublistsAux = fun a r => r.bind fun l => [l, a :: l]
-- List.sublists_eq_sublistsFast
@[csimp] theorem sublists_eq_sublistsFast : @sublists = @sublistsFast 
Goal: @List.sublists = @List.sublistsFast
-- List.sublists_append
theorem sublists_append (l₁ l₂ : List α) :
    sublists (l₁ ++ l₂) = (sublists l₂) >>= (fun x => (sublists l₁).map (· ++ x)) 
Arguments: {α : Type u} (l₁ l₂ : List α)
Goal: (l₁ ++ l₂).sublists = do
  let x ← l₂.sublists
  List.map (fun x_1 => x_1 ++ x) l₁.sublists
-- List.sublists_cons
theorem sublists_cons (a : α) (l : List α) :
    sublists (a :: l) = sublists l >>= (fun x => [x, a :: x]) 
Arguments: {α : Type u} (a : α) (l : List α)
Goal: (a :: l).sublists = do
  let x ← l.sublists
  [x, a :: x]
-- List.sublists_concat
@[simp]
theorem sublists_concat (l : List α) (a : α) :
    sublists (l ++ [a]) = sublists l ++ map (fun x => x ++ [a]) (sublists l) 
Arguments: {α : Type u} (l : List α) (a : α)
Goal: (l ++ [a]).sublists = l.sublists ++ List.map (fun x => x ++ [a]) l.sublists
-- List.sublists_reverse
theorem sublists_reverse (l : List α) : sublists (reverse l) = map reverse (sublists' l) 
Arguments: {α : Type u} (l : List α)
Goal: l.reverse.sublists = List.map List.reverse l.sublists'
-- List.sublists_eq_sublists'
theorem sublists_eq_sublists' (l : List α) : sublists l = map reverse (sublists' (reverse l)) 
Arguments: {α : Type u} (l : List α)
Goal: l.sublists = List.map List.reverse l.reverse.sublists'
-- List.sublists'_reverse
theorem sublists'_reverse (l : List α) : sublists' (reverse l) = map reverse (sublists l) 
Arguments: {α : Type u} (l : List α)
Goal: l.reverse.sublists' = List.map List.reverse l.sublists
-- List.sublists'_eq_sublists
theorem sublists'_eq_sublists (l : List α) : sublists' l = map reverse (sublists (reverse l)) 
Arguments: {α : Type u} (l : List α)
Goal: l.sublists' = List.map List.reverse l.reverse.sublists
-- List.mem_sublists
@[simp]
theorem mem_sublists {s t : List α} : s ∈ sublists t ↔ s <+ t 
Arguments: {α : Type u} {s t : List α}
Goal: s ∈ t.sublists ↔ s.Sublist t
-- List.length_sublists
@[simp]
theorem length_sublists (l : List α) : length (sublists l) = 2 ^ length l 
Arguments: {α : Type u} (l : List α)
Goal: l.sublists.length = 2 ^ l.length
-- List.map_pure_sublist_sublists
theorem map_pure_sublist_sublists (l : List α) : map pure l <+ sublists l 
Arguments: {α : Type u} (l : List α)
Goal: (List.map pure l).Sublist l.sublists
-- List.map_ret_sublist_sublists
@[deprecated map_pure_sublist_sublists (since := "2024-03-24")]
theorem map_ret_sublist_sublists (l : List α) : map List.ret l <+ sublists l 
Arguments: {α : Type u} (l : List α)
Goal: (List.map List.ret l).Sublist l.sublists
-- List.sublistsLenAux_append
theorem sublistsLenAux_append :
    ∀ (n : ℕ) (l : List α) (f : List α → β) (g : β → γ) (r : List β) (s : List γ),
      sublistsLenAux n l (g ∘ f) (r.map g ++ s) = (sublistsLenAux n l f r).map g ++ s
  
Arguments: {α : Type u} {β : Type v} {γ : Type w} (n : ℕ) (l : List α) (f : List α → β) (g : β → γ) (r : List β) (s : List γ)
Goal: List.sublistsLenAux n l (g ∘ f) (List.map g r ++ s) = List.map g (List.sublistsLenAux n l f r) ++ s
-- List.sublistsLenAux_eq
theorem sublistsLenAux_eq (l : List α) (n) (f : List α → β) (r) :
    sublistsLenAux n l f r = (sublistsLen n l).map f ++ r 
Arguments: {α : Type u} {β : Type v} (l : List α) (n : ℕ) (f : List α → β) (r : List β)
Goal: List.sublistsLenAux n l f r = List.map f (List.sublistsLen n l) ++ r
-- List.sublistsLenAux_zero
theorem sublistsLenAux_zero (l : List α) (f : List α → β) (r) :
    sublistsLenAux 0 l f r = f [] :: r 
Arguments: {α : Type u} {β : Type v} (l : List α) (f : List α → β) (r : List β)
Goal: List.sublistsLenAux 0 l f r = f [] :: r