Lemmas about List.Pairwise and List.Nodup.

Pairwise and Nodup

Pairwise

theorem List.Pairwise.sublist : ∀ {α : Type u_1} {l₁ l₂ : List α} {R : α → α → Prop}, l₁.Sublist l₂ → List.Pairwise R l₂ → List.Pairwise R l₁

theorem List.Pairwise.imp {α : Type u_1} {R : α → α → Prop} {S : α → α → Prop} (H : ∀ {a b : α}, R a b → S a b) {l : List α} : List.Pairwise R l → List.Pairwise S l

theorem List.rel_of_pairwise_cons : ∀ {α : Type u_1} {a : α} {l : List α} {R : α → α → Prop}, List.Pairwise R (a :: l) → ∀ {a' : α}, a' ∈ l → R a a'

theorem List.Pairwise.of_cons : ∀ {α : Type u_1} {a : α} {l : List α} {R : α → α → Prop}, List.Pairwise R (a :: l) → List.Pairwise R l

theorem List.Pairwise.tail {α : Type u_1} {R : α → α → Prop} {l : List α} (_p : List.Pairwise R l) : List.Pairwise R l.tail

theorem List.Pairwise.imp_of_mem {α : Type u_1} {l : List α} {R : α → α → Prop} {S : α → α → Prop} (H : ∀ {a b : α}, a ∈ l → b ∈ l → R a b → S a b) (p : List.Pairwise R l) : List.Pairwise S l

theorem List.Pairwise.and : ∀ {α : 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

theorem List.pairwise_and_iff : ∀ {α : 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

theorem List.Pairwise.imp₂ : ∀ {α : 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

theorem List.Pairwise.iff_of_mem {α : Type u_1} {R : α → α → Prop} {S : α → α → Prop} {l : List α} (H : ∀ {a b : α}, a ∈ l → b ∈ l → (R a b ↔ S a b)) : List.Pairwise R l ↔ List.Pairwise S l

theorem List.Pairwise.iff {α : Type u_1} {R : α → α → Prop} {S : α → α → Prop} (H : ∀ (a b : α), R a b ↔ S a b) {l : List α} : List.Pairwise R l ↔ List.Pairwise S l

theorem List.pairwise_of_forall {α : Type u_1} {R : α → α → Prop} {l : List α} (H : ∀ (x y : α), R x y) : List.Pairwise R l

theorem List.Pairwise.and_mem {α : Type u_1} {R : α → α → Prop} {l : List α} : List.Pairwise R l ↔ List.Pairwise (fun (x y : α) => x ∈ l ∧ y ∈ l ∧ R x y) l

theorem List.Pairwise.imp_mem {α : Type u_1} {R : α → α → Prop} {l : List α} : List.Pairwise R l ↔ List.Pairwise (fun (x y : α) => x ∈ l → y ∈ l → R x y) l

theorem List.Pairwise.forall_of_forall_of_flip : ∀ {α : 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

theorem List.pairwise_singleton {α : Type u_1} (R : α → α → Prop) (a : α) : List.Pairwise R [a]

theorem List.pairwise_pair {α : Type u_1} {R : α → α → Prop} {a : α} {b : α} : List.Pairwise R [a, b] ↔ R a b

theorem List.pairwise_map {α : Type u_1} : ∀ {α_1 : Type u_2} {f : α → α_1} {R : α_1 → α_1 → Prop} {l : List α}, List.Pairwise R (List.map f l) ↔ List.Pairwise (fun (a b : α) => R (f a) (f b)) l

theorem List.Pairwise.of_map {β : 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)) : List.Pairwise R l

theorem List.Pairwise.map {β : 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) : List.Pairwise S (List.map f l)

theorem List.pairwise_filterMap {β : Type u_1} {α : Type u_2} {R : α → α → Prop} (f : β → Option α) {l : List β} : List.Pairwise R (List.filterMap f l) ↔ List.Pairwise (fun (a a' : β) => ∀ (b : α), b ∈ f a → ∀ (b' : α), b' ∈ f a' → R b b') l

theorem List.Pairwise.filterMap {β : 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) : List.Pairwise S (List.filterMap f l)

@[reducible, inline, deprecated List.Pairwise.filterMap]

abbrev List.Pairwise.filter_map {β : 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) : List.Pairwise S (List.filterMap f l)

Equations

• @List.Pairwise.filter_map = @List.Pairwise.filterMap

theorem List.pairwise_filter {α : Type u_1} {R : α → α → Prop} (p : α → Prop) [DecidablePred p] {l : List α} : List.Pairwise R (List.filter (fun (b : α) => decide (p b)) l) ↔ List.Pairwise (fun (x y : α) => p x → p y → R x y) l

theorem List.Pairwise.filter {α : Type u_1} {R : α → α → Prop} {l : List α} (p : α → Bool) : List.Pairwise R l → List.Pairwise R (List.filter p l)

theorem List.pairwise_append {α : Type u_1} {R : α → α → Prop} {l₁ : List α} {l₂ : List α} : List.Pairwise R (l₁ ++ l₂) ↔ List.Pairwise R l₁ ∧ List.Pairwise R l₂ ∧ ∀ (a : α), a ∈ l₁ → ∀ (b : α), b ∈ l₂ → R a b

theorem List.pairwise_append_comm {α : Type u_1} {R : α → α → Prop} (s : ∀ {x y : α}, R x y → R y x) {l₁ : List α} {l₂ : List α} : List.Pairwise R (l₁ ++ l₂) ↔ List.Pairwise R (l₂ ++ l₁)

theorem List.pairwise_middle {α : Type u_1} {R : α → α → Prop} (s : ∀ {x y : α}, R x y → R y x) {a : α} {l₁ : List α} {l₂ : List α} : List.Pairwise R (l₁ ++ a :: l₂) ↔ List.Pairwise R (a :: (l₁ ++ l₂))

theorem List.pairwise_join {α : Type u_1} {R : α → α → Prop} {L : List (List α)} : List.Pairwise R L.join ↔ (∀ (l : List α), l ∈ L → List.Pairwise R l) ∧ List.Pairwise (fun (l₁ l₂ : List α) => ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₂ → R x y) L

theorem List.pairwise_bind {β : Type u_1} {α : Type u_2} {R : β → β → Prop} {l : List α} {f : α → List β} : 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

theorem List.pairwise_reverse {α : Type u_1} {R : α → α → Prop} {l : List α} : List.Pairwise R l.reverse ↔ List.Pairwise (fun (a b : α) => R b a) l

@[simp]

theorem List.pairwise_replicate {α : Type u_1} {R : α → α → Prop} {n : Nat} {a : α} : List.Pairwise R (List.replicate n a) ↔ n ≤ 1 ∨ R a a

theorem List.Pairwise.drop {α : Type u_1} {R : α → α → Prop} {l : List α} {n : Nat} (h : List.Pairwise R l) : List.Pairwise R (List.drop n l)

theorem List.Pairwise.take {α : Type u_1} {R : α → α → Prop} {l : List α} {n : Nat} (h : List.Pairwise R l) : List.Pairwise R (List.take n l)

theorem List.pairwise_iff_forall_sublist : ∀ {α : Type u_1} {l : List α} {R : α → α → Prop}, List.Pairwise R l ↔ ∀ {a b : α}, [a, b].Sublist l → R a b

theorem List.Pairwise.rel_of_mem_take_of_mem_drop {α : Type u_1} {R : α → α → Prop} {n : Nat} {x : α} {y : α} {l : List α} (h : List.Pairwise R l) (hx : x ∈ List.take n l) (hy : y ∈ List.drop n l) : R x y

theorem List.Pairwise.rel_of_mem_append {α : Type u_1} {R : α → α → Prop} {x : α} {y : α} {l₁ : List α} {l₂ : List α} (h : List.Pairwise R (l₁ ++ l₂)) (hx : x ∈ l₁) (hy : y ∈ l₂) : R x y

theorem List.pairwise_of_forall_mem_list {α : Type u_1} {l : List α} {r : α → α → Prop} (h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → r a b) : List.Pairwise r l

theorem List.pairwise_pmap {β : Type u_1} {α : Type u_2} {R : α → α → Prop} {p : β → Prop} {f : (b : β) → p b → α} {l : List β} (h : ∀ (x : β), x ∈ l → p x) : 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

theorem List.Pairwise.pmap {α : Type u_1} {R : α → α → Prop} {β : Type u_2} {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)) : List.Pairwise S (List.pmap f l h)

Nodup

@[simp]

theorem List.nodup_nil {α : Type u_1} : [].Nodup

@[simp]

theorem List.nodup_cons {α : Type u_1} {a : α} {l : List α} : (a :: l).Nodup ↔ ¬a ∈ l ∧ l.Nodup

theorem List.Nodup.sublist : ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → l₂.Nodup → l₁.Nodup

theorem List.Sublist.nodup : ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → l₂.Nodup → l₁.Nodup

theorem List.getElem?_inj {α : Type u_1} {i : Nat} {j : Nat} {xs : List α} (h₀ : i < xs.length) (h₁ : xs.Nodup) (h₂ : xs[i]? = xs[j]?) : i = j

@[simp]

theorem List.nodup_replicate {α : Type u_1} {n : Nat} {a : α} : (List.replicate n a).Nodup ↔ n ≤ 1