ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/batteries/Batteries/Lean/NameMap.lean

full_name: Lean.NameMap.«instForInProdName_.lake»
code: instance : ForIn m (NameMap β) (Name × β) 
goal: ForIn m (Lean.NameMap β) (Lean.Name × β)

full_name: Lean.NameMap.filter.process
code: /--
`filter f m` returns the `NameMap` consisting of all
"`key`/`val`"-pairs in `m` where `f key val` returns `true`.
-/
def filter (f : Name → α → Bool) (m : NameMap α) : NameMap α 
goal: Lean.RBMap Lean.Name α Lean.Name.quickCmp

full_name: Lean.NameMap.filter
code: /--
`filter f m` returns the `NameMap` consisting of all
"`key`/`val`"-pairs in `m` where `f key val` returns `true`.
-/
def filter (f : Name → α → Bool) (m : NameMap α) : NameMap α 
goal: Lean.NameMap α

full_name: Lean.NameMap.filterMap
code: /--
`filterMap f m` allows to filter a `NameMap` and simultaneously modify the filtered values.

It takes a function `f : Name → α → Option β` and applies `f name` to the value with key `name`.
The resulting entries with non-`none` value are collected to form the output `NameMap`.
-/
def filterMap (f : Name → α → Option β) (m : NameMap α) : NameMap β 
goal: Lean.NameMap β

full_name: Lean.NameMap.filterMap.process
code: /--
`filterMap f m` allows to filter a `NameMap` and simultaneously modify the filtered values.

It takes a function `f : Name → α → Option β` and applies `f name` to the value with key `name`.
The resulting entries with non-`none` value are collected to form the output `NameMap`.
-/
def filterMap (f : Name → α → Option β) (m : NameMap α) : NameMap β 
goal: Lean.NameMap β
File: .lake/packages/batteries/Batteries/Lean/PersistentHashMap.lean

full_name: Lean.PersistentHashMap.ofList
code: /--
Builds a `PersistentHashMap` from a list of key-value pairs. Values of
duplicated keys are replaced by their respective last occurrences.
-/
def ofList (xs : List (α × β)) : PersistentHashMap α β 
goal: Lean.PersistentHashMap α β

full_name: Lean.PersistentHashMap.ofListWith
code: /--
Variant of `ofList` which accepts a function that combines values of duplicated
keys.
-/
def ofListWith (xs : List (α × β)) (f : α → β → β → β) :
    PersistentHashMap α β 
goal: Lean.PersistentHashMap α β

full_name: Lean.PersistentHashMap.ofArray
code: /--
Builds a `PersistentHashMap` from an array of key-value pairs. Values of
duplicated keys are replaced by their respective last occurrences.
-/
def ofArray (xs : Array (α × β)) : PersistentHashMap α β 
goal: Lean.PersistentHashMap α β

full_name: Lean.PersistentHashMap.ofArrayWith
code: /--
Variant of `ofArray` which accepts a function that combines values of duplicated
keys.
-/
def ofArrayWith (xs : Array (α × β)) (f : α → β → β → β) :
    PersistentHashMap α β 
goal: Lean.PersistentHashMap α β

full_name: Lean.PersistentHashMap.mergeWithM
code: /--
Merge two `PersistentHashMap`s. The values of keys which appear in both maps are
combined using the monadic function `f`.
-/
@[specialize]
def mergeWithM [Monad m] (self other : PersistentHashMap α β)
    (f : α → β → β → m β) : m (PersistentHashMap α β) 
goal: m (Lean.PersistentHashMap α β)

full_name: Lean.PersistentHashMap.mergeWith
code: /--
Merge two `PersistentHashMap`s. The values of keys which appear in both maps are
combined using `f`.
-/
@[inline]
def mergeWith (self other : PersistentHashMap α β) (f : α → β → β → β) :
    PersistentHashMap α β 
goal: Lean.PersistentHashMap α β
File: .lake/packages/batteries/Batteries/Lean/SMap.lean

full_name: Lean.SMap.foldM
code: /-- Monadic fold over a staged map. -/
def Lean.SMap.foldM {m : Type w → Type w} [Monad m] [BEq α] [Hashable α]
    (f : σ → α → β → m σ) (init : σ) (map : SMap α β) : m σ 
goal: m σ
File: .lake/packages/batteries/Batteries/Lean/Position.lean

full_name: Lean.FileMap.rangeOfStx?
code: /-- Gets the LSP range of syntax `stx`. -/
def Lean.FileMap.rangeOfStx? (text : FileMap) (stx : Syntax) : Option Lsp.Range 
goal: Option Lean.Lsp.Range

full_name: Lean.findLineStart
code: /-- Return the beginning of the line contatining character `pos`. -/
def Lean.findLineStart (s : String) (pos : String.Pos) : String.Pos 
goal: String.Pos

full_name: Lean.findIndentAndIsStart
code: /--
Return the indentation (number of leading spaces) of the line containing `pos`,
and whether `pos` is the first non-whitespace character in the line.
-/
def Lean.findIndentAndIsStart (s : String) (pos : String.Pos) : Nat × Bool 
goal: Nat × Bool
File: .lake/packages/batteries/Batteries/Lean/Expr.lean

full_name: Lean.Expr.toSyntax
code: /-- Converts an `Expr` into a `Syntax`, by creating a fresh metavariable
assigned to the expr and  returning a named metavariable syntax `?a`. -/
def toSyntax (e : Expr) : TermElabM Syntax.Term 
goal: Lean.Elab.TermElabM Lean.Term

full_name: Lean.Expr.forallArity
code: /--
Returns the number of leading `∀` binders of an expression. Ignores metadata.
-/
def forallArity : Expr → Nat
  
goal: Lean.Expr → Nat

full_name: Lean.Expr.lambdaArity
code: /--
Returns the number of leading `λ` binders of an expression. Ignores metadata.
-/
def lambdaArity : Expr → Nat
  
goal: Lean.Expr → Nat

full_name: Lean.Expr.getAppNumArgs'
code: /-- Like `getAppNumArgs` but ignores metadata. -/
def getAppNumArgs' (e : Expr) : Nat 
goal: Nat

full_name: Lean.Expr.getAppNumArgs'.go
code: /-- Like `getAppNumArgs` but ignores metadata. -/
def getAppNumArgs' (e : Expr) : Nat 
goal: Lean.Expr → Nat → Nat

full_name: Lean.Expr.withApp'
code: /-- Like `withApp` but ignores metadata. -/
@[inline]
def withApp' (e : Expr) (k : Expr → Array Expr → α) : α 
goal: α

full_name: Lean.Expr.withApp'.go
code: /-- Like `withApp` but ignores metadata. -/
@[inline]
def withApp' (e : Expr) (k : Expr → Array Expr → α) : α 
goal: Lean.Expr → Array Lean.Expr → Nat → α

full_name: Lean.Expr.getAppArgs'
code: /-- Like `getAppArgs` but ignores metadata. -/
@[inline]
def getAppArgs' (e : Expr) : Array Expr 
goal: Array Lean.Expr

full_name: Lean.Expr.traverseApp'
code: /-- Like `traverseApp` but ignores metadata. -/
def traverseApp' {m} [Monad m]
  (f : Expr → m Expr) (e : Expr) : m Expr 
goal: m Lean.Expr

full_name: Lean.Expr.withAppRev'.go
code: /-- Like `withAppRev` but ignores metadata. -/
@[inline]
def withAppRev' (e : Expr) (k : Expr → Array Expr → α) : α 
goal: Lean.Expr → Array Lean.Expr → α

full_name: Lean.Expr.withAppRev'
code: /-- Like `withAppRev` but ignores metadata. -/
@[inline]
def withAppRev' (e : Expr) (k : Expr → Array Expr → α) : α 
goal: α

full_name: Lean.Expr.getAppRevArgs'
code: /-- Like `getAppRevArgs` but ignores metadata. -/
@[inline]
def getAppRevArgs' (e : Expr) : Array Expr 
goal: Array Lean.Expr

full_name: Lean.Expr.getRevArgD'
code: /-- Like `getRevArgD` but ignores metadata. -/
def getRevArgD' : Expr → Nat → Expr → Expr
  
goal: Lean.Expr → Nat → Lean.Expr → Lean.Expr

full_name: Lean.Expr.getArgD'
code: /-- Like `getArgD` but ignores metadata. -/
@[inline]
def getArgD' (e : Expr) (i : Nat) (v₀ : Expr) (n := e.getAppNumArgs') : Expr 
goal: Lean.Expr

full_name: Lean.Expr.isAppOf'
code: /-- Like `isAppOf` but ignores metadata. -/
def isAppOf' (e : Expr) (n : Name) : Bool 
goal: Bool

full_name: Lean.Expr.natLit!
code: /-- Turns an expression that is a natural number literal into a natural number. -/
def natLit! : Expr → Nat
  
goal: Lean.Expr → Nat

full_name: Lean.Expr.intLit!
code: /-- Turns an expression that is a constructor of `Int` applied to a natural number literal
into an integer. -/
def intLit! (e : Expr) : Int 
goal: Int
File: .lake/packages/batteries/Batteries/Lean/Meta/Clear.lean

full_name: Lean.MVarId.tryClearMany'
code: /--
Try to clear the given fvars from the local context. Returns the new goal and
the hypotheses that were cleared. Unlike `Lean.MVarId.tryClearMany`, this
function does not require the `hyps` to be given in the order in which they
appear in the local context.
-/
def Lean.MVarId.tryClearMany' (goal : MVarId) (hyps : Array FVarId) :
    MetaM (MVarId × Array FVarId) 
goal: Lean.MetaM (Lean.MVarId × Array Lean.FVarId)
File: .lake/packages/batteries/Batteries/Lean/Meta/InstantiateMVars.lean

full_name: Lean.MVarId.instantiateMVarsInType
code: /--
Instantiate metavariables in the type of the given metavariable, update the
metavariable's declaration and return the new type.
-/
def instantiateMVarsInType [Monad m] [MonadMCtx m] [MonadError m]
    (mvarId : MVarId) : m Expr 
goal: m Lean.Expr

full_name: Lean.MVarId.instantiateMVarsInLocalDecl
code: /--
Instantiate metavariables in the `LocalDecl` of the given fvar, update the
`LocalDecl` and return the new `LocalDecl.`
-/
def instantiateMVarsInLocalDecl [Monad m] [MonadMCtx m] [MonadError m]
    (mvarId : MVarId) (fvarId : FVarId) : m LocalDecl 
goal: m Lean.LocalDecl

full_name: Lean.MVarId.instantiateMVarsInLocalContext
code: /--
Instantiate metavariables in the local context of the given metavariable, update
the metavariable's declaration and return the new local context.
-/
def instantiateMVarsInLocalContext [Monad m] [MonadMCtx m] [MonadError m]
    (mvarId : MVarId) : m LocalContext 
goal: m Lean.LocalContext

full_name: Lean.MVarId.instantiateMVars
code: /--
Instantiate metavariables in the local context and type of the given
metavariable.
-/
def instantiateMVars [Monad m] [MonadMCtx m] [MonadError m] (mvarId : MVarId) :
    m Unit 
goal: m Unit
File: .lake/packages/batteries/Batteries/Lean/Meta/DiscrTree.lean

full_name: Lean.Meta.DiscrTree.Key.cmp
code: /--
Compare two `Key`s. The ordering is total but otherwise arbitrary. (It uses
`Name.quickCmp` internally.)
-/
protected def cmp : Key → Key → Ordering
  
goal: Lean.Meta.DiscrTree.Key → Lean.Meta.DiscrTree.Key → Ordering

full_name: Lean.Meta.DiscrTree.Key.«instOrd_.lake»
code: instance : Ord Key 
goal: Ord Lean.Meta.DiscrTree.Key

full_name: Lean.Meta.DiscrTree.Trie.mergePreservingDuplicates.mergeChildren
code: /--
Merge two `Trie`s. Duplicate values are preserved.
-/
partial def mergePreservingDuplicates : Trie α → Trie α → Trie α
  
goal: Array (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α)

full_name: Lean.Meta.DiscrTree.Trie.mergePreservingDuplicates
code: /--
Merge two `Trie`s. Duplicate values are preserved.
-/
partial def mergePreservingDuplicates : Trie α → Trie α → Trie α
  
goal: Lean.Meta.DiscrTree.Trie α → Lean.Meta.DiscrTree.Trie α → Lean.Meta.DiscrTree.Trie α

full_name: Lean.Meta.DiscrTree.mergePreservingDuplicates
code: /--
Merge two `DiscrTree`s. Duplicate values are preserved.
-/
@[inline]
def mergePreservingDuplicates (t u : DiscrTree α) : DiscrTree α 
goal: Lean.Meta.DiscrTree α
File: .lake/packages/batteries/Batteries/Lean/Meta/Expr.lean

full_name: Lean.Literal.«instOrd_.lake»
code: instance : Ord Literal 
goal: Ord Lean.Literal
File: .lake/packages/batteries/Batteries/Lean/Meta/Inaccessible.lean

full_name: Lean.LocalContext.inaccessibleFVars
code: /--
Obtain the inaccessible fvars from the given local context. An fvar is
inaccessible if (a) its user name is inaccessible or (b) it is shadowed by a
later fvar with the same user name.
-/
def Lean.LocalContext.inaccessibleFVars (lctx : LocalContext) :
    Array LocalDecl 
goal: Array Lean.LocalDecl

full_name: Lean.Meta.getInaccessibleFVars
code: /--
Obtain the inaccessible fvars from the current local context. An fvar is
inaccessible if (a) its user name is inaccessible or (b) it is shadowed by a
later fvar with the same user name.
-/
def Lean.Meta.getInaccessibleFVars [Monad m] [MonadLCtx m] :
    m (Array LocalDecl) 
goal: m (Array Lean.LocalDecl)

full_name: Lean.MVarId.renameInaccessibleFVars
code: /--
Rename all inaccessible fvars. An fvar is inaccessible if (a) its user name is
inaccessible or (b) it is shadowed by a later fvar with the same user name. This
function gives all inaccessible fvars a unique, accessible user name. It returns
the new goal and the fvars that were renamed.
-/
def Lean.MVarId.renameInaccessibleFVars (mvarId : MVarId) :
    MetaM (MVarId × Array FVarId) 
goal: Lean.MetaM (Lean.MVarId × Array Lean.FVarId)
File: .lake/packages/batteries/Batteries/Lean/Float.lean

full_name: Float.inf
code: /--
The floating point value "positive infinity", also used to represent numerical computations
which produce finite values outside of the representable range of `Float`.
-/
def inf : Float 
goal: Float

full_name: Float.nan
code: /--
The floating point value "not a number", used to represent erroneous numerical computations
such as `0 / 0`. Using `nan` in any float operation will return `nan`, and all comparisons
involving `nan` return `false`, including in particular `nan == nan`.
-/
def nan : Float 
goal: Float

full_name: Float.toRatParts
code: /-- Returns `v, exp` integers such that `f = v * 2^exp`.
(`e` is not minimal, but `v.abs` will be at most `2^53 - 1`.)
Returns `none` when `f` is not finite (i.e. `inf`, `-inf` or a `nan`). -/
def toRatParts (f : Float) : Option (Int × Int) 
goal: Option (Int × Int)

full_name: Float.toRatParts'
code: /-- Returns `v, exp` integers such that `f = v * 2^exp`.
Like `toRatParts`, but `e` is guaranteed to be minimal (`n` is always odd), unless `n = 0`.
`n.abs` will be at most `2^53 - 1` because `Float` has 53 bits of precision.
Returns `none` when `f` is not finite (i.e. `inf`, `-inf` or a `nan`). -/
partial def toRatParts' (f : Float) : Option (Int × Int) 
goal: Option (Int × Int)

full_name: Float.toRatParts'.trailingZeros
code: /-- Returns `v, exp` integers such that `f = v * 2^exp`.
Like `toRatParts`, but `e` is guaranteed to be minimal (`n` is always odd), unless `n = 0`.
`n.abs` will be at most `2^53 - 1` because `Float` has 53 bits of precision.
Returns `none` when `f` is not finite (i.e. `inf`, `-inf` or a `nan`). -/
partial def toRatParts' (f : Float) : Option (Int × Int) 
goal: UInt8

full_name: Float.toStringFull
code: /-- Converts `f` to a string, including all decimal digits. -/
def toStringFull (f : Float) : String 
goal: String

full_name: Nat.divFloat
code: /--
Divide two natural numbers, to produce a correctly rounded (nearest-ties-to-even) `Float` result.
-/
protected def Nat.divFloat (a b : Nat) : Float 
goal: Float

full_name: Int.divFloat
code: /--
Divide two integers, to produce a correctly rounded (nearest-ties-to-even) `Float` result.
-/
protected def Int.divFloat (a b : Int) : Float 
goal: Float
File: .lake/packages/batteries/Batteries/Data/MLList/Heartbeats.lean

full_name: MLList.whileAtLeastHeartbeatsPercent
code: /-- Take an initial segment of a monadic lazy list,
stopping when there is less than `percent` of the remaining allowed heartbeats.

If `getMaxHeartbeats` returns `0`, then this passes through the original list unmodified.

The `initial` heartbeat counter is recorded when the first element of the list is requested.
Then each time an element is requested from the wrapped list the heartbeat counter is checked, and
if `current * 100 / initial < percent` then that element is returned,
but no further elements.
-/
def MLList.whileAtLeastHeartbeatsPercent [Monad m] [MonadLiftT CoreM m]
    (L : MLList m α) (percent : Nat := 10) : MLList m α 
goal: MLList m α
File: .lake/packages/batteries/Batteries/Lean/Meta/SavedState.lean

full_name: Lean.Meta.SavedState.runMetaM
code: /--
Run the action `x` in state `s`. Returns the result of `x` and the state after
`x` was executed. The global state remains unchanged.
-/
def runMetaM (s : Meta.SavedState) (x : MetaM α) :
    MetaM (α × Meta.SavedState) 
goal: Lean.MetaM (α × Lean.Meta.SavedState)

full_name: Lean.Meta.SavedState.runMetaM'
code: /--
Run the action `x` in state `s`. Returns the result of `x`. The global state
remains unchanged.
-/
def runMetaM' (s : Meta.SavedState) (x : MetaM α) : MetaM α 
goal: Lean.MetaM α

full_name: Lean.Meta.getIntroducedExprMVars
code: /--
Returns the mvars that are not declared in `preState`, but declared and
unassigned in `postState`. Delayed-assigned mvars are considered assigned.
-/
def getIntroducedExprMVars (preState postState : SavedState) :
    MetaM (Array MVarId) 
goal: Lean.MetaM (Array Lean.MVarId)

full_name: Lean.Meta.getAssignedExprMVars
code: /--
Returns the mvars that are declared but unassigned in `preState`, and
assigned in `postState`. Delayed-assigned mvars are considered assigned.
-/
def getAssignedExprMVars (preState postState : SavedState) :
    MetaM (Array MVarId) 
goal: Lean.MetaM (Array Lean.MVarId)
File: .lake/packages/batteries/Batteries/Lean/Meta/AssertHypotheses.lean

full_name: Lean.Meta.Hypothesis'.binderInfo
code: /--
Description of a hypothesis for `Lean.MVarId.assertHypotheses'`.
-/
structure Hypothesis' extends Hypothesis where
  /-- The hypothesis' `BinderInfo` -/
  binderInfo : BinderInfo
  /-- The hypothesis' `LocalDeclKind` -/
  kind : LocalDeclKind
goal: Lean.BinderInfo

full_name: Lean.Meta.Hypothesis'.kind
code: /--
Description of a hypothesis for `Lean.MVarId.assertHypotheses'`.
-/
structure Hypothesis' extends Hypothesis where
  /-- The hypothesis' `BinderInfo` -/
  binderInfo : BinderInfo
  /-- The hypothesis' `LocalDeclKind` -/
  kind : LocalDeclKind
goal: Lean.LocalDeclKind

full_name: Lean.Meta.Hypothesis'
code: /--
Description of a hypothesis for `Lean.MVarId.assertHypotheses'`.
-/
structure Hypothesis' extends Hypothesis where
  /-- The hypothesis' `BinderInfo` -/
  binderInfo : BinderInfo
  /-- The hypothesis' `LocalDeclKind` -/
  kind : LocalDeclKind
goal: Type

full_name: Lean.MVarId.assertHypotheses'
code: /--
Add the given hypotheses to the local context. This is a generalisation of
`Lean.MVarId.assertHypotheses` which lets you specify
-/
def _root_.Lean.MVarId.assertHypotheses' (mvarId : MVarId)
    (hs : Array Hypothesis') : MetaM (Array FVarId × MVarId) 
goal: Lean.MetaM (Array Lean.FVarId × Lean.MVarId)
File: .lake/packages/batteries/Batteries/Data/List/Init/Attach.lean

full_name: List.pmap
code: /-- `O(n)`. Partial map. If `f : Π a, P a → β` is a partial function defined on
  `a : α` satisfying `P`, then `pmap f l h` is essentially the same as `map f l`
  but is defined only when all members of `l` satisfy `P`, using the proof
  to apply `f`. -/
@[simp] def pmap {P : α → Prop} (f : ∀ a, P a → β) : ∀ l : List α, (H : ∀ a ∈ l, P a) → List β
  
goal: List β

full_name: _private.«.lake».packages.batteries.Batteries.Data.List.Init.Attach.0.List.attachWithImpl
code: /--
Unsafe implementation of `attachWith`, taking advantage of the fact that the representation of
`List {x // P x}` is the same as the input `List α`.
(Someday, the compiler might do this optimization automatically, but until then...)
-/
@[inline] private unsafe def attachWithImpl
    (l : List α) (P : α → Prop) (_ : ∀ x ∈ l, P x) : List {x // P x} 
goal: (∀ (x : α), x ∈ l → P x) → List { x // P x }

full_name: List.attachWith
code: /-- `O(1)`. "Attach" a proof `P x` that holds for all the elements of `l` to produce a new list
  with the same elements but in the type `{x // P x}`. -/
@[implemented_by attachWithImpl] def attachWith
    (l : List α) (P : α → Prop) (H : ∀ x ∈ l, P x) : List {x // P x} 
goal: List { x // P x }

full_name: List.attach
code: /-- `O(1)`. "Attach" the proof that the elements of `l` are in `l` to produce a new list
  with the same elements but in the type `{x // x ∈ l}`. -/
@[inline] def attach (l : List α) : List {x // x ∈ l} 
goal: List { x // x ∈ l }

full_name: _private.«.lake».packages.batteries.Batteries.Data.List.Init.Attach.0.List.pmapImpl
code: /-- Implementation of `pmap` using the zero-copy version of `attach`. -/
@[inline] private def pmapImpl {P : α → Prop} (f : ∀ a, P a → β) (l : List α) (H : ∀ a ∈ l, P a) :
    List β 
goal: List β

full_name: _private.«.lake».packages.batteries.Batteries.Data.List.Init.Attach.0.List.pmap_eq_pmapImpl.go
code: @[csimp] private theorem pmap_eq_pmapImpl : @pmap = @pmapImpl 
goal: List.pmap f L' hL' =
  List.map
    (fun x =>
      match x with
      | ⟨x, hx⟩ => f x hx)
    (List.pmap Subtype.mk L' hL')

full_name: _private.«.lake».packages.batteries.Batteries.Data.List.Init.Attach.0.List.pmap_eq_pmapImpl
code: @[csimp] private theorem pmap_eq_pmapImpl : @pmap = @pmapImpl 
goal: @List.pmap = @List.pmapImpl
File: .lake/packages/batteries/Batteries/Data/List/EraseIdx.lean

full_name: List.eraseIdx_zero
code: @[simp] theorem eraseIdx_zero (l : List α) : eraseIdx l 0 = tail l 
goal: l.eraseIdx 0 = l.tail

full_name: List.eraseIdx_eq_take_drop_succ
code: theorem eraseIdx_eq_take_drop_succ :
    ∀ (l : List α) (i : Nat), l.eraseIdx i = l.take i ++ l.drop (i + 1)
  
goal: l.eraseIdx i = List.take i l ++ List.drop (i + 1) l

full_name: List.eraseIdx_sublist
code: theorem eraseIdx_sublist : ∀ (l : List α) (k : Nat), eraseIdx l k <+ l
  
goal: (l.eraseIdx k).Sublist l

full_name: List.eraseIdx_subset
code: theorem eraseIdx_subset (l : List α) (k : Nat) : eraseIdx l k ⊆ l 
goal: l.eraseIdx k ⊆ l

full_name: List.eraseIdx_eq_self
code: @[simp]
theorem eraseIdx_eq_self : ∀ {l : List α} {k : Nat}, eraseIdx l k = l ↔ length l ≤ k
  
goal: l.eraseIdx k = l ↔ l.length ≤ k

full_name: List.eraseIdx_append_of_lt_length
code: theorem eraseIdx_append_of_lt_length {l : List α} {k : Nat} (hk : k < length l) (l' : List α) :
    eraseIdx (l ++ l') k = eraseIdx l k ++ l' 
goal: (l ++ l').eraseIdx k = l.eraseIdx k ++ l'

full_name: List.eraseIdx_append_of_length_le
code: theorem eraseIdx_append_of_length_le {l : List α} {k : Nat} (hk : length l ≤ k) (l' : List α) :
    eraseIdx (l ++ l') k = l ++ eraseIdx l' (k - length l) 
goal: (l ++ l').eraseIdx k = l ++ l'.eraseIdx (k - l.length)

full_name: List.IsPrefix.eraseIdx
code: protected theorem IsPrefix.eraseIdx {l l' : List α} (h : l <+: l') (k : Nat) :
    eraseIdx l k <+: eraseIdx l' k 
goal: l.eraseIdx k <+: l'.eraseIdx k

full_name: List.mem_eraseIdx_iff_getElem
code: theorem mem_eraseIdx_iff_getElem {x : α} :
    ∀ {l} {k}, x ∈ eraseIdx l k ↔ ∃ i : Fin l.length, ↑i ≠ k ∧ l[i.1] = x
  
goal: x ∈ l.eraseIdx k ↔ ∃ i, ↑i ≠ k ∧ l[↑i] = x

full_name: List.mem_eraseIdx_iff_get
code: @[deprecated mem_eraseIdx_iff_getElem (since := "2024-06-12")]
theorem mem_eraseIdx_iff_get {x : α} {l} {k} :
    x ∈ eraseIdx l k ↔ ∃ i : Fin l.length, ↑i ≠ k ∧ l.get i = x 
goal: x ∈ l.eraseIdx k ↔ ∃ i, ↑i ≠ k ∧ l.get i = x

full_name: List.mem_eraseIdx_iff_getElem?
code: theorem mem_eraseIdx_iff_getElem? {x : α} {l} {k} : x ∈ eraseIdx l k ↔ ∃ i ≠ k, l[i]? = some x 
goal: x ∈ l.eraseIdx k ↔ ∃ i, i ≠ k ∧ l[i]? = some x

full_name: List.mem_eraseIdx_iff_get?
code: @[deprecated mem_eraseIdx_iff_getElem? (since := "2024-06-12")]
theorem mem_eraseIdx_iff_get? {x : α} {l} {k} : x ∈ eraseIdx l k ↔ ∃ i ≠ k, l.get? i = x 
goal: x ∈ l.eraseIdx k ↔ ∃ i, i ≠ k ∧ l.get? i = some x
File: .lake/packages/batteries/Batteries/Data/Fin/Basic.lean

full_name: Fin.clamp
code: /-- `min n m` as an element of `Fin (m + 1)` -/
def clamp (n m : Nat) : Fin (m + 1) 
goal: Fin (m + 1)

full_name: Fin.enum
code: /-- `enum n` is the array of all elements of `Fin n` in order -/
def enum (n) : Array (Fin n) 
goal: Array (Fin n)

full_name: Fin.list
code: /-- `list n` is the list of all elements of `Fin n` in order -/
def list (n) : List (Fin n) 
goal: List (Fin n)
File: .lake/packages/batteries/Batteries/Data/Thunk.lean

full_name: Thunk.ext
code: @[ext] protected theorem ext : {a b : Thunk α} → a.get = b.get → a = b
  
goal: a.get = b.get → a = b