ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: .lake/packages/aesop/Aesop/RuleTac/Forward.lean

full_name: Aesop.RuleTac.makeForwardHyps.loop
code: partial def makeForwardHyps (e : Expr) (pat? : Option RulePattern)
    (patInst : RulePatternInstantiation) (immediate : UnorderedArraySet Nat)
    (maxDepth? : Option Nat) (forwardHypData : ForwardHypData) :
    MetaM (Array (Expr × Nat) × Array FVarId) 
goal: Lean.MetaM (Array (Lean.Expr × Nat) × Array Lean.FVarId × Lean.HashSet Lean.Expr)

full_name: Aesop.RuleTac.makeForwardHyps
code: partial def makeForwardHyps (e : Expr) (pat? : Option RulePattern)
    (patInst : RulePatternInstantiation) (immediate : UnorderedArraySet Nat)
    (maxDepth? : Option Nat) (forwardHypData : ForwardHypData) :
    MetaM (Array (Expr × Nat) × Array FVarId) 
goal: Lean.MetaM (Array (Lean.Expr × Nat) × Array Lean.FVarId)

full_name: Aesop.RuleTac.assertForwardHyp
code: def assertForwardHyp (goal : MVarId) (hyp : Hypothesis) (depth : Nat)
    (md : TransparencyMode) : ScriptM MVarId 
goal: Aesop.ScriptM Lean.MVarId

full_name: Aesop.RuleTac.assertForwardHyp.tacticBuilder
code: def assertForwardHyp (goal : MVarId) (hyp : Hypothesis) (depth : Nat)
    (md : TransparencyMode) : ScriptM MVarId 
goal: Lean.MVarId → Aesop.Script.TacticBuilder

full_name: Aesop.RuleTac.applyForwardRule.err
code: def applyForwardRule (goal : MVarId) (e : Expr) (pat? : Option RulePattern)
    (patInsts : HashSet RulePatternInstantiation)
    (immediate : UnorderedArraySet Nat) (clear : Bool)
    (md : TransparencyMode) (maxDepth? : Option Nat) : ScriptM MVarId 
goal: Lean.MetaM α

full_name: Aesop.RuleTac.applyForwardRule
code: def applyForwardRule (goal : MVarId) (e : Expr) (pat? : Option RulePattern)
    (patInsts : HashSet RulePatternInstantiation)
    (immediate : UnorderedArraySet Nat) (clear : Bool)
    (md : TransparencyMode) (maxDepth? : Option Nat) : ScriptM MVarId 
goal: Aesop.ScriptM Lean.MVarId

full_name: Aesop.RuleTac.forwardExpr
code: @[inline]
def forwardExpr (e : Expr) (pat? : Option RulePattern)
    (immediate : UnorderedArraySet Nat) (clear : Bool) (md : TransparencyMode) :
    RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.forwardConst
code: def forwardConst (decl : Name) (pat? : Option RulePattern)
    (immediate : UnorderedArraySet Nat) (clear : Bool) (md : TransparencyMode) :
    RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.forwardTerm
code: def forwardTerm (stx : Term) (pat? : Option RulePattern)
    (immediate : UnorderedArraySet Nat) (clear : Bool) (md : TransparencyMode) :
    RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.RuleTac.forward
code: def forward (t : RuleTerm) (pat? : Option RulePattern)
    (immediate : UnorderedArraySet Nat) (clear : Bool) (md : TransparencyMode) :
    RuleTac 
goal: Aesop.RuleTac
File: .lake/packages/aesop/Aesop/Tree/Tracing.lean

full_name: _private.«.lake».packages.aesop.Aesop.Tree.Tracing.0.Aesop.toYesNo
code: private def toYesNo : Bool → String
  
goal: Bool → String

full_name: Aesop.Goal.withHeadlineTraceNode
code: def Goal.withHeadlineTraceNode (g : Goal) (traceOpt : TraceOption) (k : MetaM α)
    (collapsed := true) (transform : MessageData → MetaM MessageData := pure) :
    MetaM α 
goal: Lean.MetaM α

full_name: Aesop.Goal.withHeadlineTraceNode.fmt
code: def Goal.withHeadlineTraceNode (g : Goal) (traceOpt : TraceOption) (k : MetaM α)
    (collapsed := true) (transform : MessageData → MetaM MessageData := pure) :
    MetaM α 
goal: Lean.MetaM Lean.MessageData

full_name: Aesop.Goal.traceMetadata.trc
code: def Goal.traceMetadata (g : Goal) (traceOpt : TraceOption) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Aesop.Goal.traceMetadata.trcNode
code: def Goal.traceMetadata (g : Goal) (traceOpt : TraceOption) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Aesop.Goal.traceMetadata
code: def Goal.traceMetadata (g : Goal) (traceOpt : TraceOption) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Aesop.Rapp.withHeadlineTraceNode
code: def Rapp.withHeadlineTraceNode (r : Rapp) (traceOpt : TraceOption) (k : MetaM α)
    (collapsed := true) (transform : MessageData → MetaM MessageData := pure) :
    MetaM α 
goal: Lean.MetaM α

full_name: Aesop.Rapp.traceMetadata
code: def Rapp.traceMetadata (r : Rapp) (traceOpt : TraceOption) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Aesop.Rapp.traceMetadata.trc
code: def Rapp.traceMetadata (r : Rapp) (traceOpt : TraceOption) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Aesop.Goal.traceTree
code: def Goal.traceTree (g : Goal) (traceOpt : TraceOption) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Aesop.Rapp.traceTree
code: def Rapp.traceTree (r : Rapp) (traceOpt : TraceOption) : MetaM Unit 
goal: Lean.MetaM Unit
File: .lake/packages/aesop/Aesop/Tree/ExtractProof.lean

full_name: Aesop.termThrowPRError_._@..lake.packages.aesop.Aesop.Tree.ExtractProof._hyg.5
code: macro "throwPRError " s:interpolatedStr(term) : term =>
  `(throwError m!"aesop: internal error during proof reconstruction: " ++ m!$s)
goal: Lean.ParserDescr

full_name: Aesop.«_aux_.lake_packages_aesop_Aesop_Tree_ExtractProof___macroRules_Aesop_termThrowPRError__1»
code: macro "throwPRError " s:interpolatedStr(term) : term =>
  `(throwError m!"aesop: internal error during proof reconstruction: " ++ m!$s)
goal: Lean.Macro

full_name: _private.«.lake».packages.aesop.Aesop.Tree.ExtractProof.0.Aesop.getNewConsts
code: private def getNewConsts (oldEnv newEnv : Environment) :
    HashMap Name ConstantInfo 
goal: Lean.HashMap Lean.Name Lean.ConstantInfo

full_name: _private.«.lake».packages.aesop.Aesop.Tree.ExtractProof.0.Aesop.copyNewDeclarations
code: private def copyNewDeclarations (oldEnv newEnv : Environment) : CoreM Unit 
goal: Lean.CoreM Unit

full_name: _private.«.lake».packages.aesop.Aesop.Tree.ExtractProof.0.Aesop.copyMatchEqnsExtState
code: private def copyMatchEqnsExtState (oldEnv newEnv : Environment) : CoreM Unit 
goal: Lean.CoreM Unit

full_name: _private.«.lake».packages.aesop.Aesop.Tree.ExtractProof.0.Aesop.copyEnvModifications
code: private def copyEnvModifications (oldEnv newEnv : Environment) : CoreM Unit 
goal: Lean.CoreM Unit

full_name: _private.«.lake».packages.aesop.Aesop.Tree.ExtractProof.0.Aesop.copyExprMVar
code: private partial def copyExprMVar (s : Meta.SavedState) (mvarId : MVarId) :
    MetaM Unit 
goal: Lean.MetaM Unit

full_name: _private.«.lake».packages.aesop.Aesop.Tree.ExtractProof.0.Aesop.visitGoal
code: private def visitGoal (parentEnv : Environment) (g : Goal) :
    MetaM (Option (MVarId × Array RappRef × Environment)) 
goal: Lean.MetaM (Option (Lean.MVarId × Array Aesop.RappRef × Lean.Environment))

full_name: _private.«.lake».packages.aesop.Aesop.Tree.ExtractProof.0.Aesop.visitRapp
code: private def visitRapp (parentEnv : Environment) (parentGoal : MVarId) (r : Rapp) :
    MetaM (Array MVarClusterRef × Environment) 
goal: Lean.MetaM (Array Aesop.MVarClusterRef × Lean.Environment)

full_name: _private.«.lake».packages.aesop.Aesop.Tree.ExtractProof.0.Aesop.SafePrefixState
code: private structure SafePrefixState where
  goals : Array MVarId := #[]
goal: Type

full_name: _private.«.lake».packages.aesop.Aesop.Tree.ExtractProof.0.Aesop.SafePrefixState.goals
code: private structure SafePrefixState where
  goals : Array MVarId := #[]
goal: Array Lean.MVarId

full_name: _private.«.lake».packages.aesop.Aesop.Tree.ExtractProof.0.Aesop.SafePrefixM
code: private abbrev SafePrefixM 
goal: Type

full_name: Aesop.Goal.extractProof
code: def Goal.extractProof (root : Goal) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Aesop.extractProof
code: def extractProof : TreeM Unit 
goal: Aesop.TreeM Unit

full_name: Aesop.Goal.extractSafePrefix
code: def Goal.extractSafePrefix (root : Goal) : MetaM (Array MVarId) 
goal: Lean.MetaM (Array Lean.MVarId)

full_name: Aesop.extractSafePrefix
code: def extractSafePrefix : TreeM (Array MVarId) 
goal: Aesop.TreeM (Array Lean.MVarId)
File: .lake/packages/aesop/Aesop/Tree/AddRapp.lean

full_name: Aesop.AddRapp.successProbability
code: structure AddRapp extends RuleApplication where
  parent : GoalRef
  appliedRule : RegularRule
  successProbability : Percent
goal: Aesop.Percent

full_name: Aesop.AddRapp
code: structure AddRapp extends RuleApplication where
  parent : GoalRef
  appliedRule : RegularRule
  successProbability : Percent
goal: Type

full_name: Aesop.AddRapp.appliedRule
code: structure AddRapp extends RuleApplication where
  parent : GoalRef
  appliedRule : RegularRule
  successProbability : Percent
goal: Aesop.RegularRule

full_name: Aesop.AddRapp.parent
code: structure AddRapp extends RuleApplication where
  parent : GoalRef
  appliedRule : RegularRule
  successProbability : Percent
goal: Aesop.GoalRef

full_name: _private.«.lake».packages.aesop.Aesop.Tree.AddRapp.0.Aesop.clusterGoals
code: private def clusterGoals (goals : Array Goal) : Array (Array Goal) 
goal: Array (Array Aesop.Goal)

full_name: _private.«.lake».packages.aesop.Aesop.Tree.AddRapp.0.Aesop.findPathForAssignedMVars
code: private def findPathForAssignedMVars (assignedMVars : UnorderedArraySet MVarId)
    (start : GoalRef) : TreeM (Array RappRef × HashSet GoalId) 
goal: Aesop.TreeM (Array Aesop.RappRef × Lean.HashSet Aesop.GoalId)

full_name: _private.«.lake».packages.aesop.Aesop.Tree.AddRapp.0.Aesop.getGoalsToCopy
code: private def getGoalsToCopy (assignedMVars : UnorderedArraySet MVarId)
    (start : GoalRef) : TreeM (Array GoalRef) 
goal: Aesop.TreeM (Array Aesop.GoalRef)

full_name: _private.«.lake».packages.aesop.Aesop.Tree.AddRapp.0.Aesop.copyGoals
code: private unsafe def copyGoals (assignedMVars : UnorderedArraySet MVarId)
    (start : GoalRef) (parentMetaState : Meta.SavedState)
    (parentSuccessProbability : Percent) (depth : Nat) :
    TreeM (Array Goal) 
goal: Aesop.TreeM (Array Aesop.Goal)

full_name: _private.«.lake».packages.aesop.Aesop.Tree.AddRapp.0.Aesop.makeInitialGoal
code: private def makeInitialGoal (goal : MVarId) (mvars : UnorderedArraySet MVarId)
    (parent : MVarClusterRef) (depth : Nat) (successProbability : Percent)
    (origin : GoalOrigin) : TreeM Goal 
goal: Aesop.TreeM Aesop.Goal

full_name: _private.«.lake».packages.aesop.Aesop.Tree.AddRapp.0.Aesop.addRappUnsafe
code: private unsafe def addRappUnsafe (r : AddRapp) : TreeM RappRef 
goal: Aesop.TreeM Aesop.RappRef

full_name: Aesop.addRapp
code: /--
Adds a new rapp and its subgoals. If the rapp assigns mvars, all relevant
goals containing these mvars are copied as children of the rapp as well. If
the rapp drops mvars, these are treated as assigned mvars, in the sense that
the same goals are copied as if the dropped mvar had been assigned.

Note that adding a rapp may prove the parent goal, but this function does not
make the necessary changes. So after calling it, you should check whether the
rapp's parent goal is proven and mark it accordingly.
-/
@[implemented_by addRappUnsafe]
opaque addRapp : AddRapp → TreeM RappRef
goal: Aesop.AddRapp → Aesop.TreeM Aesop.RappRef
File: .lake/packages/aesop/Aesop/BuiltinRules/ApplyHyps.lean

full_name: Aesop.BuiltinRules.applyHyp
code: def applyHyp (hyp : FVarId) (goal : MVarId) (md : TransparencyMode) :
    MetaM RuleApplication 
goal: Lean.MetaM Aesop.RuleApplication

full_name: Aesop.BuiltinRules.applyHyps
code: @[aesop unsafe 75% tactic (rule_sets := [builtin])]
def applyHyps : RuleTac 
goal: Aesop.RuleTac
File: .lake/packages/aesop/Aesop/BuiltinRules/Intros.lean

full_name: Aesop.BuiltinRules.intros
code: @[aesop norm -100 (rule_sets := [builtin])]
def intros : RuleTac 
goal: Aesop.RuleTac
File: .lake/packages/aesop/Aesop/BuiltinRules/Ext.lean

full_name: Aesop.BuiltinRules.extCore
code: def extCore (goal : MVarId) : ScriptM (Option (Array MVarId)) 
goal: Aesop.ScriptM (Option (Array Lean.MVarId))

full_name: Aesop.BuiltinRules.ext
code: @[aesop 80% tactic (index := [target _ = _]) (rule_sets := [builtin])]
def ext : RuleTac 
goal: Aesop.RuleTac
File: .lake/packages/aesop/Aesop/BuiltinRules/Assumption.lean

full_name: Aesop.BuiltinRules.assumption.tryHyp
code: @[aesop safe -50 (rule_sets := [builtin])]
def assumption : RuleTac 
goal: Lean.MetaM (Option (Aesop.RuleApplication × Bool))

full_name: Aesop.BuiltinRules.assumption
code: @[aesop safe -50 (rule_sets := [builtin])]
def assumption : RuleTac 
goal: Aesop.RuleTac
File: .lake/packages/aesop/Aesop/Script/UScript.lean

full_name: Aesop.Script.UScript
code: abbrev UScript 
goal: Type

full_name: Aesop.Script.UScript.render
code: def render (tacticState : TacticState) (s : UScript) :
    m (Array Syntax.Tactic) 
goal: m (Array Lean.Syntax.Tactic)

full_name: Aesop.Script.UScript.renderTacticSeq
code: def renderTacticSeq (uscript : UScript) (preState : Meta.SavedState)
    (goal : MVarId) : MetaM (TSyntax ``tacticSeq) 
goal: Lean.MetaM (Lean.TSyntax `Lean.Parser.Tactic.tacticSeq)

full_name: Aesop.Script.UScript.validate
code: def validate (s : UScript) : MetaM Unit 
goal: Lean.MetaM Unit
File: .lake/packages/aesop/Aesop/Script/Main.lean

full_name: Aesop.Script.UScript.optimize
code: def UScript.optimize (uscript : UScript)  (preState : Meta.SavedState)
    (goal : MVarId) : MetaM (Option (TSyntax ``tacticSeq × Bool)) 
goal: Lean.MetaM (Option (Lean.TSyntax `Lean.Parser.Tactic.tacticSeq × Bool))

full_name: Aesop.checkAndTraceScript
code: def checkAndTraceScript (uscript : UScript)
    (sscript? : Option (TSyntax ``tacticSeq)) (preState : Meta.SavedState)
    (goal : MVarId) (options : Aesop.Options') (expectCompleteProof : Bool)
    (tacticName : String) :
    MetaM Unit 
goal: Lean.MetaM Unit
File: .lake/packages/aesop/Aesop/Script/Tactic.lean

full_name: Aesop.Script.UTactic
code: abbrev UTactic 
goal: Type

full_name: Aesop.Script.STactic
code: structure STactic where
  numSubgoals : Nat
  run : Array (Array Syntax.Tactic) → Syntax.Tactic
goal: Type

full_name: Aesop.Script.STactic.numSubgoals
code: structure STactic where
  numSubgoals : Nat
  run : Array (Array Syntax.Tactic) → Syntax.Tactic
goal: Nat

full_name: Aesop.Script.STactic.run
code: structure STactic where
  numSubgoals : Nat
  run : Array (Array Syntax.Tactic) → Syntax.Tactic
goal: Array (Array Lean.Syntax.Tactic) → Lean.Syntax.Tactic

full_name: Aesop.Script.Tactic
code: structure Tactic where
  uTactic : UTactic
  sTactic? : Option STactic
goal: Type

full_name: Aesop.Script.Tactic.sTactic?
code: structure Tactic where
  uTactic : UTactic
  sTactic? : Option STactic
goal: Option Aesop.Script.STactic

full_name: Aesop.Script.Tactic.uTactic
code: structure Tactic where
  uTactic : UTactic
  sTactic? : Option STactic
goal: Aesop.Script.UTactic

full_name: Aesop.Script.Tactic.instToMessageData
code: instance : ToMessageData Tactic 
goal: Lean.ToMessageData Aesop.Script.Tactic

full_name: Aesop.Script.Tactic.unstructured
code: def unstructured (uTactic : UTactic) : Tactic 
goal: Aesop.Script.Tactic

full_name: Aesop.Script.Tactic.structured
code: def structured (uTactic : UTactic) (sTactic : STactic) : Tactic 
goal: Aesop.Script.Tactic

full_name: Aesop.Script.TacticBuilder
code: abbrev TacticBuilder 
goal: Type
File: .lake/packages/aesop/Aesop/Main.lean

full_name: Aesop.evalAesop
code: @[tactic Frontend.Parser.aesopTactic, tactic Frontend.Parser.aesopTactic?]
def evalAesop : Tactic 
goal: Lean.Elab.Tactic.Tactic
File: .lake/packages/aesop/Aesop/Script/SScript.lean

full_name: Aesop.Script.SScript
code: inductive SScript
  | empty
  | onGoal (goalPos : Nat) (step : Step) (tail : SScript)
  | focusAndSolve (goalPos : Nat) (here tail : SScript)
  deriving Inhabited
goal: Type

full_name: Aesop.Script.SScript.focusAndSolve
code: inductive SScript
  | empty
  | onGoal (goalPos : Nat) (step : Step) (tail : SScript)
  | focusAndSolve (goalPos : Nat) (here tail : SScript)
  deriving Inhabited
goal: Aesop.Script.SScript

full_name: Aesop.Script.instInhabitedSScript
code: inductive SScript
  | empty
  | onGoal (goalPos : Nat) (step : Step) (tail : SScript)
  | focusAndSolve (goalPos : Nat) (here tail : SScript)
  deriving Inhabited
goal: Inhabited Aesop.Script.SScript

full_name: Aesop.Script.SScript.empty
code: inductive SScript
  | empty
  | onGoal (goalPos : Nat) (step : Step) (tail : SScript)
  | focusAndSolve (goalPos : Nat) (here tail : SScript)
  deriving Inhabited
goal: Aesop.Script.SScript

full_name: Aesop.Script.SScript.onGoal
code: inductive SScript
  | empty
  | onGoal (goalPos : Nat) (step : Step) (tail : SScript)
  | focusAndSolve (goalPos : Nat) (here tail : SScript)
  deriving Inhabited
goal: Aesop.Script.SScript

full_name: Aesop.Script.SScript.takeNConsecutiveFocusAndSolve?
code: def takeNConsecutiveFocusAndSolve? (acc : Array SScript) :
    Nat → SScript → Option (Array SScript × SScript)
  
goal: Nat → Aesop.Script.SScript → Option (Array Aesop.Script.SScript × Aesop.Script.SScript)

full_name: Aesop.Script.SScript.render.go
code: partial def render (script : SScript) : m (Array Syntax.Tactic) 
goal: Aesop.Script.SScript → m (Array Lean.Syntax.Tactic)

full_name: Aesop.Script.SScript.render.renderSTactic?
code: partial def render (script : SScript) : m (Array Syntax.Tactic) 
goal: m (Option (Lean.Syntax.Tactic × Aesop.Script.SScript))

full_name: Aesop.Script.SScript.render
code: partial def render (script : SScript) : m (Array Syntax.Tactic) 
goal: m (Array Lean.Syntax.Tactic)
File: .lake/packages/aesop/Aesop/BuiltinRules/Split.lean

full_name: Aesop.BuiltinRules.splitTarget
code: @[aesop (rule_sets := [builtin]) safe 100]
def splitTarget : RuleTac 
goal: Aesop.RuleTac

full_name: Aesop.BuiltinRules.splitHypothesesCore
code: partial def splitHypothesesCore (goal : MVarId) :
    ScriptM (Option (Array MVarId)) 
goal: Aesop.ScriptM (Option (Array Lean.MVarId))

full_name: Aesop.BuiltinRules.splitHypotheses
code: @[aesop (rule_sets := [builtin]) safe 1000]
def splitHypotheses : RuleTac 
goal: Aesop.RuleTac
File: .lake/packages/aesop/Aesop/Script/Check.lean

full_name: Aesop.Script.UScript.checkIfEnabled
code: def UScript.checkIfEnabled (uscript : UScript) : MetaM Unit 
goal: Lean.MetaM Unit

full_name: Aesop.checkRenderedScriptIfEnabled
code: def checkRenderedScriptIfEnabled (script : TSyntax ``tacticSeq)
    (preState : Meta.SavedState) (goal : MVarId) (expectCompleteProof : Bool) :
    MetaM Unit 
goal: Lean.MetaM Unit
File: .lake/packages/aesop/Aesop/Script/StructureStatic.lean

full_name: Aesop.Script.StaticStructureM.State.perfect
code: structure State where
  perfect : Bool := true
goal: Bool

full_name: Aesop.Script.StaticStructureM.State
code: structure State where
  perfect : Bool := true
goal: Type

full_name: Aesop.Script.StaticStructureM.Context
code: structure Context where
  steps : HashMap MVarId (Nat × Step)
goal: Type

full_name: Aesop.Script.StaticStructureM.Context.steps
code: structure Context where
  steps : HashMap MVarId (Nat × Step)
goal: Lean.HashMap Lean.MVarId (Nat × Aesop.Script.Step)

full_name: Aesop.Script.StaticStructureM
code: abbrev StaticStructureM 
goal: Type

full_name: Aesop.Script.StaticStructureM.run
code: protected def StaticStructureM.run (script : UScript) (x : StaticStructureM α) :
    CoreM (α × Bool) 
goal: Lean.CoreM (α × Bool)

full_name: Aesop.Script.structureStaticCore
code: partial def structureStaticCore (tacticState : TacticState) (script : UScript) :
    CoreM (UScript × Bool) 
goal: Lean.CoreM (Aesop.Script.UScript × Bool)

full_name: Aesop.Script.structureStaticCore.nextStep
code: partial def structureStaticCore (tacticState : TacticState) (script : UScript) :
    CoreM (UScript × Bool) 
goal: Aesop.Script.StaticStructureM Aesop.Script.Step

full_name: Aesop.Script.structureStaticCore.go
code: partial def structureStaticCore (tacticState : TacticState) (script : UScript) :
    CoreM (UScript × Bool) 
goal: Aesop.Script.StaticStructureM (List Aesop.Script.Step × Aesop.Script.TacticState)

full_name: Aesop.Script.UScript.toSScriptStatic
code: def UScript.toSScriptStatic (tacticState : TacticState) (uscript : UScript) :
    CoreM (SScript × Bool) 
goal: Lean.CoreM (Aesop.Script.SScript × Bool)
File: .lake/packages/aesop/Aesop/Script/Util.lean

full_name: Aesop.Script.findFirstStep?
code: @[specialize]
def findFirstStep? {α β : Type} (goals : Array α) (step? : α → Option β)
     (stepOrder : β → Nat) : Option (Nat × α × β) 
goal: Option (Nat × α × β)

full_name: Aesop.Script.matchGoals
code: def matchGoals (postState₁ postState₂ : Meta.SavedState)
    (goals₁ goals₂ : Array MVarId) : MetaM (Option (HashMap MVarId MVarId)) 
goal: Lean.MetaM (Option (Lean.HashMap Lean.MVarId Lean.MVarId))

full_name: Aesop.Script.matchGoals.getProperGoals
code: def matchGoals (postState₁ postState₂ : Meta.SavedState)
    (goals₁ goals₂ : Array MVarId) : MetaM (Option (HashMap MVarId MVarId)) 
goal: Lean.MetaM (Array Lean.MVarId)
File: .lake/packages/aesop/Aesop/BuiltinRules/Subst.lean

full_name: Aesop.BuiltinRules.SubstitutableEq
code: structure SubstitutableEq where
  fvarId : FVarId
  symm : Bool
goal: Type

full_name: Aesop.BuiltinRules.SubstitutableEq.symm
code: structure SubstitutableEq where
  fvarId : FVarId
  symm : Bool
goal: Bool

full_name: Aesop.BuiltinRules.SubstitutableEq.fvarId
code: structure SubstitutableEq where
  fvarId : FVarId
  symm : Bool
goal: Lean.FVarId

full_name: Aesop.BuiltinRules.SubstitutableHyp.eq
code: inductive SubstitutableHyp
  | eq (h : SubstitutableEq)
  | iff (fvarId : FVarId) (eqProof eqType : Expr) (symm : Bool)
goal: Aesop.BuiltinRules.SubstitutableHyp

full_name: Aesop.BuiltinRules.SubstitutableHyp
code: inductive SubstitutableHyp
  | eq (h : SubstitutableEq)
  | iff (fvarId : FVarId) (eqProof eqType : Expr) (symm : Bool)
goal: Type

full_name: Aesop.BuiltinRules.SubstitutableHyp.iff
code: inductive SubstitutableHyp
  | eq (h : SubstitutableEq)
  | iff (fvarId : FVarId) (eqProof eqType : Expr) (symm : Bool)
goal: Aesop.BuiltinRules.SubstitutableHyp

full_name: Aesop.BuiltinRules.getSubstitutableHyp
code: def getSubstitutableHyp (fvarId : FVarId) : MetaM (Option SubstitutableHyp) 
goal: Lean.MetaM (Option Aesop.BuiltinRules.SubstitutableHyp)

full_name: Aesop.BuiltinRules.getSubstitutableEqs
code: def getSubstitutableEqs (goal : MVarId) (fvarIds : Array FVarId) :
    ScriptM (MVarId × Array SubstitutableEq) 
goal: Aesop.ScriptM (Lean.MVarId × Array Aesop.BuiltinRules.SubstitutableEq)

full_name: Aesop.BuiltinRules.substFVars
code: def substFVars (goal : MVarId) (fvarIds : Array FVarId) :
    ScriptM (Option MVarId) 
goal: Aesop.ScriptM (Option Lean.MVarId)

full_name: Aesop.BuiltinRules.subst
code: @[aesop (rule_sets := [builtin]) norm -50 tactic (index := [hyp _ = _, hyp _ ↔ _])]
def subst : RuleTac 
goal: Aesop.RuleTac
File: .lake/packages/aesop/Aesop/Script/GoalWithMVars.lean

full_name: Aesop.GoalWithMVars.mvars
code: structure GoalWithMVars where
  goal : MVarId
  mvars : HashSet MVarId
  deriving Inhabited
goal: Lean.HashSet Lean.MVarId

full_name: Aesop.GoalWithMVars
code: structure GoalWithMVars where
  goal : MVarId
  mvars : HashSet MVarId
  deriving Inhabited
goal: Type

full_name: Aesop.GoalWithMVars.goal
code: structure GoalWithMVars where
  goal : MVarId
  mvars : HashSet MVarId
  deriving Inhabited
goal: Lean.MVarId

full_name: Aesop.instInhabitedGoalWithMVars
code: structure GoalWithMVars where
  goal : MVarId
  mvars : HashSet MVarId
  deriving Inhabited
goal: Inhabited Aesop.GoalWithMVars

full_name: Aesop.instReprGoalWithMVars
code: instance : Repr GoalWithMVars 
goal: Repr Aesop.GoalWithMVars

full_name: Aesop.instBEqGoalWithMVars
code: instance : BEq GoalWithMVars 
goal: BEq Aesop.GoalWithMVars

full_name: Aesop.GoalWithMVars.ofMVarId
code: def ofMVarId (goal : MVarId) : MetaM GoalWithMVars 
goal: Lean.MetaM Aesop.GoalWithMVars