ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.zipWith_zipWith_left
theorem zipWith_zipWith_left (f : δ → γ → ε) (g : α → β → δ) :
    ∀ (la : List α) (lb : List β) (lc : List γ),
      zipWith f (zipWith g la lb) lc = zipWith3 (fun a b c => f (g a b) c) la lb lc
  
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} {δ : Type u_3} {ε : Type u_4} (f : δ → γ → ε) (g : α → β → δ) (la : List α) (lb : List β) (lc : List γ)
Goal: List.zipWith f (List.zipWith g la lb) lc = List.zipWith3 (fun a b c => f (g a b) c) la lb lc
-- List.zipWith_zipWith_right
theorem zipWith_zipWith_right (f : α → δ → ε) (g : β → γ → δ) :
    ∀ (la : List α) (lb : List β) (lc : List γ),
      zipWith f la (zipWith g lb lc) = zipWith3 (fun a b c => f a (g b c)) la lb lc
  
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} {δ : Type u_3} {ε : Type u_4} (f : α → δ → ε) (g : β → γ → δ) (la : List α) (lb : List β) (lc : List γ)
Goal: List.zipWith f la (List.zipWith g lb lc) = List.zipWith3 (fun a b c => f a (g b c)) la lb lc
-- List.zipWith3_same_left
@[simp]
theorem zipWith3_same_left (f : α → α → β → γ) :
    ∀ (la : List α) (lb : List β), zipWith3 f la la lb = zipWith (fun a b => f a a b) la lb
  
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → α → β → γ) (la : List α) (lb : List β)
Goal: List.zipWith3 f la la lb = List.zipWith (fun a b => f a a b) la lb
-- List.zipWith3_same_mid
@[simp]
theorem zipWith3_same_mid (f : α → β → α → γ) :
    ∀ (la : List α) (lb : List β), zipWith3 f la lb la = zipWith (fun a b => f a b a) la lb
  
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → α → γ) (la : List α) (lb : List β)
Goal: List.zipWith3 f la lb la = List.zipWith (fun a b => f a b a) la lb
-- List.zipWith3_same_right
@[simp]
theorem zipWith3_same_right (f : α → β → β → γ) :
    ∀ (la : List α) (lb : List β), zipWith3 f la lb lb = zipWith (fun a b => f a b b) la lb
  
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → β → γ) (la : List α) (lb : List β)
Goal: List.zipWith3 f la lb lb = List.zipWith (fun a b => f a b b) la lb
-- List.length_revzip
@[simp]
theorem length_revzip (l : List α) : length (revzip l) = length l 
Arguments: {α : Type u} (l : List α)
Goal: l.revzip.length = l.length
-- List.unzip_revzip
@[simp]
theorem unzip_revzip (l : List α) : (revzip l).unzip = (l, l.reverse) 
Arguments: {α : Type u} (l : List α)
Goal: l.revzip.unzip = (l, l.reverse)
-- List.revzip_map_fst
@[simp]
theorem revzip_map_fst (l : List α) : (revzip l).map Prod.fst = l 
Arguments: {α : Type u} (l : List α)
Goal: List.map Prod.fst l.revzip = l
-- List.revzip_map_snd
@[simp]
theorem revzip_map_snd (l : List α) : (revzip l).map Prod.snd = l.reverse 
Arguments: {α : Type u} (l : List α)
Goal: List.map Prod.snd l.revzip = l.reverse
-- List.reverse_revzip
theorem reverse_revzip (l : List α) : reverse l.revzip = revzip l.reverse 
Arguments: {α : Type u} (l : List α)
Goal: l.revzip.reverse = l.reverse.revzip
-- List.revzip_swap
theorem revzip_swap (l : List α) : (revzip l).map Prod.swap = revzip l.reverse 
Arguments: {α : Type u} (l : List α)
Goal: List.map Prod.swap l.revzip = l.reverse.revzip
-- List.getElem?_zipWith'
theorem getElem?_zipWith' (f : α → β → γ) (l₁ : List α) (l₂ : List β) (i : ℕ) :
    (zipWith f l₁ l₂)[i]? = (l₁[i]?.map f).bind fun g => l₂[i]?.map g 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (l₁ : List α) (l₂ : List β) (i : ℕ)
Goal: (List.zipWith f l₁ l₂)[i]? = (Option.map f l₁[i]?).bind fun g => Option.map g l₂[i]?
-- List.get?_zipWith'
theorem get?_zipWith' (f : α → β → γ) (l₁ : List α) (l₂ : List β) (i : ℕ) :
    (zipWith f l₁ l₂).get? i = ((l₁.get? i).map f).bind fun g => (l₂.get? i).map g 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (l₁ : List α) (l₂ : List β) (i : ℕ)
Goal: (List.zipWith f l₁ l₂).get? i = (Option.map f (l₁.get? i)).bind fun g => Option.map g (l₂.get? i)
-- List.getElem?_zipWith_eq_some
theorem getElem?_zipWith_eq_some (f : α → β → γ) (l₁ : List α) (l₂ : List β) (z : γ) (i : ℕ) :
    (zipWith f l₁ l₂)[i]? = some z ↔
      ∃ x y, l₁[i]? = some x ∧ l₂[i]? = some y ∧ f x y = z 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (l₁ : List α) (l₂ : List β) (z : γ) (i : ℕ)
Goal: (List.zipWith f l₁ l₂)[i]? = some z ↔ ∃ x y, l₁[i]? = some x ∧ l₂[i]? = some y ∧ f x y = z
-- List.get?_zipWith_eq_some
theorem get?_zipWith_eq_some (f : α → β → γ) (l₁ : List α) (l₂ : List β) (z : γ) (i : ℕ) :
    (zipWith f l₁ l₂).get? i = some z ↔
      ∃ x y, l₁.get? i = some x ∧ l₂.get? i = some y ∧ f x y = z 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (l₁ : List α) (l₂ : List β) (z : γ) (i : ℕ)
Goal: (List.zipWith f l₁ l₂).get? i = some z ↔ ∃ x y, l₁.get? i = some x ∧ l₂.get? i = some y ∧ f x y = z
-- List.getElem?_zip_eq_some
theorem getElem?_zip_eq_some (l₁ : List α) (l₂ : List β) (z : α × β) (i : ℕ) :
    (zip l₁ l₂)[i]? = some z ↔ l₁[i]? = some z.1 ∧ l₂[i]? = some z.2 
Arguments: {α : Type u} {β : Type u_1} (l₁ : List α) (l₂ : List β) (z : α × β) (i : ℕ)
Goal: (l₁.zip l₂)[i]? = some z ↔ l₁[i]? = some z.1 ∧ l₂[i]? = some z.2
-- List.get?_zip_eq_some
theorem get?_zip_eq_some (l₁ : List α) (l₂ : List β) (z : α × β) (i : ℕ) :
    (zip l₁ l₂).get? i = some z ↔ l₁.get? i = some z.1 ∧ l₂.get? i = some z.2 
Arguments: {α : Type u} {β : Type u_1} (l₁ : List α) (l₂ : List β) (z : α × β) (i : ℕ)
Goal: (l₁.zip l₂).get? i = some z ↔ l₁.get? i = some z.1 ∧ l₂.get? i = some z.2
-- List.getElem_zipWith
@[simp]
theorem getElem_zipWith {f : α → β → γ} {l : List α} {l' : List β}
    {i : Nat} {h : i < (zipWith f l l').length} :
    (zipWith f l l')[i] =
      f (l[i]'(lt_length_left_of_zipWith h))
        (l'[i]'(lt_length_right_of_zipWith h)) 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} {f : α → β → γ} {l : List α} {l' : List β} {i : ℕ} {h : i < (List.zipWith f l l').length}
Goal: (List.zipWith f l l')[i] = f l[i] l'[i]
-- List.get_zipWith
@[deprecated getElem_zipWith (since := "2024-06-12")]
theorem get_zipWith {f : α → β → γ} {l : List α} {l' : List β} {i : Fin (zipWith f l l').length} :
    (zipWith f l l').get i =
      f (l.get ⟨i, lt_length_left_of_zipWith i.isLt⟩)
        (l'.get ⟨i, lt_length_right_of_zipWith i.isLt⟩) 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} {f : α → β → γ} {l : List α} {l' : List β} {i : Fin (List.zipWith f l l').length}
Goal: (List.zipWith f l l').get i = f (l.get ⟨↑i, ⋯⟩) (l'.get ⟨↑i, ⋯⟩)
-- List.nthLe_zipWith
@[simp, deprecated get_zipWith (since := "2024-05-09")]
theorem nthLe_zipWith {f : α → β → γ} {l : List α} {l' : List β} {i : ℕ}
    {h : i < (zipWith f l l').length} :
    (zipWith f l l').nthLe i h =
      f (l.nthLe i (lt_length_left_of_zipWith h)) (l'.nthLe i (lt_length_right_of_zipWith h)) 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} {f : α → β → γ} {l : List α} {l' : List β} {i : ℕ} {h : i < (List.zipWith f l l').length}
Goal: (List.zipWith f l l').nthLe i h = f (l.nthLe i ⋯) (l'.nthLe i ⋯)
-- List.getElem_zip
@[simp]
theorem getElem_zip {l : List α} {l' : List β} {i : Nat} {h : i < (zip l l').length} :
    (zip l l')[i] =
      (l[i]'(lt_length_left_of_zip h), l'[i]'(lt_length_right_of_zip h)) 
Arguments: {α : Type u} {β : Type u_1} {l : List α} {l' : List β} {i : ℕ} {h : i < (l.zip l').length}
Goal: (l.zip l')[i] = (l[i], l'[i])
-- List.get_zip
@[deprecated getElem_zip (since := "2024-06-12")]
theorem get_zip {l : List α} {l' : List β} {i : Fin (zip l l').length} :
    (zip l l').get i =
      (l.get ⟨i, lt_length_left_of_zip i.isLt⟩, l'.get ⟨i, lt_length_right_of_zip i.isLt⟩) 
Arguments: {α : Type u} {β : Type u_1} {l : List α} {l' : List β} {i : Fin (l.zip l').length}
Goal: (l.zip l').get i = (l.get ⟨↑i, ⋯⟩, l'.get ⟨↑i, ⋯⟩)
-- List.nthLe_zip
@[simp, deprecated get_zip (since := "2024-05-09")]
theorem nthLe_zip {l : List α} {l' : List β} {i : ℕ} {h : i < (zip l l').length} :
    (zip l l').nthLe i h =
      (l.nthLe i (lt_length_left_of_zip h), l'.nthLe i (lt_length_right_of_zip h)) 
Arguments: {α : Type u} {β : Type u_1} {l : List α} {l' : List β} {i : ℕ} {h : i < (l.zip l').length}
Goal: (l.zip l').nthLe i h = (l.nthLe i ⋯, l'.nthLe i ⋯)
-- List.mem_zip_inits_tails
theorem mem_zip_inits_tails {l : List α} {init tail : List α} :
    (init, tail) ∈ zip l.inits l.tails ↔ init ++ tail = l 
Arguments: {α : Type u} {l init tail : List α}
Goal: (init, tail) ∈ l.inits.zip l.tails ↔ init ++ tail = l
-- List.map_uncurry_zip_eq_zipWith
theorem map_uncurry_zip_eq_zipWith (f : α → β → γ) (l : List α) (l' : List β) :
    map (Function.uncurry f) (l.zip l') = zipWith f l l' 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (l : List α) (l' : List β)
Goal: List.map (Function.uncurry f) (l.zip l') = List.zipWith f l l'
-- List.zipWith_distrib_reverse
theorem zipWith_distrib_reverse (h : l.length = l'.length) :
    (zipWith f l l').reverse = zipWith f l.reverse l'.reverse 
Arguments: {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (l : List α) (l' : List β) (h : l.length = l'.length)
Goal: (List.zipWith f l l').reverse = List.zipWith f l.reverse l'.reverse
-- List.Forall₂.imp
theorem Forall₂.imp (H : ∀ a b, R a b → S a b) {l₁ l₂} (h : Forall₂ R l₁ l₂) : Forall₂ S l₁ l₂ 
Arguments: {α : Type u_1} {β : Type u_2} {R S : α → β → Prop} (H : ∀ (a : α) (b : β), R a b → S a b) {l₁ : List α} {l₂ : List β} (h : List.Forall₂ R l₁ l₂)
Goal: List.Forall₂ S l₁ l₂
-- List.Forall₂.mp
theorem Forall₂.mp {Q : α → β → Prop} (h : ∀ a b, Q a b → R a b → S a b) :
    ∀ {l₁ l₂}, Forall₂ Q l₁ l₂ → Forall₂ R l₁ l₂ → Forall₂ S l₁ l₂
  
Arguments: {α : Type u_1} {β : Type u_2} {R S Q : α → β → Prop} (h : ∀ (a : α) (b : β), Q a b → R a b → S a b) {l₁ : List α} {l₂ : List β}
Goal: List.Forall₂ Q l₁ l₂ → List.Forall₂ R l₁ l₂ → List.Forall₂ S l₁ l₂
-- List.Forall₂.flip
theorem Forall₂.flip : ∀ {a b}, Forall₂ (flip R) b a → Forall₂ R a b
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {a : List α} {b : List β}
Goal: List.Forall₂ (flip R) b a → List.Forall₂ R a b
-- List.forall₂_same
@[simp]
theorem forall₂_same : ∀ {l : List α}, Forall₂ Rₐ l l ↔ ∀ x ∈ l, Rₐ x x
  
Arguments: {α : Type u_1} {Rₐ : α → α → Prop} {l : List α}
Goal: List.Forall₂ Rₐ l l ↔ ∀ (x : α), x ∈ l → Rₐ x x
-- List.forall₂_refl
theorem forall₂_refl [IsRefl α Rₐ] (l : List α) : Forall₂ Rₐ l l 
Arguments: {α : Type u_1} {Rₐ : α → α → Prop} [IsRefl α Rₐ] (l : List α)
Goal: List.Forall₂ Rₐ l l
-- List.forall₂_eq_eq_eq
@[simp]
theorem forall₂_eq_eq_eq : Forall₂ ((· = ·) : α → α → Prop) = Eq 
Arguments: {α : Type u_1}
Goal: (List.Forall₂ fun x x_1 => x = x_1) = Eq
-- List.forall₂_nil_left_iff
@[simp]
theorem forall₂_nil_left_iff {l} : Forall₂ R nil l ↔ l = nil 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l : List β}
Goal: List.Forall₂ R [] l ↔ l = []
-- List.forall₂_nil_right_iff
@[simp]
theorem forall₂_nil_right_iff {l} : Forall₂ R l nil ↔ l = nil 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l : List α}
Goal: List.Forall₂ R l [] ↔ l = []
-- List.forall₂_cons_left_iff
theorem forall₂_cons_left_iff {a l u} :
    Forall₂ R (a :: l) u ↔ ∃ b u', R a b ∧ Forall₂ R l u' ∧ u = b :: u' 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {a : α} {l : List α} {u : List β}
Goal: List.Forall₂ R (a :: l) u ↔ ∃ b u', R a b ∧ List.Forall₂ R l u' ∧ u = b :: u'
-- List.forall₂_cons_right_iff
theorem forall₂_cons_right_iff {b l u} :
    Forall₂ R u (b :: l) ↔ ∃ a u', R a b ∧ Forall₂ R u' l ∧ u = a :: u' 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {b : β} {l : List β} {u : List α}
Goal: List.Forall₂ R u (b :: l) ↔ ∃ a u', R a b ∧ List.Forall₂ R u' l ∧ u = a :: u'
-- List.forall₂_and_left
theorem forall₂_and_left {p : α → Prop} :
    ∀ l u, Forall₂ (fun a b => p a ∧ R a b) l u ↔ (∀ a ∈ l, p a) ∧ Forall₂ R l u
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {p : α → Prop} (l : List α) (u : List β)
Goal: List.Forall₂ (fun a b => p a ∧ R a b) l u ↔ (∀ (a : α), a ∈ l → p a) ∧ List.Forall₂ R l u
-- List.forall₂_map_left_iff
@[simp]
theorem forall₂_map_left_iff {f : γ → α} :
    ∀ {l u}, Forall₂ R (map f l) u ↔ Forall₂ (fun c b => R (f c) b) l u
  
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {R : α → β → Prop} {f : γ → α} {l : List γ} {u : List β}
Goal: List.Forall₂ R (List.map f l) u ↔ List.Forall₂ (fun c b => R (f c) b) l u
-- List.forall₂_map_right_iff
@[simp]
theorem forall₂_map_right_iff {f : γ → β} :
    ∀ {l u}, Forall₂ R l (map f u) ↔ Forall₂ (fun a c => R a (f c)) l u
  
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {R : α → β → Prop} {f : γ → β} {l : List α} {u : List γ}
Goal: List.Forall₂ R l (List.map f u) ↔ List.Forall₂ (fun a c => R a (f c)) l u
-- List.left_unique_forall₂'
theorem left_unique_forall₂' (hr : LeftUnique R) : ∀ {a b c}, Forall₂ R a c → Forall₂ R b c → a = b
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} (hr : Relator.LeftUnique R) {a b : List α} {c : List β}
Goal: List.Forall₂ R a c → List.Forall₂ R b c → a = b
-- Relator.LeftUnique.forall₂
theorem _root_.Relator.LeftUnique.forall₂ (hr : LeftUnique R) : LeftUnique (Forall₂ R) 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} (hr : Relator.LeftUnique R)
Goal: Relator.LeftUnique (List.Forall₂ R)
-- List.right_unique_forall₂'
theorem right_unique_forall₂' (hr : RightUnique R) :
    ∀ {a b c}, Forall₂ R a b → Forall₂ R a c → b = c
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} (hr : Relator.RightUnique R) {a : List α} {b c : List β}
Goal: List.Forall₂ R a b → List.Forall₂ R a c → b = c
-- Relator.RightUnique.forall₂
theorem _root_.Relator.RightUnique.forall₂ (hr : RightUnique R) : RightUnique (Forall₂ R) 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} (hr : Relator.RightUnique R)
Goal: Relator.RightUnique (List.Forall₂ R)
-- Relator.BiUnique.forall₂
theorem _root_.Relator.BiUnique.forall₂ (hr : BiUnique R) : BiUnique (Forall₂ R) 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} (hr : Relator.BiUnique R)
Goal: Relator.BiUnique (List.Forall₂ R)
-- List.Forall₂.length_eq
theorem Forall₂.length_eq : ∀ {l₁ l₂}, Forall₂ R l₁ l₂ → length l₁ = length l₂
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β}
Goal: List.Forall₂ R l₁ l₂ → l₁.length = l₂.length
-- List.Forall₂.get
theorem Forall₂.get :
    ∀ {x : List α} {y : List β}, Forall₂ R x y →
      ∀ ⦃i : ℕ⦄ (hx : i < x.length) (hy : i < y.length), R (x.get ⟨i, hx⟩) (y.get ⟨i, hy⟩)
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {x : List α} {y : List β}
Goal: List.Forall₂ R x y → ∀ ⦃i : ℕ⦄ (hx : i < x.length) (hy : i < y.length), R (x.get ⟨i, hx⟩) (y.get ⟨i, hy⟩)
-- List.Forall₂.nthLe
@[deprecated (since := "2024-05-05")] theorem Forall₂.nthLe {x y} (h : Forall₂ R x y) ⦃i : ℕ⦄
    (hx : i < x.length) (hy : i < y.length) : R (x.nthLe i hx) (y.nthLe i hy) 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {x : List α} {y : List β} (h : List.Forall₂ R x y) ⦃i : ℕ⦄ (hx : i < x.length) (hy : i < y.length)
Goal: R (x.nthLe i hx) (y.nthLe i hy)
-- List.forall₂_of_length_eq_of_get
theorem forall₂_of_length_eq_of_get :
    ∀ {x : List α} {y : List β},
      x.length = y.length → (∀ i h₁ h₂, R (x.get ⟨i, h₁⟩) (y.get ⟨i, h₂⟩)) → Forall₂ R x y
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {x : List α} {y : List β}
Goal: x.length = y.length →
  (∀ (i : ℕ) (h₁ : i < x.length) (h₂ : i < y.length), R (x.get ⟨i, h₁⟩) (y.get ⟨i, h₂⟩)) → List.Forall₂ R x y
-- List.forall₂_of_length_eq_of_nthLe
@[deprecated (since := "2024-05-05")] theorem forall₂_of_length_eq_of_nthLe {x y}
    (H : x.length = y.length) (H' : ∀ i h₁ h₂, R (x.nthLe i h₁) (y.nthLe i h₂)) :
    Forall₂ R x y 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {x : List α} {y : List β} (H : x.length = y.length) (H' : ∀ (i : ℕ) (h₁ : i < x.length) (h₂ : i < y.length), R (x.nthLe i h₁) (y.nthLe i h₂))
Goal: List.Forall₂ R x y
-- List.forall₂_iff_get
theorem forall₂_iff_get {l₁ : List α} {l₂ : List β} :
    Forall₂ R l₁ l₂ ↔ l₁.length = l₂.length ∧ ∀ i h₁ h₂, R (l₁.get ⟨i, h₁⟩) (l₂.get ⟨i, h₂⟩) 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β}
Goal: List.Forall₂ R l₁ l₂ ↔
  l₁.length = l₂.length ∧ ∀ (i : ℕ) (h₁ : i < l₁.length) (h₂ : i < l₂.length), R (l₁.get ⟨i, h₁⟩) (l₂.get ⟨i, h₂⟩)
-- List.forall₂_iff_nthLe
@[deprecated (since := "2024-05-05")] theorem forall₂_iff_nthLe {l₁ : List α} {l₂ : List β} :
    Forall₂ R l₁ l₂ ↔ l₁.length = l₂.length ∧ ∀ i h₁ h₂, R (l₁.nthLe i h₁) (l₂.nthLe i h₂) 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β}
Goal: List.Forall₂ R l₁ l₂ ↔
  l₁.length = l₂.length ∧ ∀ (i : ℕ) (h₁ : i < l₁.length) (h₂ : i < l₂.length), R (l₁.nthLe i h₁) (l₂.nthLe i h₂)
-- List.forall₂_zip
theorem forall₂_zip : ∀ {l₁ l₂}, Forall₂ R l₁ l₂ → ∀ {a b}, (a, b) ∈ zip l₁ l₂ → R a b
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β}
Goal: List.Forall₂ R l₁ l₂ → ∀ {a : α} {b : β}, (a, b) ∈ l₁.zip l₂ → R a b
-- List.forall₂_iff_zip
theorem forall₂_iff_zip {l₁ l₂} :
    Forall₂ R l₁ l₂ ↔ length l₁ = length l₂ ∧ ∀ {a b}, (a, b) ∈ zip l₁ l₂ → R a b 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β}
Goal: List.Forall₂ R l₁ l₂ ↔ l₁.length = l₂.length ∧ ∀ {a : α} {b : β}, (a, b) ∈ l₁.zip l₂ → R a b
-- List.forall₂_take
theorem forall₂_take : ∀ (n) {l₁ l₂}, Forall₂ R l₁ l₂ → Forall₂ R (take n l₁) (take n l₂)
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} (n : ℕ) {l₁ : List α} {l₂ : List β}
Goal: List.Forall₂ R l₁ l₂ → List.Forall₂ R (List.take n l₁) (List.take n l₂)
-- List.forall₂_drop
theorem forall₂_drop : ∀ (n) {l₁ l₂}, Forall₂ R l₁ l₂ → Forall₂ R (drop n l₁) (drop n l₂)
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} (n : ℕ) {l₁ : List α} {l₂ : List β}
Goal: List.Forall₂ R l₁ l₂ → List.Forall₂ R (List.drop n l₁) (List.drop n l₂)
-- List.forall₂_take_append
theorem forall₂_take_append (l : List α) (l₁ : List β) (l₂ : List β) (h : Forall₂ R l (l₁ ++ l₂)) :
    Forall₂ R (List.take (length l₁) l) l₁ 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} (l : List α) (l₁ l₂ : List β) (h : List.Forall₂ R l (l₁ ++ l₂))
Goal: List.Forall₂ R (List.take l₁.length l) l₁
-- List.forall₂_drop_append
theorem forall₂_drop_append (l : List α) (l₁ : List β) (l₂ : List β) (h : Forall₂ R l (l₁ ++ l₂)) :
    Forall₂ R (List.drop (length l₁) l) l₂ 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} (l : List α) (l₁ l₂ : List β) (h : List.Forall₂ R l (l₁ ++ l₂))
Goal: List.Forall₂ R (List.drop l₁.length l) l₂
-- List.rel_mem
theorem rel_mem (hr : BiUnique R) : (R ⇒ Forall₂ R ⇒ Iff) (· ∈ ·) (· ∈ ·)
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} (hr : Relator.BiUnique R)
Goal: (R ⇒ List.Forall₂ R ⇒ Iff) (fun x x_1 => x ∈ x_1) fun x x_1 => x ∈ x_1
-- List.rel_map
theorem rel_map : ((R ⇒ P) ⇒ Forall₂ R ⇒ Forall₂ P) map map
  
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {R : α → β → Prop} {P : γ → δ → Prop}
Goal: ((R ⇒ P) ⇒ List.Forall₂ R ⇒ List.Forall₂ P) List.map List.map
-- List.rel_append
theorem rel_append : (Forall₂ R ⇒ Forall₂ R ⇒ Forall₂ R) (· ++ ·) (· ++ ·)
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop}
Goal: (List.Forall₂ R ⇒ List.Forall₂ R ⇒ List.Forall₂ R) (fun x x_1 => x ++ x_1) fun x x_1 => x ++ x_1
-- List.rel_reverse
theorem rel_reverse : (Forall₂ R ⇒ Forall₂ R) reverse reverse
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop}
Goal: (List.Forall₂ R ⇒ List.Forall₂ R) List.reverse List.reverse
-- List.forall₂_reverse_iff
@[simp]
theorem forall₂_reverse_iff {l₁ l₂} : Forall₂ R (reverse l₁) (reverse l₂) ↔ Forall₂ R l₁ l₂ 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β}
Goal: List.Forall₂ R l₁.reverse l₂.reverse ↔ List.Forall₂ R l₁ l₂
-- List.rel_join
theorem rel_join : (Forall₂ (Forall₂ R) ⇒ Forall₂ R) join join
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop}
Goal: (List.Forall₂ (List.Forall₂ R) ⇒ List.Forall₂ R) List.join List.join
-- List.rel_bind
theorem rel_bind : (Forall₂ R ⇒ (R ⇒ Forall₂ P) ⇒ Forall₂ P) List.bind List.bind 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {R : α → β → Prop} {P : γ → δ → Prop}
Goal: (List.Forall₂ R ⇒ (R ⇒ List.Forall₂ P) ⇒ List.Forall₂ P) List.bind List.bind
-- List.rel_foldl
theorem rel_foldl : ((P ⇒ R ⇒ P) ⇒ P ⇒ Forall₂ R ⇒ P) foldl foldl
  
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {R : α → β → Prop} {P : γ → δ → Prop}
Goal: ((P ⇒ R ⇒ P) ⇒ P ⇒ List.Forall₂ R ⇒ P) List.foldl List.foldl
-- List.rel_foldr
theorem rel_foldr : ((R ⇒ P ⇒ P) ⇒ P ⇒ Forall₂ R ⇒ P) foldr foldr
  
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {R : α → β → Prop} {P : γ → δ → Prop}
Goal: ((R ⇒ P ⇒ P) ⇒ P ⇒ List.Forall₂ R ⇒ P) List.foldr List.foldr
-- List.rel_filter
theorem rel_filter {p : α → Bool} {q : β → Bool}
    (hpq : (R ⇒ (· ↔ ·)) (fun x => p x) (fun x => q x)) :
    (Forall₂ R ⇒ Forall₂ R) (filter p) (filter q)
  
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {p : α → Bool} {q : β → Bool} (hpq : (R ⇒ fun x x_1 => x ↔ x_1) (fun x => p x = true) fun x => q x = true)
Goal: (List.Forall₂ R ⇒ List.Forall₂ R) (List.filter p) (List.filter q)
-- List.rel_filterMap
theorem rel_filterMap : ((R ⇒ Option.Rel P) ⇒ Forall₂ R ⇒ Forall₂ P) filterMap filterMap
  
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {R : α → β → Prop} {P : γ → δ → Prop}
Goal: ((R ⇒ Option.Rel P) ⇒ List.Forall₂ R ⇒ List.Forall₂ P) List.filterMap List.filterMap
-- List.sublistForall₂_iff
theorem sublistForall₂_iff {l₁ : List α} {l₂ : List β} :
    SublistForall₂ R l₁ l₂ ↔ ∃ l, Forall₂ R l₁ l ∧ l <+ l₂ 
Arguments: {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {l₁ : List α} {l₂ : List β}
Goal: List.SublistForall₂ R l₁ l₂ ↔ ∃ l, List.Forall₂ R l₁ l ∧ l.Sublist l₂
-- List.Sublist.sublistForall₂
theorem Sublist.sublistForall₂ {l₁ l₂ : List α} (h : l₁ <+ l₂) [IsRefl α Rₐ] :
    SublistForall₂ Rₐ l₁ l₂ 
Arguments: {α : Type u_1} {Rₐ : α → α → Prop} {l₁ l₂ : List α} (h : l₁.Sublist l₂) [IsRefl α Rₐ]
Goal: List.SublistForall₂ Rₐ l₁ l₂
-- List.tail_sublistForall₂_self
theorem tail_sublistForall₂_self [IsRefl α Rₐ] (l : List α) : SublistForall₂ Rₐ l.tail l 
Arguments: {α : Type u_1} {Rₐ : α → α → Prop} [IsRefl α Rₐ] (l : List α)
Goal: List.SublistForall₂ Rₐ l.tail l
-- List.permutationsAux2_fst
theorem permutationsAux2_fst (t : α) (ts : List α) (r : List β) :
    ∀ (ys : List α) (f : List α → β), (permutationsAux2 t ts r ys f).1 = ys ++ ts
  
Arguments: {α : Type u_1} {β : Type u_2} (t : α) (ts : List α) (r : List β) (ys : List α) (f : List α → β)
Goal: (List.permutationsAux2 t ts r ys f).1 = ys ++ ts
-- List.permutationsAux2_snd_nil
@[simp]
theorem permutationsAux2_snd_nil (t : α) (ts : List α) (r : List β) (f : List α → β) :
    (permutationsAux2 t ts r [] f).2 = r 
Arguments: {α : Type u_1} {β : Type u_2} (t : α) (ts : List α) (r : List β) (f : List α → β)
Goal: (List.permutationsAux2 t ts r [] f).2 = r
-- List.permutationsAux2_snd_cons
@[simp]
theorem permutationsAux2_snd_cons (t : α) (ts : List α) (r : List β) (y : α) (ys : List α)
    (f : List α → β) :
    (permutationsAux2 t ts r (y :: ys) f).2 =
      f (t :: y :: ys ++ ts) :: (permutationsAux2 t ts r ys fun x : List α => f (y :: x)).2 
Arguments: {α : Type u_1} {β : Type u_2} (t : α) (ts : List α) (r : List β) (y : α) (ys : List α) (f : List α → β)
Goal: (List.permutationsAux2 t ts r (y :: ys) f).2 =
  f (t :: y :: ys ++ ts) :: (List.permutationsAux2 t ts r ys fun x => f (y :: x)).2
-- List.permutationsAux2_append
theorem permutationsAux2_append (t : α) (ts : List α) (r : List β) (ys : List α) (f : List α → β) :
    (permutationsAux2 t ts nil ys f).2 ++ r = (permutationsAux2 t ts r ys f).2 
Arguments: {α : Type u_1} {β : Type u_2} (t : α) (ts : List α) (r : List β) (ys : List α) (f : List α → β)
Goal: (List.permutationsAux2 t ts [] ys f).2 ++ r = (List.permutationsAux2 t ts r ys f).2