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