Documentation

Init.Data.List.Nat.Modify

modifyHead #

@[simp]
theorem List.length_modifyHead {α : Type u_1} {f : αα} {l : List α} :
theorem List.modifyHead_eq_set {α : Type u_1} [Inhabited α] (f : αα) (l : List α) :
modifyHead f l = l.set 0 (f (l[0]?.getD default))
@[simp]
theorem List.modifyHead_eq_nil_iff {α : Type u_1} {f : αα} {l : List α} :
@[simp]
theorem List.modifyHead_modifyHead {α : Type u_1} {l : List α} {f g : αα} :
theorem List.getElem_modifyHead {α : Type u_1} {l : List α} {f : αα} {i : Nat} (h : i < (modifyHead f l).length) :
(modifyHead f l)[i] = if h' : i = 0 then f l[0] else l[i]
@[simp]
theorem List.getElem_modifyHead_zero {α : Type u_1} {l : List α} {f : αα} {h : 0 < (modifyHead f l).length} :
(modifyHead f l)[0] = f l[0]
@[simp]
theorem List.getElem_modifyHead_succ {α : Type u_1} {l : List α} {f : αα} {n : Nat} (h : n + 1 < (modifyHead f l).length) :
(modifyHead f l)[n + 1] = l[n + 1]
theorem List.getElem?_modifyHead {α : Type u_1} {l : List α} {f : αα} {i : Nat} :
@[simp]
theorem List.getElem?_modifyHead_zero {α : Type u_1} {l : List α} {f : αα} :
@[simp]
theorem List.getElem?_modifyHead_succ {α : Type u_1} {l : List α} {f : αα} {n : Nat} :
(modifyHead f l)[n + 1]? = l[n + 1]?
@[simp]
theorem List.head_modifyHead {α : Type u_1} (f : αα) (l : List α) (h : modifyHead f l []) :
(modifyHead f l).head h = f (l.head )
@[simp]
theorem List.head?_modifyHead {α : Type u_1} {l : List α} {f : αα} :
@[simp]
theorem List.tail_modifyHead {α : Type u_1} {f : αα} {l : List α} :
@[simp]
theorem List.take_modifyHead {α : Type u_1} {f : αα} {l : List α} {i : Nat} :
take i (modifyHead f l) = modifyHead f (take i l)
@[simp]
theorem List.drop_modifyHead_of_pos {α : Type u_1} {f : αα} {l : List α} {i : Nat} (h : 0 < i) :
drop i (modifyHead f l) = drop i l
theorem List.eraseIdx_modifyHead_zero {α : Type u_1} {f : αα} {l : List α} :
@[simp]
theorem List.eraseIdx_modifyHead_of_pos {α : Type u_1} {f : αα} {l : List α} {i : Nat} (h : 0 < i) :
@[simp]
theorem List.modifyHead_id {α : Type u_1} :
@[simp]
theorem List.modifyHead_dropLast {α : Type u_1} {l : List α} {f : αα} :

modifyTailIdx #

@[simp]
theorem List.modifyTailIdx_id {α : Type u_1} (n : Nat) (l : List α) :
theorem List.eraseIdx_eq_modifyTailIdx {α : Type u_1} (i : Nat) (l : List α) :
@[simp]
theorem List.length_modifyTailIdx {α : Type u_1} (f : List αList α) (H : ∀ (l : List α), (f l).length = l.length) (n : Nat) (l : List α) :
theorem List.modifyTailIdx_add {α : Type u_1} (f : List αList α) (n : Nat) (l₁ l₂ : List α) :
modifyTailIdx f (l₁.length + n) (l₁ ++ l₂) = l₁ ++ modifyTailIdx f n l₂
theorem List.modifyTailIdx_eq_take_drop {α : Type u_1} (f : List αList α) (H : f [] = []) (i : Nat) (l : List α) :
modifyTailIdx f i l = take i l ++ f (drop i l)
theorem List.exists_of_modifyTailIdx {α : Type u_1} (f : List αList α) {n : Nat} {l : List α} (h : n l.length) :
(l₁ : List α), (l₂ : List α), l = l₁ ++ l₂ l₁.length = n modifyTailIdx f n l = l₁ ++ f l₂
theorem List.modifyTailIdx_modifyTailIdx {α : Type u_1} {f g : List αList α} (m n : Nat) (l : List α) :
modifyTailIdx g (m + n) (modifyTailIdx f n l) = modifyTailIdx (fun (l : List α) => modifyTailIdx g m (f l)) n l
theorem List.modifyTailIdx_modifyTailIdx_le {α : Type u_1} {f g : List αList α} (m n : Nat) (l : List α) (h : n m) :
modifyTailIdx g m (modifyTailIdx f n l) = modifyTailIdx (fun (l : List α) => modifyTailIdx g (m - n) (f l)) n l
theorem List.modifyTailIdx_modifyTailIdx_self {α : Type u_1} {f g : List αList α} (n : Nat) (l : List α) :

modify #

@[simp]
theorem List.modify_nil {α : Type u_1} (f : αα) (i : Nat) :
@[simp]
theorem List.modify_zero_cons {α : Type u_1} (f : αα) (a : α) (l : List α) :
modify f 0 (a :: l) = f a :: l
@[simp]
theorem List.modify_succ_cons {α : Type u_1} (f : αα) (a : α) (l : List α) (i : Nat) :
modify f (i + 1) (a :: l) = a :: modify f i l
theorem List.modifyHead_eq_modify_zero {α : Type u_1} (f : αα) (l : List α) :
modifyHead f l = modify f 0 l
@[simp]
theorem List.modify_eq_nil_iff {α : Type u_1} {f : αα} {i : Nat} {l : List α} :
modify f i l = [] l = []
theorem List.getElem?_modify {α : Type u_1} (f : αα) (i : Nat) (l : List α) (j : Nat) :
(modify f i l)[j]? = (fun (a : α) => if i = j then f a else a) <$> l[j]?
@[simp]
theorem List.length_modify {α : Type u_1} (f : αα) (i : Nat) (l : List α) :
(modify f i l).length = l.length
@[simp]
theorem List.getElem?_modify_eq {α : Type u_1} (f : αα) (i : Nat) (l : List α) :
(modify f i l)[i]? = f <$> l[i]?
@[simp]
theorem List.getElem?_modify_ne {α : Type u_1} (f : αα) {i j : Nat} (l : List α) (h : i j) :
(modify f i l)[j]? = l[j]?
theorem List.getElem_modify {α : Type u_1} (f : αα) (i : Nat) (l : List α) (j : Nat) (h : j < (modify f i l).length) :
(modify f i l)[j] = if i = j then f l[j] else l[j]
@[simp]
theorem List.getElem_modify_eq {α : Type u_1} (f : αα) (i : Nat) (l : List α) (h : i < (modify f i l).length) :
(modify f i l)[i] = f l[i]
@[simp]
theorem List.getElem_modify_ne {α : Type u_1} (f : αα) {i j : Nat} (l : List α) (h : i j) (h' : j < (modify f i l).length) :
(modify f i l)[j] = l[j]
theorem List.modify_eq_self {α : Type u_1} {f : αα} {i : Nat} {l : List α} (h : l.length i) :
modify f i l = l
theorem List.modify_modify_eq {α : Type u_1} (f g : αα) (i : Nat) (l : List α) :
modify g i (modify f i l) = modify (g f) i l
theorem List.modify_modify_ne {α : Type u_1} (f g : αα) {i j : Nat} (l : List α) (h : i j) :
modify g j (modify f i l) = modify f i (modify g j l)
theorem List.modify_eq_set {α : Type u_1} [Inhabited α] (f : αα) (i : Nat) (l : List α) :
modify f i l = l.set i (f (l[i]?.getD default))
theorem List.modify_eq_take_drop {α : Type u_1} (f : αα) (i : Nat) (l : List α) :
modify f i l = take i l ++ modifyHead f (drop i l)
theorem List.modify_eq_take_cons_drop {α : Type u_1} {f : αα} {i : Nat} {l : List α} (h : i < l.length) :
modify f i l = take i l ++ f l[i] :: drop (i + 1) l
theorem List.exists_of_modify {α : Type u_1} (f : αα) {i : Nat} {l : List α} (h : i < l.length) :
(l₁ : List α), (a : α), (l₂ : List α), l = l₁ ++ a :: l₂ l₁.length = i modify f i l = l₁ ++ f a :: l₂
@[simp]
theorem List.modify_id {α : Type u_1} (i : Nat) (l : List α) :
modify id i l = l
theorem List.take_modify {α : Type u_1} (f : αα) (i j : Nat) (l : List α) :
take j (modify f i l) = modify f i (take j l)
theorem List.drop_modify_of_lt {α : Type u_1} (f : αα) (i j : Nat) (l : List α) (h : i < j) :
drop j (modify f i l) = drop j l
theorem List.drop_modify_of_ge {α : Type u_1} (f : αα) (i j : Nat) (l : List α) (h : i j) :
drop j (modify f i l) = modify f (i - j) (drop j l)
theorem List.eraseIdx_modify_of_eq {α : Type u_1} (f : αα) (i : Nat) (l : List α) :
(modify f i l).eraseIdx i = l.eraseIdx i
theorem List.eraseIdx_modify_of_lt {α : Type u_1} (f : αα) (i j : Nat) (l : List α) (h : j < i) :
(modify f i l).eraseIdx j = modify f (i - 1) (l.eraseIdx j)
theorem List.eraseIdx_modify_of_gt {α : Type u_1} (f : αα) (i j : Nat) (l : List α) (h : j > i) :
(modify f i l).eraseIdx j = modify f i (l.eraseIdx j)
theorem List.modify_eraseIdx_of_lt {α : Type u_1} (f : αα) (i j : Nat) (l : List α) (h : j < i) :
modify f j (l.eraseIdx i) = (modify f j l).eraseIdx i
theorem List.modify_eraseIdx_of_ge {α : Type u_1} (f : αα) (i j : Nat) (l : List α) (h : j i) :
modify f j (l.eraseIdx i) = (modify f (j + 1) l).eraseIdx i