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

full_name: Lean.Meta.KExprMap.map
code: /--
  A mapping that identifies definitionally equal expressions.
  We implement it as a mapping from `HeadIndex` to `AssocList Expr α`.

  Remark: this map may be quite inefficient if there are many `HeadIndex` collisions.
-/
structure KExprMap (α : Type) where
  map : PHashMap HeadIndex (AssocList Expr α) := {}
  deriving Inhabited
goal: Lean.PHashMap Lean.HeadIndex (Lean.AssocList Lean.Expr α)

full_name: Lean.Meta.KExprMap
code: /--
  A mapping that identifies definitionally equal expressions.
  We implement it as a mapping from `HeadIndex` to `AssocList Expr α`.

  Remark: this map may be quite inefficient if there are many `HeadIndex` collisions.
-/
structure KExprMap (α : Type) where
  map : PHashMap HeadIndex (AssocList Expr α) := {}
  deriving Inhabited
goal: Type

full_name: Lean.Meta.instInhabitedKExprMap
code: /--
  A mapping that identifies definitionally equal expressions.
  We implement it as a mapping from `HeadIndex` to `AssocList Expr α`.

  Remark: this map may be quite inefficient if there are many `HeadIndex` collisions.
-/
structure KExprMap (α : Type) where
  map : PHashMap HeadIndex (AssocList Expr α) := {}
  deriving Inhabited
goal: {a : Type} → Inhabited (Lean.Meta.KExprMap a)

full_name: Lean.Meta.KExprMap.find?
code: /-- Return `some v` if there is an entry `e ↦ v` in `m`. -/
def KExprMap.find? (m : KExprMap α) (e : Expr) : MetaM (Option α) 
goal: Lean.MetaM (Option α)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.KExprMap.0.Lean.Meta.updateList
code: private def updateList (ps : AssocList Expr α) (e : Expr) (v : α) : MetaM (AssocList Expr α) 
goal: Lean.MetaM (Lean.AssocList Lean.Expr α)

full_name: Lean.Meta.KExprMap.insert
code: /-- Insert `e ↦ v` into `m` -/
def KExprMap.insert (m : KExprMap α) (e : Expr) (v : α) : MetaM (KExprMap α) 
goal: Lean.MetaM (Lean.Meta.KExprMap α)
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/AuxLemma.lean

full_name: Lean.Meta.instInhabitedAuxLemmas
code: structure AuxLemmas where
  idx    : Nat := 1
  lemmas : PHashMap Expr (Name × List Name) := {}
  deriving Inhabited
goal: Inhabited Lean.Meta.AuxLemmas

full_name: Lean.Meta.AuxLemmas.idx
code: structure AuxLemmas where
  idx    : Nat := 1
  lemmas : PHashMap Expr (Name × List Name) := {}
  deriving Inhabited
goal: Nat

full_name: Lean.Meta.AuxLemmas
code: structure AuxLemmas where
  idx    : Nat := 1
  lemmas : PHashMap Expr (Name × List Name) := {}
  deriving Inhabited
goal: Type

full_name: Lean.Meta.AuxLemmas.lemmas
code: structure AuxLemmas where
  idx    : Nat := 1
  lemmas : PHashMap Expr (Name × List Name) := {}
  deriving Inhabited
goal: Lean.PHashMap Lean.Expr (Lean.Name × List Lean.Name)

full_name: Lean.Meta.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.AuxLemma._hyg.52
code: builtin_initialize auxLemmasExt : EnvExtension AuxLemmas ← registerEnvExtension (pure {})
goal: IO (Lean.EnvExtension Lean.Meta.AuxLemmas)

full_name: Lean.Meta.auxLemmasExt
code: builtin_initialize auxLemmasExt : EnvExtension AuxLemmas ← registerEnvExtension (pure {})
goal: Lean.EnvExtension Lean.Meta.AuxLemmas

full_name: Lean.Meta.mkAuxLemma
code: /--
  Helper method for creating auxiliary lemmas in the environment.

  It uses a cache that maps `type` to declaration name. The cache is not stored in `.olean` files.
  It is useful to make sure the same auxiliary lemma is not created over and over again in the same file.

  This method is useful for tactics (e.g., `simp`) that may perform preprocessing steps to lemmas provided by
  users. For example, `simp` preprocessor may convert a lemma into multiple ones.
-/
def mkAuxLemma (levelParams : List Name) (type : Expr) (value : Expr) : MetaM Name 
goal: Lean.MetaM Lean.Name
File: .lake/packages/lean4/src/lean/Lean/Meta/Structure.lean

full_name: Lean.Meta.getStructureName
code: def getStructureName (struct : Expr) : MetaM Name 
goal: Lean.MetaM Lean.Name
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/FVarSubst.lean

full_name: Lean.Meta.instInhabitedFVarSubst
code: /--
  Some tactics substitute hypotheses with expressions.
  We track these substitutions using `FVarSubst`.
  It is just a mapping from the original FVarId (internal) name
  to an expression. The free variables occurring in the expression must
  be defined in the new goal. -/
structure FVarSubst where
  map : AssocList FVarId Expr := {}
  deriving Inhabited
goal: Inhabited Lean.Meta.FVarSubst

full_name: Lean.Meta.FVarSubst
code: /--
  Some tactics substitute hypotheses with expressions.
  We track these substitutions using `FVarSubst`.
  It is just a mapping from the original FVarId (internal) name
  to an expression. The free variables occurring in the expression must
  be defined in the new goal. -/
structure FVarSubst where
  map : AssocList FVarId Expr := {}
  deriving Inhabited
goal: Type

full_name: Lean.Meta.FVarSubst.map
code: /--
  Some tactics substitute hypotheses with expressions.
  We track these substitutions using `FVarSubst`.
  It is just a mapping from the original FVarId (internal) name
  to an expression. The free variables occurring in the expression must
  be defined in the new goal. -/
structure FVarSubst where
  map : AssocList FVarId Expr := {}
  deriving Inhabited
goal: Lean.AssocList Lean.FVarId Lean.Expr

full_name: Lean.Meta.FVarSubst.empty
code: def empty : FVarSubst 
goal: Lean.Meta.FVarSubst

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

full_name: Lean.Meta.FVarSubst.contains
code: def contains (s : FVarSubst) (fvarId : FVarId) : Bool 
goal: Bool

full_name: Lean.Meta.FVarSubst.insert
code: /-- Add entry `fvarId |-> v` to `s` if `s` does not contain an entry for `fvarId`. -/
def insert (s : FVarSubst) (fvarId : FVarId) (v : Expr) : FVarSubst 
goal: Lean.Meta.FVarSubst

full_name: Lean.Meta.FVarSubst.erase
code: def erase (s : FVarSubst) (fvarId : FVarId) : FVarSubst 
goal: Lean.Meta.FVarSubst

full_name: Lean.Meta.FVarSubst.find?
code: def find? (s : FVarSubst) (fvarId : FVarId) : Option Expr 
goal: Option Lean.Expr

full_name: Lean.Meta.FVarSubst.get
code: def get (s : FVarSubst) (fvarId : FVarId) : Expr 
goal: Lean.Expr

full_name: Lean.Meta.FVarSubst.apply
code: /-- Given `e`, for each `(x => v)` in `s` replace `x` with `v` in `e` -/
def apply (s : FVarSubst) (e : Expr) : Expr 
goal: Lean.Expr

full_name: Lean.Meta.FVarSubst.domain
code: def domain (s : FVarSubst) : List FVarId 
goal: List Lean.FVarId

full_name: Lean.Meta.FVarSubst.any
code: def any (p : FVarId → Expr → Bool) (s : FVarSubst) : Bool 
goal: Bool

full_name: Lean.Meta.FVarSubst.append
code: /--
Constructs a substitution consisting of `s` followed by `t`.
This satisfies `(s.append t).apply e = t.apply (s.apply e)`
-/
def append (s t : FVarSubst) : FVarSubst 
goal: Lean.Meta.FVarSubst

full_name: Lean.LocalDecl.applyFVarSubst
code: def LocalDecl.applyFVarSubst (s : Meta.FVarSubst) : LocalDecl → LocalDecl
  
goal: Lean.LocalDecl → Lean.LocalDecl

full_name: Lean.Expr.applyFVarSubst
code: abbrev Expr.applyFVarSubst (s : Meta.FVarSubst) (e : Expr) : Expr 
goal: Lean.Expr
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Unfold.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Unfold.0.Lean.Meta.getSimpUnfoldContext
code: private def getSimpUnfoldContext : MetaM Simp.Context 
goal: Lean.MetaM Lean.Meta.Simp.Context

full_name: Lean.Meta.unfold
code: def unfold (e : Expr) (declName : Name) : MetaM Simp.Result 
goal: Lean.MetaM Lean.Meta.Simp.Result

full_name: Lean.Meta.unfold.pre
code: def unfold (e : Expr) (declName : Name) : MetaM Simp.Result 
goal: Lean.Meta.SimpM Lean.Meta.Simp.Step

full_name: Lean.Meta.unfoldTarget
code: def unfoldTarget (mvarId : MVarId) (declName : Name) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.unfoldLocalDecl
code: def unfoldLocalDecl (mvarId : MVarId) (fvarId : FVarId) (declName : Name) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Simp.lean

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Simp._hyg.4
code: builtin_initialize registerTraceClass `Meta.Tactic.simp
goal: IO Unit

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Simp._hyg.53
code: builtin_initialize registerTraceClass `Meta.Tactic.simp.congr (inherited := true)
goal: IO Unit

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Simp._hyg.103
code: builtin_initialize registerTraceClass `Meta.Tactic.simp.discharge (inherited := true)
goal: IO Unit

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Simp._hyg.153
code: builtin_initialize registerTraceClass `Meta.Tactic.simp.rewrite (inherited := true)
goal: IO Unit

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Simp._hyg.203
code: builtin_initialize registerTraceClass `Meta.Tactic.simp.unify (inherited := true)
goal: IO Unit

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Simp._hyg.253
code: builtin_initialize registerTraceClass `Meta.Tactic.simp.ground (inherited := true)
goal: IO Unit

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Simp._hyg.303
code: builtin_initialize registerTraceClass `Meta.Tactic.simp.numSteps
goal: IO Unit

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Simp._hyg.352
code: builtin_initialize registerTraceClass `Meta.Tactic.simp.heads
goal: IO Unit

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Simp._hyg.401
code: builtin_initialize registerTraceClass `Debug.Meta.Tactic.simp
goal: IO Unit

full_name: Lean.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Simp._hyg.450
code: builtin_initialize registerTraceClass `Debug.Meta.Tactic.simp.congr (inherited := true)
goal: IO Unit
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Revert.lean

full_name: Lean.MVarId.revert
code: /--
Revert free variables `fvarIds` at goal `mvarId`.
-/
def _root_.Lean.MVarId.revert (mvarId : MVarId) (fvarIds : Array FVarId) (preserveOrder : Bool := false)
    (clearAuxDeclsInsteadOfRevert := false) : MetaM (Array FVarId × MVarId) 
goal: Lean.MetaM (Array Lean.FVarId × Lean.MVarId)

full_name: Lean.MVarId.revertAfter
code: /-- Reverts all local declarations after `fvarId`. -/
def _root_.Lean.MVarId.revertAfter (mvarId : MVarId) (fvarId : FVarId) : MetaM (Array FVarId × MVarId) 
goal: Lean.MetaM (Array Lean.FVarId × Lean.MVarId)

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

full_name: Lean.Meta.delta?
code: def delta? (e : Expr) (p : Name → Bool := fun _ => true) : CoreM (Option Expr) 
goal: Lean.CoreM (Option Lean.Expr)

full_name: Lean.Meta.deltaExpand
code: /-- Low-level delta expansion. It is used to implement equation lemmas and elimination principles for recursive definitions. -/
def deltaExpand (e : Expr) (p : Name → Bool) : CoreM Expr 
goal: Lean.CoreM Lean.Expr

full_name: Lean.MVarId.deltaTarget
code: /--
Delta expand declarations that satisfy `p` at `mvarId` type.
-/
def _root_.Lean.MVarId.deltaTarget (mvarId : MVarId) (p : Name → Bool) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Meta.deltaTarget
code: @[deprecated MVarId.deltaTarget (since := "2022-07-15")]
def deltaTarget (mvarId : MVarId) (p : Name → Bool) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.deltaLocalDecl
code: /--
Delta expand declarations that satisfy `p` at `fvarId` type.
-/
def _root_.Lean.MVarId.deltaLocalDecl (mvarId : MVarId) (fvarId : FVarId) (p : Name → Bool) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

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

full_name: Lean.Meta.findLocalDeclWithType?
code: /-- Return a local declaration whose type is definitionally equal to `type`. -/
def findLocalDeclWithType? (type : Expr) : MetaM (Option FVarId) 
goal: Lean.MetaM (Option Lean.FVarId)

full_name: Lean.MVarId.assumptionCore
code: /-- Return `true` if managed to close goal `mvarId` using an assumption. -/
def _root_.Lean.MVarId.assumptionCore (mvarId : MVarId) : MetaM Bool 
goal: Lean.MetaM Bool

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

full_name: Lean.MVarId.assumption
code: /-- Close goal `mvarId` using an assumption. Throw error message if failed. -/
def _root_.Lean.MVarId.assumption (mvarId : MVarId) : MetaM Unit 
goal: Lean.MetaM Unit

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

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

full_name: Lean.MVarId.refl
code: /--
Close given goal using `Eq.refl`.
-/
def _root_.Lean.MVarId.refl (mvarId : MVarId) : MetaM Unit 
goal: Lean.MetaM Unit

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

full_name: Lean.MVarId.applyRefl
code: @[deprecated MVarId.refl (since := "2022-07-15")]
def _root_.Lean.MVarId.applyRefl (mvarId : MVarId) (msg : MessageData := "refl failed") : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Lean.MVarId.heqOfEq
code: /--
Try to apply `heq_of_eq`. If successful, then return new goal, otherwise return `mvarId`.
-/
def _root_.Lean.MVarId.heqOfEq (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.eqOfHEq
code: /--
Try to apply `eq_of_heq`. If successful, then return new goal, otherwise return `mvarId`.
-/
def _root_.Lean.MVarId.eqOfHEq (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.hrefl
code: /--
Close given goal using `HEq.refl`.
-/
def _root_.Lean.MVarId.hrefl (mvarId : MVarId) : MetaM Unit 
goal: Lean.MetaM Unit
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Repeat.lean

full_name: Lean.Meta.repeat'Core.go
code: /--
Implementation of `repeat'` and `repeat1'`.

`repeat'Core f` runs `f` on all of the goals to produce a new list of goals,
then runs `f` again on all of those goals, and repeats until `f` fails on all remaining goals,
or until `maxIters` total calls to `f` have occurred.

Returns a boolean indicating whether `f` succeeded at least once, and
all the remaining goals (i.e. those on which `f` failed).
-/
def repeat'Core [Monad m] [MonadExcept ε m] [MonadBacktrack s m] [MonadMCtx m]
    (f : MVarId → m (List MVarId)) (goals : List MVarId) (maxIters := 100000) :
    m (Bool × List MVarId) 
goal: Nat → Bool → List Lean.MVarId → List (List Lean.MVarId) → Array Lean.MVarId → m (Bool × Array Lean.MVarId)

full_name: Lean.Meta.repeat'Core
code: /--
Implementation of `repeat'` and `repeat1'`.

`repeat'Core f` runs `f` on all of the goals to produce a new list of goals,
then runs `f` again on all of those goals, and repeats until `f` fails on all remaining goals,
or until `maxIters` total calls to `f` have occurred.

Returns a boolean indicating whether `f` succeeded at least once, and
all the remaining goals (i.e. those on which `f` failed).
-/
def repeat'Core [Monad m] [MonadExcept ε m] [MonadBacktrack s m] [MonadMCtx m]
    (f : MVarId → m (List MVarId)) (goals : List MVarId) (maxIters := 100000) :
    m (Bool × List MVarId) 
goal: m (Bool × List Lean.MVarId)

full_name: Lean.Meta.repeat'
code: /--
`repeat' f` runs `f` on all of the goals to produce a new list of goals,
then runs `f` again on all of those goals, and repeats until `f` fails on all remaining goals,
or until `maxIters` total calls to `f` have occurred.
Always succeeds (returning the original goals if `f` fails on all of them).
-/
def repeat' [Monad m] [MonadExcept ε m] [MonadBacktrack s m] [MonadMCtx m]
    (f : MVarId → m (List MVarId)) (goals : List MVarId) (maxIters := 100000) : m (List MVarId) 
goal: m (List Lean.MVarId)

full_name: Lean.Meta.repeat1'
code: /--
`repeat1' f` runs `f` on all of the goals to produce a new list of goals,
then runs `f` again on all of those goals, and repeats until `f` fails on all remaining goals,
or until `maxIters` total calls to `f` have occurred.
Fails if `f` does not succeed at least once.
-/
def repeat1' [Monad m] [MonadError m] [MonadExcept ε m] [MonadBacktrack s m] [MonadMCtx m]
    (f : MVarId → m (List MVarId)) (goals : List MVarId) (maxIters := 100000) : m (List MVarId) 
goal: m (List Lean.MVarId)
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Symm.lean

full_name: Lean.Meta.Symm.symmExt.config
code: /-- Discrimation tree settings for the `symm` extension. -/
def symmExt.config : WhnfCoreConfig 
goal: Lean.Meta.WhnfCoreConfig

full_name: Lean.Meta.Symm.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Symm._hyg.21
code: /-- Environment extensions for symm lemmas -/
builtin_initialize symmExt :
    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.Symm.symmExt
code: /-- Environment extensions for symm lemmas -/
builtin_initialize symmExt :
    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.Symm.initFn._@..lake.packages.lean4.src.lean.Lean.Meta.Tactic.Symm._hyg.106
code: builtin_initialize registerBuiltinAttribute {
  name := `symm
  descr := "symmetric relation"
  add := fun decl _ kind => MetaM.run' do
    let declTy := (← getConstInfo decl).type
    let (xs, _, targetTy) ← withReducible <| forallMetaTelescopeReducing declTy
    let fail := throwError
      "@[symm] attribute only applies to lemmas proving x ∼ y → y ∼ x, got {declTy}"
    let some _ := xs.back? | fail
    let targetTy ← reduce targetTy
    let .app (.app rel _) _ := targetTy | fail
    let key ← withReducible <| DiscrTree.mkPath rel symmExt.config
    symmExt.add (decl, key) kind
}
goal: IO Unit

full_name: Lean.Expr.getSymmLems
code: /-- Return the symmetry lemmas that match the target type. -/
def getSymmLems (tgt : Expr) : MetaM (Array Name) 
goal: Lean.MetaM (Array Lean.Name)

full_name: Lean.Expr.applySymm
code: /-- Given a term `e : a ~ b`, construct a term in `b ~ a` using `@[symm]` lemmas. -/
def applySymm (e : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: Lean.MVarId.applySymm
code: /--
Apply a symmetry lemma (i.e. marked with `@[symm]`) to a metavariable.

The type of `g` should be of the form `a ~ b`, and is used to index the symm lemmas.
-/
def applySymm (g : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.applySymmAt
code: /-- Use a symmetry lemma (i.e. marked with `@[symm]`) to replace a hypothesis in a goal. -/
def applySymmAt (h : FVarId) (g : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.symmSaturate
code: /-- For every hypothesis `h : a ~ b` where a `@[symm]` lemma is available,
add a hypothesis `h_symm : b ~ a`. -/
def symmSaturate (g : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId
File: .lake/packages/lean4/src/lean/Lean/Meta/Tactic/Grind/Cases.lean

full_name: Lean.Meta.Grind.cases
code: /--
The `grind` tactic includes an auxiliary `cases` tactic that is not intended for direct use by users.
This method implements it.
This tactic is automatically applied when introducing local declarations with a type tagged with `[grind_cases]`.
It differs from the user-facing Lean `cases` tactic in the following ways:

- It avoids unnecessary `revert` and `intro` operations.

- It does not introduce new local declarations for each minor premise. Instead, the `grind` tactic preprocessor is responsible for introducing them.

- It assumes that the major premise (i.e., the parameter `fvarId`) is the latest local declaration in the current goal.

- If the major premise type is an indexed family, auxiliary declarations and (heterogeneous) equalities are introduced.
  However, these equalities are not resolved using `unifyEqs`. Instead, the `grind` tactic employs union-find and
  congruence closure to process these auxiliary equalities. This approach avoids applying substitution to propositions
  that have already been internalized by `grind`.
-/
def cases (mvarId : MVarId) (fvarId : FVarId) : MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: Lean.Meta.Grind.cases.throwInductiveExpected
code: /--
The `grind` tactic includes an auxiliary `cases` tactic that is not intended for direct use by users.
This method implements it.
This tactic is automatically applied when introducing local declarations with a type tagged with `[grind_cases]`.
It differs from the user-facing Lean `cases` tactic in the following ways:

- It avoids unnecessary `revert` and `intro` operations.

- It does not introduce new local declarations for each minor premise. Instead, the `grind` tactic preprocessor is responsible for introducing them.

- It assumes that the major premise (i.e., the parameter `fvarId`) is the latest local declaration in the current goal.

- If the major premise type is an indexed family, auxiliary declarations and (heterogeneous) equalities are introduced.
  However, these equalities are not resolved using `unifyEqs`. Instead, the `grind` tactic employs union-find and
  congruence closure to process these auxiliary equalities. This approach avoids applying substitution to propositions
  that have already been internalized by `grind`.
-/
def cases (mvarId : MVarId) (fvarId : FVarId) : MetaM (List MVarId) 
goal: Lean.MetaM α