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

full_name: Lean.Elab.Level.Context.ref
code: structure Context where
  options           : Options
  ref               : Syntax
  autoBoundImplicit : Bool
goal: Lean.Syntax

full_name: Lean.Elab.Level.Context
code: structure Context where
  options           : Options
  ref               : Syntax
  autoBoundImplicit : Bool
goal: Type

full_name: Lean.Elab.Level.Context.options
code: structure Context where
  options           : Options
  ref               : Syntax
  autoBoundImplicit : Bool
goal: Lean.Options

full_name: Lean.Elab.Level.Context.autoBoundImplicit
code: structure Context where
  options           : Options
  ref               : Syntax
  autoBoundImplicit : Bool
goal: Bool

full_name: Lean.Elab.Level.State.ngen
code: structure State where
  ngen       : NameGenerator
  mctx       : MetavarContext
  levelNames : List Name
goal: Lean.NameGenerator

full_name: Lean.Elab.Level.State.mctx
code: structure State where
  ngen       : NameGenerator
  mctx       : MetavarContext
  levelNames : List Name
goal: Lean.MetavarContext

full_name: Lean.Elab.Level.State.levelNames
code: structure State where
  ngen       : NameGenerator
  mctx       : MetavarContext
  levelNames : List Name
goal: List Lean.Name

full_name: Lean.Elab.Level.State
code: structure State where
  ngen       : NameGenerator
  mctx       : MetavarContext
  levelNames : List Name
goal: Type

full_name: Lean.Elab.Level.LevelElabM
code: abbrev LevelElabM 
goal: Type

full_name: Lean.Elab.Level.instMonadOptionsLevelElabM
code: instance : MonadOptions LevelElabM 
goal: Lean.MonadOptions Lean.Elab.Level.LevelElabM

full_name: Lean.Elab.Level.instMonadRefLevelElabM
code: @[always_inline]
instance : MonadRef LevelElabM 
goal: Lean.MonadRef Lean.Elab.Level.LevelElabM

full_name: Lean.Elab.Level.instAddMessageContextLevelElabM
code: instance : AddMessageContext LevelElabM 
goal: Lean.AddMessageContext Lean.Elab.Level.LevelElabM

full_name: Lean.Elab.Level.instMonadNameGeneratorLevelElabM
code: @[always_inline]
instance : MonadNameGenerator LevelElabM 
goal: Lean.MonadNameGenerator Lean.Elab.Level.LevelElabM

full_name: Lean.Elab.Level.mkFreshLevelMVar
code: def mkFreshLevelMVar : LevelElabM Level 
goal: Lean.Elab.Level.LevelElabM Lean.Level

full_name: Lean.Elab.Level.maxUniverseOffset
code: register_builtin_option maxUniverseOffset : Nat := {
  defValue := 32
  descr    := "maximum universe level offset"
}
goal: Lean.Option Nat

full_name: Lean.Elab.Level.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Level._hyg.285
code: register_builtin_option maxUniverseOffset : Nat := {
  defValue := 32
  descr    := "maximum universe level offset"
}
goal: IO (Lean.Option Nat)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Level.0.Lean.Elab.Level.checkUniverseOffset
code: private def checkUniverseOffset [Monad m] [MonadError m] [MonadOptions m] (n : Nat) : m Unit 
goal: m Unit

full_name: Lean.Elab.Level.elabLevel
code: partial def elabLevel (stx : Syntax) : LevelElabM Level 
goal: Lean.Elab.Level.LevelElabM Lean.Level
File: .lake/packages/lean4/src/lean/Lean/Elab/BinderPredicates.lean

full_name: Lean.Elab.Command.elabBinderPred
code: @[builtin_command_elab binderPredicate] def elabBinderPred : CommandElab 
goal: Lean.Elab.Command.CommandElab

full_name: Lean.Elab.Command.checkBinderPredicate
code: /-- Missing docs handler for `binder_predicate` -/
@[builtin_missing_docs_handler Lean.Parser.Command.binderPredicate]
def checkBinderPredicate : SimpleHandler 
goal: Lean.Linter.MissingDocs.SimpleHandler
File: .lake/packages/lean4/src/lean/Lean/Elab/Macro.lean

full_name: Lean.Elab.Command.elabMacro
code: @[builtin_command_elab Lean.Parser.Command.macro] def elabMacro : CommandElab
  
goal: Lean.Elab.Command.CommandElab
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Unfold.lean

full_name: Lean.Elab.Tactic.unfoldLocalDecl
code: def unfoldLocalDecl (declName : Name) (fvarId : FVarId) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.unfoldTarget
code: def unfoldTarget (declName : Name) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.evalUnfold.go
code: /-- "unfold " ident+ (location)? -/
@[builtin_tactic Lean.Parser.Tactic.unfold] def evalUnfold : Tactic 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.evalUnfold
code: /-- "unfold " ident+ (location)? -/
@[builtin_tactic Lean.Parser.Tactic.unfold] def evalUnfold : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Congr.lean

full_name: Lean.Elab.Tactic.Lean.Elab.Tactic.evalCongr
code: @[builtin_tactic Parser.Tactic.congr] def evalCongr : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Generalize.lean

full_name: Lean.Elab.Tactic.evalGeneralize
code: @[builtin_tactic Lean.Parser.Tactic.generalize] def evalGeneralize : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/PreDefinition/Structural/BRecOn.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.PreDefinition.Structural.BRecOn.0.Lean.Elab.Structural.throwToBelowFailed
code: private def throwToBelowFailed : MetaM α 
goal: Lean.MetaM α

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.PreDefinition.Structural.BRecOn.0.Lean.Elab.Structural.toBelowAux
code: /-- See `toBelow` -/
private partial def toBelowAux (C : Expr) (belowDict : Expr) (arg : Expr) (F : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.PreDefinition.Structural.BRecOn.0.Lean.Elab.Structural.withBelowDict
code: /-- See `toBelow` -/
private def withBelowDict (below : Expr) (numIndParams : Nat) (k : Expr → Expr → MetaM α) : MetaM α 
goal: Lean.MetaM α

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.PreDefinition.Structural.BRecOn.0.Lean.Elab.Structural.toBelow
code: /--
  `below` is a free variable with type of the form `I.below indParams motive indices major`,
  where `I` is the name of an inductive datatype.

  For example, when trying to show that the following function terminates using structural recursion
  ```lean
  def addAdjacent : List Nat → List Nat
  | []       => []
  | [a]      => [a]
  | a::b::as => (a+b) :: addAdjacent as
  ```
  when we are visiting `addAdjacent as` at `replaceRecApps`, `below` has type
  `@List.below Nat (fun (x : List Nat) => List Nat) (a::b::as)`
  The motive `fun (x : List Nat) => List Nat` depends on the actual function we are trying to compute.
  So, we first replace it with a fresh variable `C` at `withBelowDict`.
  Recall that `brecOn` implements course-of-values recursion, and `below` can be viewed as a dictionary
  of the "previous values".
  We search this dictionary using the auxiliary function `toBelowAux`.
  The dictionary is built using the `PProd` (`And` for inductive predicates).
  We keep searching it until we find `C recArg`, where `C` is the auxiliary fresh variable created at `withBelowDict`.  -/
private partial def toBelow (below : Expr) (numIndParams : Nat) (recArg : Expr) : MetaM Expr 
goal: Lean.MetaM Lean.Expr

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.PreDefinition.Structural.BRecOn.0.Lean.Elab.Structural.replaceRecApps.loop
code: private partial def replaceRecApps (recFnName : Name) (recArgInfo : RecArgInfo) (below : Expr) (e : Expr) : M Expr 
goal: StateRefT' IO.RealWorld (Lean.HasConstCache recFnName) Lean.Elab.Structural.M Lean.Expr

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.PreDefinition.Structural.BRecOn.0.Lean.Elab.Structural.replaceRecApps
code: private partial def replaceRecApps (recFnName : Name) (recArgInfo : RecArgInfo) (below : Expr) (e : Expr) : M Expr 
goal: Lean.Elab.Structural.M Lean.Expr

full_name: Lean.Elab.Structural.mkBRecOn
code: def mkBRecOn (recFnName : Name) (recArgInfo : RecArgInfo) (value : Expr) : M Expr 
goal: Lean.Elab.Structural.M Lean.Expr
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Location.lean

full_name: Lean.Elab.Tactic.Location
code: /-- Denotes a set of locations where a tactic should be applied for the main goal. See also `withLocation`. -/
inductive Location where
  /-- Apply the tactic everywhere. -/
  | wildcard
  /-- `hypotheses` are hypothesis names in the main goal that the tactic should be applied to.
  If `type` is true, then the tactic should also be applied to the target type. -/
  | targets (hypotheses : Array Syntax) (type : Bool)
goal: Type

full_name: Lean.Elab.Tactic.Location.wildcard
code: /-- Denotes a set of locations where a tactic should be applied for the main goal. See also `withLocation`. -/
inductive Location where
  /-- Apply the tactic everywhere. -/
  | wildcard
  /-- `hypotheses` are hypothesis names in the main goal that the tactic should be applied to.
  If `type` is true, then the tactic should also be applied to the target type. -/
  | targets (hypotheses : Array Syntax) (type : Bool)
goal: Lean.Elab.Tactic.Location

full_name: Lean.Elab.Tactic.Location.targets
code: /-- Denotes a set of locations where a tactic should be applied for the main goal. See also `withLocation`. -/
inductive Location where
  /-- Apply the tactic everywhere. -/
  | wildcard
  /-- `hypotheses` are hypothesis names in the main goal that the tactic should be applied to.
  If `type` is true, then the tactic should also be applied to the target type. -/
  | targets (hypotheses : Array Syntax) (type : Bool)
goal: Lean.Elab.Tactic.Location

full_name: Lean.Elab.Tactic.expandLocation
code: def expandLocation (stx : Syntax) : Location 
goal: Lean.Elab.Tactic.Location

full_name: Lean.Elab.Tactic.expandOptLocation
code: def expandOptLocation (stx : Syntax) : Location 
goal: Lean.Elab.Tactic.Location

full_name: Lean.Elab.Tactic.withLocation
code: /--
Runs the given `atLocal` and `atTarget` methods on each of the locations selected by the given `loc`.
* If `loc` is a list of locations, runs at each specified hypothesis (and finally the goal if `⊢` is included),
  and fails if any of the tactic applications fail.
* If `loc` is `*`, runs at the target first and then the hypotheses in reverse order.
  If `atTarget` closes the main goal, `withLocation` does not run `atLocal`.
  If all tactic applications fail, `withLocation` with call `failed` with the main goal mvar.
-/
def withLocation (loc : Location) (atLocal : FVarId → TacticM Unit) (atTarget : TacticM Unit) (failed : MVarId → TacticM Unit) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Delta.lean

full_name: Lean.Elab.Tactic.deltaLocalDecl
code: def deltaLocalDecl (declNames : Array Name) (fvarId : FVarId) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.deltaTarget
code: def deltaTarget (declNames : Array Name) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.evalDelta
code: /-- "delta " ident+ (location)? -/
@[builtin_tactic Lean.Parser.Tactic.delta] def evalDelta : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/SimpTrace.lean

full_name: Lean.Elab.Tactic.mkSimpCallStx
code: /-- Constructs the syntax for a simp call, for use with `simp?`. -/
def mkSimpCallStx (stx : Syntax) (usedSimps : UsedSimps) : MetaM (TSyntax `tactic) 
goal: Lean.MetaM (Lean.TSyntax `tactic)

full_name: Lean.Elab.Tactic.evalSimpTrace
code: @[builtin_tactic simpTrace] def evalSimpTrace : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.evalSimpAllTrace
code: @[builtin_tactic simpAllTrace] def evalSimpAllTrace : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.dsimpLocation'.go
code: /-- Implementation of `dsimp?`. -/
def dsimpLocation' (ctx : Simp.Context) (simprocs : SimprocsArray) (loc : Location) :
    TacticM Simp.Stats 
goal: Lean.Elab.Tactic.TacticM Lean.Meta.Simp.Stats

full_name: Lean.Elab.Tactic.dsimpLocation'
code: /-- Implementation of `dsimp?`. -/
def dsimpLocation' (ctx : Simp.Context) (simprocs : SimprocsArray) (loc : Location) :
    TacticM Simp.Stats 
goal: Lean.Elab.Tactic.TacticM Lean.Meta.Simp.Stats

full_name: Lean.Elab.Tactic.evalDSimpTrace
code: @[builtin_tactic dsimpTrace] def evalDSimpTrace : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Change.lean

full_name: Lean.Elab.Tactic.«_aux_.lake_packages_lean4_src_lean_Lean_Elab_Tactic_Change___elabRules_Lean_Parser_Tactic_change_1»
code: /-- `change` can be used to replace the main goal or its hypotheses with
different, yet definitionally equal, goal or hypotheses.

For example, if `n : Nat` and the current goal is `⊢ n + 2 = 2`, then
```lean
change _ + 1 = _
```
changes the goal to `⊢ n + 1 + 1 = 2`.

The tactic also applies to hypotheses. If `h : n + 2 = 2` and `h' : n + 3 = 4`
are hypotheses, then
```lean
change _ + 1 = _ at h h'
```
changes their types to be `h : n + 1 + 1 = 2` and `h' : n + 2 + 1 = 4`.

Change is like `refine` in that every placeholder needs to be solved for by unification,
but using named placeholders or `?_` results in `change` to creating new goals.

The tactic `show e` is interchangeable with `change e`, where the pattern `e` is applied to
the main goal. -/
@[builtin_tactic change] elab_rules : tactic
  | `(tactic| change $newType:term $[$loc:location]?) => do
    withLocation (expandOptLocation (Lean.mkOptionalNode loc))
      (atLocal := fun h => do
        let hTy ← h.getType
        -- This is a hack to get the new type to elaborate in the same sort of way that
        -- it would for a `show` expression for the goal.
        let mvar ← mkFreshExprMVar none
        let (_, mvars) ← elabTermWithHoles
                          (← `(term | show $newType from $(← Term.exprToSyntax mvar))) hTy `change
        liftMetaTactic fun mvarId => do
          return (← mvarId.changeLocalDecl h (← inferType mvar)) :: mvars)
      (atTarget := evalTactic <| ← `(tactic| refine_lift show $newType from ?_))
      (failed := fun _ => throwError "change tactic failed")
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Symm.lean

full_name: Lean.Elab.Tactic.evalSymm
code: @[builtin_tactic Lean.Parser.Tactic.symm]
def evalSymm : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.evalSymmSaturate
code: @[builtin_tactic Lean.Parser.Tactic.symmSaturate]
def evalSymmSaturate : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Rfl.lean

full_name: Lean.Elab.Tactic.Rfl.evalApplyRfl
code: @[builtin_tactic Lean.Parser.Tactic.applyRfl] def evalApplyRfl : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Match.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Match.0.Lean.Elab.Tactic.mkAuxiliaryMatchTerm
code: private def mkAuxiliaryMatchTerm (parentTag : Name) (matchTac : Syntax) : MacroM (Term × Array Syntax) 
goal: Lean.MacroM (Lean.Term × Array Lean.Syntax)

full_name: Lean.Elab.Tactic.evalMatch
code: @[builtin_tactic Lean.Parser.Tactic.match]
def evalMatch : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Repeat.lean

full_name: Lean.Elab.Tactic.evalRepeat'
code: @[builtin_tactic repeat']
def evalRepeat' : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.evalRepeat1'
code: @[builtin_tactic repeat1']
def evalRepeat1' : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Conv/Unfold.lean

full_name: Lean.Elab.Tactic.Conv.evalUnfold
code: @[builtin_tactic Lean.Parser.Tactic.Conv.unfold] def evalUnfold : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Conv/Change.lean

full_name: Lean.Elab.Tactic.Conv.evalChange
code: @[builtin_tactic Lean.Parser.Tactic.Conv.change] def evalChange : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Conv/Delta.lean

full_name: Lean.Elab.Tactic.Conv.evalDelta
code: @[builtin_tactic Lean.Parser.Tactic.Conv.delta] def evalDelta : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Rewrites.lean

full_name: Lean.Elab.Rewrites.evalExact
code: @[builtin_tactic Lean.Parser.Tactic.rewrites?]
def evalExact : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Conv/Simp.lean

full_name: Lean.Elab.Tactic.Conv.applySimpResult
code: def applySimpResult (result : Simp.Result) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.Conv.evalSimp
code: @[builtin_tactic Lean.Parser.Tactic.Conv.simp] def evalSimp : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.Conv.evalSimpMatch
code: @[builtin_tactic Lean.Parser.Tactic.Conv.simpMatch] def evalSimpMatch : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.Conv.evalDSimp
code: @[builtin_tactic Lean.Parser.Tactic.Conv.dsimp] def evalDSimp : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Conv/Rewrite.lean

full_name: Lean.Elab.Tactic.Conv.evalRewrite
code: @[builtin_tactic Lean.Parser.Tactic.Conv.rewrite] def evalRewrite : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/FalseOrByContra.lean

full_name: Lean.MVarId.falseOrByContra
code: @[inherit_doc Lean.Parser.Tactic.falseOrByContra]
-- When `useClassical` is `none`, we try to find a `Decidable` instance when replacing `P` with `¬ ¬ P`,
-- but fall back to a classical instance. When it is `some true`, we always use the classical instance.
-- When it is `some false`, if there is no `Decidable` instance we don't introduce the double negation,
-- and fall back to `False.elim`.
partial def falseOrByContra (g : MVarId) (useClassical : Option Bool := none) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.MVarId.elabFalseOrByContra
code: @[builtin_tactic Lean.Parser.Tactic.falseOrByContra]
def elabFalseOrByContra : Tactic
   
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Cache.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Cache.0.Lean.Elab.Tactic.equivMVarDecl
code: private def equivMVarDecl (d₁ d₂ : MetavarDecl) : Bool 
goal: Bool

full_name: Lean.Elab.Tactic.tactic.dbg_cache
code: register_builtin_option tactic.dbg_cache : Bool := {
  defValue := false
  group    := "tactic"
  descr    := "enable tactic cache debug messages (remark: they are sent to the standard error)"
}
goal: Lean.Option Bool

full_name: Lean.Elab.Tactic.initFn._@..lake.packages.lean4.src.lean.Lean.Elab.Tactic.Cache._hyg.17
code: register_builtin_option tactic.dbg_cache : Bool := {
  defValue := false
  group    := "tactic"
  descr    := "enable tactic cache debug messages (remark: they are sent to the standard error)"
}
goal: IO (Lean.Option Bool)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Cache.0.Lean.Elab.Tactic.dbg_cache
code: private def dbg_cache (msg : String) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Cache.0.Lean.Elab.Tactic.dbg_cache'
code: private def dbg_cache' (cacheRef : IO.Ref Cache) (pos : String.Pos) (mvarId : MVarId) (msg : String) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Cache.0.Lean.Elab.Tactic.findCache?
code: private def findCache? (cacheRef : IO.Ref Cache) (mvarId : MVarId) (stx : Syntax) (pos : String.Pos) : TacticM (Option Snapshot) 
goal: Lean.Elab.Tactic.TacticM (Option Lean.Elab.Tactic.Snapshot)

full_name: Lean.Elab.Tactic.evalCheckpoint
code: @[builtin_tactic checkpoint] def evalCheckpoint : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Rewrite.lean

full_name: Lean.Elab.Tactic.rewriteTarget
code: def rewriteTarget (stx : Syntax) (symm : Bool) (config : Rewrite.Config := {}) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.rewriteLocalDecl
code: def rewriteLocalDecl (stx : Syntax) (symm : Bool) (fvarId : FVarId) (config : Rewrite.Config := {}) :
    TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.withRWRulesSeq.go
code: def withRWRulesSeq (token : Syntax) (rwRulesSeqStx : Syntax) (x : (symm : Bool) → (term : Syntax) → TacticM Unit) : TacticM Unit 
goal: List Lean.Name → Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.withRWRulesSeq
code: def withRWRulesSeq (token : Syntax) (rwRulesSeqStx : Syntax) (x : (symm : Bool) → (term : Syntax) → TacticM Unit) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.evalUnsafe._@..lake.packages.lean4.src.lean.Lean.Elab.Tactic.Rewrite._hyg.1167
code: declare_config_elab elabRewriteConfig Rewrite.Config
goal: Lean.Expr → Lean.Elab.TermElabM Lean.Meta.Rewrite.Config

full_name: Lean.Elab.Tactic.elabRewriteConfig
code: declare_config_elab elabRewriteConfig Rewrite.Config
goal: Lean.Syntax → Lean.Elab.TermElabM Lean.Meta.Rewrite.Config

full_name: Lean.Elab.Tactic.eval._@..lake.packages.lean4.src.lean.Lean.Elab.Tactic.Rewrite._hyg.1167
code: declare_config_elab elabRewriteConfig Rewrite.Config
goal: Lean.Expr → Lean.Elab.TermElabM Lean.Meta.Rewrite.Config

full_name: Lean.Elab.Tactic.evalRewriteSeq
code: @[builtin_tactic Lean.Parser.Tactic.rewriteSeq] def evalRewriteSeq : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/lean4/src/lean/Lean/Elab/Tactic/Conv/Congr.lean

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Conv.Congr.0.Lean.Elab.Tactic.Conv.congrImplies
code: private def congrImplies (mvarId : MVarId) : MetaM (List MVarId) 
goal: Lean.MetaM (List Lean.MVarId)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Conv.Congr.0.Lean.Elab.Tactic.Conv.isImplies
code: private def isImplies (e : Expr) : MetaM Bool 
goal: Lean.MetaM Bool

full_name: Lean.Elab.Tactic.Conv.congr
code: def congr (mvarId : MVarId) (addImplicitArgs := false) (nameSubgoals := true) :
    MetaM (List (Option MVarId)) 
goal: Lean.MetaM (List (Option Lean.MVarId))

full_name: Lean.Elab.Tactic.Conv.evalCongr
code: @[builtin_tactic Lean.Parser.Tactic.Conv.congr] def evalCongr : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Conv.Congr.0.Lean.Elab.Tactic.Conv.selectIdx
code: private def selectIdx (tacticName : String) (mvarIds : List (Option MVarId)) (i : Int) :
  TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.Conv.evalSkip
code: @[builtin_tactic Lean.Parser.Tactic.Conv.skip] def evalSkip : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.Conv.evalLhs
code: @[builtin_tactic Lean.Parser.Tactic.Conv.lhs] def evalLhs : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.Conv.evalRhs
code: @[builtin_tactic Lean.Parser.Tactic.Conv.rhs] def evalRhs : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.Conv.congrFunN
code: /-- Implementation of `arg 0` -/
def congrFunN (mvarId : MVarId) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: Lean.Elab.Tactic.Conv.evalArg
code: @[builtin_tactic Lean.Parser.Tactic.Conv.arg] def evalArg : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.Conv.evalFun
code: @[builtin_tactic Lean.Parser.Tactic.Conv.«fun»] def evalFun : Tactic 
goal: Lean.Elab.Tactic.Tactic

full_name: Lean.Elab.Tactic.Conv.extLetBodyCongr?
code: def extLetBodyCongr? (mvarId : MVarId) (lhs rhs : Expr) : MetaM (Option MVarId) 
goal: Lean.MetaM (Option Lean.MVarId)

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Conv.Congr.0.Lean.Elab.Tactic.Conv.extCore
code: private def extCore (mvarId : MVarId) (userName? : Option Name) : MetaM MVarId 
goal: Lean.MetaM Lean.MVarId

full_name: _private.«.lake».packages.lean4.src.lean.Lean.Elab.Tactic.Conv.Congr.0.Lean.Elab.Tactic.Conv.ext
code: private def ext (userName? : Option Name) : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: Lean.Elab.Tactic.Conv.evalExt
code: @[builtin_tactic Lean.Parser.Tactic.Conv.ext] def evalExt : Tactic 
goal: Lean.Elab.Tactic.Tactic