ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/lean4/src/lean/Lean/Data/Json/Elab.lean

full_name: Lean.Parser.Category.json
code: /-- Json syntactic category -/
declare_syntax_cat json (behavior := symbol)
goal: Lean.Parser.Category

full_name: Lean.Json.jsonNull
code: /-- Json null value syntax. -/
syntax "null" : json
goal: Lean.ParserDescr

full_name: Lean.Json.jsonTrue
code: /-- Json true value syntax. -/
syntax "true" : json
goal: Lean.ParserDescr

full_name: Lean.Json.jsonFalse
code: /-- Json false value syntax. -/
syntax "false" : json
goal: Lean.ParserDescr

full_name: Lean.Json.json_
code: /-- Json string syntax. -/
syntax str : json
goal: Lean.ParserDescr

full_name: Lean.Json.«json-_»
code: /-- Json number negation syntax for ordinary numbers. -/
syntax "-"? num : json
goal: Lean.ParserDescr

full_name: Lean.Json.«json-__1»
code: /-- Json number negation syntax for scientific numbers. -/
syntax "-"? scientific : json
goal: Lean.ParserDescr

full_name: Lean.Json.«json[_]»
code: /-- Json array syntax. -/
syntax "[" json,* "]" : json
goal: Lean.ParserDescr

full_name: Lean.Json.jsonIdent
code: /-- Json identifier syntax. -/
syntax jsonIdent := ident <|> str
goal: Lean.ParserDescr

full_name: Lean.Json.jsonField
code: /-- Json key/value syntax. -/
syntax jsonField := jsonIdent ": " json
goal: Lean.ParserDescr

full_name: Lean.Json.«json{_}»
code: /-- Json object syntax. -/
syntax "{" jsonField,* "}" : json
goal: Lean.ParserDescr

full_name: Lean.Json.«termJson%_»
code: /-- Allows to use Json syntax in a Lean file. -/
syntax "json% " json : term
goal: Lean.ParserDescr

full_name: Lean.Json.«_aux_.lake_packages_lean4_src_lean_Lean_Data_Json_Elab___macroRules_Lean_Json_termJson%__1»
code: macro_rules
  | `(json% null)           => `(Lean.Json.null)
  | `(json% true)           => `(Lean.Json.bool Bool.true)
  | `(json% false)          => `(Lean.Json.bool Bool.false)
  | `(json% $n:str)         => `(Lean.Json.str $n)
  | `(json% $n:num)         => `(Lean.Json.num $n)
  | `(json% $n:scientific)  => `(Lean.Json.num $n)
  | `(json% -$n:num)        => `(Lean.Json.num (-$n))
  | `(json% -$n:scientific) => `(Lean.Json.num (-$n))
  | `(json% [$[$xs],*])     => `(Lean.Json.arr #[$[json% $xs],*])
  | `(json% {$[$ks:jsonIdent : $vs:json],*}) => do
    let ks : Array (TSyntax `term) ← ks.mapM fun
      | `(jsonIdent| $k:ident) => pure (k.getId |> toString |> quote)
      | `(jsonIdent| $k:str)   => pure k
      | _                     => Macro.throwUnsupported
    `(Lean.Json.mkObj [$[($ks, json% $vs)],*])
  | `(json% $stx)           =>
    if stx.raw.isAntiquot then
      let stx := ⟨stx.raw.getAntiquotTerm⟩
      `(Lean.toJson $stx)
    else
      Macro.throwUnsupported
goal: Lean.Macro
File: .lake/packages/lean4/src/lean/Lean/Meta/CompletionName.lean

full_name: Lean.Meta.completionBlackListExt
code: builtin_initialize completionBlackListExt : TagDeclarationExtension ← mkTagDeclarationExtension
goal: Lean.TagDeclarationExtension

full_name: Lean.Meta.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.CompletionName._hyg.5
code: builtin_initialize completionBlackListExt : TagDeclarationExtension ← mkTagDeclarationExtension
goal: IO Lean.TagDeclarationExtension

full_name: Lean.Meta.addToCompletionBlackList
code: def addToCompletionBlackList (env : Environment) (declName : Name) : Environment 
goal: Lean.Environment

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.CompletionName.0.Lean.Meta.isInternalNameModuloPrivate
code: /--
Checks whether a given name is internal due to something other than `_private`.
Correctly deals with names like `_private.<SomeNamespace>.0.<SomeType>._sizeOf_1` in a private type
`SomeType`, which `n.isInternal && !isPrivateName n` does not.
-/
private def isInternalNameModuloPrivate : Name → Bool
  
goal: Lean.Name → Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.CompletionName.0.Lean.Meta.isBlacklisted
code: /--
Return true if name is blacklisted for completion purposes.
-/
private def isBlacklisted (env : Environment) (declName : Name) : Bool 
goal: Bool

full_name: Lean.Meta.allowCompletion
code: /--
Return true if completion is allowed for name.
-/
def allowCompletion (env : Environment) (declName : Name) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/Meta/Constructions/RecOn.lean

full_name: mkRecOn
code: def mkRecOn (n : Name) : MetaM Unit 
goal: Lean.MetaM Unit
File: .lake/packages/lean4/src/lean/Lean/Meta/Iterator.lean

full_name: Lean.Meta.Iterator
code: /--
Provides an iterface for iterating over values that are bundled with the `Meta` state
they are valid in.
-/
protected structure Iterator (α : Type) where
  /-- Function for getting next value and state pair. -/
  next : MetaM (Option (α × Meta.SavedState))
goal: Type

full_name: Lean.Meta.Iterator.next
code: /--
Provides an iterface for iterating over values that are bundled with the `Meta` state
they are valid in.
-/
protected structure Iterator (α : Type) where
  /-- Function for getting next value and state pair. -/
  next : MetaM (Option (α × Meta.SavedState))
goal: Lean.MetaM (Option (α × Lean.Meta.SavedState))

full_name: Lean.Meta.Iterator.ofList
code: /--
Convert a list into an iterator with the current state.
-/
def ofList (l : List α) : MetaM (Meta.Iterator α) 
goal: Lean.MetaM (Lean.Meta.Iterator α)

full_name: Lean.Meta.Iterator.filterMapM._next
code: /--
Map and filter results of iterator and returning only those values returned
by `f`.
-/
partial def filterMapM (f : α → MetaM (Option β)) (L : Meta.Iterator α) : Meta.Iterator β 
goal: Lean.MetaM (Option (β × Lean.Meta.SavedState))

full_name: Lean.Meta.Iterator.filterMapM
code: /--
Map and filter results of iterator and returning only those values returned
by `f`.
-/
partial def filterMapM (f : α → MetaM (Option β)) (L : Meta.Iterator α) : Meta.Iterator β 
goal: Lean.Meta.Iterator β

full_name: Lean.Meta.Iterator.head
code: /--
Find the first value in the iterator while resetting state or call `failure`
if empty.
-/
def head (L : Meta.Iterator α) : MetaM α 
goal: Lean.MetaM α

full_name: Lean.Meta.Iterator.firstM
code: /--
Return the first value returned by the iterator that `f` succeeds on.
-/
def firstM (L : Meta.Iterator α) (f : α → MetaM (Option β)) : MetaM β 
goal: Lean.MetaM β
File: .lake/packages/lean4/src/lean/Lean/Meta/Match.lean

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Match._hyg.4
code: builtin_initialize registerTraceClass `Meta.Match
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Meta/CtorRecognizer.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.CtorRecognizer.0.Lean.Meta.getConstructorVal?
code: private def getConstructorVal? (env : Environment) (ctorName : Name) : Option ConstructorVal 
goal: Option Lean.ConstructorVal

full_name: Lean.Meta.isConstructorAppCore?
code: /--
If `e` is a constructor application,
then return the corresponding `ConstructorVal`.
-/
def isConstructorAppCore? (e : Expr) : MetaM (Option ConstructorVal) 
goal: Lean.MetaM (Option Lean.ConstructorVal)

full_name: Lean.Meta.isConstructorApp?
code: /--
If `e` is a constructor application or a builtin literal defeq to a constructor application,
then return the corresponding `ConstructorVal`.
-/
def isConstructorApp? (e : Expr) : MetaM (Option ConstructorVal) 
goal: Lean.MetaM (Option Lean.ConstructorVal)

full_name: Lean.Meta.isConstructorApp'?
code: /--
Similar to `isConstructorApp?`, but uses `whnf`.
-/
def isConstructorApp'? (e : Expr) : MetaM (Option ConstructorVal) 
goal: Lean.MetaM (Option Lean.ConstructorVal)

full_name: Lean.Meta.isConstructorApp
code: /--
Returns `true`, if `e` is constructor application of builtin literal defeq to
a constructor application.
-/
def isConstructorApp (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.isConstructorApp'
code: /--
Returns `true` if `isConstructorApp e` or `isConstructorApp (← whnf e)`
-/
def isConstructorApp' (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.constructorApp?
code: /--
If `e` is a constructor application, return a pair containing the corresponding `ConstructorVal` and the constructor
application arguments.
-/
def constructorApp? (e : Expr) : MetaM (Option (ConstructorVal × Array Expr)) 
goal: Lean.MetaM (Option (Lean.ConstructorVal × Array Lean.Expr))

full_name: Lean.Meta.constructorApp'?
code: /--
Similar to `constructorApp?`, but on failure it puts `e` in WHNF and tries again.
It also `isOffset?`
-/
def constructorApp'? (e : Expr) : MetaM (Option (ConstructorVal × Array Expr)) 
goal: Lean.MetaM (Option (Lean.ConstructorVal × Array Lean.Expr))
File: .lake/packages/lean4/src/lean/Lean/Meta/Match/MatchPatternAttr.lean

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Match.MatchPatternAttr._hyg.4
code: builtin_initialize matchPatternAttr : TagAttribute ←
  registerTagAttribute `match_pattern "mark that a definition can be used in a pattern (remark: the dependent pattern matching compiler will unfold the definition)"
goal: IO Lean.TagAttribute

full_name: Lean.matchPatternAttr
code: builtin_initialize matchPatternAttr : TagAttribute ←
  registerTagAttribute `match_pattern "mark that a definition can be used in a pattern (remark: the dependent pattern matching compiler will unfold the definition)"
goal: Lean.TagAttribute

full_name: Lean.hasMatchPatternAttribute
code: @[export lean_has_match_pattern_attribute]
def hasMatchPatternAttribute (env : Environment) (n : Name) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/Meta/Offset.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Offset.0.Lean.Meta.withInstantiatedMVars
code: private abbrev withInstantiatedMVars (e : Expr) (k : Expr → OptionT MetaM α) : OptionT MetaM α 
goal: OptionT Lean.MetaM α

full_name: Lean.Meta.evalNat.visit
code: /--
  Evaluate simple `Nat` expressions.
  Remark: this method assumes the given expression has type `Nat`. -/
partial def evalNat (e : Expr) : OptionT MetaM Nat 
goal: OptionT Lean.MetaM Nat

full_name: Lean.Meta.evalNat
code: /--
  Evaluate simple `Nat` expressions.
  Remark: this method assumes the given expression has type `Nat`. -/
partial def evalNat (e : Expr) : OptionT MetaM Nat 
goal: OptionT Lean.MetaM Nat

full_name: Lean.Meta.matchesInstance
code: /--
Checks that expression `e` is definitional equal to `inst`.

Uses `instances` transparency so that reducible terms and instances extended
other instances are unfolded.
-/
def matchesInstance (e inst : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Offset.0.Lean.Meta.isNatZero
code: private def isNatZero (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Offset.0.Lean.Meta.mkOffset
code: private def mkOffset (e : Expr) (offset : Nat) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: Lean.Meta.isDefEqOffset
code: def isDefEqOffset (s t : Expr) : MetaM LBool 
goal: Lean.MetaM Lean.LBool
File: .lake/packages/lean4/src/lean/Lean/Meta/Match/Value.lean

full_name: Lean.Meta.isMatchValue
code: /-- Return true is `e` is a term that should be processed by the `match`-compiler using `casesValues` -/
def isMatchValue (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool
File: .lake/packages/lean4/src/lean/Lean/Meta/Match/MVarRenaming.lean

full_name: Lean.Meta.MVarRenaming
code: /-- A mapping from MVarId to MVarId -/
structure MVarRenaming where
  map : MVarIdMap MVarId := {}
goal: Type

full_name: Lean.Meta.MVarRenaming.map
code: /-- A mapping from MVarId to MVarId -/
structure MVarRenaming where
  map : MVarIdMap MVarId := {}
goal: Lean.MVarIdMap Lean.MVarId

full_name: Lean.Meta.MVarRenaming.isEmpty
code: def MVarRenaming.isEmpty (s : MVarRenaming) : Bool 
goal: Bool

full_name: Lean.Meta.MVarRenaming.find?
code: def MVarRenaming.find? (s : MVarRenaming) (mvarId : MVarId) : Option MVarId 
goal: Option Lean.MVarId

full_name: Lean.Meta.MVarRenaming.find!
code: def MVarRenaming.find! (s : MVarRenaming) (mvarId : MVarId) : MVarId 
goal: Lean.MVarId

full_name: Lean.Meta.MVarRenaming.insert
code: def MVarRenaming.insert (s : MVarRenaming) (mvarId mvarId' : MVarId) : MVarRenaming 
goal: Lean.Meta.MVarRenaming

full_name: Lean.Meta.MVarRenaming.apply
code: def MVarRenaming.apply (s : MVarRenaming) (e : Expr) : Expr 
goal: Lean.Expr
File: .lake/packages/lean4/src/lean/Lean/Meta/Match/CaseArraySizes.lean

full_name: Lean.Meta.CaseArraySizesSubgoal.subst
code: structure CaseArraySizesSubgoal where
  mvarId : MVarId
  elems  : Array FVarId := #[]
  diseqs : Array FVarId := #[]
  subst  : FVarSubst := {}
  deriving Inhabited
goal: Lean.Meta.FVarSubst

full_name: Lean.Meta.instInhabitedCaseArraySizesSubgoal
code: structure CaseArraySizesSubgoal where
  mvarId : MVarId
  elems  : Array FVarId := #[]
  diseqs : Array FVarId := #[]
  subst  : FVarSubst := {}
  deriving Inhabited
goal: Inhabited Lean.Meta.CaseArraySizesSubgoal

full_name: Lean.Meta.CaseArraySizesSubgoal.elems
code: structure CaseArraySizesSubgoal where
  mvarId : MVarId
  elems  : Array FVarId := #[]
  diseqs : Array FVarId := #[]
  subst  : FVarSubst := {}
  deriving Inhabited
goal: Array Lean.FVarId

full_name: Lean.Meta.CaseArraySizesSubgoal.diseqs
code: structure CaseArraySizesSubgoal where
  mvarId : MVarId
  elems  : Array FVarId := #[]
  diseqs : Array FVarId := #[]
  subst  : FVarSubst := {}
  deriving Inhabited
goal: Array Lean.FVarId

full_name: Lean.Meta.CaseArraySizesSubgoal
code: structure CaseArraySizesSubgoal where
  mvarId : MVarId
  elems  : Array FVarId := #[]
  diseqs : Array FVarId := #[]
  subst  : FVarSubst := {}
  deriving Inhabited
goal: Type

full_name: Lean.Meta.CaseArraySizesSubgoal.mvarId
code: structure CaseArraySizesSubgoal where
  mvarId : MVarId
  elems  : Array FVarId := #[]
  diseqs : Array FVarId := #[]
  subst  : FVarSubst := {}
  deriving Inhabited
goal: Lean.MVarId

full_name: Lean.Meta.getArrayArgType
code: def getArrayArgType (a : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Match.CaseArraySizes.0.Lean.Meta.mkArrayGetLit
code: private def mkArrayGetLit (a : Expr) (i : Nat) (n : Nat) (h : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Match.CaseArraySizes.0.Lean.Meta.introArrayLit.loop
code: private partial def introArrayLit (mvarId : MVarId) (a : Expr) (n : Nat) (xNamePrefix : Name) (aSizeEqN : Expr) : MetaM MVarId 
goal: Lean.MetaM (Lean.Expr × Array Lean.Expr)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Match.CaseArraySizes.0.Lean.Meta.introArrayLit
code: private partial def introArrayLit (mvarId : MVarId) (a : Expr) (n : Nat) (xNamePrefix : Name) (aSizeEqN : Expr) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.caseArraySizes
code: /--
  Split goal `... |- C a` into sizes.size + 1 subgoals
  1) `..., x_1 ... x_{sizes[0]} |- C #[x_1, ... x_{sizes[0]}]`
  ...
  n) `..., x_1 ... x_{sizes[n-1]}  |- C #[x_1, ..., x_{sizes[n-1]}]`
  n+1) `..., (h_1 : a.size != sizes[0]), ..., (h_n : a.size != sizes[n-1]) |- C a`
  where `n = sizes.size` -/
def caseArraySizes (mvarId : MVarId) (fvarId : FVarId) (sizes : Array Nat) (xNamePrefix := `x) (hNamePrefix := `h) : MetaM (Array CaseArraySizesSubgoal) 
goal: Lean.MetaM (Array Lean.Meta.CaseArraySizesSubgoal)
File: .lake/packages/lean4/src/lean/Lean/Meta/CollectFVars.lean

full_name: Lean.Expr.collectFVars
code: def Expr.collectFVars (e : Expr) : StateRefT CollectFVars.State MetaM Unit 
goal: StateRefT' IO.RealWorld Lean.CollectFVars.State Lean.MetaM Unit

full_name: Lean.LocalDecl.collectFVars
code: def LocalDecl.collectFVars (localDecl : LocalDecl) : StateRefT CollectFVars.State MetaM Unit 
goal: StateRefT' IO.RealWorld Lean.CollectFVars.State Lean.MetaM Unit

full_name: Lean.CollectFVars.State.addDependencies.getNext?
code: /-- For each variable in `s.fvarSet`, include its dependencies. -/
partial def CollectFVars.State.addDependencies (s : CollectFVars.State) : MetaM CollectFVars.State 
goal: StateRefT' IO.RealWorld Nat (StateRefT' IO.RealWorld Lean.CollectFVars.State Lean.MetaM) (Option Lean.FVarId)

full_name: Lean.CollectFVars.State.addDependencies
code: /-- For each variable in `s.fvarSet`, include its dependencies. -/
partial def CollectFVars.State.addDependencies (s : CollectFVars.State) : MetaM CollectFVars.State 
goal: Lean.MetaM Lean.CollectFVars.State

full_name: Lean.CollectFVars.State.addDependencies.go
code: /-- For each variable in `s.fvarSet`, include its dependencies. -/
partial def CollectFVars.State.addDependencies (s : CollectFVars.State) : MetaM CollectFVars.State 
goal: StateRefT' IO.RealWorld Nat (StateRefT' IO.RealWorld Lean.CollectFVars.State Lean.MetaM) Unit

full_name: Lean.Meta.removeUnused
code: def removeUnused (vars : Array Expr) (used : CollectFVars.State) : MetaM (LocalContext × LocalInstances × Array Expr) 
goal: Lean.MetaM (Lean.LocalContext × Lean.LocalInstances × Array Lean.Expr)
File: .lake/packages/lean4/src/lean/Lean/Meta/DecLevel.lean

full_name: Lean.Meta.DecLevelContext.canAssignMVars
code: structure DecLevelContext where
  /--
   If `true`, then `decAux? ?m` returns a fresh metavariable `?n` s.t.
   `?m := ?n+1`.
   -/
  canAssignMVars : Bool := true
goal: Bool

full_name: Lean.Meta.DecLevelContext
code: structure DecLevelContext where
  /--
   If `true`, then `decAux? ?m` returns a fresh metavariable `?n` s.t.
   `?m := ?n+1`.
   -/
  canAssignMVars : Bool := true
goal: Type

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.DecLevel.0.Lean.Meta.decAux?
code: private partial def decAux? : Level → ReaderT DecLevelContext MetaM (Option Level)
  
goal: Lean.Level → ReaderT Lean.Meta.DecLevelContext Lean.MetaM (Option Lean.Level)

full_name: Lean.Meta.decLevel?
code: def decLevel? (u : Level) : MetaM (Option Level) 
goal: Lean.MetaM (Option Lean.Level)

full_name: Lean.Meta.decLevel
code: def decLevel (u : Level) : MetaM Level 
goal: Lean.MetaM Lean.Level

full_name: Lean.Meta.getDecLevel
code: /-- This method is useful for inferring universe level parameters for function that take arguments such as `{α : Type u}`.
   Recall that `Type u` is `Sort (u+1)` in Lean. Thus, given `α`, we must infer its universe level,
   and then decrement 1 to obtain `u`. -/
def getDecLevel (type : Expr) : MetaM Level 
goal: Lean.MetaM Lean.Level

full_name: Lean.Meta.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.DecLevel._hyg.738
code: builtin_initialize
  registerTraceClass `Meta.isLevelDefEq.step
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Meta/ReduceEval.lean

full_name: Lean.Meta.ReduceEval.reduceEval
code: class ReduceEval (α : Type) where
  reduceEval : Expr → MetaM α
goal: Lean.Expr → Lean.MetaM α

full_name: Lean.Meta.ReduceEval
code: class ReduceEval (α : Type) where
  reduceEval : Expr → MetaM α
goal: Type

full_name: Lean.Meta.reduceEval
code: def reduceEval [ReduceEval α] (e : Expr) : MetaM α 
goal: Lean.MetaM α

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.ReduceEval.0.Lean.Meta.throwFailedToEval
code: private def throwFailedToEval (e : Expr) : MetaM α 
goal: Lean.MetaM α

full_name: Lean.Meta.instReduceEvalNat
code: instance : ReduceEval Nat 
goal: Lean.Meta.ReduceEval Nat

full_name: Lean.Meta.instReduceEvalOption
code: instance [ReduceEval α] : ReduceEval (Option α) 
goal: Lean.Meta.ReduceEval (Option α)

full_name: Lean.Meta.instReduceEvalString
code: instance : ReduceEval String 
goal: Lean.Meta.ReduceEval String

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.ReduceEval.0.Lean.Meta.evalName
code: private partial def evalName (e : Expr) : MetaM Name 
goal: Lean.MetaM Lean.Name

full_name: Lean.Meta.instReduceEvalName
code: instance : ReduceEval Name 
goal: Lean.Meta.ReduceEval Lean.Name
File: .lake/packages/lean4/src/lean/Lean/Meta/AbstractNestedProofs.lean

full_name: Lean.Meta.AbstractNestedProofs.getLambdaBody
code: def getLambdaBody (e : Expr) : Expr 
goal: Lean.Expr

full_name: Lean.Meta.AbstractNestedProofs.isNonTrivialProof
code: def isNonTrivialProof (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.AbstractNestedProofs.Context.baseName
code: structure Context where
  baseName : Name
goal: Lean.Name

full_name: Lean.Meta.AbstractNestedProofs.Context
code: structure Context where
  baseName : Name
goal: Type

full_name: Lean.Meta.AbstractNestedProofs.State.nextIdx
code: structure State where
  nextIdx : Nat := 1
goal: Nat

full_name: Lean.Meta.AbstractNestedProofs.State
code: structure State where
  nextIdx : Nat := 1
goal: Type

full_name: Lean.Meta.AbstractNestedProofs.M
code: abbrev M 
goal: Type

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.AbstractNestedProofs.0.Lean.Meta.AbstractNestedProofs.mkAuxLemma
code: private def mkAuxLemma (e : Expr) : M Expr 
goal: Lean.Meta.AbstractNestedProofs.M Lean.Expr

full_name: Lean.Meta.AbstractNestedProofs.visit
code: partial def visit (e : Expr) : M Expr 
goal: Lean.Meta.AbstractNestedProofs.M Lean.Expr

full_name: Lean.Meta.abstractNestedProofs
code: /-- Replace proofs nested in `e` with new lemmas. The new lemmas have names of the form `mainDeclName.proof_<idx>` -/
def abstractNestedProofs (mainDeclName : Name) (e : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr
File: .lake/packages/lean4/src/lean/Lean/Meta/CollectMVars.lean

full_name: Lean.Meta.collectMVars
code: /--
  Collect unassigned metavariables occurring in the given expression.

  Remark: if `e` contains `?m` and there is a `t` assigned to `?m`, we
  collect unassigned metavariables occurring in `t`.

  Remark: if `e` contains `?m` and `?m` is delayed assigned to some term `t`,
  we collect `?m` and unassigned metavariables occurring in `t`.
  We collect `?m` because it has not been assigned yet. -/
partial def collectMVars (e : Expr) : StateRefT CollectMVars.State MetaM Unit 
goal: StateRefT' IO.RealWorld Lean.CollectMVars.State Lean.MetaM Unit

full_name: Lean.Meta.getMVars
code: /-- Return metavariables occurring in the given expression. See `collectMVars` -/
def getMVars (e : Expr) : MetaM (Array MVarId) 
goal: Lean.MetaM (Array Lean.MVarId)

full_name: Lean.Meta.getMVarsNoDelayed
code: /-- Similar to `getMVars`, but removes delayed assignments. -/
def getMVarsNoDelayed (e : Expr) : MetaM (Array MVarId) 
goal: Lean.MetaM (Array Lean.MVarId)

full_name: Lean.Meta.collectMVarsAtDecl
code: def collectMVarsAtDecl (d : Declaration) : StateRefT CollectMVars.State MetaM Unit 
goal: StateRefT' IO.RealWorld Lean.CollectMVars.State Lean.MetaM Unit

full_name: Lean.Meta.getMVarsAtDecl
code: def getMVarsAtDecl (d : Declaration) : MetaM (Array MVarId) 
goal: Lean.MetaM (Array Lean.MVarId)

full_name: Lean.MVarId.getMVarDependencies
code: /--
Collect the metavariables which `mvarId` depends on. These are the metavariables
which appear in the type and local context of `mvarId`, as well as the
metavariables which *those* metavariables depend on, etc.
-/
partial def _root_.Lean.MVarId.getMVarDependencies (mvarId : MVarId) (includeDelayed := false) :
    MetaM (HashSet MVarId) 
goal: Lean.MetaM (Lean.HashSet Lean.MVarId)

full_name: Lean.MVarId.getMVarDependencies.addMVars
code: /--
Collect the metavariables which `mvarId` depends on. These are the metavariables
which appear in the type and local context of `mvarId`, as well as the
metavariables which *those* metavariables depend on, etc.
-/
partial def _root_.Lean.MVarId.getMVarDependencies (mvarId : MVarId) (includeDelayed := false) :
    MetaM (HashSet MVarId) 
goal: StateRefT' IO.RealWorld (Lean.HashSet Lean.MVarId) Lean.MetaM Unit

full_name: Lean.MVarId.getMVarDependencies.go
code: /--
Collect the metavariables which `mvarId` depends on. These are the metavariables
which appear in the type and local context of `mvarId`, as well as the
metavariables which *those* metavariables depend on, etc.
-/
partial def _root_.Lean.MVarId.getMVarDependencies (mvarId : MVarId) (includeDelayed := false) :
    MetaM (HashSet MVarId) 
goal: StateRefT' IO.RealWorld (Lean.HashSet Lean.MVarId) Lean.MetaM Unit