Documentation

Linglib.Core.Data.List.TakeDrop

Membership and extensionality for take and drop by index #

The getElem? forms of List.mem_take_iff_getElem and List.mem_drop_iff_getElem: an element of a prefix or suffix is an entry of the original list at an index on that side of the cut. Two lists have the same take n exactly when they agree at every index below n (List.take_eq_take_iff_getElem?), and the same drop n exactly when they agree from n on (List.drop_eq_drop_iff_getElem?); the extensionality lemmas List.ext_take_getElem? and List.ext_drop_getElem? are their reverse directions. [UPSTREAM] candidates for Init/Data/List/Nat/TakeDrop.lean, beside their getElem counterparts and List.ext_getElem?.

theorem List.mem_take_iff_getElem? {α : Type u_1} {l : List α} {a : α} {n : ℕ} :
a ∈ take n l ↔ ∃ (i : ℕ), i < n ∧ l[i]? = some a
theorem List.mem_drop_iff_getElem? {α : Type u_1} {l : List α} {a : α} {n : ℕ} :
a ∈ drop n l ↔ ∃ (i : ℕ), i ≥ n ∧ l[i]? = some a
theorem List.ext_take_getElem? {α : Type u_1} {l₁ l₂ : List α} {n : ℕ} (h : ∀ (k : ℕ), k < n → l₁[k]? = l₂[k]?) :
take n l₁ = take n l₂
theorem List.ext_drop_getElem? {α : Type u_1} {l₁ l₂ : List α} {n : ℕ} (h : ∀ (k : ℕ), n ≤ k → l₁[k]? = l₂[k]?) :
drop n l₁ = drop n l₂
theorem List.take_eq_take_iff_getElem? {α : Type u_1} {l₁ l₂ : List α} {n : ℕ} :
take n l₁ = take n l₂ ↔ ∀ (k : ℕ), k < n → l₁[k]? = l₂[k]?
theorem List.drop_eq_drop_iff_getElem? {α : Type u_1} {l₁ l₂ : List α} {n : ℕ} :
drop n l₁ = drop n l₂ ↔ ∀ (k : ℕ), n ≤ k → l₁[k]? = l₂[k]?
theorem List.take_eq_take_of_le {α : Type u_1} {l₁ l₂ : List α} {n m : ℕ} (h : take m l₁ = take m l₂) (hnm : n ≤ m) :
take n l₁ = take n l₂
theorem List.drop_eq_drop_of_le {α : Type u_1} {l₁ l₂ : List α} {n m : ℕ} (h : drop m l₁ = drop m l₂) (hmn : m ≤ n) :
drop n l₁ = drop n l₂
theorem List.lt_length_of_mem_drop {α : Type u_1} {l : List α} {a : α} {n : ℕ} (h : a ∈ drop n l) :
n < l.length