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

full_name: Lean.Meta.Grind.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Grind.Attr._hyg.5
code: builtin_initialize grindNormExt : SimpExtension ←
  registerSimpAttr `grind_norm "simplification/normalization theorems for `grind`"
goal: IO Lean.Meta.SimpExtension

full_name: Lean.Meta.Grind.grindNormExt
code: builtin_initialize grindNormExt : SimpExtension ←
  registerSimpAttr `grind_norm "simplification/normalization theorems for `grind`"
goal: Lean.Meta.SimpExtension

full_name: Lean.Meta.Grind.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Grind.Attr._hyg.33
code: builtin_initialize grindNormSimprocExt : SimprocExtension ←
  registerSimprocAttr `grind_norm_proc "simplification/normalization procedured for `grind`" none
goal: IO Lean.Meta.Simp.SimprocExtension

full_name: Lean.Meta.Grind.grindNormSimprocExt
code: builtin_initialize grindNormSimprocExt : SimprocExtension ←
  registerSimprocAttr `grind_norm_proc "simplification/normalization procedured for `grind`" none
goal: Lean.Meta.Simp.SimprocExtension

full_name: Lean.Meta.Grind.grindCasesExt
code: builtin_initialize grindCasesExt : SimpleScopedEnvExtension Name NameSet ←
  registerSimpleScopedEnvExtension {
    initial        := {}
    addEntry       := fun s declName => s.insert declName
  }
goal: Lean.SimpleScopedEnvExtension Lean.Name Lean.NameSet

full_name: Lean.Meta.Grind.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Grind.Attr._hyg.62
code: builtin_initialize grindCasesExt : SimpleScopedEnvExtension Name NameSet ←
  registerSimpleScopedEnvExtension {
    initial        := {}
    addEntry       := fun s declName => s.insert declName
  }
goal: IO (Lean.SimpleScopedEnvExtension Lean.Name Lean.NameSet)

full_name: Lean.Meta.Grind.isGrindCasesTarget
code: /--
Returns `true` if `declName` has been tagged with attribute `[grind_cases]`.
-/
def isGrindCasesTarget (declName : Name) : CoreM Bool 
goal: Lean.CoreM Bool

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Grind.Attr.0.Lean.Meta.Grind.getAlias?
code: private def getAlias? (value : Expr) : MetaM (Option Name) 
goal: Lean.MetaM (Option Lean.Name)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Grind.Attr.0.Lean.Meta.Grind.validateGrindCasesAttr
code: /--
Throws an error if `declName` cannot be annotated with attribute `[grind_cases]`.
We support the following cases:
- `declName` is a non-recursive datatype.
- `declName` is an abbreviation for a non-recursive datatype.
-/
private partial def validateGrindCasesAttr (declName : Name) : CoreM Unit 
goal: Lean.CoreM Unit

full_name: Lean.Meta.Grind.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Grind.Attr._hyg.430
code: builtin_initialize
  registerBuiltinAttribute {
    name  := `grind_cases
    descr := "`grind` tactic applies `cases` to (non-recursive) inductives during pre-processing step"
    add   := fun declName _ attrKind => do
      validateGrindCasesAttr declName
      grindCasesExt.add declName attrKind
  }
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Grind/Util.lean

full_name: Lean.MVarId.ensureNoMVar
code: /--
Throws an exception if target of the given goal contains metavariables.
-/
def _root_.Lean.MVarId.ensureNoMVar (mvarId : MVarId) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.MVarId.ensureProp
code: /--
Throws an exception if target is not a proposition.
-/
def _root_.Lean.MVarId.ensureProp (mvarId : MVarId) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.MVarId.transformTarget
code: def _root_.Lean.MVarId.transformTarget (mvarId : MVarId) (f : Expr → MetaM Expr) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.Grind.unfoldReducible
code: /--
Unfold all `reducible` declarations occurring in `e`.
-/
def unfoldReducible (e : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: Lean.MVarId.unfoldReducible
code: /--
Unfold all `reducible` declarations occurring in the goal's target.
-/
def _root_.Lean.MVarId.unfoldReducible (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.abstractNestedProofs
code: /--
Abstract nested proofs occurring in the goal's target.
-/
def _root_.Lean.MVarId.abstractNestedProofs (mvarId : MVarId) (mainDeclName : Name) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.betaReduce
code: /--
Beta-reduce the goal's target.
-/
def _root_.Lean.MVarId.betaReduce (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.byContra?
code: /--
If the target is not `False`, apply `byContradiction`.
-/
def _root_.Lean.MVarId.byContra? (mvarId : MVarId) : MetaM (Option MVarId) 
goal: Lean.MetaM (Option Lean.MVarId)

full_name: Lean.MVarId.clearAuxDecls
code: /--
Clear auxiliary decls used to encode recursive declarations.
`grind` eliminates them to ensure they are not accidentaly used by its proof automation.
-/
def _root_.Lean.MVarId.clearAuxDecls (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Grind/Injection.lean

full_name: Lean.Meta.Grind.injection?
code: /--
The `grind` tactic includes an auxiliary `injection?` tactic that is not intended for direct use by users.
This tactic is automatically applied when introducing non-dependent propositions.
It differs from the user-facing Lean `injection` tactic in the following ways:

- It does not introduce new propositions. Instead, the `grind` tactic preprocessor is responsible for introducing them.
- It assumes that `fvarId` is the latest local declaration in the current goal.
- It does not handle cases where the constructors are different because the simplifier already reduces such equalities to `False`.
- It does not have support for heterogeneous equality. Recall that the simplifier already reduces them to `Eq` if
  the types are definitionally equal.
-/
def injection? (mvarId : MVarId) (fvarId : FVarId) : MetaM (Option MVarId) 
goal: Lean.MetaM (Option Lean.MVarId)
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Grind/RevertAll.lean

full_name: Lean.MVarId.revertAll
code: /--
Revert all free variables at goal `mvarId`.
-/
def _root_.Lean.MVarId.revertAll (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Rfl.lean

full_name: Lean.Meta.Rfl.reflExt.config
code: /-- Discrimation tree settings for the `refl` extension. -/
def reflExt.config : WhnfCoreConfig 
goal: Lean.Meta.WhnfCoreConfig

full_name: Lean.Meta.Rfl.reflExt
code: /-- Environment extensions for `refl` lemmas -/
initialize reflExt :
    SimpleScopedEnvExtension (Name × Array DiscrTree.Key) (DiscrTree Name) ←
  registerSimpleScopedEnvExtension {
    addEntry := fun dt (n, ks) => dt.insertCore ks n
    initial := {}
  }
goal: Lean.SimpleScopedEnvExtension (Lean.Name × Array Lean.Meta.DiscrTree.Key) (Lean.Meta.DiscrTree Lean.Name)

full_name: Lean.Meta.Rfl.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Rfl._hyg.21
code: /-- Environment extensions for `refl` lemmas -/
initialize reflExt :
    SimpleScopedEnvExtension (Name × Array DiscrTree.Key) (DiscrTree Name) ←
  registerSimpleScopedEnvExtension {
    addEntry := fun dt (n, ks) => dt.insertCore ks n
    initial := {}
  }
goal: IO (Lean.SimpleScopedEnvExtension (Lean.Name × Array Lean.Meta.DiscrTree.Key) (Lean.Meta.DiscrTree Lean.Name))

full_name: Lean.Meta.Rfl.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Rfl._hyg.106
code: initialize registerBuiltinAttribute {
  name := `refl
  descr := "reflexivity relation"
  add := fun decl _ kind => MetaM.run' do
    let declTy := (← getConstInfo decl).type
    let (_, _, targetTy) ← withReducible <| forallMetaTelescopeReducing declTy
    let fail := throwError
      "@[refl] attribute only applies to lemmas proving x ∼ x, got {declTy}"
    let .app (.app rel lhs) rhs := targetTy | fail
    if let .app (.const ``Eq [_]) _ := rel then
      throwError "@[refl] attribute may not be used on `Eq.refl`."
    unless ← withNewMCtxDepth <| isDefEq lhs rhs do fail
    let key ← DiscrTree.mkPath rel reflExt.config
    reflExt.add (decl, key) kind
}
goal: IO Unit

full_name: Lean.MVarId.applyRfl
code: /-- `MetaM` version of the `rfl` tactic.

This tactic applies to a goal whose target has the form `x ~ x`,
where `~` is a reflexive relation other than `=`,
that is, a relation which has a reflexive lemma tagged with the attribute @[refl].
-/
def _root_.Lean.MVarId.applyRfl (goal : MVarId) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Rfl.0.Lean.Meta.Rfl.rel_of_eq_and_refl
code: /-- Helper theorem for `Lean.MVarId.liftReflToEq`. -/
private theorem rel_of_eq_and_refl {α : Sort _} {R : α → α → Prop}
    {x y : α} (hxy : x = y) (h : R x x) : R x y 
goal: R x y

full_name: Lean.MVarId.liftReflToEq
code: /--
Convert a goal of the form `x ~ y` into the form `x = y`, where `~` is a reflexive
relation, that is, a relation which has a reflexive lemma tagged with the attribute `@[refl]`.
If this can't be done, returns the original `MVarId`.
-/
def _root_.Lean.MVarId.liftReflToEq (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Cleanup.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.addUsedFVar
code: private partial def cleanupCore (mvarId : MVarId) (toPreserve : Array FVarId) (indirectProps : Bool) : MetaM MVarId 
goal: StateRefT' IO.RealWorld (Bool × Lean.FVarIdSet) Lean.MetaM Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.addDeps
code: private partial def cleanupCore (mvarId : MVarId) (toPreserve : Array FVarId) (indirectProps : Bool) : MetaM MVarId 
goal: StateRefT' IO.RealWorld (Bool × Lean.FVarIdSet) Lean.MetaM Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.collectUsed
code: private partial def cleanupCore (mvarId : MVarId) (toPreserve : Array FVarId) (indirectProps : Bool) : MetaM MVarId 
goal: StateRefT' IO.RealWorld (Bool × Lean.FVarIdSet) Lean.MetaM Lean.FVarIdSet

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.collectProps
code: private partial def cleanupCore (mvarId : MVarId) (toPreserve : Array FVarId) (indirectProps : Bool) : MetaM MVarId 
goal: StateRefT' IO.RealWorld (Bool × Lean.FVarIdSet) Lean.MetaM Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore
code: private partial def cleanupCore (mvarId : MVarId) (toPreserve : Array FVarId) (indirectProps : Bool) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.addUsedFVars
code: private partial def cleanupCore (mvarId : MVarId) (toPreserve : Array FVarId) (indirectProps : Bool) : MetaM MVarId 
goal: StateRefT' IO.RealWorld (Bool × Lean.FVarIdSet) Lean.MetaM Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.collectPropsStep
code: private partial def cleanupCore (mvarId : MVarId) (toPreserve : Array FVarId) (indirectProps : Bool) : MetaM MVarId 
goal: StateRefT' IO.RealWorld (Bool × Lean.FVarIdSet) Lean.MetaM Unit

full_name: Lean.MVarId.cleanup
code: /--
  Auxiliary tactic for cleaning the local context. It removes local declarations (aka hypotheses) that are *not* relevant.
  We say a variable `x` is "relevant" if
  - It occurs in the `toPreserve` array, or
  - It occurs in the target type, or
  - There is a relevant variable `y` that depends on `x`, or
  - If `indirectProps` is true, the type of `x` is a proposition and it depends on a relevant variable `y`.

  By default, `toPreserve := #[]` and `indirectProps := true`. These settings are used in the mathlib tactic `extract_goal`
  to give the user more control over which variables to include.
-/
abbrev _root_.Lean.MVarId.cleanup (mvarId : MVarId) (toPreserve : Array FVarId := #[]) (indirectProps : Bool := true) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.cleanup
code: @[deprecated MVarId.cleanup (since := "2022-07-15")]
abbrev cleanup (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Clear.lean

full_name: Lean.MVarId.clear
code: /--
Erase the given free variable from the goal `mvarId`.
-/
def _root_.Lean.MVarId.clear (mvarId : MVarId) (fvarId : FVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.clear
code: @[deprecated MVarId.clear (since := "2022-07-15")]
def clear (mvarId : MVarId) (fvarId : FVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.tryClear
code: /--
Try to erase the given free variable from the goal `mvarId`. It is no-op if the free variable
cannot be erased due to forward dependencies.
-/
def _root_.Lean.MVarId.tryClear (mvarId : MVarId) (fvarId : FVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.tryClear
code: @[deprecated MVarId.tryClear (since := "2022-07-15")]
def tryClear (mvarId : MVarId) (fvarId : FVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.tryClearMany
code: /--
Try to erase the given free variables from the goal `mvarId`.
-/
def _root_.Lean.MVarId.tryClearMany (mvarId : MVarId) (fvarIds : Array FVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.tryClearMany
code: @[deprecated MVarId.tryClearMany (since := "2022-07-15")]
def tryClearMany (mvarId : MVarId) (fvarIds : Array FVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Constructor.lean

full_name: Lean.MVarId.constructor
code: /--
When the goal `mvarId` type is an inductive datatype,
`constructor` calls `apply` with the first matching constructor.
-/
def _root_.Lean.MVarId.constructor (mvarId : MVarId) (cfg : ApplyConfig := {}) : MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Lean.Meta.constructor
code: @[deprecated MVarId.constructor (since := "2022-07-15")]
def constructor (mvarId : MVarId) (cfg : ApplyConfig := {}) : MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Lean.MVarId.existsIntro
code: def _root_.Lean.MVarId.existsIntro (mvarId : MVarId) (w : Expr) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.existsIntro
code: @[deprecated MVarId.existsIntro (since := "2022-07-15")]
def existsIntro (mvarId : MVarId) (w : Expr) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Rewrite.lean

full_name: Lean.Meta.RewriteResult.eNew
code: structure RewriteResult where
  eNew     : Expr
  eqProof  : Expr
  mvarIds  : List MVarId
goal: Lean.Expr

full_name: Lean.Meta.RewriteResult.eqProof
code: structure RewriteResult where
  eNew     : Expr
  eqProof  : Expr
  mvarIds  : List MVarId
goal: Lean.Expr

full_name: Lean.Meta.RewriteResult
code: structure RewriteResult where
  eNew     : Expr
  eqProof  : Expr
  mvarIds  : List MVarId
goal: Type

full_name: Lean.Meta.RewriteResult.mvarIds
code: structure RewriteResult where
  eNew     : Expr
  eqProof  : Expr
  mvarIds  : List MVarId
goal: List Lean.MVarId

full_name: Lean.MVarId.rewrite
code: /--
Rewrite goal `mvarId`
-/
def _root_.Lean.MVarId.rewrite (mvarId : MVarId) (e : Expr) (heq : Expr)
    (symm : Bool := false) (config := { : Rewrite.Config }) : MetaM RewriteResult 
goal: Lean.MetaM Lean.Meta.RewriteResult

full_name: Lean.Meta.rewrite
code: @[deprecated MVarId.rewrite (since := "2022-07-15")]
def rewrite (mvarId : MVarId) (e : Expr) (heq : Expr)
    (symm : Bool := false) (config := { : Rewrite.Config }) : MetaM RewriteResult 
goal: Lean.MetaM Lean.Meta.RewriteResult
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Rename.lean

full_name: Lean.MVarId.rename
code: /--
Rename the user-face naming for the free variable `fvarId` at `mvarId`.
-/
def _root_.Lean.MVarId.rename (mvarId : MVarId) (fvarId : FVarId) (userNameNew : Name) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.rename
code: @[deprecated MVarId.rename (since := "2022-07-15")]
def rename (mvarId : MVarId) (fvarId : FVarId) (newUserName : Name) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Subst.lean

full_name: Lean.Meta.substCore
code: def substCore (mvarId : MVarId) (hFVarId : FVarId) (symm := false) (fvarSubst : FVarSubst := {}) (clearH := true) (tryToSkip := false) : MetaM (FVarSubst × MVarId) 
goal: Lean.MetaM (Lean.Meta.FVarSubst × Lean.MVarId)

full_name: Lean.Meta.heqToEq
code: /--
  Given `h : HEq α a α b` in the given goal, produce a new goal where `h : Eq α a b`.
  If `h` is not of the give form, then just return `(h, mvarId)`
-/
def heqToEq (mvarId : MVarId) (fvarId : FVarId) (tryToClear : Bool := true) : MetaM (FVarId × MVarId) 
goal: Lean.MetaM (Lean.FVarId × Lean.MVarId)

full_name: Lean.Meta.substVar
code: /--
Given `x`, try to find an equation of the form `heq : x = rhs` or `heq : lhs = x`,
and runs `substCore` on it. Throws an expection if no such equation is found.
-/
partial def substVar (mvarId : MVarId) (x : FVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.subst
code: partial def subst (mvarId : MVarId) (h : FVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.subst.substEq
code: partial def subst (mvarId : MVarId) (h : FVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.substVar?
code: /--
Given `x`, try to find an equation of the form `heq : x = rhs` or `heq : lhs = x`,
and runs `substCore` on it. Returns `none` if no such equation is found, or if `substCore` fails.
-/
def substVar? (mvarId : MVarId) (hFVarId : FVarId) : MetaM (Option MVarId) 
goal: Lean.MetaM (Option Lean.MVarId)

full_name: Lean.Meta.subst?
code: def subst? (mvarId : MVarId) (hFVarId : FVarId) : MetaM (Option MVarId) 
goal: Lean.MetaM (Option Lean.MVarId)

full_name: Lean.Meta.substCore?
code: def substCore? (mvarId : MVarId) (hFVarId : FVarId) (symm := false) (fvarSubst : FVarSubst := {}) (clearH := true) (tryToSkip := false) : MetaM (Option (FVarSubst × MVarId)) 
goal: Lean.MetaM (Option (Lean.Meta.FVarSubst × Lean.MVarId))

full_name: Lean.Meta.trySubstVar
code: def trySubstVar (mvarId : MVarId) (hFVarId : FVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.trySubst
code: def trySubst (mvarId : MVarId) (hFVarId : FVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.substSomeVar?
code: def substSomeVar? (mvarId : MVarId) : MetaM (Option MVarId) 
goal: Lean.MetaM (Option Lean.MVarId)

full_name: Lean.Meta.substVars
code: partial def substVars (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Subst._hyg.3841
code: builtin_initialize registerTraceClass `Meta.Tactic.subst
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Acyclic.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Acyclic.0.Lean.MVarId.isTarget
code: private def isTarget (lhs rhs : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.MVarId.acyclic.go
code: /--
  Close the given goal if `h` is a proof for an equality such as `as = a :: as`.
  Inductive datatypes in Lean are acyclic.
-/
def acyclic (mvarId : MVarId) (h : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.MVarId.acyclic
code: /--
  Close the given goal if `h` is a proof for an equality such as `as = a :: as`.
  Inductive datatypes in Lean are acyclic.
-/
def acyclic (mvarId : MVarId) (h : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.MVarId.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Acyclic._hyg.844
code: builtin_initialize
  registerTraceClass `Meta.Tactic.acyclic
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Injection.lean

full_name: Lean.Meta.getCtorNumPropFields
code: def getCtorNumPropFields (ctorInfo : ConstructorVal) : MetaM Nat 
goal: Lean.MetaM Nat

full_name: Lean.Meta.InjectionResultCore.subgoal
code: inductive InjectionResultCore where
  | solved
  | subgoal (mvarId : MVarId) (numNewEqs : Nat)
goal: Lean.Meta.InjectionResultCore

full_name: Lean.Meta.InjectionResultCore
code: inductive InjectionResultCore where
  | solved
  | subgoal (mvarId : MVarId) (numNewEqs : Nat)
goal: Type

full_name: Lean.Meta.InjectionResultCore.solved
code: inductive InjectionResultCore where
  | solved
  | subgoal (mvarId : MVarId) (numNewEqs : Nat)
goal: Lean.Meta.InjectionResultCore

full_name: Lean.Meta.injectionCore
code: def injectionCore (mvarId : MVarId) (fvarId : FVarId) : MetaM InjectionResultCore 
goal: Lean.MetaM Lean.Meta.InjectionResultCore

full_name: Lean.Meta.InjectionResult.solved
code: inductive InjectionResult where
  | solved
  | subgoal (mvarId : MVarId) (newEqs : Array FVarId) (remainingNames : List Name)
goal: Lean.Meta.InjectionResult

full_name: Lean.Meta.InjectionResult
code: inductive InjectionResult where
  | solved
  | subgoal (mvarId : MVarId) (newEqs : Array FVarId) (remainingNames : List Name)
goal: Type

full_name: Lean.Meta.InjectionResult.subgoal
code: inductive InjectionResult where
  | solved
  | subgoal (mvarId : MVarId) (newEqs : Array FVarId) (remainingNames : List Name)
goal: Lean.Meta.InjectionResult

full_name: Lean.Meta.injectionIntro.go
code: def injectionIntro (mvarId : MVarId) (numEqs : Nat) (newNames : List Name) (tryToClear := true) : MetaM InjectionResult 
goal: Nat → Lean.MVarId → Array Lean.FVarId → List Lean.Name → Lean.MetaM Lean.Meta.InjectionResult

full_name: Lean.Meta.injectionIntro
code: def injectionIntro (mvarId : MVarId) (numEqs : Nat) (newNames : List Name) (tryToClear := true) : MetaM InjectionResult 
goal: Lean.MetaM Lean.Meta.InjectionResult

full_name: Lean.Meta.injection
code: def injection (mvarId : MVarId) (fvarId : FVarId) (newNames : List Name := []) : MetaM InjectionResult 
goal: Lean.MetaM Lean.Meta.InjectionResult

full_name: Lean.Meta.InjectionsResult
code: inductive InjectionsResult where
  | solved
  | subgoal (mvarId : MVarId) (remainingNames : List Name)
goal: Type

full_name: Lean.Meta.InjectionsResult.solved
code: inductive InjectionsResult where
  | solved
  | subgoal (mvarId : MVarId) (remainingNames : List Name)
goal: Lean.Meta.InjectionsResult

full_name: Lean.Meta.InjectionsResult.subgoal
code: inductive InjectionsResult where
  | solved
  | subgoal (mvarId : MVarId) (remainingNames : List Name)
goal: Lean.Meta.InjectionsResult

full_name: Lean.Meta.injections.go
code: partial def injections (mvarId : MVarId) (newNames : List Name := []) (maxDepth : Nat := 5) : MetaM InjectionsResult 
goal: Nat → List Lean.FVarId → Lean.MVarId → List Lean.Name → Lean.MetaM Lean.Meta.InjectionsResult

full_name: Lean.Meta.injections
code: partial def injections (mvarId : MVarId) (newNames : List Name := []) (maxDepth : Nat := 5) : MetaM InjectionsResult 
goal: Lean.MetaM Lean.Meta.InjectionsResult