ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Batteries.RBNode.Path.Balanced.fill
protected theorem Balanced.fill {path : Path α} {t} :
    path.Balanced c₀ n₀ c n → t.Balanced c n → (path.fill t).Balanced c₀ n₀
  
Arguments: {α : Type u_1} {c₀ : Batteries.RBColor} {n₀ : Nat} {c : Batteries.RBColor} {n : Nat} {path : Batteries.RBNode.Path α} {t : Batteries.RBNode α}
Goal: Batteries.RBNode.Path.Balanced c₀ n₀ path c n → t.Balanced c n → (path.fill t).Balanced c₀ n₀
-- Batteries.RBNode.Balanced.zoom
protected theorem _root_.Batteries.RBNode.Balanced.zoom : t.Balanced c n → path.Balanced c₀ n₀ c n →
    zoom cut t path = (t', path') → ∃ c n, t'.Balanced c n ∧ path'.Balanced c₀ n₀ c n
  
Goal: ∀ {α : Type u_1} {cut : α → Ordering} {t : Batteries.RBNode α} {path : Batteries.RBNode.Path α}
  {t' : Batteries.RBNode α} {path' : Batteries.RBNode.Path α} {c₀ : Batteries.RBColor} {n₀ : Nat}
  {c : Batteries.RBColor} {n : Nat},
  t.Balanced c n →
    Batteries.RBNode.Path.Balanced c₀ n₀ path c n →
      Batteries.RBNode.zoom cut t path = (t', path') →
        ∃ c n, t'.Balanced c n ∧ Batteries.RBNode.Path.Balanced c₀ n₀ path' c n
-- Batteries.RBNode.Path.Balanced.ins
protected theorem Balanced.ins {path : Path α}
    (hp : path.Balanced c₀ n₀ c n) (ht : t.RedRed (c = red) n) :
    ∃ n, (path.ins t).Balanced black n 
Arguments: {α : Type u_1} {c₀ : Batteries.RBColor} {n₀ : Nat} {c : Batteries.RBColor} {n : Nat} {t : Batteries.RBNode α} {path : Batteries.RBNode.Path α} (hp : Batteries.RBNode.Path.Balanced c₀ n₀ path c n) (ht : Batteries.RBNode.RedRed (c = Batteries.RBColor.red) t n)
Goal: ∃ n, (path.ins t).Balanced Batteries.RBColor.black n
-- Batteries.RBNode.Path.Balanced.insertNew
protected theorem Balanced.insertNew {path : Path α} (H : path.Balanced c n black 0) :
    ∃ n, (path.insertNew v).Balanced black n 
Arguments: {α : Type u_1} {c : Batteries.RBColor} {n : Nat} {v : α} {path : Batteries.RBNode.Path α} (H : Batteries.RBNode.Path.Balanced c n path Batteries.RBColor.black 0)
Goal: ∃ n, (path.insertNew v).Balanced Batteries.RBColor.black n
-- Batteries.RBNode.Path.Balanced.del
protected theorem Balanced.del {path : Path α}
    (hp : path.Balanced c₀ n₀ c n) (ht : t.DelProp c' n) (hc : c = black → c' ≠ red) :
    ∃ n, (path.del t c').Balanced black n 
Arguments: {α : Type u_1} {c₀ : Batteries.RBColor} {n₀ : Nat} {c : Batteries.RBColor} {n : Nat} {c' : Batteries.RBColor} {t : Batteries.RBNode α} {path : Batteries.RBNode.Path α} (hp : Batteries.RBNode.Path.Balanced c₀ n₀ path c n) (ht : Batteries.RBNode.DelProp c' t n) (hc : c = Batteries.RBColor.black → c' ≠ Batteries.RBColor.red)
Goal: ∃ n, (path.del t c').Balanced Batteries.RBColor.black n
-- Batteries.RBNode.Path.zoom_zoomed₂
theorem zoom_zoomed₂ (e : zoom cut t path = (t', path'))
    (hp : path.Zoomed cut) : path'.Zoomed cut 
Goal: ∀ {α : Type u_1} {cut : α → Ordering} {t : Batteries.RBNode α} {path : Batteries.RBNode.Path α}
  {t' : Batteries.RBNode α} {path' : Batteries.RBNode.Path α},
  Batteries.RBNode.zoom cut t path = (t', path') →
    Batteries.RBNode.Path.Zoomed cut path → Batteries.RBNode.Path.Zoomed cut path'
-- Batteries.RBNode.cmpEq.RootOrdered_congr
theorem _root_.Batteries.RBNode.cmpEq.RootOrdered_congr
    {cmp : α → α → Ordering} (h : cmpEq cmp a b) :
    ∀ {t : Path α}, t.RootOrdered cmp a ↔ t.RootOrdered cmp b
  
Arguments: {α : Type u_1} {a b : α} {cmp : α → α → Ordering} (h : Batteries.RBNode.cmpEq cmp a b) {t : Batteries.RBNode.Path α}
Goal: Batteries.RBNode.Path.RootOrdered cmp t a ↔ Batteries.RBNode.Path.RootOrdered cmp t b
-- Batteries.RBNode.Path.Zoomed.toRootOrdered
theorem Zoomed.toRootOrdered {cmp} :
    ∀ {path : Path α}, path.Zoomed (cmp v) → path.RootOrdered cmp v
  
Arguments: {α : Type u_1} {v : α} {cmp : α → α → Ordering} {path : Batteries.RBNode.Path α}
Goal: Batteries.RBNode.Path.Zoomed (cmp v) path → Batteries.RBNode.Path.RootOrdered cmp path v
-- Batteries.RBNode.Path.Ordered.fill
protected theorem Ordered.fill : ∀ {path : Path α} {t},
    (path.fill t).Ordered cmp ↔ path.Ordered cmp ∧ t.Ordered cmp ∧ t.All (path.RootOrdered cmp)
  
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {path : Batteries.RBNode.Path α} {t : Batteries.RBNode α}
Goal: Batteries.RBNode.Ordered cmp (path.fill t) ↔
  Batteries.RBNode.Path.Ordered cmp path ∧
    Batteries.RBNode.Ordered cmp t ∧ Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp path) t
-- Batteries.RBNode.Ordered.zoom'
theorem _root_.Batteries.RBNode.Ordered.zoom' {t : RBNode α} {path : Path α}
    (ht : t.Ordered cmp) (hp : path.Ordered cmp) (tp : t.All (path.RootOrdered cmp))
    (pz : path.Zoomed cut) (eq : t.zoom cut path = (t', path')) :
    t'.Ordered cmp ∧ path'.Ordered cmp ∧ t'.All (path'.RootOrdered cmp) ∧ path'.Zoomed cut 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {t' : Batteries.RBNode α} {path' : Batteries.RBNode.Path α} {t : Batteries.RBNode α} {path : Batteries.RBNode.Path α} (ht : Batteries.RBNode.Ordered cmp t) (hp : Batteries.RBNode.Path.Ordered cmp path) (tp : Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp path) t) (pz : Batteries.RBNode.Path.Zoomed cut path) (eq : Batteries.RBNode.zoom cut t path = (t', path'))
Goal: Batteries.RBNode.Ordered cmp t' ∧
  Batteries.RBNode.Path.Ordered cmp path' ∧
    Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp path') t' ∧ Batteries.RBNode.Path.Zoomed cut path'
-- Batteries.RBNode.Ordered.zoom
theorem _root_.Batteries.RBNode.Ordered.zoom {t : RBNode α}
    (ht : t.Ordered cmp) (eq : t.zoom cut = (t', path')) :
    t'.Ordered cmp ∧ path'.Ordered cmp ∧ t'.All (path'.RootOrdered cmp) ∧ path'.Zoomed cut 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {t' : Batteries.RBNode α} {path' : Batteries.RBNode.Path α} {t : Batteries.RBNode α} (ht : Batteries.RBNode.Ordered cmp t) (eq : Batteries.RBNode.zoom cut t = (t', path'))
Goal: Batteries.RBNode.Ordered cmp t' ∧
  Batteries.RBNode.Path.Ordered cmp path' ∧
    Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp path') t' ∧ Batteries.RBNode.Path.Zoomed cut path'
-- Batteries.RBNode.Path.Ordered.ins
theorem Ordered.ins : ∀ {path : Path α} {t : RBNode α},
    t.Ordered cmp → path.Ordered cmp → t.All (path.RootOrdered cmp) → (path.ins t).Ordered cmp
  
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {path : Batteries.RBNode.Path α} {t : Batteries.RBNode α}
Goal: Batteries.RBNode.Ordered cmp t →
  Batteries.RBNode.Path.Ordered cmp path →
    Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp path) t → Batteries.RBNode.Ordered cmp (path.ins t)
-- Batteries.RBNode.Path.Ordered.insertNew
theorem Ordered.insertNew {path : Path α} (hp : path.Ordered cmp) (vp : path.RootOrdered cmp v) :
    (path.insertNew v).Ordered cmp 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {v : α} {path : Batteries.RBNode.Path α} (hp : Batteries.RBNode.Path.Ordered cmp path) (vp : Batteries.RBNode.Path.RootOrdered cmp path v)
Goal: Batteries.RBNode.Ordered cmp (path.insertNew v)
-- Batteries.RBNode.Path.Ordered.del
theorem Ordered.del : ∀ {path : Path α} {t : RBNode α} {c},
    t.Ordered cmp → path.Ordered cmp → t.All (path.RootOrdered cmp) → (path.del t c).Ordered cmp
  
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {path : Batteries.RBNode.Path α} {t : Batteries.RBNode α} {c : Batteries.RBColor}
Goal: Batteries.RBNode.Ordered cmp t →
  Batteries.RBNode.Path.Ordered cmp path →
    Batteries.RBNode.All (Batteries.RBNode.Path.RootOrdered cmp path) t → Batteries.RBNode.Ordered cmp (path.del t c)
-- Batteries.RBNode.Ordered.alter
protected theorem Ordered.alter {t : RBNode α}
    (H : ∀ {x t' p}, t.zoom cut = (t', p) → f t'.root? = some x →
      p.RootOrdered cmp x ∧ t'.OnRoot (cmpEq cmp x))
    (h : t.Ordered cmp) : (alter cut f t).Ordered cmp 
Arguments: {α : Type u_1} {cut : α → Ordering} {f : Option α → Option α} {cmp : α → α → Ordering} {t : Batteries.RBNode α} (H :
  ∀ {x : α} {t' : Batteries.RBNode α} {p : Batteries.RBNode.Path α},
    Batteries.RBNode.zoom cut t = (t', p) →
      f t'.root? = some x →
        Batteries.RBNode.Path.RootOrdered cmp p x ∧ Batteries.RBNode.OnRoot (Batteries.RBNode.cmpEq cmp x) t') (h : Batteries.RBNode.Ordered cmp t)
Goal: Batteries.RBNode.Ordered cmp (Batteries.RBNode.alter cut f t)
-- Batteries.RBNode.Balanced.alter
protected theorem Balanced.alter {t : RBNode α}
    (h : t.Balanced c n) : ∃ c n, (t.alter cut f).Balanced c n 
Arguments: {α : Type u_1} {c : Batteries.RBColor} {n : Nat} {cut : α → Ordering} {f : Option α → Option α} {t : Batteries.RBNode α} (h : t.Balanced c n)
Goal: ∃ c n, (Batteries.RBNode.alter cut f t).Balanced c n
-- Batteries.RBNode.modify_eq_alter
theorem modify_eq_alter (t : RBNode α) : t.modify cut f = t.alter cut (.map f) 
Arguments: {α : Type u_1} {cut : α → Ordering} {f : α → α} (t : Batteries.RBNode α)
Goal: Batteries.RBNode.modify cut f t = Batteries.RBNode.alter cut (Option.map f) t
-- Batteries.RBNode.Ordered.modify
protected theorem Ordered.modify {t : RBNode α}
    (H : (t.zoom cut).1.OnRoot fun x => cmpEq cmp (f x) x)
    (h : t.Ordered cmp) : (modify cut f t).Ordered cmp 
Arguments: {α : Type u_1} {cut : α → Ordering} {cmp : α → α → Ordering} {f : α → α} {t : Batteries.RBNode α} (H : Batteries.RBNode.OnRoot (fun x => Batteries.RBNode.cmpEq cmp (f x) x) (Batteries.RBNode.zoom cut t).fst) (h : Batteries.RBNode.Ordered cmp t)
Goal: Batteries.RBNode.Ordered cmp (Batteries.RBNode.modify cut f t)
-- Batteries.RBNode.Balanced.modify
protected theorem Balanced.modify {t : RBNode α}
    (h : t.Balanced c n) : ∃ c n, (t.modify cut f).Balanced c n 
Arguments: {α : Type u_1} {c : Batteries.RBColor} {n : Nat} {cut : α → Ordering} {f : α → α} {t : Batteries.RBNode α} (h : t.Balanced c n)
Goal: ∃ c n, (Batteries.RBNode.modify cut f t).Balanced c n
-- Batteries.RBNode.WF.alter
theorem WF.alter {t : RBNode α}
    (H : ∀ {x t' p}, t.zoom cut = (t', p) → f t'.root? = some x →
      p.RootOrdered cmp x ∧ t'.OnRoot (cmpEq cmp x))
    (h : WF cmp t) : WF cmp (alter cut f t) 
Arguments: {α : Type u_1} {cut : α → Ordering} {f : Option α → Option α} {cmp : α → α → Ordering} {t : Batteries.RBNode α} (H :
  ∀ {x : α} {t' : Batteries.RBNode α} {p : Batteries.RBNode.Path α},
    Batteries.RBNode.zoom cut t = (t', p) →
      f t'.root? = some x →
        Batteries.RBNode.Path.RootOrdered cmp p x ∧ Batteries.RBNode.OnRoot (Batteries.RBNode.cmpEq cmp x) t') (h : Batteries.RBNode.WF cmp t)
Goal: Batteries.RBNode.WF cmp (Batteries.RBNode.alter cut f t)
-- Batteries.RBNode.WF.modify
theorem WF.modify {t : RBNode α}
    (H : (t.zoom cut).1.OnRoot fun x => cmpEq cmp (f x) x)
    (h : WF cmp t) : WF cmp (t.modify cut f) 
Arguments: {α : Type u_1} {cut : α → Ordering} {cmp : α → α → Ordering} {f : α → α} {t : Batteries.RBNode α} (H : Batteries.RBNode.OnRoot (fun x => Batteries.RBNode.cmpEq cmp (f x) x) (Batteries.RBNode.zoom cut t).fst) (h : Batteries.RBNode.WF cmp t)
Goal: Batteries.RBNode.WF cmp (Batteries.RBNode.modify cut f t)
-- Batteries.RBNode.find?_eq_zoom
theorem find?_eq_zoom : ∀ {t : RBNode α} (p := .root), t.find? cut = (t.zoom cut p).1.root?
  
Arguments: {α : Type u_1} {cut : α → Ordering} {t : Batteries.RBNode α} (p : Batteries.RBNode.Path α := Batteries.RBNode.Path.root)
Goal: Batteries.RBNode.find? cut t = (Batteries.RBNode.zoom cut t p).fst.root?
-- Batteries.RBSet.ModifyWF.of_eq
theorem ModifyWF.of_eq {t : RBSet α cmp}
    (H : ∀ {x}, RBNode.find? cut t.val = some x → cmpEq cmp (f x) x) : ModifyWF t cut f 
Arguments: {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {f : α → α} {t : Batteries.RBSet α cmp} (H : ∀ {x : α}, Batteries.RBNode.find? cut t.val = some x → Batteries.RBNode.cmpEq cmp (f x) x)
Goal: t.ModifyWF cut f
-- List.rel_of_pairwise_cons
theorem rel_of_pairwise_cons (p : (a :: l).Pairwise R) : ∀ {a'}, a' ∈ l → R a a' 
Goal: ∀ {α : Type u_1} {a : α} {l : List α} {R : α → α → Prop}, List.Pairwise R (a :: l) → ∀ {a' : α}, a' ∈ l → R a a'
-- List.Pairwise.of_cons
theorem Pairwise.of_cons (p : (a :: l).Pairwise R) : Pairwise R l 
Goal: ∀ {α : Type u_1} {a : α} {l : List α} {R : α → α → Prop}, List.Pairwise R (a :: l) → List.Pairwise R l
-- List.Pairwise.tail
theorem Pairwise.tail : ∀ {l : List α} (_p : Pairwise R l), Pairwise R l.tail
  
Arguments: {α : Type u_1} {R : α → α → Prop} {l : List α} (_p : List.Pairwise R l)
Goal: List.Pairwise R l.tail
-- List.Pairwise.drop
theorem Pairwise.drop : ∀ {l : List α} {n : Nat}, List.Pairwise R l → List.Pairwise R (l.drop n)
  
Arguments: {α : Type u_1} {R : α → α → Prop} {l : List α} {n : Nat}
Goal: List.Pairwise R l → List.Pairwise R (List.drop n l)
-- List.Pairwise.imp_of_mem
theorem Pairwise.imp_of_mem {S : α → α → Prop}
    (H : ∀ {a b}, a ∈ l → b ∈ l → R a b → S a b) (p : Pairwise R l) : Pairwise S l 
Arguments: {α : Type u_1} {l : List α} {R S : α → α → Prop} (H : ∀ {a b : α}, a ∈ l → b ∈ l → R a b → S a b) (p : List.Pairwise R l)
Goal: List.Pairwise S l
-- List.Pairwise.and
theorem Pairwise.and (hR : Pairwise R l) (hS : Pairwise S l) :
    l.Pairwise fun a b => R a b ∧ S a b 
Goal: ∀ {α : Type u_1} {R : α → α → Prop} {l : List α} {S : α → α → Prop},
  List.Pairwise R l → List.Pairwise S l → List.Pairwise (fun a b => R a b ∧ S a b) l
-- List.pairwise_and_iff
theorem pairwise_and_iff : l.Pairwise (fun a b => R a b ∧ S a b) ↔ Pairwise R l ∧ Pairwise S l 
Goal: ∀ {α : Type u_1} {R : α → α → Prop} {l : List α} {S : α → α → Prop},
  List.Pairwise (fun a b => R a b ∧ S a b) l ↔ List.Pairwise R l ∧ List.Pairwise S l
-- List.Pairwise.imp₂
theorem Pairwise.imp₂ (H : ∀ a b, R a b → S a b → T a b)
    (hR : Pairwise R l) (hS : l.Pairwise S) : l.Pairwise T 
Goal: ∀ {α : Type u_1} {R S T : α → α → Prop} {l : List α},
  (∀ (a b : α), R a b → S a b → T a b) → List.Pairwise R l → List.Pairwise S l → List.Pairwise T l
-- List.Pairwise.iff_of_mem
theorem Pairwise.iff_of_mem {S : α → α → Prop} {l : List α}
    (H : ∀ {a b}, a ∈ l → b ∈ l → (R a b ↔ S a b)) : Pairwise R l ↔ Pairwise S l 
Arguments: {α : Type u_1} {R S : α → α → Prop} {l : List α} (H : ∀ {a b : α}, a ∈ l → b ∈ l → (R a b ↔ S a b))
Goal: List.Pairwise R l ↔ List.Pairwise S l
-- List.Pairwise.iff
theorem Pairwise.iff {S : α → α → Prop} (H : ∀ a b, R a b ↔ S a b) {l : List α} :
    Pairwise R l ↔ Pairwise S l 
Arguments: {α : Type u_1} {R S : α → α → Prop} (H : ∀ (a b : α), R a b ↔ S a b) {l : List α}
Goal: List.Pairwise R l ↔ List.Pairwise S l
-- List.pairwise_of_forall
theorem pairwise_of_forall {l : List α} (H : ∀ x y, R x y) : Pairwise R l 
Arguments: {α : Type u_1} {R : α → α → Prop} {l : List α} (H : ∀ (x y : α), R x y)
Goal: List.Pairwise R l
-- List.Pairwise.and_mem
theorem Pairwise.and_mem {l : List α} :
    Pairwise R l ↔ Pairwise (fun x y => x ∈ l ∧ y ∈ l ∧ R x y) l 
Arguments: {α : Type u_1} {R : α → α → Prop} {l : List α}
Goal: List.Pairwise R l ↔ List.Pairwise (fun x y => x ∈ l ∧ y ∈ l ∧ R x y) l
-- List.Pairwise.imp_mem
theorem Pairwise.imp_mem {l : List α} :
    Pairwise R l ↔ Pairwise (fun x y => x ∈ l → y ∈ l → R x y) l 
Arguments: {α : Type u_1} {R : α → α → Prop} {l : List α}
Goal: List.Pairwise R l ↔ List.Pairwise (fun x y => x ∈ l → y ∈ l → R x y) l
-- List.Pairwise.forall_of_forall_of_flip
theorem Pairwise.forall_of_forall_of_flip (h₁ : ∀ x ∈ l, R x x) (h₂ : Pairwise R l)
    (h₃ : l.Pairwise (flip R)) : ∀ ⦃x⦄, x ∈ l → ∀ ⦃y⦄, y ∈ l → R x y 
Goal: ∀ {α : Type u_1} {l : List α} {R : α → α → Prop},
  (∀ (x : α), x ∈ l → R x x) →
    List.Pairwise R l → List.Pairwise (flip R) l → ∀ ⦃x : α⦄, x ∈ l → ∀ ⦃y : α⦄, y ∈ l → R x y
-- List.pairwise_singleton
theorem pairwise_singleton (R) (a : α) : Pairwise R [a] 
Arguments: {α : Type u_1} (R : α → α → Prop) (a : α)
Goal: List.Pairwise R [a]
-- List.pairwise_pair
theorem pairwise_pair {a b : α} : Pairwise R [a, b] ↔ R a b 
Arguments: {α : Type u_1} {R : α → α → Prop} {a b : α}
Goal: List.Pairwise R [a, b] ↔ R a b
-- List.pairwise_append_comm
theorem pairwise_append_comm {R : α → α → Prop} (s : ∀ {x y}, R x y → R y x) {l₁ l₂ : List α} :
    Pairwise R (l₁ ++ l₂) ↔ Pairwise R (l₂ ++ l₁) 
Arguments: {α : Type u_1} {R : α → α → Prop} (s : ∀ {x y : α}, R x y → R y x) {l₁ l₂ : List α}
Goal: List.Pairwise R (l₁ ++ l₂) ↔ List.Pairwise R (l₂ ++ l₁)
-- List.pairwise_middle
theorem pairwise_middle {R : α → α → Prop} (s : ∀ {x y}, R x y → R y x) {a : α} {l₁ l₂ : List α} :
    Pairwise R (l₁ ++ a :: l₂) ↔ Pairwise R (a :: (l₁ ++ l₂)) 
Arguments: {α : Type u_1} {R : α → α → Prop} (s : ∀ {x y : α}, R x y → R y x) {a : α} {l₁ l₂ : List α}
Goal: List.Pairwise R (l₁ ++ a :: l₂) ↔ List.Pairwise R (a :: (l₁ ++ l₂))
-- List.Pairwise.of_map
theorem Pairwise.of_map {S : β → β → Prop} (f : α → β) (H : ∀ a b : α, S (f a) (f b) → R a b)
    (p : Pairwise S (map f l)) : Pairwise R l 
Arguments: {β : Type u_1} {α : Type u_2} {R : α → α → Prop} {l : List α} {S : β → β → Prop} (f : α → β) (H : ∀ (a b : α), S (f a) (f b) → R a b) (p : List.Pairwise S (List.map f l))
Goal: List.Pairwise R l
-- List.Pairwise.map
theorem Pairwise.map {S : β → β → Prop} (f : α → β) (H : ∀ a b : α, R a b → S (f a) (f b))
    (p : Pairwise R l) : Pairwise S (map f l) 
Arguments: {β : Type u_1} {α : Type u_2} {R : α → α → Prop} {l : List α} {S : β → β → Prop} (f : α → β) (H : ∀ (a b : α), R a b → S (f a) (f b)) (p : List.Pairwise R l)
Goal: List.Pairwise S (List.map f l)
-- List.pairwise_filterMap
theorem pairwise_filterMap (f : β → Option α) {l : List β} :
    Pairwise R (filterMap f l) ↔ Pairwise (fun a a' : β => ∀ b ∈ f a, ∀ b' ∈ f a', R b b') l 
Arguments: {β : Type u_1} {α : Type u_2} {R : α → α → Prop} (f : β → Option α) {l : List β}
Goal: List.Pairwise R (List.filterMap f l) ↔ List.Pairwise (fun a a' => ∀ (b : α), b ∈ f a → ∀ (b' : α), b' ∈ f a' → R b b') l
-- List.Pairwise.filter_map
theorem Pairwise.filter_map {S : β → β → Prop} (f : α → Option β)
    (H : ∀ a a' : α, R a a' → ∀ b ∈ f a, ∀ b' ∈ f a', S b b') {l : List α} (p : Pairwise R l) :
    Pairwise S (filterMap f l) 
Arguments: {β : Type u_1} {α : Type u_2} {R : α → α → Prop} {S : β → β → Prop} (f : α → Option β) (H : ∀ (a a' : α), R a a' → ∀ (b : β), b ∈ f a → ∀ (b' : β), b' ∈ f a' → S b b') {l : List α} (p : List.Pairwise R l)
Goal: List.Pairwise S (List.filterMap f l)
-- List.pairwise_filter
theorem pairwise_filter (p : α → Prop) [DecidablePred p] {l : List α} :
    Pairwise R (filter p l) ↔ Pairwise (fun x y => p x → p y → R x y) l 
Arguments: {α : Type u_1} {R : α → α → Prop} (p : α → Prop) [DecidablePred p] {l : List α}
Goal: List.Pairwise R (List.filter (fun b => decide (p b)) l) ↔ List.Pairwise (fun x y => p x → p y → R x y) l
-- List.Pairwise.filter
theorem Pairwise.filter (p : α → Bool) : Pairwise R l → Pairwise R (filter p l) 
Arguments: {α : Type u_1} {R : α → α → Prop} {l : List α} (p : α → Bool)
Goal: List.Pairwise R l → List.Pairwise R (List.filter p l)
-- List.pairwise_join
theorem pairwise_join {L : List (List α)} :
    Pairwise R (join L) ↔
      (∀ l ∈ L, Pairwise R l) ∧ Pairwise (fun l₁ l₂ => ∀ x ∈ l₁, ∀ y ∈ l₂, R x y) L 
Arguments: {α : Type u_1} {R : α → α → Prop} {L : List (List α)}
Goal: List.Pairwise R L.join ↔
  (∀ (l : List α), l ∈ L → List.Pairwise R l) ∧
    List.Pairwise (fun l₁ l₂ => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) L
-- List.pairwise_bind
theorem pairwise_bind {R : β → β → Prop} {l : List α} {f : α → List β} :
    List.Pairwise R (l.bind f) ↔
      (∀ a ∈ l, Pairwise R (f a)) ∧ Pairwise (fun a₁ a₂ => ∀ x ∈ f a₁, ∀ y ∈ f a₂, R x y) l 
Arguments: {β : Type u_1} {α : Type u_2} {R : β → β → Prop} {l : List α} {f : α → List β}
Goal: List.Pairwise R (l.bind f) ↔
  (∀ (a : α), a ∈ l → List.Pairwise R (f a)) ∧
    List.Pairwise (fun a₁ a₂ => ∀ (x : β), x ∈ f a₁ → ∀ (y : β), y ∈ f a₂ → R x y) l
-- List.pairwise_iff_forall_sublist
theorem pairwise_iff_forall_sublist : l.Pairwise R ↔ (∀ {a b}, [a,b] <+ l → R a b) 
Goal: ∀ {α : Type u_1} {l : List α} {R : α → α → Prop}, List.Pairwise R l ↔ ∀ {a b : α}, [a, b] <+ l → R a b
-- List.pairwise_of_reflexive_on_dupl_of_forall_ne
@[deprecated pairwise_iff_forall_sublist (since := "2023-09-18")]
theorem pairwise_of_reflexive_on_dupl_of_forall_ne [DecidableEq α] {l : List α} {r : α → α → Prop}
    (hr : ∀ a, 1 < count a l → r a a) (h : ∀ a ∈ l, ∀ b ∈ l, a ≠ b → r a b) : l.Pairwise r 
Arguments: {α : Type u_1} [DecidableEq α] {l : List α} {r : α → α → Prop} (hr : ∀ (a : α), 1 < List.count a l → r a a) (h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b)
Goal: List.Pairwise r l
-- List.map_get_sublist
theorem map_get_sublist {l : List α} {is : List (Fin l.length)} (h : is.Pairwise (·.val < ·.val)) :
    is.map (get l) <+ l 
Arguments: {α : Type u_1} {l : List α} {is : List (Fin l.length)} (h : List.Pairwise (fun x x_1 => ↑x < ↑x_1) is)
Goal: List.map l.get is <+ l
-- List.sublist_eq_map_get
theorem sublist_eq_map_get (h : l' <+ l) : ∃ is : List (Fin l.length),
    l' = map (get l) is ∧ is.Pairwise (· < ·) 
Goal: ∀ {α : Type u_1} {l' l : List α}, l' <+ l → ∃ is, l' = List.map l.get is ∧ List.Pairwise (fun x x_1 => x < x_1) is
-- List.pairwise_iff_getElem
theorem pairwise_iff_getElem : Pairwise R l ↔
    ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length) (_hij : i < j), R l[i] l[j] 
Goal: ∀ {α : Type u_1} {R : α → α → Prop} {l : List α},
  List.Pairwise R l ↔ ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length), i < j → R l[i] l[j]
-- List.pairwise_iff_get
theorem pairwise_iff_get : Pairwise R l ↔ ∀ (i j) (_hij : i < j), R (get l i) (get l j) 
Goal: ∀ {α : Type u_1} {R : α → α → Prop} {l : List α},
  List.Pairwise R l ↔ ∀ (i j : Fin l.length), i < j → R (l.get i) (l.get j)
-- List.pairwise_replicate
theorem pairwise_replicate {α : Type _} {r : α → α → Prop} {x : α} (hx : r x x) :
    ∀ n : Nat, Pairwise r (List.replicate n x)
  
Arguments: {α : Type u_1} {r : α → α → Prop} {x : α} (hx : r x x) (n : Nat)
Goal: List.Pairwise r (List.replicate n x)
-- List.pwFilter_nil
@[simp] theorem pwFilter_nil [DecidableRel R] : pwFilter R [] = [] 
Goal: ∀ {α : Type u_1} {R : α → α → Prop} [inst : DecidableRel R], List.pwFilter R [] = []
-- List.pwFilter_cons_of_pos
@[simp] theorem pwFilter_cons_of_pos [DecidableRel (α := α) R] {a : α} {l : List α}
    (h : ∀ b ∈ pwFilter R l, R a b) : pwFilter R (a :: l) = a :: pwFilter R l 
Arguments: {α : Type u_1} {R : α → α → Prop} [DecidableRel R] {a : α} {l : List α} (h : ∀ (b : α), b ∈ List.pwFilter R l → R a b)
Goal: List.pwFilter R (a :: l) = a :: List.pwFilter R l
-- List.pwFilter_cons_of_neg
@[simp] theorem pwFilter_cons_of_neg [DecidableRel (α := α) R] {a : α} {l : List α}
    (h : ¬∀ b ∈ pwFilter R l, R a b) : pwFilter R (a :: l) = pwFilter R l 
Arguments: {α : Type u_1} {R : α → α → Prop} [DecidableRel R] {a : α} {l : List α} (h : ¬∀ (b : α), b ∈ List.pwFilter R l → R a b)
Goal: List.pwFilter R (a :: l) = List.pwFilter R l
-- List.pwFilter_map
theorem pwFilter_map [DecidableRel (α := α) R] (f : β → α) :
    ∀ l : List β, pwFilter R (map f l) = map f (pwFilter (fun x y => R (f x) (f y)) l)
  
Arguments: {α : Type u_1} {R : α → α → Prop} {β : Type u_2} [DecidableRel R] (f : β → α) (l : List β)
Goal: List.pwFilter R (List.map f l) = List.map f (List.pwFilter (fun x y => R (f x) (f y)) l)
-- List.pwFilter_sublist
theorem pwFilter_sublist [DecidableRel (α := α) R] : ∀ l : List α, pwFilter R l <+ l
  
Arguments: {α : Type u_1} {R : α → α → Prop} [DecidableRel R] (l : List α)
Goal: List.pwFilter R l <+ l
-- List.pwFilter_subset
theorem pwFilter_subset [DecidableRel (α := α) R] (l : List α) : pwFilter R l ⊆ l 
Arguments: {α : Type u_1} {R : α → α → Prop} [DecidableRel R] (l : List α)
Goal: List.pwFilter R l ⊆ l
-- List.pairwise_pwFilter
theorem pairwise_pwFilter [DecidableRel (α := α) R] : ∀ l : List α, Pairwise R (pwFilter R l)
  
Arguments: {α : Type u_1} {R : α → α → Prop} [DecidableRel R] (l : List α)
Goal: List.Pairwise R (List.pwFilter R l)
-- List.pwFilter_eq_self
theorem pwFilter_eq_self [DecidableRel (α := α) R] {l : List α} :
    pwFilter R l = l ↔ Pairwise R l 
Arguments: {α : Type u_1} {R : α → α → Prop} [DecidableRel R] {l : List α}
Goal: List.pwFilter R l = l ↔ List.Pairwise R l
-- List.pwFilter_idem
@[simp] theorem pwFilter_idem [DecidableRel (α := α) R] :
    pwFilter R (pwFilter R l) = pwFilter R l 
Arguments: {α : Type u_1} {R : α → α → Prop} {l : List α} [DecidableRel R]
Goal: List.pwFilter R (List.pwFilter R l) = List.pwFilter R l