ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Int.natAbs_eq_of_dvd_dvd
lemma natAbs_eq_of_dvd_dvd (hmn : m ∣ n) (hnm : n ∣ m) : natAbs m = natAbs n 
Arguments: {m n : ℤ} (hmn : m ∣ n) (hnm : n ∣ m)
Goal: m.natAbs = n.natAbs
-- Int.ediv_dvd_of_dvd
lemma ediv_dvd_of_dvd (hmn : m ∣ n) : n / m ∣ n 
Arguments: {m n : ℤ} (hmn : m ∣ n)
Goal: n / m ∣ n
-- Int.le_iff_pos_of_dvd
lemma le_iff_pos_of_dvd (ha : 0 < a) (hab : a ∣ b) : a ≤ b ↔ 0 < b 
Arguments: {a b : ℤ} (ha : 0 < a) (hab : a ∣ b)
Goal: a ≤ b ↔ 0 < b
-- Int.le_add_iff_lt_of_dvd_sub
lemma le_add_iff_lt_of_dvd_sub (ha : 0 < a) (hab : a ∣ c - b) : a + b ≤ c ↔ b < c 
Arguments: {a b c : ℤ} (ha : 0 < a) (hab : a ∣ c - b)
Goal: a + b ≤ c ↔ b < c
-- Int.sign_natCast_of_ne_zero
lemma sign_natCast_of_ne_zero {n : ℕ} (hn : n ≠ 0) : Int.sign n = 1 
Arguments: {n : ℕ} (hn : n ≠ 0)
Goal: (↑n).sign = 1
-- Int.sign_add_eq_of_sign_eq
lemma sign_add_eq_of_sign_eq : ∀ {m n : ℤ}, m.sign = n.sign → (m + n).sign = n.sign 
Arguments: {m n : ℤ}
Goal: m.sign = n.sign → (m + n).sign = n.sign
-- Int.toNat_natCast
@[simp] lemma toNat_natCast (n : ℕ) : toNat ↑n = n 
Arguments: (n : ℕ)
Goal: (↑n).toNat = n
-- Int.toNat_natCast_add_one
@[simp] lemma toNat_natCast_add_one {n : ℕ} : ((n : ℤ) + 1).toNat = n + 1 
Arguments: {n : ℕ}
Goal: (↑n + 1).toNat = n + 1
-- Int.toNat_le
@[simp] lemma toNat_le {n : ℕ} : toNat m ≤ n ↔ m ≤ n 
Arguments: {m : ℤ} {n : ℕ}
Goal: m.toNat ≤ n ↔ m ≤ ↑n
-- Int.lt_toNat
@[simp]
lemma lt_toNat {m : ℕ} : m < toNat n ↔ (m : ℤ) < n 
Arguments: {n : ℤ} {m : ℕ}
Goal: m < n.toNat ↔ ↑m < n
-- Int.toNat_le_toNat
lemma toNat_le_toNat {a b : ℤ} (h : a ≤ b) : toNat a ≤ toNat b 
Arguments: {a b : ℤ} (h : a ≤ b)
Goal: a.toNat ≤ b.toNat
-- Int.toNat_lt_toNat
lemma toNat_lt_toNat {a b : ℤ} (hb : 0 < b) : toNat a < toNat b ↔ a < b 
Arguments: {a b : ℤ} (hb : 0 < b)
Goal: a.toNat < b.toNat ↔ a < b
-- Int.lt_of_toNat_lt
lemma lt_of_toNat_lt {a b : ℤ} (h : toNat a < toNat b) : a < b 
Arguments: {a b : ℤ} (h : a.toNat < b.toNat)
Goal: a < b
-- Int.toNat_pred_coe_of_pos
@[simp] lemma toNat_pred_coe_of_pos {i : ℤ} (h : 0 < i) : ((i.toNat - 1 : ℕ) : ℤ) = i - 1 
Arguments: {i : ℤ} (h : 0 < i)
Goal: ↑(i.toNat - 1) = i - 1
-- Int.toNat_eq_zero
@[simp] lemma toNat_eq_zero : ∀ {n : ℤ}, n.toNat = 0 ↔ n ≤ 0
  
Arguments: {n : ℤ}
Goal: n.toNat = 0 ↔ n ≤ 0
-- Int.toNat_sub_of_le
@[simp]
theorem toNat_sub_of_le {a b : ℤ} (h : b ≤ a) : (toNat (a - b) : ℤ) = a - b 
Arguments: {a b : ℤ} (h : b ≤ a)
Goal: ↑(a - b).toNat = a - b
-- Int.toNat_lt'
lemma toNat_lt' {n : ℕ} (hn : n ≠ 0) : m.toNat < n ↔ m < n 
Arguments: {m : ℤ} {n : ℕ} (hn : n ≠ 0)
Goal: m.toNat < n ↔ m < ↑n
-- Int.natMod_lt
lemma natMod_lt {n : ℕ} (hn : n ≠ 0) : m.natMod n < n 
Arguments: {m : ℤ} {n : ℕ} (hn : n ≠ 0)
Goal: m.natMod ↑n < n
-- Int.pow_eq
@[simp] lemma pow_eq (m : ℤ) (n : ℕ) : m.pow n = m ^ n 
Arguments: (m : ℤ) (n : ℕ)
Goal: m.pow n = m ^ n
-- List.iterateTR_loop_eq
theorem iterateTR_loop_eq (f : α → α) (a : α) (n : ℕ) (l : List α) :
    iterateTR.loop f a n l = reverse l ++ iterate f a n 
Arguments: {α : Type u_1} (f : α → α) (a : α) (n : ℕ) (l : List α)
Goal: List.iterateTR.loop f a n l = l.reverse ++ List.iterate f a n
-- List.iterate_eq_iterateTR
@[csimp]
theorem iterate_eq_iterateTR : @iterate = @iterateTR 
Goal: @List.iterate = @List.iterateTR
-- List.Chain.iff
theorem Chain.iff {S : α → α → Prop} (H : ∀ a b, R a b ↔ S a b) {a : α} {l : List α} :
    Chain R a l ↔ Chain S a l 
Arguments: {α : Type u} {R S : α → α → Prop} (H : ∀ (a b : α), R a b ↔ S a b) {a : α} {l : List α}
Goal: List.Chain R a l ↔ List.Chain S a l
-- List.Chain.iff_mem
theorem Chain.iff_mem {a : α} {l : List α} :
    Chain R a l ↔ Chain (fun x y => x ∈ a :: l ∧ y ∈ l ∧ R x y) a l 
Arguments: {α : Type u} {R : α → α → Prop} {a : α} {l : List α}
Goal: List.Chain R a l ↔ List.Chain (fun x y => x ∈ a :: l ∧ y ∈ l ∧ R x y) a l
-- List.chain_singleton
theorem chain_singleton {a b : α} : Chain R a [b] ↔ R a b 
Arguments: {α : Type u} {R : α → α → Prop} {a b : α}
Goal: List.Chain R a [b] ↔ R a b
-- List.chain_split
theorem chain_split {a b : α} {l₁ l₂ : List α} :
    Chain R a (l₁ ++ b :: l₂) ↔ Chain R a (l₁ ++ [b]) ∧ Chain R b l₂ 
Arguments: {α : Type u} {R : α → α → Prop} {a b : α} {l₁ l₂ : List α}
Goal: List.Chain R a (l₁ ++ b :: l₂) ↔ List.Chain R a (l₁ ++ [b]) ∧ List.Chain R b l₂
-- List.chain_append_cons_cons
@[simp]
theorem chain_append_cons_cons {a b c : α} {l₁ l₂ : List α} :
    Chain R a (l₁ ++ b :: c :: l₂) ↔ Chain R a (l₁ ++ [b]) ∧ R b c ∧ Chain R c l₂ 
Arguments: {α : Type u} {R : α → α → Prop} {a b c : α} {l₁ l₂ : List α}
Goal: List.Chain R a (l₁ ++ b :: c :: l₂) ↔ List.Chain R a (l₁ ++ [b]) ∧ R b c ∧ List.Chain R c l₂
-- List.chain_iff_forall₂
theorem chain_iff_forall₂ :
    ∀ {a : α} {l : List α}, Chain R a l ↔ l = [] ∨ Forall₂ R (a :: dropLast l) l
  
Arguments: {α : Type u} {R : α → α → Prop} {a : α} {l : List α}
Goal: List.Chain R a l ↔ l = [] ∨ List.Forall₂ R (a :: l.dropLast) l
-- List.chain_append_singleton_iff_forall₂
theorem chain_append_singleton_iff_forall₂ :
    Chain R a (l ++ [b]) ↔ Forall₂ R (a :: l) (l ++ [b]) 
Arguments: {α : Type u} {R : α → α → Prop} {l : List α} {a b : α}
Goal: List.Chain R a (l ++ [b]) ↔ List.Forall₂ R (a :: l) (l ++ [b])
-- List.chain_map
theorem chain_map (f : β → α) {b : β} {l : List β} :
    Chain R (f b) (map f l) ↔ Chain (fun a b : β => R (f a) (f b)) b l 
Arguments: {α : Type u} {β : Type v} {R : α → α → Prop} (f : β → α) {b : β} {l : List β}
Goal: List.Chain R (f b) (List.map f l) ↔ List.Chain (fun a b => R (f a) (f b)) b l
-- List.chain_of_chain_map
theorem chain_of_chain_map {S : β → β → Prop} (f : α → β) (H : ∀ a b : α, S (f a) (f b) → R a b)
    {a : α} {l : List α} (p : Chain S (f a) (map f l)) : Chain R a l 
Arguments: {α : Type u} {β : Type v} {R : α → α → Prop} {S : β → β → Prop} (f : α → β) (H : ∀ (a b : α), S (f a) (f b) → R a b) {a : α} {l : List α} (p : List.Chain S (f a) (List.map f l))
Goal: List.Chain R a l
-- List.chain_map_of_chain
theorem chain_map_of_chain {S : β → β → Prop} (f : α → β) (H : ∀ a b : α, R a b → S (f a) (f b))
    {a : α} {l : List α} (p : Chain R a l) : Chain S (f a) (map f l) 
Arguments: {α : Type u} {β : Type v} {R : α → α → Prop} {S : β → β → Prop} (f : α → β) (H : ∀ (a b : α), R a b → S (f a) (f b)) {a : α} {l : List α} (p : List.Chain R a l)
Goal: List.Chain S (f a) (List.map f l)
-- List.chain_pmap_of_chain
theorem chain_pmap_of_chain {S : β → β → Prop} {p : α → Prop} {f : ∀ a, p a → β}
    (H : ∀ a b ha hb, R a b → S (f a ha) (f b hb)) {a : α} {l : List α} (hl₁ : Chain R a l)
    (ha : p a) (hl₂ : ∀ a ∈ l, p a) : Chain S (f a ha) (List.pmap f l hl₂) 
Arguments: {α : Type u} {β : Type v} {R : α → α → Prop} {S : β → β → Prop} {p : α → Prop} {f : (a : α) → p a → β} (H : ∀ (a b : α) (ha : p a) (hb : p b), R a b → S (f a ha) (f b hb)) {a : α} {l : List α} (hl₁ : List.Chain R a l) (ha : p a) (hl₂ : ∀ (a : α), a ∈ l → p a)
Goal: List.Chain S (f a ha) (List.pmap f l hl₂)
-- List.chain_of_chain_pmap
theorem chain_of_chain_pmap {S : β → β → Prop} {p : α → Prop} (f : ∀ a, p a → β) {l : List α}
    (hl₁ : ∀ a ∈ l, p a) {a : α} (ha : p a) (hl₂ : Chain S (f a ha) (List.pmap f l hl₁))
    (H : ∀ a b ha hb, S (f a ha) (f b hb) → R a b) : Chain R a l 
Arguments: {α : Type u} {β : Type v} {R : α → α → Prop} {S : β → β → Prop} {p : α → Prop} (f : (a : α) → p a → β) {l : List α} (hl₁ : ∀ (a : α), a ∈ l → p a) {a : α} (ha : p a) (hl₂ : List.Chain S (f a ha) (List.pmap f l hl₁)) (H : ∀ (a b : α) (ha : p a) (hb : p b), S (f a ha) (f b hb) → R a b)
Goal: List.Chain R a l
-- List.Chain.pairwise
protected theorem Chain.pairwise [IsTrans α R] :
    ∀ {a : α} {l : List α}, Chain R a l → Pairwise R (a :: l)
  
Arguments: {α : Type u} {R : α → α → Prop} [IsTrans α R] {a : α} {l : List α}
Goal: List.Chain R a l → List.Pairwise R (a :: l)
-- List.chain_iff_pairwise
theorem chain_iff_pairwise [IsTrans α R] {a : α} {l : List α} : Chain R a l ↔ Pairwise R (a :: l) 
Arguments: {α : Type u} {R : α → α → Prop} [IsTrans α R] {a : α} {l : List α}
Goal: List.Chain R a l ↔ List.Pairwise R (a :: l)
-- List.Chain.sublist
protected theorem Chain.sublist [IsTrans α R] (hl : l₂.Chain R a) (h : l₁ <+ l₂) :
    l₁.Chain R a 
Arguments: {α : Type u} {R : α → α → Prop} {l₁ l₂ : List α} {a : α} [IsTrans α R] (hl : List.Chain R a l₂) (h : l₁.Sublist l₂)
Goal: List.Chain R a l₁
-- List.Chain.rel
protected theorem Chain.rel [IsTrans α R] (hl : l.Chain R a) (hb : b ∈ l) : R a b 
Arguments: {α : Type u} {R : α → α → Prop} {l : List α} {a b : α} [IsTrans α R] (hl : List.Chain R a l) (hb : b ∈ l)
Goal: R a b
-- List.chain_iff_get
theorem chain_iff_get {R} : ∀ {a : α} {l : List α}, Chain R a l ↔
    (∀ h : 0 < length l, R a (get l ⟨0, h⟩)) ∧
      ∀ (i : ℕ) (h : i < l.length - 1),
        R (get l ⟨i, by omega⟩) (get l ⟨i+1, by omega⟩)
  
Arguments: {α : Type u} {R : α → α → Prop} {a : α} {l : List α}
Goal: List.Chain R a l ↔
  (∀ (h : 0 < l.length), R a (l.get ⟨0, h⟩)) ∧ ∀ (i : ℕ) (h : i < l.length - 1), R (l.get ⟨i, ⋯⟩) (l.get ⟨i + 1, ⋯⟩)
-- List.Chain'.imp
theorem Chain'.imp {S : α → α → Prop} (H : ∀ a b, R a b → S a b) {l : List α} (p : Chain' R l) :
    Chain' S l 
Arguments: {α : Type u} {R S : α → α → Prop} (H : ∀ (a b : α), R a b → S a b) {l : List α} (p : List.Chain' R l)
Goal: List.Chain' S l
-- List.Chain'.iff
theorem Chain'.iff {S : α → α → Prop} (H : ∀ a b, R a b ↔ S a b) {l : List α} :
    Chain' R l ↔ Chain' S l 
Arguments: {α : Type u} {R S : α → α → Prop} (H : ∀ (a b : α), R a b ↔ S a b) {l : List α}
Goal: List.Chain' R l ↔ List.Chain' S l
-- List.Chain'.iff_mem
theorem Chain'.iff_mem : ∀ {l : List α}, Chain' R l ↔ Chain' (fun x y => x ∈ l ∧ y ∈ l ∧ R x y) l
  
Arguments: {α : Type u} {R : α → α → Prop} {l : List α}
Goal: List.Chain' R l ↔ List.Chain' (fun x y => x ∈ l ∧ y ∈ l ∧ R x y) l
-- List.chain'_nil
@[simp]
theorem chain'_nil : Chain' R [] 
Arguments: {α : Type u} {R : α → α → Prop}
Goal: List.Chain' R []
-- List.chain'_singleton
@[simp]
theorem chain'_singleton (a : α) : Chain' R [a] 
Arguments: {α : Type u} {R : α → α → Prop} (a : α)
Goal: List.Chain' R [a]
-- List.chain'_cons
@[simp]
theorem chain'_cons {x y l} : Chain' R (x :: y :: l) ↔ R x y ∧ Chain' R (y :: l) 
Arguments: {α : Type u} {R : α → α → Prop} {x y : α} {l : List α}
Goal: List.Chain' R (x :: y :: l) ↔ R x y ∧ List.Chain' R (y :: l)
-- List.chain'_isInfix
theorem chain'_isInfix : ∀ l : List α, Chain' (fun x y => [x, y] <:+: l) l
  
Arguments: {α : Type u} (l : List α)
Goal: List.Chain' (fun x y => [x, y] <:+: l) l
-- List.chain'_split
theorem chain'_split {a : α} :
    ∀ {l₁ l₂ : List α}, Chain' R (l₁ ++ a :: l₂) ↔ Chain' R (l₁ ++ [a]) ∧ Chain' R (a :: l₂)
  
Arguments: {α : Type u} {R : α → α → Prop} {a : α} {l₁ l₂ : List α}
Goal: List.Chain' R (l₁ ++ a :: l₂) ↔ List.Chain' R (l₁ ++ [a]) ∧ List.Chain' R (a :: l₂)
-- List.chain'_append_cons_cons
@[simp]
theorem chain'_append_cons_cons {b c : α} {l₁ l₂ : List α} :
    Chain' R (l₁ ++ b :: c :: l₂) ↔ Chain' R (l₁ ++ [b]) ∧ R b c ∧ Chain' R (c :: l₂) 
Arguments: {α : Type u} {R : α → α → Prop} {b c : α} {l₁ l₂ : List α}
Goal: List.Chain' R (l₁ ++ b :: c :: l₂) ↔ List.Chain' R (l₁ ++ [b]) ∧ R b c ∧ List.Chain' R (c :: l₂)
-- List.chain'_map
theorem chain'_map (f : β → α) {l : List β} :
    Chain' R (map f l) ↔ Chain' (fun a b : β => R (f a) (f b)) l 
Arguments: {α : Type u} {β : Type v} {R : α → α → Prop} (f : β → α) {l : List β}
Goal: List.Chain' R (List.map f l) ↔ List.Chain' (fun a b => R (f a) (f b)) l
-- List.chain'_of_chain'_map
theorem chain'_of_chain'_map {S : β → β → Prop} (f : α → β) (H : ∀ a b : α, S (f a) (f b) → R a b)
    {l : List α} (p : Chain' S (map f l)) : Chain' R l 
Arguments: {α : Type u} {β : Type v} {R : α → α → Prop} {S : β → β → Prop} (f : α → β) (H : ∀ (a b : α), S (f a) (f b) → R a b) {l : List α} (p : List.Chain' S (List.map f l))
Goal: List.Chain' R l
-- List.chain'_map_of_chain'
theorem chain'_map_of_chain' {S : β → β → Prop} (f : α → β) (H : ∀ a b : α, R a b → S (f a) (f b))
    {l : List α} (p : Chain' R l) : Chain' S (map f l) 
Arguments: {α : Type u} {β : Type v} {R : α → α → Prop} {S : β → β → Prop} (f : α → β) (H : ∀ (a b : α), R a b → S (f a) (f b)) {l : List α} (p : List.Chain' R l)
Goal: List.Chain' S (List.map f l)
-- List.Pairwise.chain'
theorem Pairwise.chain' : ∀ {l : List α}, Pairwise R l → Chain' R l
  
Arguments: {α : Type u} {R : α → α → Prop} {l : List α}
Goal: List.Pairwise R l → List.Chain' R l
-- List.chain'_iff_pairwise
theorem chain'_iff_pairwise [IsTrans α R] : ∀ {l : List α}, Chain' R l ↔ Pairwise R l
  
Arguments: {α : Type u} {R : α → α → Prop} [IsTrans α R] {l : List α}
Goal: List.Chain' R l ↔ List.Pairwise R l
-- List.Chain'.sublist
protected theorem Chain'.sublist [IsTrans α R] (hl : l₂.Chain' R) (h : l₁ <+ l₂) : l₁.Chain' R 
Arguments: {α : Type u} {R : α → α → Prop} {l₁ l₂ : List α} [IsTrans α R] (hl : List.Chain' R l₂) (h : l₁.Sublist l₂)
Goal: List.Chain' R l₁
-- List.Chain'.cons
theorem Chain'.cons {x y l} (h₁ : R x y) (h₂ : Chain' R (y :: l)) : Chain' R (x :: y :: l) 
Arguments: {α : Type u} {R : α → α → Prop} {x y : α} {l : List α} (h₁ : R x y) (h₂ : List.Chain' R (y :: l))
Goal: List.Chain' R (x :: y :: l)
-- List.Chain'.tail
theorem Chain'.tail : ∀ {l}, Chain' R l → Chain' R l.tail
  
Arguments: {α : Type u} {R : α → α → Prop} {l : List α}
Goal: List.Chain' R l → List.Chain' R l.tail
-- List.Chain'.rel_head
theorem Chain'.rel_head {x y l} (h : Chain' R (x :: y :: l)) : R x y 
Arguments: {α : Type u} {R : α → α → Prop} {x y : α} {l : List α} (h : List.Chain' R (x :: y :: l))
Goal: R x y
-- List.Chain'.rel_head?
theorem Chain'.rel_head? {x l} (h : Chain' R (x :: l)) ⦃y⦄ (hy : y ∈ head? l) : R x y 
Arguments: {α : Type u} {R : α → α → Prop} {x : α} {l : List α} (h : List.Chain' R (x :: l)) ⦃y : α⦄ (hy : y ∈ l.head?)
Goal: R x y
-- List.Chain'.cons'
theorem Chain'.cons' {x} : ∀ {l : List α}, Chain' R l → (∀ y ∈ l.head?, R x y) → Chain' R (x :: l)
  
Arguments: {α : Type u} {R : α → α → Prop} {x : α} {l : List α}
Goal: List.Chain' R l → (∀ (y : α), y ∈ l.head? → R x y) → List.Chain' R (x :: l)
-- List.chain'_cons'
theorem chain'_cons' {x l} : Chain' R (x :: l) ↔ (∀ y ∈ head? l, R x y) ∧ Chain' R l 
Arguments: {α : Type u} {R : α → α → Prop} {x : α} {l : List α}
Goal: List.Chain' R (x :: l) ↔ (∀ (y : α), y ∈ l.head? → R x y) ∧ List.Chain' R l
-- List.chain'_append
theorem chain'_append :
    ∀ {l₁ l₂ : List α},
      Chain' R (l₁ ++ l₂) ↔ Chain' R l₁ ∧ Chain' R l₂ ∧ ∀ x ∈ l₁.getLast?, ∀ y ∈ l₂.head?, R x y
  
Arguments: {α : Type u} {R : α → α → Prop} {l₁ l₂ : List α}
Goal: List.Chain' R (l₁ ++ l₂) ↔
  List.Chain' R l₁ ∧ List.Chain' R l₂ ∧ ∀ (x : α), x ∈ l₁.getLast? → ∀ (y : α), y ∈ l₂.head? → R x y
-- List.Chain'.append
theorem Chain'.append (h₁ : Chain' R l₁) (h₂ : Chain' R l₂)
    (h : ∀ x ∈ l₁.getLast?, ∀ y ∈ l₂.head?, R x y) : Chain' R (l₁ ++ l₂) 
Arguments: {α : Type u} {R : α → α → Prop} {l₁ l₂ : List α} (h₁ : List.Chain' R l₁) (h₂ : List.Chain' R l₂) (h : ∀ (x : α), x ∈ l₁.getLast? → ∀ (y : α), y ∈ l₂.head? → R x y)
Goal: List.Chain' R (l₁ ++ l₂)
-- List.Chain'.left_of_append
theorem Chain'.left_of_append (h : Chain' R (l₁ ++ l₂)) : Chain' R l₁ 
Arguments: {α : Type u} {R : α → α → Prop} {l₁ l₂ : List α} (h : List.Chain' R (l₁ ++ l₂))
Goal: List.Chain' R l₁
-- List.Chain'.right_of_append
theorem Chain'.right_of_append (h : Chain' R (l₁ ++ l₂)) : Chain' R l₂ 
Arguments: {α : Type u} {R : α → α → Prop} {l₁ l₂ : List α} (h : List.Chain' R (l₁ ++ l₂))
Goal: List.Chain' R l₂
-- List.Chain'.infix
theorem Chain'.infix (h : Chain' R l) (h' : l₁ <:+: l) : Chain' R l₁ 
Arguments: {α : Type u} {R : α → α → Prop} {l l₁ : List α} (h : List.Chain' R l) (h' : l₁ <:+: l)
Goal: List.Chain' R l₁
-- List.Chain'.suffix
theorem Chain'.suffix (h : Chain' R l) (h' : l₁ <:+ l) : Chain' R l₁ 
Arguments: {α : Type u} {R : α → α → Prop} {l l₁ : List α} (h : List.Chain' R l) (h' : l₁ <:+ l)
Goal: List.Chain' R l₁
-- List.Chain'.prefix
theorem Chain'.prefix (h : Chain' R l) (h' : l₁ <+: l) : Chain' R l₁ 
Arguments: {α : Type u} {R : α → α → Prop} {l l₁ : List α} (h : List.Chain' R l) (h' : l₁ <+: l)
Goal: List.Chain' R l₁
-- List.Chain'.drop
theorem Chain'.drop (h : Chain' R l) (n : ℕ) : Chain' R (drop n l) 
Arguments: {α : Type u} {R : α → α → Prop} {l : List α} (h : List.Chain' R l) (n : ℕ)
Goal: List.Chain' R (List.drop n l)
-- List.Chain'.init
theorem Chain'.init (h : Chain' R l) : Chain' R l.dropLast 
Arguments: {α : Type u} {R : α → α → Prop} {l : List α} (h : List.Chain' R l)
Goal: List.Chain' R l.dropLast
-- List.Chain'.take
theorem Chain'.take (h : Chain' R l) (n : ℕ) : Chain' R (take n l) 
Arguments: {α : Type u} {R : α → α → Prop} {l : List α} (h : List.Chain' R l) (n : ℕ)
Goal: List.Chain' R (List.take n l)
-- List.chain'_pair
theorem chain'_pair {x y} : Chain' R [x, y] ↔ R x y 
Arguments: {α : Type u} {R : α → α → Prop} {x y : α}
Goal: List.Chain' R [x, y] ↔ R x y
-- List.Chain'.imp_head
theorem Chain'.imp_head {x y} (h : ∀ {z}, R x z → R y z) {l} (hl : Chain' R (x :: l)) :
    Chain' R (y :: l) 
Arguments: {α : Type u} {R : α → α → Prop} {x y : α} (h : ∀ {z : α}, R x z → R y z) {l : List α} (hl : List.Chain' R (x :: l))
Goal: List.Chain' R (y :: l)
-- List.chain'_reverse
theorem chain'_reverse : ∀ {l}, Chain' R (reverse l) ↔ Chain' (flip R) l
  
Arguments: {α : Type u} {R : α → α → Prop} {l : List α}
Goal: List.Chain' R l.reverse ↔ List.Chain' (flip R) l
-- List.chain'_iff_get
theorem chain'_iff_get {R} : ∀ {l : List α}, Chain' R l ↔
    ∀ (i : ℕ) (h : i < length l - 1),
      R (get l ⟨i, by omega⟩) (get l ⟨i + 1, by omega⟩)
  
Arguments: {α : Type u} {R : α → α → Prop} {l : List α}
Goal: List.Chain' R l ↔ ∀ (i : ℕ) (h : i < l.length - 1), R (l.get ⟨i, ⋯⟩) (l.get ⟨i + 1, ⋯⟩)
-- List.Chain'.append_overlap
theorem Chain'.append_overlap {l₁ l₂ l₃ : List α} (h₁ : Chain' R (l₁ ++ l₂))
    (h₂ : Chain' R (l₂ ++ l₃)) (hn : l₂ ≠ []) : Chain' R (l₁ ++ l₂ ++ l₃) 
Arguments: {α : Type u} {R : α → α → Prop} {l₁ l₂ l₃ : List α} (h₁ : List.Chain' R (l₁ ++ l₂)) (h₂ : List.Chain' R (l₂ ++ l₃)) (hn : l₂ ≠ [])
Goal: List.Chain' R (l₁ ++ l₂ ++ l₃)
-- List.chain'_join
lemma chain'_join : ∀ {L : List (List α)}, [] ∉ L →
    (Chain' R L.join ↔ (∀ l ∈ L, Chain' R l) ∧
    L.Chain' (fun l₁ l₂ => ∀ᵉ (x ∈ l₁.getLast?) (y ∈ l₂.head?), R x y))

Arguments: {α : Type u} {R : α → α → Prop} {L : List (List α)}
Goal: ¬[] ∈ L →
  (List.Chain' R L.join ↔
    (∀ (l : List α), l ∈ L → List.Chain' R l) ∧
      List.Chain' (fun l₁ l₂ => ∀ (x : α), x ∈ l₁.getLast? → ∀ (y : α), y ∈ l₂.head? → R x y) L)
-- List.exists_chain_of_relationReflTransGen
theorem exists_chain_of_relationReflTransGen (h : Relation.ReflTransGen r a b) :
    ∃ l, Chain r a l ∧ getLast (a :: l) (cons_ne_nil _ _) = b 
Arguments: {α : Type u} {r : α → α → Prop} {a b : α} (h : Relation.ReflTransGen r a b)
Goal: ∃ l, List.Chain r a l ∧ (a :: l).getLast ⋯ = b
-- List.Chain.induction
theorem Chain.induction (p : α → Prop) (l : List α) (h : Chain r a l)
    (hb : getLast (a :: l) (cons_ne_nil _ _) = b) (carries : ∀ ⦃x y : α⦄, r x y → p y → p x)
    (final : p b) : ∀ i ∈ a :: l, p i 
Arguments: {α : Type u} {r : α → α → Prop} {a b : α} (p : α → Prop) (l : List α) (h : List.Chain r a l) (hb : (a :: l).getLast ⋯ = b) (carries : ∀ ⦃x y : α⦄, r x y → p y → p x) (final : p b) (i : α)
Goal: i ∈ a :: l → p i
-- List.Chain.induction_head
@[elab_as_elim]
theorem Chain.induction_head (p : α → Prop) (l : List α) (h : Chain r a l)
    (hb : getLast (a :: l) (cons_ne_nil _ _) = b) (carries : ∀ ⦃x y : α⦄, r x y → p y → p x)
    (final : p b) : p a 
Arguments: {α : Type u} {r : α → α → Prop} {a b : α} (p : α → Prop) (l : List α) (h : List.Chain r a l) (hb : (a :: l).getLast ⋯ = b) (carries : ∀ ⦃x y : α⦄, r x y → p y → p x) (final : p b)
Goal: p a
-- List.relationReflTransGen_of_exists_chain
theorem relationReflTransGen_of_exists_chain (l : List α) (hl₁ : Chain r a l)
    (hl₂ : getLast (a :: l) (cons_ne_nil _ _) = b) : Relation.ReflTransGen r a b 
Arguments: {α : Type u} {r : α → α → Prop} {a b : α} (l : List α) (hl₁ : List.Chain r a l) (hl₂ : (a :: l).getLast ⋯ = b)
Goal: Relation.ReflTransGen r a b
-- List.Chain'.cons_of_le
theorem Chain'.cons_of_le [LinearOrder α] {a : α} {as m : List α}
    (ha : List.Chain' (· > ·) (a :: as)) (hm : List.Chain' (· > ·) m) (hmas : m ≤ as) :
    List.Chain' (· > ·) (a :: m) 
Arguments: {α : Type u} [LinearOrder α] {a : α} {as m : List α} (ha : List.Chain' (fun x x_1 => x > x_1) (a :: as)) (hm : List.Chain' (fun x x_1 => x > x_1) m) (hmas : m ≤ as)
Goal: List.Chain' (fun x x_1 => x > x_1) (a :: m)
-- Acc.list_chain'
theorem Acc.list_chain' {l : List.chains r} (acc : ∀ a ∈ l.val.head?, Acc r a) :
    Acc (List.lex_chains r) l 
Arguments: {α : Type u_1} {r : α → α → Prop} {l : List.chains r} (acc : ∀ (a : α), a ∈ (↑l).head? → Acc r a)
Goal: Acc (List.lex_chains r) l
-- WellFounded.list_chain'
theorem WellFounded.list_chain' (hwf : WellFounded r) :
    WellFounded (List.lex_chains r) 
Arguments: {α : Type u_1} {r : α → α → Prop} (hwf : WellFounded r)
Goal: WellFounded (List.lex_chains r)
-- List.Pi.cons_def
lemma cons_def (a : α i) (f : ∀ j ∈ l, α j) : cons _ _ a f =
    fun j hj ↦ if h : j = i then h.symm.rec a else f j <| (mem_cons.1 hj).resolve_left h 
Arguments: {ι : Type u_1} [DecidableEq ι] {α : ι → Sort u_2} {i : ι} {l : List ι} (a : α i) (f : (j : ι) → j ∈ l → α j)
Goal: List.Pi.cons i l a f = fun j hj => if h : j = i then ⋯ ▸ a else f j ⋯
-- Multiset.Pi.cons_coe
@[simp] lemma _root_.Multiset.Pi.cons_coe {l : List ι} (a : α i) (f : ∀ j ∈ l, α j) :
    Multiset.Pi.cons l _ a f = cons _ _ a f 
Arguments: {ι : Type u_1} [DecidableEq ι] {α : ι → Sort u_2} {i : ι} {l : List ι} (a : α i) (f : (j : ι) → j ∈ l → α j)
Goal: Multiset.Pi.cons (↑l) i a f = List.Pi.cons i l a f
-- List.Pi.cons_eta
@[simp] lemma cons_eta (f : ∀ j ∈ i :: l, α j) :
    cons _ _ (head f) (tail f) = f 
Arguments: {ι : Type u_1} [DecidableEq ι] {α : ι → Sort u_2} {i : ι} {l : List ι} (f : (j : ι) → j ∈ i :: l → α j)
Goal: List.Pi.cons i l (List.Pi.head f) (List.Pi.tail f) = f
-- List.Pi.cons_map
lemma cons_map (a : α i) (f : ∀ j ∈ l, α j)
    {α' : ι → Sort*} (φ : ∀ ⦃j⦄, α j → α' j) :
    cons _ _ (φ a) (fun j hj ↦ φ (f j hj)) = (fun j hj ↦ φ ((cons _ _ a f) j hj)) 
Arguments: {ι : Type u_1} [DecidableEq ι] {α : ι → Sort u_2} {i : ι} {l : List ι} (a : α i) (f : (j : ι) → j ∈ l → α j) {α' : ι → Sort u_3} (φ : ⦃j : ι⦄ → α j → α' j)
Goal: (List.Pi.cons i l (φ a) fun j hj => φ (f j hj)) = fun j hj => φ (List.Pi.cons i l a f j hj)
-- List.Pi.forall_rel_cons_ext
lemma forall_rel_cons_ext {r : ∀ ⦃i⦄, α i → α i → Prop} {a₁ a₂ : α i} {f₁ f₂ : ∀ j ∈ l, α j}
    (ha : r a₁ a₂) (hf : ∀ (i : ι) (hi : i ∈ l), r (f₁ i hi) (f₂ i hi)) :
    ∀ j hj, r (cons _ _ a₁ f₁ j hj) (cons _ _ a₂ f₂ j hj) 
Arguments: {ι : Type u_1} [DecidableEq ι] {α : ι → Sort u_2} {i : ι} {l : List ι} {r : ⦃i : ι⦄ → α i → α i → Prop} {a₁ a₂ : α i} {f₁ f₂ : (j : ι) → j ∈ l → α j} (ha : r a₁ a₂) (hf : ∀ (i : ι) (hi : i ∈ l), r (f₁ i hi) (f₂ i hi)) (j : ι) (hj : j ∈ i :: l)
Goal: r (List.Pi.cons i l a₁ f₁ j hj) (List.Pi.cons i l a₂ f₂ j hj)
-- List.pi_nil
@[simp] lemma pi_nil (t : ∀ i, List (α i)) :
    pi [] t = [Pi.nil α] 
Arguments: {ι : Type u_1} [DecidableEq ι] {α : ι → Type u_2} (t : (i : ι) → List (α i))
Goal: [].pi t = [List.Pi.nil α]
-- List.pi_cons
@[simp] lemma pi_cons (i : ι) (l : List ι) (t : ∀ j, List (α j)) :
    pi (i :: l) t = ((t i).bind fun b ↦ (pi l t).map <| Pi.cons _ _ b) 
Arguments: {ι : Type u_1} [DecidableEq ι] {α : ι → Type u_2} (i : ι) (l : List ι) (t : (j : ι) → List (α j))
Goal: (i :: l).pi t = (t i).bind fun b => List.map (List.Pi.cons i l b) (l.pi t)
-- Multiset.pi_coe
lemma _root_.Multiset.pi_coe (l : List ι) (fs : ∀ i, List (α i)) :
    (l : Multiset ι).pi (fs ·) = (↑(pi l fs) : Multiset (∀ i ∈ l, α i)) 
Arguments: {ι : Type u_1} [DecidableEq ι] {α : ι → Type u_2} (l : List ι) (fs : (i : ι) → List (α i))
Goal: ((↑l).pi fun x => ↑(fs x)) = ↑(l.pi fs)
-- List.mem_pi
lemma mem_pi {l : List ι} (fs : ∀ i, List (α i)) :
    ∀ f : ∀ i ∈ l, α i, (f ∈ pi l fs) ↔ (∀ i (hi : i ∈ l), f i hi ∈ fs i) 
Arguments: {ι : Type u_1} [DecidableEq ι] {α : ι → Type u_2} {l : List ι} (fs : (i : ι) → List (α i)) (f : (i : ι) → i ∈ l → α i)
Goal: f ∈ l.pi fs ↔ ∀ (i : ι) (hi : i ∈ l), f i hi ∈ fs i
-- List.Nat.mem_antidiagonal
@[simp]
theorem mem_antidiagonal {n : ℕ} {x : ℕ × ℕ} : x ∈ antidiagonal n ↔ x.1 + x.2 = n 
Arguments: {n : ℕ} {x : ℕ × ℕ}
Goal: x ∈ List.Nat.antidiagonal n ↔ x.1 + x.2 = n