Bootstrapping theorems about arrays

This file contains some theorems about Array and List needed for Init.Data.List.Impl.

@[simp]

theorem Array.getElem_toList {α : Type u_1} {a : Array α} {i : Nat} (h : i < a.size) : a.toList[i] = a[i]

@[simp]

theorem Array.getElem_mk {α : Type u_1} {xs : List α} {i : Nat} (h : i < xs.length) : { toList := xs }[i] = xs[i]

theorem Array.getElem_eq_getElem_toList {α : Type u_1} {i : Nat} {a : Array α} (h : i < a.size) : a[i] = a.toList[i]

theorem Array.getElem?_eq_getElem {α : Type u_1} {a : Array α} {i : Nat} (h : i < a.size) : a[i]? = some a[i]

@[simp]

theorem Array.getElem?_eq_none_iff {α : Type u_1} {i : Nat} {a : Array α} : a[i]? = none ↔ a.size ≤ i

theorem Array.getElem?_eq {α : Type u_1} {a : Array α} {i : Nat} : a[i]? = if h : i < a.size then some a[i] else none

theorem Array.getElem?_eq_getElem?_toList {α : Type u_1} (a : Array α) (i : Nat) : a[i]? = a.toList[i]?

@[reducible, inline, deprecated Array.getElem_eq_getElem_toList]

abbrev Array.getElem_eq_toList_getElem {α : Type u_1} {i : Nat} {a : Array α} (h : i < a.size) : a[i] = a.toList[i]

Equations

• @Array.getElem_eq_toList_getElem = @Array.getElem_eq_getElem_toList

@[reducible, inline, deprecated Array.getElem_eq_toList_getElem]

abbrev Array.getElem_eq_data_getElem {α : Type u_1} {i : Nat} {a : Array α} (h : i < a.size) : a[i] = a.toList[i]

Equations

• @Array.getElem_eq_data_getElem = @Array.getElem_eq_getElem_toList

@[deprecated Array.getElem_eq_toList_getElem]

theorem Array.getElem_eq_toList_get {α : Type u_1} {i : Nat} (a : Array α) (h : i < a.size) : a[i] = a.toList.get ⟨i, h⟩

theorem Array.get_push_lt {α : Type u_1} (a : Array α) (x : α) (i : Nat) (h : i < a.size) : let_fun this := ⋯; (a.push x)[i] = a[i]

@[simp]

theorem Array.get_push_eq {α : Type u_1} (a : Array α) (x : α) : (a.push x)[a.size] = x

theorem Array.get_push {α : Type u_1} (a : Array α) (x : α) (i : Nat) (h : i < (a.push x).size) : (a.push x)[i] = if h : i < a.size then a[i] else x

Lemmas about List.toArray.

@[simp]

theorem List.size_toArrayAux {α : Type u_1} {a : List α} {b : Array α} : (a.toArrayAux b).size = b.size + a.length

@[simp]

theorem List.toArray_toList {α : Type u_1} (a : Array α) : a.toList.toArray = a

@[reducible, inline, deprecated List.toArray_toList]

abbrev List.toArray_data {α : Type u_1} (a : Array α) : a.toList.toArray = a

Equations

• @List.toArray_data = @List.toArray_toList

@[simp]

theorem List.getElem_toArray {α : Type u_1} {a : List α} {i : Nat} (h : i < a.toArray.size) : a.toArray[i] = a[i]

@[simp]

theorem List.getElem?_toArray {α : Type u_1} {a : List α} {i : Nat} : a.toArray[i]? = a[i]?

@[deprecated]

theorem List.toArray_concat {α : Type u_1} {as : List α} {x : α} : (as ++ [x]).toArray = as.toArray.push x

@[simp]

theorem List.push_toArray {α : Type u_1} (l : List α) (a : α) : l.toArray.push a = (l ++ [a]).toArray

@[simp]

theorem List.push_toArray_fun {α : Type u_1} (l : List α) : l.toArray.push = fun (a : α) => (l ++ [a]).toArray

Unapplied variant of push_toArray, useful for monadic reasoning.

theorem List.foldrM_toArray {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (f : α → β → m β) (init : β) (l : List α) : Array.foldrM f init l.toArray = List.foldrM f init l

theorem List.foldlM_toArray {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [Monad m] (f : β → α → m β) (init : β) (l : List α) : Array.foldlM f init l.toArray = List.foldlM f init l

theorem List.foldr_toArray {α : Type u_1} {β : Type u_2} (f : α → β → β) (init : β) (l : List α) : Array.foldr f init l.toArray = List.foldr f init l

theorem List.foldl_toArray {β : Type u_1} {α : Type u_2} (f : β → α → β) (init : β) (l : List α) : Array.foldl f init l.toArray = List.foldl f init l

@[simp]

theorem List.foldrM_toArray' {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} {start : Nat} [Monad m] (f : α → β → m β) (init : β) (l : List α) (h : start = l.toArray.size) : Array.foldrM f init l.toArray start = List.foldrM f init l

Variant of foldrM_toArray with a side condition for the start argument.

@[simp]

theorem List.foldlM_toArray' {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} {stop : Nat} [Monad m] (f : β → α → m β) (init : β) (l : List α) (h : stop = l.toArray.size) : Array.foldlM f init l.toArray 0 stop = List.foldlM f init l

Variant of foldlM_toArray with a side condition for the stop argument.

@[simp]

theorem List.foldr_toArray' {α : Type u_1} {β : Type u_2} {start : Nat} (f : α → β → β) (init : β) (l : List α) (h : start = l.toArray.size) : Array.foldr f init l.toArray start = List.foldr f init l

Variant of foldr_toArray with a side condition for the start argument.

@[simp]

theorem List.foldl_toArray' {β : Type u_1} {α : Type u_2} {stop : Nat} (f : β → α → β) (init : β) (l : List α) (h : stop = l.toArray.size) : Array.foldl f init l.toArray 0 stop = List.foldl f init l

Variant of foldl_toArray with a side condition for the stop argument.

@[simp]

theorem List.append_toArray {α : Type u_1} (l₁ : List α) (l₂ : List α) : l₁.toArray ++ l₂.toArray = (l₁ ++ l₂).toArray

@[simp]

theorem Array.singleton_def {α : Type u_1} (v : α) : Array.singleton v = #[v]

@[simp]

theorem Array.toArray_toList {α : Type u_1} (a : Array α) : a.toList.toArray = a

@[reducible, inline, deprecated Array.toArray_toList]

abbrev Array.toArray_data {α : Type u_1} (a : Array α) : a.toList.toArray = a

Equations

• @Array.toArray_data = @Array.toArray_toList

@[simp]

theorem Array.length_toList {α : Type u_1} {l : Array α} : l.toList.length = l.size

@[reducible, inline, deprecated Array.length_toList]

abbrev Array.data_length {α : Type u_1} {l : Array α} : l.toList.length = l.size

Equations

• @Array.data_length = @Array.length_toList

@[simp]

theorem Array.mkEmpty_eq (α : Type u_1) (n : Nat) : Array.mkEmpty n = #[]

@[simp]

theorem Array.size_mk {α : Type u_1} (as : List α) : { toList := as }.size = as.length

theorem Array.foldrM_push {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (f : α → β → m β) (init : β) (arr : Array α) (a : α) : Array.foldrM f init (arr.push a) = do let init ← f a init Array.foldrM f init arr

@[simp]

theorem Array.foldrM_push' {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (f : α → β → m β) (init : β) (arr : Array α) (a : α) : Array.foldrM f init (arr.push a) (arr.size + 1) = do let init ← f a init Array.foldrM f init arr

Variant of foldrM_push with the start := arr.size + 1 rather than (arr.push a).size.

theorem Array.foldr_push {α : Type u_1} {β : Type u_2} (f : α → β → β) (init : β) (arr : Array α) (a : α) : Array.foldr f init (arr.push a) = Array.foldr f (f a init) arr

@[simp]

theorem Array.foldr_push' {α : Type u_1} {β : Type u_2} (f : α → β → β) (init : β) (arr : Array α) (a : α) : Array.foldr f init (arr.push a) (arr.size + 1) = Array.foldr f (f a init) arr

Variant of foldr_push with the start := arr.size + 1 rather than (arr.push a).size.

@[inline]

def Array.toListRev {α : Type u_1} (arr : Array α) : List α

A more efficient version of arr.toList.reverse.

Equations

• arr.toListRev = Array.foldl (fun (l : List α) (t : α) => t :: l) [] arr

@[simp]

theorem Array.toListRev_eq {α : Type u_1} (arr : Array α) : arr.toListRev = arr.toList.reverse

theorem Array.mapM_eq_foldlM {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] (f : α → m β) (arr : Array α) : Array.mapM f arr = Array.foldlM (fun (bs : Array β) (a : α) => bs.push <$> f a) #[] arr

@[irreducible]

theorem Array.mapM_eq_foldlM.aux {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] (f : α → m β) (arr : Array α) (i : Nat) (r : Array β) : Array.mapM.map f arr i r = List.foldlM (fun (bs : Array β) (a : α) => bs.push <$> f a) r (List.drop i arr.toList)

@[simp]

theorem Array.toList_map {α : Type u_1} {β : Type u_2} (f : α → β) (arr : Array α) : (Array.map f arr).toList = List.map f arr.toList

@[reducible, inline, deprecated Array.toList_map]

abbrev Array.map_data {α : Type u_1} {β : Type u_2} (f : α → β) (arr : Array α) : (Array.map f arr).toList = List.map f arr.toList

Equations

• @Array.map_data = @Array.toList_map

@[simp]

theorem Array.size_map {α : Type u_1} {β : Type u_2} (f : α → β) (arr : Array α) : (Array.map f arr).size = arr.size

@[simp]

theorem Array.appendList_nil {α : Type u_1} (arr : Array α) : arr ++ [] = arr

@[simp]

theorem Array.appendList_cons {α : Type u_1} (arr : Array α) (a : α) (l : List α) : arr ++ a :: l = arr.push a ++ l

@[simp]

theorem Array.toList_appendList {α : Type u_1} (arr : Array α) (l : List α) : (arr ++ l).toList = arr.toList ++ l

theorem Array.foldl_toList_eq_bind {α : Type u_1} {β : Type u_2} (l : List α) (acc : Array β) (F : Array β → α → Array β) (G : α → List β) (H : ∀ (acc : Array β) (a : α), (F acc a).toList = acc.toList ++ G a) : (List.foldl F acc l).toList = acc.toList ++ l.bind G

@[reducible, inline, deprecated Array.foldl_toList_eq_bind]

abbrev Array.foldl_data_eq_bind {α : Type u_1} {β : Type u_2} (l : List α) (acc : Array β) (F : Array β → α → Array β) (G : α → List β) (H : ∀ (acc : Array β) (a : α), (F acc a).toList = acc.toList ++ G a) : (List.foldl F acc l).toList = acc.toList ++ l.bind G

Equations

• @Array.foldl_data_eq_bind = @Array.foldl_toList_eq_bind

theorem Array.foldl_toList_eq_map {α : Type u_1} {β : Type u_2} (l : List α) (acc : Array β) (G : α → β) : (List.foldl (fun (acc : Array β) (a : α) => acc.push (G a)) acc l).toList = acc.toList ++ List.map G l

@[reducible, inline, deprecated Array.foldl_toList_eq_map]

abbrev Array.foldl_data_eq_map {α : Type u_1} {β : Type u_2} (l : List α) (acc : Array β) (G : α → β) : (List.foldl (fun (acc : Array β) (a : α) => acc.push (G a)) acc l).toList = acc.toList ++ List.map G l

Equations

• @Array.foldl_data_eq_map = @Array.foldl_toList_eq_map

theorem Array.size_uset {α : Type u_1} (a : Array α) (v : α) (i : USize) (h : i.toNat < a.size) : (a.uset i v h).size = a.size

theorem Array.anyM_eq_anyM_loop {m : Type → Type u_1} {α : Type u_2} [Monad m] (p : α → m Bool) (as : Array α) (start : Nat) (stop : Nat) : Array.anyM p as start stop = Array.anyM.loop p as (min stop as.size) ⋯ start

theorem Array.anyM_stop_le_start {m : Type → Type u_1} {α : Type u_2} [Monad m] (p : α → m Bool) (as : Array α) (start : Nat) (stop : Nat) (h : min stop as.size ≤ start) : Array.anyM p as start stop = pure false

theorem Array.mem_def {α : Type u_1} {a : α} {as : Array α} : a ∈ as ↔ a ∈ as.toList

@[simp]

theorem Array.not_mem_empty {α : Type u_1} (a : α) : ¬a ∈ #[]

get

@[simp]

theorem Array.get_eq_getElem {α : Type u_1} (a : Array α) (i : Fin a.size) : a.get i = a[↑i]

theorem Array.getElem?_lt {α : Type u_1} (a : Array α) {i : Nat} (h : i < a.size) : a[i]? = some a[i]

theorem Array.getElem?_ge {α : Type u_1} (a : Array α) {i : Nat} (h : i ≥ a.size) : a[i]? = none

@[simp]

theorem Array.get?_eq_getElem? {α : Type u_1} (a : Array α) (i : Nat) : a.get? i = a[i]?

theorem Array.getElem?_len_le {α : Type u_1} (a : Array α) {i : Nat} (h : a.size ≤ i) : a[i]? = none

theorem Array.getD_get? {α : Type u_1} (a : Array α) (i : Nat) (d : α) : a[i]?.getD d = if p : i < a.size then a[i] else d

@[simp]

theorem Array.getD_eq_get? {α : Type u_1} (a : Array α) (n : Nat) (d : α) : a.getD n d = a[n]?.getD d

theorem Array.get!_eq_getD {α : Type u_1} {n : Nat} [Inhabited α] (a : Array α) : a.get! n = a.getD n default

@[simp]

theorem Array.get!_eq_getElem? {α : Type u_1} [Inhabited α] (a : Array α) (i : Nat) : a.get! i = (a.get? i).getD default

set

@[simp]

theorem Array.getElem_set_eq {α : Type u_1} (a : Array α) (i : Fin a.size) (v : α) {j : Nat} (eq : ↑i = j) (p : j < (a.set i v).size) : (a.set i v)[j] = v

@[simp]

theorem Array.getElem_set_ne {α : Type u_1} (a : Array α) (i : Fin a.size) (v : α) {j : Nat} (pj : j < (a.set i v).size) (h : ↑i ≠ j) : (a.set i v)[j] = a[j]

theorem Array.getElem_set {α : Type u_1} (a : Array α) (i : Fin a.size) (v : α) (j : Nat) (h : j < (a.set i v).size) : (a.set i v)[j] = if ↑i = j then v else a[j]

@[simp]

theorem Array.getElem?_set_eq {α : Type u_1} (a : Array α) (i : Fin a.size) (v : α) : (a.set i v)[↑i]? = some v

@[simp]

theorem Array.getElem?_set_ne {α : Type u_1} (a : Array α) (i : Fin a.size) {j : Nat} (v : α) (ne : ↑i ≠ j) : (a.set i v)[j]? = a[j]?

setD

@[simp]

theorem Array.set!_is_setD : @Array.set! = @Array.setD

@[simp]

theorem Array.size_setD {α : Type u_1} (a : Array α) (index : Nat) (val : α) : (a.setD index val).size = a.size

@[simp]

theorem Array.getElem_setD_eq {α : Type u_1} (a : Array α) {i : Nat} (v : α) (h : i < (a.setD i v).size) : (a.setD i v)[i] = v

@[simp]

theorem Array.getElem?_setD_eq {α : Type u_1} (a : Array α) {i : Nat} (p : i < a.size) (v : α) : (a.setD i v)[i]? = some v

@[simp]

theorem Array.getD_get?_setD {α : Type u_1} (a : Array α) (i : Nat) (v : α) (d : α) : (a.setD i v)[i]?.getD d = if i < a.size then v else d

Simplifies a normal form from get!

ofFn

@[simp, irreducible]

theorem Array.size_ofFn_go {α : Type u_1} {n : Nat} (f : Fin n → α) (i : Nat) (acc : Array α) : (Array.ofFn.go f i acc).size = acc.size + (n - i)

@[simp]

theorem Array.size_ofFn {n : Nat} {α : Type u_1} (f : Fin n → α) : (Array.ofFn f).size = n

@[irreducible]

theorem Array.getElem_ofFn_go {n : Nat} {α : Type u_1} (f : Fin n → α) (i : Nat) {acc : Array α} {k : Nat} (hki : k < n) (hin : i ≤ n) (hi : i = acc.size) (hacc : ∀ (j : Nat) (hj : j < acc.size), acc[j] = f ⟨j, ⋯⟩) : (Array.ofFn.go f i acc)[k] = f ⟨k, hki⟩

@[simp]

theorem Array.getElem_ofFn {n : Nat} {α : Type u_1} (f : Fin n → α) (i : Nat) (h : i < (Array.ofFn f).size) : (Array.ofFn f)[i] = f ⟨i, ⋯⟩

@[simp]

theorem Array.size_mkArray {α : Type u_1} (n : Nat) (v : α) : (mkArray n v).size = n

mkArray

@[simp]

theorem Array.toList_mkArray {α : Type u_1} (n : Nat) (v : α) : (mkArray n v).toList = List.replicate n v

@[reducible, inline, deprecated Array.toList_mkArray]

abbrev Array.mkArray_data {α : Type u_1} (n : Nat) (v : α) : (mkArray n v).toList = List.replicate n v

Equations

• @Array.mkArray_data = @Array.toList_mkArray

@[simp]

theorem Array.getElem_mkArray {α : Type u_1} {i : Nat} (n : Nat) (v : α) (h : i < (mkArray n v).size) : (mkArray n v)[i] = v

theorem Array.mem_toList {α : Type u_1} {a : α} {l : Array α} : a ∈ l.toList ↔ a ∈ l

mem

@[reducible, inline, deprecated Array.mem_toList]

abbrev Array.mem_data {α : Type u_1} {a : α} {l : Array α} : a ∈ l.toList ↔ a ∈ l

Equations

• @Array.mem_data = @Array.mem_toList

theorem Array.not_mem_nil {α : Type u_1} (a : α) : ¬a ∈ #[]

theorem Array.getElem_of_mem {α : Type u_1} {a : α} {as : Array α} : a ∈ as → ∃ (n : Nat), ∃ (h : n < as.size), as[n] = a

@[simp]

theorem Array.mem_dite_empty_left {α : Type u_1} {p : Prop} {x : α} [Decidable p] {l : ¬p → Array α} : (x ∈ if h : p then #[] else l h) ↔ ∃ (h : ¬p), x ∈ l h

@[simp]

theorem Array.mem_dite_empty_right {α : Type u_1} {p : Prop} {x : α} [Decidable p] {l : p → Array α} : (x ∈ if h : p then l h else #[]) ↔ ∃ (h : p), x ∈ l h

@[simp]

theorem Array.mem_ite_empty_left {α : Type u_1} {p : Prop} {x : α} [Decidable p] {l : Array α} : (x ∈ if p then #[] else l) ↔ ¬p ∧ x ∈ l

@[simp]

theorem Array.mem_ite_empty_right {α : Type u_1} {p : Prop} {x : α} [Decidable p] {l : Array α} : (x ∈ if p then l else #[]) ↔ p ∧ x ∈ l

theorem Array.lt_of_getElem {α : Type u_1} {x : α} {a : Array α} {idx : Nat} {hidx : idx < a.size} : a[idx] = x → idx < a.size

get lemmas

theorem Array.getElem?_mem {α : Type u_1} {l : Array α} {i : Fin l.size} : l[i] ∈ l

theorem Array.getElem_fin_eq_toList_get {α : Type u_1} (a : Array α) (i : Fin a.toList.length) : a[i] = a.toList.get i

@[reducible, inline, deprecated Array.getElem_fin_eq_toList_get]

abbrev Array.getElem_fin_eq_data_get {α : Type u_1} (a : Array α) (i : Fin a.toList.length) : a[i] = a.toList.get i

Equations

• @Array.getElem_fin_eq_data_get = @Array.getElem_fin_eq_toList_get

@[simp]

theorem Array.ugetElem_eq_getElem {α : Type u_1} (a : Array α) {i : USize} (h : i.toNat < a.size) : a[i] = a[i.toNat]

theorem Array.get?_len_le {α : Type u_1} (a : Array α) (i : Nat) (h : a.size ≤ i) : a[i]? = none

theorem Array.getElem_mem_toList {α : Type u_1} {i : Nat} (a : Array α) (h : i < a.size) : a[i] ∈ a.toList

@[reducible, inline, deprecated Array.getElem_mem_toList]

abbrev Array.getElem_mem_data {α : Type u_1} {i : Nat} (a : Array α) (h : i < a.size) : a[i] ∈ a.toList

Equations

• @Array.getElem_mem_data = @Array.getElem_mem_toList

theorem Array.getElem?_eq_toList_getElem? {α : Type u_1} (a : Array α) (i : Nat) : a[i]? = a.toList[i]?

@[deprecated Array.getElem?_eq_toList_getElem?]

theorem Array.getElem?_eq_toList_get? {α : Type u_1} (a : Array α) (i : Nat) : a[i]? = a.toList.get? i

@[reducible, inline, deprecated Array.getElem?_eq_toList_getElem?]

abbrev Array.getElem?_eq_data_get? {α : Type u_1} (a : Array α) (i : Nat) : a[i]? = a.toList.get? i

Equations

• @Array.getElem?_eq_data_get? = @Array.getElem?_eq_toList_get?

theorem Array.get?_eq_toList_get? {α : Type u_1} (a : Array α) (i : Nat) : a.get? i = a.toList.get? i

@[reducible, inline, deprecated Array.get?_eq_toList_get?]

abbrev Array.get?_eq_data_get? {α : Type u_1} (a : Array α) (i : Nat) : a.get? i = a.toList.get? i

Equations

• @Array.get?_eq_data_get? = @Array.get?_eq_toList_get?

theorem Array.get!_eq_get? {α : Type u_1} {n : Nat} [Inhabited α] (a : Array α) : a.get! n = (a.get? n).getD default

theorem Array.getElem?_eq_some_iff {α : Type u_1} {n : Nat} {a : α} {as : Array α} : as[n]? = some a ↔ ∃ (h : n < as.size), as[n] = a

@[simp]

theorem Array.back_eq_back? {α : Type u_1} [Inhabited α] (a : Array α) : a.back = a.back?.getD default

@[simp]

theorem Array.back?_push {α : Type u_1} {x : α} (a : Array α) : (a.push x).back? = some x

theorem Array.back_push {α : Type u_1} {x : α} [Inhabited α] (a : Array α) : (a.push x).back = x

theorem Array.get?_push_lt {α : Type u_1} (a : Array α) (x : α) (i : Nat) (h : i < a.size) : (a.push x)[i]? = some a[i]

theorem Array.get?_push_eq {α : Type u_1} (a : Array α) (x : α) : (a.push x)[a.size]? = some x

theorem Array.get?_push {α : Type u_1} {x : α} {i : Nat} {a : Array α} : (a.push x)[i]? = if i = a.size then some x else a[i]?

@[simp]

theorem Array.get?_size {α : Type u_1} {a : Array α} : a[a.size]? = none

@[simp]

theorem Array.toList_set {α : Type u_1} (a : Array α) (i : Fin a.size) (v : α) : (a.set i v).toList = a.toList.set (↑i) v

@[reducible, inline, deprecated Array.toList_set]

abbrev Array.data_set {α : Type u_1} (a : Array α) (i : Fin a.size) (v : α) : (a.set i v).toList = a.toList.set (↑i) v

Equations

• @Array.data_set = @Array.toList_set

theorem Array.get_set_eq {α : Type u_1} (a : Array α) (i : Fin a.size) (v : α) : (a.set i v)[↑i] = v

theorem Array.get?_set_eq {α : Type u_1} (a : Array α) (i : Fin a.size) (v : α) : (a.set i v)[↑i]? = some v

@[simp]

theorem Array.get?_set_ne {α : Type u_1} (a : Array α) (i : Fin a.size) {j : Nat} (v : α) (h : ↑i ≠ j) : (a.set i v)[j]? = a[j]?

theorem Array.get?_set {α : Type u_1} (a : Array α) (i : Fin a.size) (j : Nat) (v : α) : (a.set i v)[j]? = if ↑i = j then some v else a[j]?

theorem Array.get_set {α : Type u_1} (a : Array α) (i : Fin a.size) (j : Nat) (hj : j < a.size) (v : α) : (a.set i v)[j] = if ↑i = j then v else a[j]

@[simp]

theorem Array.get_set_ne {α : Type u_1} (a : Array α) (i : Fin a.size) {j : Nat} (v : α) (hj : j < a.size) (h : ↑i ≠ j) : (a.set i v)[j] = a[j]

theorem Array.getElem_setD {α : Type u_1} (a : Array α) (i : Nat) (v : α) (h : i < (a.setD i v).size) : (a.setD i v)[i] = v

theorem Array.set_set {α : Type u_1} (a : Array α) (i : Fin a.size) (v : α) (v' : α) : (a.set i v).set ⟨↑i, ⋯⟩ v' = a.set i v'

theorem Array.swap_def {α : Type u_1} (a : Array α) (i : Fin a.size) (j : Fin a.size) : a.swap i j = (a.set i (a.get j)).set ⟨↑j, ⋯⟩ (a.get i)

@[simp]

theorem Array.toList_swap {α : Type u_1} (a : Array α) (i : Fin a.size) (j : Fin a.size) : (a.swap i j).toList = (a.toList.set (↑i) (a.get j)).set (↑j) (a.get i)

@[reducible, inline, deprecated Array.toList_swap]

abbrev Array.data_swap {α : Type u_1} (a : Array α) (i : Fin a.size) (j : Fin a.size) : (a.swap i j).toList = (a.toList.set (↑i) (a.get j)).set (↑j) (a.get i)

Equations

• @Array.data_swap = @Array.toList_swap

theorem Array.get?_swap {α : Type u_1} (a : Array α) (i : Fin a.size) (j : Fin a.size) (k : Nat) : (a.swap i j)[k]? = if ↑j = k then some a[↑i] else if ↑i = k then some a[↑j] else a[k]?

@[simp]

theorem Array.swapAt_def {α : Type u_1} (a : Array α) (i : Fin a.size) (v : α) : a.swapAt i v = (a[↑i], a.set i v)

@[simp]

theorem Array.swapAt!_def {α : Type u_1} (a : Array α) (i : Nat) (v : α) (h : i < a.size) : a.swapAt! i v = (a[i], a.set ⟨i, h⟩ v)

@[simp]

theorem Array.toList_pop {α : Type u_1} (a : Array α) : a.pop.toList = a.toList.dropLast

@[reducible, inline, deprecated Array.toList_pop]

abbrev Array.data_pop {α : Type u_1} (a : Array α) : a.pop.toList = a.toList.dropLast

Equations

• @Array.data_pop = @Array.toList_pop

@[simp]

theorem Array.pop_empty {α : Type u_1} : #[].pop = #[]

@[simp]

theorem Array.pop_push {α : Type u_1} {x : α} (a : Array α) : (a.push x).pop = a

@[simp]

theorem Array.getElem_pop {α : Type u_1} (a : Array α) (i : Nat) (hi : i < a.pop.size) : a.pop[i] = a[i]

theorem Array.eq_empty_of_size_eq_zero {α : Type u_1} {as : Array α} (h : as.size = 0) : as = #[]

theorem Array.eq_push_pop_back_of_size_ne_zero {α : Type u_1} [Inhabited α] {as : Array α} (h : as.size ≠ 0) : as = as.pop.push as.back

theorem Array.eq_push_of_size_ne_zero {α : Type u_1} {as : Array α} (h : as.size ≠ 0) : ∃ (bs : Array α), ∃ (c : α), as = bs.push c

theorem Array.size_eq_length_toList {α : Type u_1} (as : Array α) : as.size = as.toList.length

@[reducible, inline, deprecated Array.size_eq_length_toList]

abbrev Array.size_eq_length_data {α : Type u_1} (as : Array α) : as.size = as.toList.length

Equations

• @Array.size_eq_length_data = @Array.size_eq_length_toList

@[simp]

theorem Array.size_swap! {α : Type u_1} (a : Array α) (i : Nat) (j : Nat) : (a.swap! i j).size = a.size

@[simp]

theorem Array.size_reverse {α : Type u_1} (a : Array α) : a.reverse.size = a.size

@[irreducible]

theorem Array.size_reverse.go {α : Type u_1} (as : Array α) (i : Nat) (j : Fin as.size) : (Array.reverse.loop as i j).size = as.size

@[simp]

theorem Array.size_range {n : Nat} : (Array.range n).size = n

@[simp]

theorem Array.toList_range (n : Nat) : (Array.range n).toList = List.range n

@[reducible, inline, deprecated Array.toList_range]

abbrev Array.data_range (n : Nat) : (Array.range n).toList = List.range n

Equations

• Array.data_range = Array.toList_range

@[simp]

theorem Array.getElem_range {n : Nat} {x : Nat} (h : x < (Array.range n).size) : (Array.range n)[x] = x

@[simp]

theorem Array.toList_reverse {α : Type u_1} (a : Array α) : a.reverse.toList = a.toList.reverse

@[irreducible]

theorem Array.toList_reverse.go {α : Type u_1} (a : Array α) (as : Array α) (i : Nat) (j : Nat) (hj : j < as.size) (h : i + j + 1 = a.size) (h₂ : as.size = a.size) (H : ∀ (k : Nat), as.toList[k]? = if i ≤ k ∧ k ≤ j then a.toList[k]? else a.toList.reverse[k]?) (k : Nat) : (Array.reverse.loop as i ⟨j, hj⟩).toList[k]? = a.toList.reverse[k]?

@[reducible, inline, deprecated Array.toList_reverse]

abbrev Array.reverse_toList {α : Type u_1} (a : Array α) : a.reverse.toList = a.toList.reverse

Equations

• @Array.reverse_toList = @Array.toList_reverse

foldl / foldr

@[simp]

theorem Array.foldlM_loop_empty {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} {s : Nat} {h : s ≤ #[].size} [Monad m] (f : β → α → m β) (init : β) (i : Nat) (j : Nat) : Array.foldlM.loop f #[] s h i j init = pure init

@[simp]

theorem Array.foldlM_empty {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} {start : Nat} {stop : Nat} [Monad m] (f : β → α → m β) (init : β) : Array.foldlM f init #[] start stop = pure init

@[simp]

theorem Array.foldrM_fold_empty {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] (f : α → β → m β) (init : β) (i : Nat) (j : Nat) (h : j ≤ #[].size) : Array.foldrM.fold f #[] i j h init = pure init

@[simp]

theorem Array.foldrM_empty {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} {start : Nat} {stop : Nat} [Monad m] (f : α → β → m β) (init : β) : Array.foldrM f init #[] start stop = pure init

theorem Array.foldl_induction {α : Type u_1} {β : Type u_2} {as : Array α} (motive : Nat → β → Prop) {init : β} (h0 : motive 0 init) {f : β → α → β} (hf : ∀ (i : Fin as.size) (b : β), motive (↑i) b → motive (↑i + 1) (f b as[i])) : motive as.size (Array.foldl f init as)

@[irreducible]

theorem Array.foldl_induction.go {α : Type u_1} {β : Type u_2} {as : Array α} (motive : Nat → β → Prop) {f : β → α → β} (hf : ∀ (i : Fin as.size) (b : β), motive (↑i) b → motive (↑i + 1) (f b as[i])) {i : Nat} {j : Nat} {b : β} (h₁ : j ≤ as.size) (h₂ : as.size ≤ i + j) (H : motive j b) : motive as.size (Array.foldlM.loop f as as.size ⋯ i j b)

theorem Array.foldr_induction {α : Type u_1} {β : Type u_2} {as : Array α} (motive : Nat → β → Prop) {init : β} (h0 : motive as.size init) {f : α → β → β} (hf : ∀ (i : Fin as.size) (b : β), motive (↑i + 1) b → motive (↑i) (f as[i] b)) : motive 0 (Array.foldr f init as)

@[irreducible]

theorem Array.foldr_induction.go {α : Type u_1} {β : Type u_2} {as : Array α} (motive : Nat → β → Prop) {f : α → β → β} (hf : ∀ (i : Fin as.size) (b : β), motive (↑i + 1) b → motive (↑i) (f as[i] b)) {i : Nat} {b : β} (hi : i ≤ as.size) (H : motive i b) : motive 0 (Array.foldrM.fold f as 0 i hi b)

theorem Array.foldl_congr {α : Type u_1} {β : Type u_2} {as : Array α} {bs : Array α} (h₀ : as = bs) {f : β → α → β} {g : β → α → β} (h₁ : f = g) {a : β} {b : β} (h₂ : a = b) {start : Nat} {start' : Nat} {stop : Nat} {stop' : Nat} (h₃ : start = start') (h₄ : stop = stop') : Array.foldl f a as start stop = Array.foldl g b bs start' stop'

theorem Array.foldr_congr {α : Type u_1} {β : Type u_2} {as : Array α} {bs : Array α} (h₀ : as = bs) {f : α → β → β} {g : α → β → β} (h₁ : f = g) {a : β} {b : β} (h₂ : a = b) {start : Nat} {start' : Nat} {stop : Nat} {stop' : Nat} (h₃ : start = start') (h₄ : stop = stop') : Array.foldr f a as start stop = Array.foldr g b bs start' stop'

map

@[simp]

theorem Array.mem_map {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : Array α} : b ∈ Array.map f l ↔ ∃ (a : α), a ∈ l ∧ f a = b

theorem Array.mapM_eq_mapM_toList {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] (f : α → m β) (arr : Array α) : Array.mapM f arr = List.toArray <$> List.mapM f arr.toList

@[simp]

theorem Array.toList_mapM {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] (f : α → m β) (arr : Array α) : Array.toList <$> Array.mapM f arr = List.mapM f arr.toList

@[reducible, inline, deprecated Array.mapM_eq_mapM_toList]

abbrev Array.mapM_eq_mapM_data {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] (f : α → m β) (arr : Array α) : Array.mapM f arr = List.toArray <$> List.mapM f arr.toList

Equations

• @Array.mapM_eq_mapM_data = @Array.mapM_eq_mapM_toList

@[irreducible]

theorem Array.mapM_map_eq_foldl {α : Type u_1} {β : Type u_2} {b : Array β} (as : Array α) (f : α → β) (i : Nat) : Array.mapM.map f as i b = Array.foldl (fun (r : Array β) (a : α) => r.push (f a)) b as i

theorem Array.map_eq_foldl {α : Type u_1} {β : Type u_2} (as : Array α) (f : α → β) : Array.map f as = Array.foldl (fun (r : Array β) (a : α) => r.push (f a)) #[] as

theorem Array.map_induction {α : Type u_1} {β : Type u_2} (as : Array α) (f : α → β) (motive : Nat → Prop) (h0 : motive 0) (p : Fin as.size → β → Prop) (hs : ∀ (i : Fin as.size), motive ↑i → p i (f as[i]) ∧ motive (↑i + 1)) : motive as.size ∧ ∃ (eq : (Array.map f as).size = as.size), ∀ (i : Nat) (h : i < as.size), p ⟨i, h⟩ (Array.map f as)[i]

theorem Array.map_spec {α : Type u_1} {β : Type u_2} (as : Array α) (f : α → β) (p : Fin as.size → β → Prop) (hs : ∀ (i : Fin as.size), p i (f as[i])) : ∃ (eq : (Array.map f as).size = as.size), ∀ (i : Nat) (h : i < as.size), p ⟨i, h⟩ (Array.map f as)[i]

@[simp]

theorem Array.getElem_map {α : Type u_1} {β : Type u_2} (f : α → β) (as : Array α) (i : Nat) (h : i < (Array.map f as).size) : (Array.map f as)[i] = f as[i]

@[simp]

theorem Array.getElem?_map {α : Type u_1} {β : Type u_2} (f : α → β) (as : Array α) (i : Nat) : (Array.map f as)[i]? = Option.map f as[i]?

@[simp]

theorem Array.map_push {α : Type u_1} {β : Type u_2} {f : α → β} {as : Array α} {x : α} : Array.map f (as.push x) = (Array.map f as).push (f x)

mapIdx

theorem Array.mapIdx_induction {α : Type u_1} {β : Type u_2} (as : Array α) (f : Fin as.size → α → β) (motive : Nat → Prop) (h0 : motive 0) (p : Fin as.size → β → Prop) (hs : ∀ (i : Fin as.size), motive ↑i → p i (f i as[i]) ∧ motive (↑i + 1)) : motive as.size ∧ ∃ (eq : (as.mapIdx f).size = as.size), ∀ (i : Nat) (h : i < as.size), p ⟨i, h⟩ (as.mapIdx f)[i]

theorem Array.mapIdx_induction.go {α : Type u_1} {β : Type u_2} (as : Array α) (f : Fin as.size → α → β) (motive : Nat → Prop) (p : Fin as.size → β → Prop) (hs : ∀ (i : Fin as.size), motive ↑i → p i (f i as[i]) ∧ motive (↑i + 1)) {bs : Array β} {i : Nat} {j : Nat} {h : i + j = as.size} (h₁ : j = bs.size) (h₂ : ∀ (i : Nat) (h : i < as.size) (h' : i < bs.size), p ⟨i, h⟩ bs[i]) (hm : motive j) : let arr := Array.mapIdxM.map as f i j h bs; motive as.size ∧ ∃ (eq : arr.size = as.size), ∀ (i_1 : Nat) (h : i_1 < as.size), p ⟨i_1, h⟩ arr[i_1]

theorem Array.mapIdx_spec {α : Type u_1} {β : Type u_2} (as : Array α) (f : Fin as.size → α → β) (p : Fin as.size → β → Prop) (hs : ∀ (i : Fin as.size), p i (f i as[i])) : ∃ (eq : (as.mapIdx f).size = as.size), ∀ (i : Nat) (h : i < as.size), p ⟨i, h⟩ (as.mapIdx f)[i]

@[simp]

theorem Array.size_mapIdx {α : Type u_1} {β : Type u_2} (a : Array α) (f : Fin a.size → α → β) : (a.mapIdx f).size = a.size

@[simp]

theorem Array.size_zipWithIndex {α : Type u_1} (as : Array α) : as.zipWithIndex.size = as.size

@[simp]

theorem Array.getElem_mapIdx {α : Type u_1} {β : Type u_2} (a : Array α) (f : Fin a.size → α → β) (i : Nat) (h : i < (a.mapIdx f).size) : (a.mapIdx f)[i] = f ⟨i, ⋯⟩ a[i]

@[simp]

theorem Array.getElem?_mapIdx {α : Type u_1} {β : Type u_2} (a : Array α) (f : Fin a.size → α → β) (i : Nat) : (a.mapIdx f)[i]? = a[i]?.pbind fun (b : α) (h : b ∈ a[i]?) => some (f ⟨i, ⋯⟩ b)

modify

@[simp]

theorem Array.size_modify {α : Type u_1} (a : Array α) (i : Nat) (f : α → α) : (a.modify i f).size = a.size

theorem Array.getElem_modify {α : Type u_1} {f : α → α} {as : Array α} {x : Nat} {i : Nat} (h : i < (as.modify x f).size) : (as.modify x f)[i] = if x = i then f as[i] else as[i]

theorem Array.getElem_modify_self {α : Type u_1} {as : Array α} {i : Nat} (f : α → α) (h : i < (as.modify i f).size) : (as.modify i f)[i] = f as[i]

theorem Array.getElem_modify_of_ne {α : Type u_1} {j : Nat} {as : Array α} {i : Nat} (h : i ≠ j) (f : α → α) (hj : j < (as.modify i f).size) : (as.modify i f)[j] = as[j]

@[deprecated Array.getElem_modify]

theorem Array.get_modify {α : Type u_1} {f : α → α} {arr : Array α} {x : Nat} {i : Nat} (h : i < (arr.modify x f).size) : (arr.modify x f).get ⟨i, h⟩ = if x = i then f (arr.get ⟨i, ⋯⟩) else arr.get ⟨i, ⋯⟩

filter

@[simp]

theorem Array.toList_filter {α : Type u_1} (p : α → Bool) (l : Array α) : (Array.filter p l).toList = List.filter p l.toList

@[reducible, inline, deprecated Array.toList_filter]

abbrev Array.filter_data {α : Type u_1} (p : α → Bool) (l : Array α) : (Array.filter p l).toList = List.filter p l.toList

Equations

• @Array.filter_data = @Array.toList_filter

@[simp]

theorem Array.filter_filter {α : Type u_1} {p : α → Bool} (q : α → Bool) (l : Array α) : Array.filter p (Array.filter q l) = Array.filter (fun (a : α) => p a && q a) l

@[simp]

theorem Array.mem_filter : ∀ {α : Type u_1} {p : α → Bool} {as : Array α} {x : α}, x ∈ Array.filter p as ↔ x ∈ as ∧ p x = true

theorem Array.mem_of_mem_filter {α : Type u_1} {p : α → Bool} {a : α} {l : Array α} (h : a ∈ Array.filter p l) : a ∈ l

theorem Array.filter_congr {α : Type u_1} {as : Array α} {bs : Array α} (h : as = bs) {f : α → Bool} {g : α → Bool} (h' : f = g) {start : Nat} {stop : Nat} {start' : Nat} {stop' : Nat} (h₁ : start = start') (h₂ : stop = stop') : Array.filter f as start stop = Array.filter g bs start' stop'

filterMap

@[simp]

theorem Array.toList_filterMap {α : Type u_1} {β : Type u_2} (f : α → Option β) (l : Array α) : (Array.filterMap f l).toList = List.filterMap f l.toList

@[reducible, inline, deprecated Array.toList_filterMap]

abbrev Array.filterMap_data {α : Type u_1} {β : Type u_2} (f : α → Option β) (l : Array α) : (Array.filterMap f l).toList = List.filterMap f l.toList

Equations

• @Array.filterMap_data = @Array.toList_filterMap

@[simp]

theorem Array.mem_filterMap {α : Type u_1} {β : Type u_2} {f : α → Option β} {l : Array α} {b : β} : b ∈ Array.filterMap f l ↔ ∃ (a : α), a ∈ l ∧ f a = some b

theorem Array.filterMap_congr {α : Type u_1} {β : Type u_2} {as : Array α} {bs : Array α} (h : as = bs) {f : α → Option β} {g : α → Option β} (h' : f = g) {start : Nat} {stop : Nat} {start' : Nat} {stop' : Nat} (h₁ : start = start') (h₂ : stop = stop') : Array.filterMap f as start stop = Array.filterMap g bs start' stop'

empty

theorem Array.size_empty {α : Type u_1} : #[].size = 0

theorem Array.toList_empty {α : Type u_1} : #[].toList = []

@[reducible, inline, deprecated Array.toList_empty]

abbrev Array.empty_data {α : Type u_1} : #[].toList = []

Equations

• @Array.empty_data = @Array.toList_empty

append

theorem Array.push_eq_append_singleton {α : Type u_1} (as : Array α) (x : α) : as.push x = as ++ #[x]

@[simp]

theorem Array.mem_append {α : Type u_1} {a : α} {s : Array α} {t : Array α} : a ∈ s ++ t ↔ a ∈ s ∨ a ∈ t

@[simp]

theorem Array.size_append {α : Type u_1} (as : Array α) (bs : Array α) : (as ++ bs).size = as.size + bs.size

theorem Array.getElem_append {α : Type u_1} {i : Nat} {as : Array α} {bs : Array α} (h : i < (as ++ bs).size) : (as ++ bs)[i] = if h' : i < as.size then as[i] else bs[i - as.size]

theorem Array.getElem_append_left {α : Type u_1} {i : Nat} {as : Array α} {bs : Array α} {h : i < (as ++ bs).size} (hlt : i < as.size) : (as ++ bs)[i] = as[i]

@[reducible, inline, deprecated Array.getElem_append_left]

abbrev Array.get_append_left {α : Type u_1} {i : Nat} {as : Array α} {bs : Array α} {h : i < (as ++ bs).size} (hlt : i < as.size) : (as ++ bs)[i] = as[i]

Equations

• @Array.get_append_left = @Array.getElem_append_left

theorem Array.getElem_append_right {α : Type u_1} {i : Nat} {as : Array α} {bs : Array α} {h : i < (as ++ bs).size} (hle : as.size ≤ i) (hlt : optParam (i - as.size < bs.size) ⋯) : (as ++ bs)[i] = bs[i - as.size]

@[reducible, inline, deprecated Array.getElem_append_right]

abbrev Array.get_append_right {α : Type u_1} {i : Nat} {as : Array α} {bs : Array α} {h : i < (as ++ bs).size} (hle : as.size ≤ i) (hlt : optParam (i - as.size < bs.size) ⋯) : (as ++ bs)[i] = bs[i - as.size]

Equations

• @Array.get_append_right = @Array.getElem_append_right

@[simp]

theorem Array.append_nil {α : Type u_1} (as : Array α) : as ++ #[] = as

@[simp]

theorem Array.nil_append {α : Type u_1} (as : Array α) : #[] ++ as = as

theorem Array.append_assoc {α : Type u_1} (as : Array α) (bs : Array α) (cs : Array α) : as ++ bs ++ cs = as ++ (bs ++ cs)

flatten

@[simp]

theorem Array.toList_flatten {α : Type u_1} {l : Array (Array α)} : l.flatten.toList = (List.map Array.toList l.toList).join

theorem Array.mem_flatten {α : Type u_1} {a : α} {L : Array (Array α)} : a ∈ L.flatten ↔ ∃ (l : Array α), l ∈ L ∧ a ∈ l

extract

theorem Array.extract_loop_zero {α : Type u_1} (as : Array α) (bs : Array α) (start : Nat) : Array.extract.loop as 0 start bs = bs

theorem Array.extract_loop_succ {α : Type u_1} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) (h : start < as.size) : Array.extract.loop as (size + 1) start bs = Array.extract.loop as size (start + 1) (bs.push as[start])

theorem Array.extract_loop_of_ge {α : Type u_1} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) (h : start ≥ as.size) : Array.extract.loop as size start bs = bs

theorem Array.extract_loop_eq_aux {α : Type u_1} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) : Array.extract.loop as size start bs = bs ++ Array.extract.loop as size start #[]

theorem Array.extract_loop_eq {α : Type u_1} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) (h : start + size ≤ as.size) : Array.extract.loop as size start bs = bs ++ as.extract start (start + size)

theorem Array.size_extract_loop {α : Type u_1} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) : (Array.extract.loop as size start bs).size = bs.size + min size (as.size - start)

@[simp]

theorem Array.size_extract {α : Type u_1} (as : Array α) (start : Nat) (stop : Nat) : (as.extract start stop).size = min stop as.size - start

theorem Array.getElem_extract_loop_lt_aux {α : Type u_1} {i : Nat} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) (hlt : i < bs.size) : i < (Array.extract.loop as size start bs).size

theorem Array.getElem_extract_loop_lt {α : Type u_1} {i : Nat} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) (hlt : i < bs.size) (h : optParam (i < (Array.extract.loop as size start bs).size) ⋯) : (Array.extract.loop as size start bs)[i] = bs[i]

theorem Array.getElem_extract_loop_ge_aux {α : Type u_1} {i : Nat} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) (hge : i ≥ bs.size) (h : i < (Array.extract.loop as size start bs).size) : start + i - bs.size < as.size

theorem Array.getElem_extract_loop_ge {α : Type u_1} {i : Nat} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) (hge : i ≥ bs.size) (h : i < (Array.extract.loop as size start bs).size) (h' : optParam (start + i - bs.size < as.size) ⋯) : (Array.extract.loop as size start bs)[i] = as[start + i - bs.size]

theorem Array.getElem_extract_aux {α : Type u_1} {i : Nat} {as : Array α} {start : Nat} {stop : Nat} (h : i < (as.extract start stop).size) : start + i < as.size

@[simp]

theorem Array.getElem_extract {α : Type u_1} {i : Nat} {as : Array α} {start : Nat} {stop : Nat} (h : i < (as.extract start stop).size) : (as.extract start stop)[i] = as[start + i]

theorem Array.getElem?_extract {α : Type u_1} {i : Nat} {as : Array α} {start : Nat} {stop : Nat} : (as.extract start stop)[i]? = if i < min stop as.size - start then as[start + i]? else none

@[simp]

theorem Array.extract_all {α : Type u_1} (as : Array α) : as.extract 0 as.size = as

theorem Array.extract_empty_of_stop_le_start {α : Type u_1} (as : Array α) {start : Nat} {stop : Nat} (h : stop ≤ start) : as.extract start stop = #[]

theorem Array.extract_empty_of_size_le_start {α : Type u_1} (as : Array α) {start : Nat} {stop : Nat} (h : as.size ≤ start) : as.extract start stop = #[]

@[simp]

theorem Array.extract_empty {α : Type u_1} (start : Nat) (stop : Nat) : #[].extract start stop = #[]

any

@[irreducible]

theorem Array.anyM_loop_cons {m : Type → Type u_1} {α : Type u_2} [Monad m] (p : α → m Bool) (a : α) (as : List α) (stop : Nat) (start : Nat) (h : stop + 1 ≤ (a :: as).length) : Array.anyM.loop p { toList := a :: as } (stop + 1) h (start + 1) = Array.anyM.loop p { toList := as } stop ⋯ start

@[simp, irreducible]

theorem Array.anyM_toList {m : Type → Type u_1} {α : Type u_2} [Monad m] (p : α → m Bool) (as : Array α) : List.anyM p as.toList = Array.anyM p as

@[irreducible]

theorem Array.anyM_loop_iff_exists {α : Type u_1} {p : α → Bool} {as : Array α} {start : Nat} {stop : Nat} (h : stop ≤ as.size) : Array.anyM.loop p as stop h start = true ↔ ∃ (i : Fin as.size), start ≤ ↑i ∧ ↑i < stop ∧ p as[i] = true

theorem Array.any_iff_exists {α : Type u_1} {p : α → Bool} {as : Array α} {start : Nat} {stop : Nat} : as.any p start stop = true ↔ ∃ (i : Fin as.size), start ≤ ↑i ∧ ↑i < stop ∧ p as[i] = true

theorem Array.any_eq_true {α : Type u_1} {p : α → Bool} {as : Array α} : as.any p = true ↔ ∃ (i : Fin as.size), p as[i] = true

theorem Array.any_toList {α : Type u_1} {p : α → Bool} (as : Array α) : as.toList.any p = as.any p

@[reducible, inline, deprecated]

abbrev Array.any_def {α : Type u_1} {p : α → Bool} (as : Array α) : as.toList.any p = as.any p

Equations

• @Array.any_def = @Array.any_toList

all

theorem Array.allM_eq_not_anyM_not {m : Type → Type u_1} {α : Type u_2} [Monad m] [LawfulMonad m] (p : α → m Bool) (as : Array α) : Array.allM p as = (fun (x : Bool) => !x) <$> Array.anyM (fun (x : α) => (fun (x : Bool) => !x) <$> p x) as

@[simp]

theorem Array.allM_toList {m : Type → Type u_1} {α : Type u_2} [Monad m] [LawfulMonad m] (p : α → m Bool) (as : Array α) : List.allM p as.toList = Array.allM p as

theorem Array.all_eq_not_any_not {α : Type u_1} (p : α → Bool) (as : Array α) (start : Nat) (stop : Nat) : as.all p start stop = !as.any (fun (x : α) => !p x) start stop

theorem Array.all_iff_forall {α : Type u_1} {p : α → Bool} {as : Array α} {start : Nat} {stop : Nat} : as.all p start stop = true ↔ ∀ (i : Fin as.size), start ≤ ↑i ∧ ↑i < stop → p as[i] = true

theorem Array.all_eq_true {α : Type u_1} {p : α → Bool} {as : Array α} : as.all p = true ↔ ∀ (i : Fin as.size), p as[i] = true

theorem Array.all_toList {α : Type u_1} {p : α → Bool} (as : Array α) : as.toList.all p = as.all p

@[reducible, inline, deprecated]

abbrev Array.all_def {α : Type u_1} {p : α → Bool} (as : Array α) : as.toList.all p = as.all p

Equations

• @Array.all_def = @Array.all_toList

theorem Array.all_eq_true_iff_forall_mem {α : Type u_1} {p : α → Bool} {l : Array α} : l.all p = true ↔ ∀ (x : α), x ∈ l → p x = true

contains

theorem Array.contains_def {α : Type u_1} [DecidableEq α] {a : α} {as : Array α} : as.contains a = true ↔ a ∈ as

instance Array.instDecidableMemOfDecidableEq {α : Type u_1} [DecidableEq α] (a : α) (as : Array α) : Decidable (a ∈ as)

Equations

• Array.instDecidableMemOfDecidableEq a as = decidable_of_iff (as.contains a = true) ⋯

swap

@[simp]

theorem Array.getElem_swap_right {α : Type u_1} (a : Array α) {i : Fin a.size} {j : Fin a.size} : (a.swap i j)[↑j] = a[i]

@[simp]

theorem Array.getElem_swap_left {α : Type u_1} (a : Array α) {i : Fin a.size} {j : Fin a.size} : (a.swap i j)[↑i] = a[j]

@[simp]

theorem Array.getElem_swap_of_ne {α : Type u_1} {p : Nat} (a : Array α) {i : Fin a.size} {j : Fin a.size} (hp : p < a.size) (hi : p ≠ ↑i) (hj : p ≠ ↑j) : (a.swap i j)[p] = a[p]

theorem Array.getElem_swap' {α : Type u_1} (a : Array α) (i : Fin a.size) (j : Fin a.size) (k : Nat) (hk : k < a.size) : (a.swap i j)[k] = if k = ↑i then a[j] else if k = ↑j then a[i] else a[k]

theorem Array.getElem_swap {α : Type u_1} (a : Array α) (i : Fin a.size) (j : Fin a.size) (k : Nat) (hk : k < (a.swap i j).size) : (a.swap i j)[k] = if k = ↑i then a[j] else if k = ↑j then a[i] else a[k]

@[simp]

theorem Array.swap_swap {α : Type u_1} (a : Array α) {i : Fin a.size} {j : Fin a.size} : (a.swap i j).swap ⟨↑i, ⋯⟩ ⟨↑j, ⋯⟩ = a

theorem Array.swap_comm {α : Type u_1} (a : Array α) {i : Fin a.size} {j : Fin a.size} : a.swap i j = a.swap j i

@[reducible, inline, deprecated Array.getElem_extract_loop_lt_aux]

abbrev Array.get_extract_loop_lt_aux {α : Type u_1} {i : Nat} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) (hlt : i < bs.size) : i < (Array.extract.loop as size start bs).size

Equations

• @Array.get_extract_loop_lt_aux = @Array.getElem_extract_loop_lt_aux

@[reducible, inline, deprecated Array.getElem_extract_loop_lt]

abbrev Array.get_extract_loop_lt {α : Type u_1} {i : Nat} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) (hlt : i < bs.size) (h : optParam (i < (Array.extract.loop as size start bs).size) ⋯) : (Array.extract.loop as size start bs)[i] = bs[i]

Equations

• @Array.get_extract_loop_lt = @Array.getElem_extract_loop_lt

@[reducible, inline, deprecated Array.getElem_extract_loop_ge_aux]

abbrev Array.get_extract_loop_ge_aux {α : Type u_1} {i : Nat} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) (hge : i ≥ bs.size) (h : i < (Array.extract.loop as size start bs).size) : start + i - bs.size < as.size

Equations

• @Array.get_extract_loop_ge_aux = @Array.getElem_extract_loop_ge_aux

@[reducible, inline, deprecated Array.getElem_extract_loop_ge]

abbrev Array.get_extract_loop_ge {α : Type u_1} {i : Nat} (as : Array α) (bs : Array α) (size : Nat) (start : Nat) (hge : i ≥ bs.size) (h : i < (Array.extract.loop as size start bs).size) (h' : optParam (start + i - bs.size < as.size) ⋯) : (Array.extract.loop as size start bs)[i] = as[start + i - bs.size]

Equations

• @Array.get_extract_loop_ge = @Array.getElem_extract_loop_ge

@[reducible, inline, deprecated Array.getElem_extract_aux]

abbrev Array.get_extract_aux {α : Type u_1} {i : Nat} {as : Array α} {start : Nat} {stop : Nat} (h : i < (as.extract start stop).size) : start + i < as.size

Equations

• @Array.get_extract_aux = @Array.getElem_extract_aux

@[reducible, inline, deprecated Array.getElem_extract]

abbrev Array.get_extract {α : Type u_1} {i : Nat} {as : Array α} {start : Nat} {stop : Nat} (h : i < (as.extract start stop).size) : (as.extract start stop)[i] = as[start + i]

Equations

• @Array.get_extract = @Array.getElem_extract

@[reducible, inline, deprecated Array.getElem_swap_right]

abbrev Array.get_swap_right {α : Type u_1} (a : Array α) {i : Fin a.size} {j : Fin a.size} : (a.swap i j)[↑j] = a[i]

Equations

• @Array.get_swap_right = @Array.getElem_swap_right

@[reducible, inline, deprecated Array.getElem_swap_left]

abbrev Array.get_swap_left {α : Type u_1} (a : Array α) {i : Fin a.size} {j : Fin a.size} : (a.swap i j)[↑i] = a[j]

Equations

• @Array.get_swap_left = @Array.getElem_swap_left

@[reducible, inline, deprecated Array.getElem_swap_of_ne]

abbrev Array.get_swap_of_ne {α : Type u_1} {p : Nat} (a : Array α) {i : Fin a.size} {j : Fin a.size} (hp : p < a.size) (hi : p ≠ ↑i) (hj : p ≠ ↑j) : (a.swap i j)[p] = a[p]

Equations

• @Array.get_swap_of_ne = @Array.getElem_swap_of_ne

@[reducible, inline, deprecated Array.getElem_swap]

abbrev Array.get_swap {α : Type u_1} (a : Array α) (i : Fin a.size) (j : Fin a.size) (k : Nat) (hk : k < (a.swap i j).size) : (a.swap i j)[k] = if k = ↑i then a[j] else if k = ↑j then a[i] else a[k]

Equations

• @Array.get_swap = @Array.getElem_swap

@[reducible, inline, deprecated Array.getElem_swap']

abbrev Array.get_swap' {α : Type u_1} (a : Array α) (i : Fin a.size) (j : Fin a.size) (k : Nat) (hk : k < a.size) : (a.swap i j)[k] = if k = ↑i then a[j] else if k = ↑j then a[i] else a[k]

Equations

• @Array.get_swap' = @Array.getElem_swap'

More theorems about List.toArray, followed by an Array operation.

Our goal is to have simp "pull List.toArray outwards" as much as possible.

@[simp]

theorem List.mem_toArray {α : Type u_1} {a : α} {l : List α} : a ∈ l.toArray ↔ a ∈ l

@[simp]

theorem List.toListRev_toArray {α : Type u_1} (l : List α) : l.toArray.toListRev = l.reverse

@[simp]

theorem List.push_append_toArray {α : Type u_1} (as : Array α) (a : α) (l : List α) : as.push a ++ l.toArray = as ++ (a :: l).toArray

@[simp]

theorem List.mapM_toArray {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [Monad m] [LawfulMonad m] (f : α → m β) (l : List α) : Array.mapM f l.toArray = List.toArray <$> List.mapM f l

@[simp]

theorem List.map_toArray {α : Type u_1} {β : Type u_2} (f : α → β) (l : List α) : Array.map f l.toArray = (List.map f l).toArray

@[simp]

theorem List.toArray_appendList {α : Type u_1} (l₁ : List α) (l₂ : List α) : l₁.toArray ++ l₂ = (l₁ ++ l₂).toArray

@[simp]

theorem List.set_toArray {α : Type u_1} (l : List α) (i : Fin l.toArray.size) (a : α) : l.toArray.set i a = (l.set (↑i) a).toArray

@[simp]

theorem List.uset_toArray {α : Type u_1} (l : List α) (i : USize) (a : α) (h : i.toNat < l.toArray.size) : l.toArray.uset i a h = (l.set i.toNat a).toArray

@[simp]

theorem List.setD_toArray {α : Type u_1} (l : List α) (i : Nat) (a : α) : l.toArray.setD i a = (l.set i a).toArray

theorem List.anyM_toArray {m : Type → Type u_1} {α : Type u_2} [Monad m] [LawfulMonad m] (p : α → m Bool) (l : List α) : Array.anyM p l.toArray = List.anyM p l

theorem List.any_toArray {α : Type u_1} (p : α → Bool) (l : List α) : l.toArray.any p = l.any p

theorem List.allM_toArray {m : Type → Type u_1} {α : Type u_2} [Monad m] [LawfulMonad m] (p : α → m Bool) (l : List α) : Array.allM p l.toArray = List.allM p l

theorem List.all_toArray {α : Type u_1} (p : α → Bool) (l : List α) : l.toArray.all p = l.all p

@[simp]

theorem List.anyM_toArray' {m : Type → Type u_1} {α : Type u_2} {stop : Nat} [Monad m] [LawfulMonad m] (p : α → m Bool) (l : List α) (h : stop = l.toArray.size) : Array.anyM p l.toArray 0 stop = List.anyM p l

Variant of anyM_toArray with a side condition on stop.

@[simp]

theorem List.any_toArray' {α : Type u_1} {stop : Nat} (p : α → Bool) (l : List α) (h : stop = l.toArray.size) : l.toArray.any p 0 stop = l.any p

Variant of any_toArray with a side condition on stop.

@[simp]

theorem List.allM_toArray' {m : Type → Type u_1} {α : Type u_2} {stop : Nat} [Monad m] [LawfulMonad m] (p : α → m Bool) (l : List α) (h : stop = l.toArray.size) : Array.allM p l.toArray 0 stop = List.allM p l

Variant of allM_toArray with a side condition on stop.

@[simp]

theorem List.all_toArray' {α : Type u_1} {stop : Nat} (p : α → Bool) (l : List α) (h : stop = l.toArray.size) : l.toArray.all p 0 stop = l.all p

Variant of all_toArray with a side condition on stop.

@[simp]

theorem List.swap_toArray {α : Type u_1} (l : List α) (i : Fin l.toArray.size) (j : Fin l.toArray.size) : l.toArray.swap i j = ((l.set (↑i) l[j]).set (↑j) l[i]).toArray

@[simp]

theorem List.pop_toArray {α : Type u_1} (l : List α) : l.toArray.pop = l.dropLast.toArray

@[simp]

theorem List.reverse_toArray {α : Type u_1} (l : List α) : l.toArray.reverse = l.reverse.toArray

@[simp]

theorem List.filter_toArray' {α : Type u_1} {stop : Nat} (p : α → Bool) (l : List α) (h : stop = l.toArray.size) : Array.filter p l.toArray 0 stop = (List.filter p l).toArray

@[simp]

theorem List.filterMap_toArray' {α : Type u_1} {β : Type u_2} {stop : Nat} (f : α → Option β) (l : List α) (h : stop = l.toArray.size) : Array.filterMap f l.toArray 0 stop = (List.filterMap f l).toArray

theorem List.filter_toArray {α : Type u_1} (p : α → Bool) (l : List α) : Array.filter p l.toArray = (List.filter p l).toArray

theorem List.filterMap_toArray {α : Type u_1} {β : Type u_2} (f : α → Option β) (l : List α) : Array.filterMap f l.toArray = (List.filterMap f l).toArray

@[simp]

theorem List.flatten_toArray {α : Type u_1} (l : List (List α)) : (Array.map List.toArray l.toArray).flatten = l.join.toArray

@[simp]

theorem List.toArray_range (n : Nat) : (List.range n).toArray = Array.range n