ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/lean4/src/lean/Lean/Meta/GeneralizeVars.lean

full_name: Lean.Meta.mkGeneralizationForbiddenSet.loop
code: /--
  Add to `forbidden` all a set of `FVarId`s containing `targets` and all variables they depend on.
-/
partial def mkGeneralizationForbiddenSet (targets : Array Expr) (forbidden : FVarIdSet := {}) : MetaM FVarIdSet 
goal: Lean.MetaM Lean.FVarIdSet

full_name: Lean.Meta.mkGeneralizationForbiddenSet
code: /--
  Add to `forbidden` all a set of `FVarId`s containing `targets` and all variables they depend on.
-/
partial def mkGeneralizationForbiddenSet (targets : Array Expr) (forbidden : FVarIdSet := {}) : MetaM FVarIdSet 
goal: Lean.MetaM Lean.FVarIdSet

full_name: Lean.Meta.mkGeneralizationForbiddenSet.visit
code: /--
  Add to `forbidden` all a set of `FVarId`s containing `targets` and all variables they depend on.
-/
partial def mkGeneralizationForbiddenSet (targets : Array Expr) (forbidden : FVarIdSet := {}) : MetaM FVarIdSet 
goal: Lean.MetaM (List Lean.FVarId × Lean.FVarIdSet)

full_name: Lean.Meta.getFVarSetToGeneralize
code: /--
  Collect variables to be generalized.
  It uses the following heuristic
  - Collect forward dependencies that are not in the forbidden set, and depend on some variable in `targets`.

  - We use `mkForbiddenSet` to compute `forbidden`.

  Remark: we *not* collect instance implicit arguments nor auxiliary declarations for compiling
  recursive declarations.
-/
def getFVarSetToGeneralize (targets : Array Expr) (forbidden : FVarIdSet) (ignoreLetDecls := false) : MetaM FVarIdSet 
goal: Lean.MetaM Lean.FVarIdSet

full_name: Lean.Meta.getFVarsToGeneralize
code: def getFVarsToGeneralize (targets : Array Expr) (forbidden : FVarIdSet := {}) (ignoreLetDecls := false) : MetaM (Array FVarId) 
goal: Lean.MetaM (Array Lean.FVarId)
File: .lake/packages/lean4/src/lean/Lean/Meta/PPGoal.lean

full_name: Lean.Meta.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.PPGoal._hyg.6
code: register_builtin_option pp.auxDecls : Bool := {
  defValue := false
  group    := "pp"
  descr    := "display auxiliary declarations used to compile recursive functions"
}
goal: IO (Lean.Option Bool)

full_name: Lean.Meta.pp.auxDecls
code: register_builtin_option pp.auxDecls : Bool := {
  defValue := false
  group    := "pp"
  descr    := "display auxiliary declarations used to compile recursive functions"
}
goal: Lean.Option Bool

full_name: Lean.Meta.pp.implementationDetailHyps
code: register_builtin_option pp.implementationDetailHyps : Bool := {
  defValue := false
  group    := "pp"
  descr    := "display implementation detail hypotheses in the local context"
}
goal: Lean.Option Bool

full_name: Lean.Meta.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.PPGoal._hyg.48
code: register_builtin_option pp.implementationDetailHyps : Bool := {
  defValue := false
  group    := "pp"
  descr    := "display implementation detail hypotheses in the local context"
}
goal: IO (Lean.Option Bool)

full_name: Lean.Meta.pp.inaccessibleNames
code: register_builtin_option pp.inaccessibleNames : Bool := {
  defValue := true
  group    := "pp"
  descr    := "display inaccessible declarations in the local context"
}
goal: Lean.Option Bool

full_name: Lean.Meta.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.PPGoal._hyg.90
code: register_builtin_option pp.inaccessibleNames : Bool := {
  defValue := true
  group    := "pp"
  descr    := "display inaccessible declarations in the local context"
}
goal: IO (Lean.Option Bool)

full_name: Lean.Meta.pp.showLetValues
code: register_builtin_option pp.showLetValues : Bool := {
  defValue := true
  group    := "pp"
  descr    := "display let-declaration values in the info view"
}
goal: Lean.Option Bool

full_name: Lean.Meta.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.PPGoal._hyg.132
code: register_builtin_option pp.showLetValues : Bool := {
  defValue := true
  group    := "pp"
  descr    := "display let-declaration values in the info view"
}
goal: IO (Lean.Option Bool)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.PPGoal.0.Lean.Meta.addLine
code: private def addLine (fmt : Format) : Format 
goal: Lean.Format

full_name: Lean.Meta.getGoalPrefix
code: def getGoalPrefix (mvarDecl : MetavarDecl) : String 
goal: String

full_name: Lean.Meta.ppGoal.pushPending
code: def ppGoal (mvarId : MVarId) : MetaM Format 
goal: Lean.MetaM Lean.Format

full_name: Lean.Meta.ppGoal.ppVars
code: def ppGoal (mvarId : MVarId) : MetaM Format 
goal: Lean.MetaM (List Lean.Name × Option Lean.Expr × Lean.Format)

full_name: Lean.Meta.ppGoal
code: def ppGoal (mvarId : MVarId) : MetaM Format 
goal: Lean.MetaM Lean.Format
File: .lake/packages/lean4/src/lean/Lean/Meta/Diagnostics.lean

full_name: Lean.Meta.collectAboveThreshold
code: def collectAboveThreshold [BEq α] [Hashable α] (counters : PHashMap α Nat) (threshold : Nat) (p : α → Bool) (lt : α → α → Bool) : Array (α × Nat) 
goal: Array (α × Nat)

full_name: Lean.Meta.subCounters
code: def subCounters [BEq α] [Hashable α] (newCounters oldCounters : PHashMap α Nat) : PHashMap α Nat 
goal: Lean.PHashMap α Nat

full_name: Lean.Meta.DiagSummary.data
code: structure DiagSummary where
  data  : Array MessageData := #[]
  max   : Nat := 0
  deriving Inhabited
goal: Array Lean.MessageData

full_name: Lean.Meta.instInhabitedDiagSummary
code: structure DiagSummary where
  data  : Array MessageData := #[]
  max   : Nat := 0
  deriving Inhabited
goal: Inhabited Lean.Meta.DiagSummary

full_name: Lean.Meta.DiagSummary
code: structure DiagSummary where
  data  : Array MessageData := #[]
  max   : Nat := 0
  deriving Inhabited
goal: Type

full_name: Lean.Meta.DiagSummary.max
code: structure DiagSummary where
  data  : Array MessageData := #[]
  max   : Nat := 0
  deriving Inhabited
goal: Nat

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

full_name: Lean.Meta.mkDiagSummary
code: def mkDiagSummary (counters : PHashMap Name Nat) (p : Name → Bool := fun _ => true) : MetaM DiagSummary 
goal: Lean.MetaM Lean.Meta.DiagSummary

full_name: Lean.Meta.mkDiagSummaryForUnfolded
code: def mkDiagSummaryForUnfolded (counters : PHashMap Name Nat) (instances := false) : MetaM DiagSummary 
goal: Lean.MetaM Lean.Meta.DiagSummary

full_name: Lean.Meta.mkDiagSummaryForUnfoldedReducible
code: def mkDiagSummaryForUnfoldedReducible (counters : PHashMap Name Nat) : MetaM DiagSummary 
goal: Lean.MetaM Lean.Meta.DiagSummary

full_name: Lean.Meta.mkDiagSummaryForUsedInstances
code: def mkDiagSummaryForUsedInstances : MetaM DiagSummary 
goal: Lean.MetaM Lean.Meta.DiagSummary

full_name: Lean.Meta.mkDiagSynthPendingFailure
code: def mkDiagSynthPendingFailure (failures : PHashMap Expr MessageData) : MetaM DiagSummary 
goal: Lean.MetaM Lean.Meta.DiagSummary

full_name: Lean.Meta.appendSection
code: def appendSection (m : MessageData) (cls : Name) (header : String) (s : DiagSummary) (resultSummary := true) : MessageData 
goal: Lean.MessageData

full_name: Lean.Meta.reportDiag
code: def reportDiag : MetaM Unit 
goal: Lean.MetaM Unit
File: .lake/packages/lean4/src/lean/Lean/Meta/ArgsPacker/Basic.lean

full_name: Lean.Meta.ArgsPacker.varNamess
code: /--
The metadata required for the operation in the `Lean.Meta.ArgsPacker` module; see
the module docs there for an overview.
-/
structure ArgsPacker where
  /--
  Variable names to use when unpacking a packed argument.

  Crucialy, the size of this arry also indicates the number of functions to pack, and
  the length of each array the arity.
  -/
  varNamess : Array (Array Name)
  deriving Inhabited
goal: Array (Array Lean.Name)

full_name: Lean.Meta.ArgsPacker
code: /--
The metadata required for the operation in the `Lean.Meta.ArgsPacker` module; see
the module docs there for an overview.
-/
structure ArgsPacker where
  /--
  Variable names to use when unpacking a packed argument.

  Crucialy, the size of this arry also indicates the number of functions to pack, and
  the length of each array the arity.
  -/
  varNamess : Array (Array Name)
  deriving Inhabited
goal: Type

full_name: Lean.Meta.instInhabitedArgsPacker
code: /--
The metadata required for the operation in the `Lean.Meta.ArgsPacker` module; see
the module docs there for an overview.
-/
structure ArgsPacker where
  /--
  Variable names to use when unpacking a packed argument.

  Crucialy, the size of this arry also indicates the number of functions to pack, and
  the length of each array the arity.
  -/
  varNamess : Array (Array Name)
  deriving Inhabited
goal: Inhabited Lean.Meta.ArgsPacker
File: .lake/packages/lean4/src/lean/Lean/Meta/Constructions.lean

full_name: Lean.mkCasesOnImp
code: @[extern "lean_mk_cases_on"] opaque mkCasesOnImp (env : Environment) (declName : @& Name) : Except KernelException Declaration
goal: Except Lean.KernelException Lean.Declaration

full_name: Lean.mkNoConfusionTypeCoreImp
code: @[extern "lean_mk_no_confusion_type"] opaque mkNoConfusionTypeCoreImp (env : Environment) (declName : @& Name) : Except KernelException Declaration
goal: Except Lean.KernelException Lean.Declaration

full_name: Lean.mkNoConfusionCoreImp
code: @[extern "lean_mk_no_confusion"] opaque mkNoConfusionCoreImp (env : Environment) (declName : @& Name) : Except KernelException Declaration
goal: Except Lean.KernelException Lean.Declaration

full_name: Lean.mkCasesOn
code: def mkCasesOn (declName : Name) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.mkNoConfusionCore
code: def mkNoConfusionCore (declName : Name) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.mkNoConfusionEnum.mkNoConfusionType
code: def mkNoConfusionEnum (enumName : Name) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.mkNoConfusionEnum
code: def mkNoConfusionEnum (enumName : Name) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.mkNoConfusionEnum.mkToCtorIdx
code: def mkNoConfusionEnum (enumName : Name) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.mkNoConfusionEnum.mkNoConfusion
code: def mkNoConfusionEnum (enumName : Name) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.mkNoConfusion
code: def mkNoConfusion (declName : Name) : MetaM Unit 
goal: Lean.MetaM Unit
File: .lake/packages/lean4/src/lean/Lean/Meta/FunInfo.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.FunInfo.0.Lean.Meta.checkFunInfoCache
code: @[inline] private def checkFunInfoCache (fn : Expr) (maxArgs? : Option Nat) (k : MetaM FunInfo) : MetaM FunInfo 
goal: Lean.MetaM Lean.Meta.FunInfo

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.FunInfo.0.Lean.Meta.whenHasVar
code: @[inline] private def whenHasVar {α} (e : Expr) (deps : α) (k : α → α) : α 
goal: α

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.FunInfo.0.Lean.Meta.collectDeps
code: private def collectDeps (fvars : Array Expr) (e : Expr) : Array Nat 
goal: Array Nat

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.FunInfo.0.Lean.Meta.collectDeps.visit
code: private def collectDeps (fvars : Array Expr) (e : Expr) : Array Nat 
goal: Array Nat

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.FunInfo.0.Lean.Meta.updateHasFwdDeps
code: /-- Update `hasFwdDeps` fields using new `backDeps` -/
private def updateHasFwdDeps (pinfo : Array ParamInfo) (backDeps : Array Nat) : Array ParamInfo 
goal: Array Lean.Meta.ParamInfo

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.FunInfo.0.Lean.Meta.getFunInfoAux
code: private def getFunInfoAux (fn : Expr) (maxArgs? : Option Nat) : MetaM FunInfo 
goal: Lean.MetaM Lean.Meta.FunInfo

full_name: Lean.Meta.getFunInfo
code: def getFunInfo (fn : Expr) : MetaM FunInfo 
goal: Lean.MetaM Lean.Meta.FunInfo

full_name: Lean.Meta.getFunInfoNArgs
code: def getFunInfoNArgs (fn : Expr) (nargs : Nat) : MetaM FunInfo 
goal: Lean.MetaM Lean.Meta.FunInfo

full_name: Lean.Meta.FunInfo.getArity
code: def FunInfo.getArity (info : FunInfo) : Nat 
goal: Nat
File: .lake/packages/lean4/src/lean/Lean/Meta/MatchUtil.lean

full_name: Lean.Meta.testHelper
code: @[inline] def testHelper (e : Expr) (p : Expr → MetaM Bool) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.matchHelper?
code: @[inline] def matchHelper? (e : Expr) (p? : Expr → MetaM (Option α)) : MetaM (Option α) 
goal: Lean.MetaM (Option α)

full_name: Lean.Meta.matchEq?
code: /-- Matches `e` with `lhs = (rhs : α)` and returns `(α, lhs, rhs)`. -/
def matchEq? (e : Expr) : MetaM (Option (Expr × Expr × Expr)) 
goal: Lean.MetaM (Option (Lean.Expr × Lean.Expr × Lean.Expr))

full_name: Lean.Meta.matchHEq?
code: def matchHEq? (e : Expr) : MetaM (Option (Expr × Expr × Expr × Expr)) 
goal: Lean.MetaM (Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr))

full_name: Lean.Meta.matchEqHEq?
code: /--
  Return `some (α, lhs, rhs)` if `e` is of the form `@Eq α lhs rhs` or `@HEq α lhs α rhs`
-/
def matchEqHEq? (e : Expr) : MetaM (Option (Expr × Expr × Expr)) 
goal: Lean.MetaM (Option (Lean.Expr × Lean.Expr × Lean.Expr))

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

full_name: Lean.Meta.matchNot?
code: def matchNot? (e : Expr) : MetaM (Option Expr) 
goal: Lean.MetaM (Option Lean.Expr)

full_name: Lean.Meta.matchNe?
code: def matchNe? (e : Expr) : MetaM (Option (Expr × Expr × Expr)) 
goal: Lean.MetaM (Option (Lean.Expr × Lean.Expr × Lean.Expr))

full_name: Lean.Meta.matchConstructorApp?
code: def matchConstructorApp? (e : Expr) : MetaM (Option ConstructorVal) 
goal: Lean.MetaM (Option Lean.ConstructorVal)
File: .lake/packages/lean4/src/lean/Lean/Meta/GetUnfoldableConst.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.GetUnfoldableConst.0.Lean.Meta.canUnfoldDefault
code: private def canUnfoldDefault (cfg : Config) (info : ConstantInfo) : CoreM Bool 
goal: Lean.CoreM Bool

full_name: Lean.Meta.canUnfold
code: def canUnfold (info : ConstantInfo) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Meta.getUnfoldableConst?
code: /--
Look up a constant name, returning the `ConstantInfo`
if it should be unfolded at the current reducibility settings,
or `none` otherwise.

This is part of the implementation of `whnf`.
External users wanting to look up names should be using `Lean.getConstInfo`.
-/
def getUnfoldableConst? (constName : Name) : MetaM (Option ConstantInfo) 
goal: Lean.MetaM (Option Lean.ConstantInfo)

full_name: Lean.Meta.getUnfoldableConstNoEx?
code: /--
As with `getUnfoldableConst?` but return `none` instead of failing if the constant is not found.
-/
def getUnfoldableConstNoEx? (constName : Name) : MetaM (Option ConstantInfo) 
goal: Lean.MetaM (Option Lean.ConstantInfo)
File: .lake/packages/lean4/src/lean/Lean/Elab/Quotation/Util.lean

full_name: Lean.Elab.Term.Quotation.hygiene
code: register_builtin_option hygiene : Bool := {
  defValue := true
  descr    := "Annotate identifiers in quotations such that they are resolved relative to the scope at their declaration, not that at their eventual use/expansion, to avoid accidental capturing. Note that quotations/notations already defined are unaffected."
}
goal: Lean.Option Bool

full_name: Lean.Elab.Term.Quotation.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Quotation.Util._hyg.7
code: register_builtin_option hygiene : Bool := {
  defValue := true
  descr    := "Annotate identifiers in quotations such that they are resolved relative to the scope at their declaration, not that at their eventual use/expansion, to avoid accidental capturing. Note that quotations/notations already defined are unaffected."
}
goal: IO (Lean.Option Bool)

full_name: Lean.Elab.Term.Quotation.getAntiquotationIds
code: def getAntiquotationIds (stx : Syntax) : TermElabM (Array Ident) 
goal: Lean.Elab.TermElabM (Array Lean.Ident)

full_name: Lean.Elab.Term.Quotation.getPatternVars
code: /-- Get all pattern vars (as `Syntax.ident`s) in `stx` -/
partial def getPatternVars (stx : Syntax) : TermElabM (Array Syntax) 
goal: Lean.Elab.TermElabM (Array Lean.Syntax)

full_name: Lean.Elab.Term.Quotation.getPatternsVars
code: def getPatternsVars (pats : Array Syntax) : TermElabM (Array Syntax) 
goal: Lean.Elab.TermElabM (Array Lean.Syntax)

full_name: Lean.Elab.Term.Quotation.getAntiquotKindSpec?
code: /--
Given an antiquotation like `$e:term` (i.e. `Syntax.antiquotKind?` returns `some`),
returns the `"term"` atom if present.
-/
def getAntiquotKindSpec? (antiquot : Syntax) : Option Syntax 
goal: Option Lean.Syntax
File: .lake/packages/lean4/src/lean/Lean/Elab/MacroRules.lean

full_name: Lean.Elab.Command.elabMacroRulesAux
code: /--
  Remark: `k` is the user provided kind with the current namespace included.
  Recall that syntax node kinds contain the current namespace.
-/
def elabMacroRulesAux (doc? : Option (TSyntax ``docComment))
    (attrs? : Option (TSepArray ``attrInstance ",")) (attrKind : TSyntax ``attrKind)
    (tk : Syntax) (k : SyntaxNodeKind) (alts : Array (TSyntax ``matchAlt)) :
    CommandElabM Syntax 
goal: Lean.Elab.Command.CommandElabM Lean.Syntax

full_name: Lean.Elab.Command.elabMacroRules
code: @[builtin_command_elab «macro_rules»] def elabMacroRules : CommandElab 
goal: Lean.Elab.Command.CommandElab
File: .lake/packages/lean4/src/lean/Lean/Elab/RecAppSyntax.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.RecAppSyntax.0.Lean.recAppKey
code: private def recAppKey 
goal: Lean.Name

full_name: Lean.mkRecAppWithSyntax
code: /--
  We store the syntax at recursive applications to be able to generate better error messages
  when performing well-founded and structural recursion.
-/
def mkRecAppWithSyntax (e : Expr) (stx : Syntax) : Expr 
goal: Lean.Expr

full_name: Lean.getRecAppSyntax?
code: /--
  Retrieve (if available) the syntax object attached to a recursive application.
-/
def getRecAppSyntax? (e : Expr) : Option Syntax 
goal: Option Lean.Syntax

full_name: Lean.MData.isRecApp
code: /--
  Checks if the `MData` is for a recursive applciation.
-/
def MData.isRecApp (d : MData) : Bool 
goal: Bool
File: .lake/packages/lean4/src/lean/Lean/Elab/DeclarationRange.lean

full_name: Lean.Elab.getDeclarationRange
code: def getDeclarationRange [Monad m] [MonadFileMap m] (stx : Syntax) : m DeclarationRange 
goal: m Lean.DeclarationRange

full_name: Lean.Elab.getDeclarationSelectionRef
code: /--
  For most builtin declarations, the selection range is just its name, which is stored in the second position.
  Example:
  ```
  "def " >> declId >> optDeclSig >> declVal
  ```
  If the declaration name is absent, we use the keyword instead.
  This function converts the given `Syntax` into one that represents its "selection range".
-/
def getDeclarationSelectionRef (stx : Syntax) : Syntax 
goal: Lean.Syntax

full_name: Lean.Elab.addDeclarationRanges
code: /--
  Store the `range` and `selectionRange` for `declName` where `stx` is the whole syntax object describing `declName`.
  This method is for the builtin declarations only.
  User-defined commands should use `Lean.addDeclarationRanges` to store this information for their commands. -/
def addDeclarationRanges [Monad m] [MonadEnv m] [MonadFileMap m] (declName : Name) (stx : Syntax) : m Unit 
goal: m Unit

full_name: Lean.Elab.addAuxDeclarationRanges
code: /-- Auxiliary method for recording ranges for auxiliary declarations (e.g., fields, nested declarations, etc. -/
def addAuxDeclarationRanges [Monad m] [MonadEnv m] [MonadFileMap m] (declName : Name) (stx : Syntax) (header : Syntax) : m Unit 
goal: m Unit
File: .lake/packages/lean4/src/lean/Lean/Elab/Mixfix.lean

full_name: Lean.Elab.Command.expandMixfix.withAttrKindGlobal
code: @[builtin_macro Lean.Parser.Command.mixfix] def expandMixfix : Macro 
goal: Lean.MacroM Lean.Syntax

full_name: Lean.Elab.Command.expandMixfix
code: @[builtin_macro Lean.Parser.Command.mixfix] def expandMixfix : Macro 
goal: Lean.Macro
File: .lake/packages/lean4/src/lean/Lean/Elab/Notation.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Notation.0.Lean.Elab.Command.antiquote
code: /-- Wrap all occurrences of the given `ident` nodes in antiquotations -/
private partial def antiquote (vars : Array Syntax) : Syntax → Syntax
  
goal: Lean.Syntax → Lean.Syntax

full_name: Lean.Elab.Command.addInheritDocDefault
code: def addInheritDocDefault (rhs : Term) (attrs? : Option (TSepArray ``attrInstance ",")) :
    Option (TSepArray ``attrInstance ",") 
goal: Option (Lean.Syntax.TSepArray `Lean.Parser.Term.attrInstance ",")

full_name: Lean.Elab.Command.expandNotationItemIntoSyntaxItem
code: /-- Convert `notation` command lhs item into a `syntax` command item -/
def expandNotationItemIntoSyntaxItem : TSyntax ``notationItem → MacroM (TSyntax `stx)
  
goal: Lean.TSyntax `Lean.Parser.Command.notationItem → Lean.MacroM (Lean.TSyntax `stx)

full_name: Lean.Elab.Command.expandNotationItemIntoPattern
code: /-- Convert `notation` command lhs item into a pattern element -/
def expandNotationItemIntoPattern (stx : Syntax) : MacroM Syntax 
goal: Lean.MacroM Lean.Syntax

full_name: Lean.Elab.Command.removeParenthesesAux
code: def removeParenthesesAux (parens body : Syntax) : Syntax 
goal: Lean.Syntax

full_name: Lean.Elab.Command.removeParentheses
code: partial def removeParentheses (stx : Syntax) : MacroM Syntax 
goal: Lean.MacroM Lean.Syntax

full_name: Lean.Elab.Command.hasDuplicateAntiquot
code: partial def hasDuplicateAntiquot (stxs : Array Syntax) : Bool 
goal: Bool

full_name: Lean.Elab.Command.mkUnexpander
code: /-- Try to derive an unexpander from a notation.
    The notation must be of the form `notation ... => c body`
    where `c` is a declaration in the current scope and `body` any syntax
    that contains each variable from the LHS at most once. -/
def mkUnexpander (attrKind : TSyntax ``attrKind) (pat qrhs : Term) : OptionT MacroM Syntax 
goal: OptionT Lean.MacroM Lean.Syntax

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Notation.0.Lean.Elab.Command.expandNotationAux
code: private def expandNotationAux (ref : Syntax) (currNamespace : Name)
    (doc? : Option (TSyntax ``docComment))
    (attrs? : Option (TSepArray ``attrInstance ","))
    (attrKind : TSyntax ``attrKind)
    (prec? : Option Prec) (name? : Option Ident) (prio? : Option Prio)
    (items : Array (TSyntax ``notationItem)) (rhs : Term) : MacroM Syntax 
goal: Lean.MacroM Lean.Syntax

full_name: Lean.Elab.Command.expandNotation
code: @[builtin_macro Lean.Parser.Command.notation] def expandNotation : Macro
  
goal: Lean.Macro
File: .lake/packages/lean4/src/lean/Lean/Elab/InheritDoc.lean

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.InheritDoc._hyg.4
code: builtin_initialize
  registerBuiltinAttribute {
    name := `inherit_doc
    descr := "inherit documentation from a specified declaration"
    add   := fun decl stx kind => do
      unless kind == AttributeKind.global do
        throwError "invalid `[inherit_doc]` attribute, must be global"
      match stx with
      | `(attr| inherit_doc $[$id?:ident]?) => withRef stx[0] do
        let some id := id?
          | throwError "invalid `[inherit_doc]` attribute, could not infer doc source"
        let declName ← Elab.realizeGlobalConstNoOverloadWithInfo id
        if (← findSimpleDocString? (← getEnv) decl).isSome then
          logWarning m!"{← mkConstWithLevelParams decl} already has a doc string"
        let some doc ← findSimpleDocString? (← getEnv) declName
          | logWarningAt id m!"{← mkConstWithLevelParams declName} does not have a doc string"
        addDocString decl doc
      | _  => throwError "invalid `[inherit_doc]` attribute"
  }
goal: IO Unit