File: .lake/packages/lean4/src/lean/Init/Data/Array/Basic.lean

full_name: Array.mkArray
code: @[extern "lean_mk_array"]
def mkArray {α : Type u} (n : Nat) (v : α) : Array α 
goal: Array α

full_name: Array.ofFn.go
code: /--
`ofFn f` with `f : Fin n → α` returns the list whose ith element is `f i`.
```
ofFn f = #[f 0, f 1, ... , f(n - 1)]
``` -/
def ofFn {n} (f : Fin n → α) : Array α 
goal: Array α

full_name: Array.ofFn
code: /--
`ofFn f` with `f : Fin n → α` returns the list whose ith element is `f i`.
```
ofFn f = #[f 0, f 1, ... , f(n - 1)]
``` -/
def ofFn {n} (f : Fin n → α) : Array α 
goal: Array α

full_name: Array.range
code: /-- The array `#[0, 1, ..., n - 1]`. -/
def range (n : Nat) : Array Nat 
goal: Array Nat

full_name: Array.size_mkArray
code: @[simp] theorem size_mkArray (n : Nat) (v : α) : (mkArray n v).size = n 
goal: (mkArray n v).size = n

full_name: Array.«instEmptyCollection_.lake»
code: instance : EmptyCollection (Array α) 
goal: EmptyCollection (Array α)

full_name: Array.«instInhabited_.lake»
code: instance : Inhabited (Array α) 
goal: Inhabited (Array α)

full_name: Array.isEmpty
code: @[simp] def isEmpty (a : Array α) : Bool 
goal: Bool

full_name: Array.singleton
code: def singleton (v : α) : Array α 
goal: Array α

full_name: Array.uget
code: /-- Low-level version of `fget` which is as fast as a C array read.
   `Fin` values are represented as tag pointers in the Lean runtime. Thus,
   `fget` may be slightly slower than `uget`. -/
@[extern "lean_array_uget", simp]
def uget (a : @& Array α) (i : USize) (h : i.toNat < a.size) : α 
goal: α

full_name: Array.«instGetElemUSizeLtNatToNatSize_.lake»
code: instance : GetElem (Array α) USize α fun xs i => i.toNat < xs.size 
goal: GetElem (Array α) USize α fun xs i => i.toNat < xs.size

full_name: Array.back
code: def back [Inhabited α] (a : Array α) : α 
goal: α

full_name: Array.get?
code: def get? (a : Array α) (i : Nat) : Option α 
goal: Option α

full_name: Array.back?
code: def back? (a : Array α) : Option α 
goal: Option α

full_name: Array.getLit
code: abbrev getLit {α : Type u} {n : Nat} (a : Array α) (i : Nat) (h₁ : a.size = n) (h₂ : i < n) : α 
goal: α

full_name: Array.size_set
code: @[simp] theorem size_set (a : Array α) (i : Fin a.size) (v : α) : (set a i v).size = a.size 
goal: (a.set i v).size = a.size

full_name: Array.size_push
code: @[simp] theorem size_push (a : Array α) (v : α) : (push a v).size = a.size + 1 
goal: (a.push v).size = a.size + 1

full_name: Array.uset
code: /-- Low-level version of `fset` which is as fast as a C array fset.
   `Fin` values are represented as tag pointers in the Lean runtime. Thus,
   `fset` may be slightly slower than `uset`. -/
@[extern "lean_array_uset"]
def uset (a : Array α) (i : USize) (v : α) (h : i.toNat < a.size) : Array α 
goal: Array α

full_name: Array.swap
code: /--
Swaps two entries in an array.

This will perform the update destructively provided that `a` has a reference
count of 1 when called.
-/
@[extern "lean_array_fswap"]
def swap (a : Array α) (i j : @& Fin a.size) : Array α 
goal: Array α

full_name: Array.swap!
code: /--
Swaps two entries in an array, or panics if either index is out of bounds.

This will perform the update destructively provided that `a` has a reference
count of 1 when called.
-/
@[extern "lean_array_swap"]
def swap! (a : Array α) (i j : @& Nat) : Array α 
goal: Array α

full_name: Array.swapAt
code: @[inline] def swapAt (a : Array α) (i : Fin a.size) (v : α) : α × Array α 
goal: α × Array α

full_name: Array.swapAt!
code: @[inline]
def swapAt! (a : Array α) (i : Nat) (v : α) : α × Array α 
goal: α × Array α

full_name: Array.pop
code: @[extern "lean_array_pop"]
def pop (a : Array α) : Array α 
goal: Array α

full_name: Array.shrink
code: def shrink (a : Array α) (n : Nat) : Array α 
goal: Array α

full_name: Array.shrink.loop
code: def shrink (a : Array α) (n : Nat) : Array α 
goal: Nat → Array α → Array α

full_name: Array.modifyMUnsafe
code: @[inline]
unsafe def modifyMUnsafe [Monad m] (a : Array α) (i : Nat) (f : α → m α) : m (Array α) 
goal: m (Array α)

full_name: Array.modifyM
code: @[implemented_by modifyMUnsafe]
def modifyM [Monad m] (a : Array α) (i : Nat) (f : α → m α) : m (Array α) 
goal: m (Array α)

full_name: Array.modify
code: @[inline]
def modify (a : Array α) (i : Nat) (f : α → α) : Array α 
goal: Array α

full_name: Array.modifyOp
code: @[inline]
def modifyOp (self : Array α) (idx : Nat) (f : α → α) : Array α 
goal: Array α

full_name: Array.forInUnsafe
code: /--
  We claim this unsafe implementation is correct because an array cannot have more than `usizeSz` elements in our runtime.

  This kind of low level trick can be removed with a little bit of compiler support. For example, if the compiler simplifies `as.size < usizeSz` to true. -/
@[inline] unsafe def forInUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (b : β) (f : α → β → m (ForInStep β)) : m β 
goal: m β

full_name: Array.forInUnsafe.loop
code: /--
  We claim this unsafe implementation is correct because an array cannot have more than `usizeSz` elements in our runtime.

  This kind of low level trick can be removed with a little bit of compiler support. For example, if the compiler simplifies `as.size < usizeSz` to true. -/
@[inline] unsafe def forInUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (b : β) (f : α → β → m (ForInStep β)) : m β 
goal: m β

full_name: Array.forIn.loop
code: /-- Reference implementation for `forIn` -/
@[implemented_by Array.forInUnsafe]
protected def forIn {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (b : β) (f : α → β → m (ForInStep β)) : m β 
goal: m β

full_name: Array.forIn
code: /-- Reference implementation for `forIn` -/
@[implemented_by Array.forInUnsafe]
protected def forIn {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (b : β) (f : α → β → m (ForInStep β)) : m β 
goal: m β

full_name: Array.«instForIn_.lake»
code: instance : ForIn m (Array α) α 
goal: ForIn m (Array α) α

full_name: Array.foldlMUnsafe
code: /-- See comment at `forInUnsafe` -/
@[inline]
unsafe def foldlMUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : β → α → m β) (init : β) (as : Array α) (start := 0) (stop := as.size) : m β 
goal: m β

full_name: Array.foldlMUnsafe.fold
code: /-- See comment at `forInUnsafe` -/
@[inline]
unsafe def foldlMUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : β → α → m β) (init : β) (as : Array α) (start := 0) (stop := as.size) : m β 
goal: m β

full_name: Array.foldlM
code: /-- Reference implementation for `foldlM` -/
@[implemented_by foldlMUnsafe]
def foldlM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : β → α → m β) (init : β) (as : Array α) (start := 0) (stop := as.size) : m β 
goal: m β

full_name: Array.foldlM.loop
code: /-- Reference implementation for `foldlM` -/
@[implemented_by foldlMUnsafe]
def foldlM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : β → α → m β) (init : β) (as : Array α) (start := 0) (stop := as.size) : m β 
goal: m β

full_name: Array.foldrMUnsafe.fold
code: /-- See comment at `forInUnsafe` -/
@[inline]
unsafe def foldrMUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → β → m β) (init : β) (as : Array α) (start := as.size) (stop := 0) : m β 
goal: m β

full_name: Array.foldrMUnsafe
code: /-- See comment at `forInUnsafe` -/
@[inline]
unsafe def foldrMUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → β → m β) (init : β) (as : Array α) (start := as.size) (stop := 0) : m β 
goal: m β

full_name: Array.foldrM
code: /-- Reference implementation for `foldrM` -/
@[implemented_by foldrMUnsafe]
def foldrM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → β → m β) (init : β) (as : Array α) (start := as.size) (stop := 0) : m β 
goal: m β

full_name: Array.foldrM.fold
code: /-- Reference implementation for `foldrM` -/
@[implemented_by foldrMUnsafe]
def foldrM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → β → m β) (init : β) (as : Array α) (start := as.size) (stop := 0) : m β 
goal: m β

full_name: Array.mapMUnsafe.map
code: /-- See comment at `forInUnsafe` -/
@[inline]
unsafe def mapMUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → m β) (as : Array α) : m (Array β) 
goal: m (Array PNonScalar)

full_name: Array.mapMUnsafe
code: /-- See comment at `forInUnsafe` -/
@[inline]
unsafe def mapMUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → m β) (as : Array α) : m (Array β) 
goal: m (Array β)

full_name: Array.mapM
code: /-- Reference implementation for `mapM` -/
@[implemented_by mapMUnsafe]
def mapM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → m β) (as : Array α) : m (Array β) 
goal: m (Array β)

full_name: Array.mapM.map
code: /-- Reference implementation for `mapM` -/
@[implemented_by mapMUnsafe]
def mapM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → m β) (as : Array α) : m (Array β) 
goal: m (Array β)

full_name: Array.mapIdxM.map
code: @[inline]
def mapIdxM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (f : Fin as.size → α → m β) : m (Array β) 
goal: m (Array β)

full_name: Array.mapIdxM
code: @[inline]
def mapIdxM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (f : Fin as.size → α → m β) : m (Array β) 
goal: m (Array β)

full_name: Array.findSomeM?
code: @[inline]
def findSomeM? {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (f : α → m (Option β)) : m (Option β) 
goal: m (Option β)

full_name: Array.findM?
code: @[inline]
def findM? {α : Type} {m : Type → Type} [Monad m] (as : Array α) (p : α → m Bool) : m (Option α) 
goal: m (Option α)

full_name: Array.findIdxM?
code: @[inline]
def findIdxM? [Monad m] (as : Array α) (p : α → m Bool) : m (Option Nat) 
goal: m (Option Nat)

full_name: Array.anyMUnsafe.any
code: @[inline]
unsafe def anyMUnsafe {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Array α) (start := 0) (stop := as.size) : m Bool 
goal: m Bool

full_name: Array.anyMUnsafe
code: @[inline]
unsafe def anyMUnsafe {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Array α) (start := 0) (stop := as.size) : m Bool 
goal: m Bool

full_name: Array.anyM.loop
code: @[implemented_by anyMUnsafe]
def anyM {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Array α) (start := 0) (stop := as.size) : m Bool 
goal: m Bool

full_name: Array.anyM
code: @[implemented_by anyMUnsafe]
def anyM {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Array α) (start := 0) (stop := as.size) : m Bool 
goal: m Bool

full_name: Array.allM
code: @[inline]
def allM {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Array α) (start := 0) (stop := as.size) : m Bool 
goal: m Bool

full_name: Array.findSomeRevM?.find
code: @[inline]
def findSomeRevM? {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (f : α → m (Option β)) : m (Option β) 
goal: i ≤ as.size → m (Option β)

full_name: Array.findSomeRevM?
code: @[inline]
def findSomeRevM? {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (f : α → m (Option β)) : m (Option β) 
goal: m (Option β)

full_name: Array.findRevM?
code: @[inline]
def findRevM? {α : Type} {m : Type → Type w} [Monad m] (as : Array α) (p : α → m Bool) : m (Option α) 
goal: m (Option α)

full_name: Array.forM
code: @[inline]
def forM {α : Type u} {m : Type v → Type w} [Monad m] (f : α → m PUnit) (as : Array α) (start := 0) (stop := as.size) : m PUnit 
goal: m PUnit

full_name: Array.forRevM
code: @[inline]
def forRevM {α : Type u} {m : Type v → Type w} [Monad m] (f : α → m PUnit) (as : Array α) (start := as.size) (stop := 0) : m PUnit 
goal: m PUnit

full_name: Array.foldl
code: @[inline]
def foldl {α : Type u} {β : Type v} (f : β → α → β) (init : β) (as : Array α) (start := 0) (stop := as.size) : β 
goal: β

full_name: Array.foldr
code: @[inline]
def foldr {α : Type u} {β : Type v} (f : α → β → β) (init : β) (as : Array α) (start := as.size) (stop := 0) : β 
goal: β

full_name: Array.map
code: @[inline]
def map {α : Type u} {β : Type v} (f : α → β) (as : Array α) : Array β 
goal: Array β

full_name: Array.mapIdx
code: @[inline]
def mapIdx {α : Type u} {β : Type v} (as : Array α) (f : Fin as.size → α → β) : Array β 
goal: Array β

full_name: Array.zipWithIndex
code: /-- Turns `#[a, b]` into `#[(a, 0), (b, 1)]`. -/
def zipWithIndex (arr : Array α) : Array (α × Nat) 
goal: Array (α × Nat)

full_name: Array.find?
code: @[inline]
def find? {α : Type} (as : Array α) (p : α → Bool) : Option α 
goal: Option α

full_name: Array.findSome?
code: @[inline]
def findSome? {α : Type u} {β : Type v} (as : Array α) (f : α → Option β) : Option β 
goal: Option β

full_name: Array.findSome!
code: @[inline]
def findSome! {α : Type u} {β : Type v} [Inhabited β] (a : Array α) (f : α → Option β) : β 
goal: β

full_name: Array.findSomeRev?
code: @[inline]
def findSomeRev? {α : Type u} {β : Type v} (as : Array α) (f : α → Option β) : Option β 
goal: Option β

full_name: Array.findRev?
code: @[inline]
def findRev? {α : Type} (as : Array α) (p : α → Bool) : Option α 
goal: Option α

full_name: Array.findIdx?
code: @[inline]
def findIdx? {α : Type u} (as : Array α) (p : α → Bool) : Option Nat 
goal: Option Nat

full_name: Array.findIdx?.loop
code: @[inline]
def findIdx? {α : Type u} (as : Array α) (p : α → Bool) : Option Nat 
goal: Option Nat

full_name: Array.getIdx?
code: def getIdx? [BEq α] (a : Array α) (v : α) : Option Nat 
goal: Option Nat

full_name: Array.any
code: @[inline]
def any (as : Array α) (p : α → Bool) (start := 0) (stop := as.size) : Bool 
goal: Bool

full_name: Array.all
code: @[inline]
def all (as : Array α) (p : α → Bool) (start := 0) (stop := as.size) : Bool 
goal: Bool

full_name: Array.contains
code: def contains [BEq α] (as : Array α) (a : α) : Bool 
goal: Bool

full_name: Array.elem
code: def elem [BEq α] (a : α) (as : Array α) : Bool 
goal: Bool

full_name: Array.getEvenElems
code: @[inline] def getEvenElems (as : Array α) : Array α 
goal: Array α

full_name: Array.toList
code: /-- Convert a `Array α` into an `List α`. This is O(n) in the size of the array.  -/
-- This function is exported to C, where it is called by `Array.data`
-- (the projection) to implement this functionality.
@[export lean_array_to_list]
def toList (as : Array α) : List α 
goal: List α

full_name: Array.toListAppend
code: /-- Prepends an `Array α` onto the front of a list.  Equivalent to `as.toList ++ l`. -/
@[inline]
def toListAppend (as : Array α) (l : List α) : List α 
goal: List α

full_name: Array.«instRepr_.lake»
code: instance {α : Type u} [Repr α] : Repr (Array α) 
goal: Repr (Array α)

full_name: Array.«instToString_.lake»
code: instance [ToString α] : ToString (Array α) 
goal: ToString (Array α)

full_name: Array.append
code: protected def append (as : Array α) (bs : Array α) : Array α 
goal: Array α

full_name: Array.«instAppend_.lake»
code: instance : Append (Array α) 
goal: Append (Array α)

full_name: Array.appendList
code: protected def appendList (as : Array α) (bs : List α) : Array α 
goal: Array α

full_name: Array.«instHAppendList_.lake»
code: instance : HAppend (Array α) (List α) (Array α) 
goal: HAppend (Array α) (List α) (Array α)

full_name: Array.concatMapM
code: @[inline]
def concatMapM [Monad m] (f : α → m (Array β)) (as : Array α) : m (Array β) 
goal: m (Array β)

full_name: Array.concatMap
code: @[inline]
def concatMap (f : α → Array β) (as : Array α) : Array β 
goal: Array β

full_name: Array.flatten
code: /-- Joins array of array into a single array.

`flatten #[#[a₁, a₂, ⋯], #[b₁, b₂, ⋯], ⋯]` = `#[a₁, a₂, ⋯, b₁, b₂, ⋯]`
-/
def flatten (as : Array (Array α)) : Array α 
goal: Array α

full_name: «term#[_,]»
code: syntax "#[" withoutPosition(sepBy(term, ", ")) "]" : term
goal: Lean.ParserDescr

full_name: «_aux_.lake_packages_lean4_src_lean_Init_Data_Array_Basic___macroRules_term#[_,]_1»
code: macro_rules
  | `(#[ $elems,* ]) => `(List.toArray [ $elems,* ])
goal: Lean.Macro

full_name: Array.isEqvAux
code: @[specialize]
def isEqvAux (a b : Array α) (hsz : a.size = b.size) (p : α → α → Bool) (i : Nat) : Bool 
goal: Bool

full_name: Array.isEqv
code: @[inline] def isEqv (a b : Array α) (p : α → α → Bool) : Bool 
goal: Bool

full_name: Array.«instBEq_.lake»
code: instance [BEq α] : BEq (Array α) 
goal: BEq (Array α)

full_name: Array.filter
code: @[inline]
def filter (p : α → Bool) (as : Array α) (start := 0) (stop := as.size) : Array α 
goal: Array α

full_name: Array.filterM
code: @[inline]
def filterM [Monad m] (p : α → m Bool) (as : Array α) (start := 0) (stop := as.size) : m (Array α) 
goal: m (Array α)

full_name: Array.filterMapM
code: @[specialize]
def filterMapM [Monad m] (f : α → m (Option β)) (as : Array α) (start := 0) (stop := as.size) : m (Array β) 
goal: m (Array β)

full_name: Array.filterMap
code: @[inline]
def filterMap (f : α → Option β) (as : Array α) (start := 0) (stop := as.size) : Array β 
goal: Array β

full_name: Array.getMax?
code: @[specialize]
def getMax? (as : Array α) (lt : α → α → Bool) : Option α 
goal: Option α

full_name: Array.partition
code: @[inline]
def partition (p : α → Bool) (as : Array α) : Array α × Array α 
goal: Array α × Array α

full_name: Array.ext.extAux
code: theorem ext (a b : Array α)
    (h₁ : a.size = b.size)
    (h₂ : (i : Nat) → (hi₁ : i < a.size) → (hi₂ : i < b.size) → a[i] = b[i])
    : a = b 
goal: a = b

full_name: Array.ext
code: theorem ext (a b : Array α)
    (h₁ : a.size = b.size)
    (h₂ : (i : Nat) → (hi₁ : i < a.size) → (hi₂ : i < b.size) → a[i] = b[i])
    : a = b 
goal: a = b

full_name: Array.extLit
code: theorem extLit {n : Nat}
    (a b : Array α)
    (hsz₁ : a.size = n) (hsz₂ : b.size = n)
    (h : (i : Nat) → (hi : i < n) → a.getLit i hsz₁ hi = b.getLit i hsz₂ hi) : a = b 
goal: a = b

full_name: Array.indexOfAux
code: def indexOfAux [BEq α] (a : Array α) (v : α) (i : Nat) : Option (Fin a.size) 
goal: Option (Fin a.size)

full_name: Array.indexOf?
code: def indexOf? [BEq α] (a : Array α) (v : α) : Option (Fin a.size) 
goal: Option (Fin a.size)

full_name: Array.size_swap
code: @[simp] theorem size_swap (a : Array α) (i j : Fin a.size) : (a.swap i j).size = a.size 
goal: (a.swap i j).size = a.size

full_name: Array.size_pop
code: @[simp] theorem size_pop (a : Array α) : a.pop.size = a.size - 1 
goal: a.pop.size = a.size - 1

full_name: Array.reverse.termination
code: theorem reverse.termination {i j : Nat} (h : i < j) : j - 1 - (i + 1) < j - i 
goal: j - 1 - (i + 1) < j - i

full_name: Array.reverse
code: def reverse (as : Array α) : Array α 
goal: Array α

full_name: Array.reverse.loop
code: def reverse (as : Array α) : Array α 
goal: Array α

full_name: Array.popWhile
code: def popWhile (p : α → Bool) (as : Array α) : Array α 
goal: Array α

full_name: Array.takeWhile.go
code: def takeWhile (p : α → Bool) (as : Array α) : Array α 
goal: Array α

full_name: Array.takeWhile
code: def takeWhile (p : α → Bool) (as : Array α) : Array α 
goal: Array α

full_name: Array.feraseIdx
code: /-- Remove the element at a given index from an array without bounds checks, using a `Fin` index.

  This function takes worst case O(n) time because
  it has to backshift all elements at positions greater than `i`.-/
def feraseIdx (a : Array α) (i : Fin a.size) : Array α 
goal: Array α

full_name: Array.size_feraseIdx
code: theorem size_feraseIdx (a : Array α) (i : Fin a.size) : (a.feraseIdx i).size = a.size - 1 
goal: (a.feraseIdx i).size = a.size - 1

full_name: Array.eraseIdx
code: /-- Remove the element at a given index from an array, or do nothing if the index is out of bounds.

  This function takes worst case O(n) time because
  it has to backshift all elements at positions greater than `i`.-/
def eraseIdx (a : Array α) (i : Nat) : Array α 
goal: Array α

full_name: Array.erase
code: def erase [BEq α] (as : Array α) (a : α) : Array α 
goal: Array α

full_name: Array.insertAt.loop
code: /-- Insert element `a` at position `i`. -/
@[inline] def insertAt (as : Array α) (i : Fin (as.size + 1)) (a : α) : Array α 
goal: (as : Array α) → Fin as.size → Array α

full_name: Array.insertAt
code: /-- Insert element `a` at position `i`. -/
@[inline] def insertAt (as : Array α) (i : Fin (as.size + 1)) (a : α) : Array α 
goal: Array α

full_name: Array.insertAt!
code: /-- Insert element `a` at position `i`. Panics if `i` is not `i ≤ as.size`. -/
def insertAt! (as : Array α) (i : Nat) (a : α) : Array α 
goal: Array α

full_name: Array.toListLitAux
code: def toListLitAux (a : Array α) (n : Nat) (hsz : a.size = n) : ∀ (i : Nat), i ≤ a.size → List α → List α
  
goal: i ≤ a.size → List α → List α

full_name: Array.toArrayLit
code: def toArrayLit (a : Array α) (n : Nat) (hsz : a.size = n) : Array α 
goal: Array α

full_name: Array.ext'
code: theorem ext' {as bs : Array α} (h : as.data = bs.data) : as = bs 
goal: as = bs

full_name: Array.toArrayAux_eq
code: @[simp] theorem toArrayAux_eq (as : List α) (acc : Array α) : (as.toArrayAux acc).data = acc.data ++ as 
goal: (as.toArrayAux acc).data = acc.data ++ as

full_name: Array.data_toArray
code: theorem data_toArray (as : List α) : as.toArray.data = as 
goal: (List.toArray as).data = as

full_name: Array.toArrayLit_eq.go
code: theorem toArrayLit_eq (as : Array α) (n : Nat) (hsz : as.size = n) : as = toArrayLit as n hsz 
goal: as.toListLitAux n hsz i hi (List.drop i as.data) = as.data

full_name: Array.toArrayLit_eq.getLit_eq
code: theorem toArrayLit_eq (as : Array α) (n : Nat) (hsz : as.size = n) : as = toArrayLit as n hsz 
goal: as.getLit i h₁ h₂ = getElem as.data i ⋯

full_name: Array.toArrayLit_eq
code: theorem toArrayLit_eq (as : Array α) (n : Nat) (hsz : as.size = n) : as = toArrayLit as n hsz 
goal: as = as.toArrayLit n hsz

full_name: Array.isPrefixOfAux
code: def isPrefixOfAux [BEq α] (as bs : Array α) (hle : as.size ≤ bs.size) (i : Nat) : Bool 
goal: Bool

full_name: Array.isPrefixOf
code: /-- Return true iff `as` is a prefix of `bs`.
That is, `bs = as ++ t` for some `t : List α`.-/
def isPrefixOf [BEq α] (as bs : Array α) : Bool 
goal: Bool

full_name: _private.«.lake».packages.lean4.src.lean.Init.Data.Array.Basic.0.Array.allDiffAuxAux
code: private def allDiffAuxAux [BEq α] (as : Array α) (a : α) : forall (i : Nat), i < as.size → Bool
  
goal: i < as.size → Bool

full_name: _private.«.lake».packages.lean4.src.lean.Init.Data.Array.Basic.0.Array.allDiffAux
code: private def allDiffAux [BEq α] (as : Array α) (i : Nat) : Bool 
goal: Bool

full_name: Array.allDiff
code: def allDiff [BEq α] (as : Array α) : Bool 
goal: Bool

full_name: Array.zipWithAux
code: @[specialize] def zipWithAux (f : α → β → γ) (as : Array α) (bs : Array β) (i : Nat) (cs : Array γ) : Array γ 
goal: Array γ

full_name: Array.zipWith
code: @[inline] def zipWith (as : Array α) (bs : Array β) (f : α → β → γ) : Array γ 
goal: Array γ

full_name: Array.zip
code: def zip (as : Array α) (bs : Array β) : Array (α × β) 
goal: Array (α × β)

full_name: Array.unzip
code: def unzip (as : Array (α × β)) : Array α × Array β 
goal: Array α × Array β

full_name: Array.split
code: def split (as : Array α) (p : α → Bool) : Array α × Array α 
goal: Array α × Array α